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

opentrons/protocol_engine/commands/home.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional, List, Type
 from typing_extensions import Literal
 
 from opentrons.types import MountType
+from ..state import update_types
 from ..types import MotorAxis
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
@@ -41,16 +42,16 @@ class HomeResult(BaseModel):
     """Result data from the execution of a Home command."""
 
 
-class HomeImplementation(
-    AbstractCommandImpl[HomeParams, SuccessData[HomeResult, None]]
-):
+class HomeImplementation(AbstractCommandImpl[HomeParams, SuccessData[HomeResult]]):
     """Home command implementation."""
 
     def __init__(self, movement: MovementHandler, **kwargs: object) -> None:
         self._movement = movement
 
-    async def execute(self, params: HomeParams) -> SuccessData[HomeResult, None]:
+    async def execute(self, params: HomeParams) -> SuccessData[HomeResult]:
         """Home some or all motors to establish positional accuracy."""
+        state_update = update_types.StateUpdate()
+
         if (
             params.skipIfMountPositionOk is None
             or not await self._movement.check_for_valid_position(
@@ -58,7 +59,12 @@ class HomeImplementation(
             )
         ):
             await self._movement.home(axes=params.axes)
-        return SuccessData(public=HomeResult(), private=None)
+
+        # todo(mm, 2024-09-17): Clearing all pipette locations *unconditionally* is to
+        # preserve prior behavior, but we might only want to do this if we actually home.
+        state_update.clear_all_pipette_locations()
+
+        return SuccessData(public=HomeResult(), state_update=state_update)
 
 
 class Home(BaseCommand[HomeParams, HomeResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/liquid_probe.py

@@ -1,24 +1,26 @@
 """The liquidProbe and tryLiquidProbe commands."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, NamedTuple, Optional, Type, Union
+from typing_extensions import Literal
+
+from pydantic import Field
+
+from opentrons.protocol_engine.state import update_types
 from opentrons.protocol_engine.errors.exceptions import (
     MustHomeError,
     PipetteNotReadyToAspirateError,
     TipNotEmptyError,
+    IncompleteLabwareDefinitionError,
 )
 from opentrons.types import MountType
 from opentrons_shared_data.errors.exceptions import (
     PipetteLiquidNotFoundError,
 )
-from typing_extensions import Literal
-
-from pydantic import Field
 
 from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
-    LiquidNotFoundErrorInternalData,
     PipetteIdMixin,
     WellLocationMixin,
     DestinationPositionResult,
@@ -36,7 +38,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 LiquidProbeCommandType = Literal["liquidProbe"]
@@ -84,10 +86,86 @@ class TryLiquidProbeResult(DestinationPositionResult):
 
 
 _LiquidProbeExecuteReturn = Union[
-    SuccessData[LiquidProbeResult, None],
-    DefinedErrorData[LiquidNotFoundError, LiquidNotFoundErrorInternalData],
+    SuccessData[LiquidProbeResult],
+    DefinedErrorData[LiquidNotFoundError],
 ]
-_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult, None]
+_TryLiquidProbeExecuteReturn = SuccessData[TryLiquidProbeResult]
+
+
+class _ExecuteCommonResult(NamedTuple):
+    # If the probe succeeded, the z_pos that it returned.
+    # Or, if the probe found no liquid, the error representing that,
+    # so calling code can propagate those details up.
+    z_pos_or_error: float | PipetteLiquidNotFoundError
+
+    state_update: update_types.StateUpdate
+    deck_point: DeckPoint
+
+
+async def _execute_common(
+    state_view: StateView,
+    movement: MovementHandler,
+    pipetting: PipettingHandler,
+    params: _CommonParams,
+) -> _ExecuteCommonResult:
+    pipette_id = params.pipetteId
+    labware_id = params.labwareId
+    well_name = params.wellName
+
+    state_update = update_types.StateUpdate()
+
+    # May raise TipNotAttachedError.
+    aspirated_volume = state_view.pipettes.get_aspirated_volume(pipette_id)
+
+    if aspirated_volume is None:
+        # Theoretically, we could avoid raising an error by automatically preparing
+        # to aspirate above the well like AspirateImplementation does. However, the
+        # only way for this to happen is if someone tries to do a liquid probe with
+        # a tip that's previously held liquid, which they should avoid anyway.
+        raise PipetteNotReadyToAspirateError(
+            "The pipette cannot probe liquid because of a previous blow out."
+            " The plunger must be reset while the tip is somewhere away from liquid."
+        )
+    elif aspirated_volume != 0:
+        raise TipNotEmptyError(
+            message="The pipette cannot probe for liquid when the tip has liquid in it."
+        )
+
+    if await movement.check_for_valid_position(mount=MountType.LEFT) is False:
+        raise MustHomeError(
+            message="Current position of pipette is invalid. Please home."
+        )
+
+    # liquid_probe process start position
+    position = await movement.move_to_well(
+        pipette_id=pipette_id,
+        labware_id=labware_id,
+        well_name=well_name,
+        well_location=params.wellLocation,
+    )
+    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:
+        z_pos = await pipetting.liquid_probe_in_place(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=params.wellLocation,
+        )
+    except PipetteLiquidNotFoundError as exception:
+        return _ExecuteCommonResult(
+            z_pos_or_error=exception, state_update=state_update, deck_point=deck_point
+        )
+    else:
+        return _ExecuteCommonResult(
+            z_pos_or_error=z_pos, state_update=state_update, deck_point=deck_point
+        )
 
 
 class LiquidProbeImplementation(
@@ -124,48 +202,17 @@ class LiquidProbeImplementation(
             MustHomeError: as an undefined error, if the plunger is not in a valid
                 position.
         """
-        pipette_id = params.pipetteId
-        labware_id = params.labwareId
-        well_name = params.wellName
-
-        # May raise TipNotAttachedError.
-        aspirated_volume = self._state_view.pipettes.get_aspirated_volume(pipette_id)
-
-        if aspirated_volume is None:
-            # Theoretically, we could avoid raising an error by automatically preparing
-            # to aspirate above the well like AspirateImplementation does. However, the
-            # only way for this to happen is if someone tries to do a liquid probe with
-            # a tip that's previously held liquid, which they should avoid anyway.
-            raise PipetteNotReadyToAspirateError(
-                "The pipette cannot probe liquid because of a previous blow out."
-                " The plunger must be reset while the tip is somewhere away from liquid."
-            )
-        elif aspirated_volume != 0:
-            raise TipNotEmptyError(
-                message="The pipette cannot probe for liquid when the tip has liquid in it."
-            )
-
-        if await self._movement.check_for_valid_position(mount=MountType.LEFT) is False:
-            raise MustHomeError(
-                message="Current position of pipette is invalid. Please home."
-            )
-
-        # liquid_probe process start position
-        position = await self._movement.move_to_well(
-            pipette_id=pipette_id,
-            labware_id=labware_id,
-            well_name=well_name,
-            well_location=params.wellLocation,
+        z_pos_or_error, state_update, deck_point = await _execute_common(
+            self._state_view, self._movement, self._pipetting, params
         )
-
-        try:
-            z_pos = await self._pipetting.liquid_probe_in_place(
-                pipette_id=pipette_id,
-                labware_id=labware_id,
-                well_name=well_name,
-                well_location=params.wellLocation,
+        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+            state_update.set_liquid_probed(
+                labware_id=params.labwareId,
+                well_name=params.wellName,
+                height=update_types.CLEAR,
+                volume=update_types.CLEAR,
+                last_probed=self._model_utils.get_timestamp(),
             )
-        except PipetteLiquidNotFoundError as e:
             return DefinedErrorData(
                 public=LiquidNotFoundError(
                     id=self._model_utils.generate_id(),
@@ -174,21 +221,35 @@ class LiquidProbeImplementation(
                         ErrorOccurrence.from_failed(
                             id=self._model_utils.generate_id(),
                             createdAt=self._model_utils.get_timestamp(),
-                            error=e,
+                            error=z_pos_or_error,
                         )
                     ],
                 ),
-                private=LiquidNotFoundErrorInternalData(
-                    position=DeckPoint(x=position.x, y=position.y, z=position.z)
-                ),
+                state_update=state_update,
             )
         else:
+            try:
+                well_volume: float | update_types.ClearType = (
+                    self._state_view.geometry.get_well_volume_at_height(
+                        labware_id=params.labwareId,
+                        well_name=params.wellName,
+                        height=z_pos_or_error,
+                    )
+                )
+            except IncompleteLabwareDefinitionError:
+                well_volume = update_types.CLEAR
+            state_update.set_liquid_probed(
+                labware_id=params.labwareId,
+                well_name=params.wellName,
+                height=z_pos_or_error,
+                volume=well_volume,
+                last_probed=self._model_utils.get_timestamp(),
+            )
             return SuccessData(
                 public=LiquidProbeResult(
-                    z_position=z_pos,
-                    position=DeckPoint(x=position.x, y=position.y, z=position.z),
+                    z_position=z_pos_or_error, position=deck_point
                 ),
-                private=None,
+                state_update=state_update,
             )
 
 
@@ -217,40 +278,37 @@ class TryLiquidProbeImplementation(
         found, `tryLiquidProbe` returns a success result with `z_position=null` instead
         of a defined error.
         """
-        # We defer to the `liquidProbe` implementation. If it returns a defined
-        # `liquidNotFound` error, we remap that to a success result.
-        # Otherwise, we return the result or propagate the exception unchanged.
-
-        original_impl = LiquidProbeImplementation(
-            state_view=self._state_view,
-            movement=self._movement,
-            pipetting=self._pipetting,
-            model_utils=self._model_utils,
+        z_pos_or_error, state_update, deck_point = await _execute_common(
+            self._state_view, self._movement, self._pipetting, params
         )
-        original_result = await original_impl.execute(params)
-
-        match original_result:
-            case DefinedErrorData(
-                public=LiquidNotFoundError(),
-                private=LiquidNotFoundErrorInternalData() as original_private,
-            ):
-                return SuccessData(
-                    public=TryLiquidProbeResult(
-                        z_position=None,
-                        position=original_private.position,
-                    ),
-                    private=None,
-                )
-            case SuccessData(
-                public=LiquidProbeResult() as original_public, private=None
-            ):
-                return SuccessData(
-                    public=TryLiquidProbeResult(
-                        position=original_public.position,
-                        z_position=original_public.z_position,
-                    ),
-                    private=None,
+
+        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+            z_pos = None
+            well_volume: float | update_types.ClearType = update_types.CLEAR
+        else:
+            z_pos = z_pos_or_error
+            try:
+                well_volume = self._state_view.geometry.get_well_volume_at_height(
+                    labware_id=params.labwareId, well_name=params.wellName, height=z_pos
                 )
+            except IncompleteLabwareDefinitionError:
+                well_volume = update_types.CLEAR
+
+        state_update.set_liquid_probed(
+            labware_id=params.labwareId,
+            well_name=params.wellName,
+            height=z_pos if z_pos is not None else update_types.CLEAR,
+            volume=well_volume,
+            last_probed=self._model_utils.get_timestamp(),
+        )
+
+        return SuccessData(
+            public=TryLiquidProbeResult(
+                z_position=z_pos,
+                position=deck_point,
+            ),
+            state_update=state_update,
+        )
 
 
 class LiquidProbe(

opentrons/protocol_engine/commands/load_labware.py

@@ -10,6 +10,8 @@ from ..errors import LabwareIsNotAllowedInLocationError
 from ..resources import labware_validation, fixture_validation
 from ..types import (
     LabwareLocation,
+    ModuleLocation,
+    ModuleModel,
     OnLabwareLocation,
     DeckSlotLocation,
     AddressableAreaLocation,
@@ -17,9 +19,10 @@ from ..types import (
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
 
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
     from ..execution import EquipmentHandler
 
 
@@ -87,7 +90,7 @@ class LoadLabwareResult(BaseModel):
 
 
 class LoadLabwareImplementation(
-    AbstractCommandImpl[LoadLabwareParams, SuccessData[LoadLabwareResult, None]]
+    AbstractCommandImpl[LoadLabwareParams, SuccessData[LoadLabwareResult]]
 ):
     """Load labware command implementation."""
 
@@ -99,7 +102,7 @@ class LoadLabwareImplementation(
 
     async def execute(
         self, params: LoadLabwareParams
-    ) -> SuccessData[LoadLabwareResult, None]:
+    ) -> SuccessData[LoadLabwareResult]:
         """Load definition and calibration data necessary for a labware."""
         # TODO (tz, 8-15-2023): extend column validation to column 1 when working
         # on https://opentrons.atlassian.net/browse/RSS-258 and completing
@@ -115,7 +118,10 @@ class LoadLabwareImplementation(
 
         if isinstance(params.location, AddressableAreaLocation):
             area_name = params.location.addressableAreaName
-            if not fixture_validation.is_deck_slot(params.location.addressableAreaName):
+            if not (
+                fixture_validation.is_deck_slot(params.location.addressableAreaName)
+                or fixture_validation.is_abs_reader(params.location.addressableAreaName)
+            ):
                 raise LabwareIsNotAllowedInLocationError(
                     f"Cannot load {params.loadName} onto addressable area {area_name}"
                 )
@@ -138,6 +144,16 @@ class LoadLabwareImplementation(
             labware_id=params.labwareId,
         )
 
+        state_update = StateUpdate()
+
+        state_update.set_loaded_labware(
+            labware_id=loaded_labware.labware_id,
+            offset_id=loaded_labware.offsetId,
+            definition=loaded_labware.definition,
+            location=verified_location,
+            display_name=params.displayName,
+        )
+
         # TODO(jbl 2023-06-23) these validation checks happen after the labware is loaded, because they rely on
         #   on the definition. In practice this will not cause any issues since they will raise protocol ending
         #   exception, but for correctness should be refactored to do this check beforehand.
@@ -146,6 +162,13 @@ class LoadLabwareImplementation(
                 top_labware_definition=loaded_labware.definition,
                 bottom_labware_id=verified_location.labwareId,
             )
+        # Validate labware for the absorbance reader
+        elif isinstance(params.location, ModuleLocation):
+            module = self._state_view.modules.get(params.location.moduleId)
+            if module is not None and module.model == ModuleModel.ABSORBANCE_READER_V1:
+                self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
+                    loaded_labware.definition
+                )
 
         return SuccessData(
             public=LoadLabwareResult(
@@ -153,7 +176,7 @@ class LoadLabwareImplementation(
                 definition=loaded_labware.definition,
                 offsetId=loaded_labware.offsetId,
             ),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/load_liquid.py

@@ -4,11 +4,14 @@ from pydantic import BaseModel, Field
 from typing import Optional, Type, Dict, TYPE_CHECKING
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
+
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
+    from ..resources import ModelUtils
 
 LoadLiquidCommandType = Literal["loadLiquid"]
 
@@ -37,16 +40,17 @@ class LoadLiquidResult(BaseModel):
 
 
 class LoadLiquidImplementation(
-    AbstractCommandImpl[LoadLiquidParams, SuccessData[LoadLiquidResult, None]]
+    AbstractCommandImpl[LoadLiquidParams, SuccessData[LoadLiquidResult]]
 ):
     """Load liquid command implementation."""
 
-    def __init__(self, state_view: StateView, **kwargs: object) -> None:
+    def __init__(
+        self, state_view: StateView, model_utils: ModelUtils, **kwargs: object
+    ) -> None:
         self._state_view = state_view
+        self._model_utils = model_utils
 
-    async def execute(
-        self, params: LoadLiquidParams
-    ) -> SuccessData[LoadLiquidResult, None]:
+    async def execute(self, params: LoadLiquidParams) -> SuccessData[LoadLiquidResult]:
         """Load data necessary for a liquid."""
         self._state_view.liquid.validate_liquid_id(params.liquidId)
 
@@ -54,7 +58,14 @@ class LoadLiquidImplementation(
             labware_id=params.labwareId, wells=params.volumeByWell
         )
 
-        return SuccessData(public=LoadLiquidResult(), private=None)
+        state_update = StateUpdate()
+        state_update.set_liquid_loaded(
+            labware_id=params.labwareId,
+            volumes=params.volumeByWell,
+            last_loaded=self._model_utils.get_timestamp(),
+        )
+
+        return SuccessData(public=LoadLiquidResult(), state_update=state_update)
 
 
 class LoadLiquid(BaseCommand[LoadLiquidParams, LoadLiquidResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/load_module.py

@@ -16,8 +16,9 @@ from opentrons.types import DeckSlotName
 
 from opentrons.protocol_engine.resources import deck_configuration_provider
 
+
 if TYPE_CHECKING:
-    from ..state import StateView
+    from ..state.state import StateView
     from ..execution import EquipmentHandler
 
 
@@ -103,7 +104,7 @@ class LoadModuleResult(BaseModel):
 
 
 class LoadModuleImplementation(
-    AbstractCommandImpl[LoadModuleParams, SuccessData[LoadModuleResult, None]]
+    AbstractCommandImpl[LoadModuleParams, SuccessData[LoadModuleResult]]
 ):
     """The implementation of the load module command."""
 
@@ -113,9 +114,7 @@ class LoadModuleImplementation(
         self._equipment = equipment
         self._state_view = state_view
 
-    async def execute(
-        self, params: LoadModuleParams
-    ) -> SuccessData[LoadModuleResult, None]:
+    async def execute(self, params: LoadModuleParams) -> SuccessData[LoadModuleResult]:
         """Check that the requested module is attached and assign its identifier."""
         module_type = params.model.as_type()
         self._ensure_module_location(params.location.slotName, module_type)
@@ -158,7 +157,6 @@ class LoadModuleImplementation(
                 model=loaded_module.definition.model,
                 definition=loaded_module.definition,
             ),
-            private=None,
         )
 
     def _ensure_module_location(

opentrons/protocol_engine/commands/load_pipette.py

@@ -1,6 +1,7 @@
 """Load pipette command request, result, and implementation models."""
 from __future__ import annotations
 
+from opentrons.protocol_engine.state.update_types import StateUpdate
 from opentrons_shared_data.pipette.pipette_load_name_conversions import (
     convert_to_pipette_name_type,
 )
@@ -16,23 +17,16 @@ from opentrons.types import MountType
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
-from .configuring_common import PipetteConfigUpdateResultMixin
 from ..errors import InvalidSpecificationForRobotTypeError, InvalidLoadPipetteSpecsError
 
 if TYPE_CHECKING:
     from ..execution import EquipmentHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 LoadPipetteCommandType = Literal["loadPipette"]
 
 
-class LoadPipettePrivateResult(PipetteConfigUpdateResultMixin):
-    """The not-to-be-exposed results of a load pipette call."""
-
-    ...
-
-
 class LoadPipetteParams(BaseModel):
     """Payload needed to load a pipette on to a mount."""
 
@@ -72,9 +66,7 @@ class LoadPipetteResult(BaseModel):
 
 
 class LoadPipetteImplementation(
-    AbstractCommandImpl[
-        LoadPipetteParams, SuccessData[LoadPipetteResult, LoadPipettePrivateResult]
-    ]
+    AbstractCommandImpl[LoadPipetteParams, SuccessData[LoadPipetteResult]]
 ):
     """Load pipette command implementation."""
 
@@ -86,7 +78,7 @@ class LoadPipetteImplementation(
 
     async def execute(
         self, params: LoadPipetteParams
-    ) -> SuccessData[LoadPipetteResult, LoadPipettePrivateResult]:
+    ) -> SuccessData[LoadPipetteResult]:
         """Check that requested pipette is attached and assign its identifier."""
         pipette_generation = convert_to_pipette_name_type(
             params.pipetteName.value
@@ -123,13 +115,22 @@ class LoadPipetteImplementation(
             tip_overlap_version=params.tipOverlapNotAfterVersion,
         )
 
+        state_update = StateUpdate()
+        state_update.set_load_pipette(
+            pipette_id=loaded_pipette.pipette_id,
+            pipette_name=params.pipetteName,
+            mount=params.mount,
+            liquid_presence_detection=params.liquidPresenceDetection,
+        )
+        state_update.update_pipette_config(
+            pipette_id=loaded_pipette.pipette_id,
+            serial_number=loaded_pipette.serial_number,
+            config=loaded_pipette.static_config,
+        )
+
         return SuccessData(
             public=LoadPipetteResult(pipetteId=loaded_pipette.pipette_id),
-            private=LoadPipettePrivateResult(
-                pipette_id=loaded_pipette.pipette_id,
-                serial_number=loaded_pipette.serial_number,
-                config=loaded_pipette.static_config,
-            ),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/magnetic_module/disengage.py

@@ -13,7 +13,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.execution import EquipmentHandler
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
 
 
 DisengageCommandType = Literal["magneticModule/disengage"]
@@ -38,7 +38,7 @@ class DisengageResult(BaseModel):
 
 
 class DisengageImplementation(
-    AbstractCommandImpl[DisengageParams, SuccessData[DisengageResult, None]]
+    AbstractCommandImpl[DisengageParams, SuccessData[DisengageResult]]
 ):
     """The implementation of a Magnetic Module disengage command."""
 
@@ -51,9 +51,7 @@ class DisengageImplementation(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(
-        self, params: DisengageParams
-    ) -> SuccessData[DisengageResult, None]:
+    async def execute(self, params: DisengageParams) -> SuccessData[DisengageResult]:
         """Execute a Magnetic Module disengage command.
 
         Raises:
@@ -75,7 +73,9 @@ class DisengageImplementation(
         if hardware_module is not None:  # Not virtualizing modules.
             await hardware_module.deactivate()
 
-        return SuccessData(public=DisengageResult(), private=None)
+        return SuccessData(
+            public=DisengageResult(),
+        )
 
 
 class Disengage(BaseCommand[DisengageParams, DisengageResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/magnetic_module/engage.py

@@ -10,7 +10,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.execution import EquipmentHandler
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
 
 
 EngageCommandType = Literal["magneticModule/engage"]
@@ -54,7 +54,7 @@ class EngageResult(BaseModel):
 
 
 class EngageImplementation(
-    AbstractCommandImpl[EngageParams, SuccessData[EngageResult, None]]
+    AbstractCommandImpl[EngageParams, SuccessData[EngageResult]]
 ):
     """The implementation of a Magnetic Module engage command."""
 
@@ -67,7 +67,7 @@ class EngageImplementation(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(self, params: EngageParams) -> SuccessData[EngageResult, None]:
+    async def execute(self, params: EngageParams) -> SuccessData[EngageResult]:
         """Execute a Magnetic Module engage command.
 
         Raises:
@@ -95,7 +95,9 @@ class EngageImplementation(
         if hardware_module is not None:  # Not virtualizing modules.
             await hardware_module.engage(height=hardware_height)
 
-        return SuccessData(public=EngageResult(), private=None)
+        return SuccessData(
+            public=EngageResult(),
+        )
 
 
 class Engage(BaseCommand[EngageParams, EngageResult, ErrorOccurrence]):