rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/core/channels/voice_stream/voice_channel.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import copy
+import string
 import time
 from dataclasses import asdict, dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
@@ -37,6 +38,7 @@ from rasa.core.channels.voice_stream.call_state import (
 )
 from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
+from rasa.core.channels.voice_stream.tts.deepgram import DeepgramTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.util import (
@@ -53,6 +55,13 @@ from rasa.utils.io import remove_emojis
 logger = structlog.get_logger(__name__)
 
 # define constants for the voice channel
+DEFAULT_INTERRUPTION_MIN_WORDS = 3
+
+
+@dataclass
+class InterruptionConfig:
+    enabled: bool = False
+    min_words: int = DEFAULT_INTERRUPTION_MIN_WORDS
 
 
 @dataclass
@@ -125,6 +134,8 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
         return AzureTTS.from_config_dict(tts_config)
     elif name.lower() == "cartesia":
         return CartesiaTTS.from_config_dict(tts_config)
+    elif name.lower() == "deepgram":
+        return DeepgramTTS.from_config_dict(tts_config)
     else:
         mark_as_beta_feature("Custom TTS Engine")
         try:
@@ -270,6 +281,10 @@ class VoiceOutputChannel(OutputChannel):
         except (WebsocketClosed, ServerError):
             call_state.connection_failed = True
 
+        # Is the response interruptible?
+        allow_interruptions = kwargs.get("allow_interruptions", True)
+        call_state.channel_data["allow_interruptions"] = allow_interruptions
+
         if cached_audio_bytes:
             audio_stream = self.chunk_audio(cached_audio_bytes)
         else:
@@ -368,6 +383,7 @@ class VoiceInputChannel(InputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, Any]] = None,
     ):
         if self.requires_voice_license:
             validate_voice_license_scope()
@@ -376,12 +392,21 @@ class VoiceInputChannel(InputChannel):
         self.asr_config = asr_config
         self.tts_config = tts_config
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
+        if interruptions:
+            self.interruption_config = InterruptionConfig(**interruptions)
+        else:
+            self.interruption_config = InterruptionConfig()
+
+        if self.interruption_config.enabled:
+            mark_as_beta_feature(f"Interruption Handling in {self.name()}")
 
         logger.info(
             "voice_channel.initialized",
+            name=self.name(),
             server_url=self.server_url,
             asr_config=self.asr_config,
             tts_config=self.tts_config,
+            interruption_config=self.interruption_config,
         )
 
     def get_sender_id(self, call_parameters: CallParameters) -> str:
@@ -463,6 +488,43 @@ class VoiceInputChannel(InputChannel):
         """Map a channel input message to a voice channel action."""
         raise NotImplementedError
 
+    def should_interrupt(self, e: ASREvent) -> bool:
+        """Determine if the current ASR event should interrupt playback.
+        Returns True if the bot response is interruptible
+        And if the user spoke more than 3 words.
+
+        Arguments:
+            e: The ASR event to evaluate.
+
+        Returns:
+            True if the event should interrupt playback, False otherwise.
+        """
+        # Are interruptions are enabled for the channel?
+        if not self.interruption_config.enabled:
+            return False
+
+        # Is the bot response interruptible?
+        if not call_state.channel_data.get("allow_interruptions", True):
+            return False
+
+        # Did the user speak more than 3 words?
+        min_words = self.interruption_config.min_words
+        if isinstance(e, UserIsSpeaking):
+            translator = str.maketrans("", "", string.punctuation)
+            words = e.text.translate(translator).split()
+            return len(words) >= min_words
+        return False
+
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio.
+
+        This function is used for interruption handling.
+        As not all channels support flushing bot audio buffer,
+        if a channel does not implement it. It has no effect."""
+        pass
+
     async def run_audio_streaming(
         self,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
@@ -598,6 +660,8 @@ class VoiceInputChannel(InputChannel):
                 call_state.user_speech_start_time = time.time()
             self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True
+            if self.should_interrupt(e):
+                await self.interrupt_playback(voice_websocket, call_parameters)
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(

rasa/core/concurrent_lock_store.py

@@ -4,6 +4,7 @@ from collections import deque
 from typing import Deque, Optional, Text
 
 import structlog
+from pydantic import ValidationError
 
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
@@ -12,6 +13,12 @@ from rasa.core.lock_store import (
     LockError,
     LockStore,
 )
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
+from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
 
 DEFAULT_REDIS_DB = 1
@@ -74,9 +81,10 @@ class ConcurrentRedisLockStore(LockStore):
                 alphanumeric.
             socket_timeout - Timeout in seconds after which an exception will be raised
                 in case Redis doesn't respond within `socket_timeout` seconds.
+            deployment_mode - Redis deployment mode: standard, cluster, or sentinel.
+            endpoints - List of endpoints for cluster/sentinel mode in host:port format.
+            sentinel_service - Sentinel service name.
         """
