rasa-pro 3.10.7__py3-none-any.whl → 3.10.7.dev1__py3-none-any.whl

rasa/shared/importers/importer.py

@@ -23,6 +23,7 @@ from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.common import cached_method
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger(__name__)
@@ -113,7 +114,7 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
+        args: Optional[Dict[Text, Any]] = None,
     ) -> "TrainingDataImporter":
         """Loads a `TrainingDataImporter` instance from a configuration file."""
         config = read_config_file(config_path)
@@ -126,7 +127,7 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
+        args: Optional[Dict[Text, Any]] = None,
     ) -> "TrainingDataImporter":
         """Loads core `TrainingDataImporter` instance.
 
@@ -142,7 +143,7 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
+        args: Optional[Dict[Text, Any]] = None,
     ) -> "TrainingDataImporter":
         """Loads nlu `TrainingDataImporter` instance.
 
@@ -226,7 +227,8 @@ class TrainingDataImporter(ABC):
             **constructor_arguments,
         )
 
-    def fingerprint(self) -> Text:
+    @staticmethod
+    def fingerprint() -> Text:
         """Returns a random fingerprint as data shouldn't be cached."""
         return rasa.shared.utils.io.random_string(25)
 
@@ -282,7 +284,6 @@ class NluDataImporter(TrainingDataImporter):
         """Retrieves NLU training data (see parent class for full docstring)."""
         return self._importer.get_nlu_data(language)
 
-    @rasa.shared.utils.common.cached_method
     def get_config_file_for_auto_config(self) -> Optional[Text]:
         """Returns config file path for auto-config only if there is a single one."""
         return self._importer.get_config_file_for_auto_config()
@@ -298,14 +299,14 @@ class CombinedDataImporter(TrainingDataImporter):
     def __init__(self, importers: List[TrainingDataImporter]):
         self._importers = importers
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         configs = [importer.get_config() for importer in self._importers]
 
         return reduce(lambda merged, other: {**merged, **(other or {})}, configs, {})
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [importer.get_domain() for importer in self._importers]
@@ -316,7 +317,7 @@ class CombinedDataImporter(TrainingDataImporter):
             Domain.empty(),
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         stories = [
@@ -327,7 +328,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         flow_lists = [importer.get_flows() for importer in self._importers]
@@ -338,7 +339,7 @@ class CombinedDataImporter(TrainingDataImporter):
             FlowsList(underlying_flows=[]),
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         stories = [importer.get_conversation_tests() for importer in self._importers]
@@ -347,7 +348,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), stories, StoryGraph([])
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         nlu_data = [importer.get_nlu_data(language) for importer in self._importers]
@@ -356,7 +357,7 @@ class CombinedDataImporter(TrainingDataImporter):
             lambda merged, other: merged.merge(other), nlu_data, TrainingData()
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_config_file_for_auto_config(self) -> Optional[Text]:
         """Returns config file path for auto-config only if there is a single one."""
         if len(self._importers) != 1:
@@ -415,26 +416,22 @@ class FlowSyncImporter(PassThroughImporter):
         """Loads the default flows from the file system."""
         from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
-        default_flows_file = str(
-            importlib_resources.files("rasa.dialogue_understanding.patterns").joinpath(
-                DEFAULT_PATTERN_FLOWS_FILE_NAME
-            )
-        )
-
-        flows = YAMLFlowsReader.read_from_file(default_flows_file)
+        flows = YAMLFlowsReader.read_from_file(FlowSyncImporter.default_pattern_path())
         flows.validate()
         return flows
 
     @staticmethod
