rasa-pro 3.14.0.dev3__py3-none-any.whl → 3.14.0.dev5__py3-none-any.whl

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -8,13 +8,6 @@ from typing import Any, Callable, Dict, List, Optional
 import jsonpatch
 import structlog
 
-from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
-    AgentStackFrame,
-    AgentState,
-    FlowStackFrameType,
-    UserFlowStackFrame,
-)
-
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 
@@ -98,42 +91,6 @@ class DialogueStack:
         """
         return self.frames.pop()
 
-    def move_frames_to_top(self, frames_to_move: List["DialogueStackFrame"]) -> None:
-        """Moves specified frames to top of stack while preserving their relative order.
-
-        Args:
-            frames_to_move: The frames to move to the top of the stack.
-        """
-        # Get frames that are not being moved
-        frames_to_keep = [frame for frame in self.frames if frame not in frames_to_move]
-
-        # Reorder: keep frames first, then moved frames
-        self.frames = frames_to_keep + frames_to_move
-
-        # set all frames to interrupt except for LINK and CALL
-        for frame in self.frames:
-            if (
-                isinstance(frame, UserFlowStackFrame)
-                and frame.frame_type == FlowStackFrameType.LINK
-            ):
-                continue
-            if (
-                isinstance(frame, UserFlowStackFrame)
-                and frame.frame_type == FlowStackFrameType.CALL
-            ):
-                continue
-            if (
-                isinstance(frame, UserFlowStackFrame)
-                and frame.frame_type == FlowStackFrameType.REGULAR
-            ):
-                frame.frame_type = FlowStackFrameType.INTERRUPT
-
-        # set the first frame to regular
-        for frame in self.frames:
-            if isinstance(frame, UserFlowStackFrame):
-                frame.frame_type = FlowStackFrameType.REGULAR
-                return
-
     def current_context(self) -> Dict[str, Any]:
         """Returns the context of the topmost frame.
 
