rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/shared/providers/router/router_client.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class RouterClient(Protocol):
+    """
+    Protocol for a Router client that specifies the interface for interacting
+    with the API.
+    """
+
+    @classmethod
+    def from_config(cls, config: dict) -> RouterClient:
+        """
+        Initializes the router client with the given configuration.
+
+        This class method should be implemented to parse the given
+        configuration and create an instance of an router client.
+        """
+        ...
+
+    @property
+    def config(self) -> Dict:
+        """
+        Returns the configuration for that the router client is initialized with.
+
+        This property should be implemented to return a dictionary containing
+        the client configuration settings for the router client.
+        """
+        ...
+
+    @property
+    def router_settings(self) -> Dict[str, Any]:
+        """
+        Returns the router settings for the Router client.
+
+        This property should be implemented to return a dictionary containing
+        the router settings for the router client.
+        """
+        ...
+
+    @property
+    def model_group_id(self) -> str:
+        """
+        Returns the model group ID for the Router client.
+
+        This property should be implemented to return the model group ID
+        for the router client.
+        """
+        ...
+
+    @property
+    def model_configurations(self) -> List[Dict[str, Any]]:
+        """
+        Returns the list of model configurations for the Router client.
+
+        This property should be implemented to return the list of model configurations
+        for the router client as a list of dictionaries.
+
+        Each dictionary should contain the model configuration.
+        Ideally, the `ModelGroupConfig` should parse the model configurations
+        and generate this list of dictionaries.
+        """
+        ...
+
+    @property
+    def router_client(self) -> object:
+        """
+        Returns the instantiated Router client.
+
+        This property should be implemented to return the instantiated
+        Router client.
+        """
+        ...

rasa/shared/utils/cli.py

