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

opentrons/protocol_engine/commands/blow_out.py

@@ -1,18 +1,21 @@
 """Blow-out command request, result, and implementation models."""
+
 from __future__ import annotations
 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,
+    blow_out_in_place,
+)
+from .movement_common import (
     WellLocationMixin,
     DestinationPositionResult,
+    move_to_well,
+    StallOrCollisionError,
 )
 from .command import (
     AbstractCommandImpl,
@@ -21,7 +24,7 @@ from .command import (
     DefinedErrorData,
     SuccessData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
 
 from opentrons.hardware_control import HardwareControlAPI
 
@@ -49,7 +52,7 @@ class BlowOutResult(DestinationPositionResult):
 
 _ExecuteReturn = Union[
     SuccessData[BlowOutResult],
-    DefinedErrorData[OverpressureError],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
 ]
 
 
@@ -73,59 +76,61 @@ class BlowOutImplementation(AbstractCommandImpl[BlowOutParams, _ExecuteReturn]):
 
     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(
+        move_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
             well_location=params.wellLocation,
         )
-        deck_point = DeckPoint.construct(x=x, y=y, z=z)
-        state_update.set_pipette_location(
+        if isinstance(move_result, DefinedErrorData):
+            return move_result
+        blow_out_result = await blow_out_in_place(
             pipette_id=params.pipetteId,
-            new_labware_id=params.labwareId,
-            new_well_name=params.wellName,
-            new_deck_point=deck_point,
+            flow_rate=params.flowRate,
+            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:
-            await self._pipetting.blow_out_in_place(
-                pipette_id=params.pipetteId, flow_rate=params.flowRate
-            )
-        except PipetteOverpressureError as e:
+        if isinstance(blow_out_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": (
-                            x,
-                            y,
-                            z,
-                        )
-                    },
+                public=blow_out_result.public,
+                state_update=StateUpdate.reduce(
+                    move_result.state_update, blow_out_result.state_update
+                ),
+                state_update_if_false_positive=StateUpdate.reduce(
+                    move_result.state_update,
+                    blow_out_result.state_update_if_false_positive,
                 ),
             )
         else:
             return SuccessData(
-                public=BlowOutResult(position=deck_point),
-                state_update=state_update,
+                public=BlowOutResult(position=move_result.public.position),
+                state_update=StateUpdate.reduce(
+                    move_result.state_update, blow_out_result.state_update
+                ),
             )
 
 
-class BlowOut(BaseCommand[BlowOutParams, BlowOutResult, ErrorOccurrence]):
+class BlowOut(
+    BaseCommand[
+        BlowOutParams,
+        BlowOutResult,
+        OverpressureError | StallOrCollisionError,
+    ]
+):
     """Blow-out command model."""
 
     commandType: BlowOutCommandType = "blowout"
     params: BlowOutParams
-    result: Optional[BlowOutResult]
+    result: Optional[BlowOutResult] = None
 
     _ImplementationCls: Type[BlowOutImplementation] = BlowOutImplementation
 

opentrons/protocol_engine/commands/blow_out_in_place.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 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
 
@@ -10,6 +9,7 @@ from .pipetting_common import (
     OverpressureError,
     PipetteIdMixin,
     FlowRateMixin,
+    blow_out_in_place,
 )
 from .command import (
     AbstractCommandImpl,
@@ -72,36 +72,25 @@ class BlowOutInPlaceImplementation(
 
     async def execute(self, params: BlowOutInPlaceParams) -> _ExecuteReturn:
         """Blow-out without moving the pipette."""
-        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(),
-            )
+        current_position = await self._gantry_mover.get_position(params.pipetteId)
+        result = await blow_out_in_place(
+            pipette_id=params.pipetteId,
+            flow_rate=params.flowRate,
+            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):
+            return result
+        return SuccessData(
+            public=BlowOutInPlaceResult(), state_update=result.state_update
+        )
 
 
 class BlowOutInPlace(
@@ -111,7 +100,7 @@ class BlowOutInPlace(
 
     commandType: BlowOutInPlaceCommandType = "blowOutInPlace"
     params: BlowOutInPlaceParams
-    result: Optional[BlowOutInPlaceResult]
+    result: Optional[BlowOutInPlaceResult] = None
 
     _ImplementationCls: Type[
         BlowOutInPlaceImplementation

opentrons/protocol_engine/commands/calibration/calibrate_gripper.py

@@ -1,10 +1,11 @@
 """Models and implementation for the calibrateGripper command."""
 
 from enum import Enum
-from typing import Optional, Type
+from typing import Optional, Type, Any
 from typing_extensions import Literal
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.types import Point
 from opentrons.hardware_control import HardwareControlAPI
@@ -22,6 +23,10 @@ from opentrons.protocol_engine.resources import ensure_ot3_hardware
 CalibrateGripperCommandType = Literal["calibration/calibrateGripper"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class CalibrateGripperParamsJaw(Enum):  # noqa: D101
     FRONT = "front"
     REAR = "rear"
@@ -39,7 +44,7 @@ class CalibrateGripperParams(BaseModel):
         ),
     )
 
-    otherJawOffset: Optional[Vec3f] = Field(
+    otherJawOffset: Vec3f | SkipJsonSchema[None] = Field(
         None,
         description=(
             "If an offset for the other probe is already found, then specifying it here"
@@ -48,6 +53,7 @@ class CalibrateGripperParams(BaseModel):
             " If this param is not specified then the command will only find and return"
             " the offset for the specified probe."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -62,11 +68,12 @@ class CalibrateGripperResult(BaseModel):
         ),
     )
 
-    savedCalibration: Optional[GripperCalibrationOffset] = Field(
+    savedCalibration: GripperCalibrationOffset | SkipJsonSchema[None] = Field(
         None,
         description=(
             "Gripper calibration result data, when `otherJawOffset` is provided."
         ),
+        json_schema_extra=_remove_default,
     )
 
 
@@ -118,8 +125,8 @@ class CalibrateGripperImplementation(
             calibration_data = result
 
         return SuccessData(
-            public=CalibrateGripperResult.construct(
-                jawOffset=Vec3f.construct(
+            public=CalibrateGripperResult.model_construct(
+                jawOffset=Vec3f.model_construct(
                     x=probe_offset.x, y=probe_offset.y, z=probe_offset.z
                 ),
                 savedCalibration=calibration_data,
@@ -143,7 +150,7 @@ class CalibrateGripper(
 
     commandType: CalibrateGripperCommandType = "calibration/calibrateGripper"
     params: CalibrateGripperParams
-    result: Optional[CalibrateGripperResult]
+    result: Optional[CalibrateGripperResult] = None
 
     _ImplementationCls: Type[
         CalibrateGripperImplementation

opentrons/protocol_engine/commands/calibration/calibrate_module.py

@@ -101,7 +101,7 @@ class CalibrateModule(
 
     commandType: CalibrateModuleCommandType = "calibration/calibrateModule"
     params: CalibrateModuleParams
-    result: Optional[CalibrateModuleResult]
+    result: Optional[CalibrateModuleResult] = None
 
     _ImplementationCls: Type[
         CalibrateModuleImplementation

opentrons/protocol_engine/commands/calibration/calibrate_pipette.py

@@ -65,8 +65,8 @@ class CalibratePipetteImplementation(
         await ot3_api.save_instrument_offset(mount=ot3_mount, delta=pipette_offset)
 
         return SuccessData(
-            public=CalibratePipetteResult.construct(
-                pipetteOffset=InstrumentOffsetVector.construct(
+            public=CalibratePipetteResult.model_construct(
+                pipetteOffset=InstrumentOffsetVector.model_construct(
                     x=pipette_offset.x, y=pipette_offset.y, z=pipette_offset.z
                 )
             ),
@@ -80,7 +80,7 @@ class CalibratePipette(
 
     commandType: CalibratePipetteCommandType = "calibration/calibratePipette"
     params: CalibratePipetteParams
-    result: Optional[CalibratePipetteResult]
+    result: Optional[CalibratePipetteResult] = None
 
     _ImplementationCls: Type[
         CalibratePipetteImplementation

opentrons/protocol_engine/commands/calibration/move_to_maintenance_position.py

@@ -136,7 +136,7 @@ class MoveToMaintenancePosition(
         "calibration/moveToMaintenancePosition"
     )
     params: MoveToMaintenancePositionParams
-    result: Optional[MoveToMaintenancePositionResult]
+    result: Optional[MoveToMaintenancePositionResult] = None
 
     _ImplementationCls: Type[
         MoveToMaintenancePositionImplementation

opentrons/protocol_engine/commands/command.py

@@ -1,12 +1,11 @@
 """Base command data model and type definitions."""
 
-
 from __future__ import annotations
 
 import dataclasses
 from abc import ABC, abstractmethod
 from datetime import datetime
-from enum import Enum
+import enum
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -15,10 +14,12 @@ from typing import (
     List,
     Type,
     Union,
+    Any,
+    Dict,
 )
 
 from pydantic import BaseModel, Field
-from pydantic.generics import GenericModel
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.protocol_engine.state.update_types import StateUpdate
@@ -41,7 +42,7 @@ _ErrorT = TypeVar("_ErrorT", bound=ErrorOccurrence)
 _ErrorT_co = TypeVar("_ErrorT_co", bound=ErrorOccurrence, covariant=True)
 
 
-class CommandStatus(str, Enum):
+class CommandStatus(str, enum.Enum):
     """Command execution status."""
 
     QUEUED = "queued"
@@ -50,7 +51,7 @@ class CommandStatus(str, Enum):
     FAILED = "failed"
 
 
-class CommandIntent(str, Enum):
+class CommandIntent(str, enum.Enum):
     """Run intent for a given command.
 
     Props:
@@ -63,8 +64,12 @@ class CommandIntent(str, Enum):
     FIXIT = "fixit"
 
 
+def _pop_default(s: Dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class BaseCommandCreate(
-    GenericModel,
+    BaseModel,
     # These type parameters need to be invariant because our fields are mutable.
     Generic[_ParamsT],
 ):
@@ -82,7 +87,7 @@ class BaseCommandCreate(
         ),
     )
     params: _ParamsT = Field(..., description="Command execution data payload")
-    intent: Optional[CommandIntent] = Field(
+    intent: CommandIntent | SkipJsonSchema[None] = Field(
         None,
         description=(
             "The reason the command was added. If not specified or `protocol`,"
@@ -95,14 +100,16 @@ class BaseCommandCreate(
             "Use setup commands for activities like pre-run calibration checks"
             " and module setup, like pre-heating."
         ),
+        json_schema_extra=_pop_default,
     )
-    key: Optional[str] = Field(
+    key: str | SkipJsonSchema[None] = Field(
         None,
         description=(
             "A key value, unique in this run, that can be used to track"
             " the same logical command across multiple runs of the same protocol."
             " If a value is not provided, one will be generated."
         ),
+        json_schema_extra=_pop_default,
     )
 
 
@@ -144,8 +151,65 @@ class DefinedErrorData(Generic[_ErrorT_co]):
     )
 
 
+_ExecuteReturnT_co = TypeVar(
+    "_ExecuteReturnT_co",
+    bound=Union[
+        SuccessData[BaseModel],
+        DefinedErrorData[ErrorOccurrence],
+    ],
+    covariant=True,
+)
+
+
+class AbstractCommandImpl(
+    ABC,
+    Generic[_ParamsT_contra, _ExecuteReturnT_co],
+):
+    """Abstract command creation and execution implementation.
+
+    A given command request should map to a specific command implementation,
+    which defines how to execute the command and map data from execution into the
+    result model.
+    """
+
+    def __init__(
+        self,
+        state_view: StateView,
+        hardware_api: HardwareControlAPI,
+        equipment: execution.EquipmentHandler,
+        file_provider: execution.FileProvider,
+        movement: execution.MovementHandler,
+        gantry_mover: execution.GantryMover,
+        labware_movement: execution.LabwareMovementHandler,
+        pipetting: execution.PipettingHandler,
+        tip_handler: execution.TipHandler,
+        run_control: execution.RunControlHandler,
+        rail_lights: execution.RailLightsHandler,
+        model_utils: ModelUtils,
+        status_bar: execution.StatusBarHandler,
+        command_note_adder: CommandNoteAdder,
+    ) -> None:
+        """Initialize the command implementation with execution handlers."""
+        pass
+
+    @abstractmethod
+    async def execute(self, params: _ParamsT_contra) -> _ExecuteReturnT_co:
+        """Execute the command, mapping data from execution into a response model.
+
+        This should either:
+
+        - Return a `SuccessData`, if the command completed normally.
+        - Return a `DefinedErrorData`, if the command failed with a "defined error."
+          Defined errors are errors that are documented as part of the robot's public
+          API.
+        - Raise an exception, if the command failed with any other error
+          (in other words, an undefined error).
+        """
+        ...
+
+
 class BaseCommand(
-    GenericModel,
+    BaseModel,
     # These type parameters need to be invariant because our fields are mutable.
     Generic[_ParamsT, _ResultT, _ErrorT],
 ):
@@ -242,60 +306,3 @@ class BaseCommand(
             ],
         ]
     ]
-
-
-_ExecuteReturnT_co = TypeVar(
-    "_ExecuteReturnT_co",
-    bound=Union[
-        SuccessData[BaseModel],
-        DefinedErrorData[ErrorOccurrence],
-    ],
-    covariant=True,
-)
-
-
-class AbstractCommandImpl(
-    ABC,
-    Generic[_ParamsT_contra, _ExecuteReturnT_co],
-):
-    """Abstract command creation and execution implementation.
-
-    A given command request should map to a specific command implementation,
-    which defines how to execute the command and map data from execution into the
-    result model.
-    """
-
-    def __init__(
-        self,
-        state_view: StateView,
-        hardware_api: HardwareControlAPI,
-        equipment: execution.EquipmentHandler,
-        file_provider: execution.FileProvider,
-        movement: execution.MovementHandler,
-        gantry_mover: execution.GantryMover,
-        labware_movement: execution.LabwareMovementHandler,
-        pipetting: execution.PipettingHandler,
-        tip_handler: execution.TipHandler,
-        run_control: execution.RunControlHandler,
-        rail_lights: execution.RailLightsHandler,
-        model_utils: ModelUtils,
-        status_bar: execution.StatusBarHandler,
-        command_note_adder: CommandNoteAdder,
-    ) -> None:
-        """Initialize the command implementation with execution handlers."""
-        pass
-
-    @abstractmethod
-    async def execute(self, params: _ParamsT_contra) -> _ExecuteReturnT_co:
-        """Execute the command, mapping data from execution into a response model.
-
-        This should either:
-
-        - Return a `SuccessData`, if the command completed normally.
-        - Return a `DefinedErrorData`, if the command failed with a "defined error."
-          Defined errors are errors that are documented as part of the robot's public
-          API.
-        - Raise an exception, if the command failed with any other error
-          (in other words, an undefined error).
-        """
-        ...