opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/drop_tip.py

@@ -1,20 +1,27 @@
 """Drop tip command request, result, and implementation models."""
+
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
 
 from pydantic import Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
+
 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 ..state.update_types import StateUpdate
+from ..types import DropTipWellLocation
 from .pipetting_common import (
     PipetteIdMixin,
-    DestinationPositionResult,
     TipPhysicallyAttachedError,
 )
+from .movement_common import (
+    DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
+)
 from .command import (
     AbstractCommandImpl,
     BaseCommand,
@@ -32,6 +39,10 @@ if TYPE_CHECKING:
 DropTipCommandType = Literal["dropTip"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DropTipParams(PipetteIdMixin):
     """Payload required to drop a tip in a specific well."""
 
@@ -41,15 +52,16 @@ class DropTipParams(PipetteIdMixin):
         default_factory=DropTipWellLocation,
         description="Relative well location at which to drop the tip.",
     )
-    homeAfter: Optional[bool] = Field(
+    homeAfter: bool | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Whether to home this pipette's plunger after dropping the tip."
             " You should normally leave this unspecified to let the robot choose"
             " a safe default depending on its hardware."
         ),
+        json_schema_extra=_remove_default,
     )
-    alternateDropLocation: Optional[bool] = Field(
+    alternateDropLocation: bool | SkipJsonSchema[None] = Field(
         False,
         description=(
             "Whether to alternate location where tip is dropped within the labware."
@@ -58,6 +70,7 @@ class DropTipParams(PipetteIdMixin):
             " labware well."
             " If False, the tip will be dropped at the top center of the well."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -68,7 +81,9 @@ class DropTipResult(DestinationPositionResult):
 
 
 _ExecuteReturn = (
-    SuccessData[DropTipResult] | DefinedErrorData[TipPhysicallyAttachedError]
+    SuccessData[DropTipResult]
+    | DefinedErrorData[TipPhysicallyAttachedError]
+    | DefinedErrorData[StallOrCollisionError]
 )
 
 
@@ -95,8 +110,6 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
         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,
@@ -116,19 +129,16 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             partially_configured=is_partially_configured,
         )
 
-        position = await self._movement_handler.move_to_well(
+        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,
         )
-        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,
-        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
 
         try:
             await self._tip_handler.drop_tip(
@@ -145,33 +155,44 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                         error=exception,
                     )
                 ],
-                errorInfo={"retryLocation": position},
-            )
-            state_update_if_false_positive = update_types.StateUpdate()
-            state_update_if_false_positive.update_pipette_tip_state(
-                pipette_id=params.pipetteId, tip_geometry=None
+                errorInfo={
+                    "retryLocation": (
+                        move_result.public.position.x,
+                        move_result.public.position.y,
+                        move_result.public.position.z,
+                    )
+                },
             )
             return DefinedErrorData(
                 public=error,
-                state_update=state_update,
-                state_update_if_false_positive=state_update_if_false_positive,
+                state_update=StateUpdate.reduce(
+                    StateUpdate(), move_result.state_update
+                ).set_fluid_unknown(pipette_id=pipette_id),
+                state_update_if_false_positive=move_result.state_update.update_pipette_tip_state(
+                    pipette_id=params.pipetteId, tip_geometry=None
+                ),
             )
         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,
