rasa-pro 3.8.18__py3-none-any.whl → 3.9.15__py3-none-any.whl

rasa/nlu/extractors/duckling_entity_extractor.py

@@ -34,7 +34,7 @@ def extract_value(match: Dict[Text, Any]) -> Dict[Text, Any]:
 
 
 def convert_duckling_format_to_rasa(
-    matches: List[Dict[Text, Any]]
+    matches: List[Dict[Text, Any]],
 ) -> List[Dict[Text, Any]]:
     extracted = []
 

rasa/nlu/featurizers/dense_featurizer/convert_featurizer.py

@@ -189,7 +189,7 @@ class ConveRTFeaturizer(DenseFeaturizer, GraphComponent):
                 f"Parameter 'model_url' of "
                 f"'{ConveRTFeaturizer.__name__}' was "
                 f"set to '{model_url}' which is strictly reserved for pytests of "
-                f"Rasa Open Source only. Due to licensing issues you are "
+                f"Rasa Pro only. Due to licensing issues you are "
                 f"not allowed to use the model from this URL. "
                 f"You can either use a community hosted URL or if you have a "
                 f"local copy of the model, pass the path to the directory "
@@ -323,13 +323,11 @@ class ConveRTFeaturizer(DenseFeaturizer, GraphComponent):
         return texts
 
     def _sentence_encoding_of_text(self, batch: List[Text]) -> np.ndarray:
-
         return self.sentence_encoding_signature(tf.convert_to_tensor(batch))[
             "default"
         ].numpy()
 
     def _sequence_encoding_of_text(self, batch: List[Text]) -> np.ndarray:
-
         return self.sequence_encoding_signature(tf.convert_to_tensor(batch))[
             "sequence_encoding"
         ].numpy()
@@ -346,7 +344,6 @@ class ConveRTFeaturizer(DenseFeaturizer, GraphComponent):
         batch_size = 64
 
         for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
-
             non_empty_examples = list(
                 filter(lambda x: x.get(attribute), training_data.training_examples)
             )
@@ -410,7 +407,6 @@ class ConveRTFeaturizer(DenseFeaturizer, GraphComponent):
             )
 
     def _tokenize(self, sentence: Text) -> Any:
-
         return self.tokenize_signature(tf.convert_to_tensor([sentence]))[
             "default"
         ].numpy()

rasa/nlu/featurizers/dense_featurizer/lm_featurizer.py

@@ -316,7 +316,6 @@ class LanguageModelFeaturizer(DenseFeaturizer, GraphComponent):
         batch_token_ids = []
         batch_tokens = []
         for example in batch_examples:
-
             example_tokens, example_token_ids = self._tokenize_example(
                 example, attribute
             )
@@ -416,7 +415,6 @@ class LanguageModelFeaturizer(DenseFeaturizer, GraphComponent):
         # This doesn't affect the computation since we compute an attention mask
         # anyways.
         for example_token_ids in batch_token_ids:
-
             # Truncate any longer sequences so that they can be fed to the model
             if len(example_token_ids) > max_sequence_length_model:
                 example_token_ids = example_token_ids[:max_sequence_length_model]
@@ -710,7 +708,6 @@ class LanguageModelFeaturizer(DenseFeaturizer, GraphComponent):
         batch_size = 64
 
         for attribute in DENSE_FEATURIZABLE_ATTRIBUTES:
-
             non_empty_examples = list(
                 filter(lambda x: x.get(attribute), training_data.training_examples)
             )
@@ -718,7 +715,6 @@ class LanguageModelFeaturizer(DenseFeaturizer, GraphComponent):
             batch_start_index = 0
 
             while batch_start_index < len(non_empty_examples):
-
                 batch_end_index = min(
                     batch_start_index + batch_size, len(non_empty_examples)
                 )

rasa/nlu/featurizers/featurizer.py

