opentrons 8.3.0a1__py2.py3-none-any.whl → 8.3.0a4__py2.py3-none-any.whl

opentrons/protocol_engine/commands/evotip_unseal_pipette.py

@@ -0,0 +1,160 @@
+"""Unseal evotip resin tip command request, result, and implementation models."""
+
+from __future__ import annotations
+
+from pydantic import Field
+from typing import TYPE_CHECKING, Optional, Type
+from typing_extensions import Literal
+
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
+from opentrons.protocol_engine.errors import UnsupportedLabwareForActionError
+from opentrons.protocol_engine.types import MotorAxis
+from opentrons.types import MountType
+
+from ..types import DropTipWellLocation
+from .pipetting_common import (
+    PipetteIdMixin,
+)
+from .movement_common import (
+    DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
+)
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
+from ..resources import labware_validation
+
+if TYPE_CHECKING:
+    from ..state.state import StateView
+    from ..execution import MovementHandler, TipHandler, GantryMover
+
+
+EvotipUnsealPipetteCommandType = Literal["evotipUnsealPipette"]
+
+
+class EvotipUnsealPipetteParams(PipetteIdMixin):
+    """Payload required to drop a tip in a specific well."""
+
+    labwareId: str = Field(..., description="Identifier of labware to use.")
+    wellName: str = Field(..., description="Name of well to use in labware.")
+    wellLocation: DropTipWellLocation = Field(
+        default_factory=DropTipWellLocation,
+        description="Relative well location at which to drop the tip.",
+    )
+
+
+class EvotipUnsealPipetteResult(DestinationPositionResult):
+    """Result data from the execution of a DropTip command."""
+
+    pass
+
+
+_ExecuteReturn = (
+    SuccessData[EvotipUnsealPipetteResult] | DefinedErrorData[StallOrCollisionError]
+)
+
+
+class EvotipUnsealPipetteImplementation(
+    AbstractCommandImpl[EvotipUnsealPipetteParams, _ExecuteReturn]
+):
+    """Drop tip command implementation."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        tip_handler: TipHandler,
+        movement: MovementHandler,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
+        **kwargs: object,
+    ) -> None:
+        self._state_view = state_view
+        self._tip_handler = tip_handler
+        self._movement_handler = movement
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
+
+    async def execute(self, params: EvotipUnsealPipetteParams) -> _ExecuteReturn:
+        """Move to and drop a tip using the requested pipette."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        well_location = params.wellLocation
+        labware_definition = self._state_view.labware.get_definition(params.labwareId)
+        if not labware_validation.is_evotips(labware_definition.parameters.loadName):
+            raise UnsupportedLabwareForActionError(
+                f"Cannot use command: `EvotipUnsealPipette` with labware: {labware_definition.parameters.loadName}"
+            )
+        is_partially_configured = self._state_view.pipettes.get_is_partially_configured(
+            pipette_id=pipette_id
+        )
+        tip_drop_location = self._state_view.geometry.get_checked_tip_drop_location(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_location=well_location,
+            partially_configured=is_partially_configured,
+        )
+
+        move_result = await move_to_well(
+            movement=self._movement_handler,
+            model_utils=self._model_utils,
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=tip_drop_location,
+        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+
+        # Move to an appropriate position
+        mount = self._state_view.pipettes.get_mount(pipette_id)
+
+        mount_axis = MotorAxis.LEFT_Z if mount == MountType.LEFT else MotorAxis.RIGHT_Z
+        await self._gantry_mover.move_axes(
+            axis_map={mount_axis: -14}, speed=10, relative_move=True
+        )
+
+        await self._tip_handler.drop_tip(
+            pipette_id=pipette_id,
+            home_after=None,
+            do_not_ignore_tip_presence=False,
+            ignore_plunger=True,
+        )
+
+        return SuccessData(
+            public=EvotipUnsealPipetteResult(position=move_result.public.position),
+            state_update=move_result.state_update.set_fluid_unknown(
+                pipette_id=pipette_id
+            ).update_pipette_tip_state(pipette_id=params.pipetteId, tip_geometry=None),
+        )
+
+
+class EvotipUnsealPipette(
+    BaseCommand[
+        EvotipUnsealPipetteParams, EvotipUnsealPipetteResult, StallOrCollisionError
+    ]
+):
+    """Evotip unseal command model."""
+
+    commandType: EvotipUnsealPipetteCommandType = "evotipUnsealPipette"
+    params: EvotipUnsealPipetteParams
+    result: Optional[EvotipUnsealPipetteResult] = None
+
+    _ImplementationCls: Type[
+        EvotipUnsealPipetteImplementation
+    ] = EvotipUnsealPipetteImplementation
+
+
+class EvotipUnsealPipetteCreate(BaseCommandCreate[EvotipUnsealPipetteParams]):
+    """Evotip unseal command creation request model."""
+
+    commandType: EvotipUnsealPipetteCommandType = "evotipUnsealPipette"
+    params: EvotipUnsealPipetteParams
+
+    _CommandCls: Type[EvotipUnsealPipette] = EvotipUnsealPipette

opentrons/protocol_engine/commands/get_next_tip.py

@@ -120,7 +120,7 @@ class GetNextTip(BaseCommand[GetNextTipParams, GetNextTipResult, ErrorOccurrence
 
     commandType: GetNextTipCommandType = "getNextTip"
     params: GetNextTipParams
-    result: Optional[GetNextTipResult]
+    result: Optional[GetNextTipResult] = None
 
     _ImplementationCls: Type[GetNextTipImplementation] = GetNextTipImplementation
 

opentrons/protocol_engine/commands/liquid_probe.py

@@ -19,12 +19,14 @@ from opentrons.types import MountType
 from opentrons_shared_data.errors.exceptions import (
     PipetteLiquidNotFoundError,
     UnsupportedHardwareCommand,
+    PipetteOverpressureError,
 )
 
 from ..types import DeckPoint
 from .pipetting_common import (
     LiquidNotFoundError,
     PipetteIdMixin,
+    OverpressureError,
 )
 from .movement_common import (
     WellLocationMixin,
@@ -43,7 +45,7 @@ from .command import (
 from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
-    from ..execution import MovementHandler, PipettingHandler
+    from ..execution import MovementHandler, PipettingHandler, GantryMover
     from ..resources import ModelUtils
     from ..state.state import StateView
 
@@ -99,10 +101,14 @@ class TryLiquidProbeResult(DestinationPositionResult):
 
 _LiquidProbeExecuteReturn = Union[
     SuccessData[LiquidProbeResult],
-    DefinedErrorData[LiquidNotFoundError] | DefinedErrorData[StallOrCollisionError],
+    DefinedErrorData[LiquidNotFoundError]
+    | DefinedErrorData[StallOrCollisionError]
+    | DefinedErrorData[OverpressureError],
 ]
 _TryLiquidProbeExecuteReturn = (
-    SuccessData[TryLiquidProbeResult] | DefinedErrorData[StallOrCollisionError]
+    SuccessData[TryLiquidProbeResult]
+    | DefinedErrorData[StallOrCollisionError]
+    | DefinedErrorData[OverpressureError]
 )
 
 
@@ -110,19 +116,22 @@ 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
+    z_pos_or_error: float | PipetteLiquidNotFoundError | PipetteOverpressureError
 
     state_update: update_types.StateUpdate
     deck_point: DeckPoint
 
 
-async def _execute_common(
+async def _execute_common(  # noqa: C901
     state_view: StateView,
     movement: MovementHandler,
+    gantry_mover: GantryMover,
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
     params: _CommonParams,
-) -> _ExecuteCommonResult | DefinedErrorData[StallOrCollisionError]:
+) -> _ExecuteCommonResult | DefinedErrorData[StallOrCollisionError] | DefinedErrorData[
+    OverpressureError
+]:
     pipette_id = params.pipetteId
     labware_id = params.labwareId
     well_name = params.wellName
@@ -173,6 +182,7 @@ async def _execute_common(
     if isinstance(move_result, DefinedErrorData):
         return move_result
     try:
+        current_position = await gantry_mover.get_position(params.pipetteId)
         z_pos = await pipetting.liquid_probe_in_place(
             pipette_id=pipette_id,
             labware_id=labware_id,
@@ -185,6 +195,33 @@ async def _execute_common(
             state_update=move_result.state_update,
             deck_point=move_result.public.position,
         )
+    except PipetteOverpressureError as e:
+        return DefinedErrorData(
+            public=OverpressureError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+                errorInfo=(
+                    {
+                        # This is here bc its not optional in the type but we are not using the retry location for this case
+                        "retryLocation": (
+                            current_position.x,
+                            current_position.y,
+                            current_position.z,
+                        )
+                    }
+                ),
+            ),
+            state_update=move_result.state_update.set_fluid_unknown(
+                pipette_id=pipette_id
+            ),
+        )
     else:
         return _ExecuteCommonResult(
             z_pos_or_error=z_pos,
@@ -202,12 +239,14 @@ class LiquidProbeImplementation(
         self,
         state_view: StateView,
         movement: MovementHandler,
+        gantry_mover: GantryMover,
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
+        self._gantry_mover = gantry_mover
         self._pipetting = pipetting
         self._model_utils = model_utils
 
@@ -230,6 +269,7 @@ class LiquidProbeImplementation(
         result = await _execute_common(
             state_view=self._state_view,
             movement=self._movement,
+            gantry_mover=self._gantry_mover,
             pipetting=self._pipetting,
             model_utils=self._model_utils,
             params=params,
@@ -237,7 +277,9 @@ class LiquidProbeImplementation(
         if isinstance(result, DefinedErrorData):
             return result
         z_pos_or_error, state_update, deck_point = result
-        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+        if isinstance(
+            z_pos_or_error, (PipetteLiquidNotFoundError, PipetteOverpressureError)
+        ):
             state_update.set_liquid_probed(
                 labware_id=params.labwareId,
                 well_name=params.wellName,
@@ -294,12 +336,14 @@ class TryLiquidProbeImplementation(
         self,
         state_view: StateView,
         movement: MovementHandler,
+        gantry_mover: GantryMover,
         pipetting: PipettingHandler,
         model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._state_view = state_view
         self._movement = movement
+        self._gantry_mover = gantry_mover
         self._pipetting = pipetting
         self._model_utils = model_utils
 
@@ -313,6 +357,7 @@ class TryLiquidProbeImplementation(
         result = await _execute_common(
             state_view=self._state_view,
             movement=self._movement,
+            gantry_mover=self._gantry_mover,
             pipetting=self._pipetting,
             model_utils=self._model_utils,
             params=params,
@@ -321,7 +366,9 @@ class TryLiquidProbeImplementation(
             return result
         z_pos_or_error, state_update, deck_point = result
 
-        if isinstance(z_pos_or_error, PipetteLiquidNotFoundError):
+        if isinstance(
+            z_pos_or_error, (PipetteLiquidNotFoundError, PipetteOverpressureError)
+        ):
             z_pos = None
             well_volume: float | update_types.ClearType = update_types.CLEAR
         else:
@@ -354,26 +401,30 @@ class LiquidProbe(
     BaseCommand[
         LiquidProbeParams,
         LiquidProbeResult,
-        LiquidNotFoundError | StallOrCollisionError,
+        LiquidNotFoundError | StallOrCollisionError | OverpressureError,
     ]
 ):
     """The model for a full `liquidProbe` command."""
 
     commandType: LiquidProbeCommandType = "liquidProbe"
     params: LiquidProbeParams
-    result: Optional[LiquidProbeResult]
+    result: Optional[LiquidProbeResult] = None
 
     _ImplementationCls: Type[LiquidProbeImplementation] = LiquidProbeImplementation
 
 
 class TryLiquidProbe(
-    BaseCommand[TryLiquidProbeParams, TryLiquidProbeResult, StallOrCollisionError]
+    BaseCommand[
+        TryLiquidProbeParams,
+        TryLiquidProbeResult,
+        StallOrCollisionError | OverpressureError,
+    ]
 ):
     """The model for a full `tryLiquidProbe` command."""
 
     commandType: TryLiquidProbeCommandType = "tryLiquidProbe"
     params: TryLiquidProbeParams
-    result: Optional[TryLiquidProbeResult]
+    result: Optional[TryLiquidProbeResult] = None
 
     _ImplementationCls: Type[
         TryLiquidProbeImplementation

opentrons/protocol_engine/commands/load_labware.py

@@ -192,6 +192,11 @@ class LoadLabwareImplementation(
                 self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
                     loaded_labware.definition
                 )
+
+        self._state_view.labware.raise_if_labware_cannot_be_ondeck(
+            location=params.location, labware_definition=loaded_labware.definition
+        )
+
         return SuccessData(
             public=LoadLabwareResult(
                 labwareId=loaded_labware.labware_id,

opentrons/protocol_engine/commands/load_lid.py

@@ -132,7 +132,7 @@ class LoadLid(BaseCommand[LoadLidParams, LoadLidResult, ErrorOccurrence]):
 
     commandType: LoadLidCommandType = "loadLid"
     params: LoadLidParams
-    result: Optional[LoadLidResult]
+    result: Optional[LoadLidResult] = None
 
     _ImplementationCls: Type[LoadLidImplementation] = LoadLidImplementation
 

opentrons/protocol_engine/commands/load_lid_stack.py

@@ -175,7 +175,7 @@ class LoadLidStack(
 
     commandType: LoadLidStackCommandType = "loadLidStack"
     params: LoadLidStackParams
-    result: Optional[LoadLidStackResult]
+    result: Optional[LoadLidStackResult] = None
 
     _ImplementationCls: Type[LoadLidStackImplementation] = LoadLidStackImplementation
 

opentrons/protocol_engine/commands/load_liquid_class.py

@@ -128,7 +128,7 @@ class LoadLiquidClass(
 
     commandType: LoadLiquidClassCommandType = "loadLiquidClass"
     params: LoadLiquidClassParams
-    result: Optional[LoadLiquidClassResult]
+    result: Optional[LoadLiquidClassResult] = None
 
     _ImplementationCls: Type[
         LoadLiquidClassImplementation

opentrons/protocol_engine/commands/move_labware.py

@@ -223,6 +223,15 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
         self._state_view.labware.raise_if_labware_has_labware_on_top(
             labware_id=params.labwareId
         )
+
+        if isinstance(available_new_location, DeckSlotLocation):
+            self._state_view.labware.raise_if_labware_cannot_be_ondeck(
+                location=available_new_location,
+                labware_definition=self._state_view.labware.get_definition(
+                    params.labwareId
+                ),
+            )
+
         if isinstance(available_new_location, OnLabwareLocation):
             self._state_view.labware.raise_if_labware_has_labware_on_top(
                 available_new_location.labwareId

opentrons/protocol_engine/commands/robot/close_gripper_jaw.py

@@ -70,7 +70,7 @@ class closeGripperJaw(
 
     commandType: closeGripperJawCommandType = "robot/closeGripperJaw"
     params: closeGripperJawParams
-    result: Optional[closeGripperJawResult]
+    result: Optional[closeGripperJawResult] = None
 
     _ImplementationCls: Type[
         closeGripperJawImplementation

opentrons/protocol_engine/commands/robot/move_axes_relative.py

@@ -85,7 +85,7 @@ class MoveAxesRelative(
 
     commandType: MoveAxesRelativeCommandType = "robot/moveAxesRelative"
     params: MoveAxesRelativeParams
-    result: Optional[MoveAxesRelativeResult]
+    result: Optional[MoveAxesRelativeResult] = None
 
     _ImplementationCls: Type[
         MoveAxesRelativeImplementation

opentrons/protocol_engine/commands/robot/move_axes_to.py

@@ -86,7 +86,7 @@ class MoveAxesTo(BaseCommand[MoveAxesToParams, MoveAxesToResult, ErrorOccurrence
 
     commandType: MoveAxesToCommandType = "robot/moveAxesTo"
     params: MoveAxesToParams
-    result: Optional[MoveAxesToResult]
+    result: Optional[MoveAxesToResult] = None
 
     _ImplementationCls: Type[MoveAxesToImplementation] = MoveAxesToImplementation
 

opentrons/protocol_engine/commands/robot/move_to.py

@@ -80,7 +80,7 @@ class MoveTo(BaseCommand[MoveToParams, MoveToResult, ErrorOccurrence]):
 
     commandType: MoveToCommandType = "robot/moveTo"
     params: MoveToParams
-    result: Optional[MoveToResult]
+    result: Optional[MoveToResult] = None
 
     _ImplementationCls: Type[MoveToImplementation] = MoveToImplementation
 

opentrons/protocol_engine/commands/robot/open_gripper_jaw.py

@@ -61,7 +61,7 @@ class openGripperJaw(
 
     commandType: openGripperJawCommandType = "robot/openGripperJaw"
     params: openGripperJawParams
-    result: Optional[openGripperJawResult]
+    result: Optional[openGripperJawResult] = None
 
     _ImplementationCls: Type[
         openGripperJawImplementation

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -157,7 +157,7 @@ class RunExtendedProfile(
 
     commandType: RunExtendedProfileCommandType = "thermocycler/runExtendedProfile"
     params: RunExtendedProfileParams
-    result: Optional[RunExtendedProfileResult]
+    result: Optional[RunExtendedProfileResult] = None
 
     _ImplementationCls: Type[RunExtendedProfileImpl] = RunExtendedProfileImpl
 

opentrons/protocol_engine/commands/unsafe/unsafe_blow_out_in_place.py

@@ -82,7 +82,7 @@ class UnsafeBlowOutInPlace(
 
     commandType: UnsafeBlowOutInPlaceCommandType = "unsafe/blowOutInPlace"
     params: UnsafeBlowOutInPlaceParams
-    result: Optional[UnsafeBlowOutInPlaceResult]
+    result: Optional[UnsafeBlowOutInPlaceResult] = None
 
     _ImplementationCls: Type[
         UnsafeBlowOutInPlaceImplementation

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -99,7 +99,7 @@ class UnsafeDropTipInPlace(
 
     commandType: UnsafeDropTipInPlaceCommandType = "unsafe/dropTipInPlace"
     params: UnsafeDropTipInPlaceParams
-    result: Optional[UnsafeDropTipInPlaceResult]
+    result: Optional[UnsafeDropTipInPlaceResult] = None
 
     _ImplementationCls: Type[
         UnsafeDropTipInPlaceImplementation

opentrons/protocol_engine/commands/unsafe/unsafe_engage_axes.py

@@ -66,7 +66,7 @@ class UnsafeEngageAxes(
 
     commandType: UnsafeEngageAxesCommandType = "unsafe/engageAxes"
     params: UnsafeEngageAxesParams
-    result: Optional[UnsafeEngageAxesResult]
+    result: Optional[UnsafeEngageAxesResult] = None
 
     _ImplementationCls: Type[
         UnsafeEngageAxesImplementation

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -192,7 +192,7 @@ class UnsafePlaceLabware(
 
     commandType: UnsafePlaceLabwareCommandType = "unsafe/placeLabware"
     params: UnsafePlaceLabwareParams
-    result: Optional[UnsafePlaceLabwareResult]
+    result: Optional[UnsafePlaceLabwareResult] = None
 
     _ImplementationCls: Type[
         UnsafePlaceLabwareImplementation

opentrons/protocol_engine/commands/unsafe/unsafe_ungrip_labware.py

@@ -61,7 +61,7 @@ class UnsafeUngripLabware(
 
     commandType: UnsafeUngripLabwareCommandType = "unsafe/ungripLabware"
     params: UnsafeUngripLabwareParams
-    result: Optional[UnsafeUngripLabwareResult]
+    result: Optional[UnsafeUngripLabwareResult] = None
 
     _ImplementationCls: Type[
         UnsafeUngripLabwareImplementation

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -74,7 +74,7 @@ class UpdatePositionEstimators(
 
     commandType: UpdatePositionEstimatorsCommandType = "unsafe/updatePositionEstimators"
     params: UpdatePositionEstimatorsParams
-    result: Optional[UpdatePositionEstimatorsResult]
+    result: Optional[UpdatePositionEstimatorsResult] = None
 
     _ImplementationCls: Type[
         UpdatePositionEstimatorsImplementation

opentrons/protocol_engine/errors/__init__.py

@@ -11,6 +11,7 @@ from .exceptions import (
     PickUpTipTipNotAttachedError,
     TipAttachedError,
     CommandDoesNotExistError,
+    UnsupportedLabwareForActionError,
     LabwareNotLoadedError,
     LabwareNotLoadedOnModuleError,
     LabwareNotLoadedOnLabwareError,
@@ -18,6 +19,7 @@ from .exceptions import (
     LiquidDoesNotExistError,
     LabwareDefinitionDoesNotExistError,
     LabwareCannotBeStackedError,
+    LabwareCannotSitOnDeckError,
     LabwareIsInStackError,
     LabwareOffsetDoesNotExistError,
     LabwareIsNotTipRackError,
@@ -103,8 +105,10 @@ __all__ = [
     "LabwareNotLoadedOnLabwareError",
     "LabwareNotOnDeckError",
     "LiquidDoesNotExistError",
+    "UnsupportedLabwareForActionError",
     "LabwareDefinitionDoesNotExistError",
     "LabwareCannotBeStackedError",
+    "LabwareCannotSitOnDeckError",
     "LabwareIsInStackError",
     "LabwareOffsetDoesNotExistError",
     "LabwareIsNotTipRackError",

opentrons/protocol_engine/errors/exceptions.py

@@ -283,6 +283,19 @@ class LabwareCannotBeStackedError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class LabwareCannotSitOnDeckError(ProtocolEngineError):
+    """Raised when a labware is incompatible with a deck slot."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a LabwareCannotSitOnDeckError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class LabwareIsInStackError(ProtocolEngineError):
     """Raised when trying to move to or physically interact with a labware that has another labware on top."""
 
@@ -374,6 +387,19 @@ class TouchTipIncompatibleArgumentsError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class UnsupportedLabwareForActionError(ProtocolEngineError):
+    """Raised when trying to use an unsupported labware for a command."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a UnsupportedLabwareForActionError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class WellDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a well that does not exist."""
 

opentrons/protocol_engine/execution/gantry_mover.py

@@ -114,6 +114,7 @@ class GantryMover(TypingProtocol):
         critical_point: Optional[Dict[MotorAxis, float]] = None,
         speed: Optional[float] = None,
         relative_move: bool = False,
+        expect_stalls: bool = False,
     ) -> Dict[MotorAxis, float]:
         """Move a set of axes a given distance."""
         ...
@@ -341,6 +342,7 @@ class HardwareGantryMover(GantryMover):
         critical_point: Optional[Dict[MotorAxis, float]] = None,
         speed: Optional[float] = None,
         relative_move: bool = False,
+        expect_stalls: bool = False,
     ) -> Dict[MotorAxis, float]:
         """Move a set of axes a given distance.
 
@@ -349,6 +351,7 @@ class HardwareGantryMover(GantryMover):
             critical_point: A critical point override for axes
             speed: Optional speed parameter for the move.
             relative_move: Whether the axis map needs to be converted from a relative to absolute move.
+            expect_stalls: Whether it is expected that the move triggers a stall error.
         """
         try:
             pos_hw = self._convert_axis_map_for_hw(axis_map)
@@ -385,6 +388,7 @@ class HardwareGantryMover(GantryMover):
             await self._hardware_api.move_axes(
                 position=absolute_pos,
                 speed=speed,
+                expect_stalls=expect_stalls,
             )
 
         except PositionUnknownError as e:
@@ -588,6 +592,7 @@ class VirtualGantryMover(GantryMover):
         critical_point: Optional[Dict[MotorAxis, float]] = None,
         speed: Optional[float] = None,
         relative_move: bool = False,
+        expect_stalls: bool = False,
     ) -> Dict[MotorAxis, float]:
         """Move the give axes map. No-op in virtual implementation."""
         mount = self.pick_mount_from_axis_map(axis_map)