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

opentrons/protocol_engine/commands/move_labware.py

@@ -1,29 +1,49 @@
 """Models and implementation for the ``moveLabware`` command."""
 
 from __future__ import annotations
+from opentrons_shared_data.errors.exceptions import (
+    FailedGripperPickupError,
+    LabwareDroppedError,
+    StallOrCollisionDetectedError,
+)
 from pydantic import BaseModel, Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons.protocol_engine.resources.model_utils import ModelUtils
 from opentrons.types import Point
 from ..types import (
+    ModuleModel,
+    CurrentWell,
     LabwareLocation,
     DeckSlotLocation,
+    ModuleLocation,
     OnLabwareLocation,
     AddressableAreaLocation,
     LabwareMovementStrategy,
     LabwareOffsetVector,
     LabwareMovementOffsetData,
 )
-from ..errors import LabwareMovementNotAllowedError, NotSupportedOnRobotType
+from ..errors import (
+    LabwareMovementNotAllowedError,
+    NotSupportedOnRobotType,
+    LabwareOffsetDoesNotExistError,
+)
 from ..resources import labware_validation, fixture_validation
-from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from .command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    DefinedErrorData,
+    SuccessData,
+)
 from ..errors.error_occurrence import ErrorOccurrence
+from ..state.update_types import StateUpdate
 from opentrons_shared_data.gripper.constants import GRIPPER_PADDLE_WIDTH
 
 if TYPE_CHECKING:
     from ..execution import EquipmentHandler, RunControlHandler, LabwareMovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 
 MoveLabwareCommandType = Literal["moveLabware"]
@@ -33,7 +53,6 @@ MoveLabwareCommandType = Literal["moveLabware"]
 _TRASH_CHUTE_DROP_BUFFER_MM = 8
 
 
-# TODO (spp, 2022-12-14): https://opentrons.atlassian.net/browse/RLAB-237
 class MoveLabwareParams(BaseModel):
     """Input parameters for a ``moveLabware`` command."""
 
@@ -74,28 +93,42 @@ class MoveLabwareResult(BaseModel):
     )
 
 
-class MoveLabwareImplementation(
-    AbstractCommandImpl[MoveLabwareParams, SuccessData[MoveLabwareResult, None]]
-):
+class GripperMovementError(ErrorOccurrence):
+    """Returned when something physically goes wrong when the gripper moves labware.
+
+    When this error happens, the engine will leave the labware in its original place.
+    """
+
+    isDefined: bool = True
+
+    errorType: Literal["gripperMovement"] = "gripperMovement"
+
+
+_ExecuteReturn = SuccessData[MoveLabwareResult] | DefinedErrorData[GripperMovementError]
+
+
+class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteReturn]):
     """The execution implementation for ``moveLabware`` commands."""
 
     def __init__(
         self,
+        model_utils: ModelUtils,
         state_view: StateView,
         equipment: EquipmentHandler,
         labware_movement: LabwareMovementHandler,
         run_control: RunControlHandler,
         **kwargs: object,
     ) -> None:
+        self._model_utils = model_utils
         self._state_view = state_view
         self._equipment = equipment
         self._labware_movement = labware_movement
         self._run_control = run_control
 
-    async def execute(  # noqa: C901
-        self, params: MoveLabwareParams
-    ) -> SuccessData[MoveLabwareResult, None]:
+    async def execute(self, params: MoveLabwareParams) -> _ExecuteReturn:  # noqa: C901
         """Move a loaded labware to a new location."""
