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

rasa/dialogue_understanding/processor/command_processor.py

@@ -16,6 +16,7 @@ from rasa.dialogue_understanding.commands import (
 from rasa.dialogue_understanding.commands.handle_code_change_command import (
     HandleCodeChangeCommand,
 )
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
@@ -36,16 +37,23 @@ from rasa.shared.constants import (
     ROUTE_TO_CALM_SLOT,
     RASA_PATTERN_CANNOT_HANDLE_CHITCHAT,
 )
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT, SlotMappingType
 from rasa.shared.core.constants import FLOW_HASHES_SLOT
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS
 
 structlogger = structlog.get_logger()
 
+CANNOT_HANDLE_REASON = (
+    "A command generator attempted to set a slot "
+    "with a value extracted by an extractor "
+    "that is incompatible with the slot mapping type."
+)
+
 
 def contains_command(commands: List[Command], typ: Type[Command]) -> bool:
     """Check if a list of commands contains a command of a given type.
@@ -118,7 +126,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     ]
     if free_form_answer_commands != commands[: len(free_form_answer_commands)]:
         structlogger.error(
-            "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",  # noqa: E501
+            "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",
             commands=commands,
         )
         raise ValueError(
@@ -341,7 +349,6 @@ def clean_up_commands(
     clean_commands: List[Command] = []
 
     for command in commands:
-
         if isinstance(command, SetSlotCommand):
             clean_commands = clean_up_slot_command(
                 clean_commands, command, tracker, all_flows, slots_so_far
@@ -355,6 +362,19 @@ def clean_up_commands(
                 ".skip_command_flow_already_cancelled",
                 command=command,
             )
+
+        # if there is a cannot handle command after the previous step,
+        # we don't want to add another one
+        elif isinstance(command, CannotHandleCommand) and contains_command(
+            clean_commands, CannotHandleCommand
+        ):
+            structlogger.debug(
+                "command_processor"
+                ".clean_up_commands"
+                ".skip_command_already_has_cannot_handle",
+                command=command,
+            )
+
         elif isinstance(command, StartFlowCommand) and command.flow == active_flow:
             # drop a start flow command if the starting flow is equal to the currently
             # active flow
@@ -388,6 +408,13 @@ def clean_up_commands(
         else:
             clean_commands.append(command)
 
+    # when coexistence is enabled, by default there will be a SetSlotCommand
+    # for the ROUTE_TO_CALM_SLOT slot.
+    if tracker.has_coexistence_routing_slot and len(clean_commands) > 2:
+        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
+    elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
+        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
+
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -460,6 +487,22 @@ def clean_up_slot_command(
     stack = tracker.stack
 
     resulting_commands = commands_so_far[:]
+
+    slot = tracker.slots.get(command.name)
+    if slot is None:
+        structlogger.debug(
+            "command_processor.clean_up_slot_command.skip_command_slot_not_in_domain",
+            command=command,
+        )
+        return resulting_commands
+
+    if not should_slot_be_set(slot, command):
+        cannot_handle = CannotHandleCommand(reason=CANNOT_HANDLE_REASON)
+        if cannot_handle not in resulting_commands:
+            resulting_commands.append(cannot_handle)
+
+        return resulting_commands
+
     if command.name in slots_so_far and command.name != ROUTE_TO_CALM_SLOT:
         current_collect_info = get_current_collect_step(stack, all_flows)
 
@@ -576,3 +619,69 @@ def clean_up_chitchat_command(
         )
 
     return resulting_commands
+
+
+def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
+    """Check if a slot should be set by a command."""
+    if command.extractor == SetSlotExtractor.COMMAND_PAYLOAD_READER.value:
+        # if the command is issued by the command payload reader, it means the slot
+        # was set deterministically via a response button. In this case,
+        # we can always set it
+        return True
+
+    slot_mappings = slot.mappings
+
+    if not slot_mappings:
+        slot_mappings = [{"type": SlotMappingType.FROM_LLM.value}]
+
+    for mapping in slot_mappings:
+        mapping_type = SlotMappingType(
+            mapping.get("type", SlotMappingType.FROM_LLM.value)
+        )
+
+        should_be_set_by_llm = (
+            command.extractor == SetSlotExtractor.LLM.value
+            and mapping_type == SlotMappingType.FROM_LLM
+        )
+        should_be_set_by_nlu = (
+            command.extractor == SetSlotExtractor.NLU.value
+            and mapping_type.is_predefined_type()
+        )
+
+        if should_be_set_by_llm or should_be_set_by_nlu:
+            # if the extractor matches the mapping type, we can continue
+            # setting the slot
+            break
+
+        structlogger.debug(
+            "command_processor.clean_up_slot_command.skip_command.extractor_"
+            "does_not_match_slot_mapping",
+            extractor=command.extractor,
+            slot_name=slot.name,
+            mapping_type=mapping_type.value,
+        )
+        return False
+
+    return True
+
+
+def filter_cannot_handle_command_for_skipped_slots(
+    clean_commands: List[Command],
+) -> List[Command]:
+    """Filter out a 'cannot handle' command for skipped slots.
+
+    This is used to filter out a 'cannot handle' command for skipped slots
+    in case other commands are present.
+
+    Returns:
+        The filtered commands.
+    """
+    return [
+        command
+        for command in clean_commands
+        if not (
+            isinstance(command, CannotHandleCommand)
+            and command.reason
+            and CANNOT_HANDLE_REASON == command.reason
+        )
+    ]

rasa/e2e_test/constants.py

@@ -8,3 +8,4 @@ KEY_SLOT_SET = "slot_was_set"
 KEY_SLOT_NOT_SET = "slot_was_not_set"
 KEY_STEPS = "steps"
 KEY_TEST_CASE = "test_case"
+KEY_METADATA = "metadata"

rasa/e2e_test/e2e_test_case.py

@@ -8,6 +8,7 @@ from rasa.e2e_test.constants import (
     KEY_BOT_INPUT,
     KEY_BOT_UTTERED,
     KEY_FIXTURES,
+    KEY_METADATA,
     KEY_SLOT_NOT_SET,
     KEY_SLOT_SET,
     KEY_STEPS,
@@ -63,6 +64,7 @@ class TestStep:
     slot_was_not_set: bool = False
     _slot_instance: Optional[Union[Text, Dict[Text, Any]]] = None
     _underlying: Optional[Dict[Text, Any]] = None
+    metadata_name: Optional[Text] = None
 
     @staticmethod
     def from_dict(test_step_dict: Dict[Text, Any]) -> "TestStep":
@@ -71,6 +73,8 @@ class TestStep:
         Example:
             >>> TestStep.from_dict({"user": "hello"})
             TestStep(text="hello", actor="user")
+            >>> TestStep.from_dict({"user": "hello", metadata: "some_metadata"})
+            TestStep(text="hello", actor="user", metadata_name="some_metadata")
             >>> TestStep.from_dict({"bot": "hello world"})
             TestStep(text="hello world", actor="bot")
 
@@ -94,6 +98,7 @@ class TestStep:
             slot_was_not_set=bool(test_step_dict.get(KEY_SLOT_NOT_SET)),
             _slot_instance=slot_instance,
             _underlying=test_step_dict,
+            metadata_name=test_step_dict.get(KEY_METADATA, ""),
         )
 
     @staticmethod
@@ -269,6 +274,7 @@ class TestCase:
     file: Optional[Text] = None
     line: Optional[int] = None
     fixture_names: Optional[List[Text]] = None
+    metadata_name: Optional[Text] = None
 
     @staticmethod
     def from_dict(
@@ -311,6 +317,7 @@ class TestCase:
             if hasattr(input_test_case, "lc")
             else None,
             fixture_names=input_test_case.get(KEY_FIXTURES),
+            metadata_name=input_test_case.get(KEY_METADATA),
         )
 
     def file_with_line(self) -> Text:
@@ -320,3 +327,40 @@ class TestCase:
 
         line = str(self.line) if self.line is not None else ""
         return f"{self.file}:{line}"
+
+
+@dataclass(frozen=True)
+class Metadata:
+    """Class for storing an input metadata."""
+
+    name: Text
+    metadata: Dict[Text, Any]
+
+    @staticmethod
+    def from_dict(metadata_dict: Dict[Text, Any]) -> "Metadata":
+        """Creates a metadata from a dictionary.
+
+        Example:
+            >>> Metadata.from_dict({"some_metadata": {"room": "test_room"}})
+            Metadata(name="some_metadata", metadata={"room": "test_room"})
+
+        Args:
+            metadata_dict: Dictionary containing the metadata.
+        """
+        return Metadata(
+            name=next(iter(metadata_dict.keys())),
+            metadata={
+                metadata_name: metadata_value
+                for metadata in metadata_dict.values()
+                for metadata_name, metadata_value in metadata.items()
+            },
+        )
+
+
+@dataclass(frozen=True)
+class TestSuite:
+    """Class for representing all top level test suite keys."""
+
+    test_cases: List[TestCase]
+    fixtures: List[Fixture]
+    metadata: List[Metadata]

rasa/e2e_test/e2e_test_runner.py

@@ -1,9 +1,10 @@
 import asyncio
+import copy
 import datetime
 import difflib
 import logging
 from asyncio import CancelledError
-from typing import Dict, List, Optional, Text, Tuple, Union
+from typing import Any, Dict, List, Optional, Text, Tuple, Union
 from urllib.parse import urlparse
 
 import rasa.shared.utils.io
@@ -19,6 +20,7 @@ from rasa.utils.endpoints import EndpointConfig
 from rasa.e2e_test.e2e_test_case import (
     ActualStepOutput,
     Fixture,
+    Metadata,
     TestCase,
     TestStep,
 )
@@ -85,6 +87,8 @@ class E2ETestRunner:
         collector: CollectingOutputChannel,
         steps: List[TestStep],
         sender_id: Text,
+        test_case_metadata: Optional[Metadata] = None,
+        input_metadata: Optional[List[Metadata]] = None,
     ) -> TEST_TURNS_TYPE:
         """Runs dialogue prediction.
 
@@ -94,12 +98,12 @@ class E2ETestRunner:
             sender_id: The test case name with added timestamp suffix.
 
         Returns:
-        Test turns: {turn_sequence (int) : TestStep or ActualStepOutput}.
+            Test turns: {turn_sequence (int) : TestStep or ActualStepOutput}.
         """
         turns: TEST_TURNS_TYPE = {}
         event_cursor = 0
 
-        tracker = await self.agent.processor.fetch_tracker_with_initial_session(  # type: ignore[union-attr]  # noqa: E501
+        tracker = await self.agent.processor.fetch_tracker_with_initial_session(  # type: ignore[union-attr]
             sender_id
         )
         # turn -1 i used to contain events that happen during
@@ -123,12 +127,24 @@ class E2ETestRunner:
                 )
                 continue
 
+            metadata = test_case_metadata.metadata if test_case_metadata else {}
+
+            if input_metadata:
+                step_metadata = self.filter_metadata_for_input(
+                    step.metadata_name, input_metadata
+                )
+                step_metadata_dict = step_metadata.metadata if step_metadata else {}
+                metadata = self.merge_metadata(
+                    sender_id, step.text, metadata, step_metadata_dict
+                )
+
             try:
                 await self.agent.handle_message(
                     UserMessage(
                         step.text,
                         collector,
                         sender_id,
+                        metadata=metadata,
                     )
                 )
             except CancelledError:
@@ -147,6 +163,49 @@ class E2ETestRunner:
             )
         return turns
 
+    @staticmethod
+    def merge_metadata(
+        sender_id: Text,
+        step_text: Text,
+        test_case_metadata: Dict[Text, Text],
+        step_metadata: Dict[Text, Text],
+    ) -> Dict[Text, Text]:
+        """Merges the test case and user step metadata.
+
+        Args:
+            sender_id: The test case name with added timestamp suffix.
+            step_text: The user step text.
+            test_case_metadata: The test case metadata dict.
+            step_metadata: The user step metadata dict.
+
+        Returns:
+            A dictionary with the merged metadata.
+        """
+        if not test_case_metadata:
+            return step_metadata
+        if not step_metadata:
+            return test_case_metadata
+
+        keys_to_overwrite = []
+
+        for key in step_metadata.keys():
+            if key in test_case_metadata.keys():
+                keys_to_overwrite.append(key)
+
+        if keys_to_overwrite:
+            test_case_name = sender_id.rsplit("_", 1)[0]
+            logger.warning(
+                f"Metadata {keys_to_overwrite} exist in both the test case "
+                f"'{test_case_name}' and the user step '{step_text}'. "
+                "The user step metadata takes precedence and will "
+                "override the test case metadata."
+            )
+
+        merged_metadata = copy.deepcopy(test_case_metadata)
+        merged_metadata.update(step_metadata)
+
+        return merged_metadata
+
     @staticmethod
     def get_actual_step_output(
         tracker: DialogueStateTracker,
@@ -310,10 +369,10 @@ class E2ETestRunner:
         if failed_step.text is not None:
             diff_test_text = f"{failed_step.actor}: {failed_step.text}"
             diff_actual_text = NO_RESPONSE
-            event: Optional[
-                Union[BotUttered, SlotSet]
-            ] = cls._find_first_non_matched_utterance(
-                test_response, bot_utter_test_steps
+            event: Optional[Union[BotUttered, SlotSet]] = (
+                cls._find_first_non_matched_utterance(
+                    test_response, bot_utter_test_steps
+                )
             )
             if event and isinstance(event, BotUttered):
                 test_response.remove_bot_uttered_event(event)
@@ -533,7 +592,7 @@ class E2ETestRunner:
         """
         if not fixtures:
             return
-        tracker = await self.agent.processor.fetch_tracker_with_initial_session(  # type: ignore[union-attr]  # noqa: E501
+        tracker = await self.agent.processor.fetch_tracker_with_initial_session(  # type: ignore[union-attr]
             sender_id
         )
 
@@ -564,11 +623,43 @@ class E2ETestRunner:
             )
         )
 
