rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a2__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,
@@ -792,28 +789,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
 
@@ -1279,13 +1254,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 = []
 

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

rasa/core/utils.py

@@ -1,9 +1,8 @@
-import structlog
 import logging
 import os
 from pathlib import Path
 from socket import SOCK_DGRAM, SOCK_STREAM
-from typing import Any, Dict, Optional, List, Set, TYPE_CHECKING, Text, Tuple, Union
+from typing import Any, Dict, Optional, Set, TYPE_CHECKING, Text, Tuple, Union
 
 import numpy as np
 from sanic import Sanic
@@ -20,18 +19,14 @@ from rasa.core.constants import (
 from rasa.core.lock_store import LockStore, RedisLockStore, InMemoryLockStore
 from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.utils.endpoints import (
-    EndpointConfig,
-    read_endpoint_config,
-    read_property_config_from_endpoints_file,
-)
+from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
 from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
 
-structlogger = structlog.get_logger()
+logger = logging.getLogger(__name__)
 
 
 def configure_file_logging(
@@ -129,17 +124,15 @@ def list_routes(app: Sanic) -> Dict[Text, Text]:
         for arg in route._params:
             options[arg] = f"[{arg}]"
 
-        name = route.name.replace("rasa_server.", "")
-        methods = ",".join(route.methods)
+        handlers = [(next(iter(route.methods)), route.name.replace("rasa_server.", ""))]
 
-        full_endpoint = "/" + "/".join(endpoint)
-        line = unquote(f"{full_endpoint:50s} {methods:30s} {name}")
-        output[name] = line
+        for method, name in handlers:
+            full_endpoint = "/" + "/".join(endpoint)
+            line = unquote(f"{full_endpoint:50s} {method:30s} {name}")
+            output[name] = line
 
     url_table = "\n".join(output[url] for url in sorted(output))
-    structlogger.debug(
-        "server.routes", event_info=f"Available web server routes: \n{url_table}"
-    )
+    logger.debug(f"Available web server routes: \n{url_table}")
 
     return output
 
@@ -178,8 +171,6 @@ def is_limit_reached(num_messages: int, limit: Optional[int]) -> bool:
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
-    _instance = None
-
     @classmethod
     def read_endpoints(cls, endpoint_file: Text) -> "AvailableEndpoints":
         """Read the different endpoints from a yaml file."""
@@ -193,9 +184,6 @@ 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")
-        model_groups = read_property_config_from_endpoints_file(
-            endpoint_file, property_name="model_groups"
-        )
 
         return cls(
             nlg,
@@ -206,7 +194,6 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
-            model_groups,
         )
 
     def __init__(
@@ -219,7 +206,6 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
-        model_groups: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         """Create an `AvailableEndpoints` object."""
         self.model = model
@@ -230,15 +216,6 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
-        self.model_groups = model_groups
-
-    @classmethod
-    def get_instance(cls, endpoint_file: Optional[Text] = None) -> "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
 
 
 def read_endpoints_from_path(
@@ -257,7 +234,7 @@ def read_endpoints_from_path(
     endpoints_config_path = cli_utils.get_validated_path(
         endpoints_path, "endpoints", DEFAULT_ENDPOINTS_PATH, True
     )
-    return AvailableEndpoints.get_instance(endpoints_config_path)
+    return AvailableEndpoints.read_endpoints(endpoints_config_path)
 
 
 def _lock_store_is_multi_worker_compatible(
@@ -286,22 +263,17 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
     """
 
     def _log_and_get_default_number_of_workers() -> int:
-        structlogger.debug(
-            "server.worker.set_count",
-            number_of_workers=DEFAULT_SANIC_WORKERS,
-            event_info=f"Using the default number of Sanic workers "
-            f"({DEFAULT_SANIC_WORKERS}).",
+        logger.debug(
+            f"Using the default number of Sanic workers ({DEFAULT_SANIC_WORKERS})."
         )
         return DEFAULT_SANIC_WORKERS
 
     try:
         env_value = int(os.environ.get(ENV_SANIC_WORKERS, DEFAULT_SANIC_WORKERS))
     except ValueError:
-        structlogger.error(
-            "server.worker.set_count.error",
-            number_of_workers=os.environ[ENV_SANIC_WORKERS],
-            event_info=f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
-            f"to int ('{os.environ[ENV_SANIC_WORKERS]}').",
+        logger.error(
+            f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
+            f"to int ('{os.environ[ENV_SANIC_WORKERS]}')."
         )
         return _log_and_get_default_number_of_workers()
 
@@ -309,28 +281,20 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         return _log_and_get_default_number_of_workers()
 
     if env_value < 1:
-        structlogger.warning(
-            "server.worker.set_count.error_less_than_one",
-            number_of_workers=env_value,
-            event_info=f"Cannot set number of Sanic workers to the desired value "
-            f"({env_value}). The number of workers must be at least 1.",
+        logger.debug(
+            f"Cannot set number of Sanic workers to the desired value "
+            f"({env_value}). The number of workers must be at least 1."
         )
         return _log_and_get_default_number_of_workers()
 
     if _lock_store_is_multi_worker_compatible(lock_store):
-        structlogger.debug(
-            "server.worker.set_count.success",
-            event_info=f"Using {env_value} Sanic workers.",
-            num_workers=env_value,
-        )
+        logger.debug(f"Using {env_value} Sanic workers.")
         return env_value
 
-    structlogger.warning(
-        "server.worker.set_count.error_no_lock_store",
-        event_info=f"Unable to assign desired number of Sanic workers ({env_value}) as "
+    logger.debug(
+        f"Unable to assign desired number of Sanic workers ({env_value}) as "
         f"no `RedisLockStore` or custom `LockStore` endpoint "
-        f"configuration has been found.",
-        num_workers=env_value,
+        f"configuration has been found."
     )
     return _log_and_get_default_number_of_workers()