rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0.dev13__py3-none-any.whl

rasa/cli/inspect.py

@@ -9,6 +9,10 @@ from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
+from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.exceptions import ModelNotFound
+from rasa.model import get_local_model
+from rasa.shared.utils.cli import print_error
 from rasa.utils.cli import remove_argument_from_parser
 
 
@@ -55,6 +59,8 @@ async def open_inspector_in_browser(server_url: Text, voice: bool = False) -> No
 def inspect(args: argparse.Namespace) -> None:
     """Inspect the bot using the most recent model."""
     import rasa.cli.run
+    from rasa.cli.utils import get_validated_path
+    from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     async def after_start_hook_open_inspector(_: Sanic, __: AbstractEventLoop) -> None:
         """Hook to open the browser on server start."""
@@ -71,5 +77,18 @@ def inspect(args: argparse.Namespace) -> None:
     args.credentials = None
     args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
 
-    telemetry.track_inspect_started(args.connector)
+    model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
+
+    try:
+        model = get_local_model(model)
+    except ModelNotFound:
+        print_error(
+            "No model found. Train a model before running the "
+            "server using `rasa train`."
+        )
+        return
+
+    metadata = LocalModelStorage.metadata_from_archive(model)
+
+    telemetry.track_inspect_started(args.connector, metadata.assistant_id)
     rasa.cli.run.run(args)

rasa/cli/shell.py

@@ -95,7 +95,7 @@ def shell_nlu(args: argparse.Namespace) -> None:
         )
         return
 
-    telemetry.track_shell_started("nlu")
+    telemetry.track_shell_started("nlu", metadata.assistant_id)
     rasa.nlu.run.run_cmdline(model)
 
 
@@ -129,12 +129,12 @@ def shell(args: argparse.Namespace) -> None:
     if metadata.training_type == TrainingType.NLU:
         import rasa.nlu.run
 
-        telemetry.track_shell_started("nlu")
+        telemetry.track_shell_started("nlu", metadata.assistant_id)
 
         rasa.nlu.run.run_cmdline(model)
     else:
         import rasa.cli.run
 
-        telemetry.track_shell_started("rasa")
+        telemetry.track_shell_started("rasa", metadata.assistant_id)
 
         rasa.cli.run.run(args)

rasa/core/actions/action.py

@@ -73,9 +73,9 @@ from rasa.shared.core.constants import (
     ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_TYPE,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
+    SetSlotExtractor,
     SlotMappingType,
 )
 from rasa.shared.core.domain import Domain
@@ -111,6 +111,7 @@ if TYPE_CHECKING:
     from rasa.core.channels.channel import OutputChannel
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
+    from rasa.shared.core.slot_mappings import SlotMapping
 
 logger = logging.getLogger(__name__)
 
@@ -118,6 +119,10 @@ logger = logging.getLogger(__name__)
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
     from rasa.core.actions.action_clean_stack import ActionCleanStack
+    from rasa.core.actions.action_handle_digressions import (
+        ActionBlockDigressions,
+        ActionContinueDigression,
+    )
     from rasa.core.actions.action_hangup import ActionHangup
     from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
@@ -152,6 +157,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
+        ActionBlockDigressions(),
+        ActionContinueDigression(),
     ]
 
 
@@ -940,7 +947,14 @@ class RemoteAction(Action):
         )
 
         events = rasa.shared.core.events.deserialise_events(events_json)
-        return cast(List[Event], bot_messages) + events
+
+        processed_events = []
+        for event in events:
+            if isinstance(event, SlotSet) and event.filled_by is None:
+                event.filled_by = SetSlotExtractor.CUSTOM.value
+            processed_events.append(event)
+
+        return cast(List[Event], bot_messages) + processed_events
 
     def name(self) -> Text:
         return self._name
@@ -1208,7 +1222,7 @@ class ActionExtractSlots(Action):
 
     async def _execute_custom_action(
         self,
-        mapping: Dict[Text, Any],
+        mapping: "SlotMapping",
         executed_custom_actions: Set[Text],
         output_channel: "OutputChannel",
         nlg: "NaturalLanguageGenerator",
@@ -1216,7 +1230,7 @@ class ActionExtractSlots(Action):
         domain: "Domain",
         calm_custom_action_names: Optional[Set[str]] = None,
     ) -> Tuple[List[Event], Set[Text]]:
-        custom_action = mapping.get("action")
+        custom_action = mapping.run_action_every_turn
 
         if not custom_action or custom_action in executed_custom_actions:
             return [], executed_custom_actions
@@ -1317,10 +1331,9 @@ class ActionExtractSlots(Action):
                 slot_events.append(SlotSet(slot.name, slot_value))
 
             for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
-                should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
+                should_fill_controlled_slot = mapping.type == SlotMappingType.CONTROLLED
 
-                if should_fill_custom_slot:
+                if should_fill_controlled_slot:
                     (
                         custom_evts,
                         executed_custom_actions,

rasa/core/actions/action_handle_digressions.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import structlog
+
+from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.core.utils import add_bot_utterance_metadata
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.handle_digressions import (
+    HandleDigressionsPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.shared.core.constants import (
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+class ActionBlockDigressions(Action):
+    """Action which blocks an interruption and continues the current flow."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_BLOCK_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_block_digressions.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.REGULAR
+
+        stack = tracker.stack
+        stack.push(
+            UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type), 0
+        )
+        stack.push(
+            ContinueInterruptedPatternFlowStackFrame(
+                previous_flow_name=blocked_flow_id
+            ),
+            1,
+        )
+        events = tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_block_digressions"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_block_digressions.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events
+
+
+class ActionContinueDigression(Action):
+    """Action which continues with an interruption."""
+
+    def name(self) -> str:
+        """Return the action name."""
+        return ACTION_CONTINUE_DIGRESSION
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Update the stack."""
+        structlogger.debug("action_continue_digression.run")
+        top_frame = tracker.stack.top()
+
+        if not isinstance(top_frame, HandleDigressionsPatternFlowStackFrame):
+            return []
+
+        blocked_flow_id = top_frame.interrupting_flow_id
+        frame_type = FlowStackFrameType.INTERRUPT
+        stack = tracker.stack
+        stack.push(UserFlowStackFrame(flow_id=blocked_flow_id, frame_type=frame_type))
+
+        events = [
+            FlowInterrupted(
+                flow_id=top_frame.interrupted_flow_id,
+                step_id=top_frame.interrupted_step_id,
+            )
+        ] + tracker.create_stack_updated_events(stack)
+
+        utterance = "utter_continue_interruption"
+        message = await nlg.generate(
+            utterance,
+            tracker,
+            output_channel.name(),
+        )
+
+        if message is None:
+            structlogger.error(
+                "action_continue_digression.run.failed.finding.utter",
+                utterance=utterance,
+            )
+        else:
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
+            events.append(create_bot_utterance(message))
+
+        return events

rasa/core/actions/forms.py

@@ -2,7 +2,7 @@ import copy
 import itertools
 import json
 import logging
-from typing import Any, Dict, List, Optional, Set, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
 
@@ -16,7 +16,7 @@ from rasa.shared.constants import UTTER_PREFIX
 from rasa.shared.core.constants import (
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
-    MAPPING_TYPE,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -35,6 +35,9 @@ from rasa.shared.core.slots import ListSlot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
 
+if TYPE_CHECKING:
+    from rasa.shared.core.slot_mappings import SlotMapping
+
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
@@ -158,7 +161,9 @@ class FormAction(LoopAction):
         domain_slots = domain.as_dict().get(KEY_SLOTS, {})
         for slot in domain.required_slots_for_form(self.name()):
             for slot_mapping in domain_slots.get(slot, {}).get(SLOT_MAPPINGS, []):
-                if slot_mapping.get(MAPPING_TYPE) == str(SlotMappingType.FROM_ENTITY):
+                if slot_mapping.get(KEY_MAPPING_TYPE) == str(
+                    SlotMappingType.FROM_ENTITY
+                ):
                     mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
                     if mapping_as_string in unique_entity_slot_mappings:
                         unique_entity_slot_mappings.remove(mapping_as_string)
@@ -169,7 +174,7 @@ class FormAction(LoopAction):
         return unique_entity_slot_mappings
 
     def entity_mapping_is_unique(
-        self, slot_mapping: Dict[Text, Any], domain: Domain
+        self, slot_mapping: "SlotMapping", domain: Domain
     ) -> bool:
         """Verifies if the from_entity mapping is unique."""
         if not self._have_unique_entity_mappings_been_initialized:
@@ -177,7 +182,7 @@ class FormAction(LoopAction):
             self._unique_entity_mappings = self._create_unique_entity_mappings(domain)
             self._have_unique_entity_mappings_been_initialized = True
 
-        mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
+        mapping_as_string = json.dumps(slot_mapping.as_dict(), sort_keys=True)
         return mapping_as_string in self._unique_entity_mappings
 
     @staticmethod

rasa/core/channels/__init__.py

@@ -32,6 +32,7 @@ from rasa.core.channels.vier_cvg import CVGInput
 from rasa.core.channels.voice_stream.twilio_media_streams import (
     TwilioMediaStreamsInputChannel,
 )
+from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 
 input_channel_classes: List[Type[InputChannel]] = [
@@ -55,6 +56,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     JambonzVoiceReadyInput,
     TwilioMediaStreamsInputChannel,
     BrowserAudioInputChannel,
+    GenesysInputChannel,
     StudioChatInput,
 ]
 

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,9 +1,11 @@
+import asyncio
 import copy
 import json
 import uuid
+from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -223,6 +225,16 @@ class AudiocodesInput(InputChannel):
         self.scheduler_job = None
         self.keep_alive = keep_alive
         self.keep_alive_expiration_factor = keep_alive_expiration_factor
+        self.background_tasks: Dict[Text, Set[asyncio.Task]] = defaultdict(set)
+
+    def _create_task(self, conversation_id: Text, coro: Awaitable[Any]) -> asyncio.Task:
+        """Create and track an asyncio task for a conversation."""
+        task: asyncio.Task = asyncio.create_task(coro)
+        self.background_tasks[conversation_id].add(task)
+        task.add_done_callback(
+            lambda t: self.background_tasks[conversation_id].discard(t)
+        )
+        return task
 
     async def _set_scheduler_job(self) -> None:
         if self.scheduler_job:
@@ -251,11 +263,20 @@ class AudiocodesInput(InputChannel):
         )
         now = datetime.now(timezone.utc)
         delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
-        self.conversations = {
-            k: v
-            for k, v in self.conversations.items()
-            if v.is_active_conversation(now, delta)
-        }
+
+        # clean up conversations
+        inactive = [
+            conv_id
+            for conv_id, conv in self.conversations.items()
+            if not conv.is_active_conversation(now, delta)
+        ]
+
+        # cancel tasks and remove conversations
+        for conv_id in inactive:
+            for task in self.background_tasks[conv_id]:
+                task.cancel()
+            self.background_tasks.pop(conv_id, None)
+            self.conversations.pop(conv_id, None)
 
     def handle_start_conversation(self, body: Dict[Text, Any]) -> Dict[Text, Any]:
         conversation_id = body["conversation"]
@@ -347,31 +368,29 @@ class AudiocodesInput(InputChannel):
             structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
+                structlogger.warning(
+                    "audiocodes.on_activities.no_conversation", request=request.json
+                )
                 return response.json({})
             elif conversation.ws:
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json({})
+                response_json = {}
             else:
                 # handle non websocket case where messages get returned in json
                 ac_output = AudiocodesOutput()
-                await conversation.handle_activities(
-                    request.json,
-                    output_channel=ac_output,
-                    on_new_message=on_new_message,
-                )
-                return response.json(
-                    {
-                        "conversation": conversation_id,
-                        "activities": ac_output.messages,
-                    }
-                )
+                response_json = {
+                    "conversation": conversation_id,
+                    "activities": ac_output.messages,
+                }
+
+            # start a background task to handle activities
+            self._create_task(
+                conversation_id,
+                conversation.handle_activities(request.json, ac_output, on_new_message),
+            )
+            return response.json(response_json)
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/core/channels/voice_stream/browser_audio.py

@@ -65,6 +65,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if "audio" in data:

rasa/core/channels/voice_stream/call_state.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextvars import ContextVar
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 from werkzeug.local import LocalProxy
@@ -19,6 +19,12 @@ class CallState:
     should_hangup: bool = False
     connection_failed: bool = False
 
+    # Genesys requires the server and client each maintain a
+    # monotonically increasing message sequence number.
+    client_sequence_number: int = 0
+    server_sequence_number: int = 0
+    audio_buffer: bytearray = field(default_factory=bytearray)
+
 
 _call_state: ContextVar[CallState] = ContextVar("call_state")
 call_state = LocalProxy(_call_state)