def sleep(force=False):
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
get_engine().process_grammars_context()
notify('sleep')
def wake(force=False):
get_engine().start_saving_adaptation_state()
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
notify('wake')
def setupFinalDflyGrammar(self):
log.info("Setting up final grammar.")
assert not self.dflyGrammar
self.dflyGrammar = Grammar(self.fullName + "Grammar")
if self.finalDflyRule:
self.dflyGrammar.add_rule(self.finalDflyRule)
for r in self.independentRules:
self.dflyGrammar.add_rule(self.concreteRules[r])
loadStart = time.time()
self.dflyGrammar.load()
loadEnd = time.time()
log.info("Grammar load time: %ss" % (loadEnd - loadStart))
get_engine().set_exclusiveness(self.dflyGrammar, 1)
# These should never be recognized on their own, only as part of the
# master rule, quirk of dragonfly that you have to do this even though
# they're only pulled in by ruleref.
for r in self.seriesRules:
self.concreteRules[r].disable()
if self.terminatorRule:
self.concreteRules[self.terminatorRule].disable()
# independent rules only enabled via being a dependency need to have disable
# called on their dragonfly version so that they don't get recognized by
# themselves, same quirk.
notEnabledRules = self.dependencyRuleSet - self.baseRuleSet
for r in notEnabledRules:
self.concreteRules[r].disable()
# they're enabled by default, don't activate until explicitly made to
self.dflyGrammar.disable()
def __init__(self):
# Natlink doesn't provide a way to poll files or sockets,
# and it runs in the same thread as Dragon itself so we can't
# block, so we run on a periodic timer.
DragonflyNode.__init__(self)
self.timer = get_engine().create_timer(self._eventLoop, 1)
self.buf = ""
# rule cache, stores types:
# hash -> HashedRule
# hash of component rule hashes -> MasterGrammar
# hash of unloaded rule -> NeedDependency
self.hashedRules = {}
self.activatedRules = set() # set of HashRules
self.activeMasterGrammar = None
self.lastMicState = None
self.lastLoadState = None
self.recognitionState = "success"
# hashes we've asked for but haven't got a reply for yet
self.requestedLoads = set()
self.globalRule = GlobalRules(name="GlobalRules")
self.globalRuleGrammar = FailureReportingGrammar(self.globalRule.name)
self.globalRuleGrammar.setClient(self)
self.globalRuleGrammar.add_rule(self.globalRule)
self.globalRuleGrammar.load()
get_engine().set_exclusiveness(self.globalRuleGrammar, 1)
self.wordLists = {}
def run_pytest_suite(engine_name, pytest_options):
# Get test file paths.
paths = []
for name in engine_tests_dict[engine_name]:
if name.startswith("test_"):
# Use full module paths so pytest can import the files
# correctly.
name = "dragonfly/test/" + name + ".py"
paths.append(name)
# Initialize the engine and call connect().
engine = get_engine(engine_name)
engine.connect()
# Prevent the engine from running timers on its own. This lets us
# avoid race conditions.
engine._timer_manager.disable()
try:
# Run doctests through pytest.main() now that the engine is set up.
# Pass any specified pytest options, followed by doctest options for
# compatibility with both Python 2.7 and 3.
args = pytest_options + [
'-o', 'doctest_optionflags=ALLOW_UNICODE IGNORE_EXCEPTION_DETAIL'
] + paths
return pytest.main(args)
finally:
# Disconnect after the tests.
engine.disconnect()
# Check that the dragonfly engine was not changed during the tests.
assert engine is get_engine(), \
"The registered engine changed during the test suite."
def __init__(self):
# Natlink doesn't provide a way to poll files or sockets,
# and it runs in the same thread as Dragon itself so we can't
# block, so we run on a periodic timer.
DragonflyNode.__init__(self)
self.timer = get_engine().create_timer(self._eventLoop, 1)
self.buf = ""
# rule cache, stores types:
# hash -> HashedRule
# hash of component rule hashes -> MasterGrammar
# hash of unloaded rule -> NeedDependency
self.hashedRules = {}
self.activatedRules = set() # set of HashRules
self.activeMasterGrammar = None
self.lastMicState = None
self.lastLoadState = None
self.recognitionState = "success"
# hashes we've asked for but haven't got a reply for yet
self.requestedLoads = set()
self.globalRule = GlobalRules(name="GlobalRules")
self.globalRuleGrammar = FailureReportingGrammar(self.globalRule.name)
self.globalRuleGrammar.setClient(self)
self.globalRuleGrammar.add_rule(self.globalRule)
self.globalRuleGrammar.load()
get_engine().set_exclusiveness(self.globalRuleGrammar, 1)
self.wordLists = {}
def drop_keep_clipboard(nnavi500, capitalization, spacing):
# Maintain standard spark functionality for non-strings
if capitalization == 0 and spacing == 0 and nnavi500 == 1:
Key("c-v").execute()
return
# Get clipboard text
if nnavi500 > 1:
key = str(nnavi500)
if key in _CLIP:
text = _CLIP[key]
else:
get_engine().speak("slot empty")
text = None
else:
text = Clipboard.get_system_text()
# Format if necessary, and paste
if text is not None:
cb = Clipboard(from_system=True)
if capitalization != 0 or spacing != 0:
text = textformat.TextFormat.formatted_text(
capitalization, spacing, text)
Clipboard.set_system_text(text)
time.sleep(settings.settings([u'miscellaneous', u'keypress_wait'])/1000.)
Key("c-v").execute()
time.sleep(settings.settings([u'miscellaneous', u'keypress_wait'])/1000.)
# Restore the clipboard contents.
cb.copy_to_system()
def drop_keep_clipboard(nnavi500, nexus, capitalization, spacing):
# Maintain standard spark functionality for non-strings
if capitalization == 0 and spacing == 0 and nnavi500 == 1:
Key("c-v").execute()
return
# Get clipboard text
if nnavi500 > 1:
key = str(nnavi500)
if key in nexus.clip:
text = nexus.clip[key]
else:
dragonfly.get_engine().speak("slot empty")
text = None
else:
text = Clipboard.get_system_text()
# Format if necessary, and paste
if text is not None:
cb = Clipboard(from_system=True)
if capitalization != 0 or spacing != 0:
text = textformat.TextFormat.formatted_text(capitalization, spacing, text)
Clipboard.set_system_text(text)
time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"]/1000.)
Key("c-v").execute()
time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"]/1000.)
# Restore the clipboard contents.
cb.copy_to_system()
def sleep(force=False):
get_engine().stop_saving_adaptation_state()
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
notify('sleep')
def setupFinalDflyGrammar(self):
log.info("Setting up final grammar.")
assert not self.dflyGrammar
self.dflyGrammar = Grammar(self.fullName + "Grammar")
if self.finalDflyRule:
self.dflyGrammar.add_rule(self.finalDflyRule)
for r in self.independentRules:
self.dflyGrammar.add_rule(self.concreteRules[r])
loadStart = time.time()
self.dflyGrammar.load()
loadEnd = time.time()
log.info("Grammar load time: %ss" % (loadEnd - loadStart))
get_engine().set_exclusiveness(self.dflyGrammar, 1)
# These should never be recognized on their own, only as part of the
# master rule, quirk of dragonfly that you have to do this even though
# they're only pulled in by ruleref.
for r in self.seriesRules:
self.concreteRules[r].disable()
if self.terminatorRule:
self.concreteRules[self.terminatorRule].disable()
# independent rules only enabled via being a dependency need to have disable
# called on their dragonfly version so that they don't get recognized by
# themselves, same quirk.
notEnabledRules = self.dependencyRuleSet - self.baseRuleSet
for r in notEnabledRules:
self.concreteRules[r].disable()
# they're enabled by default, don't activate until explicitly made to
self.dflyGrammar.disable()
def wake(force=False):
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
get_engine().process_grammars_context()
notify('wake')
def report(message, speak=False, console=True, log=False):
import dragonfly
if console:
print message
if speak:
dragonfly.get_engine().speak(message)
if log:
settings.report_to_file(message)
class SleepRule(MappingRule):
mapping = {
"rise from your grave":
Function(wake) +
Function(lambda: get_engine().start_saving_adaptation_state()),
"quiet you":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
}
def main(args):
logging.basicConfig(level=logging.INFO)
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "kaldi_module_loader_plus.py")
os.environ.setdefault("GOOGLE_APPLICATION_CREDENTIALS", "gcloud.json")
# Set any configuration options here as keyword arguments.
engine = get_engine(
"kaldi",
model_dir='kaldi_model_zamia',
# tmp_dir='kaldi_tmp', # default for temporary directory
# vad_aggressiveness=3, # default aggressiveness of VAD
# vad_padding_ms=300,
#vad_padding_start_ms=300, # default ms of required silence before VAD
#vad_padding_end_ms=300, # default ms of required silence after VAD
#vad_complex_padding_end_ms=1000, # default ms of required silence after VAD for complex utterances
# input_device_index=None, # set to an int to choose a non-default microphone
auto_add_to_user_lexicon=
True, # set to True to possibly use cloud for pronunciations
cloud_dictation_lang="en-US", # set to 'gcloud' to use cloud dictation
)
if len(args) >= 1 and args[0] == "-l":
# Show the list of attached microphone devices.
# Note that this code should only be called after the engine has been initialized above with configuration options,
# otherwise if this line of code happens before the engine is created, get_engine will create the engine with default arguments.
get_engine("kaldi").print_mic_list()
# Call connect() now that the engine configuration is set.
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
load_sleep_wake_grammar(True)
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Start the engine's main recognition loop
try:
# Loop forever
print("Listening...")
engine.do_recognition()
except KeyboardInterrupt:
pass
def main():
logging.basicConfig(level=logging.INFO)
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "kaldi_module_loader_plus.py")
if 'devices' in sys.argv:
print('microphones:', get_engine('kaldi').print_mic_list())
exit(0)
# Set any configuration options here as keyword arguments.
if 'test' in sys.argv:
engine = get_engine('text')
else:
engine = get_engine(
"kaldi",
model_dir='kaldi_model',
# tmp_dir='kaldi_model_zamia.tmp', # default for temporary directory
# vad_aggressiveness=3, # default aggressiveness of VAD
# vad_padding_start_ms=300, # default ms of required silence before VAD
vad_padding_end_ms=500, # default ms of required silence after VAD
# vad_complex_padding_end_ms=500, # default ms of required silence after VAD for complex utterances
audio_input_device='Blue',
# auto_add_to_user_lexicon=True, # set to True to possibly use cloud for pronunciations
# lazy_compilation=True, # set to True to parallelize & speed up loading
# cloud_dictation=None, # set to 'gcloud' to use cloud dictation
)
# Call connect() now that the engine configuration is set.
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
load_sleep_wake_grammar(True)
# load_noise_grammar()
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Start the engine's main recognition loop
if 'test' not in sys.argv:
engine.prepare_for_recognition()
try:
# Loop forever
print("Listening...")
engine.do_recognition()
except KeyboardInterrupt:
pass
class SleepRule(MappingRule):
mapping = {
"listen to me":
Function(wake) +
Function(lambda: get_engine().start_saving_adaptation_state()),
"(go to sleep)|(stop listening)":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
# "halt listening": Function(lambda: get_engine().stop_saving_adaptation_state()) + Function(sleep),
}
class SleepRule(MappingRule):
mapping = {
'dragonfly exit':
Function(halt),
"start listening":
Function(wake) +
Function(lambda: get_engine().start_saving_adaptation_state()),
"stop listening":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
"halt listening":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
}
def __init__(self):
self.mode = "normal"
self.frequency = 5
self.command_titles = ["sublime", "jupyter", "rstudio", "mingw64", "lyx", "scientific notebook"]
self.command_executables = ["code.exe", "kindle.exe"]
self.command_contexts = AppContext(title=self.command_titles) | AppContext(self.command_executables)
self.timer = get_engine().create_timer(self.check_context, self.frequency)
def main():
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "dfly-loader-natlink.py")
engine = get_engine("natlink")
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Recognize from Dragon in a loop (opens a dialogue window).
engine.natlink.waitForSpeech()
# Unload all grammars from the engine so that Dragon doesn't keep
# recognizing them.
for grammar in engine.grammars:
grammar.unload()
# Disconnect after the dialogue is closed.
engine.disconnect()
def main():
desc = "Example script for using the " \
"'SphinxEngine.process_wave_file' method"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("file", type=argparse.FileType("r"),
help="A .wav file.")
args = parser.parse_args()
file_path = args.file.name
args.file.close()
# Set up the engine.
# process_wave() handles START_ASLEEP = True (default), but a warning
# message will be logged. We can suppress that here.
engine = get_engine("sphinx")
engine.config.START_ASLEEP = False
# Voice activity detection config values may need to be adjusted to
# recognise speech. Do this by changing the decoder's config.
# Note that these values represent a number of audio frames, not time
# intervals.
# For example:
engine.config.DECODER_CONFIG.set_int("-vad_postspeech", 30)
# Process the wave file and print any results.
# Note: process_wave_file() is a generator function.
engine.connect()
had_result = False
for result in engine.process_wave_file(file_path):
print(result)
had_result = True
# Exit with 1 if there were no results.
if not had_result:
exit(1)
def disconnect():
print("Disconnecting engine.")
engine = get_engine()
if engine.name == 'natlink' and 'natspeak' in sys.executable:
print("Not calling disconnect() for embedded natlink.")
else:
engine.disconnect()
def main():
logging.basicConfig(level=logging.INFO)
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "wsr_module_loader_plus.py")
# Set any configuration options here as keyword arguments.
engine = get_engine("sapi5inproc")
# Call connect() now that the engine configuration is set.
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
load_sleep_wake_grammar(True)
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Start the engine's main recognition loop
try:
# Recognize from WSR in a loop.
print("Listening...")
engine.recognize_forever()
except KeyboardInterrupt:
pass
def _init_engine(args):
# Retrieve the engine option pairs from the arguments.
# TODO Remove multiple engine options per -o arg in version 1.0.0.
options = {}
for argument in args.engine_options:
for options_list in argument:
for option, value in options_list:
options[option] = value
try:
# Initialize the specified engine with options, catching and
# reporting errors.
engine = get_engine(args.engine, **options)
except EngineError as e:
LOG.error(e)
engine = None
# Set the engine language if necessary.
if engine and args.language != engine.language:
try:
engine.language = args.language
except AttributeError:
LOG.error("Cannot set language for engine %r", engine.name)
engine = None
return engine
def disconnect():
# You shouldn't really run this module in other engines because it uses
# sphinx-specific engine methods.
print("Disconnecting engine (only for sphinx)")
engine = get_engine()
if engine.name == "sphinx":
engine.disconnect()
def drop(nnavi500, nexus):
key = str(nnavi500)
while True:
failure = False
try:
if key in nexus.clip:
Clipboard.set_system_text(nexus.clip[key])
Key("c-v").execute()
else:
dragonfly.get_engine().speak("slot empty")
time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] /
1000.)
except Exception:
failure = True
if not failure:
break
def run(self, result):
self.engine = dragonfly.get_engine(self.engine_name)
self.engine.connect()
try:
return unittest.TestSuite.run(self, result)
finally:
self.engine.disconnect()
def add_vocab():
engine = dragonfly.get_engine()
if engine.name != "natlink":
utilities.report(
"feature unavailable in your speech recognition engine",
speak=True)
return
# attempts to get what was highlighted first
highlighted = context.read_selected_without_altering_clipboard(True)
# change the following regex to accept alphabetical only
disallow = "^[A-Za-z]*$"
selected = None
if highlighted[0] == 0 and highlighted[1] != "":
if not re.match(disallow, highlighted[1]):
utilities.report("only used for single words", speak=True)
return
selected = highlighted[1]
try:
h_launch.launch(settings.QTYPE_SET, process_set, selected)
except Exception:
utilities.simple_log(False)
def main():
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "dfly-loader-wsr.py")
# Initialize and connect the engine.
# Set any configuration options here as keyword arguments.
engine = get_engine("sapi5inproc")
engine.connect()
# Load grammars.
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Define recognition callback functions.
def on_begin():
print("Speech start detected.")
def on_recognition(words):
print("Recognized: %s" % " ".join(words))
def on_failure():
print("Sorry, what was that?")
# Recognize from WSR in a loop.
try:
engine.do_recognition(on_begin, on_recognition, on_failure)
except KeyboardInterrupt:
pass
def clear_log():
# Function to clear status window.
# Natlink status window not used an out-of-process mode.
# ToDo: window_exists utilized when engine launched through Dragonfly CLI via bat in future
try:
if sys.platform.startswith('win'):
clearcmd = "cls" # Windows OS
else:
clearcmd = "clear" # Linux
if get_engine()._name == 'natlink':
import natlinkstatus # pylint: disable=import-error
status = natlinkstatus.NatlinkStatus()
if status.NatlinkIsEnabled() == 1:
import win32gui # pylint: disable=import-error
handle = get_window_by_title(
"Messages from Python Macros") or get_window_by_title(
"Messages from Natlink")
rt_handle = win32gui.FindWindowEx(handle, None, "RICHEDIT",
None)
win32gui.SetWindowText(rt_handle, "")
else:
if window_exists(windowname="Caster: Status Window"):
os.system(clearcmd)
else:
if window_exists(windowname="Caster: Status Window"):
os.system(clearcmd)
else:
printer.out("clear_log: Not implemented with GUI")
except Exception as e:
printer.out(e)
def run(self, result):
engine = dragonfly.get_engine(self.engine_name)
engine.connect()
try:
return unittest.TestSuite.run(self, result)
finally:
engine.disconnect()
def main():
desc = "Example script for using the " \
"'SphinxEngine.process_wave_file' method"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("file",
type=argparse.FileType("r"),
help="A .wav file.")
args = parser.parse_args()
file_path = args.file.name
args.file.close()
# Set up the engine.
# process_wave() handles START_ASLEEP = True (default), but a warning
# message will be logged. We can suppress that here.
engine = get_engine("sphinx")
engine.config.START_ASLEEP = False
# Voice activity detection config values may need to be adjusted to
# recognise speech. Do this by changing the decoder's config.
# Note that these values represent a number of audio frames, not time
# intervals.
# For example:
engine.config.DECODER_CONFIG.set_int("-vad_postspeech", 30)
# Process the wave file and print any results.
# Note: process_wave_file() is a generator function.
engine.connect()
had_result = False
for result in engine.process_wave_file(file_path):
print(result)
had_result = True
# Exit with 1 if there were no results.
if not had_result:
exit(1)
def main():
logging.basicConfig(level=logging.INFO)
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "dfly-loader-wsr.py")
engine = get_engine("sapi5inproc")
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
engine.speak('beginning loop!')
while 1:
pythoncom.PumpWaitingMessages()
time.sleep(.1)
def setup_show_spectrum():
global timer
audio = Audio()
recognizer = lambda spectrogram: plot_spectrum(processor.freqs,
spectrogram[-1])
processor = Processor(audio, recognizer, length_s=1)
timer = get_engine().create_timer(make_timer_func(audio, processor), 0.02)
def main():
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "sphinx_module_loader.py")
# Initialize the engine.
engine = get_engine("sphinx")
# Try to import the local engine configuration object first. If there isn't one,
# use the default engine configuration.
log = logging.getLogger("config")
try:
import config
engine.config = config
log.info("Using local engine configuration module 'config.py'")
except ImportError:
pass
except Exception as e:
# Log errors caught when setting the configuration.
log.exception("Failed to set config using 'config.py': %s" % e)
log.warning("Falling back to the default engine configuration")
# You can also set any configuration options here instead of using a
# config.py file. For example:
# engine.config.START_ASLEEP = False
# Call connect() now that the engine configuration is set.
engine.connect()
# Load grammars.
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Define recognition callback functions.
def on_begin():
print("Speech start detected.")
def on_recognition(words):
message = u"Recognized: %s" % u" ".join(words)
# This only seems to be an issue with Python 2.7 on Windows.
if six.PY2:
encoding = sys.stdout.encoding or "ascii"
message = message.encode(encoding, errors='replace')
print(message)
def on_failure():
print("Sorry, what was that?")
# Start the engine's main recognition loop
try:
engine.do_recognition(on_begin, on_recognition, on_failure)
except KeyboardInterrupt:
pass
def test_with_engine(args):
# Initialise the specified engine, catching and reporting errors.
try:
engine = get_engine(args.engine)
_log.debug("Testing with engine '%s'" % args.engine)
except Exception as e:
_log.error(e)
return 1
# Set the logging level of the root logger.
if args.quiet:
args.log_level = "WARNING"
logging.root.setLevel(getattr(logging, args.log_level))
# Set the engine language if necessary.
if engine.name == "text":
engine.language = args.language
# Connect to the engine, load grammar modules, take input from stdin and
# disconnect from the engine if interrupted or if EOF is received.
with engine.connection():
# Load each module. Errors during loading will be caught and logged.
# Use the overall success of module loading and/or mimic calls as
# the return code.
return_code = 0
for f in args.files:
module_ = CommandModule(f.name)
module_.load()
if not module_.loaded:
return_code = 1
# Also close each file object created by argparse.
f.close()
# Read lines from stdin and pass them to engine.mimic. Strip excess
# white space from each line. Report any mimic failures.
if args.no_input:
# Return early if --no-input was specified.
return return_code
_log.info("Enter commands to mimic followed by new lines.")
try:
# Use iter to avoid a bug in Python 2.x:
# https://bugs.python.org/issue3907
for line in iter(sys.stdin.readline, ''):
line = line.strip()
if not line: # skip empty lines.
continue
try:
engine.mimic(line.split())
_log.info("Mimic success for words: %s" % line)
except MimicFailure:
_log.error("Mimic failure for words: %s" % line)
return_code = 1
except KeyboardInterrupt:
pass
return return_code
def main():
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "sphinx_module_loader.py")
# Initialize the engine.
engine = get_engine("sphinx")
# Try to import the local engine configuration object first. If there isn't one,
# use the default engine configuration.
log = logging.getLogger("config")
try:
import config
engine.config = config
log.info("Using local engine configuration module 'config.py'")
except ImportError:
pass
except Exception as e:
# Log errors caught when setting the configuration.
log.exception("Failed to set config using 'config.py': %s" % e)
log.warning("Falling back to the default engine configuration")
# You can also set any configuration options here instead of using a
# config.py file. For example:
engine.config.START_ASLEEP = False
engine.config.DECODER_CONFIG.set_float("-vad_threshold", 3.1)
engine.config.LANGUAGE = LANGUAGE
# Call connect() now that the engine configuration is set.
engine.connect()
# Load grammars.
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
class Observer(RecognitionObserver):
def on_begin(self):
print("=> Speech start detected.")
def on_recognition(self, words):
message = u"Recognized: %s" % u" ".join(words)
print("=>", message)
def on_failure(self):
print("=> Sorry, what was that?")
observer = Observer()
observer.register()
# Start the engine's main recognition loop
try:
engine.recognise_forever()
except KeyboardInterrupt:
pass
def _send_request(self, request_function):
# Send requests to the server using new threads to emulate requests
# from a different process.
request_thread = threading.Thread(target=request_function)
request_thread.start()
# Manually process server requests by calling the timer manager's
# main callback directly.
while request_thread.is_alive():
get_engine()._timer_manager.main_callback()
time.sleep(0.05)
# Handle errors and results from the request.
if isinstance(self.current_response, Exception):
raise self.current_response
else:
return self.current_response
def _send_request(self, request_function):
# Send requests to the server using new threads to emulate requests
# from a different process.
request_thread = threading.Thread(target=request_function)
request_thread.start()
# Manually process server requests by calling the timer manager's
# main callback directly.
while request_thread.isAlive():
get_engine()._timer_manager.main_callback()
time.sleep(0.05)
# Handle errors and results from the request.
if isinstance(self.current_response, Exception):
raise self.current_response
else:
return self.current_response
def drop(nnavi500):
key = str(nnavi500)
while True:
failure = False
try:
if key in control.nexus().clip:
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardText(control.nexus().clip[key])
win32clipboard.CloseClipboard()
Key("c-v").execute()
else:
dragonfly.get_engine().speak("slot empty")
time.sleep(0.05)
except Exception:
failure = True
if not failure:
break
def drop(nnavi500, nexus):
key = str(nnavi500)
while True:
failure = False
try:
if key in nexus.clip:
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardText(nexus.clip[key])
win32clipboard.CloseClipboard()
Key("c-v").execute()
else:
dragonfly.get_engine().speak("slot empty")
time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"]/1000.)
except Exception:
failure = True
if not failure:
break
def _connect_engine(self):
engine_name = self._resolve_engine_name(self.engine)
try:
log.info("Importing Dragonfly library.")
import dragonfly
log.info("Locating SR engine {0}."
"".format(engine_name or "(automatic selection)"))
self._engine = dragonfly.get_engine(engine_name)
log.info("Connecting to SR engine {0}.".format(self._engine))
self._engine.connect()
except Exception, e:
log.exception("Error during Dragonfly setup: {0}".format(e))
raise
def main():
try:
path = os.path.dirname(__file__)
except NameError:
# The "__file__" name is not always available, for example
# when this module is run from PythonWin. In this case we
# simply use the current working directory.
path = os.getcwd()
__file__ = os.path.join(path, "sphinx_module_loader.py")
engine = get_engine("sphinx")
# Try to import the local engine configuration object first. If there isn't one,
# use the default engine configuration.
log = logging.getLogger("config")
try:
import config
engine.config = config
log.info("Using local engine configuration module 'config.py'")
except ImportError:
pass
except Exception as e:
# Log errors caught when setting the configuration.
log.exception("Failed to set config using 'config.py': %s" % e)
log.warning("Falling back to the default engine configuration")
# You can also set any configuration options here instead of using a
# config.py file. For example:
# engine.config.START_ASLEEP = False
# Call connect() now that the engine configuration is set.
engine.connect()
# Register a recognition observer
observer = Observer()
observer.register()
directory = CommandModuleDirectory(path, excludes=[__file__])
directory.load()
# Start the engine's main recognition loop
try:
engine.recognise_forever()
except KeyboardInterrupt:
pass
def setUpClass(cls):
cls.current_response = None
# Start the server on a different port for the tests and esure the
# engine is connected.
cls.server = RPCServer(port=50052)
engine = get_engine()
engine.connect()
cls.server.start()
# If the engine's timer manager is a ThreadedTimerManager, disable
# the main callback to prevent race conditions.
timer_manager = engine._timer_manager
if isinstance(timer_manager, ThreadedTimerManager):
cls.threaded_timer_manager = timer_manager
timer_manager.disable()
else:
cls.threaded_timer_manager = None
def collectValues(self, node, values=None):
if values is None:
values = {}
refTypes = (dfly.Repetition, dfly.RuleRef)
isRefType = any([isinstance(node.actor, t) for t in refTypes])
if node.name and isinstance(node.actor, ElementBase) and not isRefType:
v = node.value()
w = node.words()
if isinstance(v, get_engine().DictationContainer):
# The value vs. words distinction is to help with things
# like numbers where the value is 3 but the words are "three".
# For dictated text there is no distinction.
v = w
# elif isinstance(v, ActionBase):
# # When we have rule refs to other mapping rules, the value ends up
# # being the looked up action, which is not what we want. We want to
# # know which phrse was triggered.
# v = v._action.grammarString
log.info("extra [%s] value [%s] words [%s] realWords [%s]" % (node.name, v, w, node.words()))
self.addValue(values, node.name, v)
if node.name and isRefType:
repValues = {}
for n in node.children:
self.collectValues(n, repValues)
log.info("node.name [%s] repValues [%s]" % (node.name, repValues))
repValues.update({ 'words' : node.words() })
self.addValue(values, node.name, repValues)
#values.update({ node.name : repValues })
else:
for n in node.children:
self.collectValues(n, values)
return values
def add_vocab():
engine=dragonfly.get_engine()
if engine.name!="natlink":
utilities.report("feature unavailable in your speech recognition engine", speak=True)
return
# attempts to get what was highlighted first
highlighted=context.read_selected_without_altering_clipboard(True)
# change the following regex to accept alphabetical only
disallow="^[A-Za-z]*$"
selected=None
if highlighted[0]==0 and highlighted[1]!="":
if not re.match(disallow, highlighted[1]):
utilities.report("only used for single words", speak=True)
return
selected=highlighted[1]
try:
h_launch.launch(settings.QTYPE_SET, process_set, selected)
except Exception:
utilities.simple_log(False)
def setUp(self):
engine = get_engine("text")
assert isinstance(engine, EngineBase)
assert engine.name == "text"
engine.connect()
self.engine = engine
def tearDownClass(cls):
# Check that the dragonfly engine was not changed during the tests.
assert cls.engine is dragonfly.get_engine()
def write_transcripts():
engine = get_engine()
if engine.name == "sphinx":
engine.write_transcript_files(
"training.fileids", "training.transcription"
)
"""
Dragonfly command module designed for use with the CMU Pocket Sphinx engine,
either with the module loader or as a script.
Shows use of dragonfly Functions, Lists, Repetition, Dictation, IntegerRefs,
Mimic, etc.
"""
from dragonfly import (Dictation, Function, Grammar, IntegerRef, List,
ListRef, MappingRule, RecognitionObserver, Mimic,
Repetition, get_engine, Text)
if __name__ == '__main__':
# If this file is being run, not imported, then use the sphinx engine.
sphinx_engine = get_engine("sphinx")
def disconnect():
# You shouldn't really run this module in other engines because it uses
# sphinx-specific engine methods.
print("Disconnecting engine (only for sphinx)")
engine = get_engine()
if engine.name == "sphinx":
engine.disconnect()
def print_(x):
print(x)
def tearDownClass(cls):
cls.server.stop()
get_engine().disconnect()
# Re-enable the timer manager's callback if necessary.
if cls.threaded_timer_manager:
cls.threaded_timer_manager.enable()
# Set the grammar as exclusive.
# The sapi5shared engine apparently requires this for mimic() to
# work, making the method kind of useless. This does not apply to
# sapi5inproc.
g.set_exclusiveness(True)
response = self.send_request("mimic", ["testing mimicry"])
try:
self.assertIn("result", response)
self.assertEqual(response["result"], True)
finally:
g.set_exclusiveness(False)
g.unload()
def test_speak(self):
response = self.send_request("speak", ["testing speak"])
self.assertIn("result", response)
self.assertEqual(response["result"], None)
def test_get_engine_language(self):
""" Verify that the 'speak' RPC method works correctly. """
response = self.send_request("get_engine_language", [])
self.assertIn("result", response)
self.assertEqual(response["result"], "en")
if __name__ == '__main__':
# Use the "text" engine by default.
get_engine("text")
unittest.main()