-    def load_default_pattern_flows_domain() -> Domain:
-        """Loads the default flows from the file system."""
-        default_flows_file = str(
+    def default_pattern_path() -> str:
+        return str(
             importlib_resources.files("rasa.dialogue_understanding.patterns").joinpath(
                 DEFAULT_PATTERN_FLOWS_FILE_NAME
             )
         )
 
-        return Domain.from_path(default_flows_file)
+    @staticmethod
+    def load_default_pattern_flows_domain() -> Domain:
+        """Loads the default flows from the file system."""
+        return Domain.from_path(FlowSyncImporter.default_pattern_path())
 
     @classmethod
     def merge_with_default_flows(cls, flows: FlowsList) -> FlowsList:
@@ -460,7 +457,7 @@ class FlowSyncImporter(PassThroughImporter):
 
         return flows.merge(FlowsList(missing_default_flows))
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_flows(self) -> FlowsList:
         flows = self._importer.get_flows()
 
@@ -470,11 +467,11 @@ class FlowSyncImporter(PassThroughImporter):
 
         return self.merge_with_default_flows(flows)
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_user_flows(self) -> FlowsList:
         return self._importer.get_flows()
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of flows."""
         # load domain data from user defined domain files
@@ -516,7 +513,7 @@ class ResponsesSyncImporter(PassThroughImporter):
     back to the Domain.
     """
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of retrieval intents in NLU data."""
         existing_domain = self._importer.get_domain()
@@ -598,7 +595,7 @@ class ResponsesSyncImporter(PassThroughImporter):
             }
         )
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Updates NLU data with responses for retrieval intents from domain."""
         existing_nlu_data = self._importer.get_nlu_data(language)
@@ -633,7 +630,7 @@ class E2EImporter(PassThroughImporter):
     - adds potential end-to-end bot messages from stories as actions to the domain
     """
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_user_flows(self) -> FlowsList:
         if not isinstance(self._importer, FlowSyncImporter):
             raise NotImplementedError(
@@ -642,9 +639,12 @@ class E2EImporter(PassThroughImporter):
 
         return self._importer.get_user_flows()
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_domain(self) -> Domain:
-        """Retrieves model domain (see parent class for full docstring)."""
+        """Merge existing domain with properties of end-to-end actions in stories.
+
+        Returns: Domain with end-to-end actions added to action names.
+        """
         original = self._importer.get_domain()
         e2e_domain = self._get_domain_with_e2e_actions()
 
@@ -674,7 +674,7 @@ class E2EImporter(PassThroughImporter):
 
         return Domain.from_dict({KEY_E2E_ACTIONS: list(additional_e2e_action_names)})
 
-    @rasa.shared.utils.common.cached_method
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         training_datasets = [

rasa/shared/importers/multi_project.py

@@ -1,22 +1,23 @@
-import logging
-from functools import reduce
-from typing import Text, Set, Dict, Optional, List, Union, Any
 import os
+from functools import reduce
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 import rasa.shared.data
 import rasa.shared.utils.io
 from rasa.shared.core.domain import Domain
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.importers import utils
-from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.core.training_data.structures import StoryGraph
-from rasa.shared.utils.common import mark_as_experimental_feature
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
     YAMLStoryReader,
 )
+from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.importers import utils
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.common import cached_method, mark_as_experimental_feature
 from rasa.shared.utils.yaml import read_config_file, read_model_configuration
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 class MultiProjectImporter(TrainingDataImporter):
@@ -50,8 +51,13 @@ class MultiProjectImporter(TrainingDataImporter):
         self._story_paths += extra_story_files
         self._nlu_paths += extra_nlu_files
 
-        logger.debug(
-            "Selected projects: {}".format("".join([f"\n-{i}" for i in self._imports]))
+        structlogger.debug(
+            "multi_project_importer.initialisation",
+            event_info=(
+                "Selected projects: {}".format(
+                    "".join([f"\n-{i}" for i in self._imports])
+                )
+            ),
         )
 
         mark_as_experimental_feature(feature_name="MultiProjectImporter")
@@ -135,6 +141,7 @@ class MultiProjectImporter(TrainingDataImporter):
 
         return training_paths
 
+    @cached_method
     def is_imported(self, path: Text) -> bool:
         """Checks whether a path is imported by a skill.
 
@@ -175,6 +182,7 @@ class MultiProjectImporter(TrainingDataImporter):
             [rasa.shared.utils.io.is_subdirectory(path, i) for i in self._imports]
         )
 
+    @cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domains = [Domain.load(path) for path in self._domain_paths]
@@ -184,20 +192,24 @@ class MultiProjectImporter(TrainingDataImporter):
             Domain.empty(),
         )
 