@@ -64,7 +64,7 @@ class Featurizer(Generic[FeatureType], ABC):
 
     @staticmethod
     def raise_if_featurizer_configs_are_not_compatible(
-        featurizer_configs: Iterable[Dict[Text, Any]]
+        featurizer_configs: Iterable[Dict[Text, Any]],
     ) -> None:
         """Validates that the given configurations of featurizers can be used together.
 

rasa/nlu/featurizers/sparse_featurizer/count_vectors_featurizer.py

@@ -1,32 +1,30 @@
 from __future__ import annotations
-
 import logging
 import re
-from typing import Any, Dict, List, Optional, Text, Tuple, Set, Type, Union
-
-import numpy as np
 import scipy.sparse
-from sklearn.exceptions import NotFittedError
-from sklearn.feature_extraction.text import CountVectorizer
+from typing import Any, Dict, List, Optional, Text, Tuple, Set, Type
+from rasa.nlu.tokenizers.tokenizer import Tokenizer
 
 import rasa.shared.utils.io
 from rasa.engine.graph import GraphComponent, ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
+from rasa.nlu.utils.spacy_utils import SpacyModel
+from rasa.shared.constants import DOCS_URL_COMPONENTS
+import rasa.utils.io as io_utils
+from sklearn.exceptions import NotFittedError
+from sklearn.feature_extraction.text import CountVectorizer
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.exceptions import RasaException, FileIOException
 from rasa.nlu.constants import (
     TOKENS_NAMES,
     MESSAGE_ATTRIBUTES,
     DENSE_FEATURIZABLE_ATTRIBUTES,
 )
-from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
-from rasa.nlu.tokenizers.tokenizer import Tokenizer
-from rasa.nlu.utils.spacy_utils import SpacyModel
-from rasa.shared.constants import DOCS_URL_COMPONENTS
-from rasa.shared.exceptions import RasaException, FileIOException
 from rasa.shared.nlu.constants import TEXT, INTENT, INTENT_RESPONSE_KEY, ACTION_NAME
-from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.training_data import TrainingData
 
 BUFFER_SLOTS_PREFIX = "buf_"
 
@@ -101,7 +99,6 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
         return ["sklearn"]
 
     def _load_count_vect_params(self) -> None:
-
         # Use shared vocabulary between text and all other attributes of Message
         self.use_shared_vocab = self._config["use_shared_vocab"]
 
@@ -342,7 +339,7 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _convert_attribute_tokens_to_texts(
-        attribute_tokens: Dict[Text, List[List[Text]]]
+        attribute_tokens: Dict[Text, List[List[Text]]],
     ) -> Dict[Text, List[Text]]:
         attribute_texts = {}
 
@@ -661,7 +658,6 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
         for message in messages:
             for attribute in self._attributes:
-
                 message_tokens = self._get_processed_message_tokens_by_attribute(
                     message, attribute
                 )
@@ -687,36 +683,11 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _is_any_model_trained(
-        attribute_vocabularies: Dict[Text, Optional[Dict[Text, int]]]
+        attribute_vocabularies: Dict[Text, Optional[Dict[Text, int]]],
     ) -> bool:
         """Check if any model got trained."""
         return any(value is not None for value in attribute_vocabularies.values())
 
-    @staticmethod
-    def convert_vocab(
-        vocab: Dict[str, Union[int, Optional[Dict[str, int]]]], to_int: bool
-    ) -> Dict[str, Union[None, int, np.int64, Dict[str, Union[int, np.int64]]]]:
-        """Converts numpy integers in the vocabulary to Python integers."""
-
-        def convert_value(value: int) -> Union[int, np.int64]:
-            """Helper function to convert a single value based on to_int flag."""
-            return int(value) if to_int else np.int64(value)
-
-        result_dict: Dict[
-            str, Union[None, int, np.int64, Dict[str, Union[int, np.int64]]]
-        ] = {}
-        for key, sub_dict in vocab.items():
-            if isinstance(sub_dict, int):
-                result_dict[key] = convert_value(sub_dict)
-            elif not sub_dict:
-                result_dict[key] = None
-            else:
-                result_dict[key] = {
-                    sub_key: convert_value(value) for sub_key, value in sub_dict.items()
-                }
-
-        return result_dict
-
     def persist(self) -> None:
         """Persist this model into the passed directory.
 
