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

opentrons/protocol_engine/commands/configure_for_volume.py

@@ -7,7 +7,7 @@ from typing_extensions import Literal
 from .pipetting_common import PipetteIdMixin
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
-from .configuring_common import PipetteConfigUpdateResultMixin
+from ..state.update_types import StateUpdate
 
 if TYPE_CHECKING:
     from ..execution import EquipmentHandler
@@ -34,12 +34,6 @@ class ConfigureForVolumeParams(PipetteIdMixin):
     )
 
 
-class ConfigureForVolumePrivateResult(PipetteConfigUpdateResultMixin):
-    """Result sent to the store but not serialized."""
-
-    pass
-
-
 class ConfigureForVolumeResult(BaseModel):
     """Result data from execution of an ConfigureForVolume command."""
 
@@ -49,7 +43,7 @@ class ConfigureForVolumeResult(BaseModel):
 class ConfigureForVolumeImplementation(
     AbstractCommandImpl[
         ConfigureForVolumeParams,
-        SuccessData[ConfigureForVolumeResult, ConfigureForVolumePrivateResult],
+        SuccessData[ConfigureForVolumeResult],
     ]
 ):
     """Configure for volume command implementation."""
@@ -59,7 +53,7 @@ class ConfigureForVolumeImplementation(
 
     async def execute(
         self, params: ConfigureForVolumeParams
-    ) -> SuccessData[ConfigureForVolumeResult, ConfigureForVolumePrivateResult]:
+    ) -> SuccessData[ConfigureForVolumeResult]:
         """Check that requested pipette can be configured for the given volume."""
         pipette_result = await self._equipment.configure_for_volume(
             pipette_id=params.pipetteId,
@@ -67,13 +61,16 @@ class ConfigureForVolumeImplementation(
             tip_overlap_version=params.tipOverlapNotAfterVersion,
         )
 
+        state_update = StateUpdate()
+        state_update.update_pipette_config(
+            pipette_id=pipette_result.pipette_id,
+            config=pipette_result.static_config,
+            serial_number=pipette_result.serial_number,
+        )
+
         return SuccessData(
             public=ConfigureForVolumeResult(),
-            private=ConfigureForVolumePrivateResult(
-                pipette_id=pipette_result.pipette_id,
-                serial_number=pipette_result.serial_number,
-                config=pipette_result.static_config,
-            ),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/configure_nozzle_layout.py

@@ -1,5 +1,6 @@
 """Configure nozzle layout command request, result, and implementation models."""
 from __future__ import annotations
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from pydantic import BaseModel
 from typing import TYPE_CHECKING, Optional, Type, Union
 from typing_extensions import Literal
@@ -9,9 +10,6 @@ from .pipetting_common import (
 )
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
-from .configuring_common import (
-    PipetteNozzleLayoutResultMixin,
-)
 from ..types import (
     AllNozzleLayoutConfiguration,
     SingleNozzleLayoutConfiguration,
@@ -39,12 +37,6 @@ class ConfigureNozzleLayoutParams(PipetteIdMixin):
     ]
 
 
-class ConfigureNozzleLayoutPrivateResult(PipetteNozzleLayoutResultMixin):
-    """Result sent to the store but not serialized."""
-
-    pass
-
-
 class ConfigureNozzleLayoutResult(BaseModel):
     """Result data from execution of an configureNozzleLayout command."""
 
@@ -54,7 +46,7 @@ class ConfigureNozzleLayoutResult(BaseModel):
 class ConfigureNozzleLayoutImplementation(
     AbstractCommandImpl[
         ConfigureNozzleLayoutParams,
-        SuccessData[ConfigureNozzleLayoutResult, ConfigureNozzleLayoutPrivateResult],
+        SuccessData[ConfigureNozzleLayoutResult],
     ]
 ):
     """Configure nozzle layout command implementation."""
@@ -67,7 +59,7 @@ class ConfigureNozzleLayoutImplementation(
 
     async def execute(
         self, params: ConfigureNozzleLayoutParams
-    ) -> SuccessData[ConfigureNozzleLayoutResult, ConfigureNozzleLayoutPrivateResult]:
+    ) -> SuccessData[ConfigureNozzleLayoutResult]:
         """Check that requested pipette can support the requested nozzle layout."""
         primary_nozzle = params.configurationParams.dict().get("primaryNozzle")
         front_right_nozzle = params.configurationParams.dict().get("frontRightNozzle")
@@ -85,12 +77,14 @@ class ConfigureNozzleLayoutImplementation(
             **nozzle_params,
         )
 
+        update_state = StateUpdate()
+        update_state.update_pipette_nozzle(
+            pipette_id=params.pipetteId, nozzle_map=nozzle_map
+        )
+
         return SuccessData(
             public=ConfigureNozzleLayoutResult(),
-            private=ConfigureNozzleLayoutPrivateResult(
-                pipette_id=params.pipetteId,
-                nozzle_map=nozzle_map,
-            ),
+            state_update=update_state,
         )
 
 

opentrons/protocol_engine/commands/custom.py

@@ -40,16 +40,18 @@ class CustomResult(BaseModel):
 
 
 class CustomImplementation(
-    AbstractCommandImpl[CustomParams, SuccessData[CustomResult, None]]
+    AbstractCommandImpl[CustomParams, SuccessData[CustomResult]]
 ):
     """Custom command implementation."""
 
     # TODO(mm, 2022-11-09): figure out how a plugin can specify a custom command
     # implementation. For now, always no-op, so we can use custom commands as containers
     # for legacy RPC (pre-ProtocolEngine) payloads.
-    async def execute(self, params: CustomParams) -> SuccessData[CustomResult, None]:
+    async def execute(self, params: CustomParams) -> SuccessData[CustomResult]:
         """A custom command does nothing when executed directly."""
-        return SuccessData(public=CustomResult.construct(), private=None)
+        return SuccessData(
+            public=CustomResult.construct(),
+        )
 
 
 class Custom(BaseCommand[CustomParams, CustomResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/dispense.py

@@ -8,15 +8,15 @@ from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 from pydantic import Field
 
 from ..types import DeckPoint
+from ..state.update_types import StateUpdate, CLEAR
 from .pipetting_common import (
     PipetteIdMixin,
     DispenseVolumeMixin,
     FlowRateMixin,
-    WellLocationMixin,
+    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
     DestinationPositionResult,
     OverpressureError,
-    OverpressureErrorInternalData,
 )
 from .command import (
     AbstractCommandImpl,
@@ -30,13 +30,14 @@ from ..errors.error_occurrence import ErrorOccurrence
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
     from ..resources import ModelUtils
+    from ..state.state import StateView
 
 
 DispenseCommandType = Literal["dispense"]
 
 
 class DispenseParams(
-    PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin, WellLocationMixin
+    PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
 ):
     """Payload required to dispense to a specific well."""
 
@@ -53,8 +54,8 @@ class DispenseResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[DispenseResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[DispenseResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -63,31 +64,54 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
 
     def __init__(
         self,
+        state_view: StateView,
         movement: MovementHandler,
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
+        self._state_view = state_view
         self._movement = movement
         self._pipetting = pipetting
         self._model_utils = model_utils
 
     async def execute(self, params: DispenseParams) -> _ExecuteReturn:
         """Move to and dispense to the requested well."""
+        state_update = StateUpdate()
+        well_location = params.wellLocation
+        labware_id = params.labwareId
+        well_name = params.wellName
+        volume = params.volume
+
+        # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
+
         position = await self._movement.move_to_well(
             pipette_id=params.pipetteId,
-            labware_id=params.labwareId,
-            well_name=params.wellName,
-            well_location=params.wellLocation,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=well_location,
         )
+        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_labware_id=labware_id,
+            new_well_name=well_name,
+            new_deck_point=deck_point,
+        )
+
         try:
             volume = await self._pipetting.dispense_in_place(
                 pipette_id=params.pipetteId,
-                volume=params.volume,
+                volume=volume,
                 flow_rate=params.flowRate,
                 push_out=params.pushOut,
             )
         except PipetteOverpressureError as e:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=CLEAR,
+            )
             return DefinedErrorData(
                 public=OverpressureError(
                     id=self._model_utils.generate_id(),
@@ -101,23 +125,21 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
                     ],
                     errorInfo={"retryLocation": (position.x, position.y, position.z)},
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint.construct(
-                        x=position.x, y=position.y, z=position.z
-                    )
-                ),
+                state_update=state_update,
             )
         else:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=volume,
+            )
             return SuccessData(
-                public=DispenseResult(
-                    volume=volume,
-                    position=DeckPoint(x=position.x, y=position.y, z=position.z),
-                ),
-                private=None,
+                public=DispenseResult(volume=volume, position=deck_point),
+                state_update=state_update,
             )
 
 
-class Dispense(BaseCommand[DispenseParams, DispenseResult, ErrorOccurrence]):
+class Dispense(BaseCommand[DispenseParams, DispenseResult, OverpressureError]):
     """Dispense command model."""
 
     commandType: DispenseCommandType = "dispense"

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,17 +62,22 @@ 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()
         try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
             volume = await self._pipetting.dispense_in_place(
                 pipette_id=params.pipetteId,
                 volume=params.volume,
@@ -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,16 +122,48 @@ 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,
+                    )
+                ],
+            )
+            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]):
     """Drop tip command model."""

opentrons/protocol_engine/commands/drop_tip_in_place.py

@@ -4,9 +4,18 @@ 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
@@ -34,27 +43,59 @@ 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,
         **kwargs: object,
     ) -> None:
         self._tip_handler = tip_handler
+        self._model_utils = model_utils
 
-    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()
+
+        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,
+                    )
+                ],
+            )
+            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(

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(