+    @cached_method
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         return utils.story_graph_from_paths(
             self._story_paths, self.get_domain(), exclusion_percentage
         )
 
+    @cached_method
     def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         return utils.story_graph_from_paths(self._e2e_story_paths, self.get_domain())
 
+    @cached_method
     def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         return self.config
 
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         return utils.training_data_from_paths(self._nlu_paths, language)

rasa/shared/importers/rasa.py

@@ -6,7 +6,6 @@ import rasa.shared.core.flows.yaml_flows_io
 from rasa.shared.core.flows import FlowsList
 
 import rasa.shared.data
-import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.importers import utils
@@ -16,6 +15,7 @@ from rasa.shared.core.domain import InvalidDomain, Domain
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
     YAMLStoryReader,
 )
+from rasa.shared.utils.common import cached_method
 from rasa.shared.utils.yaml import read_model_configuration
 
 logger = logging.getLogger(__name__)
@@ -47,6 +47,7 @@ class RasaFileImporter(TrainingDataImporter):
 
         self.config_file = config_file
 
+    @cached_method
     def get_config(self) -> Dict:
         """Retrieves model config (see parent class for full docstring)."""
         if not self.config_file or not os.path.exists(self.config_file):
@@ -56,31 +57,35 @@ class RasaFileImporter(TrainingDataImporter):
         config = read_model_configuration(self.config_file)
         return config
 
-    @rasa.shared.utils.common.cached_method
     def get_config_file_for_auto_config(self) -> Optional[Text]:
         """Returns config file path for auto-config only if there is a single one."""
         return self.config_file
 
+    @cached_method
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         return utils.story_graph_from_paths(
             self._story_files, self.get_domain(), exclusion_percentage
         )
 
+    @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
         return utils.flows_from_paths(self._flow_files)
 
+    @cached_method
     def get_conversation_tests(self) -> StoryGraph:
         """Retrieves conversation test stories (see parent class for full docstring)."""
         return utils.story_graph_from_paths(
             self._conversation_test_files, self.get_domain()
         )
 
+    @cached_method
     def get_nlu_data(self, language: Optional[Text] = "en") -> TrainingData:
         """Retrieves NLU training data (see parent class for full docstring)."""
         return utils.training_data_from_paths(self._nlu_files, language)
 
+    @cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
         domain = Domain.empty()

rasa/shared/importers/remote_importer.py

@@ -8,7 +8,7 @@ import rasa.shared.core.flows.yaml_flows_io
 import rasa.shared.data
 import rasa.shared.utils.common
 import rasa.shared.utils.io
-from rasa.nlu.persistor import StorageType
+from rasa.core.persistor import StorageType
 from rasa.shared.core.domain import Domain, InvalidDomain
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
@@ -79,7 +79,7 @@ class RemoteTrainingDataImporter(TrainingDataImporter):
         self, training_file: str, training_data_path: Optional[str] = None
     ) -> str:
         """Fetches training files from remote storage."""
-        from rasa.nlu.persistor import get_persistor
+        from rasa.core.persistor import get_persistor
 
         persistor = get_persistor(self.remote_storage)
         if persistor is None:

rasa/shared/importers/utils.py

@@ -29,6 +29,8 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
 
     flows = FlowsList(underlying_flows=[])
     for file in files:
-        flows = flows.merge(YAMLFlowsReader.read_from_file(file))
+        flows = flows.merge(
+            YAMLFlowsReader.read_from_file(file), ignore_duplicates=False
+        )
     flows.validate()
     return flows

rasa/shared/nlu/training_data/training_data.py

@@ -1,5 +1,6 @@
 import logging
 import os
+from functools import cached_property
 from pathlib import Path
 import random
 from collections import Counter, OrderedDict
@@ -9,7 +10,6 @@ from typing import Any, Dict, List, Optional, Set, Text, Tuple, Callable
 import operator
 
 import rasa.shared.data
-from rasa.shared.utils.common import lazy_property
 import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     RESPONSE,
@@ -202,7 +202,7 @@ class TrainingData:
 
         return list(OrderedDict.fromkeys(examples))
 