+                public=DropTipResult(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 DropTip(BaseCommand[DropTipParams, DropTipResult, TipPhysicallyAttachedError]):
+class DropTip(
+    BaseCommand[
+        DropTipParams, DropTipResult, TipPhysicallyAttachedError | StallOrCollisionError
+    ]
+):
     """Drop tip command model."""
 
     commandType: DropTipCommandType = "dropTip"
     params: DropTipParams
-    result: Optional[DropTipResult]
+    result: Optional[DropTipResult] = None
 
     _ImplementationCls: Type[DropTipImplementation] = DropTipImplementation
 

opentrons/protocol_engine/commands/drop_tip_in_place.py

@@ -1,9 +1,17 @@
 """Drop tip in place command request, result, and implementation models."""
 from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Type, Any, Union
+
 from pydantic import Field, BaseModel
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
+from opentrons_shared_data.errors.exceptions import (
+    PipetteOverpressureError,
+    StallOrCollisionDetectedError,
+)
+
 from .command import (
     AbstractCommandImpl,
     BaseCommand,
@@ -11,7 +19,12 @@ from .command import (
     DefinedErrorData,
     SuccessData,
 )
-from .pipetting_common import PipetteIdMixin, TipPhysicallyAttachedError
+from .movement_common import StallOrCollisionError
+from .pipetting_common import (
+    PipetteIdMixin,
+    TipPhysicallyAttachedError,
+    OverpressureError,
+)
 from ..errors.exceptions import TipAttachedError
 from ..errors.error_occurrence import ErrorOccurrence
 from ..resources.model_utils import ModelUtils
@@ -24,16 +37,21 @@ if TYPE_CHECKING:
 DropTipInPlaceCommandType = Literal["dropTipInPlace"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DropTipInPlaceParams(PipetteIdMixin):
     """Payload required to drop a tip in place."""
 
-    homeAfter: Optional[bool] = Field(
+    homeAfter: bool | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Whether to home this pipette's plunger after dropping the tip."
             " You should normally leave this unspecified to let the robot choose"
             " a safe default depending on its hardware."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -43,9 +61,12 @@ class DropTipInPlaceResult(BaseModel):
     pass
 
 
-_ExecuteReturn = (
-    SuccessData[DropTipInPlaceResult] | DefinedErrorData[TipPhysicallyAttachedError]
-)
+_ExecuteReturn = Union[
+    SuccessData[DropTipInPlaceResult]
+    | DefinedErrorData[TipPhysicallyAttachedError]
+    | DefinedErrorData[OverpressureError]
+    | DefinedErrorData[StallOrCollisionError]
+]
 
 
 class DropTipInPlaceImplementation(
@@ -79,6 +100,7 @@ class DropTipInPlaceImplementation(
             state_update_if_false_positive.update_pipette_tip_state(
                 pipette_id=params.pipetteId, tip_geometry=None
             )
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
             error = TipPhysicallyAttachedError(
                 id=self._model_utils.generate_id(),
                 createdAt=self._model_utils.get_timestamp(),
@@ -96,7 +118,52 @@ class DropTipInPlaceImplementation(
                 state_update=state_update,
                 state_update_if_false_positive=state_update_if_false_positive,
             )
+        except PipetteOverpressureError 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
+            )
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
+            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=exception,
+                        )
+                    ],
+                    errorInfo={"retryLocation": retry_location},
+                ),
+                state_update=state_update,
+                state_update_if_false_positive=state_update_if_false_positive,
+            )
+        except StallOrCollisionDetectedError 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
+            )
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
+            return DefinedErrorData(
+                public=StallOrCollisionError(
+                    id=self._model_utils.generate_id(),
+                    createdAt=self._model_utils.get_timestamp(),
+                    wrappedErrors=[
+                        ErrorOccurrence.from_failed(
+                            id=self._model_utils.generate_id(),
+                            createdAt=self._model_utils.get_timestamp(),
+                            error=exception,
+                        )
+                    ],
+                    errorInfo={"retryLocation": retry_location},
+                ),
+                state_update=state_update,
+                state_update_if_false_positive=state_update_if_false_positive,
+            )
         else:
+            state_update.set_fluid_unknown(pipette_id=params.pipetteId)
             state_update.update_pipette_tip_state(
                 pipette_id=params.pipetteId, tip_geometry=None
             )
@@ -104,13 +171,17 @@ class DropTipInPlaceImplementation(
 
 
 class DropTipInPlace(
-    BaseCommand[DropTipInPlaceParams, DropTipInPlaceResult, TipPhysicallyAttachedError]
+    BaseCommand[
+        DropTipInPlaceParams,
+        DropTipInPlaceResult,
+        TipPhysicallyAttachedError | OverpressureError | StallOrCollisionError,
+    ]
 ):
     """Drop tip in place command model."""
 
     commandType: DropTipInPlaceCommandType = "dropTipInPlace"
     params: DropTipInPlaceParams
-    result: Optional[DropTipInPlaceResult]
+    result: Optional[DropTipInPlaceResult] = None
 
     _ImplementationCls: Type[
         DropTipInPlaceImplementation

opentrons/protocol_engine/commands/evotip_dispense.py

@@ -0,0 +1,156 @@
+"""Evotip Dispense-in-place command request, result, and implementation models."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Union
+from typing_extensions import Literal
+
+from opentrons.protocol_engine.errors import UnsupportedLabwareForActionError
+from .pipetting_common import (
+    PipetteIdMixin,
+    FlowRateMixin,
+    DispenseVolumeMixin,
+    BaseLiquidHandlingResult,
+    dispense_in_place,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
+    StallOrCollisionError,
+    move_to_well,
+)
+
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+    DefinedErrorData,
+)
+from ..state.update_types import StateUpdate
+from ..resources import labware_validation
+from ..errors import ProtocolEngineError
+
+if TYPE_CHECKING:
+    from ..execution import PipettingHandler, GantryMover, MovementHandler
+    from ..resources import ModelUtils
+    from ..state.state import StateView
+
+
+EvotipDispenseCommandType = Literal["evotipDispense"]
+
+
+class EvotipDispenseParams(
+    PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
+):
+    """Payload required to dispense in place."""
+
+    pass
+
+
+class EvotipDispenseResult(BaseLiquidHandlingResult):
+    """Result data from the execution of a DispenseInPlace command."""
+
+    pass
+
+
+_ExecuteReturn = Union[
+    SuccessData[EvotipDispenseResult],
+    DefinedErrorData[StallOrCollisionError],
+]
+
+
+class EvotipDispenseImplementation(
+    AbstractCommandImpl[EvotipDispenseParams, _ExecuteReturn]
+):
+    """DispenseInPlace command implementation."""
+
+    def __init__(
+        self,
+        pipetting: PipettingHandler,
+        state_view: StateView,
+        gantry_mover: GantryMover,
+        model_utils: ModelUtils,
+        movement: MovementHandler,
+        **kwargs: object,
+    ) -> None:
+        self._pipetting = pipetting
+        self._state_view = state_view
+        self._gantry_mover = gantry_mover
+        self._model_utils = model_utils
+        self._movement = movement
+
+    async def execute(self, params: EvotipDispenseParams) -> _ExecuteReturn:
+        """Move to and dispense to the requested well."""
+        well_location = params.wellLocation
+        labware_id = params.labwareId
+        well_name = params.wellName
+
+        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: `EvotipDispense` with labware: {labware_definition.parameters.loadName}"
+            )
+        move_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
+            pipette_id=params.pipetteId,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=well_location,
+        )
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+
+        current_position = await self._gantry_mover.get_position(params.pipetteId)
+        result = await dispense_in_place(
+            pipette_id=params.pipetteId,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            push_out=None,
+            location_if_error={
+                "retryLocation": (
+                    current_position.x,
+                    current_position.y,
+                    current_position.z,
+                )
+            },
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
+        )
+        if isinstance(result, DefinedErrorData):
+            # TODO (chb, 2025-01-29): Remove this and the OverpressureError returns once disabled for this function
+            raise ProtocolEngineError(
+                message="Overpressure Error during Resin Tip Dispense Command."
+            )
+        return SuccessData(
+            public=EvotipDispenseResult(volume=result.public.volume),
+            state_update=StateUpdate.reduce(
+                move_result.state_update, result.state_update
+            ),
+        )
+
+
+class EvotipDispense(
+    BaseCommand[
+        EvotipDispenseParams,
+        EvotipDispenseResult,
+        StallOrCollisionError,
+    ]
+):
+    """DispenseInPlace command model."""
+
+    commandType: EvotipDispenseCommandType = "evotipDispense"
+    params: EvotipDispenseParams
+    result: Optional[EvotipDispenseResult] = None
+
+    _ImplementationCls: Type[
+        EvotipDispenseImplementation
+    ] = EvotipDispenseImplementation
+
+
+class EvotipDispenseCreate(BaseCommandCreate[EvotipDispenseParams]):
+    """DispenseInPlace command request model."""
+
+    commandType: EvotipDispenseCommandType = "evotipDispense"
+    params: EvotipDispenseParams
+
+    _CommandCls: Type[EvotipDispense] = EvotipDispense