@@ -152,7 +109,7 @@ class DialogueStack:
         """Returns the topmost frame from the stack.
 
         Args:
-            ignore: The ID of the flow to ignore. Picks the top most
+            ignore_frame: The ID of the flow to ignore. Picks the top most
                 frame that has a different flow ID.
 
         Returns:
@@ -179,8 +136,7 @@ class DialogueStack:
             patch_dump: The patch to apply to the stack.
 
         Returns:
-        The updated stack.
-        """
+            The updated stack."""
         patch = jsonpatch.JsonPatch.from_string(patch_dump)
         dialogue_stack_dump = patch.apply(self.as_dict())
         return DialogueStack.from_dict(dialogue_stack_dump)
@@ -221,80 +177,3 @@ class DialogueStack:
         if patch:
             return patch.to_string()
         return None
-
-    def _find_agent_frame_by_predicate(
-        self, predicate: Callable[[AgentStackFrame], bool]
-    ) -> List[AgentStackFrame]:
-        stack_frames: List[AgentStackFrame] = []
-        for stack_frame in reversed(self.frames):
-            if isinstance(stack_frame, AgentStackFrame) and predicate(stack_frame):
-                stack_frames.append(stack_frame)
-        return stack_frames
-
-    def find_active_agent_frame(self) -> Optional[AgentStackFrame]:
-        stack_frames = self._find_agent_frame_by_predicate(
-            lambda frame: frame.state == AgentState.WAITING_FOR_INPUT
-        )
-        if stack_frames:
-            return stack_frames[0]
-        return None
-
-    def find_agent_stack_frame_by_agent(
-        self, agent_id: str
-    ) -> Optional[AgentStackFrame]:
-        """Get the agent stack frame for a specific agent ID.
-
-        May also include the agent stack frame in the INTERRUPTED state.
-        """
-        stack_frames = self._find_agent_frame_by_predicate(
-            lambda frame: frame.agent_id == agent_id
-        )
-        if stack_frames:
-            return stack_frames[0]
-        return None
-
-    def find_active_agent_stack_frame_for_flow(
-        self, flow_id: str
-    ) -> Optional[AgentStackFrame]:
-        """Get the agent stack frame of a specific flow."""
-        stack_frames = self._find_agent_frame_by_predicate(
-            lambda frame: frame.flow_id == flow_id
-        )
-        for stack_frame in stack_frames:
-            if stack_frame.state == AgentState.WAITING_FOR_INPUT:
-                return stack_frame
-        return None
-
-    def get_active_agent_id(self) -> Optional[typing.Text]:
-        agent_frame = self.find_active_agent_frame()
-        if agent_frame:
-            return agent_frame.agent_id
-        return None
-
-    def agent_is_active(self) -> bool:
-        return self.find_active_agent_frame() is not None
-
-    def get_all_user_flow_frames(
-        self, ignore_call_and_link_frames: bool = True
-    ) -> List[UserFlowStackFrame]:
-        """Get all user flow frames from the dialogue stack.
-
-        Args:
-            ignore_call_and_link_frames: Whether to ignore user frames of type `call`
-                and `link`. By default, these frames are ignored.
-
-        Returns:
-            A list of all user flow frames in the dialogue stack.
-        """
-        return [
-            frame
-            for frame in self.frames
-            if isinstance(frame, UserFlowStackFrame)
-            and (
-                not ignore_call_and_link_frames
-                or (
-                    frame.frame_type != FlowStackFrameType.CALL
-                    and frame.frame_type != FlowStackFrameType.LINK
-                )
-            )
-        ]

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -94,18 +94,6 @@ class InvalidFlowStepIdException(Exception):
         super().__init__(f"Invalid flow step ID '{step_id}' for flow '{flow_id}'.")
 
 
-class InvalidAgentState(RasaException):
-    """Raised if the agent state is invalid."""
-
-    def __init__(self, invalid_state: str) -> None:
-        """Creates a `InvalidAgentState`.
-
-        Args:
-            invalid_state: The invalid agent state.
-        """
-        super().__init__(f"Invalid agent state '{invalid_state}'.")
-
-
 @dataclass
 class BaseFlowStackFrame(DialogueStackFrame):
     flow_id: str = ""  # needed to avoid "default arg before non-default" error
@@ -183,48 +171,3 @@ class UserFlowStackFrame(BaseFlowStackFrame):
             step_id=data["step_id"],
             frame_type=FlowStackFrameType.from_str(data.get("frame_type")),
         )
-
-
-class AgentState(str, Enum):
-    INTERRUPTED = "interrupted"
-    WAITING_FOR_INPUT = "waiting_for_input"
-
-    @staticmethod
-    def from_str(state: Optional[str]) -> AgentState:
-        if state == AgentState.WAITING_FOR_INPUT.value:
-            return AgentState.WAITING_FOR_INPUT
-        elif state == AgentState.INTERRUPTED.value:
-            return AgentState.INTERRUPTED
-        else:
-            raise InvalidAgentState(state)
-
-
-@dataclass
-class AgentStackFrame(BaseFlowStackFrame):
-    agent_id: str = ""
-    state: AgentState = AgentState.WAITING_FOR_INPUT
-    metadata: Optional[Dict[str, Any]] = None
-
-    @classmethod
-    def type(cls) -> str:
-        """Returns the type of the frame."""
-        return "agent"
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> AgentStackFrame:
-        """Creates a `AgentStackFrame` from a dictionary.
-
-        Args:
-            data: The dictionary to create the `AgentStackFrame` from.
-
-        Returns:
-            The created `AgentStackFrame`.
-        """
-        return AgentStackFrame(
-            frame_id=data["frame_id"],
-            flow_id=data["flow_id"],
-            step_id=data["step_id"],
-            agent_id=data["agent_id"],
-            state=AgentState.from_str(data["state"]),
-            metadata=data.get("metadata"),
-        )

rasa/dialogue_understanding/stack/utils.py

@@ -198,9 +198,8 @@ def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
 def get_collect_steps_excluding_ask_before_filling_for_active_flow(
     dialogue_stack: DialogueStack, all_flows: FlowsList
 ) -> Set[str]:
-    """Get all collect steps that are part of the current flow.
-
-    Collect steps that have to be asked before filling are not considered.
+    """Get all collect steps that are part of the current flow, without
+    considering the collect steps that has to be asked before filling.
 
     Args:
         dialogue_stack: The dialogue stack.
@@ -231,17 +230,3 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         for step in active_flow.get_collect_steps()
         if not step.ask_before_filling
     )
-
-
-def is_continue_interrupted_flow_active(stack: DialogueStack) -> bool:
-    """Check if the continue interrupted flow is active."""
-    from rasa.dialogue_understanding.patterns.continue_interrupted import (
-        ContinueInterruptedPatternFlowStackFrame,
-    )
-
-    for frame in reversed(stack.frames):
-        if isinstance(frame, ContinueInterruptedPatternFlowStackFrame):
-            return True
-        if isinstance(frame, UserFlowStackFrame):
-            return False
-    return False

rasa/dialogue_understanding_test/du_test_runner.py

@@ -1,12 +1,10 @@
 import asyncio
 import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Text
 
 import structlog
 from tqdm import tqdm
 
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.exceptions import AgentNotReady
@@ -54,11 +52,10 @@ class DialogueUnderstandingTestRunner:
 
     def __init__(
         self,
-        model_path: Optional[str] = None,
+        model_path: Optional[Text] = None,
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
-        sub_agents_path: Optional[Union[Path, str]] = None,
     ) -> None:
         """Initializes the Dialogue Understanding test suite runner.
 
