Example #1
0
    def createGrammar():
        sommatoriaExpansion = Literal("sommatoria")
        sommatoriaExpansion.tag = '\\sum_{}^{}'
        sommatoriaRule = PublicRule("sommatoria_main", sommatoriaExpansion)
        indexExpansion = Literal("sommatoria da")
        indexExpansion.tag = None
        indexRule = PublicRule("summation_index", indexExpansion)
        intervalExpansion = Literal("sommatoria da a")
        intervalExpansion.tag = None
        intervalRule = PublicRule("summation_interval", intervalExpansion)
        #setattr section
        setattr(sommatoriaRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(sommatoriaRule, 'request_new_layer', False)
        setattr(sommatoriaRule, 'next_rules_trigger_words', ['da'])
        setattr(sommatoriaRule, 'is_entry_rule', True)
        #-------------------------
        setattr(indexRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(indexRule, 'request_new_layer', True)
        setattr(indexRule, 'next_rules_trigger_words', ['a'])
        setattr(indexRule, 'is_entry_rule', False)
        setattr(
            indexRule, 'go_to_begin',
            len('\\sum_{}^{}'))  #attributo che specifica se fare carry-home.
        #-------------------------------
        setattr(intervalRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(intervalRule, 'request_new_layer', True)
        setattr(
            intervalRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(intervalRule, 'is_entry_rule', False)

        #grammar creation section
        g = Grammar()
        g.add_rules(sommatoriaRule, indexRule, intervalRule)
        return g
Example #2
0
def main():
    # Create a grammar and add some rules to it
    grammar = RootGrammar()
    name = HiddenRule("name", AlternativeSet("john", "bob", "anna"))

    # greeting is either: 'hey', 'hey there' or 'hello'
    greeting = HiddenRule("greeting", AlternativeSet(
        Sequence("hey", OptionalGrouping("there")), "hello"))

    # parting_phrase is either: 'good bye' or 'see you'
    parting_phrase = HiddenRule("parting_phrase", AlternativeSet(
        "good bye", "see you"))

    # greet is a greeting followed by a name
    greet = PublicRule("greet", Sequence(RuleRef(greeting), RuleRef(name)))

    # goodbye is a parting phrase followed by a name
    goodbye = PublicRule("goodbye", Sequence(
        RuleRef(parting_phrase), RuleRef(name)))

    grammar.add_rules(name, greeting, parting_phrase, greet, goodbye)

    print("Root grammar compiles to the following:")
    print(grammar.compile())

    # Try matching some speech strings
    print_matching(grammar, "hey john")
    print_matching(grammar, "hey there john")
    print_matching(grammar, "see you john")

    # Try matching some hidden rules
    print_matching(grammar, "bob")
    print_matching(grammar, "hey there")
    print_matching(grammar, "good bye")
Example #3
0
    def createGrammar():
        integraleDefinitoExpansion = Literal("integrale da")
        integraleDefinitoExpansion.tag = "\\int\\limits_{}^{}"
        definedIntegralRule = PublicRule("defined_integral_main",
                                         integraleDefinitoExpansion)
        integraleDefinitoUpLimitExpansion = Literal("integrale da a")
        integraleDefinitoUpLimitExpansion.tag = None
        upLimitRule = PublicRule("defined_integral_limit",
                                 integraleDefinitoUpLimitExpansion)
        #setattr section
        setattr(definedIntegralRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(definedIntegralRule, 'request_new_layer', True)
        setattr(definedIntegralRule, 'next_rules_trigger_words', [
            'a'
        ])  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(definedIntegralRule, 'is_entry_rule', True)
        setattr(definedIntegralRule, 'go_to_begin', len('\\int\\limits_{}^{}')
                )  #attributo che specifica se fare carry-home.
        #------------------------------
        setattr(upLimitRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(upLimitRule, 'request_new_layer', True)
        setattr(
            upLimitRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(upLimitRule, 'is_entry_rule', False)

        #grammar creation section
        g = Grammar()
        g.add_rules(definedIntegralRule, upLimitRule)
        return g
Example #4
0
    def test_with_rule_ref(self):
        r1 = PublicRule("test", "test")
        e1 = Seq(RuleRef(r1), Dict())
        self.assert_expansion_sequence_equal(
            [Seq(RuleRef(r1)), Seq(Dict())], e1)

        r2 = PublicRule("test", Dict())
        e2 = Seq(RuleRef(r2), Dict())
        self.assert_expansion_sequence_equal([Dict(), Seq(Dict())], e2)
Example #5
0
    def createGrammar():
        limiteMainExpansion = Literal("limite per")
        limiteMainExpansion.tag = "\\lim{ \\to }"
        limiteMainRule = PublicRule("limite_main", limiteMainExpansion)
        limiteUpP1Expansion = Literal("limite per che")
        limiteUpP1Expansion.tag = None
        limiteUpP1Rule = PublicRule("limite_up_p1", limiteUpP1Expansion)
        limiteUpP2Expansion = Literal("limite per che tende")
        limiteUpP2Expansion.tag = None
        limiteUpP2Rule = PublicRule("limite_up_p2", limiteUpP2Expansion)
        limiteUpP3Expansion = Literal("limite per che tende a")
        limiteUpP3Expansion.tag = None
        limiteUpP3Rule = PublicRule("limite_up_p3", limiteUpP3Expansion)

        #setattr section
        setattr(limiteMainRule, 'node_type', NODE_TYPE.INTERNO)
        setattr(limiteMainRule, 'request_new_layer', True)
        setattr(limiteMainRule, 'next_rules_trigger_words', [
            'che'
        ])  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(limiteMainRule, 'is_entry_rule', True)
        setattr(
            limiteMainRule, 'go_to_begin',
            len('\\lim{ \\to }'))  #attributo che specifica se fare carry-home.
        #------------------------------
        setattr(limiteUpP1Rule, 'node_type', NODE_TYPE.INTERNO)
        setattr(limiteUpP1Rule, 'request_new_layer', True)
        setattr(limiteUpP1Rule, 'next_rules_trigger_words', [
            'tende'
        ])  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(limiteUpP1Rule, 'is_entry_rule', False)
        #--------------------------------
        setattr(limiteUpP2Rule, 'node_type', NODE_TYPE.INTERNO)
        setattr(limiteUpP2Rule, 'request_new_layer', True)
        setattr(limiteUpP2Rule, 'next_rules_trigger_words', [
            'a'
        ])  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(limiteUpP2Rule, 'is_entry_rule', False)
        #------------------------------------
        setattr(limiteUpP3Rule, 'node_type', NODE_TYPE.INTERNO)
        setattr(limiteUpP3Rule, 'request_new_layer', True)
        setattr(
            limiteUpP3Rule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(limiteUpP3Rule, 'is_entry_rule', False)

        #grammar creation section
        g = Grammar()
        g.add_rules(limiteMainRule, limiteUpP1Rule, limiteUpP2Rule,
                    limiteUpP3Rule)
        return g
Example #6
0
def main():
    # Create a simple rule using a Dictation expansion.
    rule = PublicRule("Hello_X", Sequence("hello", Dictation()))

    # Create a new DictationGrammar using the simple rule.
    grammar = DictationGrammar([rule])

    # Print the compiled grammar
    print(grammar.compile())

    # Match against some speech strings.
    # find_matching_rules has an optional second parameter for advancing to
    # the next part of the rule, which is set to False here.
    matching = grammar.find_matching_rules("hello", False)
    print("Matching rule: %s" % matching[0])  # first part of rule

    # Go to the next part of the rule.
    matching[0].set_next()

    # Match the dictation part. This can be anything.
    matching = grammar.find_matching_rules("world")
    print("Matching rule: %s" % matching[0])

    # The entire match and the original rule's current_match value will both be
    'hello world'
    print(matching[0].entire_match)
    print(rule.expansion.current_match)
Example #7
0
    def createGrammar():
        short_rule = Literal(
            "per")  #sto definendo un'expansion, non è una regola!!
        short_rule.tag = "\cdot"  #il contributo di questa regola per il latex finale
        long_rule = Literal("moltiplicato per")  #expansion
        long_rule.tag = "\cdot"
        multiplication_rule = PublicRule("multiplication",
                                         AlternativeSet(short_rule,
                                                        long_rule))  #rule
        #setattr section (Per ogni rule 4 setattr)
        setattr(
            multiplication_rule, 'node_type', NODE_TYPE.FOGLIA
        )  #aggiungiamo un attributo type direttamente sull'oggetto PublicRule per connotarlo come nodo o attributo
        setattr(
            multiplication_rule, 'request_new_layer', False
        )  #tiene conto del fatto che il match di questa regola possa richiedere la creazione di un nuovo layer
        setattr(
            multiplication_rule, 'next_rules_trigger_words', []
        )  #tiene conto del grafo della grammatica. Non mettere None se no salta tutto perchè None non è iterabile
        setattr(
            multiplication_rule, 'is_entry_rule',
            True)  #tiene conto se questa regola è un entry point di un grafo
        setattr(
            multiplication_rule, 'leaf_end_cursor_movement', 1
        )  #una foglia può specificare questo attributo per dire che dopo di lei il cursore deve muoversi di un tot (tipicamente per uno spazio)
        #grammar creation section
        g = Grammar()
        g.add_rule(multiplication_rule)

        return g
Example #8
0
def main():
    # Define a open/close file rule.
    open, close = Literal("open"), Literal("close")
    open.tag, close.tag = "OPEN", "CLOSE"
    cmd = PublicRule("command",
                     Sequence(AlternativeSet(open, close), "the file"))

    # Print the tags of the 'command' rule.
    print("Tags: %s\n" % cmd.tags)

    # Initialise a new grammar and add the rule to it.
    g = Grammar()
    g.add_rule(cmd)

    # Print the compiled grammar
    print("Compiled grammar is:\n%s" % g.compile())

    # Find and print rules tagged with "OPEN"
    print("Tagged rules are:\n%s\n" % g.find_tagged_rules("OPEN"))

    # Matching tags can be retrieved using r.get_tags_matching
    # The Rule.matched_tags property can also be used if Rule.matches or
    # Grammar.find_matching_rules has been called first.
    speech = "open the file"
    print("Tags matching '%s' are: %s" %
          (speech, cmd.get_tags_matching(speech)))
Example #9
0
    def test_matches_as_optional(self):
        e1 = Seq("hello", Opt(Dict()))
        r1 = PublicRule("test", e1)
        self.assertTrue(r1.matches("hello"))
        self.assertEqual(e1.current_match, "hello")
        self.assertEqual(e1.children[0].current_match, "hello")
        self.assertEqual(e1.children[1].current_match, "")

        # Test no match
        self.assertFalse(r1.matches("test testing"))
        map_expansion(e1,
                      lambda x: self.assertTrue(x.current_match in [None, ""]))
Example #10
0
def main():
    # Create a public rule with the name 'hello' and a Literal expansion
    # 'hello world'.
    rule = PublicRule("hello", Literal("hello world"))

    # Note that the following creates the same rule:
    rule = PublicRule("hello", "hello world")

    # Create a grammar and add the new rule to it
    grammar = Grammar()
    grammar.add_rule(rule)

    # Compile the grammar using compile()
    # compile_to_file(file_path) may be used to write a compiled grammar to
    # a file instead.
    # Compilation is not required for finding matching rules.
    print(grammar.compile())

    # Find rules in the grammar that match 'hello world'.
    matching = grammar.find_matching_rules("hello world")
    print("Matching: %s" % matching[0])
Example #11
0
 def createGrammar():
     fracExpansion = Literal("frazione")
     fracExpansion.tag = '\\frac{}{}'
     fracRule = PublicRule("fraction_main", fracExpansion)
     numeratorExpansion = Literal("frazione numeratore")
     numeratorExpansion.tag = None
     numeratorRule = PublicRule("fraction_numerator", numeratorExpansion)
     denominatorExpansion = Literal("frazione numeratore denominatore")
     denominatorExpansion.tag = None
     denominatorRule = PublicRule("fraction_denominator",
                                  denominatorExpansion)
     #setattr section
     setattr(fracRule, 'node_type', NODE_TYPE.INTERNO)
     setattr(fracRule, 'request_new_layer', False)
     setattr(fracRule, 'next_rules_trigger_words', [
         'numeratore'
     ])  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(fracRule, 'is_entry_rule', True)
     #-------------------
     setattr(numeratorRule, 'node_type', NODE_TYPE.INTERNO)
     setattr(numeratorRule, 'request_new_layer', True)
     setattr(numeratorRule, 'next_rules_trigger_words', [
         'denominatore'
     ])  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(numeratorRule, 'is_entry_rule', False)
     setattr(
         numeratorRule, 'go_to_begin',
         len('\\frac{}{}'))  #attributo che specifica se fare carry-home.
     #------------------------
     setattr(denominatorRule, 'node_type', NODE_TYPE.INTERNO)
     setattr(denominatorRule, 'request_new_layer', True)
     setattr(
         denominatorRule, 'next_rules_trigger_words', []
     )  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(denominatorRule, 'is_entry_rule', False)
     #grammar creation section
     g = Grammar()
     g.add_rules(fracRule, numeratorRule, denominatorRule)
     return g
Example #12
0
def main():
    # The Repeat expansion requires one or more matches for its child expansion.
    # The KleeneStar requires zero or more matches. The Sequence expansion
    # requires all of its children expansions to be spoken in sequence.

    # Create a public rule using a Repeat expansion and another using the
    # KleeneStar expansion.
    rule1 = PublicRule("repeat", Sequence(Repeat("please"), "don't crash"))
    rule2 = PublicRule("kleene", Sequence(KleeneStar("please"), "don't crash"))

    # Create a grammar and add the new rules to it
    grammar = Grammar("g")
    grammar.add_rules(rule1, rule2)

    # Compile the grammar using compile()
    print("Grammar '%s' compiles to:" % grammar.name)
    print(grammar.compile())

    # Find rules in the grammar that match some speech strings
    print_matching(grammar, "don't crash")  # only kleene will match
    print_matching(grammar, "please don't crash")  # both will match
    print_matching(grammar, "please please don't crash")  # both again
Example #13
0
    def test_matches_with_literals(self):
        e1 = Seq("hello", Dict())
        r1 = PublicRule("test", e1)
        self.assertTrue(r1.matches("hello world"))
        self.assertTrue(r1.matches("hello world"))
        self.assertEqual(e1.current_match, "hello world")
        self.assertEqual(e1.children[0].current_match, "hello")
        self.assertEqual(e1.children[1].current_match, "world")

        e2 = Seq("a", Dict(), "c")
        r2 = PublicRule("test", e2)
        self.assertTrue(r2.matches("a b c"))
        self.assertEqual(e2.children[0].current_match, "a")
        self.assertEqual(e2.children[1].current_match, "b")
        self.assertEqual(e2.children[2].current_match, "c")
        self.assertEqual(e2.current_match, "a b c")

        # Test with strings that don't match for e1 and e2
        self.assertFalse(r1.matches("test testing"))
        map_expansion(e1, lambda x: self.assertIsNone(x.current_match))
        self.assertFalse(r2.matches("test testing"))
        map_expansion(e2, lambda x: self.assertIsNone(x.current_match))
Example #14
0
def add_to_grammar(grammar_path, file_path, gram_name):
    """
    loads a ``Grammar`` at grammar_path and tries to add rules to it 
    from the file in file_path then returns the new ``Grammar``
    """
    old_gram = parser.parse_grammar_file(grammar_path)
    with open(file_path, 'rt') as f:
        word_list = f.readlines()
    #remove root rule from old grammar
    old_gram.remove_rule(old_gram.get_rule_from_name("root"))
    # get list of rules from old grammar
    old_rules = old_gram.rules
    new_gram = RootGrammar(name=gram_name, case_sensitive=True)
    # add existing rules to new grammar
    i = 0
    old_rules_text = list()
    for rules in old_rules:
        exp = rules.expansion.text.upper()
        old_rules_text.append(exp)
        if exp not in word_list:
            rule_name = "rule" + str(i)
            r = PublicRule(rule_name, exp, case_sensitive=True)
            new_gram.add_rule(r)
            i += 1
    # add new rules to new grammar
    for lines in word_list:
        rule_name = "rule" + str(i)
        exp = lines.upper().strip()
        print("upp is ", exp)
        if exp not in old_rules_text and exp != "" and exp != "{" and exp != "}" and exp != ".":
            r = PublicRule(rule_name, exp, case_sensitive=True)
            new_gram.add_rule(r)
            i += 1

    # compile new grammar back to file
    new_gram.compile_to_file(grammar_path, compile_as_root_grammar=True)
Example #15
0
    def createGrammar():
        rule = Literal("gamma")
        rule.tag = "\\gamma"
        gammaRule = PublicRule("gamma", rule)
        #setattr section
        setattr(gammaRule, 'node_type', NODE_TYPE.FOGLIA)
        setattr(gammaRule, 'request_new_layer', False)
        setattr(
            gammaRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(gammaRule, 'is_entry_rule', True)
        #grammar creation section
        g = Grammar()
        g.add_rule(gammaRule)

        return g
Example #16
0
 def createGrammar():
     rule = Literal("valore assoluto di")
     rule.tag = '||'
     absoluteValueRule = PublicRule("absolute_value", rule)
     #setattr section
     setattr(absoluteValueRule, 'node_type', NODE_TYPE.INTERNO
             )  #vuol dire che si dovrà terminare con una foglia
     setattr(absoluteValueRule, 'request_new_layer', True)
     setattr(
         absoluteValueRule, 'next_rules_trigger_words', []
     )  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(absoluteValueRule, 'is_entry_rule', True)
     #grammar creation section
     g = Grammar()
     g.add_rule(absoluteValueRule)
     return g
Example #17
0
 def createGrammar():
     rule = Literal("alla")
     rule.tag = '^{}'
     powerRule = PublicRule(
         "power", rule
     )  #volutamente non ha un tag. Non ha senso scrivere solo il '^'
     #setattr section
     setattr(powerRule, 'node_type', NODE_TYPE.INTERNO)
     setattr(powerRule, 'request_new_layer', True)
     setattr(
         powerRule, 'next_rules_trigger_words', []
     )  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(powerRule, 'is_entry_rule', True)
     #grammar creation section
     g = Grammar()
     g.add_rule(powerRule)
     return g
Example #18
0
    def _get_best_hypothesis(self, hypotheses):
        """
        Take a list of speech hypotheses and return the most likely one.

        :type hypotheses: iterable
        :return: str | None
        """
        # Get all distinct, non-null hypotheses.
        distinct = tuple([h for h in set(hypotheses) if bool(h)])
        if not distinct:
            return None
        elif len(distinct) == 1:
            return distinct[0]  # only one choice

        # Decide between non-null hypotheses using a Pocket Sphinx search with
        # each hypothesis as a grammar rule.
        grammar = RootGrammar()
        grammar.language_name = self.language
        for i, hypothesis in enumerate(distinct):
            grammar.add_rule(PublicRule("rule%d" % i, Literal(hypothesis)))

        compiled = grammar.compile_grammar()
        name = "_temp"

        # Store the current search name.
        original = self._decoder.active_search

        # Note that there is no need to validate words in this case because
        # each literal in the _temp grammar came from a Pocket Sphinx
        # hypothesis.
        self._decoder.end_utterance()
        self._decoder.set_jsgf_string(name, _map_to_str(compiled))
        self._decoder.active_search = name

        # Do the processing.
        hyp = self._decoder.batch_process(
            self._audio_buffers,
            use_callbacks=False
        )
        result = hyp.hypstr if hyp else None

        # Switch back to the previous search.
        self._decoder.end_utterance()  # just in case
        self._decoder.active_search = original
        self._decoder.unset_search("_temp")
        return result
Example #19
0
def main():
    # Create a simple rule using a Dictation expansion.
    dictation = Dictation()
    dictation.tag = "dictation"  # add a tag to the expansion
    rule = PublicRule("dictation", Sequence("hello", dictation))

    # Print the compiled rule
    print("Compiled rule: %s" % rule.compile())

    # Match a speech string against the rule.
    speech = "hello world"
    print("Rule matches '%s': %s." % (speech, rule.matches(speech)))

    # Print the rule's current_match values using map_expansion.
    def print_match(x):
        print("Match for %s: %s" % (x, x.current_match))

    map_expansion(rule.expansion, print_match)
Example #20
0
    def __init__(self, module_name: str, module: Module,
                 commands: List[ExpressionCommandInfo], keywords: KeywordList,
                 on_no_keywords: Callable, on_not_recognized: Callable):
        super().__init__(module_name, module, keywords, on_no_keywords)

        self._state: Optional[Assistant] = None

        def make_expression(cmd: ExpressionCommandInfo):
            def func(ts):
                return cmd.func(module, self._state, ts)

            return cmd.expression.to_parser().addParseAction(func)

        self.jsgf_grammar = RootGrammar(
            PublicRule(f'cmd-{i}', cmd.expression.to_jsgf())
            for i, cmd in enumerate(commands))
        self.parsing_grammar = pyparsing.Or(map(make_expression, commands))
        self.on_not_recognized = on_not_recognized
Example #21
0
def main():
    # Create a hidden (private) rule
    rule1 = HiddenRule("hello", "hello")

    # Create a public rule referencing rule1
    rule2 = PublicRule("greet", RuleRef(rule1))

    # Create a grammar and add the new rules to it
    grammar = Grammar("g")
    grammar.add_rules(rule1, rule2)

    # Compile the grammar using compile()
    print("Grammar '%s' compiles to:" % grammar.name)
    print(grammar.compile())

    # Find rules matching 'hello'
    # rule2 will be found, but not rule1 because it is hidden
    print("Matching rule: %s" % grammar.find_matching_rules("hello")[0])
Example #22
0
 def createGrammar():
     rule = Literal("pedice")
     rule.tag = '_{}'
     alternative_rule = Literal("sub")
     alternative_rule.tag = '_{}'
     subscriptRule = PublicRule(
         "subscript", AlternativeSet(rule, alternative_rule)
     )  #volutamente non ha un tag. Non ha senso scrivere solo il '^'
     #setattr section
     setattr(subscriptRule, 'node_type', NODE_TYPE.INTERNO)
     setattr(subscriptRule, 'request_new_layer', True)
     setattr(
         subscriptRule, 'next_rules_trigger_words', []
     )  #non mettere None se no salta tutto perchè None non è iterabile
     setattr(subscriptRule, 'is_entry_rule', True)
     #grammar creation section
     g = Grammar()
     g.add_rule(subscriptRule)
     return g
Example #23
0
    def createGrammar():
        short_expansion = Literal("integrale")
        short_expansion.tag = "\int"
        integralRule = PublicRule("integral", short_expansion)
        #setattr section
        setattr(integralRule, 'node_type', NODE_TYPE.FOGLIA)
        setattr(integralRule, 'request_new_layer', False)
        setattr(
            integralRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(integralRule, 'is_entry_rule', True)
        setattr(
            integralRule, 'leaf_end_cursor_movement', 1
        )  #una foglia può specificare questo attributo per dire che dopo di lei il cursore deve muoversi di un tot (tipicamente per uno spazio)
        #grammar creation section
        g = Grammar()
        g.add_rule(integralRule)

        return g
Example #24
0
def main():
    # The Sequence expansion requires all of its children expansions to be spoken
    # in sequence. The OptionalGrouping expansion optionally requires its child
    # expansion to be spoken.

    # Create a public rule using an optional expansion
    rule = PublicRule("greet", Sequence("hey", OptionalGrouping("there")))

    # Create a grammar and add the new rule to it
    grammar = Grammar("g")
    grammar.add_rule(rule)

    # Compile the grammar using compile()
    print("Grammar '%s' compiles to:" % grammar.name)
    print(grammar.compile())

    # Use or do not use the optional word 'there'
    print_matching(grammar, "hey")
    print_matching(grammar, "hey there")
Example #25
0
    def createGrammar():
        short_expansion = Literal("chiusa graffa")
        short_expansion.tag = "}"
        long_expansion = Literal("chiudi parentesi graffa")
        long_expansion.tag = "}"
        long_expansion_2 = Literal("chiusa parentesi graffa")
        long_expansion_2.tag = "}"
        openSquareRule = PublicRule(
            "close_brace",
            AlternativeSet(short_expansion, long_expansion, long_expansion_2))
        #setattr section
        setattr(openSquareRule, 'node_type', NODE_TYPE.FOGLIA)
        setattr(openSquareRule, 'request_new_layer', False)
        setattr(
            openSquareRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(openSquareRule, 'is_entry_rule', True)
        #grammar creation section
        g = Grammar()
        g.add_rule(openSquareRule)

        return g
Example #26
0
    def createGrammar():
        rule = Literal("pi greco")
        rule.tag = "\\pi"
        alternative_rule = Literal("pigreco")
        alternative_rule.tag = "\\pi"
        alternative_rule2 = Literal("p greco")
        alternative_rule2.tag = "\\pi"
        piGrecoRule = PublicRule(
            "pi-greco",
            AlternativeSet(rule, alternative_rule, alternative_rule2))
        #setattr section
        setattr(piGrecoRule, 'node_type', NODE_TYPE.FOGLIA)
        setattr(piGrecoRule, 'request_new_layer', False)
        setattr(
            piGrecoRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(piGrecoRule, 'is_entry_rule', True)
        #grammar creation section
        g = Grammar()
        g.add_rule(piGrecoRule)

        return g
Example #27
0
def create_grammar(word_list, name, gram_file):
    """
    read a list in a text file (```word_list````) and create
    a grammar (```name```) file (```gram_file```) for that list,
    such that the speech can one of any of the elements of the list
    """
    upp_list = list()
    grammar = RootGrammar(name=name, case_sensitive=True)
    i = 0
    for lines in word_list:
        rule_name = "rule" + str(i)
        upp = lines.upper().strip()
        #print("upp is",upp)
        if upp != "" and upp != "{" and upp != "}" and upp != "." and upp[
                0] != "_":
            r = PublicRule(rule_name, upp, case_sensitive=True)
            grammar.add_rule(r)
            upp_list.append(upp)
            i = i + 1

    with open(gram_file, 'wt') as g:
        print(grammar.compile(), file=g)
def main():
    # Create a new public rule using speech alternatives
    # Note that the Sequence expansion requires all of its children expansions
    # to be spoken in sequence
    rule = PublicRule("greet", Sequence(AlternativeSet("hello", "hey"),
                                        "there"))

    # Create a grammar and add the new rule to it
    grammar = Grammar("g")
    grammar.add_rule(rule)

    # Compile the grammar using compile()
    print("Grammar '%s' compiles to:" % grammar.name)
    print(grammar.compile())

    # Find rules in the grammar that match some speech strings
    print_matching(grammar, "hello there")
    print_matching(grammar, "hey there")

    # 'hello hey there' will not match because only one alternative in an
    # AlternativeSet expansion can be matched
    print_matching(grammar, "hello hey there")
Example #29
0
    def createGrammar():
        short_expansion = Literal("aperta tonda")
        short_expansion.tag = "("
        long_expansion = Literal("apri parentesi tonda")
        long_expansion.tag = "("
        long_expansion_2 = Literal("aperta parentesi tonda")
        long_expansion_2.tag = "("
        openParentesisRule = PublicRule(
            "open_parenthesis",
            AlternativeSet(short_expansion, long_expansion, long_expansion_2))
        #setattr section
        setattr(openParentesisRule, 'node_type', NODE_TYPE.FOGLIA)
        setattr(openParentesisRule, 'request_new_layer', False)
        setattr(
            openParentesisRule, 'next_rules_trigger_words', []
        )  #non mettere None se no salta tutto perchè None non è iterabile
        setattr(openParentesisRule, 'is_entry_rule', True)
        #grammar creation section
        g = Grammar()
        g.add_rule(openParentesisRule)

        return g
Example #30
0
list3 = []
list2.append('sil')
list3.append('sil')
for word in list:
    word = word.lower()
    text3 = '<' + word + '>'
    list3.append(text3)
    list2.append(word)
list2.append('[ sil ] ')
list3.append('[ sil ] ;')
phoneme = " ".join(word for word in list2)
# print(phoneme)
text = "why should one halt on the way"
from jsgf import PublicRule, Literal, Grammar

rule = PublicRule("why", Literal(phoneme))
grammar = Grammar("forcing")
grammar.add_rule(rule)
align_file = 'why-align.jsgf'
grammar.compile_to_file(align_file)

text2 = 'sil ' + text + ' [ sil ] '
rule2 = PublicRule("wholeutt", Literal(text2))
grammar2 = Grammar("word")
grammar2.add_rule(rule2)
words_file = "why-words.jsgf"
grammar2.compile_to_file(words_file)

phoneme_final = " ".join(word for word in list3)

phoneme_final = phoneme_final + "\n\n<aa> = aa | ah | er | ao;\n<ae> = ae | eh | er | ah;\n<ah> = ah | ae | er | aa;\n<ao> = ao | aa | er | uh;\n<aw> = aw | aa | uh | ow;\n<ay> = ay | aa | iy | oy | ey;\n<b> = b | p | d;\n<ch> = ch | sh | jh | t;\n<dh> = dh | th | z | v;\n<d> = d | t | jh | g | b;\n<eh> = eh | ih | er | ae;\n<er> = er | eh | ah | ao;\n<ey> = ey | eh | iy | ay;\n<f> = f | hh | th | v;\n<g> = g | k | d;\n<hh> = hh | th | f | p | t | k;\n<ih> = ih | iy | eh;\n<iy> = iy | ih;\n<jh> = jh | ch | zh | d;\n<k> = k | g | t | hh;\n<l> = l | r | w;\n<m> = m | n;\n<ng> = ng | n;\n<n> = n | m | ng;\n<ow> = ow | ao | uh | aw;\n<oy> = oy | ao | iy | ay;\n<p> = p | t | b | hh;\n<r> = r | y | l;\n<ss> = sh | s | z | th;\n<sh> = sh | s | zh | ch;\n<t> = t | ch | k | d | p | hh;\n<th> = th | s | dh | f | hh;\n<uh> = uh | ao | uw | uw;\n<uw> = uw | uh | uw;\n<v> = v | f | dh;\n<w> = w | l | y;\n<y> = y | w | r;\n<z> = z | s | dh | z;\n<zh> = zh | sh | z | jh"