rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/core/policies/ted_policy.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-
 import logging
+
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from pathlib import Path
 from collections import defaultdict
 import contextlib
-from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
 import numpy as np
 import tensorflow as tf
+from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
-from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -49,22 +49,18 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.events import EntitiesAdded, Event
 from rasa.shared.core.domain import Domain
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.features import (
-    Features,
-    save_features,
-    load_features,
-)
+from rasa.shared.nlu.training_data.features import Features
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.utils import train_utils
-from rasa.utils.tensorflow.feature_array import (
-    FeatureArray,
-    serialize_nested_feature_arrays,
-    deserialize_nested_feature_arrays,
-)
 from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
 from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.model_data import RasaModelData, FeatureSignature, Data
+from rasa.utils.tensorflow.model_data import (
+    RasaModelData,
+    FeatureSignature,
+    FeatureArray,
+    Data,
+)
 from rasa.utils.tensorflow.model_data_utils import convert_to_data_format
 from rasa.utils.tensorflow.constants import (
     LABEL,
@@ -965,32 +961,22 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted
         """
         model_filename = self._metadata_filename()
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.priority.json", self.priority
-        )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.meta.json", self.config
+        rasa.utils.io.json_pickle(
+            model_path / f"{model_filename}.priority.pkl", self.priority
         )
-        # save data example
-        serialize_nested_feature_arrays(
-            self.data_example,
-            str(model_path / f"{model_filename}.data_example.st"),
-            str(model_path / f"{model_filename}.data_example_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.meta.pkl", self.config
         )
-        # save label data
-        serialize_nested_feature_arrays(
-            dict(self._label_data.data) if self._label_data is not None else {},
-            str(model_path / f"{model_filename}.label_data.st"),
-            str(model_path / f"{model_filename}.label_data_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.data_example.pkl", self.data_example
         )
-        # save fake features
-        metadata = save_features(
-            self.fake_features, str(model_path / f"{model_filename}.fake_features.st")
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.fake_features.pkl", self.fake_features
         )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.fake_features_metadata.json", metadata
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.label_data.pkl",
+            dict(self._label_data.data) if self._label_data is not None else {},
         )
-
         entity_tag_specs = (
             [tag_spec._asdict() for tag_spec in self._entity_tag_specs]
             if self._entity_tag_specs
@@ -1008,29 +994,18 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted.
         """
         tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
-
-        # load data example
-        loaded_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.data_example.st"),
-            str(model_path / f"{cls._metadata_filename()}.data_example_metadata.json"),
+        loaded_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.data_example.pkl"
         )
-        # load label data
-        loaded_label_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.label_data.st"),
-            str(model_path / f"{cls._metadata_filename()}.label_data_metadata.json"),
+        label_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_data.pkl"
         )
-        label_data = RasaModelData(data=loaded_label_data)
-
-        # load fake features
-        metadata = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.fake_features_metadata.json"
+        fake_features = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.fake_features.pkl"
         )
-        fake_features = load_features(
-            str(model_path / f"{cls._metadata_filename()}.fake_features.st"), metadata
-        )
-
-        priority = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.priority.json"
+        label_data = RasaModelData(data=label_data)
+        priority = rasa.utils.io.json_unpickle(
+            model_path / f"{cls._metadata_filename()}.priority.pkl"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
             model_path / f"{cls._metadata_filename()}.entity_tag_specs.json"
@@ -1048,8 +1023,8 @@ class TEDPolicy(Policy):
             )
             for tag_spec in entity_tag_specs
         ]
-        model_config = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.meta.json"
+        model_config = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.meta.pkl"
         )
 
         return {
@@ -1095,7 +1070,7 @@ class TEDPolicy(Policy):
     ) -> TEDPolicy:
         featurizer = TrackerFeaturizer.load(model_path)
 