@@ -0,0 +1,102 @@
+import math
+import shutil
+import sys
+from typing import Any, Text, NoReturn
+
+import rasa.shared.utils.io
+
+
+def print_color(*args: Any, color: Text) -> None:
+    """Print the given arguments to STDOUT in the specified color.
+
+    Args:
+        args: A list of objects to be printed.
+        color: A textual representation of the color.
+    """
+    output = rasa.shared.utils.io.wrap_with_color(*args, color=color)
+    stream = sys.stdout
+    if sys.platform == "win32":
+        # colorama is used to fix a regression where colors can not be printed on
+        # windows. https://github.com/RasaHQ/rasa/issues/7053
+        from colorama import AnsiToWin32
+
+        stream = AnsiToWin32(sys.stdout).stream
+    try:
+        print(output, file=stream)
+    except BlockingIOError:
+        rasa.shared.utils.io.handle_print_blocking(output)
+
+
+def print_success(*args: Any) -> None:
+    """Print the given arguments to STDOUT in green, indicating success.
+
+    Args:
+        args: A list of objects to be printed.
+    """
+    print_color(*args, color=rasa.shared.utils.io.bcolors.OKGREEN)
+
+
+def print_info(*args: Any) -> None:
+    """Print the given arguments to STDOUT in blue.
+
+    Args:
+        args: A list of objects to be printed.
+    """
+    print_color(*args, color=rasa.shared.utils.io.bcolors.OKBLUE)
+
+
+def print_warning(*args: Any) -> None:
+    """Print the given arguments to STDOUT in a color indicating a warning.
+
+    Args:
+        args: A list of objects to be printed.
+    """
+    print_color(*args, color=rasa.shared.utils.io.bcolors.WARNING)
+
+
+def print_error(*args: Any) -> None:
+    """Print the given arguments to STDOUT in a color indicating an error.
+
+    Args:
+        args: A list of objects to be printed.
+    """
+    print_color(*args, color=rasa.shared.utils.io.bcolors.FAIL)
+
+
+def print_error_and_exit(message: Text, exit_code: int = 1) -> NoReturn:
+    """Print an error message and exit the application.
+
+    Args:
+        message: The error message to be printed.
+        exit_code: The program exit code, defaults to 1.
+    """
+    print_error(message)
+    sys.exit(exit_code)
+
+
+def pad(text: Text, char: Text = "=", min: int = 3) -> Text:
+    """Pad text to a certain length.
+
+    Uses `char` to pad the text to the specified length. If the text is longer
+    than the specified length, at least `min` are used.
+
+    The padding is applied to the left and right of the text (almost) equally.
+
+    Example:
+        >>> pad("Hello")
+        "========= Hello ========"
+        >>> pad("Hello", char="-")
+        "--------- Hello --------"
+
+    Args:
+        text: Text to pad.
+        min: Minimum length of the padding.
+        char: Character to pad with.
+
+    Returns:
+        Padded text.
+    """
+    width = shutil.get_terminal_size((80, 20)).columns
+    padding = max(width - len(text) - 2, min * 2)
+
+    return char * (padding // 2) + " " + text + " " + char * math.ceil(padding / 2)

rasa/shared/utils/common.py

@@ -0,0 +1,324 @@
+import asyncio
+import functools
+import importlib
+import inspect
+import logging
+import os
+import pkgutil
+import sys
+from types import ModuleType
+from typing import Sequence, Text, Dict, Optional, Any, List, Callable, Collection, Type
+
+import rasa.shared.utils.io
+from rasa.exceptions import MissingDependencyException
+from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
+from rasa.shared.exceptions import ProviderClientValidationError, RasaException
+
+logger = logging.getLogger(__name__)
+
+
+def class_from_module_path(
+    module_path: Text, lookup_path: Optional[Text] = None
+) -> Type:
+    """Given the module name and path of a class, tries to retrieve the class.
+
+    The loaded class can be used to instantiate new objects.
+
+    Args:
+        module_path: either an absolute path to a Python class,
+                     or the name of the class in the local / global scope.
+        lookup_path: a path where to load the class from, if it cannot
+                     be found in the local / global scope.
+
+    Returns:
+        a Python class
+
+    Raises:
+        ImportError, in case the Python class cannot be found.
+        RasaException, in case the imported result is something other than a class
+    """
+    warn_and_exit_if_module_path_contains_rasa_plus(module_path, lookup_path)
+
+    klass = None
+    if "." in module_path:
+        module_name, _, class_name = module_path.rpartition(".")
+        m = importlib.import_module(module_name)
+        klass = getattr(m, class_name, None)
+    elif lookup_path:
+        # try to import the class from the lookup path
+        m = importlib.import_module(lookup_path)
+        klass = getattr(m, module_path, None)
+
+    if klass is None:
+        raise ImportError(f"Cannot retrieve class from path {module_path}.")
+
+    if not inspect.isclass(klass):
+        raise RasaException(
+            f"`class_from_module_path()` is expected to return a class, "
+            f"but for {module_path} we got a {type(klass)}."
+        )
+    return klass
+
+
+def import_package_modules(package_name: str) -> List[ModuleType]:
+    """Import all modules in a package."""
+    package = importlib.import_module(package_name)
+    return [
+        importlib.import_module(f"{package_name}.{module_name}")
+        for _, module_name, _ in pkgutil.iter_modules(package.__path__)
+    ]
+
+
+def all_subclasses(cls: Any) -> List[Any]:
+    """Returns all known (imported) subclasses of a class."""
+    classes = cls.__subclasses__() + [
+        g for s in cls.__subclasses__() for g in all_subclasses(s)
+    ]
+
+    return [subclass for subclass in classes if not inspect.isabstract(subclass)]
+
+
+def module_path_from_instance(inst: Any) -> Text:
+    """Return the module path of an instance's class."""
+    return inst.__module__ + "." + inst.__class__.__name__
+
+
+def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
+    """Sorts a list of dictionaries by their first key."""
+    return sorted(dicts, key=lambda d: next(iter(d.keys())))
+
+
+def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Caches method calls based on the call's `args` and `kwargs`.
+    Works for `async` and `sync` methods. Don't apply this to functions.
+    Args:
+        f: The decorated method whose return value should be cached.
+    Returns:
+        The return value which the method gives for the first call with the given
+        arguments.
+    """
+    assert "self" in arguments_of(f), "This decorator can only be used with methods."
+
+    class Cache:
+        """Helper class to abstract the caching details."""
+
+        def __init__(self, caching_object: object, args: Any, kwargs: Any) -> None:
+            self.caching_object = caching_object
+            self.cache = getattr(caching_object, self._cache_name(), {})
+            # noinspection PyUnresolvedReferences
+            self.cache_key = functools._make_key(args, kwargs, typed=False)
+
+        def _cache_name(self) -> Text:
+            return f"_cached_{self.caching_object.__class__.__name__}_{f.__name__}"
+
+        def is_cached(self) -> bool:
+            return self.cache_key in self.cache
+
+        def cache_result(self, result: Any) -> None:
+            self.cache[self.cache_key] = result
+            setattr(self.caching_object, self._cache_name(), self.cache)
+
+        def cached_result(self) -> Any:
+            return self.cache[self.cache_key]
+
+    if asyncio.iscoroutinefunction(f):
+
+        @functools.wraps(f)
+        async def decorated(self: object, *args: Any, **kwargs: Any) -> Any:
+            cache = Cache(self, args, kwargs)
+            if not cache.is_cached():
+                # Store the task immediately so that other concurrent calls of the
+                # method can re-use the same task and don't schedule a second execution.
+                to_cache = asyncio.ensure_future(f(self, *args, **kwargs))
+                cache.cache_result(to_cache)
+            return await cache.cached_result()
+
+        return decorated
+    else:
+
+        @functools.wraps(f)
+        def decorated(self: object, *args: Any, **kwargs: Any) -> Any:
+            cache = Cache(self, args, kwargs)
+            if not cache.is_cached():
+                to_cache = f(self, *args, **kwargs)
+                cache.cache_result(to_cache)
+            return cache.cached_result()
+
+        return decorated
+
+
+def transform_collection_to_sentence(collection: Collection[Text]) -> Text:
+    """Transforms e.g. a list like ['A', 'B', 'C'] into a sentence 'A, B and C'."""
+    x = list(collection)
+    if len(x) >= 2:
+        return ", ".join(map(str, x[:-1])) + " and " + x[-1]
+    return "".join(collection)
+
+
+def minimal_kwargs(
+    kwargs: Dict[Text, Any], func: Callable, excluded_keys: Optional[List] = None
+) -> Dict[Text, Any]:
+    """Returns only the kwargs which are required by a function.
+
+    Keys, contained in the exception list, are not included.
+
+    Args:
+        kwargs: All available kwargs.
+        func: The function which should be called.
+        excluded_keys: Keys to exclude from the result.
+
+    Returns:
+        Subset of kwargs which are accepted by `func`.
+
+    """
+    excluded_keys = excluded_keys or []
+
+    possible_arguments = arguments_of(func)
+
+    return {
+        k: v
+        for k, v in kwargs.items()
+        if k in possible_arguments and k not in excluded_keys
+    }
+
+
+def mark_as_experimental_feature(feature_name: Text) -> None:
+    """Warns users that they are using an experimental feature."""
+    logger.warning(
+        f"The {feature_name} is currently experimental and might change or be "
+        "removed in the future 🔬 Please share your feedback on it in the "
+        "forum (https://forum.rasa.com) to help us make this feature "
+        "ready for production."
+    )
+
+
+def mark_as_beta_feature(feature_name: Text) -> None:
+    """Warns users that they are using a beta feature."""
+    logger.warning(
+        f"🔬 Beta Feature: {feature_name} is in beta. It may have unexpected "
+        "behaviour and might be changed in the future."
+    )
+
+
+def arguments_of(func: Callable) -> List[Text]:
+    """Return the parameters of the function `func` as a list of names."""
+    import inspect
+
+    return list(inspect.signature(func).parameters.keys())
+
+
+def extract_duplicates(list1: List[Any], list2: List[Any]) -> List[Any]:
+    """Extracts duplicates from two lists."""
+    if list1:
+        dict1 = {
+            (sorted(list(i.keys()))[0] if isinstance(i, dict) else i): i for i in list1
+        }
+    else:
+        dict1 = {}
+
+    if list2:
+        dict2 = {
+            (sorted(list(i.keys()))[0] if isinstance(i, dict) else i): i for i in list2
+        }
+    else:
+        dict2 = {}
+
+    set1 = set(dict1.keys())
+    set2 = set(dict2.keys())
+    dupes = set1.intersection(set2)
+    return sorted(list(dupes))
+
+
+def clean_duplicates(dupes: Dict[Text, Any]) -> Dict[Text, Any]:
+    """Removes keys for empty values."""
+    duplicates = dupes.copy()
+    for k in dupes:
+        if not dupes[k]:
+            duplicates.pop(k)
+
+    return duplicates
+
+
+def merge_dicts(
+    tempDict1: Dict[Text, Any],
+    tempDict2: Dict[Text, Any],
+    override_existing_values: bool = False,
+) -> Dict[Text, Any]:
+    """Merges two dicts."""
+    if override_existing_values:
+        merged_dicts, b = tempDict1.copy(), tempDict2.copy()
+
+    else:
+        merged_dicts, b = tempDict2.copy(), tempDict1.copy()
+    merged_dicts.update(b)
+    return merged_dicts
+
+
+def merge_lists(
+    list1: List[Any], list2: List[Any], override: bool = False
+) -> List[Any]:
+    """Merges two lists."""
+    return sorted(list(set(list1 + list2)))
+
+
+def merge_lists_of_dicts(
+    dict_list1: List[Dict],
+    dict_list2: List[Dict],
+    override_existing_values: bool = False,
+) -> List[Dict]:
+    """Merges two dict lists."""
+    dict1 = {
+        (sorted(list(i.keys()))[0] if isinstance(i, dict) else i): i for i in dict_list1
+    }
+    dict2 = {
+        (sorted(list(i.keys()))[0] if isinstance(i, dict) else i): i for i in dict_list2
+    }
+    merged_dicts = merge_dicts(dict1, dict2, override_existing_values)
+    return list(merged_dicts.values())
+
+
+def warn_and_exit_if_module_path_contains_rasa_plus(
+    module_path: Text, lookup_path: Optional[str] = None
+) -> None:
+    """Warns and exits if the module path contains `rasa_plus`.
+
+    Args:
+        module_path: The module path to check.
+        lookup_path: The lookup path to check.
+    """
+    if "rasa_plus" in module_path.lower() or (
+        lookup_path and "rasa_plus" in lookup_path.lower()
+    ):
+        rasa.shared.utils.io.raise_warning(
+            f"Your module path '{module_path}' contains 'rasa_plus'. "
+            f"The path to this Rasa Pro component has changed, please "
+            f"follow the migration guide in the official documentation "
+            f"to update your code: ",
+            docs=DOCS_URL_MIGRATION_GUIDE,
+        )
+        sys.exit(1)
+
+
+def validate_environment(
+    required_env_vars: Sequence[str],
+    required_packages: Sequence[str],
+    component_name: str,
+) -> None:
+    """Make sure all needed requirements for a component are met.
+    Args:
+         required_env_vars: List of environment variables that should be set
+         required_packages: List of packages that should be installed
+         component_name: component name that needs the requirements
+    """
+    for e in required_env_vars:
+        if not os.environ.get(e):
+            raise ProviderClientValidationError(
+                f"Missing environment variable for {component_name}: {e}"
+            )
+    for p in required_packages:
+        try:
+            importlib.import_module(p)
+        except ImportError:
+            raise MissingDependencyException(
+                f"Missing package for {component_name}: {p}"
+            )

rasa/shared/utils/constants.py

@@ -0,0 +1,4 @@
+DEFAULT_ENCODING = "utf-8"
+
+READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR = "READ_YAML_FILE_CACHE_MAXSIZE"
+DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE = 256

rasa/shared/utils/health_check/embeddings_health_check_mixin.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any
+
+
+class EmbeddingsHealthCheckMixin:
+    """Mixin class that provides methods for performing embeddings health checks during
+    training and inference within components.
+
+    This mixin offers static methods that wrap the following health check functions:
+    - `perform_embeddings_health_check`
+    """
+
+    @staticmethod
+    def perform_embeddings_health_check(
+        custom_embeddings_config: Optional[Dict[str, Any]],
+        default_embeddings_config: Dict[str, Any],
+        log_source_method: str,
+        log_source_component: str,
+    ) -> None:
+        """Wraps the `perform_embeddings_health_check` function to enable
+        tracing and instrumentation.
+        """
+        from rasa.shared.utils.health_check.health_check import (
+            perform_embeddings_health_check,
+        )
+
+        perform_embeddings_health_check(
+            custom_embeddings_config,
+            default_embeddings_config,
+            log_source_method,
+            log_source_component,
+        )