def test_should_use_parsers_sequentially(self):
# Given
input_text = "hello world"
intent = intent_classification_result(intent_name='dummy_intent_1',
probability=0.7)
slots = [
unresolved_slot(match_range=(6, 11),
value='world',
entity='mocked_entity',
slot_name='mocked_slot_name')
]
class FirstIntentParserConfig(ProcessingUnitConfig):
unit_name = "first_intent_parser"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return FirstIntentParserConfig()
def get_required_resources(self):
return None
class FirstIntentParser(IntentParser):
unit_name = "first_intent_parser"
config_type = FirstIntentParserConfig
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
return empty_result(text)
def persist(self, path):
path = Path(path)
path.mkdir()
with (path / "metadata.json").open(mode="w") as f:
f.write(json_string({"unit_name": self.unit_name}))
@classmethod
def from_path(cls, path):
cfg = cls.config_type()
return cls(cfg)
class SecondIntentParserConfig(ProcessingUnitConfig):
unit_name = "second_intent_parser"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return SecondIntentParserConfig()
def get_required_resources(self):
return None
class SecondIntentParser(IntentParser):
unit_name = "second_intent_parser"
config_type = SecondIntentParserConfig
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
if text == input_text:
return parsing_result(text, intent, slots)
return empty_result(text)
def persist(self, path):
path = Path(path)
path.mkdir()
with (path / "metadata.json").open(mode="w") as f:
f.write(json_string({"unit_name": self.unit_name}))
@classmethod
def from_path(cls, path):
cfg = cls.config_type()
return cls(cfg)
register_processing_unit(FirstIntentParser)
register_processing_unit(SecondIntentParser)
mocked_dataset_metadata = {
"language_code": "en",
"entities": {
"mocked_entity": {
"automatically_extensible": True,
"utterances": dict()
}
},
"slot_name_mappings": {
"dummy_intent_1": {
"mocked_slot_name": "mocked_entity"
}
}
}
config = NLUEngineConfig(
[FirstIntentParserConfig(),
SecondIntentParserConfig()])
engine = SnipsNLUEngine(config).fit(SAMPLE_DATASET)
# pylint:disable=protected-access
engine._dataset_metadata = mocked_dataset_metadata
# pylint:enable=protected-access
# When
parse = engine.parse(input_text)
# Then
expected_slots = [custom_slot(s) for s in slots]
expected_parse = parsing_result(input_text, intent, expected_slots)
self.assertDictEqual(expected_parse, parse)
def test_should_use_parsers_sequentially(self):
# Given
input_text = "hello world"
intent = intent_classification_result(intent_name='dummy_intent_1',
probability=0.7)
slots = [
unresolved_slot(match_range=(6, 11),
value='world',
entity='mocked_entity',
slot_name='mocked_slot_name')
]
class TestIntentParser1Config(ProcessingUnitConfig):
unit_name = "test_intent_parser1"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return TestIntentParser1Config()
class TestIntentParser1(IntentParser):
unit_name = "test_intent_parser1"
config_type = TestIntentParser1Config
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
return empty_result(text)
def to_dict(self):
return {
"unit_name": self.unit_name,
}
@classmethod
def from_dict(cls, unit_dict):
conf = cls.config_type()
return TestIntentParser1(conf)
class TestIntentParser2Config(ProcessingUnitConfig):
unit_name = "test_intent_parser2"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return TestIntentParser2Config()
class TestIntentParser2(IntentParser):
unit_name = "test_intent_parser2"
config_type = TestIntentParser2Config
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
if text == input_text:
return parsing_result(text, intent, slots)
return empty_result(text)
def to_dict(self):
return {
"unit_name": self.unit_name,
}
@classmethod
def from_dict(cls, unit_dict):
conf = cls.config_type()
return TestIntentParser2(conf)
register_processing_unit(TestIntentParser1)
register_processing_unit(TestIntentParser2)
mocked_dataset_metadata = {
"language_code": "en",
"entities": {
"mocked_entity": {
"automatically_extensible": True,
"utterances": dict()
}
},
"slot_name_mappings": {
"dummy_intent_1": {
"mocked_slot_name": "mocked_entity"
}
}
}
config = NLUEngineConfig(
[TestIntentParser1Config(),
TestIntentParser2Config()])
engine = SnipsNLUEngine(config).fit(SAMPLE_DATASET)
# pylint:disable=protected-access
engine._dataset_metadata = mocked_dataset_metadata
# pylint:enable=protected-access
# When
parse = engine.parse(input_text)
# Then
expected_slots = [custom_slot(s) for s in slots]
expected_parse = parsing_result(input_text, intent, expected_slots)
self.assertDictEqual(expected_parse, parse)
def test_should_use_parsers_sequentially(self):
# Given
input_text = "hello world"
intent = intent_classification_result(
intent_name='dummy_intent_1', probability=0.7)
slots = [unresolved_slot(match_range=(6, 11),
value='world',
entity='mocked_entity',
slot_name='mocked_slot_name')]
class TestIntentParser1Config(ProcessingUnitConfig):
unit_name = "test_intent_parser1"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return TestIntentParser1Config()
class TestIntentParser1(IntentParser):
unit_name = "test_intent_parser1"
config_type = TestIntentParser1Config
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
return empty_result(text)
def to_dict(self):
return {
"unit_name": self.unit_name,
}
@classmethod
def from_dict(cls, unit_dict):
conf = cls.config_type()
return TestIntentParser1(conf)
class TestIntentParser2Config(ProcessingUnitConfig):
unit_name = "test_intent_parser2"
def to_dict(self):
return {"unit_name": self.unit_name}
@classmethod
def from_dict(cls, obj_dict):
return TestIntentParser2Config()
class TestIntentParser2(IntentParser):
unit_name = "test_intent_parser2"
config_type = TestIntentParser2Config
def fit(self, dataset, force_retrain):
self._fitted = True
return self
@property
def fitted(self):
return hasattr(self, '_fitted') and self._fitted
def parse(self, text, intents):
if text == input_text:
return parsing_result(text, intent, slots)
return empty_result(text)
def to_dict(self):
return {
"unit_name": self.unit_name,
}
@classmethod
def from_dict(cls, unit_dict):
conf = cls.config_type()
return TestIntentParser2(conf)
register_processing_unit(TestIntentParser1)
register_processing_unit(TestIntentParser2)
mocked_dataset_metadata = {
"language_code": "en",
"entities": {
"mocked_entity": {
"automatically_extensible": True,
"utterances": dict()
}
},
"slot_name_mappings": {
"dummy_intent_1": {
"mocked_slot_name": "mocked_entity"
}
}
}
config = NLUEngineConfig([TestIntentParser1Config(),
TestIntentParser2Config()])
engine = SnipsNLUEngine(config).fit(SAMPLE_DATASET)
# pylint:disable=protected-access
engine._dataset_metadata = mocked_dataset_metadata
# pylint:enable=protected-access
# When
parse = engine.parse(input_text)
# Then
expected_slots = [custom_slot(s) for s in slots]
expected_parse = parsing_result(input_text, intent, expected_slots)
self.assertDictEqual(expected_parse, parse)