if task.cancelled():
             continue
         if task.exception() is not None:
-            loop.call_exception_handler(
-                {
-                    "message": "Unhandled exception during Client.run shutdown.",
-                    "exception": task.exception(),
-                    "task": task,
-                }
-            )
+            loop.call_exception_handler({
+                "message": "Unhandled exception during Client.run shutdown.",
+                "exception": task.exception(),
+                "task": task,
+            })
 
 
 def _cleanup_loop(loop: asyncio.AbstractEventLoop) -> None:

         return total
 
     def __bool__(self) -> bool:
-        return any(
-            (
-                self.title,
-                self.url,
-                self.description,
-                self._colour,
-                self._fields,
-                self._timestamp,
-                self._author,
-                self._thumbnail,
-                self._footer,
-                self._image,
-                self._provider,
-                self._video,
-            )
-        )
+        return any((
+            self.title,
+            self.url,
+            self.description,
+            self._colour,
+            self._fields,
+            self._timestamp,
+            self._author,
+            self._thumbnail,
+            self._footer,
+            self._image,
+            self._provider,
+            self._video,
+        ))
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Embed):

             overwrites_data: List[PermissionOverwritePayload] = []
             for target, perm in overwrites.items():
                 allow, deny = perm.pair()
-                overwrites_data.append(
-                    {
-                        "allow": str(allow.value),
-                        "deny": str(deny.value),
-                        "id": target,
-                        # can only set overrides for roles here
-                        "type": abc._Overwrites.ROLE,
-                    }
-                )
+                overwrites_data.append({
+                    "allow": str(allow.value),
+                    "deny": str(deny.value),
+                    "id": target,
+                    # can only set overrides for roles here
+                    "type": abc._Overwrites.ROLE,
+                })
             data["permission_overwrites"] = overwrites_data
 
         if category is not MISSING:

         _log.exception("Exception occurred during %s", info)
 
 
-_SELECT_COMPONENT_TYPES = frozenset(
-    (
-        ComponentType.string_select,
-        ComponentType.user_select,
-        ComponentType.role_select,
-        ComponentType.mentionable_select,
-        ComponentType.channel_select,
-    )
-)
+_SELECT_COMPONENT_TYPES = frozenset((
+    ComponentType.string_select,
+    ComponentType.user_select,
+    ComponentType.role_select,
+    ComponentType.mentionable_select,
+    ComponentType.channel_select,
+))
 
 
 class ConnectionState:

         )
         normalized_query = query_details[0]["normalized_query"]
 
-        return Response(
-            {
-                "query": normalized_query,
-            }
-        )
+        return Response({
+            "query": normalized_query,
+        })
 
     @action(detail=True, methods=["GET"])
     def query_metrics(self, request: Request, pk: str):

         )
         cpu = run_query(QUERY_CPU_USAGE_SQL, {"days": days, "conditions": conditions})
 
-        return Response(
-            {
-                "execution_count": execution_count,
-                "memory_usage": memory_usage,
-                "read_bytes": read_bytes,
-                "cpu": cpu,
-            }
-        )
+        return Response({
+            "execution_count": execution_count,
+            "memory_usage": memory_usage,
+            "read_bytes": read_bytes,
+            "cpu": cpu,
+        })
 
     @action(detail=True, methods=["GET"])
     def query_explain(self, request: Request, pk: str):

         example_queries = query_details[0]["example_queries"]
         explain = run_query(EXPLAIN_QUERY, {"query": example_queries[0]})
 
-        return Response(
-            {
-                "explain": explain,
-            }
-        )
+        return Response({
+            "explain": explain,
+        })
 
     @action(detail=True, methods=["GET"])
     def query_examples(self, request: Request, pk: str):

         )
         example_queries = query_details[0]["example_queries"]
 
-        return Response(
-            {
-                "example_queries": [{"query": q} for q in example_queries],
-            }
-        )
+        return Response({
+            "example_queries": [{"query": q} for q in example_queries],
+        })
 
     @action(detail=False, methods=["GET"])
     def query_graphs(self, request: Request):

         )
         read_bytes = run_query(QUERY_READ_BYTES_SQL, {"days": days, "conditions": ""})
         cpu = run_query(QUERY_CPU_USAGE_SQL, {"days": days, "conditions": ""})
-        return Response(
-            {
-                "execution_count": execution_count,
-                "memory_usage": memory_usage,
-                "read_bytes": read_bytes,
-                "cpu": cpu,
-            }
-        )
+        return Response({
+            "execution_count": execution_count,
+            "memory_usage": memory_usage,
+            "read_bytes": read_bytes,
+            "cpu": cpu,
+        })
 
     @action(detail=False, methods=["POST"])
     def logs(self, request: Request):

                 )
                 i += 1
                 sleep(0.5)
-            return Response(
-                {
-                    "is_result_equal": is_result_equal,
-                    "benchmarking_result": benchmarking_result,
-                }
-            )
+            return Response({
+                "is_result_equal": is_result_equal,
+                "benchmarking_result": benchmarking_result,
+            })
         except Exception as e:
             return Response(
                 status=418, data={"error": str(e), "error_location": error_location}

             self.exchange_name, type=aio_pika.ExchangeType.FANOUT
         )
 
-        await asyncio.gather(
-            *[
-                self._bind_queue(queue_name, channel, exchange)
-                for queue_name in self.queues
-            ]
-        )
+        await asyncio.gather(*[
+            self._bind_queue(queue_name, channel, exchange)
+            for queue_name in self.queues
+        ])
 
         return exchange
 

                 )
                 return None
 
