#!/usr/bin/env python
# encoding: utf-8
'''
auditok.auditok -- Audio Activity Detection tool
auditok.auditok is a program that can be used for Audio/Acoustic activity detection.
It can read audio data from audio files as well as from built-in device(s) or standard input
@author: Mohamed El Amine SEHILI
@copyright: 2015 Mohamed El Amine SEHILI
@license: GPL v3
@contact: amine.sehili@gmail.com
@deffield updated: 02 Dec 2015
'''
import sys
import os
from optparse import OptionParser, OptionGroup
from threading import Thread
import tempfile
import wave
import time
import threading
import logging
try:
import future
from queue import Queue, Empty
except ImportError:
if sys.version_info >= (3, 0):
from queue import Queue, Empty
else:
from Queue import Queue, Empty
try:
from pydub import AudioSegment
WITH_PYDUB = True
except ImportError:
WITH_PYDUB = False
from .core import StreamTokenizer
from .io import PyAudioSource, BufferAudioSource, StdinAudioSource, player_for
from .util import ADSFactory, AudioEnergyValidator
from auditok import __version__ as version
__all__ = []
__version__ = version
__date__ = '2015-11-23'
__updated__ = '2015-03-11'
DEBUG = 0
TESTRUN = 1
PROFILE = 0
LOGGER_NAME = "AUDITOK_LOGGER"
class AudioFileFormatError(Exception):
pass
class TimeFormatError(Exception):
pass
def file_to_audio_source(filename, filetype=None, **kwargs):
lower_fname = filename.lower()
rawdata = False
if filetype is not None:
filetype = filetype.lower()
if filetype == "raw" or (filetype is None and lower_fname.endswith(".raw")):
srate = kwargs.pop("sampling_rate", None)
if srate is None:
srate = kwargs.pop("sr", None)
swidth = kwargs.pop("sample_width", None)
if swidth is None:
swidth = kwargs.pop("sw", None)
ch = kwargs.pop("channels", None)
if ch is None:
ch = kwargs.pop("ch", None)
if None in (swidth, srate, ch):
raise Exception("All audio parameters are required for raw data")
data = open(filename).read()
rawdata = True
# try first with pydub
if WITH_PYDUB:
use_channel = kwargs.pop("use_channel", None)
if use_channel is None:
use_channel = kwargs.pop("uc", None)
if use_channel is None:
use_channel = 1
else:
try:
use_channel = int(use_channel)
except ValueError:
pass
if not isinstance(use_channel, (int)) and not use_channel.lower() in ["left", "right", "mix"] :
raise ValueError("channel must be an integer or one of 'left', 'right' or 'mix'")
asegment = None
if rawdata:
asegment = AudioSegment(data, sample_width=swidth, frame_rate=srate, channels=ch)
if filetype in("wave", "wav") or (filetype is None and lower_fname.endswith(".wav")):
asegment = AudioSegment.from_wav(filename)
elif filetype == "mp3" or (filetype is None and lower_fname.endswith(".mp3")):
asegment = AudioSegment.from_mp3(filename)
elif filetype == "ogg" or (filetype is None and lower_fname.endswith(".ogg")):
asegment = AudioSegment.from_ogg(filename)
elif filetype == "flv" or (filetype is None and lower_fname.endswith(".flv")):
asegment = AudioSegment.from_flv(filename)
else:
asegment = AudioSegment.from_file(filename)
if asegment.channels > 1:
if isinstance(use_channel, int):
if use_channel > asegment.channels:
raise ValueError("Can not use channel '{0}', audio file has only {1} channels".format(use_channel, asegment.channels))
else:
asegment = asegment.split_to_mono()[use_channel - 1]
else:
ch_lower = use_channel.lower()
if ch_lower == "mix":
asegment = asegment.set_channels(1)
elif use_channel.lower() == "left":
asegment = asegment.split_to_mono()[0]
elif use_channel.lower() == "right":
asegment = asegment.split_to_mono()[1]
return BufferAudioSource(data_buffer = asegment._data,
sampling_rate = asegment.frame_rate,
sample_width = asegment.sample_width,
channels = asegment.channels)
# fall back to standard python
else:
if rawdata:
if ch != 1:
raise ValueError("Cannot handle multi-channel audio without pydub")
return BufferAudioSource(data, srate, swidth, ch)
if filetype in ("wav", "wave") or (filetype is None and lower_fname.endswith(".wav")):
wfp = wave.open(filename)
ch = wfp.getnchannels()
if ch != 1:
wfp.close()
raise ValueError("Cannot handle multi-channel audio without pydub")
srate = wfp.getframerate()
swidth = wfp.getsampwidth()
data = wfp.readframes(wfp.getnframes())
wfp.close()
return BufferAudioSource(data, srate, swidth, ch)
raise AudioFileFormatError("Cannot read audio file format")
def save_audio_data(data, filename, filetype=None, **kwargs):
lower_fname = filename.lower()
if filetype is not None:
filetype = filetype.lower()
# save raw data
if filetype == "raw" or (filetype is None and lower_fname.endswith(".raw")):
fp = open(filename, "w")
fp.write(data)
fp.close()
return
# save other types of data
# requires all audio parameters
srate = kwargs.pop("sampling_rate", None)
if srate is None:
srate = kwargs.pop("sr", None)
swidth = kwargs.pop("sample_width", None)
if swidth is None:
swidth = kwargs.pop("sw", None)
ch = kwargs.pop("channels", None)
if ch is None:
ch = kwargs.pop("ch", None)
if None in (swidth, srate, ch):
raise Exception("All audio parameters are required to save no raw data")
if filetype in ("wav", "wave") or (filetype is None and lower_fname.endswith(".wav")):
# use standard python's wave module
fp = wave.open(filename, "w")
fp.setnchannels(ch)
fp.setsampwidth(swidth)
fp.setframerate(srate)
fp.writeframes(data)
fp.close()
elif WITH_PYDUB:
asegment = AudioSegment(data, sample_width=swidth, frame_rate=srate, channels=ch)
asegment.export(filename, format=filetype)
else:
raise AudioFileFormatError("cannot write file format {0} (file name: {1})".format(filetype, filename))
def plot_all(signal, sampling_rate, energy_as_amp, detections=[], show=True, save_as=None):
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0., np.ceil(float(len(signal))) / sampling_rate, 1./sampling_rate )
if len(t) > len(signal):
t = t[: len(signal) - len(t)]
for start, end in detections:
p = plt.axvspan(start, end, facecolor='g', ec = 'r', lw = 2, alpha=0.4)
line = plt.axhline(y=energy_as_amp, lw=1, ls="--", c="r", label="Energy threshold as normalized amplitude")
plt.plot(t, signal)
legend = plt.legend(["Detection threshold"], bbox_to_anchor=(0., 1.02, 1., .102), loc=1, fontsize=16)
ax = plt.gca().add_artist(legend)
plt.xlabel("Time (s)", fontsize=24)
plt.ylabel("Amplitude (normalized)", fontsize=24)
if save_as is not None:
plt.savefig(save_as, dpi=120)
if show:
plt.show()
def seconds_to_str_fromatter(_format):
"""
Accepted format directives: %i %s %m %h
"""
# check directives are correct
if _format == "%S":
def _fromatter(seconds):
return "{:.2f}".format(seconds)
elif _format == "%I":
def _fromatter(seconds):
return "{0}".format(int(seconds * 1000))
else:
_format = _format.replace("%h", "{hrs:02d}")
_format = _format.replace("%m", "{mins:02d}")
_format = _format.replace("%s", "{secs:02d}")
_format = _format.replace("%i", "{millis:03d}")
try:
i = _format.index("%")
raise TimeFormatError("Unknow time format directive '{0}'".format(_format[i:i+2]))
except ValueError:
pass
def _fromatter(seconds):
millis = int(seconds * 1000)
hrs, millis = divmod(millis, 3600000)
mins, millis = divmod(millis, 60000)
secs, millis = divmod(millis, 1000)
return _format.format(hrs=hrs, mins=mins, secs=secs, millis=millis)
return _fromatter
class Worker(Thread):
def __init__(self, timeout=0.2, debug=False, logger=None):
self.timeout = timeout
self.debug = debug
self.logger = logger
if self.debug and self.logger is None:
self.logger = logging.getLogger(LOGGER_NAME)
self.logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
self.logger.addHandler(handler)
self._inbox = Queue()
self._stop_request = Queue()
Thread.__init__(self)
def debug_message(self, message):
self.logger.debug(message)
def _stop_requested(self):
try:
message = self._stop_request.get_nowait()
if message == "stop":
return True
except Empty:
return False
def stop(self):
self._stop_request.put("stop")
self.join()
def send(self, message):
self._inbox.put(message)
def _get_message(self):
try:
message = self._inbox.get(timeout=self.timeout)
return message
except Empty:
return None
class TokenizerWorker(Worker):
END_OF_PROCESSING = "END_OF_PROCESSING"
def __init__(self, ads, tokenizer, analysis_window, observers):
self.ads = ads
self.tokenizer = tokenizer
self.analysis_window = analysis_window
self.observers = observers
self._inbox = Queue()
self.count = 0
Worker.__init__(self)
def run(self):
def notify_observers(data, start, end):
audio_data = b''.join(data)
self.count += 1
start_time = start * self.analysis_window
end_time = (end+1) * self.analysis_window
duration = (end - start + 1) * self.analysis_window
# notify observers
for observer in self.observers:
observer.notify({"id" : self.count,
"audio_data" : audio_data,
"start" : start,
"end" : end,
"start_time" : start_time,
"end_time" : end_time,
"duration" : duration}
)
self.ads.open()
self.tokenizer.tokenize(data_source=self, callback=notify_observers)
for observer in self.observers:
observer.notify(TokenizerWorker.END_OF_PROCESSING)
def add_observer(self, observer):
self.observers.append(observer)
def remove_observer(self, observer):
self.observers.remove(observer)
def read(self):
if self._stop_requested():
return None
else:
return self.ads.read()
class PlayerWorker(Worker):
def __init__(self, player, timeout=0.2, debug=False, logger=None):
self.player = player
Worker.__init__(self, timeout=timeout, debug=debug, logger=logger)
def run(self):
while True:
if self._stop_requested():
break
message = self._get_message()
if message is not None:
if message == TokenizerWorker.END_OF_PROCESSING:
break
audio_data = message.pop("audio_data", None)
start_time = message.pop("start_time", None)
end_time = message.pop("end_time", None)
dur = message.pop("duration", None)
_id = message.pop("id", None)
if audio_data is not None:
if self.debug:
self.debug_message("[PLAY]: Detection {id} played (start:{start}, end:{end}, dur:{dur})".format(id=_id,
start="{:5.2f}".format(start_time), end="{:5.2f}".format(end_time), dur="{:5.2f}".format(dur)))
self.player.play(audio_data)
def notify(self, message):
self.send(message)
class CommandLineWorker(Worker):
def __init__(self, command, timeout=0.2, debug=False, logger=None):
self.command = command
Worker.__init__(self, timeout=timeout, debug=debug, logger=logger)
def run(self):
while True:
if self._stop_requested():
break
message = self._get_message()
if message is not None:
if message == TokenizerWorker.END_OF_PROCESSING:
break
audio_data = message.pop("audio_data", None)
_id = message.pop("id", None)
if audio_data is not None:
raw_audio_file = tempfile.NamedTemporaryFile(delete=False)
raw_audio_file.write(audio_data)
cmd = self.command.replace("$", raw_audio_file.name)
if self.debug:
self.debug_message("[CMD ]: Detection {id} command: {cmd}".format(id=_id, cmd=cmd))
os.system(cmd)
os.unlink(raw_audio_file.name)
def notify(self, message):
self.send(message)
class TokenSaverWorker(Worker):
def __init__(self, name_format, filetype, timeout=0.2, debug=False, logger=None, **kwargs):
self.name_format = name_format
self.filetype = filetype
self.kwargs = kwargs
Worker.__init__(self, timeout=timeout, debug=debug, logger=logger)
def run(self):
while True:
if self._stop_requested():
break
message = self._get_message()
if message is not None:
if message == TokenizerWorker.END_OF_PROCESSING:
break
audio_data = message.pop("audio_data", None)
start_time = message.pop("start_time", None)
end_time = message.pop("end_time", None)
_id = message.pop("id", None)
if audio_data is not None and len(audio_data) > 0:
fname = self.name_format.format(N=_id, start = "{:.2f}".format(start_time), end = "{:.2f}".format(end_time))
try:
if self.debug:
self.debug_message("[SAVE]: Detection {id} saved as {fname}".format(id=_id, fname=fname))
save_audio_data(audio_data, fname, filetype=self.filetype, **self.kwargs)
except Exception as e:
sys.stderr.write(str(e) + "\n")
def notify(self, message):
self.send(message)
class LogWorker(Worker):
def __init__(self, print_detections=False, output_format="{start} {end}",
time_formatter=seconds_to_str_fromatter("%S"), timeout=0.2, debug=False, logger=None):
self.print_detections = print_detections
self.output_format = output_format
self.time_formatter = time_formatter
self.detections = []
Worker.__init__(self, timeout=timeout, debug=debug, logger=logger)
def run(self):
while True:
if self._stop_requested():
break
message = self._get_message()
if message is not None:
if message == TokenizerWorker.END_OF_PROCESSING:
break
audio_data = message.pop("audio_data", None)
_id = message.pop("id", None)
start = message.pop("start", None)
end = message.pop("end", None)
start_time = message.pop("start_time", None)
end_time = message.pop("end_time", None)
if audio_data is not None and len(audio_data) > 0:
if self.debug:
self.debug_message("[DET ]: Detection {id} (start:{start}, end:{end})".format(id=_id,
start="{:5.2f}".format(start_time),
end="{:5.2f}".format(end_time)))
if self.print_detections:
print(self.output_format.format(id = _id,
start = self.time_formatter(start_time),
end = self.time_formatter(end_time)))
self.detections.append((_id, start, end, start_time, end_time))
def notify(self, message):
self.send(message)
def main(argv=None):
'''Command line options.'''
program_name = os.path.basename(sys.argv[0])
program_version = version
program_build_date = "%s" % __updated__
program_version_string = '%%prog %s (%s)' % (program_version, program_build_date)
#program_usage = '''usage: spam two eggs''' # optional - will be autogenerated by optparse
program_longdesc = '''''' # optional - give further explanation about what the program does
program_license = "Copyright 2015 Mohamed El Amine SEHILI \
Licensed under the General Public License (GPL) Version 3 \nhttp://www.gnu.org/licenses/"
if argv is None:
argv = sys.argv[1:]
try:
# setup option parser
parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license)
group = OptionGroup(parser, "[Input-Output options]")
group.add_option("-i", "--input", dest="input", help="Input audio or video file. Use - for stdin [default: read from microphone using pyaudio]", metavar="FILE")
group.add_option("-t", "--input-type", dest="input_type", help="Input audio file type. Mandatory if file name has no extension [default: %default]", type=str, default=None, metavar="String")
group.add_option("-M", "--max_time", dest="max_time", help="Max data (in seconds) to read from microphone/file [default: read until the end of file/stream]", type=float, default=None, metavar="FLOAT")
group.add_option("-O", "--output-main", dest="output_main", help="Save main stream as. If omitted main stream will not be saved [default: omitted]", type=str, default=None, metavar="FILE")
group.add_option("-o", "--output-tokens", dest="output_tokens", help="Output file name format for detections. Use {N} and {start} and {end} to build file names, example: 'Det_{N}_{start}-{end}.wav'", type=str, default=None, metavar="STRING")
group.add_option("-T", "--output-type", dest="output_type", help="Audio type used to save detections and/or main stream. If not supplied will: (1). guess from extension or (2). use wav format", type=str, default=None, metavar="STRING")
group.add_option("-u", "--use-channel", dest="use_channel", help="Choose channel to use from a multi-channel audio file (requires pydub). 'left', 'right' and 'mix' are accepted values. [Default: 1 (i.e. 1st or left channel)]", type=str, default="1", metavar="STRING")
parser.add_option_group(group)
group = OptionGroup(parser, "[Tokenization options]", "Set tokenizer options and energy threshold.")
group.add_option("-a", "--analysis-window", dest="analysis_window", help="Size of analysis window in seconds [default: %default (10ms)]", type=float, default=0.01, metavar="FLOAT")
group.add_option("-n", "--min-duration", dest="min_duration", help="Min duration of a valid audio event in seconds [default: %default]", type=float, default=0.2, metavar="FLOAT")
group.add_option("-m", "--max-duration", dest="max_duration", help="Max duration of a valid audio event in seconds [default: %default]", type=float, default=5, metavar="FLOAT")
group.add_option("-s", "--max-silence", dest="max_silence", help="Max duration of a consecutive silence within a valid audio event in seconds [default: %default]", type=float, default=0.3, metavar="FLOAT")
group.add_option("-d", "--drop-trailing-silence", dest="drop_trailing_silence", help="Drop trailing silence from a detection [default: keep trailing silence]", action="store_true", default=False)
group.add_option("-e", "--energy-threshold", dest="energy_threshold", help="Log energy threshold for detection [default: %default]", type=float, default=50, metavar="FLOAT")
parser.add_option_group(group)
group = OptionGroup(parser, "[Audio parameters]", "Define audio parameters if data is read from a headerless file (raw or stdin) or you want to use different microphone parameters.")
group.add_option("-r", "--rate", dest="sampling_rate", help="Sampling rate of audio data [default: %default]", type=int, default=16000, metavar="INT")
group.add_option("-c", "--channels", dest="channels", help="Number of channels of audio data [default: %default]", type=int, default=1, metavar="INT")
group.add_option("-w", "--width", dest="sample_width", help="Number of bytes per audio sample [default: %default]", type=int, default=2, metavar="INT")
parser.add_option_group(group)
group = OptionGroup(parser, "[Do something with detections]", "Use these options to print, play or plot detections.")
group.add_option("-C", "--command", dest="command", help="Command to call when an audio detection occurs. Use $ to represent the file name to use with the command (e.g. -C 'du -h $')", default=None, type=str, metavar="STRING")
group.add_option("-E", "--echo", dest="echo", help="Play back each detection immediately using pyaudio [default: do not play]", action="store_true", default=False)
group.add_option("-p", "--plot", dest="plot", help="Plot and show audio signal and detections (requires matplotlib)", action="store_true", default=False)
group.add_option("", "--save-image", dest="save_image", help="Save plotted audio signal and detections as a picture or a PDF file (requires matplotlib)", type=str, default=None, metavar="FILE")
group.add_option("", "--printf", dest="printf", help="print detections one per line using a user supplied format (e.g. '[{id}]: {start} -- {end}'). Available keywords {id}, {start} and {end}", type=str, default="{id} {start} {end}", metavar="STRING")
group.add_option("", "--time-format", dest="time_format", help="format used to print {start} and {end}. [Default= %default]. %S: absolute time in sec. %I: absolute time in ms. If at least one of (%h, %m, %s, %i) is used, convert time into hours, minutes, seconds and millis (e.g. %h:%m:%s.%i). Only required fields are printed", type=str, default="%S", metavar="STRING")
parser.add_option_group(group)
parser.add_option("-q", "--quiet", dest="quiet", help="Do not print any information about detections [default: print 'id', 'start' and 'end' of each detection]", action="store_true", default=False)
parser.add_option("-D", "--debug", dest="debug", help="Print processing operations to STDOUT", action="store_true", default=False)
parser.add_option("", "--debug-file", dest="debug_file", help="Print processing operations to FILE", type=str, default=None, metavar="FILE")
# process options
(opts, args) = parser.parse_args(argv)
if opts.input == "-":
asource = StdinAudioSource(sampling_rate = opts.sampling_rate,
sample_width = opts.sample_width,
channels = opts.channels)
#read data from a file
elif opts.input is not None:
asource = file_to_audio_source(filename=opts.input, filetype=opts.input_type, uc=opts.use_channel)
# read data from microphone via pyaudio
else:
try:
asource = PyAudioSource(sampling_rate = opts.sampling_rate,
sample_width = opts.sample_width,
channels = opts.channels)
except Exception:
sys.stderr.write("Cannot read data from audio device!\n")
sys.stderr.write("You should either install pyaudio or read data from STDIN\n")
sys.exit(2)
logger = logging.getLogger(LOGGER_NAME)
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
if opts.quiet or not opts.debug:
# only critical messages will be printed
handler.setLevel(logging.CRITICAL)
else:
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
if opts.debug_file is not None:
logger.setLevel(logging.DEBUG)
opts.debug = True
handler = logging.FileHandler(opts.debug_file, "w")
fmt = logging.Formatter('[%(asctime)s] | %(message)s')
handler.setFormatter(fmt)
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
record = opts.output_main is not None or opts.plot or opts.save_image is not None
ads = ADSFactory.ads(audio_source = asource, block_dur = opts.analysis_window, max_time = opts.max_time, record = record)
validator = AudioEnergyValidator(sample_width=asource.get_sample_width(), energy_threshold=opts.energy_threshold)
if opts.drop_trailing_silence:
mode = StreamTokenizer.DROP_TRAILING_SILENCE
else:
mode = 0
analysis_window_per_second = 1. / opts.analysis_window
tokenizer = StreamTokenizer(validator=validator, min_length=opts.min_duration * analysis_window_per_second,
max_length=int(opts.max_duration * analysis_window_per_second),
max_continuous_silence=opts.max_silence * analysis_window_per_second,
mode = mode)
observers = []
tokenizer_worker = None
if opts.output_tokens is not None:
try:
# check user format is correct
fname = opts.output_tokens.format(N=0, start=0, end=0)
# find file type for detections
tok_type = opts.output_type
if tok_type is None:
tok_type = os.path.splitext(opts.output_tokens)[1][1:]
if tok_type == "":
tok_type = "wav"
token_saver = TokenSaverWorker(name_format=opts.output_tokens, filetype=tok_type,
debug=opts.debug, logger=logger, sr=asource.get_sampling_rate(),
sw=asource.get_sample_width(),
ch=asource.get_channels())
observers.append(token_saver)
except Exception:
sys.stderr.write("Wrong format for detections file name: '{0}'\n".format(opts.output_tokens))
sys.exit(2)
if opts.echo:
try:
player = player_for(asource)
player_worker = PlayerWorker(player=player, debug=opts.debug, logger=logger)
observers.append(player_worker)
except Exception:
sys.stderr.write("Cannot get an audio player!\n")
sys.stderr.write("You should either install pyaudio or supply a command (-C option) to play audio\n")
sys.exit(2)
if opts.command is not None and len(opts.command) > 0:
cmd_worker = CommandLineWorker(command=opts.command, debug=opts.debug, logger=logger)
observers.append(cmd_worker)
if not opts.quiet or opts.plot is not None or opts.save_image is not None:
oformat = opts.printf.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r")
converter = seconds_to_str_fromatter(opts.time_format)
log_worker = LogWorker(print_detections = not opts.quiet, output_format=oformat,
time_formatter=converter, logger=logger, debug=opts.debug)
observers.append(log_worker)
tokenizer_worker = TokenizerWorker(ads, tokenizer, opts.analysis_window, observers)
def _save_main_stream():
# find file type
main_type = opts.output_type
if main_type is None:
main_type = os.path.splitext(opts.output_main)[1][1:]
if main_type == "":
main_type = "wav"
ads.close()
ads.rewind()
data = ads.get_audio_source().get_data_buffer()
if len(data) > 0:
save_audio_data(data=data, filename=opts.output_main, filetype=main_type, sr=asource.get_sampling_rate(),
sw = asource.get_sample_width(),
ch = asource.get_channels())
def _plot():
import numpy as np
ads.close()
ads.rewind()
data = ads.get_audio_source().get_data_buffer()
signal = AudioEnergyValidator._convert(data, asource.get_sample_width())
detections = [(det[3] , det[4]) for det in log_worker.detections]
max_amplitude = 2**(asource.get_sample_width() * 8 - 1) - 1
energy_as_amp = np.sqrt(np.exp(opts.energy_threshold * np.log(10) / 10)) / max_amplitude
plot_all(signal / max_amplitude, asource.get_sampling_rate(), energy_as_amp, detections, show = opts.plot, save_as = opts.save_image)
# start observer threads
for obs in observers:
obs.start()
# start tokenization thread
tokenizer_worker.start()
while True:
time.sleep(1)
if len(threading.enumerate()) == 1:
break
tokenizer_worker = None
if opts.output_main is not None:
_save_main_stream()
if opts.plot or opts.save_image is not None:
_plot()
return 0
except KeyboardInterrupt:
if tokenizer_worker is not None:
tokenizer_worker.stop()
for obs in observers:
obs.stop()
if opts.output_main is not None:
_save_main_stream()
if opts.plot or opts.save_image is not None:
_plot()
return 0
except Exception as e:
sys.stderr.write(program_name + ": " + str(e) + "\n")
sys.stderr.write("for help use -h\n")
return 2
if __name__ == "__main__":
if DEBUG:
sys.argv.append("-h")
if TESTRUN:
import doctest
doctest.testmod()
if PROFILE:
import cProfile
import pstats
profile_filename = 'auditok.auditok_profile.txt'
cProfile.run('main()', profile_filename)
statsfile = open("profile_stats.txt", "wb")
p = pstats.Stats(profile_filename, stream=statsfile)
stats = p.strip_dirs().sort_stats('cumulative')
stats.print_stats()
statsfile.close()
sys.exit(0)
sys.exit(main())