rasa-pro 3.12.6.dev2__py3-none-any.whl → 3.13.0.dev2__py3-none-any.whl

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-import structlog
-
-from rasa.dialogue_understanding.commands.command import Command
-from rasa.dialogue_understanding.patterns.cannot_handle import (
-    CannotHandlePatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.patterns.handle_digressions import (
-    HandleDigressionsPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.utils import (
-    top_flow_frame,
-)
-from rasa.shared.core.events import Event
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.steps import CollectInformationFlowStep
-from rasa.shared.core.flows.utils import ALL_LABEL
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.nlu.constants import HANDLE_DIGRESSIONS_COMMAND
-
-structlogger = structlog.get_logger()
-
-
-@dataclass
-class HandleDigressionsCommand(Command):
-    """A command to handle digressions during an active flow."""
-
-    flow: str
-    """The interrupting flow."""
-
-    @classmethod
-    def command(cls) -> str:
-        """Returns the command type."""
-        return HANDLE_DIGRESSIONS_COMMAND
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> HandleDigressionsCommand:
-        """Converts the dictionary to a command.
-
-        Returns:
-            The converted dictionary.
-        """
-        try:
-            return HandleDigressionsCommand(flow=data["flow"])
-        except KeyError as e:
-            raise ValueError(
-                f"Missing parameter '{e}' while parsing HandleDigressionsCommand."
-            ) from e
-
-    def run_command_on_tracker(
-        self,
-        tracker: DialogueStateTracker,
-        all_flows: FlowsList,
-        original_tracker: DialogueStateTracker,
-    ) -> List[Event]:
-        """Runs the command on the tracker.
-
-        Args:
-            tracker: The tracker to run the command on.
-            all_flows: All flows in the assistant.
-            original_tracker: The tracker before any command was executed.
-
-        Returns:
-            The events to apply to the tracker.
-        """
-        stack = tracker.stack
-        original_stack = original_tracker.stack
-
-        if self.flow not in all_flows.flow_ids:
-            structlogger.debug(
-                "command_executor.push_cannot_handle.start_invalid_flow_id",
-                command=self,
-            )
-            stack.push(CannotHandlePatternFlowStackFrame())
-            return tracker.create_stack_updated_events(stack)
-
-        # this allows to include called user flows in the stack search
-        latest_user_frame = top_flow_frame(original_stack, ignore_call_frames=False)
-
-        if latest_user_frame is None:
-            structlogger.debug(
-                "command_executor.skip_command.no_top_flow", command=self
-            )
-            return []
-
-        original_top_flow = latest_user_frame.flow(all_flows)
-        current_step = original_top_flow.step_by_id(latest_user_frame.step_id)
-        if not isinstance(current_step, CollectInformationFlowStep):
-            structlogger.debug(
-                "command_executor.skip_command.not_at_a_collect_step", command=self
-            )
-            return []
-
-        ask_confirm_digressions = set(
-            current_step.ask_confirm_digressions
-            + original_top_flow.ask_confirm_digressions
-        )
-
-        block_digressions = set(
-            current_step.block_digressions + original_top_flow.block_digressions
-        )
-
-        if block_digressions:
-            if ALL_LABEL in block_digressions:
-                block_digressions.remove(ALL_LABEL)
-                block_digressions.add(self.flow)
-
-        if ask_confirm_digressions:
-            if ALL_LABEL in ask_confirm_digressions:
-                ask_confirm_digressions.remove(ALL_LABEL)
-                ask_confirm_digressions.add(self.flow)
-
-        structlogger.debug(
-            "command_executor.push_handle_digressions",
-            interrupting_flow_id=self.flow,
-            interrupted_flow_id=original_top_flow.id,
-            interrupted_step_id=current_step.id,
-            ask_confirm_digressions=ask_confirm_digressions,
-            block_digressions=block_digressions,
-        )
-        stack.push(
-            HandleDigressionsPatternFlowStackFrame(
-                interrupting_flow_id=self.flow,
-                interrupted_flow_id=original_top_flow.id,
-                interrupted_step_id=current_step.id,
-                ask_confirm_digressions=ask_confirm_digressions,
-                block_digressions=block_digressions,
-            )
-        )
-
-        return tracker.create_stack_updated_events(stack)
-
-    def __hash__(self) -> int:
-        return hash(self.flow)
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, HandleDigressionsCommand):
-            return False
-
-        return other.flow == self.flow

rasa/dialogue_understanding/patterns/handle_digressions.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, Set
-
-from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
-
-FLOW_PATTERN_HANDLE_DIGRESSIONS = (
-    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "handle_digressions"
-)
-
-
-@dataclass
-class HandleDigressionsPatternFlowStackFrame(PatternFlowStackFrame):
-    """A pattern flow stack frame that gets added if an interruption is completed."""
-
-    flow_id: str = FLOW_PATTERN_HANDLE_DIGRESSIONS
-    """The ID of the flow."""
-    interrupting_flow_id: str = ""
-    """The ID of the flow that interrupted the active flow."""
-    interrupted_flow_id: str = ""
-    """The name of the active flow that was interrupted."""
-    interrupted_step_id: str = ""
-    """The ID of the step that was interrupted."""
-    ask_confirm_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to confirm."""
-    block_digressions: Set[str] = field(default_factory=set)
-    """The set of interrupting flow names to block."""
-
-    @classmethod
-    def type(cls) -> str:
-        """Returns the type of the frame."""
-        return FLOW_PATTERN_HANDLE_DIGRESSIONS
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> HandleDigressionsPatternFlowStackFrame:
-        """Creates a `DialogueStackFrame` from a dictionary.
-
-        Args:
-            data: The dictionary to create the `DialogueStackFrame` from.
-
-        Returns:
-            The created `DialogueStackFrame`.
-        """
-        return HandleDigressionsPatternFlowStackFrame(
-            frame_id=data["frame_id"],
-            step_id=data["step_id"],
-            interrupted_step_id=data["interrupted_step_id"],
-            interrupted_flow_id=data["interrupted_flow_id"],
-            interrupting_flow_id=data["interrupting_flow_id"],
-            ask_confirm_digressions=set(data.get(KEY_ASK_CONFIRM_DIGRESSIONS, [])),
-            # This attribute must be converted to a set to enable usage
-            # of subset `contains` pypred operator in the default pattern
-            # conditional branching
-            block_digressions=set(data.get(KEY_BLOCK_DIGRESSIONS, [])),
-        )
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, HandleDigressionsPatternFlowStackFrame):
-            return False
-        return (
-            self.flow_id == other.flow_id
-            and self.interrupted_step_id == other.interrupted_step_id
-            and self.interrupted_flow_id == other.interrupted_flow_id
-            and self.interrupting_flow_id == other.interrupting_flow_id
-            and self.ask_confirm_digressions == other.ask_confirm_digressions
-            and self.block_digressions == other.block_digressions
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
-        """Returns the frame as a dictionary."""
-        data = super().as_dict()
-        # converting back to list to avoid serialization issues
-        data[KEY_ASK_CONFIRM_DIGRESSIONS] = list(self.ask_confirm_digressions)
-        data[KEY_BLOCK_DIGRESSIONS] = list(self.block_digressions)
-        return data

rasa/monkey_patches.py

@@ -1,91 +0,0 @@
-import os
-import traceback
-from typing import Any, Optional
-
-from litellm.secret_managers.main import str_to_bool
-from packaging.version import Version
-
-
-def litellm_langfuse_logger_init_fixed(
-    self: Any,  # we should not import LangfuseLogger class before we patch it
-    langfuse_public_key: Optional[str] = None,
-    langfuse_secret: Optional[str] = None,
-    langfuse_host: str = "https://cloud.langfuse.com",
-    flush_interval: int = 1,
-) -> None:
-    """Monkeypatched version of LangfuseLogger.__init__ from the LiteLLM library.
-
-    This patched version removes a call that fetched the `project_id` from
-    Langfuse Cloud even when it was already set via environment variables.
-    In the original implementation, this call was made *before* initializing
-    the LangfuseClient, which caused the application to freeze for up to 60 seconds.
-
-    By removing this premature call, the monkeypatch avoids the unnecessary network
-    request and prevents the timeout/freeze issue.
-
-    This workaround can be removed once the underlying bug is resolved in LiteLLM:
-    https://github.com/BerriAI/litellm/issues/7732
-    """
-    try:
-        import langfuse
-        from langfuse import Langfuse
-    except Exception as e:
-        raise Exception(
-            f"\033[91mLangfuse not installed, try running 'pip install langfuse' "
-            f"to fix this error: {e}\n{traceback.format_exc()}\033[0m"
-        )
-    # Instance variables
-    self.secret_key = langfuse_secret or os.getenv("LANGFUSE_SECRET_KEY", "")
-    self.public_key = langfuse_public_key or os.getenv("LANGFUSE_PUBLIC_KEY", "")
-
-    self.langfuse_host = langfuse_host or os.getenv(
-        "LANGFUSE_HOST", "https://cloud.langfuse.com"
-    )
-    self.langfuse_host.replace("http://", "https://")
-    if not self.langfuse_host.startswith("https://"):
-        self.langfuse_host = "https://" + self.langfuse_host
-
-    self.langfuse_release = os.getenv("LANGFUSE_RELEASE")
-    self.langfuse_debug = os.getenv("LANGFUSE_DEBUG")
-    self.langfuse_flush_interval = (
-        os.getenv("LANGFUSE_FLUSH_INTERVAL") or flush_interval
-    )
-
-    parameters = {
-        "public_key": self.public_key,
-        "secret_key": self.secret_key,
-        "host": self.langfuse_host,
-        "release": self.langfuse_release,
-        "debug": self.langfuse_debug,
-        "flush_interval": self.langfuse_flush_interval,  # flush interval in seconds
-    }
-
-    if Version(langfuse.version.__version__) >= Version("2.6.0"):
-        parameters["sdk_integration"] = "litellm"
-
-    self.Langfuse = Langfuse(**parameters)
-
-    if os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY") is not None:
-        upstream_langfuse_debug = (
-            str_to_bool(self.upstream_langfuse_debug)
-            if self.upstream_langfuse_debug is not None
-            else None
-        )
-        self.upstream_langfuse_secret_key = os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY")
-        self.upstream_langfuse_public_key = os.getenv("UPSTREAM_LANGFUSE_PUBLIC_KEY")
-        self.upstream_langfuse_host = os.getenv("UPSTREAM_LANGFUSE_HOST")
-        self.upstream_langfuse_release = os.getenv("UPSTREAM_LANGFUSE_RELEASE")
-        self.upstream_langfuse_debug = os.getenv("UPSTREAM_LANGFUSE_DEBUG")
-        self.upstream_langfuse = Langfuse(
-            public_key=self.upstream_langfuse_public_key,
-            secret_key=self.upstream_langfuse_secret_key,
-            host=self.upstream_langfuse_host,
-            release=self.upstream_langfuse_release,
-            debug=(
-                upstream_langfuse_debug
-                if upstream_langfuse_debug is not None
-                else False
-            ),
-        )
-    else:
-        self.upstream_langfuse = None