def test_should_parse_intent_after_deserialization(self):
# Given
dataset = self.slots_dataset
shared = self.get_shared_data(dataset)
parser = LookupIntentParser(**shared).fit(dataset)
parser.persist(self.tmp_file_path)
deserialized_parser = LookupIntentParser.from_path(
self.tmp_file_path, **shared)
text = "this is a dummy_a query with another dummy_c at 10p.m. or " \
"at 12p.m."
# When
parsing = deserialized_parser.parse(text)
# Then
probability = 1.0
expected_intent = intent_classification_result(
intent_name="dummy_intent_1", probability=probability)
self.assertEqual(expected_intent, parsing[RES_INTENT])
def test_should_be_deserializable_before_fitting(self):
# Given
parser_dict = {
"config": {},
"language_code": None,
"map": None,
"slots_names": [],
"intents_names": [],
"entity_scopes": None
}
self.tmp_file_path.mkdir()
metadata = {"unit_name": "dict_deterministic_intent_parser"}
self.writeJsonContent(
self.tmp_file_path / "intent_parser.json", parser_dict)
self.writeJsonContent(self.tmp_file_path / "metadata.json", metadata)
# When
parser = LookupIntentParser.from_path(self.tmp_file_path)
# Then
config = LookupIntentParserConfig()
expected_parser = LookupIntentParser(config=config)
self.assertEqual(parser.to_dict(), expected_parser.to_dict())
def test_should_be_deserializable(self):
# Given
parser_dict = {
"config": {
"unit_name": "lookup_intent_parser",
"ignore_stop_words": True
},
"language_code": "en",
"map": {
hash_str("make coffee"): [0, []],
hash_str("prepare % snipsnumber % coffees"): [0, [0]],
hash_str("% snipsnumber % teas at % snipstemperature %"):
[1, [0, 1]],
},
"slots_names": ["nb_cups", "tea_temperature"],
"intents_names": ["MakeCoffee", "MakeTea"],
"entity_scopes": [
{
"entity_scope": {
"builtin": ["snips/number"],
"custom": [],
},
"intent_group": ["MakeCoffee"]
},
{
"entity_scope": {
"builtin": ["snips/number", "snips/temperature"],
"custom": [],
},
"intent_group": ["MakeTea"]
},
],
"stop_words_whitelist": dict()
}
self.tmp_file_path.mkdir()
metadata = {"unit_name": "lookup_intent_parser"}
self.writeJsonContent(
self.tmp_file_path / "intent_parser.json", parser_dict)
self.writeJsonContent(self.tmp_file_path / "metadata.json", metadata)
resources = self.get_resources("en")
builtin_entity_parser = BuiltinEntityParser.build(language="en")
custom_entity_parser = EntityParserMock()
# When
parser = LookupIntentParser.from_path(
self.tmp_file_path, custom_entity_parser=custom_entity_parser,
builtin_entity_parser=builtin_entity_parser,
resources=resources)
res_make_coffee = parser.parse("make me a coffee")
res_make_tea = parser.parse("two teas at 90°C please")
# Then
expected_result_coffee = parsing_result(
input="make me a coffee",
intent=intent_classification_result("MakeCoffee", 1.0),
slots=[])
expected_result_tea = parsing_result(
input="two teas at 90°C please",
intent=intent_classification_result("MakeTea", 1.0),
slots=[
{
"entity": "snips/number",
"range": {"end": 3, "start": 0},
"slotName": "nb_cups",
"value": "two"
},
{
"entity": "snips/temperature",
"range": {"end": 16, "start": 12},
"slotName": "tea_temperature",
"value": "90°C"
}
])
self.assertEqual(expected_result_coffee, res_make_coffee)
self.assertEqual(expected_result_tea, res_make_tea)
def test_should_parse_slots_after_deserialization(self):
# Given
dataset = self.slots_dataset
shared = self.get_shared_data(dataset)
parser = LookupIntentParser(**shared).fit(dataset)
parser.persist(self.tmp_file_path)
deserialized_parser = LookupIntentParser.from_path(
self.tmp_file_path, **shared)
texts = [
(
"this is a dummy a query with another dummy_c at 10p.m. or at"
" 12p.m.",
[
unresolved_slot(
match_range=(10, 17),
value="dummy a",
entity="dummy_entity_1",
slot_name="dummy_slot_name",
),
unresolved_slot(
match_range=(37, 44),
value="dummy_c",
entity="dummy_entity_2",
slot_name="dummy_slot_name2",
),
unresolved_slot(
match_range=(45, 54),
value="at 10p.m.",
entity="snips/datetime",
slot_name="startTime",
),
unresolved_slot(
match_range=(58, 67),
value="at 12p.m.",
entity="snips/datetime",
slot_name="startTime",
),
],
),
(
"this, is,, a, dummy a query with another dummy_c at 10pm or "
"at 12p.m.",
[
unresolved_slot(
match_range=(14, 21),
value="dummy a",
entity="dummy_entity_1",
slot_name="dummy_slot_name",
),
unresolved_slot(
match_range=(41, 48),
value="dummy_c",
entity="dummy_entity_2",
slot_name="dummy_slot_name2",
),
unresolved_slot(
match_range=(49, 56),
value="at 10pm",
entity="snips/datetime",
slot_name="startTime",
),
unresolved_slot(
match_range=(60, 69),
value="at 12p.m.",
entity="snips/datetime",
slot_name="startTime",
),
],
),
(
"this is a dummy b",
[
unresolved_slot(
match_range=(10, 17),
value="dummy b",
entity="dummy_entity_1",
slot_name="dummy_slot_name",
)
],
),
(
" this is a dummy b ",
[
unresolved_slot(
match_range=(11, 18),
value="dummy b",
entity="dummy_entity_1",
slot_name="dummy_slot_name",
)
],
),
]
for text, expected_slots in texts:
# When
parsing = deserialized_parser.parse(text)
# Then
self.assertListEqual(expected_slots, parsing[RES_SLOTS])