opentrons 8.1.0__py2.py3-none-any.whl → 8.2.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/aspirate.py

@@ -6,11 +6,10 @@ from typing_extensions import Literal
 
 from .pipetting_common import (
     OverpressureError,
-    OverpressureErrorInternalData,
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    WellLocationMixin,
+    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
     DestinationPositionResult,
 )
@@ -25,12 +24,13 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
 
+from ..state.update_types import StateUpdate, CLEAR
 from ..types import WellLocation, WellOrigin, CurrentWell, DeckPoint
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
     from ..notes import CommandNoteAdder
 
 
@@ -38,7 +38,7 @@ AspirateCommandType = Literal["aspirate"]
 
 
 class AspirateParams(
-    PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin, WellLocationMixin
+    PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
 ):
     """Parameters required to aspirate from a specific well."""
 
@@ -52,8 +52,8 @@ class AspirateResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[AspirateResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[AspirateResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -92,6 +92,7 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
         )
 
         current_well = None
+        state_update = StateUpdate()
 
         if not ready_to_aspirate:
             await self._movement.move_to_well(
@@ -117,6 +118,14 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
             well_name=well_name,
             well_location=params.wellLocation,
             current_well=current_well,
+            operation_volume=-params.volume,
+        )
+        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,
         )
 
         try:
@@ -127,6 +136,11 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                 command_note_adder=self._command_note_adder,
             )
         except PipetteOverpressureError as e:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=CLEAR,
+            )
             return DefinedErrorData(
                 public=OverpressureError(
                     id=self._model_utils.generate_id(),
@@ -140,25 +154,24 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                     ],
                     errorInfo={"retryLocation": (position.x, position.y, position.z)},
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint.construct(
-                        x=position.x, y=position.y, z=position.z
-                    )
-                ),
+                state_update=state_update,
             )
         else:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=-volume_aspirated,
+            )
             return SuccessData(
                 public=AspirateResult(
                     volume=volume_aspirated,
-                    position=DeckPoint.construct(
-                        x=position.x, y=position.y, z=position.z
-                    ),
+                    position=deck_point,
                 ),
-                private=None,
+                state_update=state_update,
             )
 
 
