def _build_element(self):
def value_func(node, extras):
return str(extras["text"])
return Compound("test <text>",
extras=[Dictation(name="text").apply(self.f)],
value_func=value_func)
def test_dictation_non_ascii(self):
""" Test handling of non-ASCII characters in dictation. """
def value_func(node, extras):
return extras["text"]
element = Compound("test <text>",
extras=[Dictation(name="text")],
value_func=value_func)
tester = ElementTester(element)
words = [u"test", u"touché"]
engine = get_engine()
uppercase_dictation_required = engine.name in ['sphinx', 'text']
if uppercase_dictation_required:
words[1] = words[1].upper()
dictation = tester.recognize(words)
# Verify recognition returned dictation result.
if not isinstance(dictation, DictationContainerBase):
encoding = locale.getpreferredencoding()
message = (u"Expected recognition result to be a dictation"
u" container, but received %r" % (repr(dictation), ))
self.fail(message.encode(encoding))
# Verifying dictation converts/encode successfully.
string = "touché"
if isinstance(string, binary_type):
encoding = locale.getpreferredencoding()
string = string.decode("windows-1252").encode(encoding)
self.assertEqual(str(dictation), string)
self.assertEqual(text_type(dictation), u"touché")
self.assertTrue(isinstance(repr(dictation), string_types))
def _build_element(self):
def value_func(node, extras):
return str(extras["text"])
return Compound(
"test <text>",
extras=[Dictation(name="text").upper().replace(" ", "/")],
value_func=value_func)
def reset(self, mapping):
grammar = self._grammar # save reference because Grammar.remove_rule nullifies it
ccr = self._merger is not None
if grammar is not None and not ccr:
grammar.unload()
grammar.remove_rule(self)
extras = self.extras if self.extras else [IntegerRefST("n", 1, 50), Dictation("s")]
defaults = self.defaults if self.defaults else { "n": 1 }
MergeRule.__init__(self, self.name, mapping, extras, defaults, self.exported,
self.context)
if ccr: self._merger.merge(MergeInf.SELFMOD)
if grammar is not None and not ccr:
grammar.add_rule(self)
grammar.load()
def test_dictation_non_ascii(self):
""" Test handling of non-ASCII characters in dictation. """
def value_func(node, extras):
return extras["text"]
element = Compound("test <text>",
extras=[Dictation(name="text")],
value_func=value_func)
tester = ElementTester(element)
words = [u"test", u"TOUCHÉ"]
dictation = tester.recognize(words)
# Verify recognition returned dictation result.
if not isinstance(dictation, DictationContainerBase):
message = (u"Expected recognition result to be a dictation"
u" container, but received %r" %
(repr(dictation).decode("utf-8"), ))
self.fail(message.encode("utf-8"))
# Verifying dictation converts/encode successfully.
self.assertEqual(str(dictation), "touché")
self.assertEqual(text_type(dictation), u"touché")
self.assertTrue(isinstance(repr(dictation), string_types))
def __init__(self, config_path, name=None):
"""
SelfModifyingRule is a kind of rule which gets its command set changed
on-the-fly based on some kind of user interaction. Child classes
must implement their own version of the _refresh and
_deserialize methods.
:param name: str
"""
self._reload_shim = None
self._hooks_runner = None
default_smr_mapping = {"spec which gets replaced": NullAction()}
self._smr_mapping = default_smr_mapping
# extras and defaults may not get replaced:
self._smr_extras = [IntegerRefST("n", 1, 50), Dictation("s")]
self._smr_defaults = {"n": 1, "s": ""}
self._config = SelfModStateSavingConfig(config_path)
self._config.load()
self._deserialize()
MergeRule.__init__(self, name, self._smr_mapping, self._smr_extras,
self._smr_defaults)
def test_copy(self):
""" Test that Dictation elements can be copied. """
element = Dictation("text")
self.assertIsNot(element, copy.copy(element))
element = Dictation("text").camel()
self.assertIsNot(element, copy.copy(element))
class TestRule(MappingRule):
mapping = {
"hello <dictation>": Function(test1),
"<dictation> testing": Function(test2),
}
extras = [Dictation("dictation")]
class TestRule(MappingRule):
mapping = {"<dictation>": Function(test)}
extras = [Dictation("dictation")]
class TestRule(MappingRule):
mapping = {
"say <dictation>": Function(test1),
"hello world": Function(test2),
}
extras = [Dictation("dictation")]
def test_recognition_observer(self):
"""
Test that the engine's recognition observer manager works correctly.
"""
on_begin_test = self.get_test_function()
on_recognition_test = self.get_test_function()
on_failure_test = self.get_test_function()
on_next_rule_part_test = self.get_test_function()
# Set up a custom observer using test methods
class TestObserver(RecognitionObserver):
on_begin = on_begin_test
on_next_rule_part = on_next_rule_part_test
on_recognition = on_recognition_test
on_failure = on_failure_test
# Set up a TestObserver instance and a grammar with multiple rules to use
observer = TestObserver()
observer.register()
grammar = Grammar("test")
grammar.add_rule(CompoundRule("rule1", "hello world"))
grammar.add_rule(
CompoundRule("rule2",
"say <dictation>",
extras=[Dictation("dictation")]))
grammar.load()
self.assertTrue(grammar.loaded)
# Test that each method is called properly
self.assert_mimic_success("hello world")
# on_begin is called during each mimic. on_recognition should be called
# once per successful and complete recognition. Both on_failure and
# on_next_rule_part shouldn't have been called yet.
self.assert_test_function_called(on_begin_test, 1)
self.assert_test_function_called(on_recognition_test, 1)
self.assert_test_function_called(on_failure_test, 0)
self.assert_test_function_called(on_next_rule_part_test, 0)
# Test with a dictation rule
self.assert_mimic_success("say")
# Recognition begins again, is incomplete and no failure yet.
self.assert_test_function_called(on_begin_test, 2)
self.assert_test_function_called(on_recognition_test, 1)
self.assert_test_function_called(on_failure_test, 0)
# on_next_rule_part should be called because there are more rule parts
self.assert_test_function_called(on_next_rule_part_test, 1)
# Test the next part of the dictation rule
self.assert_mimic_success("testing testing")
# Recognition begins again, is complete, and no failure yet.
self.assert_test_function_called(on_begin_test, 3)
self.assert_test_function_called(on_recognition_test, 2)
self.assert_test_function_called(on_failure_test, 0)
# on_next_rule_part shouldn't have been called because this is the last part
# and on_recognition will be called instead
self.assert_test_function_called(on_next_rule_part_test, 1)
# Recognition begins again and failure occurs.
self.assert_mimic_failure("testing")
self.assert_test_function_called(on_begin_test, 4)
self.assert_test_function_called(on_next_rule_part_test,
1) # no change
self.assert_test_function_called(on_failure_test, 1)
self.assert_test_function_called(on_recognition_test, 2)
# Test that using None or "" also calls the on_failure method
self.assert_mimic_failure(None)
self.assert_test_function_called(on_failure_test, 2)
self.assert_mimic_failure("")
self.assert_test_function_called(on_failure_test, 3)
self.assert_test_function_called(on_next_rule_part_test,
1) # no change
# Unregister the observer
observer.unregister()