-    @lazy_property
+    @cached_property
     def nlu_examples(self) -> List[Message]:
         """Return examples which have come from NLU training data.
 
@@ -215,32 +215,32 @@ class TrainingData:
             ex for ex in self.training_examples if not ex.is_core_or_domain_message()
         ]
 
-    @lazy_property
+    @cached_property
     def intent_examples(self) -> List[Message]:
         """Returns the list of examples that have intent."""
         return [ex for ex in self.nlu_examples if ex.get(INTENT)]
 
-    @lazy_property
+    @cached_property
     def response_examples(self) -> List[Message]:
         """Returns the list of examples that have response."""
         return [ex for ex in self.nlu_examples if ex.get(INTENT_RESPONSE_KEY)]
 
-    @lazy_property
+    @cached_property
     def entity_examples(self) -> List[Message]:
         """Returns the list of examples that have entities."""
         return [ex for ex in self.nlu_examples if ex.get(ENTITIES)]
 
-    @lazy_property
+    @cached_property
     def intents(self) -> Set[Text]:
         """Returns the set of intents in the training data."""
         return {ex.get(INTENT) for ex in self.training_examples} - {None}
 
-    @lazy_property
+    @cached_property
     def action_names(self) -> Set[Text]:
         """Returns the set of action names in the training data."""
         return {ex.get(ACTION_NAME) for ex in self.training_examples} - {None}
 
-    @lazy_property
+    @cached_property
     def retrieval_intents(self) -> Set[Text]:
         """Returns the total number of response types in the training data."""
         return {
@@ -249,13 +249,13 @@ class TrainingData:
             if ex.get(INTENT_RESPONSE_KEY)
         }
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_intent(self) -> Dict[Text, int]:
         """Calculates the number of examples per intent."""
         intents = [ex.get(INTENT) for ex in self.nlu_examples]
         return dict(Counter(intents))
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_response(self) -> Dict[Text, int]:
         """Calculates the number of examples per response."""
         responses = [
@@ -265,12 +265,12 @@ class TrainingData:
         ]
         return dict(Counter(responses))
 
-    @lazy_property
+    @cached_property
     def entities(self) -> Set[Text]:
         """Returns the set of entity types in the training data."""
         return {e.get(ENTITY_ATTRIBUTE_TYPE) for e in self.sorted_entities()}
 
-    @lazy_property
+    @cached_property
     def entity_roles(self) -> Set[Text]:
         """Returns the set of entity roles in the training data."""
         entity_types = {
@@ -280,7 +280,7 @@ class TrainingData:
         }
         return entity_types - {NO_ENTITY_TAG}
 
-    @lazy_property
+    @cached_property
     def entity_groups(self) -> Set[Text]:
         """Returns the set of entity groups in the training data."""
         entity_types = {
@@ -299,7 +299,7 @@ class TrainingData:
 
         return entity_groups_used or entity_roles_used
 
-    @lazy_property
+    @cached_property
     def number_of_examples_per_entity(self) -> Dict[Text, int]:
         """Calculates the number of examples per entity."""
         entities = []
@@ -426,8 +426,9 @@ class TrainingData:
     def persist(
         self, dir_name: Text, filename: Text = DEFAULT_TRAINING_DATA_OUTPUT_PATH
     ) -> Dict[Text, Any]:
-        """Persists this training data to disk and returns necessary
-        information to load it again.
+        """Persists this training data to disk.
+
+        Returns: necessary information to load it again.
         """
         if not os.path.exists(dir_name):
             os.makedirs(dir_name)
@@ -498,9 +499,7 @@ class TrainingData:
     def train_test_split(
         self, train_frac: float = 0.8, random_seed: Optional[int] = None
     ) -> Tuple["TrainingData", "TrainingData"]:
-        """Split into a training and test dataset,
-        preserving the fraction of examples per intent.
-        """
+        """Split into a training and test dataset, preserving the fraction of examples per intent."""  # noqa: E501
         # collect all nlu data
         test, train = self.split_nlu_examples(train_frac, random_seed)
 

rasa/shared/utils/common.py