-        import redis
-
         host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
         port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
         db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
@@ -90,20 +98,33 @@ class ConcurrentRedisLockStore(LockStore):
         socket_timeout = endpoint_config.kwargs.get(
             "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
         )
-
-        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,
+        deployment_mode = endpoint_config.kwargs.get(
+            "deployment_mode", DeploymentMode.STANDARD.value
         )
+        endpoints = endpoint_config.kwargs.get("endpoints", [])
+        sentinel_service = endpoint_config.kwargs.get("sentinel_service")
 
+        try:
+            redis_config = RedisConfig(
+                host=host,
+                port=port,
+                db=db,
+                username=username,
+                password=password,
+                use_ssl=use_ssl,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile=ssl_keyfile,
+                ssl_ca_certs=ssl_ca_certs,
+                socket_timeout=socket_timeout,
+                deployment_mode=deployment_mode,
+                endpoints=endpoints,
+                sentinel_service=sentinel_service,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
+
+        self.deployment_mode = deployment_mode
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
             structlogger.debug(
@@ -129,6 +150,32 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            # In cluster mode, use SCAN to get keys more reliably
+            keys = []
+            cursor = 0
+
+            while True:
+                try:
+                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                    keys.extend(batch_keys)
+                    if cursor == 0:
+                        break
+                except Exception as e:
+                    structlogger.warning(
+                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                        event_info=f"SCAN interrupted in cluster mode: {e}. "
+                        f"Returning {len(keys)} keys found so far.",
+                    )
+                    break
+        else:
+            # Standard and sentinel modes use KEYS
+            keys = self.red.keys(pattern)
+
+        return keys
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:
@@ -157,11 +204,14 @@ class ConcurrentRedisLockStore(LockStore):
         tickets: Deque[Ticket] = deque()
 
         pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         for key in redis_keys:
             serialised_ticket = self.red.get(key)
             if serialised_ticket:
+                # Handle bytes to string conversion for JSON parsing
+                if isinstance(serialised_ticket, bytes):
+                    serialised_ticket = serialised_ticket.decode("utf-8")
                 ticket = Ticket.from_dict(json.loads(serialised_ticket))
                 tickets.appendleft(ticket)
 
@@ -172,7 +222,7 @@ class ConcurrentRedisLockStore(LockStore):
     def delete_lock(self, conversation_id: Text) -> None:
         """Deletes lock for conversation ID."""
         pattern = self.key_prefix + conversation_id + ":*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         if not redis_keys:
             structlogger.debug(

rasa/core/{available_endpoints.py → config/available_endpoints.py}

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import dataclasses
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from rasa.core.constants import MCP_SERVERS_KEY
 from rasa.shared.core.constants import (
     GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
     GLOBAL_SILENCE_TIMEOUT_KEY,
@@ -57,14 +60,46 @@ class InteractionHandlingConfig:
         )
 
 
+class MCPServerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    name: str = Field(..., description="The name of the MCP server.")
+    url: str = Field(..., description="The URL of the MCP server.")
+    type: str = Field(..., description="The type of the MCP server.")
+    additional_params: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional parameters for the MCP server."
+    )
+
+    @model_validator(mode="after")
+    def validate_type(self) -> MCPServerConfig:
+        # validate that type is "http"
+        if self.type not in ["http", "https"]:
+            raise ValueError(f"Invalid MCP server type: {self.type}")
+        # validate that name and url are not empty
+        if not self.name or not self.url:
+            raise ValueError("Name and URL cannot be empty")
+        return self
+
+    @model_validator(mode="before")
+    def collect_additional_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        base_fields = {"name", "url", "type"}
+        extras = {k: v for k, v in values.items() if k not in base_fields}
+        if extras:
+            values["additional_params"] = extras
+            # remove them from top level so Pydantic doesn’t complain
+            for k in extras:
+                values.pop(k)
+        return values
+
+
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
     _instance = None
 
     @classmethod
-    def read_endpoints(cls, endpoint_file: str) -> AvailableEndpoints:
+    def read_endpoints(cls, endpoint_file: Path) -> AvailableEndpoints:
         """Read the different endpoints from a yaml file."""
+
         nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
         nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
         action = read_endpoint_config(endpoint_file, endpoint_type="action_endpoint")
@@ -75,6 +110,14 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        raw_mcp_servers = read_property_config_from_endpoints_file(
+            endpoint_file, property_name=MCP_SERVERS_KEY
+        )
+        mcp_servers = (
+            [MCPServerConfig(**server) for server in raw_mcp_servers]
+            if raw_mcp_servers
+            else None
+        )
         model_groups = read_property_config_from_endpoints_file(
             endpoint_file, property_name="model_groups"
         )
@@ -89,6 +132,7 @@ class AvailableEndpoints:
         )
 
         return cls(
+            endpoint_file,
             nlg,
             nlu,
             action,
@@ -97,6 +141,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            mcp_servers,
             model_groups,
             privacy,
             interaction_handling,
@@ -104,6 +149,7 @@ class AvailableEndpoints:
 
     def __init__(
         self,
+        config_file_path: Optional[Path] = None,
         nlg: Optional[EndpointConfig] = None,
         nlu: Optional[EndpointConfig] = None,
         action: Optional[EndpointConfig] = None,
@@ -112,6 +158,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        mcp_servers: Optional[List[MCPServerConfig]] = None,
         model_groups: Optional[List[Dict[str, Any]]] = None,
         privacy: Optional[Dict[str, Any]] = None,
         interaction_handling: InteractionHandlingConfig = InteractionHandlingConfig(
@@ -119,6 +166,7 @@ class AvailableEndpoints:
         ),
     ) -> None:
         """Create an `AvailableEndpoints` object."""
+        self.config_file_path = config_file_path
         self.model = model
         self.action = action
         self.nlu = nlu
@@ -127,20 +175,7 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.mcp_servers = mcp_servers
         self.model_groups = model_groups
         self.privacy = privacy
         self.interaction_handling = interaction_handling
-
-    @classmethod
-    def get_instance(
-        cls, endpoint_file: Optional[str] = DEFAULT_ENDPOINTS_PATH
-    ) -> AvailableEndpoints:
-        """Get the singleton instance of AvailableEndpoints."""
-        # Ensure that the instance is initialized only once.
-        if cls._instance is None:
-            cls._instance = cls.read_endpoints(endpoint_file)
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None

rasa/core/config/configuration.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import Literal, Optional
+
+import structlog
+
+from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.credentials import CredentialsConfig
+from rasa.core.config.message_procesing_config import MessageProcessingConfig
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_CREDENTIALS_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclasses.dataclass
+class ValidatedConfigPaths:
+    credentials_path: Optional[Path] = None
+    endpoints_path: Optional[Path] = None
+    message_processing_config_path: Optional[Path] = None
+
+
+@dataclasses.dataclass
+class ConfigPath:
+    target: Optional[Path] = None
+    type: Literal["credentials", "endpoints", "config"] = "endpoints"
+    alternative_targets: list[Path] = dataclasses.field(default_factory=list)
+    default_path: str = ""
+
+    @staticmethod
+    def _validate(
+        config_path: ConfigPath, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        validated_path = get_validated_path(
+            config_path.target,
+            config_path.type,
+            config_path.alternative_targets,
+            can_be_missing,
+        )
+
+        if validated_path is None and can_be_missing:
+            logger.debug(
+                f"No {config_path.type} configuration file found. "
+                f"Proceeding without {config_path.type} configuration."
+            )
+
+        if isinstance(validated_path, str):
+            validated_path = Path(validated_path)
+
+        return validated_path
+
+
+@dataclasses.dataclass
+class CredentialsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="credentials",
+            alternative_targets=[Path(DEFAULT_CREDENTIALS_PATH)],
+            default_path=DEFAULT_CREDENTIALS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = CredentialsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CREDENTIALS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / CredentialsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class EndpointsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="endpoints",
+            alternative_targets=[Path(DEFAULT_ENDPOINTS_PATH)],
+            default_path=DEFAULT_ENDPOINTS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = EndpointsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_ENDPOINTS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / EndpointsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class MessageProcessingConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="config",
+            alternative_targets=[Path(DEFAULT_CONFIG_PATH)],
+            default_path=DEFAULT_CONFIG_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = MessageProcessingConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CONFIG_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / MessageProcessingConfigPath.default_file_path()
+
+
+class Configuration:
+    _instance: Optional[Configuration] = None
+
+    def __init__(
+        self,
+        endpoints: AvailableEndpoints,
+        credentials: Optional[CredentialsConfig] = None,
+        message_processing_config: Optional[MessageProcessingConfig] = None,
+    ):
+        self.credentials = credentials
+        self.endpoints = endpoints
+        self.message_processing_config = message_processing_config
+
+    @classmethod
+    def initialise_empty(cls) -> Configuration:
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        return cls._instance
+
+    @classmethod
+    def initialise_endpoints(cls, endpoints_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_endpoints.start", endpoints_path=endpoints_path
+        )
+
+        validated_endpoints_path = EndpointsConfigPath.validate(endpoints_path)
+        endpoints = (
+            AvailableEndpoints.read_endpoints(validated_endpoints_path)
+            if validated_endpoints_path
+            else AvailableEndpoints()
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=endpoints, credentials=None, message_processing_config=None
+            )
+        else:
+            cls._instance.endpoints = endpoints
+        return cls._instance
+
+    @classmethod
+    def initialise_empty_endpoints(cls) -> Configuration:
+        logger.debug("configuration.initialise_empty_endpoints.start")
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=AvailableEndpoints(),
+                credentials=None,
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.endpoints = AvailableEndpoints()
+        return cls._instance
+
+    @classmethod
+    def initialise_message_processing(
+        cls, message_processing_config_path: Path
+    ) -> Configuration:
+        logger.debug(
+            "configuration.initialise_message_processing.start",
+            message_processing_config_path=message_processing_config_path,
+        )
+        validated_message_processing_path = MessageProcessingConfigPath.validate(
+            message_processing_config_path
+        )
+        message_processing_config = (
+            MessageProcessingConfig.load_from_file(validated_message_processing_path)
+            if validated_message_processing_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                message_processing_config=message_processing_config,
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+            )
+        else:
+            cls._instance.message_processing_config = message_processing_config
+        return cls._instance
+
+    @classmethod
+    def initialise_credentials(cls, credentials_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_credentials.start",
+            credentials_path=credentials_path,
+        )
+
+        validated_credentials_path = CredentialsConfigPath.validate(credentials_path)
+
+        credentials = (
+            CredentialsConfig.load_from_file(validated_credentials_path)
+            if validated_credentials_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=credentials,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.credentials = credentials
+        return cls._instance
+
+    @classmethod
+    def get_instance(cls) -> Configuration:
+        if cls._instance is None:
+            raise Exception(
+                "Configuration not initialized. "
+                "Call appropriate 'initialise' methods to "
+                "load the config when Rasa Pro starts: "
+                "initialise_endpoints(), "
+                "initialise_credentials(), "
+                "initialise_message_processing()"
+            )
+        return cls._instance

rasa/core/config/credentials.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict
+
+from rasa.shared.utils.yaml import read_config_file
+
+
+class CredentialsConfig:
+    def __init__(
+        self, channels: Dict[str, Dict[str, Any]], config_file_path: Path
+    ) -> None:
+        self.channels = channels
+        self.config_file_path = config_file_path
+
+    @classmethod
+    def load_from_file(cls, file_path: Path) -> CredentialsConfig:
+        credentials_dict = read_config_file(file_path)
+        return cls(credentials_dict, file_path)