opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a2__py2.py3-none-any.whl

opentrons/protocol_engine/commands/command_unions.py

@@ -3,7 +3,7 @@
 from collections.abc import Collection
 from typing import Annotated, Type, Union, get_type_hints
 
-from pydantic import Field
+from pydantic import Field, TypeAdapter
 
 from opentrons.util.get_union_elements import get_union_elements
 
@@ -13,6 +13,7 @@ from .pipetting_common import (
     LiquidNotFoundError,
     TipPhysicallyAttachedError,
 )
+from .movement_common import StallOrCollisionError
 
 from . import absorbance_reader
 from . import heater_shaker
@@ -22,6 +23,7 @@ from . import thermocycler
 
 from . import calibration
 from . import unsafe
+from . import robot
 
 from .set_rail_lights import (
     SetRailLights,
@@ -31,6 +33,14 @@ from .set_rail_lights import (
     SetRailLightsResult,
 )
 
+from .air_gap_in_place import (
+    AirGapInPlace,
+    AirGapInPlaceParams,
+    AirGapInPlaceCreate,
+    AirGapInPlaceResult,
+    AirGapInPlaceCommandType,
+)
+
 from .aspirate import (
     Aspirate,
     AspirateParams,
@@ -127,6 +137,14 @@ from .load_liquid import (
     LoadLiquidCommandType,
 )
 
+from .load_liquid_class import (
+    LoadLiquidClass,
+    LoadLiquidClassParams,
+    LoadLiquidClassCreate,
+    LoadLiquidClassResult,
+    LoadLiquidClassCommandType,
+)
+
 from .load_module import (
     LoadModule,
     LoadModuleParams,
@@ -143,6 +161,22 @@ from .load_pipette import (
     LoadPipetteCommandType,
 )
 
+from .load_lid_stack import (
+    LoadLidStack,
+    LoadLidStackParams,
+    LoadLidStackCreate,
+    LoadLidStackResult,
+    LoadLidStackCommandType,
+)
+
+from .load_lid import (
+    LoadLid,
+    LoadLidParams,
+    LoadLidCreate,
+    LoadLidResult,
+    LoadLidCommandType,
+)
+
 from .move_labware import (
     GripperMovementError,
     MoveLabware,
@@ -305,6 +339,14 @@ from .get_tip_presence import (
     GetTipPresenceCommandType,
 )
 
+from .get_next_tip import (
+    GetNextTip,
+    GetNextTipCreate,
+    GetNextTipParams,
+    GetNextTipResult,
+    GetNextTipCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -320,6 +362,7 @@ from .liquid_probe import (
 
 Command = Annotated[
     Union[
+        AirGapInPlace,
         Aspirate,
         AspirateInPlace,
         Comment,
@@ -337,8 +380,11 @@ Command = Annotated[
         LoadLabware,
         ReloadLabware,
         LoadLiquid,
+        LoadLiquidClass,
         LoadModule,
         LoadPipette,
+        LoadLidStack,
+        LoadLid,
         MoveLabware,
         MoveRelative,
         MoveToCoordinates,
@@ -355,6 +401,7 @@ Command = Annotated[
         SetStatusBar,
         VerifyTipPresence,
         GetTipPresence,
+        GetNextTip,
         LiquidProbe,
         TryLiquidProbe,
         heater_shaker.WaitForTemperature,
@@ -393,11 +440,17 @@ Command = Annotated[
         unsafe.UnsafeEngageAxes,
         unsafe.UnsafeUngripLabware,
         unsafe.UnsafePlaceLabware,
+        robot.MoveTo,
+        robot.MoveAxesRelative,
+        robot.MoveAxesTo,
+        robot.openGripperJaw,
+        robot.closeGripperJaw,
     ],
     Field(discriminator="commandType"),
 ]
 
 CommandParams = Union[
+    AirGapInPlaceParams,
     AspirateParams,
     AspirateInPlaceParams,
     CommentParams,
@@ -413,8 +466,11 @@ CommandParams = Union[
     HomeParams,
     RetractAxisParams,
     LoadLabwareParams,
+    LoadLidStackParams,
+    LoadLidParams,
     ReloadLabwareParams,
     LoadLiquidParams,
+    LoadLiquidClassParams,
     LoadModuleParams,
     LoadPipetteParams,
     MoveLabwareParams,
@@ -433,6 +489,7 @@ CommandParams = Union[
     SetStatusBarParams,
     VerifyTipPresenceParams,
     GetTipPresenceParams,
+    GetNextTipParams,
     LiquidProbeParams,
     TryLiquidProbeParams,
     heater_shaker.WaitForTemperatureParams,
@@ -471,9 +528,15 @@ CommandParams = Union[
     unsafe.UnsafeEngageAxesParams,
     unsafe.UnsafeUngripLabwareParams,
     unsafe.UnsafePlaceLabwareParams,
+    robot.MoveAxesRelativeParams,
+    robot.MoveAxesToParams,
+    robot.MoveToParams,
+    robot.openGripperJawParams,
+    robot.closeGripperJawParams,
 ]
 
 CommandType = Union[
+    AirGapInPlaceCommandType,
     AspirateCommandType,
     AspirateInPlaceCommandType,
     CommentCommandType,
@@ -491,8 +554,11 @@ CommandType = Union[
     LoadLabwareCommandType,
     ReloadLabwareCommandType,
     LoadLiquidCommandType,
+    LoadLiquidClassCommandType,
     LoadModuleCommandType,
     LoadPipetteCommandType,
+    LoadLidStackCommandType,
+    LoadLidCommandType,
     MoveLabwareCommandType,
     MoveRelativeCommandType,
     MoveToCoordinatesCommandType,
@@ -509,6 +575,7 @@ CommandType = Union[
     SetStatusBarCommandType,
     VerifyTipPresenceCommandType,
     GetTipPresenceCommandType,
+    GetNextTipCommandType,
     LiquidProbeCommandType,
     TryLiquidProbeCommandType,
     heater_shaker.WaitForTemperatureCommandType,
@@ -547,10 +614,16 @@ CommandType = Union[
     unsafe.UnsafeEngageAxesCommandType,
     unsafe.UnsafeUngripLabwareCommandType,
     unsafe.UnsafePlaceLabwareCommandType,
+    robot.MoveAxesRelativeCommandType,
+    robot.MoveAxesToCommandType,
+    robot.MoveToCommandType,
+    robot.openGripperJawCommandType,
+    robot.closeGripperJawCommandType,
 ]
 
 CommandCreate = Annotated[
     Union[
+        AirGapInPlaceCreate,
         AspirateCreate,
         AspirateInPlaceCreate,
         CommentCreate,
@@ -568,8 +641,11 @@ CommandCreate = Annotated[
         LoadLabwareCreate,
         ReloadLabwareCreate,
         LoadLiquidCreate,
+        LoadLiquidClassCreate,
         LoadModuleCreate,
         LoadPipetteCreate,
+        LoadLidStackCreate,
+        LoadLidCreate,
         MoveLabwareCreate,
         MoveRelativeCreate,
         MoveToCoordinatesCreate,
@@ -586,6 +662,7 @@ CommandCreate = Annotated[
         SetStatusBarCreate,
         VerifyTipPresenceCreate,
         GetTipPresenceCreate,
+        GetNextTipCreate,
         LiquidProbeCreate,
         TryLiquidProbeCreate,
         heater_shaker.WaitForTemperatureCreate,
@@ -624,11 +701,24 @@ CommandCreate = Annotated[
         unsafe.UnsafeEngageAxesCreate,
         unsafe.UnsafeUngripLabwareCreate,
         unsafe.UnsafePlaceLabwareCreate,
+        robot.MoveAxesRelativeCreate,
+        robot.MoveAxesToCreate,
+        robot.MoveToCreate,
+        robot.openGripperJawCreate,
+        robot.closeGripperJawCreate,
     ],
     Field(discriminator="commandType"),
 ]
 
+# Each time a TypeAdapter is instantiated, it will construct a new validator and
+# serializer. To improve performance, TypeAdapters are instantiated once.
+# See https://docs.pydantic.dev/latest/concepts/performance/#typeadapter-instantiated-once
+CommandCreateAdapter: TypeAdapter[CommandCreate] = TypeAdapter(CommandCreate)
+
+CommandAdapter: TypeAdapter[Command] = TypeAdapter(Command)
+
 CommandResult = Union[
+    AirGapInPlaceResult,
     AspirateResult,
     AspirateInPlaceResult,
     CommentResult,
@@ -646,8 +736,11 @@ CommandResult = Union[
     LoadLabwareResult,
     ReloadLabwareResult,
     LoadLiquidResult,
+    LoadLiquidClassResult,
     LoadModuleResult,
     LoadPipetteResult,
+    LoadLidStackResult,
+    LoadLidResult,
     MoveLabwareResult,
     MoveRelativeResult,
     MoveToCoordinatesResult,
@@ -664,6 +757,7 @@ CommandResult = Union[
     SetStatusBarResult,
     VerifyTipPresenceResult,
     GetTipPresenceResult,
+    GetNextTipResult,
     LiquidProbeResult,
     TryLiquidProbeResult,
     heater_shaker.WaitForTemperatureResult,
@@ -702,6 +796,11 @@ CommandResult = Union[
     unsafe.UnsafeEngageAxesResult,
     unsafe.UnsafeUngripLabwareResult,
     unsafe.UnsafePlaceLabwareResult,
+    robot.MoveAxesRelativeResult,
+    robot.MoveAxesToResult,
+    robot.MoveToResult,
+    robot.openGripperJawResult,
+    robot.closeGripperJawResult,
 ]
 
 
@@ -712,6 +811,7 @@ CommandDefinedErrorData = Union[
     DefinedErrorData[OverpressureError],
     DefinedErrorData[LiquidNotFoundError],
     DefinedErrorData[GripperMovementError],
+    DefinedErrorData[StallOrCollisionError],
 ]
 
 

opentrons/protocol_engine/commands/comment.py

@@ -43,7 +43,7 @@ class Comment(BaseCommand[CommentParams, CommentResult, ErrorOccurrence]):
 
     commandType: CommentCommandType = "comment"
     params: CommentParams
-    result: Optional[CommentResult]
+    result: Optional[CommentResult] = None
 
     _ImplementationCls: Type[CommentImplementation] = CommentImplementation
 

opentrons/protocol_engine/commands/configure_for_volume.py

@@ -1,7 +1,9 @@
 """Configure for volume command request, result, and implementation models."""
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from .pipetting_common import PipetteIdMixin
@@ -16,6 +18,10 @@ if TYPE_CHECKING:
 ConfigureForVolumeCommandType = Literal["configureForVolume"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class ConfigureForVolumeParams(PipetteIdMixin):
     """Parameters required to configure volume for a specific pipette."""
 
@@ -25,12 +31,13 @@ class ConfigureForVolumeParams(PipetteIdMixin):
         "than a pipette-specific maximum volume.",
         ge=0,
     )
-    tipOverlapNotAfterVersion: Optional[str] = Field(
+    tipOverlapNotAfterVersion: str | SkipJsonSchema[None] = Field(
         None,
         description="A version of tip overlap data to not exceed. The highest-versioned "
         "tip overlap data that does not exceed this version will be used. Versions are "
         "expressed as vN where N is an integer, counting up from v0. If None, the current "
         "highest version will be used.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -81,7 +88,7 @@ class ConfigureForVolume(
 
     commandType: ConfigureForVolumeCommandType = "configureForVolume"
     params: ConfigureForVolumeParams
-    result: Optional[ConfigureForVolumeResult]
+    result: Optional[ConfigureForVolumeResult] = None
 
     _ImplementationCls: Type[
         ConfigureForVolumeImplementation

opentrons/protocol_engine/commands/configure_nozzle_layout.py

@@ -61,9 +61,11 @@ class ConfigureNozzleLayoutImplementation(
         self, params: ConfigureNozzleLayoutParams
     ) -> SuccessData[ConfigureNozzleLayoutResult]:
         """Check that requested pipette can support the requested nozzle layout."""
-        primary_nozzle = params.configurationParams.dict().get("primaryNozzle")
-        front_right_nozzle = params.configurationParams.dict().get("frontRightNozzle")
-        back_left_nozzle = params.configurationParams.dict().get("backLeftNozzle")
+        primary_nozzle = params.configurationParams.model_dump().get("primaryNozzle")
+        front_right_nozzle = params.configurationParams.model_dump().get(
+            "frontRightNozzle"
+        )
+        back_left_nozzle = params.configurationParams.model_dump().get("backLeftNozzle")
         nozzle_params = await self._tip_handler.available_for_nozzle_layout(
             pipette_id=params.pipetteId,
             style=params.configurationParams.style,
@@ -97,7 +99,7 @@ class ConfigureNozzleLayout(
 
     commandType: ConfigureNozzleLayoutCommandType = "configureNozzleLayout"
     params: ConfigureNozzleLayoutParams
-    result: Optional[ConfigureNozzleLayoutResult]
+    result: Optional[ConfigureNozzleLayoutResult] = None
 
     _ImplementationCls: Type[
         ConfigureNozzleLayoutImplementation

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