@@ -730,18 +701,17 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
             attribute_vocabularies = self._collect_vectorizer_vocabularies()
             if self._is_any_model_trained(attribute_vocabularies):
                 # Definitely need to persist some vocabularies
-                featurizer_file = model_dir / "vocabularies.json"
+                featurizer_file = model_dir / "vocabularies.pkl"
 
                 # Only persist vocabulary from one attribute if `use_shared_vocab`.
                 # Can be loaded and distributed to all attributes.
-                loaded_vocab = (
+                vocab = (
                     attribute_vocabularies[TEXT]
                     if self.use_shared_vocab
                     else attribute_vocabularies
                 )
-                vocab = self.convert_vocab(loaded_vocab, to_int=True)
 
-                rasa.shared.utils.io.dump_obj_as_json_to_file(featurizer_file, vocab)
+                io_utils.json_pickle(featurizer_file, vocab)
 
                 # Dump OOV words separately as they might have been modified during
                 # training
@@ -816,9 +786,8 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_dir:
-                featurizer_file = model_dir / "vocabularies.json"
-                vocabulary = rasa.shared.utils.io.read_json_file(featurizer_file)
-                vocabulary = cls.convert_vocab(vocabulary, to_int=False)
+                featurizer_file = model_dir / "vocabularies.pkl"
+                vocabulary = io_utils.json_unpickle(featurizer_file)
 
                 share_vocabulary = config["use_shared_vocab"]
 

rasa/nlu/featurizers/sparse_featurizer/lexical_syntactic_featurizer.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-
 import logging
 from collections import OrderedDict
+
+import scipy.sparse
+import numpy as np
 from typing import (
     Any,
     Dict,
@@ -15,34 +17,30 @@ from typing import (
     Union,
 )
 
-import numpy as np
-import scipy.sparse
-
-import rasa.shared.utils.io
-import rasa.utils.io
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.nlu.constants import TOKENS_NAMES
-from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
 from rasa.nlu.tokenizers.spacy_tokenizer import POS_TAG_KEY, SpacyTokenizer
 from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
+from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
+from rasa.nlu.constants import TOKENS_NAMES
 from rasa.shared.constants import DOCS_URL_COMPONENTS
-from rasa.shared.exceptions import InvalidConfigException
-from rasa.shared.nlu.constants import TEXT
-from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.constants import TEXT
+from rasa.shared.exceptions import InvalidConfigException
+import rasa.shared.utils.io
+import rasa.utils.io
 
 logger = logging.getLogger(__name__)
 
+
 END_OF_SENTENCE = "EOS"
 BEGIN_OF_SENTENCE = "BOS"
 
 FEATURES = "features"
 
-SEPERATOR = "###"
-
 
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.MESSAGE_FEATURIZER, is_trainable=True
@@ -74,13 +72,11 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
       of the token at position `t+1`.
     """
 
-    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.json"
+    FILENAME_FEATURE_TO_IDX_DICT = "feature_to_idx_dict.pkl"
 
     # NOTE: "suffix5" of the token "is" will be "is". Hence, when combining multiple
     # prefixes, short words will be represented/encoded repeatedly.
-    _FUNCTION_DICT: Dict[
-        Text, Callable[[Token], Union[Text, bool, None]]
-    ] = {  # noqa: RUF012
+    _FUNCTION_DICT: Dict[Text, Callable[[Token], Union[Text, bool, None]]] = {  # noqa: RUF012
         "low": lambda token: token.text.islower(),
         "title": lambda token: token.text.istitle(),
         "prefix5": lambda token: token.text[:5],
@@ -331,7 +327,6 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         assert len(window_range) == window_size
 
         for anchor in range(len(tokens)):
-
             token_features: Dict[Tuple[int, Text], Text] = {}
 
             for window_position, relative_position in enumerate(window_range):
@@ -343,13 +338,13 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
 
                 token = tokens[absolute_position]
                 for feature_name in self._feature_config[window_position]:
-                    token_features[
-                        (window_position, feature_name)
-                    ] = self._extract_raw_features_from_token(
-                        token=token,
-                        feature_name=feature_name,
-                        token_position=absolute_position,
-                        num_tokens=len(tokens),
+                    token_features[(window_position, feature_name)] = (
+                        self._extract_raw_features_from_token(
+                            token=token,
+                            feature_name=feature_name,
+                            token_position=absolute_position,
+                            num_tokens=len(tokens),
+                        )
                     )
 
             sentence_features.append(token_features)
@@ -358,7 +353,7 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
 
     @staticmethod
     def _build_feature_to_index_map(
-        feature_vocabulary: Dict[Tuple[int, Text], Set[Text]]
+        feature_vocabulary: Dict[Tuple[int, Text], Set[Text]],
     ) -> Dict[Tuple[int, Text], Dict[Text, int]]:
         """Creates a nested dictionary for mapping raw features to indices.
 
@@ -493,32 +488,6 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         """Creates a new untrained component (see parent class for full docstring)."""
         return cls(config, model_storage, resource, execution_context)
 
-    @staticmethod
-    def _restructure_feature_to_idx_dict(
-        loaded_data: Dict[str, Dict[str, int]],
-    ) -> Dict[Tuple[int, str], Dict[str, int]]:
-        """Reconstructs the feature to idx dict.
-
-        When storing the feature_to_idx_dict to disk, we need to convert the tuple (key)
-        into a string to be able to store it via json. When loading the data
-        we need to reconstruct the tuple from the stored string.
-
-        Args:
-            loaded_data: The loaded feature to idx dict from file.
-
-        Returns:
-            The reconstructed feature_to_idx_dict
-        """
-        feature_to_idx_dict = {}
-        for tuple_string, feature_value in loaded_data.items():
-            # Example of tuple_string: "1###low"
-            index, feature_name = tuple_string.split(SEPERATOR)
-
-            feature_key = (int(index), feature_name)
-            feature_to_idx_dict[feature_key] = feature_value
-
-        return feature_to_idx_dict
-
     @classmethod
     def load(
         cls,
@@ -531,13 +500,10 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         """Loads trained component (see parent class for full docstring)."""
         try:
             with model_storage.read_from(resource) as model_path:
-                loaded_data = rasa.shared.utils.io.read_json_file(
+                feature_to_idx_dict = rasa.utils.io.json_unpickle(
                     model_path / cls.FILENAME_FEATURE_TO_IDX_DICT,
+                    encode_non_string_keys=True,
                 )
-
-                # convert the key back into tuple
-                feature_to_idx_dict = cls._restructure_feature_to_idx_dict(loaded_data)
-
                 return cls(
                     config=config,
                     model_storage=model_storage,
@@ -562,13 +528,9 @@ class LexicalSyntacticFeaturizer(SparseFeaturizer, GraphComponent):
         if not self._feature_to_idx_dict:
             return None
 
-        # as we cannot dump tuples, convert the tuple into a string
-        restructured_feature_dict = {
-            f"{k[0]}{SEPERATOR}{k[1]}": v for k, v in self._feature_to_idx_dict.items()
-        }
-
         with self._model_storage.write_to(self._resource) as model_path:
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
+            rasa.utils.io.json_pickle(
                 model_path / self.FILENAME_FEATURE_TO_IDX_DICT,
-                restructured_feature_dict,
+                self._feature_to_idx_dict,
+                encode_non_string_keys=True,
             )

rasa/nlu/featurizers/sparse_featurizer/regex_featurizer.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
-
 import logging
 import re
 from typing import Any, Dict, List, Optional, Text, Tuple, Type
-
 import numpy as np
 import scipy.sparse
-
 from rasa.nlu.tokenizers.tokenizer import Tokenizer
+
 import rasa.shared.utils.io
 import rasa.utils.io
 import rasa.nlu.utils.pattern_utils as pattern_utils
@@ -242,7 +240,7 @@ class RegexFeaturizer(SparseFeaturizer, GraphComponent):
 
         try:
             with model_storage.read_from(resource) as model_dir:
-                patterns_file_name = model_dir / "patterns.json"
+                patterns_file_name = model_dir / "patterns.pkl"
                 known_patterns = rasa.shared.utils.io.read_json_file(patterns_file_name)
         except (ValueError, FileNotFoundError):
             logger.warning(
@@ -260,7 +258,7 @@ class RegexFeaturizer(SparseFeaturizer, GraphComponent):
 
     def _persist(self) -> None:
         with self._model_storage.write_to(self._resource) as model_dir:
-            regex_file = model_dir / "patterns.json"
+            regex_file = model_dir / "patterns.pkl"
             rasa.shared.utils.io.dump_obj_as_json_to_file(
                 regex_file, self.known_patterns
             )

rasa/nlu/persistor.py

@@ -1,16 +1,18 @@
 import abc
-import logging
+import structlog
 import os
 import shutil
 from typing import Optional, Text, Tuple, TYPE_CHECKING
 
+from rasa.shared.exceptions import RasaException
+
 import rasa.shared.utils.common
 import rasa.utils.common
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 def get_persistor(name: Text) -> Optional["Persistor"]:
@@ -95,7 +97,6 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
-
         ext = ".tar.gz" if include_extension else ""
         return f"{model_name}{ext}"
 
@@ -129,20 +130,36 @@ class AWSPersistor(Persistor):
     def _ensure_bucket_exists(
         self, bucket_name: Text, region_name: Optional[Text] = None
     ) -> None:
-        import boto3
         import botocore
 
-        if not region_name:
-            region_name = boto3.DEFAULT_SESSION.region_name
-
-        bucket_config = {"LocationConstraint": region_name}
         # noinspection PyUnresolvedReferences
         try:
-            self.s3.create_bucket(
-                Bucket=bucket_name, CreateBucketConfiguration=bucket_config
-            )
-        except botocore.exceptions.ClientError:
-            pass  # bucket already exists
+            self.s3.meta.client.head_bucket(Bucket=bucket_name)
+        except botocore.exceptions.ClientError as e:
+            error_code = int(e.response["Error"]["Code"])
+            if error_code == 403:
+                log = (
+                    f"Access to the specified bucket '{bucket_name}' is forbidden. "
+                    "Please make sure you have the necessary "
+                    "permission to access the bucket."
+                )
+                structlogger.error(
+                    "aws_persistor.ensure_bucket_exists.bucket_access_forbidden",
+                    bucket_name=bucket_name,
+                    event_info=log,
+                )
+                raise RasaException(log)
+            elif error_code == 404:
+                log = (
+                    f"The specified bucket '{bucket_name}' does not exist. "
+                    "Please make sure to create the bucket first."
+                )
+                structlogger.error(
+                    "aws_persistor.ensure_bucket_exists.bucket_not_found",
+                    bucket_name=bucket_name,
+                    event_info=log,
+                )
+                raise RasaException(log)
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
@@ -180,10 +197,30 @@ class GCSPersistor(Persistor):
         from google.cloud import exceptions
 
         try:
-            self.storage_client.create_bucket(bucket_name)
-        except exceptions.Conflict:
-            # bucket exists
-            pass
+            self.storage_client.get_bucket(bucket_name)
+        except exceptions.NotFound:
+            log = (
+                f"The specified bucket '{bucket_name}' does not exist. "
+                "Please make sure to create the bucket first."
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.bucket_not_found",
+                bucket_name=bucket_name,
+                event_info=log,
+            )
+            raise RasaException(log)
+        except exceptions.Forbidden:
+            log = (
+                f"Access to the specified bucket '{bucket_name}' is forbidden. "
+                "Please make sure you have the necessary "
+                "permission to access the bucket. "
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.bucket_access_forbidden",
+                bucket_name=bucket_name,
+                event_info=log,
+            )
+            raise RasaException(log)
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to GCS."""
@@ -210,18 +247,23 @@ class AzurePersistor(Persistor):
             account_url=f"https://{azure_account_name}.blob.core.windows.net/",
             credential=azure_account_key,
         )
-
-        self._ensure_container_exists(azure_container)
         self.container_name = azure_container
+        self._ensure_container_exists()
 
-    def _ensure_container_exists(self, container_name: Text) -> None:
-        from azure.core.exceptions import ResourceExistsError
-
-        try:
-            self.blob_service.create_container(container_name)
-        except ResourceExistsError:
-            # no need to create the container, it already exists
+    def _ensure_container_exists(self) -> None:
+        if self._container_client().exists():
             pass
+        else:
+            log = (
+                f"The specified container '{self.container_name}' does not exist."
+                "Please make sure to create the container first."
+            )
+            structlogger.error(
+                "azure_persistor.ensure_container_exists.container_not_found",
+                container_name=self.container_name,
+                event_info=log,
+            )
+            raise RasaException(log)
 
     def _container_client(self) -> "ContainerClient":
         return self.blob_service.get_container_client(self.container_name)

rasa/nlu/selectors/response_selector.py

@@ -430,9 +430,9 @@ class ResponseSelector(DIETClassifier):
         self, message: Message, prediction_dict: Dict[Text, Any], selector_key: Text
     ) -> None:
         message_selector_properties = message.get(RESPONSE_SELECTOR_PROPERTY_NAME, {})
-        message_selector_properties[
-            RESPONSE_SELECTOR_RETRIEVAL_INTENTS
-        ] = self.all_retrieval_intents
+        message_selector_properties[RESPONSE_SELECTOR_RETRIEVAL_INTENTS] = (
+            self.all_retrieval_intents
+        )
         message_selector_properties[selector_key] = prediction_dict
         message.set(
             RESPONSE_SELECTOR_PROPERTY_NAME,
@@ -505,7 +505,6 @@ class ResponseSelector(DIETClassifier):
             been caught earlier and a warning should have been raised.
         """
         for key, responses in self.responses.items():
-
             # First check if the predicted label was the key itself
             search_key = util.template_key_to_intent_response_key(key)
             if search_key == label.get("name"):
@@ -626,7 +625,6 @@ class ResponseSelector(DIETClassifier):
         config: Dict[Text, Any],
         finetune_mode: bool = False,
     ) -> "RasaModel":
-
         predict_data_example = RasaModelData(
             label_key=model_data_example.label_key,
             data={
@@ -723,7 +721,6 @@ class DIET2BOW(DIET):
             logger.debug(f"  {metric} ({name})")
 
     def _update_label_metrics(self, loss: tf.Tensor, acc: tf.Tensor) -> None:
-
         self.response_loss.update_state(loss)
         self.response_acc.update_state(acc)
 
@@ -796,10 +793,10 @@ class DIET2DIET(DIET):
             (self.text_name, self.config),
             (self.label_name, label_config),
         ]:
-            self._tf_layers[
-                f"sequence_layer.{attribute}"
-            ] = rasa_layers.RasaSequenceLayer(
-                attribute, self.data_signature[attribute], config
+            self._tf_layers[f"sequence_layer.{attribute}"] = (
+                rasa_layers.RasaSequenceLayer(
+                    attribute, self.data_signature[attribute], config
+                )
             )
 
         if self.config[MASKED_LM]:

rasa/nlu/test.py

@@ -886,7 +886,6 @@ def evaluate_entities(
             exclude_label=NO_ENTITY,
         )
         if output_directory:
-
             _dump_report(output_directory, f"{extractor}_report.json", report)
 
         if successes:
@@ -1550,7 +1549,6 @@ async def combine_result(
 
 
 def _contains_entity_labels(entity_results: List[EntityEvaluationResult]) -> bool:
-
     for result in entity_results:
         if result.entity_targets or result.entity_predictions:
             return True
@@ -1791,7 +1789,6 @@ async def compare_nlu(
     training_examples_per_run = []
 
     for run in range(runs):
-
         logger.info("Beginning comparison run {}/{}".format(run + 1, runs))
 
         run_path = os.path.join(output, "run_{}".format(run + 1))

rasa/nlu/utils/hugging_face/registry.py

@@ -25,7 +25,7 @@ from transformers import (  # noqa: E402
     RobertaTokenizer,
     CamembertTokenizer,
 )
-from rasa.nlu.utils.hugging_face.transformers_pre_post_processors import (  # noqa: E402, E501
+from rasa.nlu.utils.hugging_face.transformers_pre_post_processors import (  # noqa: E402
     bert_tokens_pre_processor,
     gpt_tokens_pre_processor,
     xlnet_tokens_pre_processor,