Extract slots with mapping conditions during form activation

changelog/11149.bugfix.md

@@ -0,0 +1 @@
+Fix the extraction of values for slots with mapping conditions from trigger intents that activate a form, which was possible in `2.x`.

rasa/core/actions/forms.py

@@ -11,6 +11,7 @@
 
 from rasa.core.actions.action import ActionExecutionRejection, RemoteAction
 from rasa.shared.core.constants import (
+    ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
     REQUESTED_SLOT,
     LOOP_INTERRUPTED,
@@ -566,9 +567,10 @@ async def activate(
     ) -> List[Event]:
         """Activate form if the form is called for the first time.
 
-        If activating, validate any required slots that were filled before
-        form activation and return `Form` event with the name of the form, as well
-        as any `SlotSet` events from validation of pre-filled slots.
+        If activating, run action_extract_slots to fill slots with
+        mapping conditions from trigger intents.
+        Validate any required slots that can be filled, and return any `SlotSet`
+        events from the extraction and validation of these pre-filled slots.
 
         Args:
             output_channel: The output channel which can be used to send messages
@@ -584,6 +586,26 @@ async def activate(
         # collect values of required slots filled before activation
         prefilled_slots = {}
 
+        action_extract_slots = action.action_for_name_or_text(
+            ACTION_EXTRACT_SLOTS, domain, self.action_endpoint
+        )
+
+        logger.debug(
+            f"Executing default action '{ACTION_EXTRACT_SLOTS}' at form activation."
+        )
+
+        extraction_events = await action_extract_slots.run(
+            output_channel, nlg, tracker, domain
+        )
+
+        events_as_str = "\n".join(str(e) for e in extraction_events)
+        logger.debug(
+            f"The execution of '{ACTION_EXTRACT_SLOTS}' resulted in "
+            f"these events: {events_as_str}."
+        )
+
+        tracker.update_with_events(extraction_events, domain)
+
         for slot_name in self.required_slots(domain):
             if not self._should_request_slot(tracker, slot_name):
                 prefilled_slots[slot_name] = tracker.get_slot(slot_name)
@@ -593,10 +615,21 @@ async def activate(
             return []
 
         logger.debug(f"Validating pre-filled required slots: {prefilled_slots}")
-        return await self.validate_slots(
+
+        validated_events = await self.validate_slots(
             prefilled_slots, tracker, domain, output_channel, nlg
         )
 
+        validated_slot_names = [
+            event.key for event in validated_events if isinstance(event, SlotSet)
+        ]
+
+        return validated_events + [
+            event
+            for event in extraction_events
+            if isinstance(event, SlotSet) and event.key not in validated_slot_names
+        ]
+
     async def do(
         self,
         output_channel: "OutputChannel",
@@ -605,6 +638,7 @@ async def do(
         domain: "Domain",
         events_so_far: List[Event],
     ) -> List[Event]:
+        """Executes form loop after activation."""
         events = await self._validate_if_required(tracker, domain, output_channel, nlg)
 
         if not self._user_rejected_manually(events):
@@ -656,3 +690,18 @@ async def deactivate(self, *args: Any, **kwargs: Any) -> List[Event]:
         """Deactivates form."""
         logger.debug(f"Deactivating the form '{self.name()}'")
         return []
+
+    async def _activate_loop(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+    ) -> List[Event]:
+        events = self._default_activation_events()
+
+        temp_tracker = tracker.copy()
+        temp_tracker.update_with_events(events, domain)
+        events += await self.activate(output_channel, nlg, temp_tracker, domain)
+
+        return events

rasa/core/actions/loops.py

@@ -19,11 +19,15 @@ async def run(
         tracker: "DialogueStateTracker",
         domain: "Domain",
     ) -> List[Event]:
-        events = []
+        events: List[Event] = []
 
         if not await self.is_activated(output_channel, nlg, tracker, domain):
-            events += self._default_activation_events()
-            events += await self.activate(output_channel, nlg, tracker, domain)
+            events += await self._activate_loop(
+                output_channel,
+                nlg,
+                tracker,
+                domain,
+            )
 
         if not await self.is_done(output_channel, nlg, tracker, domain, events):
             events += await self.do(output_channel, nlg, tracker, domain, events)
@@ -92,3 +96,15 @@ async def deactivate(
     ) -> List[Event]:
         # can be overwritten
         return []
+
+    async def _activate_loop(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+    ) -> List[Event]:
+        events = self._default_activation_events()
+        events += await self.activate(output_channel, nlg, tracker, domain)
+
+        return events

tests/core/actions/test_forms.py

@@ -40,21 +40,59 @@ async def test_activate():
     form_name = "my form"
     action = FormAction(form_name, None)
     slot_name = "num_people"
-    domain = f"""
-slots:
-  {slot_name}:
-    type: float
-    mappings:
-    - type: from_entity
-      entity: number
-forms:
-  {form_name}:
-    {REQUIRED_SLOTS_KEY}:
+    domain = textwrap.dedent(
+        f"""
+    slots:
+      {slot_name}:
+        type: float
+        mappings:
+        - type: from_entity
+          entity: number
+    forms:
+      {form_name}:
+        {REQUIRED_SLOTS_KEY}:
         - {slot_name}
-responses:
-    utter_ask_num_people:
-    - text: "How many people?"
-"""
+    responses:
+      utter_ask_num_people:
+      - text: "How many people?"
+      """
+    )
+    domain = Domain.from_yaml(domain)
+
+    events = await action.run(
+        CollectingOutputChannel(),
+        TemplatedNaturalLanguageGenerator(domain.responses),
+        tracker,
+        domain,
+    )
+    assert events[:-1] == [ActiveLoop(form_name), SlotSet(REQUESTED_SLOT, slot_name)]
+    assert isinstance(events[-1], BotUttered)
+
+
+async def test_activate_with_mapping_conditions_slot():
+    tracker = DialogueStateTracker.from_events(sender_id="bla", evts=[])
+    form_name = "my form"
+    action = FormAction(form_name, None)
+    slot_name = "num_people"
+    domain = textwrap.dedent(
+        f"""
+    slots:
+      {slot_name}:
+        type: float
+        mappings:
+        - type: from_entity
+          entity: number
+          conditions:
+          - active_loop: {form_name}
+    forms:
+      {form_name}:
+        {REQUIRED_SLOTS_KEY}:
+        - {slot_name}
+    responses:
+      utter_ask_num_people:
+      - text: "How many people?"
+      """
+    )
     domain = Domain.from_yaml(domain)
 
     events = await action.run(
@@ -108,6 +146,51 @@ async def test_activate_with_prefilled_slot():
     ]
 
 
+async def test_activate_with_prefilled_slot_with_mapping_conditions():
+    slot_name = "num_people"
+    slot_value = 5
+
+    tracker = DialogueStateTracker.from_events(
+        sender_id="bla", evts=[SlotSet(slot_name, slot_value)]
+    )
+    form_name = "my form"
+    action = FormAction(form_name, None)
+
+    next_slot_to_request = "next slot to request"
+    domain = f"""
+    forms:
+      {form_name}:
+        {REQUIRED_SLOTS_KEY}:
+            - {slot_name}
+            - {next_slot_to_request}
+    slots:
+      {slot_name}:
+        type: any
+        mappings:
+        - type: from_entity
+          entity: {slot_name}
+          conditions:
+          - active_loop: {form_name}
+      {next_slot_to_request}:
+        type: text
+        mappings:
+        - type: from_text
+          conditions:
+          - active_loop: {form_name}
+    """
+    domain = Domain.from_yaml(domain)
+    events = await action.run(
+        CollectingOutputChannel(),
+        TemplatedNaturalLanguageGenerator(domain.responses),
+        tracker,
+        domain,
+    )
+    assert events == [
+        ActiveLoop(form_name),
+        SlotSet(REQUESTED_SLOT, next_slot_to_request),
+    ]
+
+
 async def test_switch_forms_with_same_slot(default_agent: Agent):
     """Tests switching of forms, where the first slot is the same in both forms.
 
@@ -676,9 +759,9 @@ async def test_validate_slots_on_activation_with_other_action_after_user_utteran
         )
         tracker.update_with_events(slot_events, domain)
 
-        action = FormAction(form_name, action_server)
+        form_action = FormAction(form_name, action_server)
 
-        events = await action.run(
+        events = await form_action.run(
             CollectingOutputChannel(),
             TemplatedNaturalLanguageGenerator(domain.responses),
             tracker,
@@ -1671,3 +1754,68 @@ async def test_form_slots_empty_with_restart():
             tracker,
             domain,
         )
+
+
+async def test_extract_slots_with_mapping_conditions_during_form_activation():
+    slot_name = "city"
+    entity_value = "London"
+    entity_name = "location"
+
+    form_name = "test_form"
+
+    domain = Domain.from_yaml(
+        f"""
+    entities:
+    - {entity_name}
+    slots:
+      {slot_name}:
+        type: text
+        mappings:
+        - type: from_entity
+          entity: {entity_name}
+          conditions:
+          - active_loop: {form_name}
+    forms:
+      {form_name}:
+        {REQUIRED_SLOTS_KEY}:
+            - {slot_name}
+    """
+    )
+
+    events = [
+        ActionExecuted("action_listen"),
+        UserUttered(
+            "I live in London",
+            entities=[{"entity": entity_name, "value": entity_value}],
+        ),
+    ]
+    tracker = DialogueStateTracker.from_events(
+        sender_id="test", evts=events, domain=domain, slots=domain.slots
+    )
+    assert tracker.active_loop_name is None
+
+    action_extract_slots = ActionExtractSlots(None)
+    events = await action_extract_slots.run(
+        CollectingOutputChannel(),
+        TemplatedNaturalLanguageGenerator(domain.responses),
+        tracker,
+        domain,
+    )
+    assert events == []
+
+    expected_events = [
+        ActiveLoop(form_name),
+        SlotSet(slot_name, entity_value),
+        SlotSet(REQUESTED_SLOT, None),
+        ActiveLoop(None),
+    ]
+
+    form_action = FormAction(form_name, None)
+    form_events = await form_action.run(
+        CollectingOutputChannel(),
+        TemplatedNaturalLanguageGenerator(domain.responses),
+        tracker,
+        domain,
+    )
+
+    assert form_events == expected_events