rasa-pro 3.11.4__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/shared/providers/llm/llm_client.py

@@ -1,4 +1,6 @@
-from typing import Protocol, Dict, List, runtime_checkable, Union
+from __future__ import annotations
+
+from typing import Dict, List, Protocol, Union, runtime_checkable
 
 from rasa.shared.providers.llm.llm_response import LLMResponse
 
@@ -11,7 +13,7 @@ class LLMClient(Protocol):
     """
 
     @classmethod
-    def from_config(cls, config: dict) -> "LLMClient":
+    def from_config(cls, config: dict) -> LLMClient:
         """
         Initializes the llm client with the given configuration.
 
@@ -30,7 +32,7 @@ class LLMClient(Protocol):
         """
         ...
 
-    def completion(self, messages: Union[List[str], str]) -> LLMResponse:
+    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
         """
         Synchronously generate completions for given list of messages.
 
@@ -38,14 +40,22 @@ class LLMClient(Protocol):
         strings) and return a list of completions (as strings).
 
         Args:
-            messages: List of messages or a single message to generate the
-                completion for.
+            messages: The message can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
         Returns:
             LLMResponse
         """
         ...
 
-    async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
+    async def acompletion(
+        self, messages: Union[List[dict], List[str], str]
+    ) -> LLMResponse:
         """
         Asynchronously generate completions for given list of messages.
 
@@ -53,8 +63,14 @@ class LLMClient(Protocol):
         strings) and return a list of completions (as strings).
 
         Args:
-            messages: List of messages or a single message to generate the
-                completion for.
+            messages: The message can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
         Returns:
             LLMResponse
         """

rasa/shared/providers/llm/llm_response.py

@@ -1,5 +1,11 @@
-from dataclasses import dataclass, field, asdict
-from typing import Dict, List, Optional
+import functools
+import time
+from dataclasses import asdict, dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+
+import structlog
+
+structlogger = structlog.get_logger()
 
 
 @dataclass
@@ -16,6 +22,17 @@ class LLMUsage:
     def __post_init__(self) -> None:
         self.total_tokens = self.prompt_tokens + self.completion_tokens
 
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Any]) -> "LLMUsage":
+        """Creates an LLMUsage object from a dictionary.
+        If any keys are missing, they will default to zero
+        or whatever default you prefer.
+        """
+        return cls(
+            prompt_tokens=data.get("prompt_tokens"),
+            completion_tokens=data.get("completion_tokens"),
+        )
+
     def to_dict(self) -> dict:
         """Converts the LLMUsage dataclass instance into a dictionary."""
         return asdict(self)
@@ -42,9 +59,51 @@ class LLMResponse:
     """Optional dictionary for storing additional information related to the
     completion that may not be covered by other fields."""
 
+    latency: Optional[float] = None
+    """Optional field to store the latency of the LLM API call."""
+
+    @classmethod
+    def from_dict(cls, data: Dict[Text, Any]) -> "LLMResponse":
+        """Creates an LLMResponse from a dictionary."""
+        usage_data = data.get("usage", {})
+        usage_obj = LLMUsage.from_dict(usage_data) if usage_data else None
+
+        return cls(
+            id=data["id"],
+            choices=data["choices"],
+            created=data["created"],
+            model=data.get("model"),
+            usage=usage_obj,
+            additional_info=data.get("additional_info"),
+            latency=data.get("latency"),
+        )
+
+    @classmethod
+    def ensure_llm_response(cls, response: Union[str, "LLMResponse"]) -> "LLMResponse":
+        if isinstance(response, LLMResponse):
+            return response
+
+        structlogger.warn("llm_response.deprecated_response_type", response=response)
+        data = {"id": None, "choices": [response], "created": None}
+        return LLMResponse.from_dict(data)
+
     def to_dict(self) -> dict:
         """Converts the LLMResponse dataclass instance into a dictionary."""
         result = asdict(self)
         if self.usage:
             result["usage"] = self.usage.to_dict()
         return result
+
+
+def measure_llm_latency(
+    func: Callable[..., Awaitable[Optional[LLMResponse]]],
+) -> Callable[..., Awaitable[Optional[LLMResponse]]]:
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Optional[LLMResponse]:
+        start = time.perf_counter()
+        result: Optional[LLMResponse] = await func(*args, **kwargs)
+        if result:
+            result.latency = time.perf_counter() - start
+        return result
+
+    return wrapper

rasa/shared/providers/llm/openai_llm_client.py

@@ -1,16 +1,22 @@
+from __future__ import annotations
+
 import os
 import re
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 
 import structlog
 
 from rasa.shared.constants import (
     OPENAI_API_BASE_ENV_VAR,
-    OPENAI_API_VERSION_ENV_VAR,
     OPENAI_API_TYPE_ENV_VAR,
+    OPENAI_API_VERSION_ENV_VAR,
     OPENAI_PROVIDER,
 )
 from rasa.shared.providers._configs.openai_client_config import OpenAIClientConfig
+from rasa.shared.providers.constants import (
+    LITE_LLM_API_BASE_FIELD,
+    LITE_LLM_API_VERSION_FIELD,
+)
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
 
 structlogger = structlog.get_logger()
@@ -57,7 +63,7 @@ class OpenAILLMClient(_BaseLiteLLMClient):
         self.validate_client_setup()
 
     @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "OpenAILLMClient":
+    def from_config(cls, config: Dict[str, Any]) -> OpenAILLMClient:
         """
         Initializes the client from given configuration.
 
