rasa-pro 3.9.18__py3-none-any.whl → 3.10.16__py3-none-any.whl

rasa/telemetry.py

@@ -122,8 +122,6 @@ TELEMETRY_INTENTLESS_POLICY_TRAINING_COMPLETED_EVENT = (
     "Intentless Policy Training Completed"
 )
 TELEMETRY_INTENTLESS_POLICY_PREDICT_EVENT = "Intentless Policy Predicted"
-TELEMETRY_LLM_INTENT_PREDICT_EVENT = "LLM Intent Predicted"
-TELEMETRY_LLM_INTENT_TRAIN_COMPLETED_EVENT = "LLM Intent Training Completed"
 TELEMETRY_E2E_TEST_RUN_STARTED_EVENT = "E2E Test Run Started"
 TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_STARTED_EVENT = (
     "Enterprise Search Policy Training Started"
@@ -172,6 +170,11 @@ TRACING_BACKEND = "tracing_backend"
 METRICS_BACKEND = "metrics_backend"
 VERSION = "version"
 
+# E2E test conversion
+TELEMETRY_E2E_TEST_CONVERSION_EVENT = "E2E Test Conversion Completed"
+E2E_TEST_CONVERSION_FILE_TYPE = "file_type"
+E2E_TEST_CONVERSION_TEST_CASE_COUNT = "test_case_count"
+
 
 def print_telemetry_reporting_info() -> None:
     """Print telemetry information to std out."""
@@ -1078,6 +1081,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     retrieval is enabled, and flow retrieval embedding model.
     """
     from rasa.shared.constants import (
+        EMBEDDINGS_CONFIG_KEY,
         MODEL_CONFIG_KEY,
         MODEL_NAME_CONFIG_KEY,
     )
@@ -1116,13 +1120,17 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
         llm_model_name = (
             llm_config.get(MODEL_CONFIG_KEY)
             or llm_config.get(MODEL_NAME_CONFIG_KEY)
-            or DEFAULT_LLM_CONFIG[MODEL_NAME_CONFIG_KEY]
+            or DEFAULT_LLM_CONFIG[MODEL_CONFIG_KEY]
         )
         flow_retrieval_config = component.get(FLOW_RETRIEVAL_KEY, {})
         flow_retrieval_enabled = flow_retrieval_config.get("active", True)
+        flow_retrieval_embeddings_config = flow_retrieval_config.get(
+            EMBEDDINGS_CONFIG_KEY, DEFAULT_EMBEDDINGS_CONFIG
+        )
         flow_retrieval_embedding_model_name = (
-            flow_retrieval_config.get("embeddings", DEFAULT_EMBEDDINGS_CONFIG).get(
-                "model"
+            (
+                flow_retrieval_embeddings_config.get(MODEL_NAME_CONFIG_KEY)
+                or flow_retrieval_embeddings_config.get(MODEL_CONFIG_KEY)
             )
             if flow_retrieval_enabled
             else None
@@ -1439,6 +1447,76 @@ def track_markers_parsed_count(
     )
 
 
+def extract_assertion_type_counts(
+    input_test_cases: List["TestCase"],
+) -> typing.Tuple[bool, Dict[str, Any]]:
+    """Extracts the total count of different assertion types from the test cases."""
+    from rasa.e2e_test.assertions import AssertionType
+
+    uses_assertions = False
+
+    flow_started_count = 0
+    flow_completed_count = 0
+    flow_cancelled_count = 0
+    pattern_clarification_contains_count = 0
+    action_executed_count = 0
+    slot_was_set_count = 0
+    slot_was_not_set_count = 0
+    bot_uttered_count = 0
+    generative_response_is_relevant_count = 0
+    generative_response_is_grounded_count = 0
+
+    for test_case in input_test_cases:
+        for step in test_case.steps:
+            assertions = step.assertions if step.assertions else []
+            for assertion in assertions:
+                if assertion.type == AssertionType.ACTION_EXECUTED.value:
+                    action_executed_count += 1
+                elif assertion.type == AssertionType.SLOT_WAS_SET.value:
+                    slot_was_set_count += 1
+                elif assertion.type == AssertionType.SLOT_WAS_NOT_SET.value:
+                    slot_was_not_set_count += 1
+                elif assertion.type == AssertionType.BOT_UTTERED.value:
+                    bot_uttered_count += 1
+                elif (
+                    assertion.type
+                    == AssertionType.GENERATIVE_RESPONSE_IS_RELEVANT.value
+                ):
+                    generative_response_is_relevant_count += 1
+                elif (
+                    assertion.type
+                    == AssertionType.GENERATIVE_RESPONSE_IS_GROUNDED.value
+                ):
+                    generative_response_is_grounded_count += 1
+                elif assertion.type == AssertionType.FLOW_STARTED.value:
+                    flow_started_count += 1
+                elif assertion.type == AssertionType.FLOW_COMPLETED.value:
+                    flow_completed_count += 1
+                elif assertion.type == AssertionType.FLOW_CANCELLED.value:
+                    flow_cancelled_count += 1
+                elif (
+                    assertion.type == AssertionType.PATTERN_CLARIFICATION_CONTAINS.value
+                ):
+                    pattern_clarification_contains_count += 1
+
+                uses_assertions = True
+
+    result = {
+        "flow_started_count": flow_started_count,
+        "flow_completed_count": flow_completed_count,
+        "flow_cancelled_count": flow_cancelled_count,
+        "pattern_clarification_contains_count": pattern_clarification_contains_count,
+        "action_executed_count": action_executed_count,
+        "slot_was_set_count": slot_was_set_count,
+        "slot_was_not_set_count": slot_was_not_set_count,
+        "bot_uttered_count": bot_uttered_count,
+        "generative_response_is_relevant_count": generative_response_is_relevant_count,
+        "generative_response_is_grounded_count": generative_response_is_grounded_count,
+    }
+
+    return uses_assertions, result
+
+
 @ensure_telemetry_enabled
 def track_e2e_test_run(
     input_test_cases: List["TestCase"],
@@ -1446,15 +1524,26 @@ def track_e2e_test_run(
     input_metadata: List["Metadata"],
 ) -> None:
     """Track an end-to-end test run."""
+    properties = {
+        "number_of_test_cases": len(input_test_cases),
+        "number_of_fixtures": len(input_fixtures),
+        "uses_fixtures": len(input_fixtures) > 0,
+        "uses_metadata": len(input_metadata) > 0,
+        "number_of_metadata": len(input_metadata),
+    }
+
+    uses_assertions, assertion_type_counts = extract_assertion_type_counts(
+        input_test_cases
+    )
+
+    properties.update({"uses_assertions": uses_assertions})
+
+    if uses_assertions:
+        properties.update(assertion_type_counts)
+
     _track(
         TELEMETRY_E2E_TEST_RUN_STARTED_EVENT,
-        {
-            "number_of_test_cases": len(input_test_cases),
-            "number_of_fixtures": len(input_fixtures),
-            "uses_fixtures": len(input_fixtures) > 0,
-            "uses_metadata": len(input_metadata) > 0,
-            "number_of_metadata": len(input_metadata),
-        },
+        properties,
     )
 
 
@@ -1523,52 +1612,6 @@ def track_intentless_policy_predict(
     )
 
 
-@ensure_telemetry_enabled
-def track_llm_intent_predict(
-    embeddings_type: Optional[str],
-    embeddings_model: Optional[str],
-    llm_type: Optional[str],
-    llm_model: Optional[str],
-) -> None:
-    """Track when a user predicts an intent using the llm intent classifier."""
-    _track(
-        TELEMETRY_LLM_INTENT_PREDICT_EVENT,
-        {
-            "embeddings_type": embeddings_type,
-            "embeddings_model": embeddings_model,
-            "llm_type": llm_type,
-            "llm_model": llm_model,
-        },
-    )
-
-
-@ensure_telemetry_enabled
-def track_llm_intent_train_completed(
-    embeddings_type: Optional[str],
-    embeddings_model: Optional[str],
-    llm_type: Optional[str],
-    llm_model: Optional[str],
-    fallback_intent: Optional[str],
-    custom_prompt_template: Optional[str],
-    number_of_examples: int,
-    number_of_available_intents: int,
-) -> None:
-    """Track when a user trains the llm intent classifier."""
-    _track(
-        TELEMETRY_LLM_INTENT_TRAIN_COMPLETED_EVENT,
-        {
-            "embeddings_type": embeddings_type,
-            "embeddings_model": embeddings_model,
-            "llm_type": llm_type,
-            "llm_model": llm_model,
-            "fallback_intent": fallback_intent,
-            "custom_prompt_template": custom_prompt_template,
-            "number_of_examples": number_of_examples,
-            "number_of_available_intents": number_of_available_intents,
-        },
-    )
-
-
 @ensure_telemetry_enabled
 def identify_endpoint_config_traits(
     endpoints_file: Optional[Text],
@@ -1735,3 +1778,15 @@ def track_conversation_count(conversation_count: int, tracked_month: datetime) -
             "month": tracked_month.month,
         },
     )
+
+
+@ensure_telemetry_enabled
+def track_e2e_test_conversion_completed(file_type: str, test_case_count: int) -> None:
+    """Track the used input file type for E2E test conversion."""
+    _track(
+        TELEMETRY_E2E_TEST_CONVERSION_EVENT,
+        {
+            E2E_TEST_CONVERSION_FILE_TYPE: file_type,
+            E2E_TEST_CONVERSION_TEST_CASE_COUNT: test_case_count,
+        },
+    )

rasa/tracing/instrumentation/attribute_extractors.py

@@ -7,6 +7,7 @@ import tiktoken
 from numpy import ndarray
 from rasa_sdk.grpc_py import action_webhook_pb2
 
+from rasa.core.actions.action import DirectCustomActionExecutor
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.agent import Agent
@@ -20,6 +21,13 @@ from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.engine.graph import ExecutionContext, GraphModelConfiguration, GraphNode
 from rasa.engine.training.graph_trainer import GraphTrainer
+from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+)
 from rasa.shared.core.constants import REQUESTED_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import DialogueStackUpdated, Event
@@ -27,11 +35,14 @@ from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import INTENT_NAME_KEY, SET_SLOT_COMMAND
-from rasa.shared.utils.llm import combine_custom_and_default_config
+from rasa.shared.utils.llm import (
+    combine_custom_and_default_config,
+)
 from rasa.tracing.constants import (
     PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME,
     REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
 )
+from rasa.shared.core.training_data.structures import StoryGraph
 
 if TYPE_CHECKING:
     from langchain.llms.base import BaseLLM
@@ -249,10 +260,7 @@ def extract_attrs_for_graph_trainer(
     }
 
 
-def extract_headers(
-    message: UserMessage,
-    **kwargs: Any,
-) -> Any:
+def extract_headers(message: UserMessage, **kwargs: Any) -> Any:
     """Extract the headers from the `UserMessage`."""
     if message.headers:
         return message.headers
@@ -304,18 +312,15 @@ def extract_llm_config(self: Any, default_llm_config: Dict[str, Any]) -> Dict[st
 
     attributes = {
         "class_name": self.__class__.__name__,
-        "llm_model": str(config.get("model", llm_property.get("model_name"))),
-        "llm_type": str(llm_property.get("_type")),
-        "embeddings": json.dumps(config.get("embeddings", {})),
+        "llm_model": str(llm_property.get(MODEL_CONFIG_KEY)),
+        "llm_type": str(llm_property.get(PROVIDER_CONFIG_KEY)),
+        "embeddings": json.dumps(config.get(EMBEDDINGS_CONFIG_KEY, {})),
         "llm_temperature": str(llm_property.get("temperature")),
-        "request_timeout": str(llm_property.get("request_timeout")),
+        "request_timeout": str(llm_property.get(TIMEOUT_CONFIG_KEY)),
     }
 
-    if "model" in llm_property:
-        attributes["llm_model"] = str(llm_property.get("model"))
-
-    if "engine" in llm_property:
-        attributes["llm_engine"] = str(llm_property.get("engine"))
+    if DEPLOYMENT_CONFIG_KEY in llm_property:
+        attributes["llm_engine"] = str(llm_property.get(DEPLOYMENT_CONFIG_KEY))
 
     return attributes
 
@@ -370,6 +375,7 @@ def extract_attrs_for_execute_commands(
     tracker: DialogueStateTracker,
     all_flows: FlowsList,
     execution_context: ExecutionContext,
+    story_graph: Optional[StoryGraph] = None,
 ) -> Dict[str, Any]:
     return {
         "number_of_events": len(tracker.events),
@@ -412,6 +418,7 @@ def extract_attrs_for_clean_up_commands(
     tracker: DialogueStateTracker,
     all_flows: FlowsList,
     execution_context: ExecutionContext,
+    story_graph: Optional[StoryGraph] = None,
 ) -> Dict[str, Any]:
     commands_list = []
 
@@ -643,16 +650,24 @@ def extend_attributes_with_prompt_tokens_length(
 
 
 def extract_attrs_for_custom_action_executor_run(
-    self: Union[HTTPCustomActionExecutor, GRPCCustomActionExecutor],
+    self: Union[
+        HTTPCustomActionExecutor, GRPCCustomActionExecutor, DirectCustomActionExecutor
+    ],
     tracker: DialogueStateTracker,
     domain: Domain,
     include_domain: bool = False,
 ) -> Dict[str, Any]:
+    actions_module, url = None, None
+    if hasattr(self, "action_endpoint"):
+        url = self.action_endpoint.url
+        actions_module = self.action_endpoint.actions_module
+
     attrs: Dict[str, Any] = {
         "class_name": self.__class__.__name__,
-        "action_name": self.action_name if hasattr(self, "action_name") else "None",
+        "action_name": self.action_name,
         "sender_id": tracker.sender_id,
-        "url": self.action_endpoint.url if hasattr(self, "action_endpoint") else "None",
+        "url": str(url),
+        "actions_module": str(actions_module),
     }
     return attrs
 

rasa/utils/common.py

@@ -32,6 +32,7 @@ from rasa.constants import (
     DEFAULT_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_LIBRARIES,
     ENV_LOG_LEVEL_MATPLOTLIB,
+    ENV_LOG_LEVEL_MLFLOW,
     ENV_LOG_LEVEL_RABBITMQ,
     ENV_LOG_LEVEL_KAFKA,
 )
@@ -44,12 +45,6 @@ logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
-EXPECTED_PILLOW_DEPRECATION_WARNINGS: List[Tuple[Type[Warning], str]] = [
-    # Keras uses deprecated Pillow features
-    # cf. https://github.com/keras-team/keras/issues/16639
-    (DeprecationWarning, f"{method} is deprecated and will be removed in Pillow 10 .*")
-    for method in ["BICUBIC", "NEAREST", "BILINEAR", "HAMMING", "BOX", "LANCZOS"]
-]
 
 EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
     # TODO (issue #9932)
@@ -57,22 +52,17 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         np.VisibleDeprecationWarning,
         "Creating an ndarray from ragged nested sequences.*",
     ),
-    # raised by langchain -> faiss
-    (
-        DeprecationWarning,
-        "distutils Version classes are deprecated. Use packaging.version instead",
-    ),
     # raised by pycountry (rasa-plus anonymization), magic_filter, google rpc
     # and probably other dependencies that use pkg_resources instead of importlib
     (DeprecationWarning, ".*pkg_resources.*"),
-    # This warning is triggered by sanic-cors 2.0.0.
+    # This warning is triggered by sanic-cors 2.0.0 and by langchain -> faiss.
     # The warning can be removed after the packages are updated:
     # sanic-cors: ^2.1.0
     # packaging`: 23.2 (introduces breaking changes)
     # pep440-version-utils (also requires update on packaging)
     (
         DeprecationWarning,
-        "distutils Version classes are deprecated. Use packaging.version instead.",
+        "distutils Version classes are deprecated. Use packaging.version instead",
     ),
     # cf. https://github.com/tensorflow/tensorflow/issues/38168
     (
@@ -81,11 +71,6 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         "shape. This may consume a large amount of memory.",
     ),
     (UserWarning, "Slot auto-fill has been removed in 3.0 .*"),
-    # This warning is caused by the flatbuffers package
-    # The import was fixed on Github, but the latest version
-    # is not available on PyPi, so we cannot pin the newer version.
-    # cf. https://github.com/google/flatbuffers/issues/6957
-    (DeprecationWarning, "the imp module is deprecated in favour of importlib.*"),
     # Cannot fix this deprecation warning since we need to support two
     # numpy versions as long as we keep python 37 around
     (DeprecationWarning, "the `interpolation=` argument to quantile was renamed"),
@@ -102,10 +87,11 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
         DeprecationWarning,
         "non-integer arguments to randrange\\(\\) have been deprecated since",
     ),
+    # Ignore Keras DeprecationWarning since it requires that we
+    # upgrade tensorflow-macos to 2.13.0 version.
     (DeprecationWarning, "invalid escape sequence*"),
 ]
 
-EXPECTED_WARNINGS.extend(EXPECTED_PILLOW_DEPRECATION_WARNINGS)
 PYTHON_LOGGING_SCHEMA_DOCS = (
     "https://docs.python.org/3/library/logging.config.html#dictionary-schema-details"
 )
@@ -402,6 +388,19 @@ def update_faker_log_level(library_log_level: Text) -> None:
     logging.getLogger("faker").propagate = False
 
 
+def update_mlflow_log_level() -> None:
+    """Set the log level of mlflow.
+
+    Uses the library specific log level or the general libraries log level.
+    """
+    library_log_level = os.environ.get(
+        ENV_LOG_LEVEL_LIBRARIES, DEFAULT_LOG_LEVEL_LIBRARIES
+    )
+    log_level = os.environ.get(ENV_LOG_LEVEL_MLFLOW, library_log_level)
+    logging.getLogger("mlflow").setLevel(log_level)
+    logging.getLogger("mlflow").propagate = False
+
+
 def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     """Sorts a list of dictionaries by their first key."""
     return sorted(dicts, key=lambda d: next(iter(d.keys())))

rasa/utils/endpoints.py

@@ -1,14 +1,15 @@
+import os
 import ssl
+from types import ModuleType
+from typing import Any, Optional, Text, Dict, Union
 
 import aiohttp
-import os
+import structlog
 from aiohttp.client_exceptions import ContentTypeError
 from sanic.request import Request
-from typing import Any, Optional, Text, Dict
 
-from rasa.shared.exceptions import FileNotFoundException
-import structlog
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
+from rasa.shared.exceptions import FileNotFoundException
 from rasa.shared.utils.yaml import read_config_file
 
 structlogger = structlog.get_logger()
@@ -87,6 +88,7 @@ class EndpointConfig:
         token: Optional[Text] = None,
         token_name: Text = "token",
         cafile: Optional[Text] = None,
+        actions_module: Optional[Union[Text, ModuleType]] = None,
         **kwargs: Any,
     ) -> None:
         """Creates an `EndpointConfig` instance."""
@@ -98,6 +100,7 @@ class EndpointConfig:
         self.token_name = token_name
         self.type = kwargs.pop("store_type", kwargs.pop("type", None))
         self.cafile = cafile
+        self.actions_module = actions_module
         self.kwargs = kwargs
 
     def session(self) -> aiohttp.ClientSession:

rasa/utils/json_utils.py

@@ -0,0 +1,60 @@
+import json
+from decimal import Decimal
+from typing import Any, Text
+
+
+class DecimalEncoder(json.JSONEncoder):
+    """`json.JSONEncoder` that dumps `Decimal`s as `float`s."""
+
+    def default(self, obj: Any) -> Any:
+        """Get serializable object for `o`.
+
+        Args:
+            obj: Object to serialize.
+
+        Returns:
+            `obj` converted to `float` if `o` is a `Decimals`, else the base class
+            `default()` method.
+        """
+        if isinstance(obj, Decimal):
+            return float(obj)
+        return super().default(obj)
+
+
+class SetEncoder(json.JSONEncoder):
+    """`json.JSONEncoder` that dumps `set`s as `list`s."""
+
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, set):
+            return list(obj)
+        return super().default(obj)
+
+
+def replace_floats_with_decimals(obj: Any, round_digits: int = 9) -> Any:
+    """Convert all instances in `obj` of `float` to `Decimal`.
+
+    Args:
+        obj: Input object.
+        round_digits: Rounding precision of `Decimal` values.
+
+    Returns:
+        Input `obj` with all `float` types replaced by `Decimal`s rounded to
+        `round_digits` decimal places.
+    """
+
+    def _float_to_rounded_decimal(s: Text) -> Decimal:
+        return Decimal(s).quantize(Decimal(10) ** -round_digits)
+
+    return json.loads(json.dumps(obj), parse_float=_float_to_rounded_decimal)
+
+
+def replace_decimals_with_floats(obj: Any) -> Any:
+    """Convert all instances in `obj` of `Decimal` to `float`.
+
+    Args:
+        obj: A `List` or `Dict` object.
+
+    Returns:
+        Input `obj` with all `Decimal` types replaced by `float`s.
+    """
+    return json.loads(json.dumps(obj, cls=DecimalEncoder))

rasa/utils/licensing.py

@@ -293,7 +293,9 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
                     "Your license is about to expire. "
                     "Please contact Rasa for a renewal."
                 ),
-                expiration_date=datetime.utcfromtimestamp(license.exp).isoformat(),
+                expiration_date=datetime.fromtimestamp(
+                    license.exp, timezone.utc
+                ).isoformat(),
             )
     except LicenseNotFoundException:
         structlogger.error("license.not_found.error")
@@ -311,6 +313,12 @@ def validate_license_from_env(product_area: Text = PRODUCT_AREA) -> None:
         )
 
 
+def get_license_expiration_date() -> Text:
+    """Return the expiration date of the license."""
+    license_exp = property_of_active_license(lambda active_license: active_license.exp)
+    return datetime.fromtimestamp(license_exp, timezone.utc).isoformat()
+
+
 def is_valid_license_scope(product_area: Text, license_scope: Text) -> bool:
     """Verifies that the license scope matches the rasa-plus product area."""
     required_scopes = derive_scope_hierarchy(product_area)

rasa/utils/ml_utils.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Text
 import numpy as np
 import structlog
 from langchain.schema.embeddings import Embeddings
-from langchain.vectorstores import FAISS
+from langchain_community.vectorstores import FAISS
 from rasa.shared.constants import REQUIRED_SLOTS_KEY
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.utils.llm import AI
@@ -34,7 +34,9 @@ def load_faiss_vector_store(path: Path, embedder: Embeddings) -> Optional[FAISS]
         The loaded vector store or None if the path does not exist.
     """
     if path.exists():
-        return FAISS.load_local(str(path), embedder)
+        return FAISS.load_local(
+            str(path), embedder, allow_dangerous_deserialization=True
+        )
     else:
         return None