-class Aspirate(BaseCommand[AspirateParams, AspirateResult, ErrorOccurrence]):
+class Aspirate(BaseCommand[AspirateParams, AspirateResult, OverpressureError]):
     """Aspirate command model."""
 
     commandType: AspirateCommandType = "aspirate"

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -14,7 +14,6 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
-    OverpressureErrorInternalData,
 )
 from .command import (
     AbstractCommandImpl,
@@ -25,12 +24,13 @@ from .command import (
 )
 from ..errors.error_occurrence import ErrorOccurrence
 from ..errors.exceptions import PipetteNotReadyToAspirateError
-from ..types import DeckPoint
+from ..state.update_types import StateUpdate, CLEAR
+from ..types import CurrentWell
 
 if TYPE_CHECKING:
     from ..execution import PipettingHandler, GantryMover
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
     from ..notes import CommandNoteAdder
 
 AspirateInPlaceCommandType = Literal["aspirateInPlace"]
@@ -49,8 +49,8 @@ class AspirateInPlaceResult(BaseLiquidHandlingResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[AspirateInPlaceResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[AspirateInPlaceResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -83,16 +83,21 @@ class AspirateInPlaceImplementation(
             TipNotAttachedError: if no tip is attached to the pipette.
             PipetteNotReadyToAspirateError: pipette plunger is not ready.
         """
+        state_update = StateUpdate()
+
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
             pipette_id=params.pipetteId,
         )
-
         if not ready_to_aspirate:
             raise PipetteNotReadyToAspirateError(
                 "Pipette cannot aspirate in place because of a previous blow out."
                 " The first aspirate following a blow-out must be from a specific well"
                 " so the plunger can be reset in a known safe position."
             )
+
+        current_location = self._state_view.pipettes.get_current_location()
+        current_position = await self._gantry_mover.get_position(params.pipetteId)
+
         try:
             volume = await self._pipetting.aspirate_in_place(
                 pipette_id=params.pipetteId,
@@ -101,7 +106,15 @@ class AspirateInPlaceImplementation(
                 command_note_adder=self._command_note_adder,
             )
         except PipetteOverpressureError as e:
-            current_position = await self._gantry_mover.get_position(params.pipetteId)
+            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(),
@@ -123,22 +136,26 @@ class AspirateInPlaceImplementation(
                         }
                     ),
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint(
-                        x=current_position.x,
-                        y=current_position.y,
-                        z=current_position.z,
-                    ),
-                ),
+                state_update=state_update,
             )
         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,
+                )
             return SuccessData(
-                public=AspirateInPlaceResult(volume=volume), private=None
+                public=AspirateInPlaceResult(volume=volume),
+                state_update=state_update,
             )
 
 
 class AspirateInPlace(
-    BaseCommand[AspirateInPlaceParams, AspirateInPlaceResult, ErrorOccurrence]
+    BaseCommand[AspirateInPlaceParams, AspirateInPlaceResult, OverpressureError]
 ):
     """AspirateInPlace command model."""
 

opentrons/protocol_engine/commands/blow_out.py

@@ -1,16 +1,26 @@
 """Blow-out command request, result, and implementation models."""
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type
+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,
     WellLocationMixin,
     DestinationPositionResult,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
@@ -18,7 +28,9 @@ from opentrons.hardware_control import HardwareControlAPI
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
-    from ..state import StateView
+    from ..state.state import StateView
+    from ..resources import ModelUtils
+
 
 BlowOutCommandType = Literal["blowout"]
 
@@ -35,9 +47,13 @@ class BlowOutResult(DestinationPositionResult):
     pass
 
 
-class BlowOutImplementation(
-    AbstractCommandImpl[BlowOutParams, SuccessData[BlowOutResult, None]]
-):
+_ExecuteReturn = Union[
+    SuccessData[BlowOutResult],
+    DefinedErrorData[OverpressureError],
+]
+
+
+class BlowOutImplementation(AbstractCommandImpl[BlowOutParams, _ExecuteReturn]):
     """BlowOut command implementation."""
 
     def __init__(
@@ -46,29 +62,62 @@ class BlowOutImplementation(
         pipetting: PipettingHandler,
         state_view: StateView,
         hardware_api: HardwareControlAPI,
+        model_utils: ModelUtils,
         **kwargs: object,
     ) -> None:
         self._movement = movement
         self._pipetting = pipetting
         self._state_view = state_view
         self._hardware_api = hardware_api
+        self._model_utils = model_utils
 
-    async def execute(self, params: BlowOutParams) -> SuccessData[BlowOutResult, None]:
+    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(
             pipette_id=params.pipetteId,
             labware_id=params.labwareId,
             well_name=params.wellName,
             well_location=params.wellLocation,
         )
-
-        await self._pipetting.blow_out_in_place(
-            pipette_id=params.pipetteId, flow_rate=params.flowRate
-        )
-
-        return SuccessData(
-            public=BlowOutResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_labware_id=params.labwareId,
+            new_well_name=params.wellName,
+            new_deck_point=deck_point,
         )
+        try:
+            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": (
+                            x,
+                            y,
+                            z,
+                        )
+                    },
+                ),
+            )
+        else:
+            return SuccessData(
+                public=BlowOutResult(position=deck_point),
+                state_update=state_update,
+            )
 
 
 class BlowOut(BaseCommand[BlowOutParams, BlowOutResult, ErrorOccurrence]):

opentrons/protocol_engine/commands/blow_out_in_place.py

@@ -1,23 +1,32 @@
 """Blow-out in place command request, result, and implementation models."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type
+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
 
 from .pipetting_common import (
+    OverpressureError,
     PipetteIdMixin,
     FlowRateMixin,
 )
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
 
 
 if TYPE_CHECKING:
-    from ..execution import PipettingHandler
-    from ..state import StateView
+    from ..execution import PipettingHandler, GantryMover
+    from ..state.state import StateView
+    from ..resources import ModelUtils
 
 
 BlowOutInPlaceCommandType = Literal["blowOutInPlace"]
@@ -35,8 +44,14 @@ class BlowOutInPlaceResult(BaseModel):
     pass
 
 
+_ExecuteReturn = Union[
+    SuccessData[BlowOutInPlaceResult],
+    DefinedErrorData[OverpressureError],
+]
+
+
 class BlowOutInPlaceImplementation(
-    AbstractCommandImpl[BlowOutInPlaceParams, SuccessData[BlowOutInPlaceResult, None]]
+    AbstractCommandImpl[BlowOutInPlaceParams, _ExecuteReturn]
 ):
     """BlowOutInPlace command implementation."""
 
@@ -45,21 +60,48 @@ class BlowOutInPlaceImplementation(
         pipetting: PipettingHandler,
         state_view: StateView,
         hardware_api: HardwareControlAPI,
+        model_utils: ModelUtils,
+        gantry_mover: GantryMover,
         **kwargs: object,
     ) -> None:
         self._pipetting = pipetting
         self._state_view = state_view
         self._hardware_api = hardware_api
+        self._model_utils = model_utils
+        self._gantry_mover = gantry_mover
 
-    async def execute(
-        self, params: BlowOutInPlaceParams
-    ) -> SuccessData[BlowOutInPlaceResult, None]:
+    async def execute(self, params: BlowOutInPlaceParams) -> _ExecuteReturn:
         """Blow-out without moving the pipette."""
-        await self._pipetting.blow_out_in_place(
-            pipette_id=params.pipetteId, flow_rate=params.flowRate
-        )
-
-        return SuccessData(public=BlowOutInPlaceResult(), private=None)
+        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(),
+            )
 
 
 class BlowOutInPlace(

opentrons/protocol_engine/commands/calibration/calibrate_gripper.py

@@ -71,9 +71,7 @@ class CalibrateGripperResult(BaseModel):
 
 
 class CalibrateGripperImplementation(
-    AbstractCommandImpl[
-        CalibrateGripperParams, SuccessData[CalibrateGripperResult, None]
-    ]
+    AbstractCommandImpl[CalibrateGripperParams, SuccessData[CalibrateGripperResult]]
 ):
     """The implementation of a `calibrateGripper` command."""
 
@@ -87,7 +85,7 @@ class CalibrateGripperImplementation(
 
     async def execute(
         self, params: CalibrateGripperParams
-    ) -> SuccessData[CalibrateGripperResult, None]:
+    ) -> SuccessData[CalibrateGripperResult]:
         """Execute a `calibrateGripper` command.
 
         1. Move from the current location to the calibration area on the deck.
@@ -126,7 +124,6 @@ class CalibrateGripperImplementation(
                 ),
                 savedCalibration=calibration_data,
             ),
-            private=None,
         )
 
     @staticmethod

opentrons/protocol_engine/commands/calibration/calibrate_module.py

@@ -12,7 +12,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 
 # Work around type-only circular dependencies.
 if TYPE_CHECKING:
-    from ...state import StateView
+    from ...state.state import StateView
 
 from ...types import ModuleOffsetVector, DeckSlotLocation
 
@@ -49,7 +49,7 @@ class CalibrateModuleResult(BaseModel):
 
 
 class CalibrateModuleImplementation(
-    AbstractCommandImpl[CalibrateModuleParams, SuccessData[CalibrateModuleResult, None]]
+    AbstractCommandImpl[CalibrateModuleParams, SuccessData[CalibrateModuleResult]]
 ):
     """CalibrateModule command implementation."""
 
@@ -64,7 +64,7 @@ class CalibrateModuleImplementation(
 
     async def execute(
         self, params: CalibrateModuleParams
-    ) -> SuccessData[CalibrateModuleResult, None]:
+    ) -> SuccessData[CalibrateModuleResult]:
         """Execute calibrate-module command."""
         ot3_api = ensure_ot3_hardware(
             self._hardware_api,
@@ -91,7 +91,6 @@ class CalibrateModuleImplementation(
                 ),
                 location=slot,
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/calibration/calibrate_pipette.py

@@ -34,9 +34,7 @@ class CalibratePipetteResult(BaseModel):
 
 
 class CalibratePipetteImplementation(
-    AbstractCommandImpl[
-        CalibratePipetteParams, SuccessData[CalibratePipetteResult, None]
-    ]
+    AbstractCommandImpl[CalibratePipetteParams, SuccessData[CalibratePipetteResult]]
 ):
     """CalibratePipette command implementation."""
 
@@ -49,7 +47,7 @@ class CalibratePipetteImplementation(
 
     async def execute(
         self, params: CalibratePipetteParams
-    ) -> SuccessData[CalibratePipetteResult, None]:
+    ) -> SuccessData[CalibratePipetteResult]:
         """Execute calibrate-pipette command."""
         # TODO (tz, 20-9-22): Add a better solution to determine if a command can be executed on an OT-3/OT-2
         ot3_api = ensure_ot3_hardware(
@@ -72,7 +70,6 @@ class CalibratePipetteImplementation(
                     x=pipette_offset.x, y=pipette_offset.y, z=pipette_offset.z
                 )
             ),
-            private=None,
         )
 
 

opentrons/protocol_engine/commands/calibration/move_to_maintenance_position.py

@@ -15,7 +15,7 @@ from opentrons.protocol_engine.resources.ot3_validation import ensure_ot3_hardwa
 
 if TYPE_CHECKING:
     from opentrons.hardware_control import HardwareControlAPI
-    from ...state import StateView
+    from ...state.state import StateView
 
 # These offsets supplied from HW
 _ATTACH_POINT = Point(x=0, y=110)
@@ -57,7 +57,7 @@ class MoveToMaintenancePositionResult(BaseModel):
 class MoveToMaintenancePositionImplementation(
     AbstractCommandImpl[
         MoveToMaintenancePositionParams,
-        SuccessData[MoveToMaintenancePositionResult, None],
+        SuccessData[MoveToMaintenancePositionResult],
     ]
 ):
     """Calibration set up position command implementation."""
@@ -73,7 +73,7 @@ class MoveToMaintenancePositionImplementation(
 
     async def execute(
         self, params: MoveToMaintenancePositionParams
-    ) -> SuccessData[MoveToMaintenancePositionResult, None]:
+    ) -> SuccessData[MoveToMaintenancePositionResult]:
         """Move the requested mount to a maintenance deck slot."""
         ot3_api = ensure_ot3_hardware(
             self._hardware_api,
@@ -118,7 +118,9 @@ class MoveToMaintenancePositionImplementation(
                 )
                 await ot3_api.disengage_axes([Axis.Z_R])
 
-        return SuccessData(public=MoveToMaintenancePositionResult(), private=None)
+        return SuccessData(
+            public=MoveToMaintenancePositionResult(),
+        )
 
 
 class MoveToMaintenancePosition(