@@ -148,8 +154,8 @@ class OpenAILLMClient(_BaseLiteLLMClient):
         fn_args = super()._completion_fn_args
         fn_args.update(
             {
-                "api_base": self.api_base,
-                "api_version": self.api_version,
+                LITE_LLM_API_BASE_FIELD: self.api_base,
+                LITE_LLM_API_VERSION_FIELD: self.api_version,
             }
         )
         return fn_args

rasa/shared/providers/llm/rasa_llm_client.py

@@ -1,23 +1,28 @@
+from __future__ import annotations
+
 from typing import Any, Dict, Optional
 
 import structlog
 
 from rasa.shared.constants import (
-    RASA_PROVIDER,
     OPENAI_PROVIDER,
+    RASA_PROVIDER,
 )
 from rasa.shared.providers._configs.rasa_llm_client_config import (
     RasaLLMClientConfig,
 )
-from rasa.utils.licensing import retrieve_license_from_env
+from rasa.shared.providers.constants import (
+    LITE_LLM_API_BASE_FIELD,
+    LITE_LLM_API_KEY_FIELD,
+)
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
-
+from rasa.utils.licensing import retrieve_license_from_env
 
 structlogger = structlog.get_logger()
 
 
 class RasaLLMClient(_BaseLiteLLMClient):
-    """A client for interfacing with a Rasa-Hosted LLM endpoint that uses
+    """A client for interfacing with a Rasa-Hosted LLM endpoint that uses.
 
     Parameters:
         model (str): The model or deployment name.
@@ -50,15 +55,12 @@ class RasaLLMClient(_BaseLiteLLMClient):
 
     @property
     def api_base(self) -> Optional[str]:
-        """
-        Returns the base API URL for the openai llm client.
-        """
+        """Returns the base API URL for the openai llm client."""
         return self._api_base
 
     @property
     def provider(self) -> str:
-        """
-        Returns the provider name for the self hosted llm client.
+        """Returns the provider name for the self hosted llm client.
 
         Returns:
             String representing the provider name.
@@ -83,17 +85,18 @@ class RasaLLMClient(_BaseLiteLLMClient):
 
     @property
     def _completion_fn_args(self) -> Dict[str, Any]:
-        """Returns the completion arguments for invoking a call through
-        LiteLLM's completion functions.
-        """
+        """Returns the completion arguments for invoking a call using completions."""
         fn_args = super()._completion_fn_args
         fn_args.update(
-            {"api_base": self.api_base, "api_key": retrieve_license_from_env()}
+            {
+                LITE_LLM_API_BASE_FIELD: self.api_base,
+                LITE_LLM_API_KEY_FIELD: retrieve_license_from_env(),
+            }
         )
         return fn_args
 
     @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "RasaLLMClient":
+    def from_config(cls, config: Dict[str, Any]) -> RasaLLMClient:
         try:
             client_config = RasaLLMClientConfig.from_dict(config)
         except ValueError as e:

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -1,21 +1,25 @@
-from typing import Any, Dict, List, Optional, Union
-from litellm import (
-    text_completion,
-    atext_completion,
-)
+from __future__ import annotations
+
 import logging
 import os
