def load(cls, path: Text) -> 'KerasPolicy':
from tensorflow.keras.models import load_model
if os.path.exists(path):
featurizer = TrackerFeaturizer.load(path)
meta_file = os.path.join(path, "keras_policy.json")
if os.path.isfile(meta_file):
meta = json.loads(utils.read_file(meta_file))
tf_config_file = os.path.join(path,
"keras_policy.tf_config.pkl")
with open(tf_config_file, 'rb') as f:
_tf_config = pickle.load(f)
model_file = os.path.join(path, meta["model"])
graph = tf.Graph()
with graph.as_default():
session = tf.Session(config=_tf_config)
with session.as_default():
with warnings.catch_warnings():
warnings.simplefilter("ignore")
model = load_model(model_file)
return cls(featurizer=featurizer,
priority=meta["priority"],
model=model,
graph=graph,
session=session,
current_epoch=meta["epochs"])
else:
return cls(featurizer=featurizer)
else:
raise Exception("Failed to load dialogue model. Path {} "
"doesn't exist".format(os.path.abspath(path)))
async def test_undo_latest_msg(mock_endpoint):
tracker_dump = utils.read_file("data/test_trackers/tracker_moodbot.json")
tracker_json = json.loads(tracker_dump)
evts = tracker_json.get("events")
sender_id = uuid.uuid4().hex
url = '{}/conversations/{}/tracker?include_events=ALL'.format(
mock_endpoint.url, sender_id)
replace_url = '{}/conversations/{}/tracker/events'.format(
mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.get(url, body=tracker_dump)
mocked.put(replace_url)
await interactive._undo_latest(sender_id, mock_endpoint)
r = latest_request(mocked, 'put', replace_url)
assert r
# this should be the events the interactive call send to the endpoint
# these events should have the last utterance omitted
replaced_evts = json_of_latest_request(r)
assert len(replaced_evts) == 6
assert replaced_evts == evts[:6]
def load(path):
featurizer_file = os.path.join(path, "featurizer.json")
if os.path.isfile(featurizer_file):
return jsonpickle.decode(utils.read_file(featurizer_file))
else:
logger.error("Couldn't load featurizer for policy. "
"File '{}' doesn't exist.".format(featurizer_file))
return None
def load(cls, path: Text) -> 'FallbackPolicy':
meta = {}
if os.path.exists(path):
meta_path = os.path.join(path, "two_stage_fallback_policy.json")
if os.path.isfile(meta_path):
meta = json.loads(utils.read_file(meta_path))
return cls(**meta)
def test_all_events_before_user_msg():
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
evts = tracker_json.get("events")
m = interactive.all_events_before_latest_user_msg(evts)
assert m is not None
assert m == evts[:4]
def test_latest_user_message():
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
m = interactive.latest_user_message(tracker_json.get("events"))
assert m is not None
assert m["event"] == "user"
assert m["text"] == "/mood_great"
def test_current_state_no_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
state = tracker.current_state(EventVerbosity.NONE)
assert state.get("events") is None
def test_splitting_conversation_at_restarts():
tracker_dump = "data/test_trackers/tracker_moodbot.json"
evts = json.loads(utils.read_file(tracker_dump)).get("events")
evts_wo_restarts = evts[:]
evts.insert(2, {"event": "restart"})
evts.append({"event": "restart"})
split = interactive._split_conversation_at_restarts(evts)
assert len(split) == 2
assert [e for s in split for e in s] == evts_wo_restarts
assert len(split[0]) == 2
assert len(split[0]) == 2
def test_current_state_all_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
tracker_json["events"].insert(3, {"event": "restart"})
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
evts = [e.as_dict() for e in tracker.events]
state = tracker.current_state(EventVerbosity.ALL)
assert state.get("events") == evts
def load(cls, path: Text) -> 'MemoizationPolicy':
featurizer = TrackerFeaturizer.load(path)
memorized_file = os.path.join(path, 'memorized_turns.json')
if os.path.isfile(memorized_file):
data = json.loads(utils.read_file(memorized_file))
return cls(featurizer=featurizer,
priority=data["priority"],
lookup=data["lookup"])
else:
logger.info("Couldn't load memoization for policy. "
"File '{}' doesn't exist. Falling back to empty "
"turn memory.".format(memorized_file))
return cls()
async def test_print_history(mock_endpoint):
tracker_dump = utils.read_file("data/test_trackers/tracker_moodbot.json")
sender_id = uuid.uuid4().hex
url = '{}/conversations/{}/tracker?include_events=AFTER_RESTART'.format(
mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.get(url,
body=tracker_dump,
headers={"Accept": "application/json"})
await interactive._print_history(sender_id, mock_endpoint)
assert latest_request(mocked, 'get', url) is not None
async def test_is_listening_for_messages(mock_endpoint):
tracker_dump = utils.read_file("data/test_trackers/tracker_moodbot.json")
sender_id = uuid.uuid4().hex
url = '{}/conversations/{}/tracker?include_events=APPLIED'.format(
mock_endpoint.url, sender_id)
with aioresponses() as mocked:
mocked.get(url,
body=tracker_dump,
headers={"Content-Type": "application/json"})
is_listening = await interactive.is_listening_for_message(
sender_id, mock_endpoint)
assert is_listening
def test_read_json_dump(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
restored_tracker = restore.load_tracker_from_json(tracker_dump,
default_agent.domain)
assert len(restored_tracker.events) == 7
assert restored_tracker.latest_action_name == "action_listen"
assert not restored_tracker.is_paused()
assert restored_tracker.sender_id == "mysender"
assert restored_tracker.events[-1].timestamp == 1517821726.211042
restored_state = restored_tracker.current_state(
EventVerbosity.AFTER_RESTART)
assert restored_state == tracker_json
def test_current_state_applied_events(default_agent):
tracker_dump = "data/test_trackers/tracker_moodbot.json"
tracker_json = json.loads(utils.read_file(tracker_dump))
# add some events that result in other events not being applied anymore
tracker_json["events"].insert(1, {"event": "restart"})
tracker_json["events"].insert(7, {"event": "rewind"})
tracker_json["events"].insert(8, {"event": "undo"})
tracker = DialogueStateTracker.from_dict(tracker_json.get("sender_id"),
tracker_json.get("events", []),
default_agent.domain.slots)
evts = [e.as_dict() for e in tracker.events]
applied_events = [evts[2], evts[9]]
state = tracker.current_state(EventVerbosity.APPLIED)
assert state.get("events") == applied_events
def load(cls, path: Text) -> Policy:
filename = os.path.join(path, 'sklearn_model.pkl')
if not os.path.exists(path):
raise OSError("Failed to load dialogue model. Path {} "
"doesn't exist".format(os.path.abspath(filename)))
featurizer = TrackerFeaturizer.load(path)
assert isinstance(featurizer, MaxHistoryTrackerFeaturizer), \
("Loaded featurizer of type {}, should be "
"MaxHistoryTrackerFeaturizer.".format(type(featurizer).__name__))
meta_file = os.path.join(path, "sklearn_policy.json")
meta = json.loads(utils.read_file(meta_file))
policy = cls(featurizer=featurizer, priority=meta["priority"])
with open(filename, 'rb') as f:
state = pickle.load(f)
vars(policy).update(state)
logger.info("Loaded sklearn model")
return policy
def read_dialogue_file(filename: Text):
return jsonpickle.loads(utils.read_file(filename))
def test_restaurant_domain_is_valid():
# should raise no exception
Domain.validate_domain_yaml(read_file('examples/restaurantbot/domain.yml'))
def load_specification(cls, path: Text) -> Dict[Text, Any]:
"""Load a domains specification from a dumped model directory."""
metadata_path = os.path.join(path, 'domain.json')
specification = json.loads(utils.read_file(metadata_path))
return specification
def load(cls, filename):
if not os.path.isfile(filename):
raise Exception("Failed to load domain specification from '{}'. "
"File not found!".format(
os.path.abspath(filename)))
return cls.from_yaml(read_file(filename))
def test_dialogue_serialisation(filename):
dialogue_json = utils.read_file(filename)
restored = json.loads(dialogue_json)
tracker = tracker_from_dialogue_file(filename)
en_de_coded = json.loads(jsonpickle.encode(tracker.as_dialogue()))
assert restored == en_de_coded
def load_metadata(cls, path):
metadata_path = os.path.join(path, 'metadata.json')
metadata = json.loads(utils.read_file(os.path.abspath(metadata_path)))
return metadata