@@ -71,7 +68,6 @@ class DialogueUnderstandingTestRunner:
         import rasa.core.agent
 
         self._check_action_server(endpoints)
-        sub_agents = AvailableAgents.get_instance(sub_agents_path)
 
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
@@ -79,7 +75,6 @@ class DialogueUnderstandingTestRunner:
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
-                sub_agents=sub_agents,
             )
         )
         if not self.agent.is_ready():

rasa/e2e_test/e2e_test_runner.py

@@ -13,7 +13,6 @@ import structlog
 from tqdm import tqdm
 
 import rasa.shared.utils.io
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
@@ -66,7 +65,6 @@ class E2ETestRunner:
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
-        sub_agents_path: Optional[Text] = None,
         **kwargs: Any,
     ) -> None:
         """Initializes the E2E test suite runner.
@@ -96,15 +94,12 @@ class E2ETestRunner:
         if endpoints and not are_custom_actions_stubbed:
             self._action_server_is_reachable(endpoints)
 
-        sub_agents = AvailableAgents.get_instance(sub_agents_path)
-
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
                 model_path=model_path,
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
-                sub_agents=sub_agents,
             )
         )
 

rasa/engine/storage/local_model_storage.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 import logging
+import os
 import shutil
 import sys
+import tarfile
 import tempfile
 import uuid
 from contextlib import contextmanager
 from datetime import datetime
 from pathlib import Path
-from typing import Generator, Optional, Text, Tuple, Union
+from typing import Callable, Generator, Optional, Text, Tuple, Union
 
 from tarsafe import TarSafe
 
@@ -57,6 +59,35 @@ def windows_safe_temporary_directory(
             yield temporary_directory
 
 
+def filter_normpath(member: tarfile.TarInfo, dest_path: str) -> tarfile.TarInfo:
+    """Normalize tar member paths for safe extraction"""
+    if member.name:
+        member.name = os.path.normpath(member.name)
+    return member
+
+
+FilterFunction = Callable[[tarfile.TarInfo, str], Optional[tarfile.TarInfo]]
+
+
+def create_combined_filter(existing_filter: Optional[FilterFunction]) -> FilterFunction:
+    """Create a filter that combines existing filter with path normalization"""
+
+    def combined_filter(
+        member: tarfile.TarInfo, dest_path: str
+    ) -> Optional[tarfile.TarInfo]:
+        """Apply existing filter first, then path normalization"""
+        if existing_filter is not None:
+            filtered_member = existing_filter(member, dest_path)
+            if filtered_member is None:
+                return None  # Rejected by existing filter
+            member = filtered_member  # Use the filtered result
+
+        # Apply our path normalization
+        return filter_normpath(member, dest_path)
+
+    return combined_filter
+
+
 class LocalModelStorage(ModelStorage):
     """Stores and provides output of `GraphComponents` on local disk."""
 
@@ -122,7 +153,19 @@ class LocalModelStorage(ModelStorage):
                 # this restriction in environments where it's not possible
                 # to override this behavior, mostly for internal policy reasons
                 # reference: https://stackoverflow.com/a/49102229
-                tar.extractall(f"\\\\?\\{temporary_directory}")
+                try:
+                    # Use extraction filter to normalize paths for compatibility
+                    # before trying the \\?\ prefix approach first
+                    prev_filter = getattr(tar, "extraction_filter", None)
+                    tar.extraction_filter = create_combined_filter(prev_filter)
+                    tar.extractall(f"\\\\?\\{temporary_directory}")
+                except Exception:
+                    # Fallback for Python versions with tarfile security fix
+                    logger.warning(
+                        "Failed to extract model archive with long path support. "
+                        "Falling back to regular extraction."
+                    )
+                    tar.extractall(temporary_directory)
             else:
                 tar.extractall(temporary_directory)
         LocalModelStorage._assert_not_rasa2_archive(temporary_directory)

rasa/model_manager/model_api.py

@@ -39,11 +39,9 @@ from rasa.model_manager.trainer_service import (
     update_training_status,
 )
 from rasa.model_manager.utils import (
-    InvalidPathException,
     get_logs_content,
     logs_base_path,
     models_base_path,
-    subpath,
 )
 from rasa.model_manager.warm_rasa_process import (
     initialize_warm_rasa_process,
@@ -53,6 +51,7 @@ from rasa.server import ErrorResponse
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.yaml import dump_obj_as_yaml_to_string
 from rasa.studio.upload import build_calm_import_parts
+from rasa.utils.io import InvalidPathException, subpath
 
 dotenv.load_dotenv()
 
@@ -571,10 +570,10 @@ def external_blueprint() -> Blueprint:
     """Create a blueprint for the model manager API."""
     from rasa.core.channels.socketio import SocketBlueprint
 
-    sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
-    bp = SocketBlueprint(sio, "", "model_api_external")
+    sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
+    bp = SocketBlueprint(sio_server, "", "model_api_external")
 
-    create_bridge_server(sio, running_bots)
+    create_bridge_server(sio_server, running_bots)
 
     @bp.get("/health")
     async def health(request: Request) -> response.HTTPResponse:

rasa/model_manager/runner_service.py

@@ -15,11 +15,11 @@ from rasa.model_manager import config
 from rasa.model_manager.utils import (
     logs_path,
     models_base_path,
-    subpath,
     write_encoded_data_to_file,
 )
 from rasa.model_manager.warm_rasa_process import start_rasa_process
 from rasa.studio.prompts import handle_prompts
+from rasa.utils.io import subpath
 
 structlogger = structlog.get_logger()
 

rasa/model_manager/socket_bridge.py

@@ -19,7 +19,7 @@ socket_proxy_clients = {}
 
 
 async def socketio_websocket_traffic_wrapper(
-    sio: AsyncServer,
+    sio_server: AsyncServer,
     running_bots: Dict[str, BotSession],
     sid: str,
     auth: Optional[Dict],
@@ -55,7 +55,9 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error("model_runner.bot_not_alive", deployment_id=deployment_id)
         raise ConnectionRefusedError("model_runner.bot_not_alive")
 
-    client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
+    client = await create_bridge_client(
+        sio_server, bot.internal_url, sid, deployment_id
+    )
 
     if client.sid is not None:
         structlogger.debug(
@@ -70,20 +72,24 @@ async def socketio_websocket_traffic_wrapper(
         raise ConnectionRefusedError("model_runner.bot_connection_failed")
 
 
-def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession]) -> None:
+def create_bridge_server(
+    sio_server: AsyncServer, running_bots: Dict[str, BotSession]
+) -> None:
     """Create handlers for the socket server side.
 
     Forwards messages coming from the user to the bot.
     """
 
-    @sio.on("connect")
+    @sio_server.on("connect")
     async def socketio_websocket_traffic(
         sid: str, environ: Dict, auth: Optional[Dict]
     ) -> bool:
         """Bridge websockets between user chat socket and bot server."""
-        return await socketio_websocket_traffic_wrapper(sio, running_bots, sid, auth)
+        return await socketio_websocket_traffic_wrapper(
+            sio_server, running_bots, sid, auth
+        )
 
-    @sio.on("disconnect")
+    @sio_server.on("disconnect")
     async def disconnect(sid: str) -> None:
         """Disconnect the bot connection."""
         structlogger.debug("model_runner.bot_disconnect", sid=sid)
@@ -91,7 +97,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
             await socket_proxy_clients[sid].disconnect()
             del socket_proxy_clients[sid]
 
-    @sio.on("*")
+    @sio_server.on("*")
     async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
         """Bridge messages between user and bot.
 
