opentrons 8.1.0__py2.py3-none-any.whl → 8.2.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/dispense_in_place.py

@@ -12,7 +12,6 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
-    OverpressureErrorInternalData,
 )
 from .command import (
     AbstractCommandImpl,
@@ -22,11 +21,13 @@ from .command import (
     DefinedErrorData,
 )
 from ..errors.error_occurrence import ErrorOccurrence
-from ..types import DeckPoint
+from ..state.update_types import StateUpdate, CLEAR
+from ..types import CurrentWell
 
 if TYPE_CHECKING:
     from ..execution import PipettingHandler, GantryMover
     from ..resources import ModelUtils
+    from ..state.state import StateView
 
 
 DispenseInPlaceCommandType = Literal["dispenseInPlace"]
@@ -48,8 +49,8 @@ class DispenseInPlaceResult(BaseLiquidHandlingResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[DispenseInPlaceResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[DispenseInPlaceResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -61,16 +62,21 @@ class DispenseInPlaceImplementation(
     def __init__(
         self,
         pipetting: PipettingHandler,
+        state_view: StateView,
         gantry_mover: GantryMover,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._pipetting = pipetting
+        self._state_view = state_view
         self._gantry_mover = gantry_mover
         self._model_utils = model_utils
 
     async def execute(self, params: DispenseInPlaceParams) -> _ExecuteReturn:
         """Dispense without moving the pipette."""
+        state_update = StateUpdate()
+        current_location = self._state_view.pipettes.get_current_location()
+        current_position = await self._gantry_mover.get_position(params.pipetteId)
         try:
             volume = await self._pipetting.dispense_in_place(
                 pipette_id=params.pipetteId,
@@ -79,7 +85,15 @@ class DispenseInPlaceImplementation(
                 push_out=params.pushOut,
             )
         except PipetteOverpressureError as e:
-            current_position = await self._gantry_mover.get_position(params.pipetteId)
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                state_update.set_liquid_operated(
+                    labware_id=current_location.labware_id,
+                    well_name=current_location.well_name,
+                    volume_added=CLEAR,
+                )
             return DefinedErrorData(
                 public=OverpressureError(
                     id=self._model_utils.generate_id(),
@@ -101,22 +115,26 @@ class DispenseInPlaceImplementation(
                         }
                     ),
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint(
-                        x=current_position.x,
-                        y=current_position.y,
-                        z=current_position.z,
-                    ),
-                ),
+                state_update=state_update,
             )
         else:
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                state_update.set_liquid_operated(
+                    labware_id=current_location.labware_id,
+                    well_name=current_location.well_name,
+                    volume_added=volume,
+                )
             return SuccessData(
-                public=DispenseInPlaceResult(volume=volume), private=None
+                public=DispenseInPlaceResult(volume=volume),
+                state_update=state_update,
             )
 
 
 class DispenseInPlace(
-    BaseCommand[DispenseInPlaceParams, DispenseInPlaceResult, ErrorOccurrence]
+    BaseCommand[DispenseInPlaceParams, DispenseInPlaceResult, OverpressureError]
 ):
     """DispenseInPlace command model."""
 

opentrons/protocol_engine/commands/drop_tip.py

@@ -5,13 +5,27 @@ from pydantic import Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.errors.exceptions import TipAttachedError
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
+
+from ..state import update_types
 from ..types import DropTipWellLocation, DeckPoint
-from .pipetting_common import PipetteIdMixin, DestinationPositionResult
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .pipetting_common import (
+    PipetteIdMixin,
+    DestinationPositionResult,
+    TipPhysicallyAttachedError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
     from ..execution import MovementHandler, TipHandler
 
 
@@ -53,9 +67,12 @@ class DropTipResult(DestinationPositionResult):
     pass
 
 
-class DropTipImplementation(
-    AbstractCommandImpl[DropTipParams, SuccessData[DropTipResult, None]]
-):
+_ExecuteReturn = (
+    SuccessData[DropTipResult] | DefinedErrorData[TipPhysicallyAttachedError]
+)
+
+
+class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
     """Drop tip command implementation."""
 
     def __init__(
@@ -63,19 +80,23 @@ class DropTipImplementation(
         state_view: StateView,
         tip_handler: TipHandler,
         movement: MovementHandler,
+        model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._tip_handler = tip_handler
         self._movement_handler = movement
+        self._model_utils = model_utils
 
-    async def execute(self, params: DropTipParams) -> SuccessData[DropTipResult, None]:
+    async def execute(self, params: DropTipParams) -> _ExecuteReturn:
         """Move to and drop a tip using the requested pipette."""
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
         home_after = params.homeAfter
 
+        state_update = update_types.StateUpdate()
+
         if params.alternateDropLocation:
             well_location = self._state_view.geometry.get_next_tip_drop_location(
                 labware_id=labware_id,
@@ -101,18 +122,51 @@ class DropTipImplementation(
             well_name=well_name,
             well_location=tip_drop_location,
         )
-
-        await self._tip_handler.drop_tip(pipette_id=pipette_id, home_after=home_after)
-
-        return SuccessData(
-            public=DropTipResult(
-                position=DeckPoint(x=position.x, y=position.y, z=position.z)
-            ),
-            private=None,
+        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
+        state_update.set_pipette_location(
+            pipette_id=pipette_id,
+            new_labware_id=labware_id,
+            new_well_name=well_name,
+            new_deck_point=deck_point,
         )
 
+        try:
+            await self._tip_handler.drop_tip(
+                pipette_id=pipette_id, home_after=home_after
+            )
+        except TipAttachedError as exception:
+            error = TipPhysicallyAttachedError(
+                id=self._model_utils.generate_id(),
+                createdAt=self._model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=self._model_utils.generate_id(),
+                        createdAt=self._model_utils.get_timestamp(),
+                        error=exception,
+                    )
+                ],
+                errorInfo={"retryLocation": position},
+            )
+            state_update_if_false_positive = update_types.StateUpdate()
+            state_update_if_false_positive.update_pipette_tip_state(
+                pipette_id=params.pipetteId, tip_geometry=None
+            )
+            return DefinedErrorData(
+                public=error,
+                state_update=state_update,
+                state_update_if_false_positive=state_update_if_false_positive,
+            )
+        else:
+            state_update.update_pipette_tip_state(
+                pipette_id=params.pipetteId, tip_geometry=None
+            )
+            return SuccessData(
+                public=DropTipResult(position=deck_point),
+                state_update=state_update,
+            )
+
 
-class DropTip(BaseCommand[DropTipParams, DropTipResult, ErrorOccurrence]):
+class DropTip(BaseCommand[DropTipParams, DropTipResult, TipPhysicallyAttachedError]):
     """Drop tip command model."""
 
     commandType: DropTipCommandType = "dropTip"

opentrons/protocol_engine/commands/drop_tip_in_place.py

@@ -4,12 +4,21 @@ from pydantic import Field, BaseModel
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
-from .pipetting_common import PipetteIdMixin
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+from .pipetting_common import PipetteIdMixin, TipPhysicallyAttachedError
+from ..errors.exceptions import TipAttachedError
 from ..errors.error_occurrence import ErrorOccurrence
+from ..resources.model_utils import ModelUtils
+from ..state import update_types
 
 if TYPE_CHECKING:
-    from ..execution import TipHandler
+    from ..execution import TipHandler, GantryMover
 
 
 DropTipInPlaceCommandType = Literal["dropTipInPlace"]
@@ -34,31 +43,68 @@ class DropTipInPlaceResult(BaseModel):
     pass
 
 
+_ExecuteReturn = (
+    SuccessData[DropTipInPlaceResult] | DefinedErrorData[TipPhysicallyAttachedError]
+)
+
+
 class DropTipInPlaceImplementation(
-    AbstractCommandImpl[DropTipInPlaceParams, SuccessData[DropTipInPlaceResult, None]]
+    AbstractCommandImpl[DropTipInPlaceParams, _ExecuteReturn]
 ):
     """Drop tip in place command implementation."""
 
     def __init__(
         self,
         tip_handler: TipHandler,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
         **kwargs: object,
     ) -> None:
         self._tip_handler = tip_handler
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
 
-    async def execute(
-        self, params: DropTipInPlaceParams
-    ) -> SuccessData[DropTipInPlaceResult, None]:
+    async def execute(self, params: DropTipInPlaceParams) -> _ExecuteReturn:
         """Drop a tip using the requested pipette."""
-        await self._tip_handler.drop_tip(
-            pipette_id=params.pipetteId, home_after=params.homeAfter
-        )
-
-        return SuccessData(public=DropTipInPlaceResult(), private=None)
+        state_update = update_types.StateUpdate()
+
+        retry_location = await self._gantry_mover.get_position(params.pipetteId)
+
+        try:
+            await self._tip_handler.drop_tip(
+                pipette_id=params.pipetteId, home_after=params.homeAfter
+            )
+        except TipAttachedError as exception:
+            state_update_if_false_positive = update_types.StateUpdate()
+            state_update_if_false_positive.update_pipette_tip_state(
+                pipette_id=params.pipetteId, tip_geometry=None
+            )
+            error = TipPhysicallyAttachedError(
+                id=self._model_utils.generate_id(),
+                createdAt=self._model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=self._model_utils.generate_id(),
+                        createdAt=self._model_utils.get_timestamp(),
+                        error=exception,
+                    )
+                ],
+                errorInfo={"retryLocation": retry_location},
+            )
+            return DefinedErrorData(
+                public=error,
+                state_update=state_update,
+                state_update_if_false_positive=state_update_if_false_positive,
+            )
+        else:
+            state_update.update_pipette_tip_state(
+                pipette_id=params.pipetteId, tip_geometry=None
+            )
+            return SuccessData(public=DropTipInPlaceResult(), state_update=state_update)
 
 
 class DropTipInPlace(
-    BaseCommand[DropTipInPlaceParams, DropTipInPlaceResult, ErrorOccurrence]
+    BaseCommand[DropTipInPlaceParams, DropTipInPlaceResult, TipPhysicallyAttachedError]
 ):
     """Drop tip in place command model."""
 

opentrons/protocol_engine/commands/get_tip_presence.py

@@ -38,7 +38,7 @@ class GetTipPresenceResult(BaseModel):
 
 
 class GetTipPresenceImplementation(
-    AbstractCommandImpl[GetTipPresenceParams, SuccessData[GetTipPresenceResult, None]]
+    AbstractCommandImpl[GetTipPresenceParams, SuccessData[GetTipPresenceResult]]
 ):
     """GetTipPresence command implementation."""
 
@@ -51,7 +51,7 @@ class GetTipPresenceImplementation(
 
     async def execute(
         self, params: GetTipPresenceParams
-    ) -> SuccessData[GetTipPresenceResult, None]:
+    ) -> SuccessData[GetTipPresenceResult]:
         """Verify if tip presence is as expected for the requested pipette."""
         pipette_id = params.pipetteId
 
@@ -59,7 +59,9 @@ class GetTipPresenceImplementation(
             pipette_id=pipette_id,
         )
 
-        return SuccessData(public=GetTipPresenceResult(status=result), private=None)
+        return SuccessData(
+            public=GetTipPresenceResult(status=result),
+        )
 
 
 class GetTipPresence(

opentrons/protocol_engine/commands/heater_shaker/close_labware_latch.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -27,9 +27,7 @@ class CloseLabwareLatchResult(BaseModel):
 
 
 class CloseLabwareLatchImpl(
-    AbstractCommandImpl[
-        CloseLabwareLatchParams, SuccessData[CloseLabwareLatchResult, None]
-    ]
+    AbstractCommandImpl[CloseLabwareLatchParams, SuccessData[CloseLabwareLatchResult]]
 ):
     """Execution implementation of a Heater-Shaker's close labware latch command."""
 
@@ -44,7 +42,7 @@ class CloseLabwareLatchImpl(
 
     async def execute(
         self, params: CloseLabwareLatchParams
-    ) -> SuccessData[CloseLabwareLatchResult, None]:
+    ) -> SuccessData[CloseLabwareLatchResult]:
         """Close a Heater-Shaker's labware latch."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
@@ -59,7 +57,9 @@ class CloseLabwareLatchImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.close_labware_latch()
 
-        return SuccessData(public=CloseLabwareLatchResult(), private=None)
+        return SuccessData(
+            public=CloseLabwareLatchResult(),
+        )
 
 
 class CloseLabwareLatch(

opentrons/protocol_engine/commands/heater_shaker/deactivate_heater.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -27,9 +27,7 @@ class DeactivateHeaterResult(BaseModel):
 
 
 class DeactivateHeaterImpl(
-    AbstractCommandImpl[
-        DeactivateHeaterParams, SuccessData[DeactivateHeaterResult, None]
-    ]
+    AbstractCommandImpl[DeactivateHeaterParams, SuccessData[DeactivateHeaterResult]]
 ):
     """Execution implementation of a Heater-Shaker's deactivate heater command."""
 
@@ -44,7 +42,7 @@ class DeactivateHeaterImpl(
 
     async def execute(
         self, params: DeactivateHeaterParams
-    ) -> SuccessData[DeactivateHeaterResult, None]:
+    ) -> SuccessData[DeactivateHeaterResult]:
         """Unset a Heater-Shaker's target temperature."""
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -58,7 +56,9 @@ class DeactivateHeaterImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.deactivate_heater()
 
-        return SuccessData(public=DeactivateHeaterResult(), private=None)
+        return SuccessData(
+            public=DeactivateHeaterResult(),
+        )
 
 
 class DeactivateHeater(

opentrons/protocol_engine/commands/heater_shaker/deactivate_shaker.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 DeactivateShakerCommandType = Literal["heaterShaker/deactivateShaker"]
@@ -26,9 +26,7 @@ class DeactivateShakerResult(BaseModel):
 
 
 class DeactivateShakerImpl(
-    AbstractCommandImpl[
-        DeactivateShakerParams, SuccessData[DeactivateShakerResult, None]
-    ]
+    AbstractCommandImpl[DeactivateShakerParams, SuccessData[DeactivateShakerResult]]
 ):
     """Execution implementation of a Heater-Shaker's deactivate shaker command."""
 
@@ -43,7 +41,7 @@ class DeactivateShakerImpl(
 
     async def execute(
         self, params: DeactivateShakerParams
-    ) -> SuccessData[DeactivateShakerResult, None]:
+    ) -> SuccessData[DeactivateShakerResult]:
         """Deactivate shaker for a Heater-Shaker."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
@@ -60,7 +58,9 @@ class DeactivateShakerImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.deactivate_shaker()
 
-        return SuccessData(public=DeactivateShakerResult(), private=None)
+        return SuccessData(
+            public=DeactivateShakerResult(),
+        )
 
 
 class DeactivateShaker(

opentrons/protocol_engine/commands/heater_shaker/open_labware_latch.py

@@ -6,9 +6,10 @@ from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 OpenLabwareLatchCommandType = Literal["heaterShaker/openLabwareLatch"]
@@ -33,9 +34,7 @@ class OpenLabwareLatchResult(BaseModel):
 
 
 class OpenLabwareLatchImpl(
-    AbstractCommandImpl[
-        OpenLabwareLatchParams, SuccessData[OpenLabwareLatchResult, None]
-    ]
+    AbstractCommandImpl[OpenLabwareLatchParams, SuccessData[OpenLabwareLatchResult]]
 ):
     """Execution implementation of a Heater-Shaker's open latch labware command."""
 
@@ -52,8 +51,10 @@ class OpenLabwareLatchImpl(
 
     async def execute(
         self, params: OpenLabwareLatchParams
-    ) -> SuccessData[OpenLabwareLatchResult, None]:
+    ) -> SuccessData[OpenLabwareLatchResult]:
         """Open a Heater-Shaker's labware latch."""
+        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
@@ -72,6 +73,7 @@ class OpenLabwareLatchImpl(
             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(
@@ -83,7 +85,7 @@ class OpenLabwareLatchImpl(
 
         return SuccessData(
             public=OpenLabwareLatchResult(pipetteRetracted=pipette_should_retract),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/heater_shaker/set_and_wait_for_shake_speed.py

@@ -6,9 +6,10 @@ from pydantic import BaseModel, Field
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...state import update_types
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler, MovementHandler
 
 SetAndWaitForShakeSpeedCommandType = Literal["heaterShaker/setAndWaitForShakeSpeed"]
@@ -35,7 +36,7 @@ class SetAndWaitForShakeSpeedResult(BaseModel):
 
 class SetAndWaitForShakeSpeedImpl(
     AbstractCommandImpl[
-        SetAndWaitForShakeSpeedParams, SuccessData[SetAndWaitForShakeSpeedResult, None]
+        SetAndWaitForShakeSpeedParams, SuccessData[SetAndWaitForShakeSpeedResult]
     ]
 ):
     """Execution implementation of Heater-Shaker's set and wait shake speed command."""
@@ -54,8 +55,10 @@ class SetAndWaitForShakeSpeedImpl(
     async def execute(
         self,
         params: SetAndWaitForShakeSpeedParams,
-    ) -> SuccessData[SetAndWaitForShakeSpeedResult, None]:
+    ) -> SuccessData[SetAndWaitForShakeSpeedResult]:
         """Set and wait for 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
@@ -77,6 +80,7 @@ class SetAndWaitForShakeSpeedImpl(
             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(
@@ -90,7 +94,7 @@ class SetAndWaitForShakeSpeedImpl(
             public=SetAndWaitForShakeSpeedResult(
                 pipetteRetracted=pipette_should_retract
             ),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/heater_shaker/set_target_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -29,7 +29,7 @@ class SetTargetTemperatureResult(BaseModel):
 
 class SetTargetTemperatureImpl(
     AbstractCommandImpl[
-        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult, None]
+        SetTargetTemperatureParams, SuccessData[SetTargetTemperatureResult]
     ]
 ):
     """Execution implementation of a Heater-Shaker's set temperature command."""
@@ -46,7 +46,7 @@ class SetTargetTemperatureImpl(
     async def execute(
         self,
         params: SetTargetTemperatureParams,
-    ) -> SuccessData[SetTargetTemperatureResult, None]:
+    ) -> SuccessData[SetTargetTemperatureResult]:
         """Set a Heater-Shaker's target temperature."""
         # Allow propagation of ModuleNotLoadedError and WrongModuleTypeError.
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
@@ -64,7 +64,9 @@ class SetTargetTemperatureImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.start_set_temperature(validated_temp)
 
-        return SuccessData(public=SetTargetTemperatureResult(), private=None)
+        return SuccessData(
+            public=SetTargetTemperatureResult(),
+        )
 
 
 class SetTargetTemperature(

opentrons/protocol_engine/commands/heater_shaker/wait_for_temperature.py

@@ -9,7 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -36,9 +36,7 @@ class WaitForTemperatureResult(BaseModel):
 
 
 class WaitForTemperatureImpl(
-    AbstractCommandImpl[
-        WaitForTemperatureParams, SuccessData[WaitForTemperatureResult, None]
-    ]
+    AbstractCommandImpl[WaitForTemperatureParams, SuccessData[WaitForTemperatureResult]]
 ):
     """Execution implementation of a Heater-Shaker's wait for temperature command."""
 
@@ -53,7 +51,7 @@ class WaitForTemperatureImpl(
 
     async def execute(
         self, params: WaitForTemperatureParams
-    ) -> SuccessData[WaitForTemperatureResult, None]:
+    ) -> SuccessData[WaitForTemperatureResult]:
         """Wait for a Heater-Shaker's target temperature to be reached."""
         hs_module_substate = self._state_view.modules.get_heater_shaker_module_substate(
             module_id=params.moduleId
@@ -72,7 +70,9 @@ class WaitForTemperatureImpl(
         if hs_hardware_module is not None:
             await hs_hardware_module.await_temperature(awaiting_temperature=target_temp)
 
-        return SuccessData(public=WaitForTemperatureResult(), private=None)
+        return SuccessData(
+            public=WaitForTemperatureResult(),
+        )
 
 
 class WaitForTemperature(