+    @staticmethod
+    def filter_metadata_for_input(
+        metadata_name: Optional[Text], test_suite_metadata: List[Metadata]
+    ) -> Optional[Metadata]:
+        """Filters the test suite metadata for a metadata name.
+
+        Args:
+            metadata_name: The test case or user step metadata name.
+            test_suite_metadata: The top level list of all metadata definitions.
+
+        Returns:
+            The filtered metadata.
+        """
+        if not metadata_name:
+            return None
+
+        filtered_metadata = list(
+            filter(
+                lambda metadata: metadata_name and metadata.name == metadata_name,
+                test_suite_metadata,
+            )
+        )
+
+        if not filtered_metadata:
+            logger.warning(
+                f"Metadata '{metadata_name}' is not defined in the input metadata."
+            )
+            return None
+
+        return filtered_metadata[0]
+
     async def run_tests(
         self,
         input_test_cases: List[TestCase],
         input_fixtures: List[Fixture],
         fail_fast: bool = False,
+        **kwargs: Any,
     ) -> List["TestResult"]:
         """Runs the test cases.
 
@@ -576,14 +667,16 @@ class E2ETestRunner:
             input_test_cases: Input test cases.
             input_fixtures: Input fixtures.
             fail_fast: Whether to fail fast.
+            **kwargs: Additional arguments which are passed here.
 
         Returns:
-        List of test results.
+            List of test results.
         """
         results = []