@@ -108,7 +114,7 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
 
 
 async def create_bridge_client(
-    sio: AsyncServer, url: str, sid: str, deployment_id: str
+    sio_server: AsyncServer, url: str, sid: str, deployment_id: str
 ) -> AsyncClient:
     """Create a new socket bridge client.
 
@@ -123,36 +129,36 @@ async def create_bridge_client(
         structlogger.debug(
             "model_runner.bot_session_confirmed", deployment_id=deployment_id
         )
-        await sio.emit("session_confirm", room=sid)
+        await sio_server.emit("session_confirm", room=sid)
 
     @client.event  # type: ignore[misc]
     async def bot_message(data: Dict[str, Any]) -> None:
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
-        await sio.emit("bot_message", data, room=sid)
+        await sio_server.emit("bot_message", data, room=sid)
 
     @client.event  # type: ignore[misc]
     async def error(data: Dict[str, Any]) -> None:
         structlogger.debug(
             "model_runner.bot_error", deployment_id=deployment_id, data=data
         )
-        await sio.emit("error", data, room=sid)
+        await sio_server.emit("error", data, room=sid)
 
     @client.event  # type: ignore[misc]
     async def tracker(data: Dict[str, Any]) -> None:
-        await sio.emit("tracker", json.loads(data), room=sid)
+        await sio_server.emit("tracker", json.loads(data), room=sid)
 
     @client.event  # type: ignore[misc]
     async def disconnect() -> None:
         structlogger.debug(
             "model_runner.bot_connection_closed", deployment_id=deployment_id
         )
-        await sio.emit("disconnect", room=sid)
+        await sio_server.emit("disconnect", room=sid)
 
     @client.event  # type: ignore[misc]
     async def connect_error() -> None:
         structlogger.error(
             "model_runner.bot_connection_error", deployment_id=deployment_id
         )
-        await sio.emit("disconnect", room=sid)
+        await sio_server.emit("disconnect", room=sid)
 
     return client

rasa/model_manager/trainer_service.py

@@ -14,7 +14,6 @@ from rasa.model_manager.utils import (
     ensure_base_directory_exists,
     logs_path,
     models_base_path,
-    subpath,
     write_encoded_data_to_file,
 )
 from rasa.model_manager.warm_rasa_process import (
@@ -22,6 +21,7 @@ from rasa.model_manager.warm_rasa_process import (
 )
 from rasa.model_training import generate_random_model_name
 from rasa.studio.prompts import handle_prompts
+from rasa.utils.io import subpath
 
 structlogger = structlog.get_logger()
 
@@ -53,6 +53,15 @@ class TrainingSession(BaseModel):
         """Check if the training is running."""
         return self.status == TrainingSessionStatus.RUNNING
 
+    def has_just_finished(self) -> bool:
+        if not self.is_status_indicating_alive():
+            # skip if the training is not running
+            return False
+        if self.process.poll() is None:
+            # process is still running
+            return False
+        return True
+
     def model_path(self) -> str:
         """Return the path to the model."""
         return subpath(models_base_path(), f"{self.model_name}.tar.gz")
@@ -89,14 +98,8 @@ def terminate_training(training: TrainingSession) -> None:
 
 
 def update_training_status(training: TrainingSession) -> None:
-    if not training.is_status_indicating_alive():
-        # skip if the training is not running
-        return
-    if training.process.poll() is None:
-        # process is still running
-        return
-
-    complete_training(training)
+    if training.has_just_finished():
+        complete_training(training)
 
 
 def complete_training(training: TrainingSession) -> None:

rasa/model_manager/utils.py

@@ -5,15 +5,11 @@ from typing import Optional
 import structlog
 
 from rasa.model_manager import config
-from rasa.shared.exceptions import RasaException
+from rasa.utils.io import subpath
 
 structlogger = structlog.get_logger()
 
 
-class InvalidPathException(RasaException):
-    """Raised if a path is invalid - e.g. path traversal is detected."""
-
-
 def write_encoded_data_to_file(encoded_data: bytes, file: str) -> None:
     """Write base64 encoded data to a file."""
     # create the directory if it does not exist of the parent directory
@@ -53,30 +49,6 @@ def logs_path(action_id: str) -> str:
     return subpath(logs_base_path(), f"{action_id}.txt")
 
 
-def subpath(parent: str, child: str) -> str:
-    """Return the path to the child directory of the parent directory.
-
-    Ensures, that child doesn't navigate to parent directories. Prevents
-    path traversal. Raises an InvalidPathException if the path is invalid.
-
-    Based on Snyk's directory traversal mitigation:
-    https://learn.snyk.io/lesson/directory-traversal/
-    """
-    safe_path = os.path.abspath(os.path.join(parent, child))
-    parent = os.path.abspath(parent)
-
-    common_base = os.path.commonpath([parent, safe_path])
-    if common_base != parent:
-        raise InvalidPathException(f"Invalid path: {safe_path}")
-
-    if os.path.basename(safe_path) != child:
-        raise InvalidPathException(
-            f"Invalid path - path traversal detected: {safe_path}"
-        )
-
-    return safe_path
-
-
 def get_logs_content(action_id: str) -> Optional[str]:
     """Return the content of the log file for a given action id."""
     try: