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

rasa/core/lock_store.py

@@ -2,18 +2,27 @@ from __future__ import annotations
 
 import asyncio
 import json
-import logging
 import os
 from contextlib import asynccontextmanager
-from typing import AsyncGenerator, Dict, Optional, Text, Union
+from typing import Any, AsyncGenerator, Dict, Literal, Optional, Text, Union
+
+import structlog
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    Field,
+    NonNegativeInt,
+    model_validator,
+)
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME
 from rasa.core.lock import TicketLock
 from rasa.shared.exceptions import ConnectionException, RasaException
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 
 def _get_lock_lifetime() -> int:
@@ -76,7 +85,10 @@ class LockStore:
 
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             ticket = lock.issue_ticket(lock_lifetime)
@@ -109,7 +121,10 @@ class LockStore:
     async def _acquire_lock(
         self, conversation_id: Text, ticket: int, wait_time_in_seconds: float
     ) -> TicketLock:
-        logger.debug(f"Acquiring lock for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "lock_store._acquiring_lock_for_conversation",
+            event_info=f"Acquiring lock for conversation '{conversation_id}'.",
+        )
         while True:
             # fetch lock in every iteration because lock might no longer exist
             lock = self.get_lock(conversation_id)
@@ -120,16 +135,22 @@ class LockStore:
 
             # acquire lock if it isn't locked
             if not lock.is_locked(ticket):
-                logger.debug(f"Acquired lock for conversation '{conversation_id}'.")
+                structlogger.debug(
+                    "lock_store._acquired_lock_for_conversation",
+                    event_info=f"Acquired lock for conversation '{conversation_id}'.",
+                )
                 return lock
 
             items_before_this = ticket - (lock.now_serving or 0)
 
-            logger.debug(
-                f"Failed to acquire lock for conversation ID '{conversation_id}' "
-                f"because {items_before_this} other item(s) for this "
-                f"conversation ID have to be finished processing first. "
-                f"Retrying in {wait_time_in_seconds} seconds ..."
+            structlogger.debug(
+                "lock_store._retrying_lock_acquisition",
+                event_info=(
+                    f"Failed to acquire lock for conversation ID '{conversation_id}' "
+                    f"because {items_before_this} other item(s) for this "
+                    f"conversation ID have to be finished processing first. "
+                    f"Retrying in {wait_time_in_seconds} seconds ..."
+                ),
             )
 
             # sleep and update lock
@@ -186,9 +207,99 @@ class LockStore:
     @staticmethod
     def _log_deletion(conversation_id: Text, deletion_successful: bool) -> None:
         if deletion_successful:
-            logger.debug(f"Deleted lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._deleted_lock_for_conversation",
+                event_info=f"Deleted lock for conversation '{conversation_id}'.",
+            )
         else:
-            logger.debug(f"Could not delete lock for conversation '{conversation_id}'.")
+            structlogger.debug(
+                "lock_store._failed_to_delete_lock_for_conversation",
+                event_info=(
+                    f"Could not delete lock for conversation '{conversation_id}'."
+                ),
+            )
+
+
+class RedisLockStoreConfig(BaseModel):
+    host: Union[AnyUrl, Literal["localhost"]] = Field(
+        default="localhost", description="The host of the redis server."
+    )
+    port: NonNegativeInt = Field(
+        default=6379, ge=0, le=65535, description="The port of the redis server."
+    )
+    db: NonNegativeInt = Field(
+        default=0,
+        ge=0,
+        description="The name of the database within Redis "
+        "which should be used by Rasa",
+    )
+    username: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The username which should be used for "
+        "authentication with the Redis database.",
+    )
+    use_ssl: bool = Field(
+        default=False,
+        serialization_alias="ssl",
+        description="True if SSL should be used for the connection to Redis.",
+    )
+    ssl_certfile: Optional[str] = Field(
+        default=None,
+        description="Path to the SSL certificate file.",
+    )
+    ssl_keyfile: Optional[str] = Field(
+        default=None, description="Path to the SSL private key file."
+    )
+    ssl_ca_certs: Optional[str] = Field(
+        default=None, description="Path to the SSL CA certificate file."
+    )
+    key_prefix: Optional[str] = Field(
+        default=None,
+        description="Prefix to prepend to all keys "
+        "used by the lock store. Must be alphanumeric.",
+    )
+    socket_timeout: float = Field(
+        default=DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        description="Timeout in seconds after which an exception "
+        "will be raised in case Redis doesn't respond "
+        "within `socket_timeout` seconds.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_url_and_host_properties(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if bool(data.get("url", None)) and bool(data.get("host", None)):
+                raise RasaException(
+                    "You cannot specify both 'url' and 'host' in the Redis lock store "
+                    "configuration. Please use only one of them."
+                )
+
+            if data.get("url", None):
+                raise_deprecation_warning(
+                    "The 'url' property in the redis lock store "
+                    "configuration is deprecated. Please use 'host' instead."
+                )
+                data["host"] = data.pop("url")
+        return data
+
+    @model_validator(mode="after")
+    def verify_username_password(self) -> RedisLockStoreConfig:
+        if bool(self.username) ^ bool(self.password):
+            raise ValueError(
+                f"Expected username and password. "
+                f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
+                f"password: {'<has value>' if self.password else '<N/A>'}"
+            )
+        return self
+
+    def to_strict_redis(self) -> Dict[str, Any]:
+        return self.model_dump(by_alias=True, exclude={"key_prefix"})
 
 
 class RedisLockStore(LockStore):
@@ -196,57 +307,28 @@ class RedisLockStore(LockStore):
 
     def __init__(
         self,
-        host: Text = "localhost",
-        port: int = 6379,
-        db: int = 1,
-        username: Optional[Text] = None,
-        password: Optional[Text] = None,
-        use_ssl: bool = False,
-        ssl_certfile: Optional[Text] = None,
-        ssl_keyfile: Optional[Text] = None,
-        ssl_ca_certs: Optional[Text] = None,
-        key_prefix: Optional[Text] = None,
-        socket_timeout: float = DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
+        config: RedisLockStoreConfig = RedisLockStoreConfig(),
     ) -> None:
         """Create a lock store which uses Redis for persistence.
 
         Args:
-            host: The host of the redis server.
-            port: The port of the redis server.
-            db: The name of the database within Redis which should be used by Rasa
-                Open Source.
-            username: The username which should be used for authentication with the
-                Redis database.
-            password: The password which should be used for authentication with the
-                Redis database.
-            use_ssl: `True` if SSL should be used for the connection to Redis.
-            ssl_certfile: Path to the SSL certificate file.
-            ssl_keyfile: Path to the SSL private key file.
-            ssl_ca_certs: Path to the SSL CA certificate file.
-            key_prefix: prefix to prepend to all keys used by the lock store. Must be
-                alphanumeric.
-            socket_timeout: Timeout in seconds after which an exception will be raised
-                in case Redis doesn't respond within `socket_timeout` seconds.
+            config: Redis lock store configuration.
         """
         import redis
 
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
-        )
+        self.config = config
+        self.red = redis.StrictRedis(**self.config.to_strict_redis())
 
         self.key_prefix = DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