@@ -86,31 +86,11 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     return sorted(dicts, key=lambda d: next(iter(d.keys())))
 
 
-def lazy_property(function: Callable) -> Any:
-    """Allows to avoid recomputing a property over and over.
-
-    The result gets stored in a local var. Computation of the property
-    will happen once, on the first call of the property. All
-    succeeding calls will use the value stored in the private property.
-    """
-    attr_name = "_lazy_" + function.__name__
-
-    def _lazyprop(self: Any) -> Any:
-        if not hasattr(self, attr_name):
-            setattr(self, attr_name, function(self))
-        return getattr(self, attr_name)
-
-    return property(_lazyprop)
-
-
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
-
     Works for `async` and `sync` methods. Don't apply this to functions.
-
     Args:
         f: The decorated method whose return value should be cached.
-
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -176,8 +156,9 @@ def transform_collection_to_sentence(collection: Collection[Text]) -> Text:
 def minimal_kwargs(
     kwargs: Dict[Text, Any], func: Callable, excluded_keys: Optional[List] = None
 ) -> Dict[Text, Any]:
-    """Returns only the kwargs which are required by a function. Keys, contained in
-    the exception list, are not included.
+    """Returns only the kwargs which are required by a function.
+
+    Keys, contained in the exception list, are not included.
 
     Args:
         kwargs: All available kwargs.

rasa/shared/utils/llm.py

@@ -410,10 +410,10 @@ def try_instantiate_llm_client(
     default_llm_config: Optional[Dict],
     log_source_function: str,
     log_source_component: str,
-) -> None:
+) -> LLMClient:
     """Validate llm configuration."""
     try:
-        llm_factory(custom_llm_config, default_llm_config)
+        return llm_factory(custom_llm_config, default_llm_config)
     except (ProviderClientValidationError, ValueError) as e:
         structlogger.error(
             f"{log_source_function}.llm_instantiation_failed",
@@ -425,3 +425,29 @@ def try_instantiate_llm_client(
             f"Please make sure you specified the required environment variables. "
             f"Error: {e}"
         )
+
+
+def llm_api_health_check(
+    llm_client: LLMClient, log_source_function: str, log_source_component: str
+) -> None:
+    """Perform a health check on the LLM API."""
+    structlogger.info(
+        f"{log_source_function}.llm_api_call",
+        event_info=(
+            f"Performing a health check on the LLM API for the component - "
+            f"{log_source_component}."
+        ),
+        config=llm_client.config,
+    )
+    try:
+        llm_client.completion("hello")
+    except Exception as e:
+        structlogger.error(
+            f"{log_source_function}.llm_api_call_failed",
+            event_info="call to the LLM API failed.",
+            error=e,
+        )
+        print_error_and_exit(
+            f"Call to the LLM API failed for component - {log_source_component}. "
+            f"Error: {e}"
+        )

rasa/shared/utils/schemas/model_config.yml

@@ -34,13 +34,3 @@ mapping:
           name:
             type: str
             required: True
-  spaces:
-    type: "seq"
-    required: False
-    sequence:
-      - type: "map"
-        allowempty: True
-        mapping:
-          name:
-            type: str
-            required: True

rasa/studio/auth.py

@@ -21,19 +21,15 @@ from rasa.studio.results_logger import with_studio_error_handler, StudioResult
 
 
 class StudioAuth:
-    """Handles the authentication with the Rasa Studio authentication server."""
-
     def __init__(
         self,
         studio_config: StudioConfig,
-        verify: bool = True,
     ) -> None:
         self.config = studio_config
         self.keycloak_openid = KeycloakOpenID(
             server_url=studio_config.authentication_server_url,
             client_id=studio_config.client_id,
             realm_name=studio_config.realm_name,
-            verify=verify,
         )
 
     def health_check(self) -> bool:

rasa/tracing/instrumentation/attribute_extractors.py

@@ -664,7 +664,7 @@ def extract_attrs_for_custom_action_executor_run(
 
     attrs: Dict[str, Any] = {
         "class_name": self.__class__.__name__,
-        "action_name": self.action_name,
+        "action_name": self.action_name if hasattr(self, "action_name") else "None",
         "sender_id": tracker.sender_id,
         "url": str(url),
         "actions_module": str(actions_module),