def collect_slots(slot_dict: Dict[Text, Any]) -> List[Slot]: # it is super important to sort the slots here!!! # otherwise state ordering is not consistent slots = [] for slot_name in sorted(slot_dict): slot_class = Slot.resolve_by_type(slot_dict[slot_name].get("type")) if "type" in slot_dict[slot_name]: del slot_dict[slot_name]["type"] slot = slot_class(slot_name, **slot_dict[slot_name]) slots.append(slot) return slots
async def run( self, output_channel: "OutputChannel", nlg: "NaturalLanguageGenerator", tracker: "DialogueStateTracker", domain: "Domain", ) -> List[Event]: # attempt retrieving spec if not len(self.form_spec): for form in tracker.slots.get( "bf_forms", Slot("bf_forms", initial_value=[])).initial_value: if form.get("name") == self.name(): self.form_spec = clean_none_values(form) if not len(self.form_spec): logger.debug( f"Could not retrieve form '{tracker.active_form}', there is something wrong with your domain." ) return [Form(None)] # activate the form events = await self._activate_if_required(output_channel, nlg, tracker, domain) # validate user input events.extend(await self._validate_if_required(output_channel, nlg, tracker, domain)) # check that the form wasn't deactivated in validation if Form(None) not in events: # create temp tracker with populated slots from `validate` method temp_tracker = tracker.copy() temp_tracker.sender_id = ( tracker.sender_id) # copy() doesn't necessarily copy sender_id for e in events: if isinstance(e, SlotSet): temp_tracker.slots[e.key].value = e.value next_slot_events = await self.request_next_slot( output_channel, nlg, temp_tracker, domain) if next_slot_events is not None: # request next slot events.extend(next_slot_events) else: # there is nothing more to request, so we can submit self._log_form_slots(temp_tracker) logger.debug(f"Submitting the form '{self.name()}'") events.extend(await self.submit(output_channel, nlg, temp_tracker, domain)) # deactivate the form after submission events.extend(self.deactivate()) return events
async def test_parsing_with_tracker(): tracker = DialogueStateTracker.from_dict("1", [], [Slot("requested_language")]) # we'll expect this value 'en' to be part of the result from the interpreter tracker._set_slot("requested_language", "en") endpoint = EndpointConfig("https://interpreter.com") with aioresponses() as mocked: mocked.post("https://interpreter.com/parse", repeat=True, status=200) # mock the parse function with the one defined for this test with patch.object(RasaNLUHttpInterpreter, "parse", mocked_parse): interpreter = RasaNLUHttpInterpreter(endpoint_config=endpoint) agent = Agent(None, None, interpreter) result = await agent.parse_message_using_nlu_interpreter("lunch?", tracker) assert result["requested_language"] == "en"
def cleaned_domain(self) -> Dict[Text, Any]: """Fetch cleaned domain to display or write into a file. The internal `used_entities` property is replaced by `use_entities` or `ignore_entities` and redundant keys are replaced with default values to make the domain easier readable. Returns: A cleaned dictionary version of the domain. """ domain_data = self.as_dict() for idx, intent_info in enumerate(domain_data["intents"]): for name, intent in intent_info.items(): if intent.get(USE_ENTITIES_KEY) is True: del intent[USE_ENTITIES_KEY] if not intent.get(IGNORE_ENTITIES_KEY): intent.pop(IGNORE_ENTITIES_KEY, None) if len(intent) == 0: domain_data["intents"][idx] = name for slot in domain_data["slots"].values(): # pytype: disable=attribute-error if slot["initial_value"] is None: del slot["initial_value"] if slot["auto_fill"]: del slot["auto_fill"] if slot["type"].startswith("rasa.core.slots"): slot["type"] = Slot.resolve_by_type(slot["type"]).type_name if domain_data["config"]["store_entities_as_slots"]: del domain_data["config"]["store_entities_as_slots"] # clean empty keys return { k: v for k, v in domain_data.items() if v != {} and v != [] and v is not None }
def __missing__(self, key): value = self[key] = Slot(key) return value
def test_has_a_type_name(self): slot = self.create_slot() assert slot.type_name is not None assert type(slot) == Slot.resolve_by_type(slot.type_name)