-        if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
-            self._set_key_prefix(key_prefix)
+        if self.config.key_prefix:
+            structlogger.debug(
+                "redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=(
+                    f"Setting non-default "
+                    f"redis key prefix: '{self.config.key_prefix}'.",
+                ),
+            )
+            self._set_key_prefix(self.config.key_prefix)
 
         super().__init__()
 
@@ -254,9 +336,13 @@ class RedisLockStore(LockStore):
         if isinstance(key_prefix, str) and key_prefix.isalnum():
             self.key_prefix = key_prefix + ":" + DEFAULT_REDIS_LOCK_STORE_KEY_PREFIX
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "redis_lock_store._set_key_prefix.default_instead_of_invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def get_lock(self, conversation_id: Text) -> Optional[TicketLock]:
@@ -313,7 +399,9 @@ def _create_from_endpoint_config(
 
         lock_store: LockStore = InMemoryLockStore()
     elif endpoint_config.type == "redis":
-        lock_store = RedisLockStore(host=endpoint_config.url, **endpoint_config.kwargs)
+        config = RedisLockStoreConfig.model_validate(endpoint_config.to_dict())
+
+        lock_store = RedisLockStore(config)
     elif endpoint_config.type == "concurrent_redis":
         from rasa.core.concurrent_lock_store import ConcurrentRedisLockStore
 
@@ -321,7 +409,10 @@ def _create_from_endpoint_config(
     else:
         lock_store = _load_from_module_name_in_endpoint_config(endpoint_config)
 
-    logger.debug(f"Connected to lock store '{lock_store.__class__.__name__}'.")
+    structlogger.debug(
+        "lock_store._create_from_endpoint_config.lock_store_connected",
+        event_info=f"Connected to lock store '{lock_store.__class__.__name__}'.",
+    )
 
     return lock_store
 

rasa/dialogue_understanding_test/du_test_case.py

@@ -261,19 +261,27 @@ class DialogueUnderstandingTestStep(BaseModel):
         # Safely extract commands from the step.
         commands = []
         for command in step.get(KEY_COMMANDS, []):
+            parsed_commands = None
             try:
-                commands.extend(
-                    parse_commands(
-                        command,
-                        flows,
-                        clarify_options_optional=True,
-                        additional_commands=custom_command_classes,
-                        default_commands_to_remove=remove_default_commands,
-                    )
+                parsed_commands = parse_commands(
+                    command,
+                    flows,
+                    clarify_options_optional=True,
+                    additional_commands=custom_command_classes,
+                    default_commands_to_remove=remove_default_commands,
                 )
             except (IndexError, ValueError) as e:
                 raise ValueError(f"Failed to parse command '{command}': {e}") from e
 
+            if not parsed_commands:
+                raise ValueError(
+                    f"Failed to parse command '{command}': command parser returned "
+                    f"None. Please make sure that you are using the correct command "
+                    f"syntax and the command arguments are valid."
+                )
+
+            commands.extend(parsed_commands)
+
         # Construct the DialogueUnderstandingTestStep
         return DialogueUnderstandingTestStep(
             actor=ACTOR_USER if ACTOR_USER in step else ACTOR_BOT,

rasa/plugin.py

@@ -32,11 +32,8 @@ def plugin_manager() -> pluggy.PluginManager:
 
 def init_hooks(manager: pluggy.PluginManager) -> None:
     """Initialise hooks into rasa."""
-    import rasa.utils.licensing
     from rasa import hooks
 
-    rasa.utils.licensing.validate_license_from_env()
-
     manager.register(hooks)
 
 

rasa/shared/constants.py

@@ -238,6 +238,7 @@ EXTRA_PARAMETERS_KEY = "extra_parameters"
 MODEL_GROUP_ID_KEY = "model_group_id"
 MODEL_LIST_KEY = "model_list"
 LITELLM_PARAMS_KEY = "litellm_params"
+_VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
 LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"

rasa/shared/core/domain.py

@@ -134,6 +134,22 @@ ALL_DOMAIN_KEYS = [
 
 PREV_PREFIX = "prev_"
 
+MERGE_FUNC_MAPPING: Dict[Text, Callable[..., Any]] = {
+    KEY_ACTIONS: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_RESPONSES: rasa.shared.utils.common.merge_dicts,
+    KEY_SLOTS: rasa.shared.utils.common.merge_dicts,
+    KEY_INTENTS: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_ENTITIES: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_E2E_ACTIONS: rasa.shared.utils.common.merge_lists,
+    KEY_FORMS: rasa.shared.utils.common.merge_dicts,
+}
+
+DICT_DATA_KEYS = [
+    key
+    for key, value in MERGE_FUNC_MAPPING.items()
+    if value == rasa.shared.utils.common.merge_dicts
+]
+
 # State is a dictionary with keys (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
 # representing the origin of a SubState;
 # the values are SubStates, that contain the information needed for featurization
@@ -466,17 +482,7 @@ class Domain:
 
         duplicates: Dict[Text, List[Text]] = {}
 
-        merge_func_mappings: Dict[Text, Callable[..., Any]] = {
-            KEY_INTENTS: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_ENTITIES: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_ACTIONS: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_E2E_ACTIONS: rasa.shared.utils.common.merge_lists,
-            KEY_FORMS: rasa.shared.utils.common.merge_dicts,
-            KEY_RESPONSES: rasa.shared.utils.common.merge_dicts,
-            KEY_SLOTS: rasa.shared.utils.common.merge_dicts,
-        }
-
-        for key, merge_func in merge_func_mappings.items():
+        for key, merge_func in MERGE_FUNC_MAPPING.items():
             duplicates[key] = rasa.shared.utils.common.extract_duplicates(
                 combined.get(key, []), domain_dict.get(key, [])
             )
@@ -494,6 +500,74 @@ class Domain:
 
         return combined
 
+    def partial_merge(self, other: Domain) -> Domain:
+        """
+        Returns a new Domain with intersection-based merging:
+          - For each domain section only overwrite items that already exist in self.
+          - Brand-new items in `other` are ignored.
+
+        Args:
+            other: The domain to merge with.
+
+        Returns:
+            A new Domain object with the merged content.
+        """
+        updated_self = copy.deepcopy(self.as_dict())
+        other_dict = other.as_dict()
+
+        keys_to_merge = MERGE_FUNC_MAPPING.keys()
+        for key in keys_to_merge:
+            if key in DICT_DATA_KEYS:
+                # Merge dictionaries
+                self_val = updated_self.get(key, {})
+                other_val = other_dict.get(key, {})
+                updated_self[key] = rasa.shared.utils.common.partial_merge_dict(
+                    self_val, other_val
+                )
+            else:
+                # Merge lists
+                self_val = updated_self.get(key, [])
+                other_val = other_dict.get(key, [])
+                is_same_item_fn = SAME_ITEM_FUNCTIONS.get(key, default_is_same_item)
+                updated_self[key] = rasa.shared.utils.common.partial_merge_list(
+                    self_val, other_val, is_same_item_fn
+                )
+
+        return Domain.from_dict(updated_self)
+
+    def difference(self, other: Domain) -> Domain:
+        """
+        Returns a new Domain containing items in `self` that are NOT in `other`,
+        using simple equality checks for dict/list items.
+
+        Args:
+            other: The domain to compare with.
+
+        Returns:
+            A new Domain object with the difference content.
+        """
+        self_dict = self.as_dict()
+        other_dict = other.as_dict()
+
+        difference_dict = {}
+        for key in MERGE_FUNC_MAPPING.keys():
+            is_dict = key in DICT_DATA_KEYS
+            self_val = self_dict.get(key, {} if is_dict else [])
+            other_val = other_dict.get(key, {} if is_dict else [])
+
+            if is_dict and isinstance(self_val, dict) and isinstance(other_val, dict):
+                difference_dict[key] = {
+                    k: v
+                    for k, v in self_val.items()
+                    if k not in other_val or v != other_val[k]
+                }
+            else:
+                difference_dict[key] = [
+                    item for item in self_val if item not in other_val
+                ]  # type: ignore[assignment]
+
+        return Domain.from_dict(difference_dict)
+
     def _preprocess_domain_dict(
         self,
         data: Dict,
@@ -2120,6 +2194,11 @@ class Domain:
         """Remove all builtin slots from the domain."""
         self.slots = [slot for slot in self.slots if not slot.is_builtin]
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Domain):
+            return self.as_dict() == other.as_dict()
+        return False
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],
@@ -2178,3 +2257,78 @@ def _validate_forms(forms: Union[Dict, List]) -> None:
                 f"the keyword `{REQUIRED_SLOTS_KEY}` is required. "
                 f"Please see {DOCS_URL_FORMS} for more information."
             )
+
+
+def is_same_entity(e1: Any, e2: Any) -> bool:
+    """Check if two entities are the 'same' (string or dict).
+
+    Args:
+        e1: First entity to compare.
+        e2: Second entity to compare.
+
+    Returns:
+        True if the entities are the same, False otherwise.
+    """
+    if isinstance(e1, str) and isinstance(e2, str):
+        return e1 == e2
+
+    if isinstance(e1, dict) and isinstance(e2, dict):
+        return (
+            e1.get(ENTITY_ATTRIBUTE_TYPE) == e2.get(ENTITY_ATTRIBUTE_TYPE)
+            and e1.get(ENTITY_ATTRIBUTE_ROLE) == e2.get(ENTITY_ATTRIBUTE_ROLE)
+            and e1.get(ENTITY_ATTRIBUTE_GROUP) == e2.get(ENTITY_ATTRIBUTE_GROUP)
+        )
+
+    return False
+
+
+def is_same_intent(i1: Any, i2: Any) -> bool:
+    """Check if two intents are the 'same' (string or dict).
+
+    Args:
+        i1: First intent to compare.
+        i2: Second intent to compare.
+
+    Returns:
+        True if the intents are the same, False otherwise.
+    """
+    if isinstance(i1, str) and isinstance(i2, str):
+        return i1 == i2
+
+    if isinstance(i1, dict) and isinstance(i2, dict):
+        key1, key2 = next(iter(i1.keys())), next(iter((i2.keys())))
+        return key1 == key2
+
+    return False
+
+
+def is_same_action(a1: Any, a2: Any) -> bool:
+    """Check if two actions are the 'same' (string or dict).
+
+    Args:
+        a1: First action to compare.
+        a2: Second action to compare.
+
+    Returns:
+        True if the actions are the same, False otherwise.
+    """
+    if isinstance(a1, str) and isinstance(a2, str):
+        return a1 == a2
+
+    if isinstance(a1, dict) and isinstance(a2, dict):
+        key1, key2 = next(iter((a1.keys()))), next(iter((a2.keys())))
+        return key1 == key2
+
+    return False
+
+
+def default_is_same_item(a: Any, b: Any) -> bool:
+    """Fallback exact equality check if a key doesn't need special handling."""
+    return a == b
+
+
+SAME_ITEM_FUNCTIONS: Dict[Text, Callable[[Any, Any], bool]] = {
+    KEY_ENTITIES: is_same_entity,
+    KEY_INTENTS: is_same_intent,
+    KEY_ACTIONS: is_same_action,
+}