def test_information_state_state_set(): df = DialogueFlow('root', initial_speaker=Speaker.USER) transitions = { 'state': 'root', 'error': { 'state': 'one', 'okay': { 'state': 'two', 'error': { 'state': 'three', 'sure': 'root' } } }, 'something': { 'state': 'special', 'that is great': 'root' } } df.add_update_rule('[{read, watched}]', '#TRANSITION(special, 2.0)') df.load_transitions(transitions, speaker=Speaker.USER) df.user_turn('hi') assert df.system_turn() == 'okay' df.user_turn('i read a book') assert df.state() == 'special' assert df.system_turn() == 'that is great' assert df.state() == 'root'
def test_user_multi_hop(): df = DialogueFlow(States.A, initial_speaker=Speaker.USER) df.add_state(States.B, error_successor=States.B, user_multi_hop=True) df.add_state(States.C, error_successor=States.A, user_multi_hop=True) df.add_state(States.D, error_successor=States.A) df.add_state(States.E, error_successor=States.A) df.add_user_transition(States.A, States.B, "[{hey, hello}]") df.add_user_transition(States.A, States.C, "[{excuse, pardon}]") df.add_user_transition(States.B, States.D, "[how, you]") df.add_user_transition(States.C, States.E, "[{where, how, what}]") df.set_state(States.A) df.user_turn("hey", debugging=False) assert df.state() == States.B df.set_state(States.A) df.set_speaker(Speaker.USER) df.user_turn("hey how are you") assert df.state() == States.D df.set_state(States.A) df.set_speaker(Speaker.USER) df.user_turn("excuse me where do i go") assert df.state() == States.E df.set_state(States.A) df.set_speaker(Speaker.USER) df.user_turn("excuse me") assert df.state() == States.A
def test_virtual_transitions(): df = DialogueFlow('root') transitions = { 'state': 'root', 'hello': { 'state': 'test', 'a': { 'something typical': 'nope' }, '#VT(other)': 'blah' }, 'not taken': { 'state': 'other', 'score': 0, 'x': { 'you win': { 'state': 'success' } }, 'y': { 'you win': { 'state': 'success' } } } } df.load_transitions(transitions) df.system_turn() assert df.state() == 'test' df.user_turn('x', debugging=True) assert df.system_turn() == 'you win' assert df.state() == 'success'
def test_virtual_transitions(): df = DialogueFlow("root") transitions = { "state": "root", "hello": { "state": "test", "a": { "something typical": "nope" }, "#VT(other)": "blah", }, "not taken": { "state": "other", "score": 0, "x": { "you win": { "state": "success" } }, "y": { "you win": { "state": "success" } }, }, } df.load_transitions(transitions) df.system_turn() assert df.state() == "test" df.user_turn("x", debugging=True) assert df.system_turn() == "you win" assert df.state() == "success"
def test_system_transition(): for _ in range(6): df = DialogueFlow(States.A) df.add_system_transition(States.A, States.B, "hello", score=2.0) df.add_system_transition(States.A, States.C, "hey") assert df.system_transition(df.state()) == ("hello", States.B) df = DialogueFlow(States.A) df.add_system_transition(States.A, States.B, "hello") df.add_system_transition(States.A, States.C, "hey", score=2.0) assert df.system_transition(df.state()) == ("hey", States.C)
def test_system_transition(): for _ in range(6): df = DialogueFlow(States.A) df.add_system_transition(States.A, States.B, 'hello', score=2.0) df.add_system_transition(States.A, States.C, 'hey') assert df.system_transition(df.state()) == ('hello', States.B) df = DialogueFlow(States.A) df.add_system_transition(States.A, States.B, 'hello') df.add_system_transition(States.A, States.C, 'hey', score=2.0) assert df.system_transition(df.state()) == ('hey', States.C)
def test_ontology(): kb = KnowledgeBase() ontology = { "ontology": { "season": [ "fall", "spring", "summer", "winter" ], "month": [ "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december" ] } } kb.load_json(ontology) df = DialogueFlow(States.A, Speaker.USER, kb=kb) df.add_state(States.A) df.add_state(States.B) df.add_state(States.C) df.add_state(States.D) df.add_state(States.E) df.set_error_successor(States.A, States.E) df.set_error_successor(States.B, States.E) df.set_error_successor(States.C, States.E) df.set_error_successor(States.D, States.E) df.add_user_transition(States.A, States.B, "[#ONT(month)]") df.add_system_transition(States.B, States.C, "B to C") df.add_user_transition(States.C, States.D, "[$m=#ONT(month), $s=#ONT(season)]") df.user_turn("january") assert df.state() == States.B assert df.system_turn() == "B to C" df.user_turn("october is in the fall season") assert df.state() == States.D assert df._vars["m"] == "october" assert df._vars["s"] == "fall" df.set_state(States.A) df.set_speaker(Speaker.USER) df.user_turn("hello there", debugging=False) assert df.state() == States.E
def test_user_transition_list_disjunction(): df = DialogueFlow("root", initial_speaker=Speaker.USER) nlu = ["hello", "hi", "how are you"] df.add_user_transition("root", "x", nlu) df.update_state_settings("root", error_successor="y") df.user_turn("hi") assert df.state() == "x"
def test_reset(): df = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df.add_state(States.B, error_successor=States.E) df.add_state(States.C, error_successor=States.E) df.add_system_transition(States.A, States.B, "B") df.add_system_transition(States.A, States.C, "C") df.add_system_transition(States.E, States.E, "E") # response = df.system_turn() df.system_turn() df.user_turn("") assert df.state() == States.E df.reset() assert df.state() == "States.A" assert df.speaker() == Speaker.SYSTEM # response = df.system_turn() df.system_turn() df.user_turn("") assert df.state() == States.E df.system_turn() assert df.state() == States.E df.reset() assert df.state() == States.A assert df.speaker() == Speaker.SYSTEM # response = df.system_turn() df.system_turn() df.user_turn("") assert df.state() == States.E df.system_turn() assert df.state() == States.E
def test_reset(): df = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df.add_state(States.B, error_successor=States.E) df.add_state(States.C, error_successor=States.E) df.add_system_transition(States.A, States.B, 'B') df.add_system_transition(States.A, States.C, 'C') df.add_system_transition(States.E, States.E, 'E') response = df.system_turn() df.user_turn("") assert df.state() == States.E df.reset() assert df.state() == 'States.A' assert df.speaker() == Speaker.SYSTEM response = df.system_turn() df.user_turn("") assert df.state() == States.E df.system_turn() assert df.state() == States.E df.reset() assert df.state() == States.A assert df.speaker() == Speaker.SYSTEM response = df.system_turn() df.user_turn("") assert df.state() == States.E df.system_turn() assert df.state() == States.E
def test_information_state_state_set(): df = DialogueFlow("root", initial_speaker=Speaker.USER) transitions = { "state": "root", "error": { "state": "one", "okay": {"state": "two", "error": {"state": "three", "sure": "root"}}, }, "something": {"state": "special", "that is great": "root"}, } df.add_update_rule("[{read, watched}]", "#TRANSITION(special, 2.0)") df.load_transitions(transitions, speaker=Speaker.USER) df.user_turn("hi") assert df.system_turn() == "okay" df.user_turn("i read a book") assert df.state() == "special" assert df.system_turn() == "that is great" assert df.state() == "root"
def test_global_transition_list_disjunction(): df = DialogueFlow("root", initial_speaker=Speaker.USER) nlu = ["hi", "hello"] df.add_state("root", "x") df.add_system_transition("x", "y", "hello") df.add_global_nlu("x", nlu) df.user_turn("ok") df.system_turn() df.user_turn("hi") assert df.state() == "x"
def test_user_transition_list_disjunction(): df = DialogueFlow('root', initial_speaker=Speaker.USER) nlu = [ 'hello', 'hi', 'how are you' ] df.add_user_transition('root', 'x', nlu) df.update_state_settings('root', error_successor='y') df.user_turn('hi') assert df.state() == 'x'
def test_serialization(): df = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df.add_state(States.B, error_successor=States.E) df.add_state(States.C, error_successor=States.E) df.add_system_transition(States.A, States.B, '#GATE $spoken=B') df.add_system_transition(States.A, States.C, '#GATE(spoken) $spoken=C') df.add_system_transition(States.E, States.E, '$spoken=E') df.add_user_transition(States.B, States.A, '$heard=b') df.add_user_transition(States.E, States.A, '$heard=e') df.system_turn() assert df.state() == States.B assert df.vars()["spoken"] == "B" df.user_turn('b') df.system_turn() assert df.state() == States.C assert df.vars()["spoken"] == "C" expected_gates = {'States.B': [{}], 'States.C': [{'spoken': 'B'}]} assert df.gates() == expected_gates df.vars()["testing_none"] = None d = df.serialize() df2 = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df2.add_state(States.B, error_successor=States.E) df2.add_state(States.C, error_successor=States.E) df2.add_system_transition(States.A, States.B, '#GATE $spoken=B') df2.add_system_transition(States.A, States.C, '#GATE(spoken) $spoken=C') df2.add_system_transition(States.E, States.E, '$spoken=E') df2.add_user_transition(States.B, States.A, '$heard=b') df2.add_user_transition(States.E, States.A, '$heard=e') assert df2.state() == States.A assert 'spoken' not in df2.vars() and 'heard' not in df2.vars() assert len(df2.gates()) == 0 df2.deserialize(d) assert df.vars() == df2.vars() assert df.gates() == df2.gates() assert df.state() == df2.state() assert df2.vars()["testing_none"] is None
def test_serialization(): df = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df.add_state(States.B, error_successor=States.E) df.add_state(States.C, error_successor=States.E) df.add_system_transition(States.A, States.B, "#GATE $spoken=B") df.add_system_transition(States.A, States.C, "#GATE(spoken) $spoken=C") df.add_system_transition(States.E, States.E, "$spoken=E") df.add_user_transition(States.B, States.A, "$heard=b") df.add_user_transition(States.E, States.A, "$heard=e") df.system_turn() assert df.state() == States.B assert df.vars()["spoken"] == "B" df.user_turn("b") df.system_turn() assert df.state() == States.C assert df.vars()["spoken"] == "C" expected_gates = {"States.B": [{}], "States.C": [{"spoken": "B"}]} assert df.gates() == expected_gates df.vars()["testing_none"] = None d = df.serialize() df2 = DialogueFlow(States.A, initial_speaker=Speaker.SYSTEM) df2.add_state(States.B, error_successor=States.E) df2.add_state(States.C, error_successor=States.E) df2.add_system_transition(States.A, States.B, "#GATE $spoken=B") df2.add_system_transition(States.A, States.C, "#GATE(spoken) $spoken=C") df2.add_system_transition(States.E, States.E, "$spoken=E") df2.add_user_transition(States.B, States.A, "$heard=b") df2.add_user_transition(States.E, States.A, "$heard=e") assert df2.state() == States.A assert "spoken" not in df2.vars() and "heard" not in df2.vars() assert len(df2.gates()) == 0 df2.deserialize(d) assert df.vars() == df2.vars() assert df.gates() == df2.gates() assert df.state() == df2.state() assert df2.vars()["testing_none"] is None
def test_global_transition_list_disjunction(): df = DialogueFlow('root', initial_speaker=Speaker.USER) nlu = [ 'hi', 'hello' ] df.add_state('root', 'x') df.add_system_transition('x', 'y', 'hello') df.add_global_nlu('x', nlu) df.user_turn('ok') df.system_turn() df.user_turn('hi') assert df.state() == 'x'
def test_stack(): df = DialogueFlow("root") transitions = { "state": "root", "`What should I do?`": "gma_hospital", "#GOAL(grandma_hospital) #GATE" "`I cannot concentrate on a lot of things right now. " "My grandma is in the hospital. " "What should I do?`": { "state": "gma_hospital", "score": 2.0, "[{[{dont,shouldnt,not},worry],calm,relax,distract,[mind,off]}]": { "state": "dont_worry", "#GATE " "\"Okay, I will try my best not to worry. It's hard because she lives by " "herself and won't let anyone help her very much, so I feel like this " 'will just happen again."': { "state": "happen_again", "[{sorry,sucks,hard}]": { '"yeah, thanks."': {} }, "[will,better]": { '"I really hope you are right."': {} }, "error": { "state": "feel_better", '"I actually feel a little bit better after talking with you. Thanks for listening. "': {}, }, }, "#DEFAULT": "feel_better", }, "#IDK": { '"yeah, i dont know either. Its so tough."': {} }, }, } gma = { "#GOAL(why_grandma_hospital) " "[{[why,hospital],wrong,happened}]": { "state": "why_grandma_hospital", '"She is just so frail. I can hardly believe it. ' 'She fell off of a stool in the kitchen and broke her hip."': { "[dont worry]": {"#GRET(grandma_hospital,dont_worry)"}, "error": { "#GRET": "return" }, }, }, "#GOAL(grandma_hospital_before) " "[{has,was},{she,grandma},hospital,{before,earlier,previously}]": { "state": "grandma_hospital_before", '"No, this is the first time, thank goodness."': { "error": { "#GRET": "return" } }, }, } df.load_transitions(transitions) df.load_transitions(gma, speaker=DialogueFlow.Speaker.USER) df.add_global_nlu( "why_grandma_hospital", "#GOAL(why_grandma_hospital) [{[why,hospital],wrong,happened}]", score=0.7, ) df.add_global_nlu( "grandma_hospital_before", "#GOAL(grandma_hospital_before) [{has,was},{she,grandma},hospital,{before,earlier,previously}]", score=0.7, ) # r = df.system_turn() df.system_turn() assert df.vars()["__goal__"] == "grandma_hospital" assert len(df.vars()["__stack__"]) == 0 assert df.state() == "gma_hospital" df.user_turn("what happened") assert df.state() == "why_grandma_hospital" assert df.vars()["__goal_return_state__"] == "None" assert df.vars()["__goal__"] == "why_grandma_hospital" assert len(df.vars()["__stack__"]) == 1 assert df.vars()["__stack__"][0][0] == "grandma_hospital" assert "fell off of a stool" in df.system_turn() df.user_turn("oh no", debugging=True) assert "What should I do" in df.system_turn(debugging=True) assert df.state() == "gma_hospital" assert df.vars()["__goal__"] == "grandma_hospital" assert len(df.vars()["__stack__"]) == 0 df.user_turn("dont worry") assert df.state() == "dont_worry" assert "she lives by herself" in df.system_turn() df.user_turn("has your grandma been in the hospital before this") assert df.state() == "grandma_hospital_before" assert df.vars()["__goal__"] == "grandma_hospital_before" assert len(df.vars()["__stack__"]) == 1 assert df.vars()["__stack__"][0][0] == "grandma_hospital" assert "this is the first time" in df.system_turn() df.user_turn("ok that is good") assert "feel a little bit better" in df.system_turn() assert df.vars()["__goal__"] == "grandma_hospital" assert len(df.vars()["__stack__"]) == 0
def test_user_transition(): df = DialogueFlow(States.B) df.add_user_transition(States.B, States.C, "[{hi, hello, hey, [how, you]}]") df.add_user_transition(States.B, States.D, "[{bye, goodbye, see you, see ya, later}]") assert df.user_transition("oh hey there", df.state()) == States.C assert df.user_transition("well see ya later", df.state()) == States.D
def test_single_user_transition(): df = DialogueFlow(States.B) df.add_user_transition(States.B, States.C, "[{hi, hello, hey, [how, you]}]") assert df.user_transition("oh hey there", df.state()) == States.C
def test_single_system_transition(): df = DialogueFlow(States.A) df.add_system_transition(States.A, States.B, "hello") assert df.system_transition(df.state()) == ("hello", States.B)
def test_constructor(): df = DialogueFlow(States.A) assert df.state() == States.A assert df.speaker() == Speaker.SYSTEM
def test_stack(): df = DialogueFlow('root') transitions = { 'state': 'root', '`What should I do?`': 'gma_hospital', '#GOAL(grandma_hospital) #GATE' '`I cannot concentrate on a lot of things right now. ' 'My grandma is in the hospital. ' 'What should I do?`': { 'state': 'gma_hospital', 'score': 2.0, '[{[{dont,shouldnt,not},worry],calm,relax,distract,[mind,off]}]': { 'state': 'dont_worry', '#GATE ' '"Okay, I will try my best not to worry. It\'s hard because she lives by ' 'herself and won\'t let anyone help her very much, so I feel like this ' 'will just happen again."': { 'state': 'happen_again', '[{sorry,sucks,hard}]': { '"yeah, thanks."': {} }, '[will,better]': { '"I really hope you are right."': {} }, 'error': { 'state': 'feel_better', '"I actually feel a little bit better after talking with you. Thanks for listening. "': {} } }, '#DEFAULT': 'feel_better' }, '#IDK': { '"yeah, i dont know either. Its so tough."': {} } } } gma = { '#GOAL(why_grandma_hospital) ' '[{[why,hospital],wrong,happened}]': { 'state': 'why_grandma_hospital', '"She is just so frail. I can hardly believe it. ' 'She fell off of a stool in the kitchen and broke her hip."': { '[dont worry]': {'#GRET(grandma_hospital,dont_worry)'}, 'error': { '#GRET': 'return' } } }, '#GOAL(grandma_hospital_before) ' '[{has,was},{she,grandma},hospital,{before,earlier,previously}]': { 'state': 'grandma_hospital_before', '"No, this is the first time, thank goodness."': { 'error': { '#GRET': 'return' } } } } df.load_transitions(transitions) df.load_transitions(gma, speaker=DialogueFlow.Speaker.USER) df.add_global_nlu( 'why_grandma_hospital', '#GOAL(why_grandma_hospital) [{[why,hospital],wrong,happened}]', score=0.7) df.add_global_nlu( 'grandma_hospital_before', '#GOAL(grandma_hospital_before) [{has,was},{she,grandma},hospital,{before,earlier,previously}]', score=0.7) r = df.system_turn() assert df.vars()['__goal__'] == 'grandma_hospital' assert len(df.vars()['__stack__']) == 0 assert df.state() == 'gma_hospital' df.user_turn("what happened") assert df.state() == "why_grandma_hospital" assert df.vars()['__goal_return_state__'] == 'None' assert df.vars()['__goal__'] == 'why_grandma_hospital' assert len(df.vars()['__stack__']) == 1 assert df.vars()['__stack__'][0][0] == 'grandma_hospital' assert "fell off of a stool" in df.system_turn() df.user_turn("oh no", debugging=True) assert "What should I do" in df.system_turn(debugging=True) assert df.state() == 'gma_hospital' assert df.vars()['__goal__'] == 'grandma_hospital' assert len(df.vars()['__stack__']) == 0 df.user_turn("dont worry") assert df.state() == 'dont_worry' assert "she lives by herself" in df.system_turn() df.user_turn("has your grandma been in the hospital before this") assert df.state() == 'grandma_hospital_before' assert df.vars()['__goal__'] == 'grandma_hospital_before' assert len(df.vars()['__stack__']) == 1 assert df.vars()['__stack__'][0][0] == 'grandma_hospital' assert "this is the first time" in df.system_turn() df.user_turn("ok that is good") assert "feel a little bit better" in df.system_turn() assert df.vars()['__goal__'] == 'grandma_hospital' assert len(df.vars()['__stack__']) == 0
class CompositeDialogueFlow: def __init__( self, initial_state, system_error_state, user_error_state, initial_speaker=DialogueFlow.Speaker.SYSTEM, macros=None, kb=None, ): if isinstance(system_error_state, str): system_error_state = ("SYSTEM", system_error_state) if isinstance(user_error_state, str): user_error_state = ("SYSTEM", user_error_state) # the dialogue flow currently controlling the conversation self._controller = DialogueFlow(initial_state, initial_speaker, macros, kb) self._controller_name = "SYSTEM" # namespace : dialogue flow mapping self._components = {} self.add_component(self._controller, "SYSTEM") self._system_error_state = system_error_state self._user_error_state = user_error_state def run(self, debugging=False): """ test in interactive mode :return: None """ while True: if self.controller().speaker() == DialogueFlow.Speaker.SYSTEM: t1 = time() response = self.system_turn(debugging=debugging) if debugging: print("System turn in {:5}".format(time() - t1)) print("S:", response) else: user_input = input("U: ") t1 = time() self.user_turn(user_input, debugging=debugging) if debugging: print("User turn in {:5}".format(time() - t1)) def system_turn(self, debugging=False): """ an entire system turn comprising a single system utterance and one or more system transitions :return: the natural language system response """ visited = {self._controller.state()} self.controller().vars()["__goal_return_state__"] = "None" responses = [] while self.controller().speaker() is DialogueFlow.Speaker.SYSTEM: try: response, next_state = self.controller().system_transition( self.controller().state(), debugging=debugging) assert next_state is not None self.controller().set_state(next_state) except Exception as e: print() print(e) print( "Error in CompositeDialogueFlow. Component: {} State: {}". format(self.controller_name(), self.controller().state())) traceback.print_exc(file=sys.stdout) response, next_state = "", self._system_error_state visited = visited - {next_state} if isinstance(next_state, tuple): self.set_control(*next_state) responses.append(response) if next_state in visited or not self.state_settings( *self.state()).system_multi_hop: self.controller().set_speaker(DialogueFlow.Speaker.USER) visited.add(next_state) full_response = " ".join(responses) self.controller().vars()["__selected_response__"] = full_response return full_response def user_turn(self, natural_language, debugging=False): """ an entire user turn comprising one user utterance and one or more user transitions :param natural_language: :param debugging: :return: None """ self.controller().vars()["__user_utterance__"] = natural_language try: self.controller().apply_update_rules(natural_language, debugging=debugging) next_state = self.controller().state() except Exception as e: print() print(e) print("Error in CompositeDialogueFlow. Component: {} State: {}". format(self._controller_name, self.controller().state())) traceback.print_exc(file=sys.stdout) next_state = self._user_error_state visited = {self.controller().state()} while self.controller().speaker() is DialogueFlow.Speaker.USER: try: next_state = self.controller().user_transition( natural_language, self.controller().state(), debugging=debugging) assert next_state is not None self.controller().set_state(next_state) except Exception as e: print() print(e) print( "Error in CompositeDialogueFlow. Component: {} State: {}". format(self._controller_name, self.controller().state())) traceback.print_exc(file=sys.stdout) next_state = self._user_error_state next_state = module_state(next_state) if isinstance(next_state, tuple): self.set_control(*next_state) if self.state_settings(*self.state()).user_multi_hop: self.controller().apply_update_rules(natural_language, debugging=debugging) if next_state in visited or not self.state_settings( *self.state()).user_multi_hop: self.controller().set_speaker(DialogueFlow.Speaker.SYSTEM) visited.add(next_state) next_state = module_state(next_state) if isinstance(next_state, tuple): self.set_control(*next_state) if self.controller().speaker() is DialogueFlow.Speaker.USER: self.controller().apply_update_rules(natural_language, debugging=debugging) def set_control(self, namespace, state): state = module_state(state) speaker = self.controller().speaker() old_state = self.controller().state() self.component(namespace).set_state(old_state) self.set_controller(namespace) self.controller().set_speaker(speaker) if isinstance(state, tuple): umh = self.state_settings(*state).user_multi_hop smh = self.state_settings(*state).system_multi_hop else: umh = self.state_settings(namespace, state).user_multi_hop smh = self.state_settings(namespace, state).system_multi_hop if speaker == DialogueFlow.Speaker.USER and not umh: self.controller().change_speaker() elif speaker == DialogueFlow.Speaker.SYSTEM and not smh: self.controller().change_speaker() self.controller().set_state(state) def precache_transitions(self, process_num=1): start = time() transition_data_sets = [] for i in range(process_num): transition_data_sets.append([]) # count = 0 if process_num == 1: for name, df in self._components.items(): df.precache_transitions(process_num) else: # for name,df in self._components.items(): # for transition in df._graph.arcs(): # transition_data_sets[count].append(df._graph.arc_data(*transition)) # count = (count + 1) % process_num # # print("multiprocessing...") # p = Pool(process_num) # results = p.map(precache, transition_data_sets) # for i in range(len(results)): # result_list = results[i] # t_list = transition_data_sets[i] # for j in range(len(result_list)): # parsed_tree = result_list[j] # t = t_list[j] # t['natex']._compiler._parsed_tree = parsed_tree raise NotImplementedError() print("Elapsed: ", time() - start) def add_state(self, state, error_successor=None): state = module_state(state) if isinstance(state, tuple): ns, state = state else: ns = "SYSTEM" self._components[ns].add_state(state, error_successor) def add_user_transition(self, source, target, natex_nlu, **settings): source, target = module_source_target(source, target) if isinstance(source, tuple): ns, source = source else: ns = "SYSTEM" self._components[ns].add_user_transition(source, target, natex_nlu, **settings) def add_system_transition(self, source, target, natex_nlg, **settings): source, target = module_source_target(source, target) if isinstance(source, tuple): ns, source = source else: ns = "SYSTEM" self._components[ns].add_system_transition(source, target, natex_nlg, **settings) def add_component(self, component, namespace): self._components[namespace] = component component.set_is_module(self) component.set_namespace(namespace) component.set_gates(self.component("SYSTEM").gates()) def component(self, namespace): return self._components[namespace] def components(self): return self._components.values() def set_state(self, state): state = module_state(state) if isinstance(state, tuple): if self.component(state[0]) != self.controller(): self.component(state[0]).set_state(self.controller().state( )) # so __system_state__ is set properly self.set_controller(state[0]) state = state[1] self.controller().set_state(state) def set_controller(self, controller_name): old_controller_vars = self._controller.vars() if self._controller_name != controller_name: del old_controller_vars["__state__"] self._controller = self.component(controller_name) self._controller_name = controller_name new_controller_vars = self._controller.vars() new_controller_vars.update(old_controller_vars) self._controller.set_vars(new_controller_vars) def transition_natex(self, namespace, source, target, speaker): source, target = module_source_target(source, target) if isinstance(source, tuple): source = source[1] if isinstance(target, tuple): target = target[1] return self.component(namespace).transition_natex( source, target, speaker) def state_settings(self, namespace, state): return self.component(namespace).state_settings(state) def set_vars(self, vars): self._controller.set_vars(vars) def reset(self): gates = None goals = None for name, component in self._components.items(): component.reset() if gates is None: gates = component.gates() goals = component.goals() component.set_gates(gates) component.set_goals(goals) self.set_controller("SYSTEM") def controller(self): return self._controller def controller_name(self): return self._controller_name def state(self): return self._controller_name, self._controller.state() def serialize(self): """ Returns json serialized dict of {'vars': vars, 'gates': gates, 'state': state} """ config = { "vars": self._controller.vars(), "gates": self._controller.gates(), "state": self.state() } return json_serialize_flexible(config, speaker_enum_mapping) def deserialize(self, config_str): config = json_deserialize_flexible(config_str, speaker_enum_rmapping) self.reset() self.set_state(config["state"]) self.set_vars(config["vars"]) gates = defaultdict(list, config["gates"]) for name, component in self._components.items(): component.set_gates(gates) def new_turn(self, toplevel="SYSTEM"): self.reset() self.set_controller(toplevel)