+from typing import Any, Dict, List, Optional, Union
+
 import structlog
+from litellm import atext_completion, text_completion
 
 from rasa.shared.constants import (
-    SELF_HOSTED_VLLM_PREFIX,
-    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
     API_KEY,
+    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
+    SELF_HOSTED_VLLM_PREFIX,
 )
+from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
-from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.providers.constants import (
+    LITE_LLM_API_BASE_FIELD,
+    LITE_LLM_API_VERSION_FIELD,
+)
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
 from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.shared.utils.io import suppress_logs
@@ -66,7 +70,7 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             self._apply_dummy_api_key_if_missing()
 
     @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "SelfHostedLLMClient":
+    def from_config(cls, config: Dict[str, Any]) -> SelfHostedLLMClient:
         try:
             client_config = SelfHostedLLMClientConfig.from_dict(config)
         except ValueError as e:
@@ -183,8 +187,8 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         fn_args = super()._completion_fn_args
         fn_args.update(
             {
-                "api_base": self.api_base,
-                "api_version": self.api_version,
+                LITE_LLM_API_BASE_FIELD: self.api_base,
+                LITE_LLM_API_VERSION_FIELD: self.api_version,
             }
         )
         return fn_args
@@ -213,7 +217,14 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         Asynchronously generate completions for given prompt.
 
         Args:
-            prompt: Prompt to generate the completion for.
+            messages: The message can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
         Returns:
             List of message completions.
         Raises:
@@ -225,7 +236,9 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         except Exception as e:
             raise ProviderClientAPIException(e)
 
-    async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
+    async def acompletion(
+        self, messages: Union[List[dict], List[str], str]
+    ) -> LLMResponse:
         """Asynchronous completion of the model with the given messages.
 
         Method overrides the base class method to call the appropriate
@@ -234,7 +247,14 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         atext_completion method is called.
 
         Args:
-            messages: The messages to be used for completion.
+            messages: The message can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
 
         Returns:
             The completion response.
@@ -243,7 +263,7 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             return await super().acompletion(messages)
         return await self._atext_completion(messages)
 
-    def completion(self, messages: Union[List[str], str]) -> LLMResponse:
+    def completion(self, messages: Union[List[dict], List[str], str]) -> LLMResponse:
         """Completion of the model with the given messages.
 
         Method overrides the base class method to call the appropriate

rasa/shared/providers/mappings.py

@@ -1,13 +1,28 @@
-from typing import Dict, Type, Optional
+from typing import Dict, Optional, Type
 
 from rasa.shared.constants import (
     AZURE_OPENAI_PROVIDER,
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     OPENAI_PROVIDER,
-    SELF_HOSTED_PROVIDER,
     RASA_PROVIDER,
+    SELF_HOSTED_PROVIDER,
     SELF_HOSTED_VLLM_PREFIX,
 )
+from rasa.shared.providers._configs.azure_openai_client_config import (
+    AzureOpenAIClientConfig,
+)
+from rasa.shared.providers._configs.client_config import ClientConfig
+from rasa.shared.providers._configs.default_litellm_client_config import (
+    DefaultLiteLLMClientConfig,
+)
+from rasa.shared.providers._configs.huggingface_local_embedding_client_config import (
+    HuggingFaceLocalEmbeddingClientConfig,
+)
+from rasa.shared.providers._configs.openai_client_config import OpenAIClientConfig
+from rasa.shared.providers._configs.rasa_llm_client_config import RasaLLMClientConfig
+from rasa.shared.providers._configs.self_hosted_llm_client_config import (
+    SelfHostedLLMClientConfig,
+)
 from rasa.shared.providers.embedding.azure_openai_embedding_client import (
     AzureOpenAIEmbeddingClient,
 )
@@ -25,24 +40,8 @@ from rasa.shared.providers.llm.azure_openai_llm_client import AzureOpenAILLMClie
 from rasa.shared.providers.llm.default_litellm_llm_client import DefaultLiteLLMClient
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.providers.llm.openai_llm_client import OpenAILLMClient
-from rasa.shared.providers.llm.self_hosted_llm_client import SelfHostedLLMClient
 from rasa.shared.providers.llm.rasa_llm_client import RasaLLMClient