-            hangouts_buttons.append(
-                {
-                    "textButton": {
-                        "text": b_txt,
-                        "onClick": {"action": {"actionMethodName": b_pl}},
-                    }
+            hangouts_buttons.append({
+                "textButton": {
+                    "text": b_txt,
+                    "onClick": {"action": {"actionMethodName": b_pl}},
                 }
-            )
+            })
 
         card = {
             "cards": [

         """
         with path.open(mode="w") as f:
             table_writer = csv.writer(f)
-            table_writer.writerow(
-                [
-                    "sender_id",
-                    "session_idx",
-                    "marker",
-                    "event_idx",
-                    "num_preceding_user_turns",
-                ]
-            )
+            table_writer.writerow([
+                "sender_id",
+                "session_idx",
+                "marker",
+                "event_idx",
+                "num_preceding_user_turns",
+            ])
             for sender_id, results_per_session in results.items():
                 for session_idx, session_result in enumerate(results_per_session):
                     Marker._write_relevant_events(

     ) -> None:
         for marker_name, meta_data_per_relevant_event in session.items():
             for event_meta_data in meta_data_per_relevant_event:
-                writer.writerow(
-                    [
-                        sender_id,
-                        str(session_idx),
-                        marker_name,
-                        str(event_meta_data.idx),
-                        str(event_meta_data.preceding_user_turns),
-                    ]
-                )
+                writer.writerow([
+                    sender_id,
+                    str(session_idx),
+                    marker_name,
+                    str(event_meta_data.idx),
+                    str(event_meta_data.preceding_user_turns),
+                ])
 
 
 class OperatorMarker(Marker, ABC):

             value_str = str(np.nan)
         else:
             value_str = np.round(statistic_value, 3)
-        table_writer.writerow(
-            [
-                str(item)
-                for item in [
-                    sender_id,
-                    session_idx,
-                    marker_name,
-                    statistic_name,
-                    value_str,
-                ]
+        table_writer.writerow([
+            str(item)
+            for item in [
+                sender_id,
+                session_idx,
+                marker_name,
+                statistic_name,
+                value_str,
             ]
-        )
+        ])

         """
         # store labels in numpy arrays so that it corresponds to np arrays of input
         # features
-        return ragged_array_to_ndarray(
-            [
-                np.array(
-                    [domain.index_for_action(action) for action in tracker_actions]
-                )
-                for tracker_actions in trackers_as_actions
-            ]
-        )
+        return ragged_array_to_ndarray([
+            np.array([domain.index_for_action(action) for action in tracker_actions])
+            for tracker_actions in trackers_as_actions
+        ])
 
     def _create_entity_tags(
         self,

             updated_mappings.append(mapping_copy)
 
     for mapping in new_mappings:
-        mapping.update(
-            {
-                "conditions": [
-                    _get_updated_mapping_condition(condition, mapping, slot_name)
-                ]
-            }
-        )
+        mapping.update({
+            "conditions": [
+                _get_updated_mapping_condition(condition, mapping, slot_name)
+            ]
+        })
         updated_mappings.append(mapping)
 
     return updated_mappings

         elif key == KEY_FORMS:
             new_domain.update({key: new_forms})
         elif key == "version":
-            new_domain.update(
-                {key: DoubleQuotedScalarString(LATEST_TRAINING_DATA_FORMAT_VERSION)}
-            )
+            new_domain.update({
+                key: DoubleQuotedScalarString(LATEST_TRAINING_DATA_FORMAT_VERSION)
+            })
         else:
             new_domain.update({key: value})
     return new_domain

 
         if KEY_SLOTS not in original_content and KEY_FORMS not in original_content:
             if isinstance(original_content, dict):
-                original_content.update(
-                    {
-                        "version": DoubleQuotedScalarString(
-                            LATEST_TRAINING_DATA_FORMAT_VERSION
-                        )
-                    }
-                )
+                original_content.update({
+                    "version": DoubleQuotedScalarString(
+                        LATEST_TRAINING_DATA_FORMAT_VERSION
+                    )
+                })
 
             # this is done so that the other domain files can be moved
             # in the migrated directory

         model_data = RasaModelData(label_key=LABEL_KEY, label_sub_key=LABEL_SUB_KEY)
 
         if label_ids is not None and encoded_all_labels is not None:
-            label_ids = np.array(
-                [np.expand_dims(seq_label_ids, -1) for seq_label_ids in label_ids]
-            )
+            label_ids = np.array([
+                np.expand_dims(seq_label_ids, -1) for seq_label_ids in label_ids
+            ])
             model_data.add_features(
                 LABEL_KEY,
                 LABEL_SUB_KEY,

 
         # add the dialogue lengths
         attribute_present = next(iter(list(attribute_data.keys())))
-        dialogue_lengths = np.array(
-            [
-                np.size(np.squeeze(f, -1))
-                for f in model_data.data[attribute_present][MASK][0]
-            ]
-        )
+        dialogue_lengths = np.array([
+            np.size(np.squeeze(f, -1))
+            for f in model_data.data[attribute_present][MASK][0]
+        ])
         model_data.data[DIALOGUE][LENGTH] = [
             FeatureArray(dialogue_lengths, number_of_dimensions=1)
         ]

         # Disable input dropout in the config to be used if this is a label attribute.
         if is_label_attribute:
             config_to_use = self.config.copy()
-            config_to_use.update(
-                {SPARSE_INPUT_DROPOUT: False, DENSE_INPUT_DROPOUT: False}
-            )
+            config_to_use.update({
+                SPARSE_INPUT_DROPOUT: False,
+                DENSE_INPUT_DROPOUT: False,
+            })
         else:
             config_to_use = self.config
         # Attributes with sequence-level features also have sentence-level features,

     @staticmethod
     def _log_slots(tracker: DialogueStateTracker) -> None:
         # Log currently set slots
-        slot_values = "\n".join(
-            [f"\t{s.name}: {s.value}" for s in tracker.slots.values()]
-        )
+        slot_values = "\n".join([
+            f"\t{s.name}: {s.value}" for s in tracker.slots.values()
+        ])
         if slot_values.strip():
             structlogger.debug(
                 "processor.slots.log", slot_values=copy.deepcopy(slot_values)

 
             if action_executed_result.action_targets:
                 tracker_eval_store.merge_store(action_executed_result)
-                tracker_actions.append(
-                    {
-                        "action": action_executed_result.action_targets[0],
-                        "predicted": action_executed_result.action_predictions[0],
-                        "policy": prediction.policy_name,
-                        "confidence": prediction.max_confidence,
-                    }
-                )
+                tracker_actions.append({
+                    "action": action_executed_result.action_targets[0],
+                    "predicted": action_executed_result.action_predictions[0],
+                    "policy": prediction.policy_name,
+                    "confidence": prediction.max_confidence,
+                })
         elif use_e2e and isinstance(event, UserUttered):
             # This means that user utterance didn't have a user message, only intent,
             # so we can skip the NLU part and take the parse data directly.

         for new_event in tracker.events:
             # Event subclasses implement `__eq__` method that make it difficult
             # to compare events. We use `as_dict` to compare events.
-            if all(
-                [
-                    new_event.as_dict() != existing_event.as_dict()
-                    for existing_event in merged.events
-                ]
-            ):
+            if all([
+                new_event.as_dict() != existing_event.as_dict()
+                for existing_event in merged.events
+            ]):
                 merged.update(new_event)
 
         return merged

                     cli_parameters,
                 )
 
-            if component.types.intersection(
-                {
-                    self.ComponentType.MESSAGE_TOKENIZER,
-                    self.ComponentType.MESSAGE_FEATURIZER,
-                }
-            ):
+            if component.types.intersection({
+                self.ComponentType.MESSAGE_TOKENIZER,
+                self.ComponentType.MESSAGE_FEATURIZER,
+            }):
                 last_run_node = self._add_nlu_process_node(
                     train_nodes,
                     component.clazz,

                     config=config,
                 )
 
-            if component.types.intersection(
-                {
-                    self.ComponentType.MESSAGE_TOKENIZER,
-                    self.ComponentType.MESSAGE_FEATURIZER,
-                }
-            ):
+            if component.types.intersection({
+                self.ComponentType.MESSAGE_TOKENIZER,
+                self.ComponentType.MESSAGE_FEATURIZER,
+            }):
                 last_run_node = self._add_nlu_predict_node_from_train(
                     predict_nodes,
                     component_name,

                     config,
                     from_resource=component.is_trainable,
                 )
-            elif component.types.intersection(
-                {
-                    self.ComponentType.INTENT_CLASSIFIER,
-                    self.ComponentType.ENTITY_EXTRACTOR,
-                }
-            ):
+            elif component.types.intersection({
+                self.ComponentType.INTENT_CLASSIFIER,
+                self.ComponentType.ENTITY_EXTRACTOR,
+            }):
                 if component.is_trainable:
                     last_run_node = self._add_nlu_predict_node_from_train(
                         predict_nodes,

         for component_type, node_names in unmet_requirements_for_target.items():
             unmet_requirements.setdefault(component_type, set()).update(node_names)
     if unmet_requirements:
-        errors = "\n".join(
-            [
-                f"The following components require a {component_type.__name__}: "
-                f"{', '.join(sorted(required_by))}. "
-                for component_type, required_by in unmet_requirements.items()
-            ]
-        )
+        errors = "\n".join([
+            f"The following components require a {component_type.__name__}: "
+            f"{', '.join(sorted(required_by))}. "
+            for component_type, required_by in unmet_requirements.items()
+        ])
         num_nodes = len(
             set(
                 node_name

                 docs=DOCS_URL_COMPONENTS,
             )
 
-        if training_data.entity_examples and self._component_types.isdisjoint(
-            {DIETClassifier, CRFEntityExtractor}
-        ):
+        if training_data.entity_examples and self._component_types.isdisjoint({
+            DIETClassifier,
+            CRFEntityExtractor,
+        }):
             if training_data.entity_roles_groups_used():
                 rasa.shared.utils.io.raise_warning(
                     f"You have defined training data with entities that "

                     docs=DOCS_URL_COMPONENTS,
                 )
 
-        if training_data.regex_features and self._component_types.isdisjoint(
-            [RegexFeaturizer, RegexEntityExtractor]
-        ):
+        if training_data.regex_features and self._component_types.isdisjoint([
+            RegexFeaturizer,
+            RegexEntityExtractor,
+        ]):
             rasa.shared.utils.io.raise_warning(
                 f"You have defined training data with regexes, but "
                 f"your NLU configuration does not include a 'RegexFeaturizer' "

                 docs=DOCS_URL_COMPONENTS,
             )
 
-        if training_data.lookup_tables and self._component_types.isdisjoint(
-            [RegexFeaturizer, RegexEntityExtractor]
-        ):
+        if training_data.lookup_tables and self._component_types.isdisjoint([
+            RegexFeaturizer,
+            RegexEntityExtractor,
+        ]):
             rasa.shared.utils.io.raise_warning(
                 f"You have defined training data consisting of lookup tables, but "
                 f"your NLU configuration does not include a featurizer "

             and not node_name.startswith("e2e")
         ]
 
-        Featurizer.raise_if_featurizer_configs_are_not_compatible(
-            [schema_node.config for schema_node in featurizers]
-        )
+        Featurizer.raise_if_featurizer_configs_are_not_compatible([
+            schema_node.config for schema_node in featurizers
+        ])
 
     def _validate_core(self, story_graph: StoryGraph, domain: Domain) -> None:
         """Validates whether the configuration matches the training data.

 
             # disable input dropout applied to sparse and dense label features
             label_config = self.config.copy()
-            label_config.update(
-                {SPARSE_INPUT_DROPOUT: False, DENSE_INPUT_DROPOUT: False}
-            )
+            label_config.update({
+                SPARSE_INPUT_DROPOUT: False,
+                DENSE_INPUT_DROPOUT: False,
+            })
 
             self._tf_layers[
                 f"feature_combining_layer.{self.label_name}"

         for index, embedding in enumerate(sequence_embeddings):
             embedding_size = embedding.shape[-1]
             if actual_sequence_lengths[index] > self.max_model_sequence_length:
-                embedding = np.concatenate(
-                    [
-                        embedding,
-                        np.zeros(
-                            (
-                                actual_sequence_lengths[index]
-                                - self.max_model_sequence_length,
-                                embedding_size,
-                            ),
-                            dtype=np.float32,
+                embedding = np.concatenate([
+                    embedding,
+                    np.zeros(
+                        (
+                            actual_sequence_lengths[index]
+                            - self.max_model_sequence_length,
+                            embedding_size,
                         ),
-                    ]
-                )
+                        dtype=np.float32,
+                    ),
+                ])
             reshaped_sequence_embeddings.append(embedding)
         return ragged_array_to_ndarray(reshaped_sequence_embeddings)
 

         # To train a shared vocabulary, we use TEXT as the
         # attribute for which a combined vocabulary is built.
         if not self.finetune_mode:
-            self.vectorizers = self._create_shared_vocab_vectorizers(
-                {
-                    "strip_accents": self.strip_accents,
-                    "lowercase": self.lowercase,
-                    "stop_words": self.stop_words,
-                    "min_ngram": self.min_ngram,
-                    "max_ngram": self.max_ngram,
-                    "max_df": self.max_df,
-                    "min_df": self.min_df,
-                    "max_features": self.max_features,
-                    "analyzer": self.analyzer,
-                }
-            )
+            self.vectorizers = self._create_shared_vocab_vectorizers({
+                "strip_accents": self.strip_accents,
+                "lowercase": self.lowercase,
+                "stop_words": self.stop_words,
+                "min_ngram": self.min_ngram,
+                "max_ngram": self.max_ngram,
+                "max_df": self.max_df,
+                "min_df": self.min_df,
+                "max_features": self.max_features,
+                "analyzer": self.analyzer,
+            })
             self._fit_vectorizer_from_scratch(TEXT, combined_cleaned_texts)
         else:
             self._fit_loaded_vectorizer(TEXT, combined_cleaned_texts)

     ) -> None:
         """Constructs the vectorizers and train them with an independent vocab."""
         if not self.finetune_mode:
-            self.vectorizers = self._create_independent_vocab_vectorizers(
-                {
-                    "strip_accents": self.strip_accents,
-                    "lowercase": self.lowercase,
-                    "stop_words": self.stop_words,
-                    "min_ngram": self.min_ngram,
-                    "max_ngram": self.max_ngram,
-                    "max_df": self.max_df,
-                    "min_df": self.min_df,
-                    "max_features": self.max_features,
-                    "analyzer": self.analyzer,
-                }
-            )
+            self.vectorizers = self._create_independent_vocab_vectorizers({
+                "strip_accents": self.strip_accents,
+                "lowercase": self.lowercase,
+                "stop_words": self.stop_words,
+                "min_ngram": self.min_ngram,
+                "max_ngram": self.max_ngram,
+                "max_df": self.max_df,
+                "min_df": self.min_df,
+                "max_features": self.max_features,
+                "analyzer": self.analyzer,
+            })
         for attribute in self._attributes:
             if self._attribute_texts_is_non_empty(attribute_texts[attribute]):
                 if not self.finetune_mode:

             `self.config` should be checked
         """
         self._feature_to_idx_dict = feature_to_idx_dict
-        self._number_of_features = sum(
-            [
-                len(feature_values.values())
-                for feature_values in self._feature_to_idx_dict.values()
-            ]
-        )
+        self._number_of_features = sum([
+            len(feature_values.values())
+            for feature_values in self._feature_to_idx_dict.values()
+        ])
         if check_consistency_with_config:
             known_features = set(self._feature_to_idx_dict.keys())
             not_in_config = known_features.difference(

     from rasa.nlu.extractors.crf_entity_extractor import CRFEntityExtractor
     from rasa.nlu.classifiers.diet_classifier import DIETClassifier
 
-    return not extractors.isdisjoint(
-        {CRFEntityExtractor.__name__, DIETClassifier.__name__}
-    )
+    return not extractors.isdisjoint({
+        CRFEntityExtractor.__name__,
+        DIETClassifier.__name__,
+    })
 
 
 def align_entity_predictions(

     @app.get("/version")
     async def version(request: Request) -> HTTPResponse:
         """Respond with the version number of the installed Rasa."""
-        return response.json(
-            {
-                "version": rasa.__version__,
-                "minimum_compatible_version": MINIMUM_COMPATIBLE_VERSION,
-            }
-        )
+        return response.json({
+            "version": rasa.__version__,
+            "minimum_compatible_version": MINIMUM_COMPATIBLE_VERSION,
+        })
 
     @app.get("/status")
     @requires_auth(app, auth_token)
     @ensure_loaded_agent(app)
     async def status(request: Request) -> HTTPResponse:
         """Respond with the model name and the fingerprint of that model."""
-        return response.json(
-            {
-                "model_file": app.ctx.agent.processor.model_filename,
-                "model_id": app.ctx.agent.model_id,
-                "num_active_training_jobs": app.ctx.active_training_processes.value,
-            }
-        )
+        return response.json({
+            "model_file": app.ctx.agent.processor.model_filename,
+            "model_id": app.ctx.agent.model_id,
+            "num_active_training_jobs": app.ctx.active_training_processes.value,
+        })
 
     @app.get("/conversations/<conversation_id:path>/tracker")
     @requires_auth(app, auth_token)

 
     message_from_md = entities_parser.parse_training_example(text, intent)
     deserialised_entities = deserialise_entities(entities)
-    return TrainingDataWriter.generate_message(
-        {"text": message_from_md.get(TEXT), "entities": deserialised_entities}
-    )
+    return TrainingDataWriter.generate_message({
+        "text": message_from_md.get(TEXT),
+        "entities": deserialised_entities,
+    })
 
 
 def split_events(

 
     def as_dict(self) -> Dict[Text, Any]:
         _dict = super().as_dict()
-        _dict.update(
-            {
-                "text": self.text,
-                "parse_data": self.parse_data,
-                "input_channel": getattr(self, "input_channel", None),
-                "message_id": getattr(self, "message_id", None),
-                "metadata": self.metadata,
-            }
-        )
+        _dict.update({
+            "text": self.text,
+            "parse_data": self.parse_data,
+            "input_channel": getattr(self, "input_channel", None),
+            "message_id": getattr(self, "message_id", None),
+            "metadata": self.metadata,
+        })
         return _dict
 
     def as_sub_state(self) -> Dict[Text, Union[None, Text, List[Optional[Text]]]]:

 
     def __hash__(self) -> int:
         """Returns unique hash for event."""
-        return hash(
-            (
-                self.intent,
-                self.entities,
-                self.trigger_date_time.isoformat(),
-                self.kill_on_user_message,
-                self.name,
-            )
-        )
+        return hash((
+            self.intent,
+            self.entities,
+            self.trigger_date_time.isoformat(),
+            self.kill_on_user_message,
+            self.name,
+        ))
 
     def __eq__(self, other: Any) -> bool:
         """Compares object with other object."""

 
     def as_story_string(self) -> Text:
         """Returns text representation of event."""
-        props = json.dumps(
-            {"name": self.name, "intent": self.intent, "entities": self.entities}
-        )
+        props = json.dumps({
+            "name": self.name,
+            "intent": self.intent,
+            "entities": self.entities,
+        })
         return f"{self.type_name}{props}"
 
     @classmethod

     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update(
-            {
-                "name": self.action_name,
-                "policy": self.policy,
-                "confidence": self.confidence,
-                "action_text": self.action_text,
-                "hide_rule_turn": self.hide_rule_turn,
-            }
-        )
+        d.update({
+            "name": self.action_name,
+            "policy": self.policy,
+            "confidence": self.confidence,
+            "action_text": self.action_text,
+            "hide_rule_turn": self.hide_rule_turn,
+        })
         return d
 
     def as_sub_state(self) -> Dict[Text, Text]:

     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update(
-            {
-                "name": self.action_name,
-                "policy": self.policy,
-                "confidence": self.confidence,
-            }
-        )
+        d.update({
+            "name": self.action_name,
+            "policy": self.policy,
+            "confidence": self.confidence,
+        })
         return d
 
     def apply_to(self, tracker: "DialogueStateTracker") -> None:

         """Add unused end checkpoints
         if they were never encountered as start checkpoints.
         """
-        return unused_checkpoints.union(
-            {
-                start_name
-                for start_name in start_checkpoints
-                if start_name not in used_checkpoints
-            }
-        )
+        return unused_checkpoints.union({
+            start_name
+            for start_name in start_checkpoints
+            if start_name not in used_checkpoints
+        })
 
     @staticmethod
     def _filter_active_trackers(

                 entity_values = [entity_values]
 
             for entity_value in entity_values:
-                entities.append(
-                    {
-                        ENTITY_ATTRIBUTE_TYPE: entity_type,
-                        ENTITY_ATTRIBUTE_VALUE: entity_value,
-                        ENTITY_ATTRIBUTE_START: match.start(ENTITIES),
-                        ENTITY_ATTRIBUTE_END: match.end(ENTITIES),
-                        **default_properties,
-                    }
-                )
+                entities.append({
+                    ENTITY_ATTRIBUTE_TYPE: entity_type,
+                    ENTITY_ATTRIBUTE_VALUE: entity_value,
+                    ENTITY_ATTRIBUTE_START: match.start(ENTITIES),
+                    ENTITY_ATTRIBUTE_END: match.end(ENTITIES),
+                    **default_properties,
+                })
         return entities
 
     @staticmethod

             `True` if the `stories` contain at least one active loop.
             `False` otherwise.
         """
-        return any(
-            [
-                [event for event in story_step.events if isinstance(event, ActiveLoop)]
-                for story_step in stories
-            ]
-        )
+        return any([
+            [event for event in story_step.events if isinstance(event, ActiveLoop)]
+            for story_step in stories
+        ])
 
     @staticmethod
     def process_user_utterance(

                                     )
                                 )
                                 if commented_entity:
-                                    entity_map = CommentedMap(
-                                        [(entity["entity"], entity["value"])]
-                                    )
+                                    entity_map = CommentedMap([
+                                        (entity["entity"], entity["value"])
+                                    ])
                                     entity_map.yaml_add_eol_comment(
                                         commented_entity, entity["entity"]
                                     )
                                     entities.append(entity_map)
                                 else:
                                     entities.append(
-                                        OrderedDict(
-                                            [(entity["entity"], entity["value"])]
-                                        )
+                                        OrderedDict([
+                                            (entity["entity"], entity["value"])
+                                        ])
                                     )
                     else:
                         entities.append(

         for checkpoint in checkpoints:
             if checkpoint.name == STORY_START:
                 continue
-            next_checkpoint: OrderedDict[Text, Any] = OrderedDict(
-                [(KEY_CHECKPOINT, checkpoint.name)]
-            )
+            next_checkpoint: OrderedDict[Text, Any] = OrderedDict([
+                (KEY_CHECKPOINT, checkpoint.name)
+            ])
             if checkpoint.conditions:
                 next_checkpoint[KEY_CHECKPOINT_SLOTS] = [
                     {key: value} for key, value in checkpoint.conditions.items()

         Returns:
             Dict with converted user utterances.
         """
-        return OrderedDict(
-            [
-                (
-                    KEY_OR,
-                    [
-                        self.process_user_utterance(utterance, self._is_test_story)
-                        for utterance in utterances
-                    ],
-                )
-            ]
-        )
+        return OrderedDict([
+            (
+                KEY_OR,
+                [
+                    self.process_user_utterance(utterance, self._is_test_story)
+                    for utterance in utterances
+                ],
+            )
+        ])
 
     @staticmethod
     def process_active_loop(event: ActiveLoop) -> OrderedDict:

             retrieval_intents
         )
 
-        return Domain.from_dict(
-            {
-                KEY_INTENTS: retrieval_intent_properties,
-                KEY_RESPONSES: responses,
-                KEY_ACTIONS: action_names,
-            }
-        )
+        return Domain.from_dict({
+            KEY_INTENTS: retrieval_intent_properties,
+            KEY_RESPONSES: responses,
+            KEY_ACTIONS: action_names,
+        })
 
     def get_stories(self, exclusion_percentage: Optional[int] = None) -> StoryGraph:
         """Retrieves training stories / rules (see parent class for full docstring)."""

 
         additional_e2e_action_names = set()
         for story_step in stories.story_steps:
-            additional_e2e_action_names.update(
-                {
-                    event.action_text
-                    for event in story_step.events
-                    if isinstance(event, ActionExecuted) and event.action_text
-                }
-            )
+            additional_e2e_action_names.update({
+                event.action_text
+                for event in story_step.events
+                if isinstance(event, ActionExecuted) and event.action_text
+            })
 
         return Domain.from_dict({KEY_E2E_ACTIONS: list(additional_e2e_action_names)})
 

         if use_short_syntax:
             return f"({entity_type})"
         else:
-            entity_dict = OrderedDict(
-                [
-                    (ENTITY_ATTRIBUTE_TYPE, entity_type),
-                    (ENTITY_ATTRIBUTE_ROLE, entity_role),
-                    (ENTITY_ATTRIBUTE_GROUP, entity_group),
-                    (ENTITY_ATTRIBUTE_VALUE, entity_value),
-                ]
-            )
-            entity_dict = OrderedDict(
-                [(k, v) for k, v in entity_dict.items() if v is not None]
-            )
+            entity_dict = OrderedDict([
+                (ENTITY_ATTRIBUTE_TYPE, entity_type),
+                (ENTITY_ATTRIBUTE_ROLE, entity_role),
+                (ENTITY_ATTRIBUTE_GROUP, entity_group),
+                (ENTITY_ATTRIBUTE_VALUE, entity_value),
+            ])
+            entity_dict = OrderedDict([
+                (k, v) for k, v in entity_dict.items() if v is not None
+            ])
 
             return f"{json.dumps(entity_dict)}"
 

             ]
             return (
                 f"[{entity_text}]["
-                + ", ".join(
-                    [
-                        TrainingDataWriter.generate_entity_attributes(
-                            text=entity_text, entity=e, short_allowed=False
-                        )
-                        for e in entity
-                    ]
-                )
+                + ", ".join([
+                    TrainingDataWriter.generate_entity_attributes(
+                        text=entity_text, entity=e, short_allowed=False
+                    )
+                    for e in entity
+                ])
                 + "]"
             )
         else:

 
             if features.number_of_dimensions == 4:
                 lengths = FeatureArray(
-                    ragged_array_to_ndarray(
-                        [
-                            # add one more dim so that dialogue dim
-                            # would be a sequence
-                            np.array([[[x.shape[0]]] for x in _features])
-                            for _features in features
-                        ]
-                    ),
+                    ragged_array_to_ndarray([
+                        # add one more dim so that dialogue dim
+                        # would be a sequence
+                        np.array([[[x.shape[0]]] for x in _features])
+                        for _features in features
+                    ]),
                     number_of_dimensions=4,
                 )
             else:

         The default features
     """
     example_features = next(
-        iter(
-            [
-                list_of_features
-                for list_of_list_of_features in all_features
-                for list_of_features in list_of_list_of_features
-                if list_of_features is not None
-            ]
-        )
+        iter([
+            list_of_features
+            for list_of_list_of_features in all_features
+            for list_of_features in list_of_list_of_features
+            if list_of_features is not None
+        ])
     )
 
     # create fake_features for Nones

     encoded_actions = f.encode_all_labels(domain, precomputations=precomputations)
 
     assert len(encoded_actions) == len(domain.action_names_or_texts)
-    assert all(
-        [
-            ACTION_NAME in encoded_action and ACTION_TEXT not in encoded_action
-            for encoded_action in encoded_actions
-        ]
-    )
+    assert all([
+        ACTION_NAME in encoded_action and ACTION_TEXT not in encoded_action
+        for encoded_action in encoded_actions
+    ])
 
 
 #

     # (only `encode_entities` does that).
     units = 300
     precomputations = MessageContainerForCoreFeaturization()
-    precomputations.add_all(
-        [
-            Message(
-                data={TEXT: text, TOKENS_NAMES[TEXT]: tokens},
-                features=[
-                    dummy_features(
-                        fill_value=11,
-                        units=units,
-                        attribute=TEXT,
-                        type=SENTENCE,
-                        is_sparse=True,
-                    ),
-                    dummy_features(
-                        fill_value=12,
-                        units=units,
-                        attribute=TEXT,
-                        type=SEQUENCE,
-                        is_sparse=False,
-                    ),
-                    # Note: sparse sequence feature is last here
-                    dummy_features(
-                        fill_value=13,
-                        units=units,
-                        attribute=TEXT,
-                        type=SEQUENCE,
-                        is_sparse=True,
-                    ),
-                ],
-            ),
-            Message(data={INTENT: intent}),
-            Message(
-                data={ACTION_TEXT: action_text},
-                features=[
-                    dummy_features(
-                        fill_value=1,
-                        units=units,
-                        attribute=ACTION_TEXT,
-                        type=SEQUENCE,
-                        is_sparse=True,
-                    )
-                ],
-            ),
-        ]
-    )
+    precomputations.add_all([
+        Message(
+            data={TEXT: text, TOKENS_NAMES[TEXT]: tokens},
+            features=[
+                dummy_features(
+                    fill_value=11,
+                    units=units,
+                    attribute=TEXT,
+                    type=SENTENCE,
+                    is_sparse=True,
+                ),
+                dummy_features(
+                    fill_value=12,
+                    units=units,
+                    attribute=TEXT,
+                    type=SEQUENCE,
+                    is_sparse=False,
+                ),
+                # Note: sparse sequence feature is last here
+                dummy_features(
+                    fill_value=13,
+                    units=units,
+                    attribute=TEXT,
+                    type=SEQUENCE,
+                    is_sparse=True,
+                ),
+            ],
+        ),
+        Message(data={INTENT: intent}),
+        Message(
+            data={ACTION_TEXT: action_text},
+            features=[
+                dummy_features(
+                    fill_value=1,
+                    units=units,
+                    attribute=ACTION_TEXT,
+                    type=SEQUENCE,
+                    is_sparse=True,
+                )
+            ],
+        ),
+    ])
     if action_name is not None:
         precomputations.add(Message(data={ACTION_NAME: action_name}))
 

 
         # check that ranking length is applied - without normalization
         if trained_policy.config[RANKING_LENGTH] == 0:
-            assert sum(
-                [confidence for confidence in prediction.probabilities]
-            ) == pytest.approx(1)
+            assert sum([
+                confidence for confidence in prediction.probabilities
+            ]) == pytest.approx(1)
             assert all(confidence > 0 for confidence in prediction.probabilities)
         else:
             assert (
                 sum([confidence > 0 for confidence in prediction.probabilities])
                 == trained_policy.config[RANKING_LENGTH]
             )
-            assert sum(
-                [confidence for confidence in prediction.probabilities]
-            ) != pytest.approx(1)
+            assert sum([
+                confidence for confidence in prediction.probabilities
+            ]) != pytest.approx(1)
 
     def test_label_data_assembly(
         self, trained_policy: TEDPolicy, default_domain: Domain

             and batch_action_name_mask.shape[0] == batch_size
         )
         # some features might be "fake" so there sequence is `0`
-        seq_len = max(
-            [
-                batch_intent_sentence_shape[1],
-                batch_action_name_sentence_shape[1],
-                batch_entities_sentence_shape[1],
-                batch_slots_sentence_shape[1],
-            ]
-        )
+        seq_len = max([
+            batch_intent_sentence_shape[1],
+            batch_action_name_sentence_shape[1],
+            batch_entities_sentence_shape[1],
+            batch_slots_sentence_shape[1],
+        ])
         assert (
             batch_intent_sentence_shape[1] == seq_len
             or batch_intent_sentence_shape[1] == 0

             and batch_dialogue_length.shape[0] == batch_size
         )
         # some features might be "fake" so there sequence is `0`
-        seq_len = max(
-            [
-                batch_intent_sentence_shape[1],
-                batch_action_name_sentence_shape[1],
-                batch_entities_sentence_shape[1],
-                batch_slots_sentence_shape[1],
-            ]
-        )
+        seq_len = max([
+            batch_intent_sentence_shape[1],
+            batch_action_name_sentence_shape[1],
+            batch_entities_sentence_shape[1],
+            batch_slots_sentence_shape[1],
+        ])
         assert (
             batch_intent_sentence_shape[1] == seq_len
             or batch_intent_sentence_shape[1] == 0

     def test_similarities_collection_for_label_ids(self):
         label_ids = np.array([[0, 1], [1, -1], [2, -1]])
         outputs = {
-            "similarities": np.array(
-                [[[1.2, 0.3, 0.2]], [[0.5, 0.2, 1.6]], [[0.01, 0.1, 1.7]]]
-            )
+            "similarities": np.array([
+                [[1.2, 0.3, 0.2]],
+                [[0.5, 0.2, 1.6]],
+                [[0.01, 0.1, 1.7]],
+            ])
         }
         label_id_similarities = UnexpecTEDIntentPolicy._collect_label_id_grouped_scores(
             outputs, label_ids

         # `-1` is used as padding label id. The embedding for it
         # will be the same as `label_id=0`
         expected_extracted_label_embeddings = tf.constant(
-            np.concatenate(
-                [
-                    all_label_embeddings[2],
-                    all_label_embeddings[0],
-                    all_label_embeddings[1],
-                    all_label_embeddings[2],
-                    all_label_embeddings[0],
-                    all_label_embeddings[0],
-                ]
-            ).reshape((3, 2, 20)),
+            np.concatenate([
+                all_label_embeddings[2],
+                all_label_embeddings[0],
+                all_label_embeddings[1],
+                all_label_embeddings[2],
+                all_label_embeddings[0],
+                all_label_embeddings[0],
+            ]).reshape((3, 2, 20)),
             dtype=tf.float32,
         )
 

         ],
     }
 
-    nlg = TemplatedNaturalLanguageGenerator(
-        {"utter_ask_cuisine": [{"text": "what dou want to eat?"}]}
-    )
+    nlg = TemplatedNaturalLanguageGenerator({
+        "utter_ask_cuisine": [{"text": "what dou want to eat?"}]
+    })
     with aioresponses() as mocked:
         mocked.post("https://example.com/webhooks/actions", payload=response)
 

     form_name = "test_form"
     entity_name = "some_slot"
 
-    domain = Domain.from_dict(
-        {
-            "intents": ["greet"],
-            "entities": ["some_slot"],
-            "slots": {entity_name: {"type": "text", "mappings": [slot_mapping]}},
-            "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
-        }
-    )
+    domain = Domain.from_dict({
+        "intents": ["greet"],
+        "entities": ["some_slot"],
+        "slots": {entity_name: {"type": "text", "mappings": [slot_mapping]}},
+        "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
+    })
 
     tracker = DialogueStateTracker.from_events(
         "default",

     form_name = "some_form"
     entity_name = "some_slot"
 
-    domain = Domain.from_dict(
-        {
-            "slots": {entity_name: {"type": "text", "mappings": [slot_mapping]}},
-            "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
-        }
-    )
+    domain = Domain.from_dict({
+        "slots": {entity_name: {"type": "text", "mappings": [slot_mapping]}},
+        "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
+    })
 
     tracker = DialogueStateTracker.from_events(
         "default",

         intent=mapping_intent,
         not_intent=mapping_not_intent,
     )
-    domain = Domain.from_dict(
-        {
-            "entities": ["some_entity"],
-            "slots": {"some_slot": {"type": "any", "mappings": [mapping]}},
-            "forms": {form_name: {REQUIRED_SLOTS_KEY: ["some_slot"]}},
-        }
-    )
+    domain = Domain.from_dict({
+        "entities": ["some_entity"],
+        "slots": {"some_slot": {"type": "any", "mappings": [mapping]}},
+        "forms": {form_name: {REQUIRED_SLOTS_KEY: ["some_slot"]}},
+    })
 
     tracker = DialogueStateTracker.from_events(
         "default",

     entity_name = "some_slot"
     slot_filled_by_trigger_mapping = "other_slot"
 
-    domain = Domain.from_dict(
-        {
-            "slots": {
-                entity_name: {
-                    "type": "text",
-                    "mappings": [
-                        {
-                            "type": "from_entity",
-                            "entity": entity_name,
-                            "intent": "some_intent",
-                        }
-                    ],
-                },
-                slot_filled_by_trigger_mapping: {
-                    "type": "text",
-                    "mappings": [trigger_slot_mapping],
-                },
+    domain = Domain.from_dict({
+        "slots": {
+            entity_name: {
+                "type": "text",
+                "mappings": [
+                    {
+                        "type": "from_entity",
+                        "entity": entity_name,
+                        "intent": "some_intent",
+                    }
+                ],
             },
-            "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
-        }
-    )
+            slot_filled_by_trigger_mapping: {
+                "type": "text",
+                "mappings": [trigger_slot_mapping],
+            },
+        },
+        "forms": {form_name: {REQUIRED_SLOTS_KEY: [entity_name]}},
+    })
 
     tracker = DialogueStateTracker.from_events(
         "default",