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)