-from rasa.shared.providers._configs.azure_openai_client_config import (
-    AzureOpenAIClientConfig,
-)
-from rasa.shared.providers._configs.default_litellm_client_config import (
-    DefaultLiteLLMClientConfig,
-)
-from rasa.shared.providers._configs.huggingface_local_embedding_client_config import (
-    HuggingFaceLocalEmbeddingClientConfig,
-)
-from rasa.shared.providers._configs.openai_client_config import OpenAIClientConfig
-from rasa.shared.providers._configs.self_hosted_llm_client_config import (
-    SelfHostedLLMClientConfig,
-)
-from rasa.shared.providers._configs.rasa_llm_client_config import RasaLLMClientConfig
-
-from rasa.shared.providers._configs.client_config import ClientConfig
+from rasa.shared.providers.llm.self_hosted_llm_client import SelfHostedLLMClient
 
 _provider_to_llm_client_mapping: Dict[str, Type[LLMClient]] = {
     OPENAI_PROVIDER: OpenAILLMClient,

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -1,21 +1,25 @@
-from typing import Any, Dict, List
+from __future__ import annotations
+
 import os
-import structlog
+from copy import deepcopy
+from typing import Any, Dict, List
 
+import structlog
 from litellm import Router
 
 from rasa.shared.constants import (
-    MODEL_LIST_KEY,
+    API_KEY,
+    LITELLM_PARAMS_KEY,
+    MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_LIST_KEY,
     ROUTER_CONFIG_KEY,
-    SELF_HOSTED_VLLM_PREFIX,
     SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
-    LITELLM_PARAMS_KEY,
-    API_KEY,
-    MODEL_CONFIG_KEY,
+    SELF_HOSTED_VLLM_PREFIX,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
+from rasa.shared.providers._configs.azure_entra_id_config import AzureEntraIDOAuthConfig
 from rasa.shared.providers._configs.litellm_router_client_config import (
     LiteLLMRouterClientConfig,
 )
@@ -59,12 +63,8 @@ class _BaseLiteLLMRouterClient:
         self._extra_parameters = kwargs or {}
         self.additional_client_setup()
         try:
-            resolved_model_configurations = (
-                self._resolve_env_vars_in_model_configurations()
-            )
-            self._router_client = Router(
-                model_list=resolved_model_configurations, **router_settings
-            )
+            # We instantiate a router client here to validate the configuration.
+            self._router_client = self._create_router_client()
         except Exception as e:
             event_info = "Cannot instantiate a router client."
             structlogger.error(
@@ -93,7 +93,7 @@ class _BaseLiteLLMRouterClient:
                 return
 
     @classmethod
-    def from_config(cls, config: Dict[str, Any]) -> "_BaseLiteLLMRouterClient":
+    def from_config(cls, config: Dict[str, Any]) -> _BaseLiteLLMRouterClient:
         """Instantiates a LiteLLM Router Embedding client from a configuration dict.
 
         Args:
@@ -143,6 +143,14 @@ class _BaseLiteLLMRouterClient:
     @property
     def router_client(self) -> Router:
         """Returns the instantiated LiteLLM Router client."""
+        # In ca se oauth is used, due to a bug in LiteLLM,
+        # azure_ad_token_provider is not working as expected.
+        # To work around this, we create a new client every
+        # time we need to make a call which will
+        # ensure that the token is always fresh.
+        # GitHub issue for LiteLLm: https://github.com/BerriAI/litellm/issues/4417
+        if self._has_oauth():
+            return self._create_router_client()
         return self._router_client
 
     @property
@@ -173,11 +181,36 @@ class _BaseLiteLLMRouterClient:
             **self._litellm_extra_parameters,
         }
 
+    def _create_router_client(self) -> Router:
+        resolved_model_configurations = self._resolve_env_vars_in_model_configurations()
+        return Router(model_list=resolved_model_configurations, **self.router_settings)
+
+    def _has_oauth(self) -> bool:
+        for model_configuration in self.model_configurations:
+            if model_configuration.get("litellm_params", {}).get("oauth", None):
+                return True
+        return False
+
     def _resolve_env_vars_in_model_configurations(self) -> List:
         model_configuration_with_resolved_keys = []
         for model_configuration in self.model_configurations:
             resolved_model_configuration = resolve_environment_variables(
-                model_configuration
+                deepcopy(model_configuration)
             )
+
+            if not isinstance(resolved_model_configuration, dict):
+                continue
+
+            lite_llm_params = resolved_model_configuration.get("litellm_params", {})
+            if lite_llm_params.get("oauth", None):
+                oauth_config_dict = lite_llm_params.pop("oauth")
+                oauth_config = AzureEntraIDOAuthConfig.from_dict(oauth_config_dict)
+                credential = oauth_config.create_azure_credential()
+                # token_provider = get_bearer_token_provider(
+                #     credential, *oauth_config.scopes
+                # )
+                resolved_model_configuration["litellm_params"]["azure_ad_token"] = (
+                    credential.get_token(*oauth_config.scopes).token
+                )
             model_configuration_with_resolved_keys.append(resolved_model_configuration)
         return model_configuration_with_resolved_keys

rasa/shared/providers/router/router_client.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any, Dict, List, Protocol, runtime_checkable
 
 
@@ -9,7 +11,7 @@ class RouterClient(Protocol):
     """
 
     @classmethod
-    def from_config(cls, config: dict) -> "RouterClient":
+    def from_config(cls, config: dict) -> RouterClient:
         """
         Initializes the router client with the given configuration.
 

rasa/shared/utils/cli.py

@@ -1,7 +1,7 @@
 import math
 import shutil
 import sys
-from typing import Any, Text, NoReturn
+from typing import Any, NoReturn, Text
 
 import rasa.shared.utils.io
 

rasa/shared/utils/common.py

@@ -7,12 +7,13 @@ import os
 import pkgutil
 import sys
 from types import ModuleType
-from typing import Sequence, Text, Dict, Optional, Any, List, Callable, Collection, Type
+from typing import Any, Callable, Collection, Dict, List, Optional, Sequence, Text, 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
+from rasa.shared.utils.cli import print_success
 
 logger = logging.getLogger(__name__)
 
@@ -322,3 +323,16 @@ def validate_environment(
             raise MissingDependencyException(
                 f"Missing package for {component_name}: {p}"
             )
+
+
+def display_research_study_prompt() -> None:
+    """Logs a prompt to get users to participate in a UX Improvement research study."""
+    separator = "-" * 54
+    message = f"""
+{separator}
+Want to help shape the future of Rasa Pro?
+Share your feedback in a short conversation with our team.
+Sign up at: https://calendly.com/alvaro-rasa/rasa-pro-installation
+{separator}
+"""
+    print_success(message)

rasa/shared/utils/constants.py

@@ -2,3 +2,6 @@ DEFAULT_ENCODING = "utf-8"
 
 READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR = "READ_YAML_FILE_CACHE_MAXSIZE"
 DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE = 256
+RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME = (
+    "RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS"
+)

rasa/shared/utils/health_check/embeddings_health_check_mixin.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 
 class EmbeddingsHealthCheckMixin:

rasa/shared/utils/health_check/health_check.py

@@ -1,16 +1,16 @@
 import os
 import sys
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
     LLM_API_HEALTH_CHECK_ENV_VAR,
     MODELS_CONFIG_KEY,
-    LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers.embedding.embedding_client import EmbeddingClient
 from rasa.shared.providers.llm.llm_client import LLMClient
-from rasa.shared.utils.llm import llm_factory, structlogger, embedder_factory
+from rasa.shared.utils.llm import embedder_factory, llm_factory, structlogger
 
 
 def try_instantiate_llm_client(

rasa/shared/utils/health_check/llm_health_check_mixin.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 
 class LLMHealthCheckMixin:

rasa/shared/utils/io.py

@@ -12,7 +12,7 @@ from collections import OrderedDict
 from functools import wraps
 from hashlib import md5
 from pathlib import Path
-from typing import Any, cast, Callable, Dict, List, Optional, Text, Type, TypeVar, Union
+from typing import Any, Callable, Dict, List, Optional, Text, Type, TypeVar, Union, cast
 
 import portalocker