+        input_metadata = kwargs.get("input_metadata", None)
 
         # telemetry call for tracking test runs
-        track_e2e_test_run(input_test_cases, input_fixtures)
+        track_e2e_test_run(input_test_cases, input_fixtures, input_metadata)
 
         for test_case in input_test_cases:
             collector = CollectingOutputChannel()
@@ -597,8 +690,18 @@ class E2ETestRunner:
                 )
                 await self.set_up_fixtures(test_fixtures, sender_id)
 
+            test_case_metadata = None
+            if input_metadata:
+                test_case_metadata = self.filter_metadata_for_input(
+                    test_case.metadata_name, input_metadata
+                )
+
             tracker = await self.run_prediction_loop(
-                collector, test_case.steps, sender_id
+                collector,
+                test_case.steps,
+                sender_id,
+                test_case_metadata,
+                input_metadata,
             )
 
             test_result = self.generate_test_result(tracker, test_case)

rasa/e2e_test/e2e_test_schema.yml

@@ -13,6 +13,18 @@ mapping:
                   regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
                     type: any
 
+  metadata:
+    allowempty: True
+    type: "seq"
+    sequence:
+      - type: map
+        mapping:
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+            type: map
+            mapping:
+              regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                type: any
+
   test_cases:
     type: "seq"
     sequence:
@@ -27,6 +39,9 @@ mapping:
             sequence:
               - type: "str"
                 pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+          metadata:
+            type: "str"
+            pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
           steps:
             type: "seq"
             matching: "any"
@@ -34,7 +49,10 @@ mapping:
               - type: map
                 mapping:
                   user:
+                    type: str
+                  metadata:
                     type: "str"
+                    pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
               - type: map
                 mapping:
                   utter:

rasa/engine/caching.py

@@ -305,7 +305,6 @@ class LocalTrainingCache(TrainingCache):
         with rasa.utils.common.TempDirectoryPath(tempdir_name) as temp_dir:
             tmp_path = Path(temp_dir)
             try:
-
                 output.to_cache(tmp_path, model_storage)
 
                 logger.debug(

rasa/engine/graph.py

@@ -108,10 +108,10 @@ class GraphSchema:
         nodes = {}
         for node_name, serialized_node in serialized_graph_schema["nodes"].items():
             try:
-                serialized_node[
-                    "uses"
-                ] = rasa.shared.utils.common.class_from_module_path(
-                    serialized_node["uses"]
+                serialized_node["uses"] = (
+                    rasa.shared.utils.common.class_from_module_path(
+                        serialized_node["uses"]
+                    )
                 )
 
                 resource = serialized_node["resource"]
@@ -172,6 +172,18 @@ class GraphSchema:
                 return True
         return False
 
+    def count_nodes_of_a_given_type(
+        self, node_type: Type, include_subtypes: bool = True
+    ) -> int:
+        """Counts the number of the nodes of specified class"""
+        counter = 0
+        for node in self.nodes.values():
+            if (node.uses is node_type) or (
+                include_subtypes and issubclass(node.uses, node_type)
+            ):
+                counter += 1
+        return counter
+
 
 class GraphComponent(ABC):
     """Interface for any component which will run in a graph."""
@@ -206,7 +218,7 @@ class GraphComponent(ABC):
 
     @classmethod
     def load(
-        cls,
+        cls: Any,
         config: Dict[Text, Any],
         model_storage: ModelStorage,
         resource: Resource,
@@ -267,7 +279,7 @@ class GraphComponent(ABC):
         return []
 
     @classmethod
-    def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
+    def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Adds additional data to the fingerprint calculation.
 
         This is useful if a component uses external data that is not provided

rasa/engine/recipes/config_files/default_config.yml

@@ -1,5 +1,5 @@
 # The config recipe.
-# https://rasa.com/docs/rasa/model-configuration/
+# https://rasa.com/docs/rasa-pro/nlu-based-assistants/model-configuration/
 recipe: default.v1
 
 # The assistant project unique identifier
@@ -7,7 +7,7 @@ recipe: default.v1
 assistant_id: placeholder_default
 
 # Configuration for the Rasa NLU components.
-# https://rasa.com/docs/rasa/components
+# https://rasa.com/docs/rasa-pro/nlu-based-assistants/components
 language: en
 
 pipeline:
@@ -31,7 +31,7 @@ pipeline:
     ambiguity_threshold: 0.1
 
 # Configuration for the Rasa Core policies.
-# https://rasa.com/docs/rasa/policies
+# https://rasa.com/docs/rasa-pro/concepts/policies/policy-overview/
 policies:
   - name: MemoizationPolicy
   - name: RulePolicy

rasa/engine/recipes/default_components.py

@@ -9,7 +9,7 @@ from rasa.dialogue_understanding.generator.nlu_command_adapter import NLUCommand
 from rasa.nlu.classifiers.diet_classifier import DIETClassifier
 from rasa.nlu.classifiers.fallback_classifier import FallbackClassifier
 from rasa.nlu.classifiers.keyword_intent_classifier import KeywordIntentClassifier
-from rasa.dialogue_understanding.generator.llm_command_generator import (
+from rasa.dialogue_understanding.generator import (
     LLMCommandGenerator,
 )
 from rasa.nlu.classifiers.llm_intent_classifier import LLMIntentClassifier

rasa/engine/recipes/default_recipe.py

@@ -157,10 +157,10 @@ class DefaultV1Recipe(Recipe):
             else:
                 unique_types = set(component_types)
 
-            cls._registered_components[
-                registered_class.__name__
-            ] = cls.RegisteredComponent(
-                registered_class, unique_types, is_trainable, model_from
+            cls._registered_components[registered_class.__name__] = (
+                cls.RegisteredComponent(
+                    registered_class, unique_types, is_trainable, model_from
+                )
             )
             return registered_class
 
@@ -699,7 +699,6 @@ class DefaultV1Recipe(Recipe):
         preprocessors: List[Text],
         train_nodes: Dict[Text, SchemaNode],
     ) -> Dict[Text, SchemaNode]:
-
         predict_config = copy.deepcopy(config)
         predict_nodes = {}
 

rasa/engine/recipes/recipe.py

@@ -33,7 +33,7 @@ class Recipe(abc.ABC):
 
         if name is None:
             rasa.shared.utils.io.raise_deprecation_warning(
-                "From Rasa Open Source 4.0.0 onwards it will be required to specify "
+                "From Rasa Pro 4.0.0 onwards it will be required to specify "
                 "a recipe in your model configuration. Defaulting to recipe "
                 f"'{DefaultV1Recipe.name}'."
             )

rasa/engine/runner/dask.py

@@ -222,9 +222,7 @@ async def execute_dask_graph(dsk: Dict[str, Any], result: List[str]) -> Any:
     state = {}
     keyorder = dask.local.order(dsk)  # type:ignore[no-untyped-call]
 
-    state = dask.local.start_state_from_dask(
-        dsk, cache=cache, sortkey=keyorder.get
-    )  # type:ignore[no-untyped-call]
+    state = dask.local.start_state_from_dask(dsk, cache=cache, sortkey=keyorder.get)  # type:ignore[no-untyped-call]
 
     if state["waiting"] and not state["ready"]:
         raise ValueError("Found no accessible jobs in dask")
@@ -237,17 +235,13 @@ async def execute_dask_graph(dsk: Dict[str, Any], result: List[str]) -> Any:
         # Notify task is running
         state["running"].add(key)
 
-        dependencies = dask.local.get_dependencies(
-            dsk, key
-        )  # type:ignore[no-untyped-call]
+        dependencies = dask.local.get_dependencies(dsk, key)  # type:ignore[no-untyped-call]
         # Prep args to send
         data = {dep: state["cache"][dep] for dep in dependencies}
 
         task_result = await _execute_task(dsk[key], data)
         state["cache"][key] = task_result
-        dask.local.finish_task(
-            dsk, key, state, results, keyorder.get
-        )  # type:ignore[no-untyped-call]
+        dask.local.finish_task(dsk, key, state, results, keyorder.get)  # type:ignore[no-untyped-call]
 
     # Main loop, wait on tasks to finish, insert new ones
     while state["ready"]: