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

opentrons/protocol_engine/commands/custom.py

@@ -10,7 +10,7 @@ data still adheres to the shapes that ProtocolEngine expects.
 If you are implementing a custom command, you should probably
 put your own disambiguation identifier in the payload.
 """
-from pydantic import BaseModel, Extra
+from pydantic import ConfigDict, BaseModel, SerializeAsAny
 from typing import Optional, Type
 from typing_extensions import Literal
 
@@ -24,19 +24,13 @@ CustomCommandType = Literal["custom"]
 class CustomParams(BaseModel):
     """Payload used by a custom command."""
 
-    class Config:
-        """Allow arbitrary fields."""
-
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class CustomResult(BaseModel):
     """Result data from a custom command."""
 
-    class Config:
-        """Allow arbitrary fields."""
-
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class CustomImplementation(
@@ -50,7 +44,7 @@ class CustomImplementation(
     async def execute(self, params: CustomParams) -> SuccessData[CustomResult]:
         """A custom command does nothing when executed directly."""
         return SuccessData(
-            public=CustomResult.construct(),
+            public=CustomResult.model_construct(),
         )
 
 
@@ -58,8 +52,8 @@ class Custom(BaseCommand[CustomParams, CustomResult, ErrorOccurrence]):
     """Custom command model."""
 
     commandType: CustomCommandType = "custom"
-    params: CustomParams
-    result: Optional[CustomResult]
+    params: SerializeAsAny[CustomParams]
+    result: Optional[CustomResult] = None
 
     _ImplementationCls: Type[CustomImplementation] = CustomImplementation
 

opentrons/protocol_engine/commands/dispense.py

@@ -1,22 +1,27 @@
 """Dispense command request, result, and implementation models."""
+
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, Optional, Type, Union, Any
 from typing_extensions import Literal
 
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
 
 from pydantic import Field
+from pydantic.json_schema import SkipJsonSchema
 
-from ..types import DeckPoint
 from ..state.update_types import StateUpdate, CLEAR
 from .pipetting_common import (
     PipetteIdMixin,
     DispenseVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
-    DestinationPositionResult,
     OverpressureError,
+    dispense_in_place,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
+    DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -25,7 +30,6 @@ from .command import (
     DefinedErrorData,
     SuccessData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
@@ -36,14 +40,19 @@ if TYPE_CHECKING:
 DispenseCommandType = Literal["dispense"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DispenseParams(
     PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
 ):
     """Payload required to dispense to a specific well."""
 
-    pushOut: Optional[float] = Field(
+    pushOut: float | SkipJsonSchema[None] = Field(
         None,
         description="push the plunger a small amount farther than necessary for accurate low-volume dispensing",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -55,7 +64,7 @@ class DispenseResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 _ExecuteReturn = Union[
     SuccessData[DispenseResult],
-    DefinedErrorData[OverpressureError],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
 ]
 
 
@@ -77,7 +86,6 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
 
     async def execute(self, params: DispenseParams) -> _ExecuteReturn:
         """Move to and dispense to the requested well."""
-        state_update = StateUpdate()
         well_location = params.wellLocation
         labware_id = params.labwareId
         well_name = params.wellName
@@ -85,66 +93,92 @@ class DispenseImplementation(AbstractCommandImpl[DispenseParams, _ExecuteReturn]
 
         # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
 
-        position = await self._movement.move_to_well(
+        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,
         )
-        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
-        state_update.set_pipette_location(
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+        dispense_result = await dispense_in_place(
             pipette_id=params.pipetteId,
-            new_labware_id=labware_id,
-            new_well_name=well_name,
-            new_deck_point=deck_point,
+            volume=volume,
+            flow_rate=params.flowRate,
+            push_out=params.pushOut,
+            location_if_error={
+                "retryLocation": (
+                    move_result.public.position.x,
+                    move_result.public.position.y,
+                    move_result.public.position.z,
+                )
+            },
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
         )
 
-        try:
-            volume = await self._pipetting.dispense_in_place(
-                pipette_id=params.pipetteId,
-                volume=volume,
-                flow_rate=params.flowRate,
-                push_out=params.pushOut,
-            )
-        except PipetteOverpressureError as e:
-            state_update.set_liquid_operated(
-                labware_id=labware_id,
-                well_name=well_name,
-                volume_added=CLEAR,
-            )
+        if isinstance(dispense_result, DefinedErrorData):
             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": (position.x, position.y, position.z)},
+                public=dispense_result.public,
+                state_update=(
+                    StateUpdate.reduce(
+                        move_result.state_update, dispense_result.state_update
+                    ).set_liquid_operated(
+                        labware_id=labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            labware_id, well_name, params.pipetteId
+                        ),
+                        volume_added=CLEAR,
+                    )
+                ),
+                state_update_if_false_positive=StateUpdate.reduce(
+                    move_result.state_update,
+                    dispense_result.state_update_if_false_positive,
                 ),
-                state_update=state_update,
             )
         else:
-            state_update.set_liquid_operated(
-                labware_id=labware_id,
-                well_name=well_name,
-                volume_added=volume,
+            volume_added = (
+                self._state_view.pipettes.get_liquid_dispensed_by_ejecting_volume(
+                    pipette_id=params.pipetteId, volume=dispense_result.public.volume
+                )
             )
+            if volume_added is not None:
+                volume_added *= self._state_view.geometry.get_nozzles_per_well(
+                    labware_id, well_name, params.pipetteId
+                )
             return SuccessData(
-                public=DispenseResult(volume=volume, position=deck_point),
-                state_update=state_update,
+                public=DispenseResult(
+                    volume=dispense_result.public.volume,
+                    position=move_result.public.position,
+                ),
+                state_update=(
+                    StateUpdate.reduce(
+                        move_result.state_update, dispense_result.state_update
+                    ).set_liquid_operated(
+                        labware_id=labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            labware_id, well_name, params.pipetteId
+                        ),
+                        volume_added=volume_added
+                        if volume_added is not None
+                        else CLEAR,
+                    )
+                ),
             )
 
 
-class Dispense(BaseCommand[DispenseParams, DispenseResult, OverpressureError]):
+class Dispense(
+    BaseCommand[
+        DispenseParams, DispenseResult, OverpressureError | StallOrCollisionError
+    ]
+):
     """Dispense command model."""
 
     commandType: DispenseCommandType = "dispense"
     params: DispenseParams
-    result: Optional[DispenseResult]
+    result: Optional[DispenseResult] = None
 
     _ImplementationCls: Type[DispenseImplementation] = DispenseImplementation
 

opentrons/protocol_engine/commands/dispense_in_place.py

@@ -1,10 +1,10 @@
 """Dispense-in-place command request, result, and implementation models."""
+
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type, Union
+from typing import TYPE_CHECKING, Optional, Type, Union, Any
 from typing_extensions import Literal
 from pydantic import Field
-
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+from pydantic.json_schema import SkipJsonSchema
 
 from .pipetting_common import (
     PipetteIdMixin,
@@ -12,6 +12,7 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
+    dispense_in_place,
 )
 from .command import (
     AbstractCommandImpl,
@@ -20,8 +21,7 @@ from .command import (
     SuccessData,
     DefinedErrorData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
-from ..state.update_types import StateUpdate, CLEAR
+from ..state.update_types import CLEAR
 from ..types import CurrentWell
 
 if TYPE_CHECKING:
@@ -33,12 +33,17 @@ if TYPE_CHECKING:
 DispenseInPlaceCommandType = Literal["dispenseInPlace"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class DispenseInPlaceParams(PipetteIdMixin, DispenseVolumeMixin, FlowRateMixin):
     """Payload required to dispense in place."""
 
-    pushOut: Optional[float] = Field(
+    pushOut: float | SkipJsonSchema[None] = Field(
         None,
         description="push the plunger a small amount farther than necessary for accurate low-volume dispensing",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -74,63 +79,78 @@ class DispenseInPlaceImplementation(
 
     async def execute(self, params: DispenseInPlaceParams) -> _ExecuteReturn:
         """Dispense without moving the pipette."""
-        state_update = StateUpdate()
         current_location = self._state_view.pipettes.get_current_location()
         current_position = await self._gantry_mover.get_position(params.pipetteId)
-        try:
-            volume = await self._pipetting.dispense_in_place(
-                pipette_id=params.pipetteId,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                push_out=params.pushOut,
-            )
-        except PipetteOverpressureError as e:
+        result = await dispense_in_place(
+            pipette_id=params.pipetteId,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            push_out=params.pushOut,
+            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):
             if (
                 isinstance(current_location, CurrentWell)
                 and current_location.pipette_id == params.pipetteId
             ):
-                state_update.set_liquid_operated(
-                    labware_id=current_location.labware_id,
-                    well_name=current_location.well_name,
-                    volume_added=CLEAR,
-                )
-            return DefinedErrorData(
-                public=OverpressureError(
-                    id=self._model_utils.generate_id(),
-                    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,
-                            )
-                        }
+                return DefinedErrorData(
+                    public=result.public,
+                    state_update=result.state_update.set_liquid_operated(
+                        labware_id=current_location.labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                        volume_added=CLEAR,
                     ),
-                ),
-                state_update=state_update,
-            )
+                    state_update_if_false_positive=result.state_update_if_false_positive,
+                )
+            else:
+                return result
         else:
             if (
                 isinstance(current_location, CurrentWell)
                 and current_location.pipette_id == params.pipetteId
             ):
-                state_update.set_liquid_operated(
-                    labware_id=current_location.labware_id,
-                    well_name=current_location.well_name,
-                    volume_added=volume,
+                volume_added = (
+                    self._state_view.pipettes.get_liquid_dispensed_by_ejecting_volume(
+                        pipette_id=params.pipetteId, volume=result.public.volume
+                    )
+                )
+                if volume_added is not None:
+                    volume_added *= self._state_view.geometry.get_nozzles_per_well(
+                        current_location.labware_id,
+                        current_location.well_name,
+                        params.pipetteId,
+                    )
+                return SuccessData(
+                    public=DispenseInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update.set_liquid_operated(
+                        labware_id=current_location.labware_id,
+                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                        volume_added=volume_added
+                        if volume_added is not None
+                        else CLEAR,
+                    ),
+                )
+            else:
+                return SuccessData(
+                    public=DispenseInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update,
                 )
-            return SuccessData(
-                public=DispenseInPlaceResult(volume=volume),
-                state_update=state_update,
-            )
 
 
 class DispenseInPlace(
@@ -140,7 +160,7 @@ class DispenseInPlace(
 
     commandType: DispenseInPlaceCommandType = "dispenseInPlace"
     params: DispenseInPlaceParams
-    result: Optional[DispenseInPlaceResult]
+    result: Optional[DispenseInPlaceResult] = None
 
     _ImplementationCls: Type[
         DispenseInPlaceImplementation

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,7 +1,10 @@
 """Drop tip in place command request, result, and implementation models."""
 from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import Field, BaseModel
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from .command import (
@@ -24,16 +27,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,
     )
 
 
@@ -79,6 +87,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(),
@@ -97,6 +106,7 @@ class DropTipInPlaceImplementation(
                 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
             )
@@ -110,7 +120,7 @@ class DropTipInPlace(
 
     commandType: DropTipInPlaceCommandType = "dropTipInPlace"
     params: DropTipInPlaceParams
-    result: Optional[DropTipInPlaceResult]
+    result: Optional[DropTipInPlaceResult] = None
 
     _ImplementationCls: Type[
         DropTipInPlaceImplementation