+        state_update = StateUpdate()
+
         # Allow propagation of LabwareNotLoadedError.
         current_labware = self._state_view.labware.get(labware_id=params.labwareId)
         current_labware_definition = self._state_view.labware.get_definition(
@@ -103,6 +136,7 @@ class MoveLabwareImplementation(
         )
         definition_uri = current_labware.definitionUri
         post_drop_slide_offset: Optional[Point] = None
+        trash_lid_drop_offset: Optional[LabwareOffsetVector] = None
 
         if self._state_view.labware.is_fixed_trash(params.labwareId):
             raise LabwareMovementNotAllowedError(
@@ -111,9 +145,11 @@ class MoveLabwareImplementation(
 
         if isinstance(params.newLocation, AddressableAreaLocation):
             area_name = params.newLocation.addressableAreaName
-            if not fixture_validation.is_gripper_waste_chute(
-                area_name
-            ) and not fixture_validation.is_deck_slot(area_name):
+            if (
+                not fixture_validation.is_gripper_waste_chute(area_name)
+                and not fixture_validation.is_deck_slot(area_name)
+                and not fixture_validation.is_trash(area_name)
+            ):
                 raise LabwareMovementNotAllowedError(
                     f"Cannot move {current_labware.loadName} to addressable area {area_name}"
                 )
@@ -135,6 +171,32 @@ class MoveLabwareImplementation(
                     y=0,
                     z=0,
                 )
+            elif fixture_validation.is_trash(area_name):
+                # When dropping labware in the trash bins we want to ensure they are lids
+                # and enforce a y-axis drop offset to ensure they fall within the trash bin
+                if labware_validation.validate_definition_is_lid(
+                    self._state_view.labware.get_definition(params.labwareId)
+                ):
+                    lid_disposable_offfets = (
+                        current_labware_definition.gripperOffsets.get(
+                            "lidDisposalOffsets"
+                        )
+                    )
+                    if lid_disposable_offfets is not None:
+                        trash_lid_drop_offset = LabwareOffsetVector(
+                            x=lid_disposable_offfets.dropOffset.x,
+                            y=lid_disposable_offfets.dropOffset.y,
+                            z=lid_disposable_offfets.dropOffset.z,
+                        )
+                    else:
+                        raise LabwareOffsetDoesNotExistError(
+                            f"Labware Definition {current_labware.loadName} does not contain required field 'lidDisposalOffsets' of 'gripperOffsets'."
+                        )
+                else:
+                    raise LabwareMovementNotAllowedError(
+                        "Can only move labware with allowed role 'Lid' to a Trash Bin."
+                    )
+
         elif isinstance(params.newLocation, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.newLocation.slotName.id
@@ -157,6 +219,17 @@ class MoveLabwareImplementation(
                 top_labware_definition=current_labware_definition,
                 bottom_labware_id=available_new_location.labwareId,
             )
+            if params.labwareId == available_new_location.labwareId:
+                raise LabwareMovementNotAllowedError(
+                    "Cannot move a labware onto itself."
+                )
+        # Validate labware for the absorbance reader
+        elif isinstance(available_new_location, ModuleLocation):
+            module = self._state_view.modules.get(available_new_location.moduleId)
+            if module is not None and module.model == ModuleModel.ABSORBANCE_READER_V1:
+                self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
+                    current_labware_definition
+                )
 
         # Allow propagation of ModuleNotLoadedError.
         new_offset_id = self._equipment.find_applicable_labware_offset_id(
@@ -201,24 +274,83 @@ class MoveLabwareImplementation(
                 dropOffset=params.dropOffset or LabwareOffsetVector(x=0, y=0, z=0),
             )
 
-            # Skips gripper moves when using virtual gripper
-            await self._labware_movement.move_labware_with_gripper(
-                labware_id=params.labwareId,
-                current_location=validated_current_loc,
-                new_location=validated_new_loc,
-                user_offset_data=user_offset_data,
-                post_drop_slide_offset=post_drop_slide_offset,
-            )
+            if trash_lid_drop_offset:
+                user_offset_data.dropOffset += trash_lid_drop_offset
+
+            try:
+                # Skips gripper moves when using virtual gripper
+                await self._labware_movement.move_labware_with_gripper(
+                    labware_id=params.labwareId,
+                    current_location=validated_current_loc,
+                    new_location=validated_new_loc,
+                    user_offset_data=user_offset_data,
+                    post_drop_slide_offset=post_drop_slide_offset,
+                )
+            except (
+                FailedGripperPickupError,
+                LabwareDroppedError,
+                StallOrCollisionDetectedError,
+                # todo(mm, 2024-09-26): Catch LabwareNotPickedUpError when that exists and
+                # move_labware_with_gripper() raises it.
+            ) as exception:
+                gripper_movement_error: GripperMovementError | None = (
+                    GripperMovementError(
+                        id=self._model_utils.generate_id(),
+                        createdAt=self._model_utils.get_timestamp(),
+                        errorCode=exception.code.value.code,
+                        detail=exception.code.value.detail,
+                        wrappedErrors=[
+                            ErrorOccurrence.from_failed(
+                                id=self._model_utils.generate_id(),
+                                createdAt=self._model_utils.get_timestamp(),
+                                error=exception,
+                            )
+                        ],
+                    )
+                )
+            else:
+                gripper_movement_error = None
+
+            # All mounts will have been retracted as part of the gripper move.
+            state_update.clear_all_pipette_locations()
+
+            if gripper_movement_error:
+                return DefinedErrorData(
+                    public=gripper_movement_error,
+                    state_update=state_update,
+                )
+
         elif params.strategy == LabwareMovementStrategy.MANUAL_MOVE_WITH_PAUSE:
             # Pause to allow for manual labware movement
             await self._run_control.wait_for_resume()
 
+        # We may have just moved the labware that contains the current well out from
+        # under the pipette. Clear the current location to reflect the fact that the
+        # pipette is no longer over any labware. This is necessary for safe path
+        # planning in case the next movement goes to the same labware (now in a new
+        # place).
+        pipette_location = self._state_view.pipettes.get_current_location()
+        if (
+            isinstance(pipette_location, CurrentWell)
+            and pipette_location.labware_id == params.labwareId
+        ):
+            state_update.clear_all_pipette_locations()
+
+        state_update.set_labware_location(
+            labware_id=params.labwareId,
+            new_location=available_new_location,
+            new_offset_id=new_offset_id,
+        )
+
         return SuccessData(
-            public=MoveLabwareResult(offsetId=new_offset_id), private=None
+            public=MoveLabwareResult(offsetId=new_offset_id),
+            state_update=state_update,
         )
 
 
-class MoveLabware(BaseCommand[MoveLabwareParams, MoveLabwareResult, ErrorOccurrence]):
+class MoveLabware(
+    BaseCommand[MoveLabwareParams, MoveLabwareResult, GripperMovementError]
+):
     """A ``moveLabware`` command."""
 
     commandType: MoveLabwareCommandType = "moveLabware"

opentrons/protocol_engine/commands/move_relative.py

@@ -4,6 +4,8 @@ from pydantic import BaseModel, Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+
+from ..state import update_types
 from ..types import MovementAxis, DeckPoint
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
@@ -37,7 +39,7 @@ class MoveRelativeResult(DestinationPositionResult):
 
 
 class MoveRelativeImplementation(
-    AbstractCommandImpl[MoveRelativeParams, SuccessData[MoveRelativeResult, None]]
+    AbstractCommandImpl[MoveRelativeParams, SuccessData[MoveRelativeResult]]
 ):
     """Move relative command implementation."""
 
@@ -46,16 +48,26 @@ class MoveRelativeImplementation(
 
     async def execute(
         self, params: MoveRelativeParams
-    ) -> SuccessData[MoveRelativeResult, None]:
+    ) -> SuccessData[MoveRelativeResult]:
         """Move (jog) a given pipette a relative distance."""
+        state_update = update_types.StateUpdate()
+
         x, y, z = await self._movement.move_relative(
             pipette_id=params.pipetteId,
             axis=params.axis,
             distance=params.distance,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.pipette_location = update_types.PipetteLocationUpdate(
+            pipette_id=params.pipetteId,
+            # TODO(jbl 2023-02-14): Need to investigate whether move relative should clear current location
+            new_location=update_types.NO_CHANGE,
+            new_deck_point=deck_point,
+        )
 
         return SuccessData(
-            public=MoveRelativeResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+            public=MoveRelativeResult(position=deck_point),
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_addressable_area.py

@@ -4,7 +4,10 @@ from pydantic import Field
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons_shared_data.pipette.types import PipetteNameType
+
 from ..errors import LocationNotAccessibleByPipetteError
+from ..state import update_types
 from ..types import DeckPoint, AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
@@ -17,7 +20,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 MoveToAddressableAreaCommandType = Literal["moveToAddressableArea"]
 
@@ -73,7 +76,7 @@ class MoveToAddressableAreaResult(DestinationPositionResult):
 
 class MoveToAddressableAreaImplementation(
     AbstractCommandImpl[
-        MoveToAddressableAreaParams, SuccessData[MoveToAddressableAreaResult, None]
+        MoveToAddressableAreaParams, SuccessData[MoveToAddressableAreaResult]
     ]
 ):
     """Move to addressable area command implementation."""
@@ -86,11 +89,26 @@ class MoveToAddressableAreaImplementation(
 
     async def execute(
         self, params: MoveToAddressableAreaParams
-    ) -> SuccessData[MoveToAddressableAreaResult, None]:
+    ) -> SuccessData[MoveToAddressableAreaResult]:
         """Move the requested pipette to the requested addressable area."""
+        state_update = update_types.StateUpdate()
+
         self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
             params.addressableAreaName
         )
+        loaded_pipette = self._state_view.pipettes.get(params.pipetteId)
+        if loaded_pipette.pipetteName in (
+            PipetteNameType.P10_SINGLE,
+            PipetteNameType.P10_MULTI,
+            PipetteNameType.P50_MULTI,
+            PipetteNameType.P50_SINGLE,
+            PipetteNameType.P300_SINGLE,
+            PipetteNameType.P300_MULTI,
+            PipetteNameType.P1000_SINGLE,
+        ):
+            extra_z_offset: Optional[float] = 5.0
+        else:
+            extra_z_offset = None
 
         if fixture_validation.is_staging_slot(params.addressableAreaName):
             raise LocationNotAccessibleByPipetteError(
@@ -105,11 +123,18 @@ class MoveToAddressableAreaImplementation(
             minimum_z_height=params.minimumZHeight,
             speed=params.speed,
             stay_at_highest_possible_z=params.stayAtHighestPossibleZ,
+            highest_possible_z_extra_offset=extra_z_offset,
+        )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_addressable_area_name=params.addressableAreaName,
+            new_deck_point=deck_point,
         )
 
         return SuccessData(
             public=MoveToAddressableAreaResult(position=DeckPoint(x=x, y=y, z=z)),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_addressable_area_for_drop_tip.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
 from ..errors import LocationNotAccessibleByPipetteError
+from ..state import update_types
 from ..types import DeckPoint, AddressableOffsetVector
 from ..resources import fixture_validation
 from .pipetting_common import (
@@ -17,7 +18,7 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
-    from ..state import StateView
+    from ..state.state import StateView
 
 MoveToAddressableAreaForDropTipCommandType = Literal["moveToAddressableAreaForDropTip"]
 
@@ -85,7 +86,7 @@ class MoveToAddressableAreaForDropTipResult(DestinationPositionResult):
 class MoveToAddressableAreaForDropTipImplementation(
     AbstractCommandImpl[
         MoveToAddressableAreaForDropTipParams,
-        SuccessData[MoveToAddressableAreaForDropTipResult, None],
+        SuccessData[MoveToAddressableAreaForDropTipResult],
     ]
 ):
     """Move to addressable area for drop tip command implementation."""
@@ -98,8 +99,10 @@ class MoveToAddressableAreaForDropTipImplementation(
 
     async def execute(
         self, params: MoveToAddressableAreaForDropTipParams
-    ) -> SuccessData[MoveToAddressableAreaForDropTipResult, None]:
+    ) -> SuccessData[MoveToAddressableAreaForDropTipResult]:
         """Move the requested pipette to the requested addressable area in preperation of a drop tip."""
+        state_update = update_types.StateUpdate()
+
         self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
             params.addressableAreaName
         )
@@ -126,12 +129,18 @@ class MoveToAddressableAreaForDropTipImplementation(
             speed=params.speed,
             ignore_tip_configuration=params.ignoreTipConfiguration,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.set_pipette_location(
+            pipette_id=params.pipetteId,
+            new_addressable_area_name=params.addressableAreaName,
+            new_deck_point=deck_point,
+        )
 
         return SuccessData(
             public=MoveToAddressableAreaForDropTipResult(
                 position=DeckPoint(x=x, y=y, z=z)
             ),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_coordinates.py

@@ -5,6 +5,8 @@ from pydantic import Field
 from typing import Optional, Type, TYPE_CHECKING
 from typing_extensions import Literal
 
+
+from ..state import update_types
 from ..types import DeckPoint
 from .pipetting_common import PipetteIdMixin, MovementMixin, DestinationPositionResult
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
@@ -33,9 +35,7 @@ class MoveToCoordinatesResult(DestinationPositionResult):
 
 
 class MoveToCoordinatesImplementation(
-    AbstractCommandImpl[
-        MoveToCoordinatesParams, SuccessData[MoveToCoordinatesResult, None]
-    ]
+    AbstractCommandImpl[MoveToCoordinatesParams, SuccessData[MoveToCoordinatesResult]]
 ):
     """Move to coordinates command implementation."""
 
@@ -48,8 +48,10 @@ class MoveToCoordinatesImplementation(
 
     async def execute(
         self, params: MoveToCoordinatesParams
-    ) -> SuccessData[MoveToCoordinatesResult, None]:
+    ) -> SuccessData[MoveToCoordinatesResult]:
         """Move the requested pipette to the requested coordinates."""
+        state_update = update_types.StateUpdate()
+
         x, y, z = await self._movement.move_to_coordinates(
             pipette_id=params.pipetteId,
             deck_coordinates=params.coordinates,
@@ -57,10 +59,14 @@ class MoveToCoordinatesImplementation(
             additional_min_travel_z=params.minimumZHeight,
             speed=params.speed,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=z)
+        state_update.pipette_location = update_types.PipetteLocationUpdate(
+            pipette_id=params.pipetteId, new_location=None, new_deck_point=deck_point
+        )
 
         return SuccessData(
             public=MoveToCoordinatesResult(position=DeckPoint(x=x, y=y, z=z)),
-            private=None,
+            state_update=state_update,
         )
 
 

opentrons/protocol_engine/commands/move_to_well.py

@@ -12,9 +12,12 @@ from .pipetting_common import (
 )
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ..errors.error_occurrence import ErrorOccurrence
+from ..state import update_types
+from ..errors import LabwareIsTipRackError
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler
+    from ..state.state import StateView
 
 MoveToWellCommandType = Literal["moveToWell"]
 
@@ -32,29 +35,53 @@ class MoveToWellResult(DestinationPositionResult):
 
 
 class MoveToWellImplementation(
-    AbstractCommandImpl[MoveToWellParams, SuccessData[MoveToWellResult, None]]
+    AbstractCommandImpl[MoveToWellParams, SuccessData[MoveToWellResult]]
 ):
     """Move to well command implementation."""
 
-    def __init__(self, movement: MovementHandler, **kwargs: object) -> None:
+    def __init__(
+        self, state_view: StateView, movement: MovementHandler, **kwargs: object
+    ) -> None:
+        self._state_view = state_view
         self._movement = movement
 
-    async def execute(
-        self, params: MoveToWellParams
-    ) -> SuccessData[MoveToWellResult, None]:
+    async def execute(self, params: MoveToWellParams) -> SuccessData[MoveToWellResult]:
         """Move the requested pipette to the requested well."""
+        pipette_id = params.pipetteId
+        labware_id = params.labwareId
+        well_name = params.wellName
+        well_location = params.wellLocation
+
+        state_update = update_types.StateUpdate()
+
+        if (
+            self._state_view.labware.is_tiprack(labware_id)
+            and well_location.volumeOffset
+        ):
+            raise LabwareIsTipRackError(
+                "Cannot specify a WellLocation with a volumeOffset with movement to a tip rack"
+            )
+
         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,
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_name=well_name,
+            well_location=well_location,
             force_direct=params.forceDirect,
             minimum_z_height=params.minimumZHeight,
             speed=params.speed,
         )
+        deck_point = DeckPoint.construct(x=x, y=y, z=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,
+        )
 
         return SuccessData(
-            public=MoveToWellResult(position=DeckPoint(x=x, y=y, z=z)), private=None
+            public=MoveToWellResult(position=deck_point),
+            state_update=state_update,
         )