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

opentrons/protocol_engine/commands/aspirate.py

@@ -1,7 +1,7 @@
 """Aspirate 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 .pipetting_common import (
@@ -9,9 +9,15 @@ from .pipetting_common import (
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
+    aspirate_in_place,
+    prepare_for_aspirate,
+)
+from .movement_common import (
+    LiquidHandlingWellLocationMixin,
     DestinationPositionResult,
+    StallOrCollisionError,
+    move_to_well,
 )
 from .command import (
     AbstractCommandImpl,
@@ -20,12 +26,15 @@ from .command import (
     DefinedErrorData,
     SuccessData,
 )
-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
+from ..types import (
+    WellLocation,
+    WellOrigin,
+    CurrentWell,
+)
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
@@ -53,7 +62,7 @@ class AspirateResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 _ExecuteReturn = Union[
     SuccessData[AspirateResult],
-    DefinedErrorData[OverpressureError],
+    DefinedErrorData[OverpressureError] | DefinedErrorData[StallOrCollisionError],
 ]
 
 
@@ -86,23 +95,51 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
         pipette_id = params.pipetteId
         labware_id = params.labwareId
         well_name = params.wellName
+        well_location = params.wellLocation
+
+        state_update = StateUpdate()
+
+        final_location = self._state_view.geometry.get_well_position(
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=well_location,
+            operation_volume=-params.volume,
+            pipette_id=pipette_id,
+        )
 
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
             pipette_id=pipette_id
         )
 
         current_well = None
-        state_update = StateUpdate()
 
         if not ready_to_aspirate:
-            await self._movement.move_to_well(
+            move_result = await move_to_well(
+                movement=self._movement,
+                model_utils=self._model_utils,
                 pipette_id=pipette_id,
                 labware_id=labware_id,
                 well_name=well_name,
                 well_location=WellLocation(origin=WellOrigin.TOP),
             )
+            state_update.append(move_result.state_update)
+            if isinstance(move_result, DefinedErrorData):
+                return DefinedErrorData(move_result.public, state_update=state_update)
 
-            await self._pipetting.prepare_for_aspirate(pipette_id=pipette_id)
+            prepare_result = await prepare_for_aspirate(
+                pipette_id=pipette_id,
+                pipetting=self._pipetting,
+                model_utils=self._model_utils,
+                # Note that the retryLocation is the final location, inside the liquid,
+                # because that's where we'd want the client to try re-aspirating if this
+                # command fails and the run enters error recovery.
+                location_if_error={"retryLocation": final_location},
+            )
+            state_update.append(prepare_result.state_update)
+            if isinstance(prepare_result, DefinedErrorData):
+                return DefinedErrorData(
+                    public=prepare_result.public, state_update=state_update
+                )
 
             # set our current deck location to the well now that we've made
             # an intermediate move for the "prepare for aspirate" step
@@ -112,71 +149,84 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                 well_name=well_name,
             )
 
-        position = await self._movement.move_to_well(
+        move_result = await move_to_well(
+            movement=self._movement,
+            model_utils=self._model_utils,
             pipette_id=pipette_id,
             labware_id=labware_id,
             well_name=well_name,
-            well_location=params.wellLocation,
+            well_location=well_location,
             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(
+        state_update.append(move_result.state_update)
+        if isinstance(move_result, DefinedErrorData):
+            return DefinedErrorData(
+                public=move_result.public, state_update=state_update
+            )
+
+        aspirate_result = await aspirate_in_place(
             pipette_id=pipette_id,
-            new_labware_id=labware_id,
-            new_well_name=well_name,
-            new_deck_point=deck_point,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            location_if_error={
+                "retryLocation": (
+                    move_result.public.position.x,
+                    move_result.public.position.y,
+                    move_result.public.position.z,
+                )
+            },
+            command_note_adder=self._command_note_adder,
+            pipetting=self._pipetting,
+            model_utils=self._model_utils,
         )
-
-        try:
-            volume_aspirated = await self._pipetting.aspirate_in_place(
-                pipette_id=pipette_id,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                command_note_adder=self._command_note_adder,
-            )
-        except PipetteOverpressureError as e:
+        state_update.append(aspirate_result.state_update)
+        if isinstance(aspirate_result, DefinedErrorData):
             state_update.set_liquid_operated(
                 labware_id=labware_id,
-                well_name=well_name,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    labware_id,
+                    well_name,
+                    params.pipetteId,
+                ),
                 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": (position.x, position.y, 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=deck_point,
-                ),
-                state_update=state_update,
+                public=aspirate_result.public, state_update=state_update
             )
 
+        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, pipette_id
+            ),
+            volume_added=-aspirate_result.public.volume
+            * self._state_view.geometry.get_nozzles_per_well(
+                labware_id,
+                well_name,
+                params.pipetteId,
+            ),
+        )
 
-class Aspirate(BaseCommand[AspirateParams, AspirateResult, OverpressureError]):
+        return SuccessData(
+            public=AspirateResult(
+                volume=aspirate_result.public.volume,
+                position=move_result.public.position,
+            ),
+            state_update=state_update,
+        )
+
+
+class Aspirate(
+    BaseCommand[
+        AspirateParams, AspirateResult, OverpressureError | StallOrCollisionError
+    ]
+):
     """Aspirate command model."""
 
     commandType: AspirateCommandType = "aspirate"
     params: AspirateParams
-    result: Optional[AspirateResult]
+    result: Optional[AspirateResult] = None
 
     _ImplementationCls: Type[AspirateImplementation] = AspirateImplementation
 

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional, Type, Union
 from typing_extensions import Literal
 
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
-
 from opentrons.hardware_control import HardwareControlAPI
 
 from .pipetting_common import (
@@ -14,6 +12,7 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
+    aspirate_in_place,
 )
 from .command import (
     AbstractCommandImpl,
@@ -22,9 +21,8 @@ from .command import (
     SuccessData,
     DefinedErrorData,
 )
-from ..errors.error_occurrence import ErrorOccurrence
 from ..errors.exceptions import PipetteNotReadyToAspirateError
-from ..state.update_types import StateUpdate, CLEAR
+from ..state.update_types import CLEAR
 from ..types import CurrentWell
 
 if TYPE_CHECKING:
@@ -83,8 +81,6 @@ 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,
         )
@@ -95,63 +91,71 @@ class AspirateInPlaceImplementation(
                 " 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)
+        current_location = self._state_view.pipettes.get_current_location()
 
-        try:
-            volume = await self._pipetting.aspirate_in_place(
-                pipette_id=params.pipetteId,
-                volume=params.volume,
-                flow_rate=params.flowRate,
-                command_note_adder=self._command_note_adder,
-            )
-        except PipetteOverpressureError as e:
+        result = await aspirate_in_place(
+            pipette_id=params.pipetteId,
+            volume=params.volume,
+            flow_rate=params.flowRate,
+            location_if_error={
+                "retryLocation": (
+                    current_position.x,
+                    current_position.y,
+                    current_position.z,
+                )
+            },
+            command_note_adder=self._command_note_adder,
+            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,
+                return SuccessData(
+                    public=AspirateInPlaceResult(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=-result.public.volume
+                        * self._state_view.geometry.get_nozzles_per_well(
+                            current_location.labware_id,
+                            current_location.well_name,
+                            params.pipetteId,
+                        ),
+                    ),
+                )
+            else:
+                return SuccessData(
+                    public=AspirateInPlaceResult(volume=result.public.volume),
+                    state_update=result.state_update,
                 )
-            return SuccessData(
-                public=AspirateInPlaceResult(volume=volume),
-                state_update=state_update,
-            )
 
 
 class AspirateInPlace(
@@ -161,7 +165,7 @@ class AspirateInPlace(
 
     commandType: AspirateInPlaceCommandType = "aspirateInPlace"
     params: AspirateInPlaceParams
-    result: Optional[AspirateInPlaceResult]
+    result: Optional[AspirateInPlaceResult] = None
 
     _ImplementationCls: Type[
         AspirateInPlaceImplementation

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