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

opentrons/protocol_engine/commands/blow_out.py

@@ -1,16 +1,26 @@
 """Blow-out command request, result, and implementation models."""
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional, Type, Union
+from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 from typing_extensions import Literal
 
+
+from ..state.update_types import StateUpdate
 from ..types import DeckPoint
 from .pipetting_common import (
+    OverpressureError,
     PipetteIdMixin,
     FlowRateMixin,
     WellLocationMixin,
     DestinationPositionResult,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
@@ -18,7 +28,9 @@ from opentrons.hardware_control import HardwareControlAPI
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
-    from ..state import StateView
+    from ..state.state import StateView
+    from ..resources import ModelUtils
+
 
 BlowOutCommandType = Literal["blowout"]
 
@@ -35,9 +47,13 @@ class BlowOutResult(DestinationPositionResult):
     pass
 
 
-class BlowOutImplementation(
-    AbstractCommandImpl[BlowOutParams, SuccessData[BlowOutResult, None]]
-):
+_ExecuteReturn = Union[
+    SuccessData[BlowOutResult],
+    DefinedErrorData[OverpressureError],
+]
+
+
+class BlowOutImplementation(AbstractCommandImpl[BlowOutParams, _ExecuteReturn]):
     """BlowOut command implementation."""
 
     def __init__(
@@ -46,29 +62,62 @@ class BlowOutImplementation(
         pipetting: PipettingHandler,
         state_view: StateView,
         hardware_api: HardwareControlAPI,
+        model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._movement = movement
         self._pipetting = pipetting
         self._state_view = state_view
         self._hardware_api = hardware_api
+        self._model_utils = model_utils
 
-    async def execute(self, params: BlowOutParams) -> SuccessData[BlowOutResult, None]:
+    async def execute(self, params: BlowOutParams) -> _ExecuteReturn:
         """Move to and blow-out the requested well."""
+        state_update = StateUpdate()
+
         x, y, z = await self._movement.move_to_well(
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
             well_location=params.wellLocation,
         )
-
-        await self._pipetting.blow_out_in_place(
-            pipette_id=params.pipetteId, flow_rate=params.flowRate
-        )
-
-        return SuccessData(
-            public=BlowOutResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_labware_id=params.labwareId,
+            new_well_name=params.wellName,
+            new_deck_point=deck_point,
         )
+        try:
+            await self._pipetting.blow_out_in_place(
+                pipette_id=params.pipetteId, flow_rate=params.flowRate
+            )
+        except PipetteOverpressureError as e:
+            return DefinedErrorData(
+                public=OverpressureError(
+                    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=e,
+                        )
+                    ],
+                    errorInfo={
+                        "retryLocation": (
+                            x,
+                            y,
+                            z,
+                        )
+                    },
+                ),
+            )
+        else:
+            return SuccessData(
+                public=BlowOutResult(position=deck_point),
+                state_update=state_update,
+            )
 
 
 class BlowOut(BaseCommand[BlowOutParams, BlowOutResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/blow_out_in_place.py

@@ -1,23 +1,32 @@
 """Blow-out in place command request, result, and implementation models."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type
+from typing import TYPE_CHECKING, Optional, Type, Union
+from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 from typing_extensions import Literal
 from pydantic import BaseModel
 
 from .pipetting_common import (
+    OverpressureError,
     PipetteIdMixin,
     FlowRateMixin,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
 
 
 if TYPE_CHECKING:
-    from ..execution import PipettingHandler
-    from ..state import StateView
+    from ..execution import PipettingHandler, GantryMover
+    from ..state.state import StateView
+    from ..resources import ModelUtils
 
 
 BlowOutInPlaceCommandType = Literal["blowOutInPlace"]
@@ -35,8 +44,14 @@ class BlowOutInPlaceResult(BaseModel):
     pass
 
 
+_ExecuteReturn = Union[
+    SuccessData[BlowOutInPlaceResult],
+    DefinedErrorData[OverpressureError],
+]
+
+
 class BlowOutInPlaceImplementation(
-    AbstractCommandImpl[BlowOutInPlaceParams, SuccessData[BlowOutInPlaceResult, None]]
+    AbstractCommandImpl[BlowOutInPlaceParams, _ExecuteReturn]
 ):
     """BlowOutInPlace command implementation."""
 
@@ -45,21 +60,48 @@ class BlowOutInPlaceImplementation(
         pipetting: PipettingHandler,
         state_view: StateView,
         hardware_api: HardwareControlAPI,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
         **kwargs: object,
     ) -> None:
         self._pipetting = pipetting
         self._state_view = state_view
         self._hardware_api = hardware_api
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
 
-    async def execute(
-        self, params: BlowOutInPlaceParams
-    ) -> SuccessData[BlowOutInPlaceResult, None]:
+    async def execute(self, params: BlowOutInPlaceParams) -> _ExecuteReturn:
         """Blow-out without moving the pipette."""
-        await self._pipetting.blow_out_in_place(
-            pipette_id=params.pipetteId, flow_rate=params.flowRate
-        )
-
-        return SuccessData(public=BlowOutInPlaceResult(), private=None)
+        try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
+            await self._pipetting.blow_out_in_place(
+                pipette_id=params.pipetteId, flow_rate=params.flowRate
+            )
+        except PipetteOverpressureError as e:
+            return DefinedErrorData(
+                public=OverpressureError(
+                    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=e,
+                        )
+                    ],
+                    errorInfo={
+                        "retryLocation": (
+                            current_position.x,
+                            current_position.y,
+                            current_position.z,
+                        )
+                    },
+                ),
+            )
+        else:
+            return SuccessData(
+                public=BlowOutInPlaceResult(),
+            )
 
 
 class BlowOutInPlace(

opentrons/protocol_engine/commands/calibration/calibrate_gripper.py

@@ -71,9 +71,7 @@ class CalibrateGripperResult(BaseModel):
 
 
 class CalibrateGripperImplementation(
-    AbstractCommandImpl[
-        CalibrateGripperParams, SuccessData[CalibrateGripperResult, None]
-    ]
+    AbstractCommandImpl[CalibrateGripperParams, SuccessData[CalibrateGripperResult]]
 ):
     """The implementation of a `calibrateGripper` command."""
 
@@ -87,7 +85,7 @@ class CalibrateGripperImplementation(
 
     async def execute(
         self, params: CalibrateGripperParams
-    ) -> SuccessData[CalibrateGripperResult, None]:
+    ) -> SuccessData[CalibrateGripperResult]:
         """Execute a `calibrateGripper` command.
 
         1. Move from the current location to the calibration area on the deck.
@@ -126,7 +124,6 @@ class CalibrateGripperImplementation(
                 ),
                 savedCalibration=calibration_data,
             ),
-            private=None,
         )
 
     @staticmethod

opentrons/protocol_engine/commands/calibration/calibrate_module.py

@@ -12,7 +12,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 # Work around type-only circular dependencies.
 if TYPE_CHECKING:
-    from ...state import StateView
+    from ...state.state import StateView
 
 from ...types import ModuleOffsetVector, DeckSlotLocation
 
@@ -49,7 +49,7 @@ class CalibrateModuleResult(BaseModel):
 
 
 class CalibrateModuleImplementation(
-    AbstractCommandImpl[CalibrateModuleParams, SuccessData[CalibrateModuleResult, None]]
+    AbstractCommandImpl[CalibrateModuleParams, SuccessData[CalibrateModuleResult]]
 ):
     """CalibrateModule command implementation."""
 
@@ -64,7 +64,7 @@ class CalibrateModuleImplementation(
 
     async def execute(
         self, params: CalibrateModuleParams
-    ) -> SuccessData[CalibrateModuleResult, None]:
+    ) -> SuccessData[CalibrateModuleResult]:
         """Execute calibrate-module command."""
         ot3_api = ensure_ot3_hardware(
             self._hardware_api,
@@ -91,7 +91,6 @@ class CalibrateModuleImplementation(
                 ),
                 location=slot,
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/calibration/calibrate_pipette.py

@@ -34,9 +34,7 @@ class CalibratePipetteResult(BaseModel):
 
 
 class CalibratePipetteImplementation(
-    AbstractCommandImpl[
-        CalibratePipetteParams, SuccessData[CalibratePipetteResult, None]
-    ]
+    AbstractCommandImpl[CalibratePipetteParams, SuccessData[CalibratePipetteResult]]
 ):
     """CalibratePipette command implementation."""
 
@@ -49,7 +47,7 @@ class CalibratePipetteImplementation(
 
     async def execute(
         self, params: CalibratePipetteParams
-    ) -> SuccessData[CalibratePipetteResult, None]:
+    ) -> SuccessData[CalibratePipetteResult]:
         """Execute calibrate-pipette command."""
         # TODO (tz, 20-9-22): Add a better solution to determine if a command can be executed on an OT-3/OT-2
         ot3_api = ensure_ot3_hardware(
@@ -72,7 +70,6 @@ class CalibratePipetteImplementation(
                     x=pipette_offset.x, y=pipette_offset.y, z=pipette_offset.z
                 )
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/calibration/move_to_maintenance_position.py

@@ -15,7 +15,7 @@ from opentrons.protocol_engine.resources.ot3_validation import ensure_ot3_hardwa
 
 if TYPE_CHECKING:
     from opentrons.hardware_control import HardwareControlAPI
-    from ...state import StateView
+    from ...state.state import StateView
 
 # These offsets supplied from HW
 _ATTACH_POINT = Point(x=0, y=110)
@@ -57,7 +57,7 @@ class MoveToMaintenancePositionResult(BaseModel):
 class MoveToMaintenancePositionImplementation(
     AbstractCommandImpl[
         MoveToMaintenancePositionParams,
-        SuccessData[MoveToMaintenancePositionResult, None],
+        SuccessData[MoveToMaintenancePositionResult],
     ]
 ):
     """Calibration set up position command implementation."""
@@ -73,7 +73,7 @@ class MoveToMaintenancePositionImplementation(
 
     async def execute(
         self, params: MoveToMaintenancePositionParams
-    ) -> SuccessData[MoveToMaintenancePositionResult, None]:
+    ) -> SuccessData[MoveToMaintenancePositionResult]:
         """Move the requested mount to a maintenance deck slot."""
         ot3_api = ensure_ot3_hardware(
             self._hardware_api,
@@ -118,7 +118,9 @@ class MoveToMaintenancePositionImplementation(
                 )
                 await ot3_api.disengage_axes([Axis.Z_R])
 
-        return SuccessData(public=MoveToMaintenancePositionResult(), private=None)
+        return SuccessData(
+            public=MoveToMaintenancePositionResult(),
+        )
 
 
 class MoveToMaintenancePosition(

opentrons/protocol_engine/commands/command.py

@@ -3,8 +3,8 @@
 
 from __future__ import annotations
 
+import dataclasses
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
 from typing import (
@@ -21,6 +21,7 @@ from pydantic import BaseModel, Field
 from pydantic.generics import GenericModel
 
 from opentrons.hardware_control import HardwareControlAPI
+from opentrons.protocol_engine.state.update_types import StateUpdate
 
 from ..resources import ModelUtils
 from ..errors import ErrorOccurrence
@@ -29,7 +30,7 @@ from ..notes import CommandNote, CommandNoteAdder
 # Work around type-only circular dependencies.
 if TYPE_CHECKING:
     from .. import execution
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 _ParamsT = TypeVar("_ParamsT", bound=BaseModel)
@@ -38,7 +39,6 @@ _ResultT = TypeVar("_ResultT", bound=BaseModel)
 _ResultT_co = TypeVar("_ResultT_co", bound=BaseModel, covariant=True)
 _ErrorT = TypeVar("_ErrorT", bound=ErrorOccurrence)
 _ErrorT_co = TypeVar("_ErrorT_co", bound=ErrorOccurrence, covariant=True)
-_PrivateResultT_co = TypeVar("_PrivateResultT_co", covariant=True)
 
 
 class CommandStatus(str, Enum):
@@ -106,19 +106,23 @@ class BaseCommandCreate(
     )
 
 
-@dataclass(frozen=True)
-class SuccessData(Generic[_ResultT_co, _PrivateResultT_co]):
+@dataclasses.dataclass(frozen=True)
+class SuccessData(Generic[_ResultT_co]):
     """Data from the successful completion of a command."""
 
     public: _ResultT_co
     """Public result data. Exposed over HTTP and stored in databases."""
 
-    private: _PrivateResultT_co
-    """Additional result data, only given to `opentrons.protocol_engine` internals."""
+    state_update: StateUpdate = dataclasses.field(
+        # todo(mm, 2024-08-22): Remove the default once all command implementations
+        # use this, to make it harder to forget in new command implementations.
+        default_factory=StateUpdate
+    )
+    """How the engine state should be updated to reflect this command success."""
 
 
-@dataclass(frozen=True)
-class DefinedErrorData(Generic[_ErrorT_co, _PrivateResultT_co]):
+@dataclasses.dataclass(frozen=True)
+class DefinedErrorData(Generic[_ErrorT_co]):
     """Data from a command that failed with a defined error.
 
     This should only be used for "defined" errors, not any error.
@@ -128,8 +132,16 @@ class DefinedErrorData(Generic[_ErrorT_co, _PrivateResultT_co]):
     public: _ErrorT_co
     """Public error data. Exposed over HTTP and stored in databases."""
 
-    private: _PrivateResultT_co
-    """Additional error data, only given to `opentrons.protocol_engine` internals."""
+    state_update: StateUpdate = dataclasses.field(
+        # todo(mm, 2024-08-22): Remove the default once all command implementations
+        # use this, to make it harder to forget in new command implementations.
+        default_factory=StateUpdate
+    )
+    """How the engine state should be updated to reflect this command failure."""
+
+    state_update_if_false_positive: StateUpdate = dataclasses.field(
+        default_factory=StateUpdate
+    )
 
 
 class BaseCommand(
@@ -219,13 +231,11 @@ class BaseCommand(
                     # Our _ImplementationCls must return public result data that can fit
                     # in our `result` field:
                     _ResultT,
-                    # But we don't care (here) what kind of private result data it returns:
-                    object,
                 ],
                 DefinedErrorData[
-                    # Likewise, for our `error` field:
+                    # Our _ImplementationCls must return public error data that can fit
+                    # in our `error` field:
                     _ErrorT,
-                    object,
                 ],
             ],
         ]
@@ -235,8 +245,8 @@ class BaseCommand(
 _ExecuteReturnT_co = TypeVar(
     "_ExecuteReturnT_co",
     bound=Union[
-        SuccessData[BaseModel, object],
-        DefinedErrorData[ErrorOccurrence, object],
+        SuccessData[BaseModel],
+        DefinedErrorData[ErrorOccurrence],
     ],
     covariant=True,
 )
@@ -258,6 +268,7 @@ class AbstractCommandImpl(
         state_view: StateView,
         hardware_api: HardwareControlAPI,
         equipment: execution.EquipmentHandler,
+        file_provider: execution.FileProvider,
         movement: execution.MovementHandler,
         gantry_mover: execution.GantryMover,
         labware_movement: execution.LabwareMovementHandler,

opentrons/protocol_engine/commands/command_unions.py

@@ -10,9 +10,8 @@ from opentrons.util.get_union_elements import get_union_elements
 from .command import DefinedErrorData
 from .pipetting_common import (
     OverpressureError,
-    OverpressureErrorInternalData,
     LiquidNotFoundError,
-    LiquidNotFoundErrorInternalData,
+    TipPhysicallyAttachedError,
 )
 
 from . import absorbance_reader
@@ -142,10 +141,10 @@ from .load_pipette import (
     LoadPipetteCreate,
     LoadPipetteResult,
     LoadPipetteCommandType,
-    LoadPipettePrivateResult,
 )
 
 from .move_labware import (
+    GripperMovementError,
     MoveLabware,
     MoveLabwareParams,
     MoveLabwareCreate,
@@ -216,7 +215,6 @@ from .pick_up_tip import (
     PickUpTipResult,
     PickUpTipCommandType,
     TipPhysicallyMissingError,
-    TipPhysicallyMissingErrorInternalData,
 )
 
 from .touch_tip import (
@@ -273,7 +271,6 @@ from .configure_for_volume import (
     ConfigureForVolumeCreate,
     ConfigureForVolumeResult,
     ConfigureForVolumeCommandType,
-    ConfigureForVolumePrivateResult,
 )
 
 from .prepare_to_aspirate import (
@@ -290,7 +287,6 @@ from .configure_nozzle_layout import (
     ConfigureNozzleLayoutParams,
     ConfigureNozzleLayoutResult,
     ConfigureNozzleLayoutCommandType,
-    ConfigureNozzleLayoutPrivateResult,
 )
 
 from .verify_tip_presence import (
@@ -382,8 +378,11 @@ Command = Annotated[
         thermocycler.OpenLid,
         thermocycler.CloseLid,
         thermocycler.RunProfile,
+        thermocycler.RunExtendedProfile,
+        absorbance_reader.CloseLid,
+        absorbance_reader.OpenLid,
         absorbance_reader.Initialize,
-        absorbance_reader.MeasureAbsorbance,
+        absorbance_reader.ReadAbsorbance,
         calibration.CalibrateGripper,
         calibration.CalibratePipette,
         calibration.CalibrateModule,
@@ -392,6 +391,8 @@ Command = Annotated[
         unsafe.UnsafeDropTipInPlace,
         unsafe.UpdatePositionEstimators,
         unsafe.UnsafeEngageAxes,
+        unsafe.UnsafeUngripLabware,
+        unsafe.UnsafePlaceLabware,
     ],
     Field(discriminator="commandType"),
 ]
@@ -455,8 +456,11 @@ CommandParams = Union[
     thermocycler.OpenLidParams,
     thermocycler.CloseLidParams,
     thermocycler.RunProfileParams,
+    thermocycler.RunExtendedProfileParams,
+    absorbance_reader.CloseLidParams,
+    absorbance_reader.OpenLidParams,
     absorbance_reader.InitializeParams,
-    absorbance_reader.MeasureAbsorbanceParams,
+    absorbance_reader.ReadAbsorbanceParams,
     calibration.CalibrateGripperParams,
     calibration.CalibratePipetteParams,
     calibration.CalibrateModuleParams,
@@ -465,6 +469,8 @@ CommandParams = Union[
     unsafe.UnsafeDropTipInPlaceParams,
     unsafe.UpdatePositionEstimatorsParams,
     unsafe.UnsafeEngageAxesParams,
+    unsafe.UnsafeUngripLabwareParams,
+    unsafe.UnsafePlaceLabwareParams,
 ]
 
 CommandType = Union[
@@ -526,8 +532,11 @@ CommandType = Union[
     thermocycler.OpenLidCommandType,
     thermocycler.CloseLidCommandType,
     thermocycler.RunProfileCommandType,
+    thermocycler.RunExtendedProfileCommandType,
+    absorbance_reader.CloseLidCommandType,
+    absorbance_reader.OpenLidCommandType,
     absorbance_reader.InitializeCommandType,
-    absorbance_reader.MeasureAbsorbanceCommandType,
+    absorbance_reader.ReadAbsorbanceCommandType,
     calibration.CalibrateGripperCommandType,
     calibration.CalibratePipetteCommandType,
     calibration.CalibrateModuleCommandType,
@@ -536,6 +545,8 @@ CommandType = Union[
     unsafe.UnsafeDropTipInPlaceCommandType,
     unsafe.UpdatePositionEstimatorsCommandType,
     unsafe.UnsafeEngageAxesCommandType,
+    unsafe.UnsafeUngripLabwareCommandType,
+    unsafe.UnsafePlaceLabwareCommandType,
 ]
 
 CommandCreate = Annotated[
@@ -598,8 +609,11 @@ CommandCreate = Annotated[
         thermocycler.OpenLidCreate,
         thermocycler.CloseLidCreate,
         thermocycler.RunProfileCreate,
+        thermocycler.RunExtendedProfileCreate,
+        absorbance_reader.CloseLidCreate,
+        absorbance_reader.OpenLidCreate,
         absorbance_reader.InitializeCreate,
-        absorbance_reader.MeasureAbsorbanceCreate,
+        absorbance_reader.ReadAbsorbanceCreate,
         calibration.CalibrateGripperCreate,
         calibration.CalibratePipetteCreate,
         calibration.CalibrateModuleCreate,
@@ -608,6 +622,8 @@ CommandCreate = Annotated[
         unsafe.UnsafeDropTipInPlaceCreate,
         unsafe.UpdatePositionEstimatorsCreate,
         unsafe.UnsafeEngageAxesCreate,
+        unsafe.UnsafeUngripLabwareCreate,
+        unsafe.UnsafePlaceLabwareCreate,
     ],
     Field(discriminator="commandType"),
 ]
@@ -671,8 +687,11 @@ CommandResult = Union[
     thermocycler.OpenLidResult,
     thermocycler.CloseLidResult,
     thermocycler.RunProfileResult,
+    thermocycler.RunExtendedProfileResult,
+    absorbance_reader.CloseLidResult,
+    absorbance_reader.OpenLidResult,
     absorbance_reader.InitializeResult,
-    absorbance_reader.MeasureAbsorbanceResult,
+    absorbance_reader.ReadAbsorbanceResult,
     calibration.CalibrateGripperResult,
     calibration.CalibratePipetteResult,
     calibration.CalibrateModuleResult,
@@ -681,24 +700,18 @@ CommandResult = Union[
     unsafe.UnsafeDropTipInPlaceResult,
     unsafe.UpdatePositionEstimatorsResult,
     unsafe.UnsafeEngageAxesResult,
+    unsafe.UnsafeUngripLabwareResult,
+    unsafe.UnsafePlaceLabwareResult,
 ]
 
-# todo(mm, 2024-06-12): Ideally, command return types would have specific
-# CommandPrivateResults paired with specific CommandResults. For example,
-# a TouchTipResult can never be paired with a LoadPipettePrivateResult in practice,
-# and ideally our types would reflect that.
-CommandPrivateResult = Union[
-    None,
-    LoadPipettePrivateResult,
-    ConfigureForVolumePrivateResult,
-    ConfigureNozzleLayoutPrivateResult,
-]
 
 # All `DefinedErrorData`s that implementations will actually return in practice.
 CommandDefinedErrorData = Union[
-    DefinedErrorData[TipPhysicallyMissingError, TipPhysicallyMissingErrorInternalData],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
-    DefinedErrorData[LiquidNotFoundError, LiquidNotFoundErrorInternalData],
+    DefinedErrorData[TipPhysicallyMissingError],
+    DefinedErrorData[TipPhysicallyAttachedError],
+    DefinedErrorData[OverpressureError],
+    DefinedErrorData[LiquidNotFoundError],
+    DefinedErrorData[GripperMovementError],
 ]
 
 

opentrons/protocol_engine/commands/comment.py

@@ -24,16 +24,18 @@ class CommentResult(BaseModel):
 
 
 class CommentImplementation(
-    AbstractCommandImpl[CommentParams, SuccessData[CommentResult, None]]
+    AbstractCommandImpl[CommentParams, SuccessData[CommentResult]]
 ):
     """Comment command implementation."""
 
     def __init__(self, **kwargs: object) -> None:
         pass
 
-    async def execute(self, params: CommentParams) -> SuccessData[CommentResult, None]:
+    async def execute(self, params: CommentParams) -> SuccessData[CommentResult]:
         """No operation taken other than capturing message in command."""
-        return SuccessData(public=CommentResult(), private=None)
+        return SuccessData(
+            public=CommentResult(),
+        )
 
 
 class Comment(BaseCommand[CommentParams, CommentResult, ErrorOccurrence]):