opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/protocol_engine/commands/create_timer.py

@@ -0,0 +1,83 @@
+"""CreateTimer command request, result, and implementation models."""
+
+from __future__ import annotations
+from pydantic import BaseModel, Field
+from typing import Optional, Type, TYPE_CHECKING
+from typing_extensions import Literal
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ..execution import TaskHandler, RunControlHandler
+
+
+CreateTimerCommandType = Literal["createTimer"]
+
+
+class CreateTimerParams(BaseModel):
+    """Payload required to annotate execution with a CreateTimer."""
+
+    time: float = Field(
+        ...,
+        description="The time before the timer should elapse in seconds. This is the minimum time before the timer elapses; it may in practice take longer than this.",
+    )
+    task_id: str | None = Field(
+        None,
+        description="The id of the timer task",
+    )
+
+
+class CreateTimerResult(BaseModel):
+    """Result data from the execution of a CreateTimer command."""
+
+    task_id: str = Field(..., description="The id of the timer task")
+    time: float = Field(..., description="The same time as the parameter.")
+
+
+class CreateTimerImplementation(
+    AbstractCommandImpl[CreateTimerParams, SuccessData[CreateTimerResult]]
+):
+    """CreateTimer command implementation."""
+
+    def __init__(
+        self,
+        task_handler: TaskHandler,
+        run_control: RunControlHandler,
+        **kwargs: object,
+    ) -> None:
+        self._task_handler = task_handler
+        self._run_control = run_control
+
+    async def execute(
+        self, params: CreateTimerParams
+    ) -> SuccessData[CreateTimerResult]:
+        """No operation taken other than capturing message in command."""
+
+        async def timer(task_handler: TaskHandler) -> None:
+            async with task_handler.synchronize_concurrent("createTimer"):
+                await self._run_control.wait_for_duration(params.time)
+
+        task = await self._task_handler.create_task(timer, params.task_id)
+        return SuccessData(
+            public=CreateTimerResult(task_id=task.id, time=params.time),
+        )
+
+
+class CreateTimer(BaseCommand[CreateTimerParams, CreateTimerResult, ErrorOccurrence]):
+    """CreateTimer command model."""
+
+    commandType: CreateTimerCommandType = "createTimer"
+    params: CreateTimerParams
+    result: Optional[CreateTimerResult] = None
+
+    _ImplementationCls: Type[CreateTimerImplementation] = CreateTimerImplementation
+
+
+class CreateTimerCreate(BaseCommandCreate[CreateTimerParams]):
+    """CreateTimer command request model."""
+
+    commandType: CreateTimerCommandType = "createTimer"
+    params: CreateTimerParams
+
+    _CommandCls: Type[CreateTimer] = CreateTimer

opentrons/protocol_engine/commands/dispense.py

@@ -101,6 +101,7 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
             well_name=well_name,
             well_location=well_location,
             operation_volume=volume,
+            offset_pipette_for_reservoir_subwells=False,
         )
         if isinstance(move_result, DefinedErrorData):
             return move_result

opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -19,7 +19,7 @@ from .pipetting_common import (
     dispense_while_tracking,
 )
 from .movement_common import (
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
     DestinationPositionResult,
     StallOrCollisionError,
     move_to_well,
@@ -49,7 +49,7 @@ class DispenseWhileTrackingParams(
     PipetteIdMixin,
     DispenseVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
+    DynamicLiquidHandlingWellLocationMixin,
 ):
     """Payload required to dispense to a specific well."""
 
@@ -100,14 +100,24 @@ class DispenseWhileTrackingImplementation(
         # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
 
         state_update = StateUpdate()
+
+        end_point = self._state_view.geometry.get_well_position(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            well_location=params.trackToLocation,
+            operation_volume=params.volume,
+            pipette_id=params.pipetteId,
+        )
+
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
-            well_location=params.wellLocation,
+            well_location=params.trackFromLocation,
         )
+
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):
             return DefinedErrorData(
@@ -120,6 +130,7 @@ class DispenseWhileTrackingImplementation(
             well_name=well_name,
             volume=params.volume,
             flow_rate=params.flowRate,
+            end_point=end_point,
             push_out=params.pushOut,
             location_if_error={
                 "retryLocation": (
@@ -130,7 +141,49 @@ class DispenseWhileTrackingImplementation(
             },
             pipetting=self._pipetting,
             model_utils=self._model_utils,
+            movement_delay=params.movement_delay,
         )
+
+        if isinstance(dispense_result, DefinedErrorData):
+            if isinstance(dispense_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=dispense_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+            elif isinstance(dispense_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=dispense_result.state_update.set_liquid_operated(
+                        labware_id=params.labwareId,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            params.labwareId,
+                            params.wellName,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
+                    ),
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+
         position_after_dispense = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -139,22 +192,6 @@ class DispenseWhileTrackingImplementation(
             y=position_after_dispense.y,
             z=position_after_dispense.z,
         )
-
-        if isinstance(dispense_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=dispense_result.public,
-                state_update=dispense_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=dispense_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=DispenseWhileTrackingResult(
                 volume=dispense_result.public.volume,

opentrons/protocol_engine/commands/drop_tip.py

@@ -12,7 +12,7 @@ from opentrons.protocol_engine.errors.exceptions import TipAttachedError
 from opentrons.protocol_engine.resources.model_utils import ModelUtils
 
 from ..state.update_types import StateUpdate
-from ..types import DropTipWellLocation
+from ..types import DropTipWellLocation, TipRackWellState
 from .pipetting_common import (
     PipetteIdMixin,
     TipPhysicallyAttachedError,
@@ -140,6 +140,25 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             partially_configured=is_partially_configured,
         )
 
+        is_tip_rack = self._state_view.labware.get_definition(
+            labware_id
+        ).parameters.isTiprack
+
+        # It's possible that we are dropping tips into a labware trash for pre API v2.14 OT-2 protocols
+        # (or something else unexpected), so if it is not a tip rack mark no wells as used
+        if is_tip_rack:
+            tips_to_mark_as_used = (
+                self._state_view.tips.compute_tips_to_mark_as_used_or_empty(
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    nozzle_map=self._state_view.pipettes.get_nozzle_configuration(
+                        pipette_id
+                    ),
+                )
+            )
+        else:
+            tips_to_mark_as_used = []
+
         move_result = await move_to_well(
             movement=self._movement_handler,
             model_utils=self._model_utils,
@@ -152,12 +171,7 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             return move_result
 
         scrape_type = TipScrapeType.NONE
-        if (
-            params.scrape_tips
-            and self._state_view.geometry._labware.get_definition(
-                labware_id
-            ).parameters.isTiprack
-        ):
+        if params.scrape_tips and is_tip_rack:
             if int("".join(filter(str.isdigit, well_name))) <= 6:
                 scrape_type = TipScrapeType.RIGHT_ONE_COL
             else:
@@ -194,6 +208,10 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                     pipette_id=params.pipetteId,
                     tip_geometry=None,
                     tip_source=None,
+                ).update_tip_rack_well_state(
+                    tip_state=TipRackWellState.USED,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_used,
                 ),
             )
         else:
@@ -201,10 +219,16 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                 public=DropTipResult(position=move_result.public.position),
                 state_update=move_result.state_update.set_fluid_unknown(
                     pipette_id=pipette_id
-                ).update_pipette_tip_state(
+                )
+                .update_pipette_tip_state(
                     pipette_id=params.pipetteId,
                     tip_geometry=None,
                     tip_source=None,
+                )
+                .update_tip_rack_well_state(
+                    tip_state=TipRackWellState.USED,
+                    labware_id=labware_id,
+                    well_names=tips_to_mark_as_used,
                 ),
             )
 

opentrons/protocol_engine/commands/flex_stacker/common.py

@@ -10,6 +10,10 @@ from opentrons_shared_data.errors import ErrorCodes
 from opentrons_shared_data.errors.exceptions import CommandPreconditionViolated
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
+from opentrons.protocol_engine.errors.exceptions import (
+    LabwarePoolNotCompatibleWithModuleError,
+)
+
 
 from ...errors import ErrorOccurrence
 from ...types import (
@@ -35,6 +39,15 @@ if TYPE_CHECKING:
     from opentrons.protocol_engine.execution.equipment import LoadedLabwarePoolData
     from opentrons.protocol_engine.state.module_substates import FlexStackerSubState
 
+
+# The stacker cannot dispense labware where there is no gap between the top surface
+# of the bottom labware being dispensed, and bottom surface of the top labware.
+# This is because the stacker latch, which holds the labware stack, needs enough
+# empty space to free the bottom labware, but still hold the top labware once it
+# closes.
+STACKER_INCOMPATIBLE_LABWARE = set(["opentrons_tough_universal_lid"])
+
+
 INITIAL_COUNT_DESCRIPTION = dedent(
     """\
         The number of labware that should be initially stored in the stacker. This number will be silently clamped to
@@ -911,3 +924,25 @@ def build_retrieve_labware_move_updates(
             lid_offset_location,
         )
     return locations_for_ids, offset_ids_by_id
+
+
+def validate_labware_pool_compatible_with_stacker(
+    pool_primary_definition: LabwareDefinition,
+    pool_adapter_definition: LabwareDefinition | None,
+    pool_lid_definition: LabwareDefinition | None,
+) -> None:
+    """Verifies that the given labware pool is compatible with the stacker."""
+    labware_pool = set(
+        lw.parameters.loadName
+        for lw in [
+            pool_primary_definition,
+            pool_adapter_definition,
+            pool_lid_definition,
+        ]
+        if lw is not None
+    )
+    incompatible_labware = list(labware_pool & STACKER_INCOMPATIBLE_LABWARE)
+    if incompatible_labware:
+        raise LabwarePoolNotCompatibleWithModuleError(
+            f"The stacker cannot store {incompatible_labware}"
+        )

opentrons/protocol_engine/commands/flex_stacker/set_stored_labware.py

@@ -31,6 +31,7 @@ from .common import (
     primary_location_sequences,
     adapter_location_sequences_with_default,
     lid_location_sequences_with_default,
+    validate_labware_pool_compatible_with_stacker,
 )
 
 if TYPE_CHECKING:
@@ -210,6 +211,12 @@ class SetStoredLabwareImpl(
             )
         )
 
+        validate_labware_pool_compatible_with_stacker(
+            pool_primary_definition=labware_def,
+            pool_adapter_definition=adapter_def,
+            pool_lid_definition=lid_def,
+        )
+
         pool_height = self._state_view.geometry.get_height_of_labware_stack(
             pool_definitions
         )

opentrons/protocol_engine/commands/heater_shaker/__init__.py

@@ -32,6 +32,14 @@ from .set_and_wait_for_shake_speed import (
     SetAndWaitForShakeSpeedCommandType,
 )
 
+from .set_shake_speed import (
+    SetShakeSpeed,
+    SetShakeSpeedCreate,
+    SetShakeSpeedParams,
+    SetShakeSpeedResult,
+    SetShakeSpeedCommandType,
+)
+
 from .deactivate_shaker import (
     DeactivateShaker,
     DeactivateShakerCreate,
@@ -81,6 +89,12 @@ __all__ = [
     "SetAndWaitForShakeSpeedParams",
     "SetAndWaitForShakeSpeedResult",
     "SetAndWaitForShakeSpeedCommandType",
+    # heaterShaker/setShakeSpeed
+    "SetShakeSpeed",
+    "SetShakeSpeedCreate",
+    "SetShakeSpeedParams",
+    "SetShakeSpeedResult",
+    "SetShakeSpeedCommandType",
     # heaterShaker/deactivateShaker
     "DeactivateShaker",
     "DeactivateShakerCreate",

opentrons/protocol_engine/commands/heater_shaker/common.py

@@ -0,0 +1,20 @@
+"""Common heatershaker base models."""
+from opentrons.protocol_engine.state.module_substates.heater_shaker_module_substate import (
+    HeaterShakerModuleSubState,
+)
+
+
+async def get_heatershaker_ready_to_shake(
+    hs_module_substate: HeaterShakerModuleSubState,
+    rpm: float,
+) -> int:
+    """Check heatershaker state to confirm if it is ready to shake.
+
+    This includes
+    - Checking latch closure
+    - Validating target speed
+    """
+    hs_module_substate.raise_if_labware_latch_not_closed()
+    # Verify speed from hs module view
+    validated_speed = hs_module_substate.validate_target_speed(rpm)
+    return validated_speed

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -8,6 +8,8 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 from ...state import update_types
 
+from .common import get_heatershaker_ready_to_shake
+
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
@@ -64,10 +66,9 @@ class SetAndWaitForShakeSpeedImpl(
             module_id=params.moduleId
         )
 
-        hs_module_substate.raise_if_labware_latch_not_closed()
-
-        # Verify speed from hs module view
-        validated_speed = hs_module_substate.validate_target_speed(params.rpm)
+        validated_speed = await get_heatershaker_ready_to_shake(
+            hs_module_substate, params.rpm
+        )
 
         pipette_should_retract = (
             self._state_view.motion.check_pipette_blocking_hs_shaker(

opentrons/protocol_engine/commands/heater_shaker/set_shake_speed.py

@@ -0,0 +1,136 @@
+"""Command models to set a shake speed for a Heater-Shaker Module."""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from typing_extensions import Literal, Type
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
+from .common import get_heatershaker_ready_to_shake
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import (
+        EquipmentHandler,
+        MovementHandler,
+        TaskHandler,
+    )
+
+SetShakeSpeedCommandType = Literal["heaterShaker/setShakeSpeed"]
+
+
+class SetShakeSpeedParams(BaseModel):
+    """Input parameters to set a shake speed for a Heater-Shaker Module."""
+
+    moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
+    rpm: float = Field(..., description="Target speed in rotations per minute.")
+    taskId: str | None = Field(
+        None,
+        description="Id for the background task that manages the temperature",
+    )
+
+
+class SetShakeSpeedResult(BaseModel):
+    """Result data from setting and waiting for a Heater-Shaker's shake speed."""
+
+    pipetteRetracted: bool = Field(
+        ...,
+        description=(
+            "Whether this command automatically retracted the pipettes"
+            " before starting the shake, to avoid a potential collision."
+        ),
+    )
+    taskId: str = Field(
+        description="The task id for the setTargetTemperature task",
+    )
+
+
+class SetShakeSpeedImpl(
+    AbstractCommandImpl[SetShakeSpeedParams, SuccessData[SetShakeSpeedResult]]
+):
+    """Execution implementation of Heater-Shaker's set shake speed command."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        movement: MovementHandler,
+        task_handler: TaskHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._movement = movement
+        self._task_handler = task_handler
+
+    async def execute(
+        self,
+        params: SetShakeSpeedParams,
+    ) -> SuccessData[SetShakeSpeedResult]:
+        """Set a Heater-Shaker's target shake speed."""
+        state_update = update_types.StateUpdate()
+
+        # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
+        hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
+            module_id=params.moduleId
+        )
+
+        validated_speed = await get_heatershaker_ready_to_shake(
+            hs_module_substate, params.rpm
+        )
+        pipette_should_retract = (
+            self._state_view.motion.check_pipette_blocking_hs_shaker(
+                hs_module_substate.module_id
+            )
+        )
+        if pipette_should_retract:
+            # Move pipette away if it is close to the heater-shaker
+            # TODO(jbl 2022-07-28) replace home movement with a retract movement
+            await self._movement.home(
+                axes=self._state_view.motion.get_robot_mount_axes()
+            )
+            state_update.clear_all_pipette_locations()
+
+        # Allow propagation of ModuleNotAttachedError.
+        hs_hardware_module = self._equipment.get_module_hardware_api(
+            hs_module_substate.module_id
+        )
+
+        async def start_shake(task_handler: TaskHandler) -> None:
+            if hs_hardware_module is not None:
+                async with task_handler.synchronize_cancel_previous(
+                    hs_module_substate.module_id + "-shake"
+                ):
+                    await hs_hardware_module.set_speed(rpm=validated_speed)
+
+        task = await self._task_handler.create_task(
+            task_function=start_shake, id=params.taskId
+        )
+        return SuccessData(
+            public=SetShakeSpeedResult(
+                pipetteRetracted=pipette_should_retract, taskId=task.id
+            ),
+            state_update=state_update,
+        )
+
+
+class SetShakeSpeed(
+    BaseCommand[SetShakeSpeedParams, SetShakeSpeedResult, ErrorOccurrence]
+):
+    """A command to set a Heater-Shaker's shake speed."""
+
+    commandType: SetShakeSpeedCommandType = "heaterShaker/setShakeSpeed"
+    params: SetShakeSpeedParams
+    result: Optional[SetShakeSpeedResult] = None
+
+    _ImplementationCls: Type[SetShakeSpeedImpl] = SetShakeSpeedImpl
+
+
+class SetShakeSpeedCreate(BaseCommandCreate[SetShakeSpeedParams]):
+    """A request to create a Heater-Shaker's set shake speed command."""
+
+    commandType: SetShakeSpeedCommandType = "heaterShaker/setShakeSpeed"
+    params: SetShakeSpeedParams
+
+    _CommandCls: Type[SetShakeSpeed] = SetShakeSpeed

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -1,31 +1,47 @@
 """Command models to start heating a Heater-Shaker Module."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
-    from opentrons.protocol_engine.execution import EquipmentHandler
+    from opentrons.protocol_engine.execution import EquipmentHandler, TaskHandler
 
 
 SetTargetTemperatureCommandType = Literal["heaterShaker/setTargetTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class SetTargetTemperatureParams(BaseModel):
     """Input parameters to set a Heater-Shaker's target temperature."""
 
     moduleId: str = Field(..., description="Unique ID of the Heater-Shaker Module.")
     celsius: float = Field(..., description="Target temperature in °C.")
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="Id for the background task that manages the temperature",
+        json_schema_extra=_remove_default,
+    )
 
 
 class SetTargetTemperatureResult(BaseModel):
     """Result data from setting a Heater-Shaker's target temperature."""
 
+    taskId: str | SkipJsonSchema[None] = Field(
+        None,
+        description="The task id for the setTargetTemperature task",
+        json_schema_extra=_remove_default,
+    )
+
 
 class SetTargetTemperatureImpl(
     AbstractCommandImpl[
@@ -38,10 +54,12 @@ class SetTargetTemperatureImpl(
         self,
         state_view: StateView,
         equipment: EquipmentHandler,
+        task_handler: TaskHandler,
         **unused_dependencies: object,
     ) -> None:
         self._state_view = state_view
         self._equipment = equipment
+        self._task_handler = task_handler
 
     async def execute(
         self,
@@ -61,11 +79,19 @@ class SetTargetTemperatureImpl(
             hs_module_substate.module_id
         )
 
-        if hs_hardware_module is not None:
-            await hs_hardware_module.start_set_temperature(validated_temp)
+        async def start_set_temperature(task_handler: TaskHandler) -> None:
+            if hs_hardware_module is not None:
+                async with task_handler.synchronize_cancel_previous(
+                    hs_module_substate.module_id + "-temp"
+                ):
+                    await hs_hardware_module.start_set_temperature(validated_temp)
+                    await hs_hardware_module.await_temperature(validated_temp)
 
+        task = await self._task_handler.create_task(
+            task_function=start_set_temperature, id=params.taskId
+        )
         return SuccessData(
-            public=SetTargetTemperatureResult(),
+            public=SetTargetTemperatureResult(taskId=task.id),
         )