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

rasa/env.py

@@ -0,0 +1,14 @@
+# A central place to define all environment variables used by Rasa
+
+AUTH_TOKEN_ENV = "AUTH_TOKEN"
+JWT_SECRET_ENV = "JWT_SECRET"
+JWT_METHOD_ENV = "JWT_METHOD"
+DEFAULT_JWT_METHOD = "HS256"
+JWT_PRIVATE_KEY_ENV = "JWT_PRIVATE_KEY"
+
+REMOTE_STORAGE_PATH_ENV = "REMOTE_STORAGE_PATH"
+BUCKET_NAME_ENV = "BUCKET_NAME"
+AWS_ENDPOINT_URL_ENV = "AWS_ENDPOINT_URL"
+AZURE_CONTAINER_ENV = "AZURE_CONTAINER"
+AZURE_ACCOUNT_NAME_ENV = "AZURE_ACCOUNT_NAME"
+AZURE_ACCOUNT_KEY_ENV = "AZURE_ACCOUNT_KEY"

rasa/exceptions.py

@@ -0,0 +1,69 @@
+from typing import Text
+from packaging import version
+from dataclasses import dataclass
+
+from rasa.shared.exceptions import RasaException
+from rasa.constants import MINIMUM_COMPATIBLE_VERSION
+
+
+@dataclass
+class UnsupportedModelVersionError(RasaException):
+    """Raised when a model is too old to be loaded.
+
+    Args:
+        model_version: the used model version that is not supported and triggered
+            this exception
+    """
+
+    model_version: Text
+
+    def __str__(self) -> Text:
+        minimum_version = version.parse(MINIMUM_COMPATIBLE_VERSION)
+        return (
+            f"The model version is trained using Rasa Pro {self.model_version} "
+            f"and is not compatible with your current installation "
+            f"which supports models build with Rasa Pro {minimum_version} "
+            f"or higher. "
+            f"This means that you either need to retrain your model "
+            f"or revert back to the Rasa version that trained the model "
+            f"to ensure that the versions match up again."
+        )
+
+
+class ModelNotFound(RasaException):
+    """Raised when a model is not found in the path provided by the user."""
+
+
+class NoEventsToMigrateError(RasaException):
+    """Raised when no events to be migrated are found."""
+
+
+class NoConversationsInTrackerStoreError(RasaException):
+    """Raised when a tracker store does not contain any conversations."""
+
+
+class NoEventsInTimeRangeError(RasaException):
+    """Raised when a tracker store does not contain events within a given time range."""
+
+
+class MissingDependencyException(RasaException):
+    """Raised if a python package dependency is needed, but not installed."""
+
+
+@dataclass
+class PublishingError(RasaException):
+    """Raised when publishing of an event fails.
+
+    Attributes:
+        timestamp -- Unix timestamp of the event during which publishing fails.
+    """
+
+    timestamp: float
+
+    def __str__(self) -> Text:
+        """Returns string representation of exception."""
+        return str(self.timestamp)
+
+
+class ActionLimitReached(RasaException):
+    """Raised when predicted action limit is reached."""

rasa/graph_components/converters/nlu_message_converter.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import Dict, Text, Any, List
+
+from rasa.core.channels.channel import UserMessage
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.nlu.constants import TEXT, TEXT_TOKENS
+from rasa.shared.nlu.training_data.message import Message
+
+
+class NLUMessageConverter(GraphComponent):
+    """Converts the user message into a NLU Message object."""
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> NLUMessageConverter:
+        """Creates component (see parent class for full docstring)."""
+        return cls()
+
+    def convert_user_message(self, messages: List[UserMessage]) -> List[Message]:
+        """Converts user message into Message object.
+
+        Args:
+            messages: The user messages which should be converted to be processed by
+                the NLU components.
+
+        Returns:
+            List containing only one instance of Message.
+            Else empty list if user message is None.
+        """
+        return [
+            Message(
+                data={
+                    TEXT: message.text,
+                    "message_id": message.message_id,
+                    "metadata": message.metadata,
+                },
+                output_properties={TEXT_TOKENS},
+            )
+            for message in messages
+        ]

rasa/graph_components/providers/domain_for_core_training_provider.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import copy
+from typing import Dict, Text, Any
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.constants import REQUIRED_SLOTS_KEY
+from rasa.shared.core.domain import KEY_RESPONSES, Domain, SESSION_CONFIG_KEY, KEY_FORMS
+
+
+class DomainForCoreTrainingProvider(GraphComponent):
+    """Provides domain without information that is irrelevant for core training.
+
+    The information that we retain includes:
+    - intents and their "used" and "ignored" entities because intents influence the
+      next action prediction directly and the latter flags determine whether the
+      listed entities influence the next action prediction
+    - entities, their roles and groups, and their `influence_conversation` flag because
+      all of those items are used by policies
+    - slots names along with their types, since this type information determines the
+      pre-featurization of slot values
+    - response keys (i.e. `utter_*) because those keys may appear in stories
+    - form names because those appear in stories
+    - how slots are filled (i.e. 'mappings' key under 'slots') because a domain instance
+      needs to be created by core during training time to parse the training data
+      properly
+
+    This information that we drop (or replace with default values) includes:
+    - the 'session_config' which determines details of a session e.g. whether data is
+      transferred from one session to the next (this is replaced with defaults as it
+      cannot just be removed)
+    - the actual text of a 'response' because those are only used by response selectors
+    - the actual configuration of 'forms' because those are not actually executed
+      by core components
+
+    References:
+        - `rasa.core.featurizer.tracker_featurizer.py` (used by all policies)
+        - `rasa.core.featurizer.single_state_featurizer.py` (used by ML policies)
+        - `rasa.shared.core.domain.get_active_state` (used by above references)
+        - `rasa.shared.core.slots.as_features` (used by above references)
+        - `rasa.shared.core.training_data.structures.StoryStep.explicit_events`
+           (i.e. slots needed for core training)
+    """
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> DomainForCoreTrainingProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls()
+
+    def provide(self, domain: Domain) -> Domain:
+        """Recreates the given domain but drops information that is irrelevant for core.
+
+        Args:
+            domain: A domain.
+
+        Returns:
+            A similar domain without information that is irrelevant for core training.
+        """
+        return self.create_pruned_version(domain)
+
+    @staticmethod
+    def create_pruned_version(domain: Domain) -> Domain:
+        """Recreates the given domain but drops information that is irrelevant for core.
+
+        Args:
+            domain: A domain.
+
+        Returns:
+             A similar domain without information that is irrelevant for core training.
+        """
+        serialized_domain = copy.deepcopy(domain.as_dict())
+
+        serialized_domain.pop("config", None)  # `store_entities_as_slots`
+        serialized_domain.pop(SESSION_CONFIG_KEY, None)
+        for response_name in serialized_domain.get(KEY_RESPONSES, []):
+            serialized_domain[KEY_RESPONSES][response_name] = []
+        for form_name in serialized_domain.get(KEY_FORMS, []):
+            serialized_domain[KEY_FORMS][form_name] = {REQUIRED_SLOTS_KEY: []}
+        return Domain.from_dict(serialized_domain)

rasa/graph_components/providers/domain_provider.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import Dict, Text, Any, Optional
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
+from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.importers.importer import TrainingDataImporter
+
+
+class DomainProvider(GraphComponent):
+    """Provides domain during training and inference time."""
+
+    def __init__(
+        self,
+        model_storage: ModelStorage,
+        resource: Resource,
+        domain: Optional[Domain] = None,
+    ) -> None:
+        """Creates domain provider."""
+        self._model_storage = model_storage
+        self._resource = resource
+        self._domain = domain
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> DomainProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls(model_storage, resource)
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> DomainProvider:
+        """Creates provider using a persisted version of itself."""
+        with model_storage.read_from(resource) as resource_directory:
+            domain = Domain.from_path(resource_directory)
+        return cls(model_storage, resource, domain)
+
+    def _persist(self, domain: Domain) -> None:
+        """Persists domain to model storage."""
+        with self._model_storage.write_to(self._resource) as resource_directory:
+            domain.persist(resource_directory / "domain.yml")
+
+    def provide_train(self, importer: TrainingDataImporter) -> Domain:
+        """Provides domain from training data during training."""
+        domain = importer.get_domain()
+        self._persist(domain)
+        return domain
+
+    def provide_inference(self) -> Domain:
+        """Provides the domain during inference."""
+        if self._domain is None:
+            # This can't really happen but if it happens then we fail early
+            raise InvalidConfigException(
+                "No domain was found. This is required for "
+                "making model predictions. Please make sure to "
+                "provide a valid domain during training."
+            )
+        return self._domain

rasa/graph_components/providers/flows_provider.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Text
+
+from rasa.engine.graph import ExecutionContext, GraphComponent
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader, YamlFlowsWriter
+
+from rasa.shared.core.flows import FlowsList
+
+FLOWS_PERSISTENCE_FILE_NAME = "flows.yml"
+
+
+class FlowsProvider(GraphComponent):
+    """Provides flows information during training and inference time."""
+
+    def __init__(
+        self,
+        model_storage: ModelStorage,
+        resource: Resource,
+        flows: FlowsList,
+    ) -> None:
+        """Creates flows provider."""
+        self._model_storage = model_storage
+        self._resource = resource
+        self._flows = flows
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> FlowsProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls(model_storage, resource, flows=FlowsList(underlying_flows=[]))
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> FlowsProvider:
+        """Creates provider using a persisted version of itself."""
+        with model_storage.read_from(resource) as resource_directory:
+            flows = YAMLFlowsReader.read_from_file(
+                resource_directory / FLOWS_PERSISTENCE_FILE_NAME
+            )
+        flows.validate()
+        return cls(model_storage, resource, flows)
+
+    def _persist(self, flows: FlowsList) -> None:
+        """Persists flows to model storage."""
+        with self._model_storage.write_to(self._resource) as resource_directory:
+            YamlFlowsWriter.dump(
+                flows.underlying_flows,
+                resource_directory / FLOWS_PERSISTENCE_FILE_NAME,
+            )
+
+    def provide_train(self, importer: TrainingDataImporter) -> FlowsList:
+        """Provides flows configuration from training data during training."""
+        self._flows = importer.get_flows()
+        self._persist(self._flows)
+        return self._flows
+
+    def provide_inference(self) -> FlowsList:
+        """Provides the flows configuration during inference."""
+        return self._flows

rasa/graph_components/providers/forms_provider.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import dataclasses
+
+from typing import Dict, Text, Any
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
+import rasa.shared.utils.io
+
+
+@dataclasses.dataclass
+class Forms:
+    """Holds the forms of the domain."""
+
+    data: Dict[Text, Any]
+
+    def fingerprint(self) -> Text:
+        """Returns a fingerprint of the responses."""
+        return rasa.shared.utils.io.get_dictionary_fingerprint(self.data)
+
+    def get(self, key: Text, default: Any) -> Any:
+        """Returns the value for the given key."""
+        return self.data.get(key, default)
+
+
+class FormsProvider(GraphComponent):
+    """Provides forms during training and inference time."""
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> FormsProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls()
+
+    def provide(self, domain: Domain) -> Forms:
+        """Returns the forms from the given domain."""
+        return Forms(data=domain.forms)

rasa/graph_components/providers/nlu_training_data_provider.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+from typing import Dict, Text, Any
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.training_data import (
+    TrainingData,
+    DEFAULT_TRAINING_DATA_OUTPUT_PATH,
+)
+
+
+class NLUTrainingDataProvider(GraphComponent):
+    """Provides NLU training data during training."""
+
+    def __init__(
+        self, config: Dict[Text, Any], model_storage: ModelStorage, resource: Resource
+    ) -> None:
+        """Creates a new NLU training data provider."""
+        self._config = config
+        self._model_storage = model_storage
+        self._resource = resource
+
+    @classmethod
+    def get_default_config(cls) -> Dict[Text, Any]:
+        """Returns the default config for NLU training data provider."""
+        return {"persist": False, "language": None}
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> NLUTrainingDataProvider:
+        """Creates a new NLU training data provider."""
+        return cls(config, model_storage, resource)
+
+    def _persist(self, training_data: TrainingData) -> None:
+        """Persists NLU training data to model storage."""
+        with self._model_storage.write_to(self._resource) as resource_directory:
+            training_data.persist(
+                dir_name=str(resource_directory),
+                filename=DEFAULT_TRAINING_DATA_OUTPUT_PATH,
+            )
+
+    def provide(self, importer: TrainingDataImporter) -> TrainingData:
+        """Provides nlu training data during training."""
+        if "language" in self._config:
+            training_data = importer.get_nlu_data(language=self._config["language"])
+        else:
+            training_data = importer.get_nlu_data()
+        if self._config["persist"]:
+            self._persist(training_data)
+        return training_data

rasa/graph_components/providers/responses_provider.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import dataclasses
+
+from typing import Dict, List, Text, Any
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
+import rasa.shared.utils.io
+
+
+@dataclasses.dataclass
+class Responses:
+    """Holds the responses of the domain."""
+
+    data: Dict[Text, List[Dict[Text, Any]]]
+
+    def fingerprint(self) -> Text:
+        """Returns a fingerprint of the responses."""
+        return rasa.shared.utils.io.get_dictionary_fingerprint(self.data)
+
+    def get(self, key: Text, default: Any) -> Any:
+        """Returns the value for the given key."""
+        return self.data.get(key, default)
+
+
+class ResponsesProvider(GraphComponent):
+    """Provides responses during training and inference time."""
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> ResponsesProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls()
+
+    def provide(self, domain: Domain) -> Responses:
+        """Returns the responses from the given domain."""
+        return Responses(data=domain.responses)

rasa/graph_components/providers/rule_only_provider.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+import dataclasses
+import logging
+from typing import Dict, Text, Any
+
+import rasa.shared.utils.io
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class RuleOnlyDataProvider(GraphComponent):
+    """Provides slots and loops that are only used in rules to other policies.
+
+    Policies can use this to exclude features which are only used by rules from the
+    featurization.
+    """
+
+    rule_only_data: Dict[Text, Any]
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> RuleOnlyDataProvider:
+        """Creates component (see parent class for docstring)."""
+        rule_only_data = {}
+        try:
+            with model_storage.read_from(resource) as directory:
+                rule_only_data = rasa.shared.utils.io.read_json_file(
+                    directory / "rule_only_data.json"
+                )
+        except ValueError:
+            logger.debug(
+                "Failed to load rule-only data from a trained 'RulePolicy'. "
+                "Providing empty rule-only data instead."
+            )
+
+        return cls(rule_only_data)
+
+    def provide(self) -> Dict[Text, Any]:
+        """Provides data to other graph component."""
+        return self.rule_only_data

rasa/graph_components/providers/story_graph_provider.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+from typing import Dict, Text, Any, List
+
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.training_data.structures import StoryGraph, StoryStep
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.core.training_data.story_writer.yaml_story_writer import (
+    YAMLStoryWriter,
+)
+from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
+    YAMLStoryReader,
+)
+
+
+STORIES_PERSISTENCE_FILE_NAME = "stories.yml"
+
+
+class StoryGraphProvider(GraphComponent):
+    """Provides the training data from stories."""
+
+    def __init__(
+        self,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        stories: StoryGraph = None,
+    ) -> None:
+        """Creates provider from config."""
+        self._config = config
+        self._model_storage = model_storage
+        self._resource = resource
+        self._stories = stories
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """Returns default configuration (see parent class for full docstring)."""
+        return {"exclusion_percentage": None}
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> StoryGraphProvider:
+        """Creates component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource)
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> StoryGraphProvider:
+        """Creates provider using a persisted version of itself."""
+        with model_storage.read_from(resource) as resource_directory:
+            reader = YAMLStoryReader()
+            story_steps = reader.read_from_file(
+                resource_directory / STORIES_PERSISTENCE_FILE_NAME
+            )
+        stories = StoryGraph(story_steps)
+        return cls(config, model_storage, resource, stories)
+
+    def _persist(self, story_steps: List[StoryStep]) -> None:
+        """Persists flows to model storage."""
+        with self._model_storage.write_to(self._resource) as resource_directory:
+            writer = YAMLStoryWriter()
+            writer.dump(
+                resource_directory / STORIES_PERSISTENCE_FILE_NAME,
+                story_steps,
+            )
+
+    def provide_train(self, importer: TrainingDataImporter) -> StoryGraph:
+        """Provides the story graph from the training data.
+
+        Args:
+            importer: instance of TrainingDataImporter.
+
+        Returns:
+            The story graph containing stories and rules used for training.
+        """
+        stories = importer.get_stories(**self._config)
+        self._persist(stories.story_steps)
+        return stories
+
+    def provide_inference(self) -> StoryGraph:
+        """Provides the stories configuration during inference."""
+        if self._stories is None:
+            self._stories = StoryGraph([])
+        return self._stories