def __init__(self, factor, spec, multiplier, remainder, name=None): self._factor = factor self._mul = multiplier self._rem = remainder Compound.__init__(self, spec, extras=[multiplier, remainder], name=name)
def build_element(self, min, max): elements = [(spec, value) for spec, value in self._mapping.iteritems() if min <= value < max] if len(elements) > 1: children = [ Compound(spec=spec, value=value) for spec, value in elements ] return Alternative(children) elif len(elements) == 1: return Compound(spec=elements[0][0], value=elements[0][1]) else: return None
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").apply(self.f)], value_func=value_func)
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)
class Year(Alternative): alts = [ IntegerRef("year", 2000, 2100), Compound( spec="<century> <year>", extras=[Integer("century", 20, 21), IntegerRef("year", 10, 100)], value_func=lambda n, e: e["century"] * 100 + e["year"]), Compound( spec="<century> <year>", extras=[Integer("century", 19, 20), IntegerRef("year", 1, 100)], value_func=lambda n, e: e["century"] * 100 + e["year"]), ] def __init__(self, name): Alternative.__init__(self, name=name, children=self.alts)
def __init__(self, name=None, mapping=None, extras=None, defaults=None, exported=None, context=None): # pylint: disable=too-many-branches if name is None: name = self.__class__.__name__ if mapping is None: mapping = self.mapping if extras is None: extras = self.extras if defaults is None: defaults = self.defaults if context is None: context = self.context # Complex handling of exported, because of clashing use of the # exported name at the class level: property & class-value. if exported is not None: pass elif (hasattr(self.__class__, "exported") and not isinstance(self.__class__.exported, property)): exported = self.__class__.exported else: exported = self._default_exported # Type checking of initialization values. assert isinstance(name, string_types) assert isinstance(mapping, dict) for key, value in mapping.items(): assert isinstance(key, string_types) assert isinstance(extras, (list, tuple)) for item in extras: assert isinstance(item, ElementBase) assert exported in (True, False) self._name = name self._mapping = mapping self._extras = {element.name: element for element in extras} self._defaults = defaults children = [] for spec, value in self._mapping.items(): c = Compound(spec, elements=self._extras, value=value) children.append(c) if children: element = Alternative(children) else: element = None Rule.__init__(self, self._name, element, exported=exported, context=context)
def __init__(self, name=None, min=1, max=12, as_int=False): self._as_int = as_int if self._as_int: self._base = len(self._digits) - 1 pairs = [] for value, word in enumerate(self._digits): if isinstance(word, str): pairs.append((word, value)) elif isinstance(word, (tuple, list)): pairs.extend([(w, value) for w in word]) else: raise ValueError("Invalid type in digit list: %r" % word) alternatives = [Compound(w, value=v, name=self._digit_name) for w, v in pairs] child = Alternative(alternatives) Repetition.__init__(self, child, min, max, name=name)
def _build_element(self, min, max, memo): mapping_memo = {} children = [] for spec, value in self._mapping.items(): if min <= value < max: if spec in mapping_memo: children.append(mapping_memo[spec]) else: element = Compound(spec=spec, value=value) children.append(element) mapping_memo[spec] = element if len(children) > 1: return Alternative(children) elif len(children) == 1: return children[0] else: return None
def __init__(self, name=None, spec=None, extras=None, defaults=None, exported=None, context=None): if name is None: name = self._name or self.__class__.__name__ if spec is None: spec = self.spec if extras is None: extras = self.extras if defaults is None: defaults = self.defaults if context is None: context = self.context # Complex handling of exported, because of clashing use of the # exported name at the class level: property & class-value. if exported is not None: pass elif (hasattr(self.__class__, "exported") and not isinstance(self.__class__.exported, property)): exported = self.__class__.exported else: exported = self._default_exported assert isinstance(name, string_types) assert isinstance(spec, string_types) assert isinstance(extras, (list, tuple)) for item in extras: assert isinstance(item, ElementBase) assert exported in (True, False) self._name = name self._spec = spec self.spec = spec self._extras = dict((element.name, element) for element in extras) self._defaults = dict(defaults) child = Compound(spec, extras=self._extras) Rule.__init__(self, name, child, exported=exported, context=context)
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, name): Compound.__init__(self, name=name, spec=self.spec, extras=self.extras)
def __init__(self, spec, element, name=None): self._element = element Compound.__init__(self, spec, extras=[element], name=name)
def __init__(self, spec, words, orig_root_element, name=None): self._words = words self._orig_root_element = orig_root_element Compound.__init__(self, spec, name=name)