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")
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, 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
return result
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 __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
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
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)
def register(self, decoder: Decoder):
super().register(decoder)
grammar = RootGrammar(PublicRule(f'cmd-{i}', Literal(cmd.phrase)) for i, cmd in enumerate(self.commands))
decoder.register_grammar(self.module_name, grammar)