-        if not (model_path / f"{cls._metadata_filename()}.data_example.st").is_file():
+        if not (model_path / f"{cls._metadata_filename()}.data_example.pkl").is_file():
             return cls(
                 config,
                 model_storage,

rasa/core/policies/unexpected_intent_policy.py

@@ -5,7 +5,6 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
-
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,7 +16,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
-import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -105,6 +103,8 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
+
+import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -881,12 +881,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-
-        from safetensors.numpy import save_file
-
-        save_file(
-            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
-            model_path / f"{self._metadata_filename()}.label_quantiles.st",
+        io_utils.pickle_dump(
+            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
+            self.label_quantiles,
         )
 
     @classmethod
@@ -897,14 +894,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-
-        from safetensors.numpy import load_file
-
-        loaded_label_quantiles = load_file(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
+        label_quantiles = io_utils.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
         )
-        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
-
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

rasa/core/processor.py

@@ -46,15 +46,12 @@ from rasa.engine.runner.interface import GraphRunner
 from rasa.exceptions import ActionLimitReached, ModelNotFound
 from rasa.shared.core.constants import (
     ACTION_CORRECT_FLOW_SLOT,
-    SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-    SLOT_SILENCE_TIMEOUT,
     USER_INTENT_RESTART,
     ACTION_LISTEN_NAME,
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
     ACTION_EXTRACT_SLOTS,
-    USER_INTENT_SILENCE_TIMEOUT,
 )
 from rasa.shared.core.events import (
     ActionExecutionRejected,
@@ -104,9 +101,6 @@ logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_PREDICTIONS = int(os.environ.get("MAX_NUMBER_OF_PREDICTIONS", "10"))
-MAX_NUMBER_OF_PREDICTIONS_CALM = int(
-    os.environ.get("MAX_NUMBER_OF_PREDICTIONS_CALM", "1000")
-)
 
 
 class MessageProcessor:
@@ -120,7 +114,6 @@ class MessageProcessor:
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,
         max_number_of_predictions: int = MAX_NUMBER_OF_PREDICTIONS,
-        max_number_of_predictions_calm: int = MAX_NUMBER_OF_PREDICTIONS_CALM,
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
@@ -129,6 +122,7 @@ class MessageProcessor:
         self.nlg = generator
         self.tracker_store = tracker_store
         self.lock_store = lock_store
+        self.max_number_of_predictions = max_number_of_predictions
         self.on_circuit_break = on_circuit_break
         self.action_endpoint = action_endpoint
         self.model_filename, self.model_metadata, self.graph_runner = self._load_model(
@@ -136,10 +130,6 @@ class MessageProcessor:
         )
         self.endpoints = endpoints
 
-        self.max_number_of_predictions = max_number_of_predictions
-        self.max_number_of_predictions_calm = max_number_of_predictions_calm
-        self.is_calm_assistant = self._is_calm_assistant()
-
         if self.model_metadata.assistant_id is None:
             rasa.shared.utils.io.raise_warning(
                 f"The model metadata does not contain a value for the "
@@ -792,28 +782,6 @@ class MessageProcessor:
         )
 
         self._check_for_unseen_features(parse_data)
-        # resetting timeouts variables whenever something that is not a timeout occurs
-        if (
-            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
-            != USER_INTENT_SILENCE_TIMEOUT
-            and tracker
-        ):
-            if (
-                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
-                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
-            ):
-                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
-            if (
-                SLOT_SILENCE_TIMEOUT in tracker.slots
-                and tracker.slots[SLOT_SILENCE_TIMEOUT].value
-                != tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value
-            ):
-                tracker.update(
-                    SlotSet(
-                        SLOT_SILENCE_TIMEOUT,
-                        tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value,
-                    )
-                )
 
         return parse_data
 
@@ -1004,15 +972,11 @@ class MessageProcessor:
     ) -> int:
         """Select the action limit based on the tracker state.
 
-        This function determines the maximum number of predictions that should be
-        made during a dialogue conversation. Typically, the number of predictions
-        is limited to the number of actions executed so far in the conversation.
-        However, in certain states (e.g., when the user is correcting the
-        conversation flow), more predictions may be allowed as the system traverses
-        through a long dialogue flow.
-
-        Additionally, if the `ROUTE_TO_CALM_SLOT` is present in the tracker slots,
-        the action limit is adjusted to a separate limit for CALM-based flows.
+        Usually, we want to limit the number of predictions to the number of actions
+        that have been executed in the conversation so far. However, if the
+        conversation is currently in a state where the user is correcting the flow
+        we want to allow for more predictions to be made as we might be traversing
+        through a long flow.
 
         Args:
             tracker: instance of DialogueStateTracker.
@@ -1020,18 +984,6 @@ class MessageProcessor:
         Returns:
         The maximum number of predictions to make.
         """
-        # Check if it is a CALM assistant and if so, that the `ROUTE_TO_CALM_SLOT`
-        # is either not present or set to `True`.
-        # If it does, use the specific prediction limit for CALM assistants.
-        # Otherwise, use the default prediction limit.
-        if self.is_calm_assistant and (
-            not tracker.has_coexistence_routing_slot
-            or tracker.get_slot(ROUTE_TO_CALM_SLOT)
-        ):
-            max_number_of_predictions = self.max_number_of_predictions_calm
-        else:
-            max_number_of_predictions = self.max_number_of_predictions
-
         reversed_events = list(tracker.events)[::-1]
         is_conversation_in_flow_correction = False
         for e in reversed_events:
@@ -1046,10 +998,8 @@ class MessageProcessor:
             # allow for more predictions to be made as we might be traversing through
             # a long flow. We multiply the number of predictions by 10 to allow for
             # more predictions to be made - the factor is a best guess.
-            return max_number_of_predictions * 5
-
-        # Return the default
-        return max_number_of_predictions
+            return self.max_number_of_predictions * 5
+        return self.max_number_of_predictions
 
     def is_action_limit_reached(
         self, tracker: DialogueStateTracker, should_predict_another_action: bool
@@ -1279,13 +1229,11 @@ class MessageProcessor:
             tracker.update(events[0])
             return self.should_predict_another_action(action.name())
         except Exception:
-            structlogger.exception(
-                "rasa.core.processor.run_action.exception",
-                event_info=f"Encountered an exception while "
-                f"running action '{action.name()}'."
-                f"Bot will continue, but the actions events are lost. "
-                f"Please check the logs of your action server for "
-                f"more information.",
+            logger.exception(
+                f"Encountered an exception while running action '{action.name()}'."
+                "Bot will continue, but the actions events are lost. "
+                "Please check the logs of your action server for "
+                "more information."
             )
             events = []
 
@@ -1439,27 +1387,3 @@ class MessageProcessor:
         ]
 
         return len(filtered_commands) > 0
-
-    def _is_calm_assistant(self) -> bool:
-        """Inspects the nodes of the graph schema to determine whether
-        any node is associated with the `FlowPolicy`, which is indicative of a
-        CALM assistant setup.
-
-        Returns:
-            bool: True if any node in the graph schema uses `FlowPolicy`.
-        """
-        # Get the graph schema's nodes from the graph runner.
-        nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
-
-        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
-        # Iterate over the nodes and check if any node uses `FlowPolicy`.
-        for node_name, schema_node in nodes.items():
-            if (
-                schema_node.uses is not None
-                and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
-                == flow_policy_class_path
-            ):
-                return True
-
-        # Return False if no node is found using `FlowPolicy`.
-        return False

rasa/core/run.py

@@ -51,6 +51,7 @@ def create_http_input_channels(
         all_credentials = read_config_file(credentials_file)
     else:
         all_credentials = {}
+
     if channel:
         if len(all_credentials) > 1:
             logger.info(
@@ -225,7 +226,6 @@ def serve_application(
     request_timeout: Optional[int] = None,
     server_listeners: Optional[List[Tuple[Callable, Text]]] = None,
     inspect: Optional[bool] = False,
-    voice: Optional[bool] = False,
 ) -> None:
     """Run the API entrypoint."""
     if not channel and not credentials:
@@ -235,7 +235,7 @@ def serve_application(
 
     if inspect:
         logger.info("Starting development inspector.")
-        input_channels = [DevelopmentInspectProxy(ic, voice) for ic in input_channels]
+        input_channels = [DevelopmentInspectProxy(ic) for ic in input_channels]
 
         # the inspector needs the api to retrieve slots and flows
         enable_api = True

rasa/core/training/interactive.py

@@ -20,41 +20,25 @@ from typing import (
     cast,
 )
 
-import numpy as np
-import questionary
-import terminaltables.width_and_alignment
-from aiohttp import ClientError
-from colorclass import Color
-from questionary import Choice, Form, Question
 from sanic import Sanic, response
 from sanic.exceptions import NotFound
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from terminaltables import AsciiTable, SingleTable
+import terminaltables.width_and_alignment
+import numpy as np
+from aiohttp import ClientError
+from colorclass import Color
+import questionary
+from questionary import Choice, Form, Question
 
-import rasa.cli.utils
-import rasa.core.train
-import rasa.shared.core.events
-import rasa.shared.data
+from rasa import telemetry
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
-
-# WARNING: This command line UI is using an external library
-# communicating with the shell - these functions are hard to test
-# automatically. If you change anything in here, please make sure to
-# run the interactive learning and check if your part of the "ui"
-# still works.
-import rasa.utils.io as io_utils
-from rasa import telemetry
-from rasa.core import run, utils
-from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
-from rasa.core.utils import AvailableEndpoints
-from rasa.shared.constants import (
-    INTENT_MESSAGE_PREFIX,
-    DEFAULT_SENDER_ID,
-    UTTER_PREFIX,
-    DOCS_URL_NLU_BASED_POLICIES,
-)
+import rasa.cli.utils
+import rasa.shared.data
+from rasa.shared.nlu.constants import TEXT, INTENT_NAME_KEY
+from rasa.shared.nlu.training_data.loading import RASA, RASA_YAML
 from rasa.shared.core.constants import (
     USER_INTENT_RESTART,
     ACTION_LISTEN_NAME,
@@ -65,6 +49,9 @@ from rasa.shared.core.constants import (
     LOOP_INTERRUPTED,
     ACTION_UNLIKELY_INTENT_NAME,
 )
+from rasa.core import run, utils
+import rasa.core.train
+from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
 from rasa.shared.core.domain import (
     Domain,
     KEY_INTENTS,
@@ -73,6 +60,7 @@ from rasa.shared.core.domain import (
     KEY_ACTIONS,
     KEY_RESPONSES_TEXT,
 )
+import rasa.shared.core.events
 from rasa.shared.core.events import (
     ActionExecuted,
     ActionReverted,
@@ -82,23 +70,36 @@ from rasa.shared.core.events import (
     UserUttered,
     UserUtteranceReverted,
 )
-from rasa.shared.core.generator import TrackerWithCachedStates
+from rasa.shared.constants import (
+    INTENT_MESSAGE_PREFIX,
+    DEFAULT_SENDER_ID,
+    UTTER_PREFIX,
+    DOCS_URL_NLU_BASED_POLICIES,
+)
 from rasa.shared.core.trackers import EventVerbosity, DialogueStateTracker
 from rasa.shared.core.training_data import visualization
 from rasa.shared.core.training_data.visualization import (
     VISUALIZATION_TEMPLATE_PATH,
     visualize_neighborhood,
 )
-from rasa.shared.exceptions import InvalidConfigException
+from rasa.core.utils import AvailableEndpoints
 from rasa.shared.importers.rasa import TrainingDataImporter
-from rasa.shared.nlu.constants import TEXT, INTENT_NAME_KEY
+from rasa.utils.common import update_sanic_log_level
+from rasa.utils.endpoints import EndpointConfig
+from rasa.shared.exceptions import InvalidConfigException
 
 # noinspection PyProtectedMember
 from rasa.shared.nlu.training_data import loading
-from rasa.shared.nlu.training_data.loading import RASA, RASA_YAML
 from rasa.shared.nlu.training_data.message import Message
-from rasa.utils.common import update_sanic_log_level
-from rasa.utils.endpoints import EndpointConfig
+
+# WARNING: This command line UI is using an external library
+# communicating with the shell - these functions are hard to test
+# automatically. If you change anything in here, please make sure to
+# run the interactive learning and check if your part of the "ui"
+# still works.
+import rasa.utils.io as io_utils
+
+from rasa.shared.core.generator import TrackerWithCachedStates
 
 logger = logging.getLogger(__name__)
 
@@ -1687,7 +1688,7 @@ def run_interactive_learning(
         p = None
 
     app = run.configure_app(port=port, conversation_id="default", enable_api=True)
-    endpoints = AvailableEndpoints.get_instance(server_args.get("endpoints"))
+    endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
 
     # before_server_start handlers make sure the agent is loaded before the
     # interactive learning IO starts