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

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -9,7 +9,6 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import CannotPerformModuleAction
 
-from opentrons.protocol_engine.resources import labware_validation
 from opentrons.protocol_engine.types import AddressableAreaLocation
 
 from opentrons.drivers.types import AbsorbanceReaderLidStatus
@@ -54,39 +53,35 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
 
     async def execute(self, params: OpenLidParams) -> SuccessData[OpenLidResult]:
         """Move the absorbance reader lid from the module to the lid dock."""
+        state_update = StateUpdate()
         mod_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
-        # lid should currently be on the module
-        assert mod_substate.lid_id is not None
-        loaded_lid = self._state_view.labware.get(mod_substate.lid_id)
-        assert labware_validation.is_absorbance_reader_lid(loaded_lid.loadName)
 
         hardware_lid_status = AbsorbanceReaderLidStatus.ON
-        # If the lid is closed, if the lid is open No-op out
         if not self._state_view.config.use_virtual_modules:
             abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
             if abs_reader is not None:
-                result = await abs_reader.get_current_lid_status()
-                hardware_lid_status = result
+                hardware_lid_status = await abs_reader.get_current_lid_status()
             else:
                 raise CannotPerformModuleAction(
                     "Could not reach the Hardware API for Opentrons Plate Reader Module."
                 )
 
-        # If the lid is already OFF, no-op the lid removal
         if hardware_lid_status is AbsorbanceReaderLidStatus.OFF:
-            assert isinstance(loaded_lid.location, AddressableAreaLocation)
-            new_location = loaded_lid.location
-            new_offset_id = self._equipment.find_applicable_labware_offset_id(
-                labware_definition_uri=loaded_lid.definitionUri,
-                labware_location=loaded_lid.location,
+            # The lid is already physically OFF, so we can no-op physically closing it
+            state_update.set_absorbance_reader_lid(
+                module_id=mod_substate.module_id, is_lid_on=False
             )
         else:
             # Allow propagation of ModuleNotAttachedError.
             _ = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
+            lid_definition = (
+                self._state_view.labware.get_absorbance_reader_lid_definition()
+            )
+
             absorbance_model = self._state_view.modules.get_requested_model(
                 params.moduleId
             )
@@ -106,35 +101,28 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
                 mod_substate.module_id
             )
 
-            lid_gripper_offsets = self._state_view.labware.get_labware_gripper_offsets(
-                loaded_lid.id, None
+            # The lid's labware definition stores gripper offsets for itself in the
+            # space normally meant for offsets for labware stacked atop it.
+            lid_gripper_offsets = self._state_view.labware.get_child_gripper_offsets(
+                labware_definition=lid_definition,
+                slot_name=None,
             )
             if lid_gripper_offsets is None:
                 raise ValueError(
                     "Gripper Offset values for Absorbance Reader Lid labware must not be None."
                 )
 
-            # Skips gripper moves when using virtual gripper
             await self._labware_movement.move_labware_with_gripper(
-                labware_id=loaded_lid.id,
+                labware_definition=lid_definition,
                 current_location=current_location,
                 new_location=new_location,
                 user_offset_data=lid_gripper_offsets,
                 post_drop_slide_offset=None,
             )
-            new_offset_id = self._equipment.find_applicable_labware_offset_id(
-                labware_definition_uri=loaded_lid.definitionUri,
-                labware_location=new_location,
+            state_update.set_absorbance_reader_lid(
+                module_id=mod_substate.module_id, is_lid_on=False
             )
 
-        state_update = StateUpdate()
-
-        state_update.set_labware_location(
-            labware_id=loaded_lid.id,
-            new_location=new_location,
-            new_offset_id=new_offset_id,
-        )
-
         return SuccessData(
             public=OpenLidResult(),
             state_update=state_update,

opentrons/protocol_engine/commands/load_labware.py

@@ -10,6 +10,8 @@ from ..errors import LabwareIsNotAllowedInLocationError
 from ..resources import labware_validation, fixture_validation
 from ..types import (
     LabwareLocation,
+    ModuleLocation,
+    ModuleModel,
     OnLabwareLocation,
     DeckSlotLocation,
     AddressableAreaLocation,
@@ -160,6 +162,13 @@ class LoadLabwareImplementation(
                 top_labware_definition=loaded_labware.definition,
                 bottom_labware_id=verified_location.labwareId,
             )
+        # Validate labware for the absorbance reader
+        elif isinstance(params.location, ModuleLocation):
+            module = self._state_view.modules.get(params.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(
+                    loaded_labware.definition
+                )
 
         return SuccessData(
             public=LoadLabwareResult(

opentrons/protocol_engine/commands/load_module.py

@@ -5,7 +5,6 @@ from typing_extensions import Literal
 from pydantic import BaseModel, Field
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
-from ..errors import ModuleNotLoadedError
 from ..errors.error_occurrence import ErrorOccurrence
 from ..types import (
     DeckSlotLocation,
@@ -17,7 +16,6 @@ from opentrons.types import DeckSlotName
 
 from opentrons.protocol_engine.resources import deck_configuration_provider
 
-from opentrons.drivers.types import AbsorbanceReaderLidStatus
 
 if TYPE_CHECKING:
     from ..state.state import StateView
@@ -152,43 +150,6 @@ class LoadModuleImplementation(
                 module_id=params.moduleId,
             )
 
-        # Handle lid position update for loaded Plate Reader module on deck
-        if (
-            not self._state_view.config.use_virtual_modules
-            and params.model == ModuleModel.ABSORBANCE_READER_V1
-            and params.moduleId is not None
-        ):
-            try:
-                abs_reader = self._equipment.get_module_hardware_api(
-                    self._state_view.modules.get_absorbance_reader_substate(
-                        params.moduleId
-                    ).module_id
-                )
-            except ModuleNotLoadedError:
-                abs_reader = None
-
-            if abs_reader is not None:
-                result = await abs_reader.get_current_lid_status()
-                if (
-                    isinstance(result, AbsorbanceReaderLidStatus)
-                    and result is not AbsorbanceReaderLidStatus.ON
-                ):
-                    reader_area = self._state_view.modules.ensure_and_convert_module_fixture_location(
-                        params.location.slotName,
-                        self._state_view.config.deck_type,
-                        params.model,
-                    )
-                    lid_labware = self._state_view.labware.get_by_addressable_area(
-                        reader_area
-                    )
-
-                    if lid_labware is not None:
-                        self._state_view.labware._state.labware_by_id[
-                            lid_labware.id
-                        ].location = self._state_view.modules.absorbance_reader_dock_location(
-                            params.moduleId
-                        )
-
         return SuccessData(
             public=LoadModuleResult(
                 moduleId=loaded_module.module_id,

opentrons/protocol_engine/commands/move_labware.py

@@ -13,16 +13,22 @@ 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,
@@ -130,6 +136,7 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
         )
         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(
@@ -138,9 +145,11 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
 
         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}"
                 )
@@ -162,6 +171,32 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                     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
@@ -188,6 +223,13 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 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(
@@ -232,6 +274,9 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 dropOffset=params.dropOffset or LabwareOffsetVector(x=0, y=0, z=0),
             )
 
+            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(

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -1,10 +1,13 @@
 """Place labware payload, result, and implementaiton."""
 
 from __future__ import annotations
-from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type, cast
+from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons_shared_data.labware.types import LabwareUri
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from pydantic import BaseModel, Field
+
 from opentrons.hardware_control.types import Axis, OT3Mount
 from opentrons.motion_planning.waypoints import get_gripper_labware_placement_waypoints
 from opentrons.protocol_engine.errors.exceptions import (
@@ -13,11 +16,14 @@ from opentrons.protocol_engine.errors.exceptions import (
 )
 from opentrons.types import Point
 
-from ...types import DeckSlotLocation, ModuleModel, OnDeckLabwareLocation
+from ...types import (
+    DeckSlotLocation,
+    ModuleModel,
+    OnDeckLabwareLocation,
+)
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 from ...resources import ensure_ot3_hardware
-from ...state.update_types import StateUpdate
 
 from opentrons.hardware_control import HardwareControlAPI, OT3HardwareControlAPI
 
@@ -32,7 +38,7 @@ UnsafePlaceLabwareCommandType = Literal["unsafe/placeLabware"]
 class UnsafePlaceLabwareParams(BaseModel):
     """Payload required for an UnsafePlaceLabware command."""
 
-    labwareId: str = Field(..., description="The id of the labware to place.")
+    labwareURI: str = Field(..., description="Labware URI for labware.")
     location: OnDeckLabwareLocation = Field(
         ..., description="Where to place the labware."
     )
@@ -71,8 +77,8 @@ class UnsafePlaceLabwareImplementation(
         is pressed, get into error recovery, etc).
 
         Unlike the `moveLabware` command, where you pick a source and destination
-        location, this command takes the labwareId to be moved and location to
-        move it to.
+        location, this command takes the labwareURI of the labware to be moved
+        and location to move it to.
 
         """
         ot3api = ensure_ot3_hardware(self._hardware_api)
@@ -84,23 +90,37 @@ class UnsafePlaceLabwareImplementation(
                 "Cannot place labware when gripper is not gripping."
             )
 
-        # Allow propagation of LabwareNotLoadedError.
-        labware_id = params.labwareId
-        definition_uri = self._state_view.labware.get(labware_id).definitionUri
-        final_offsets = self._state_view.labware.get_labware_gripper_offsets(
-            labware_id, None
+        location = self._state_view.geometry.ensure_valid_gripper_location(
+            params.location,
+        )
+
+        definition = self._state_view.labware.get_definition_by_uri(
+            # todo(mm, 2024-11-07): This is an unsafe cast from untrusted input.
+            # We need a str -> LabwareUri parse/validate function.
+            LabwareUri(params.labwareURI)
+        )
+
+        # todo(mm, 2024-11-06): This is only correct in the special case of an
+        # absorbance reader lid. Its definition currently puts the offsets for *itself*
+        # in the property that's normally meant for offsets for its *children.*
+        final_offsets = self._state_view.labware.get_child_gripper_offsets(
+            labware_definition=definition, slot_name=None
+        )
+        drop_offset = (
+            Point(
+                final_offsets.dropOffset.x,
+                final_offsets.dropOffset.y,
+                final_offsets.dropOffset.z,
+            )
+            if final_offsets
+            else None
         )
-        drop_offset = cast(Point, final_offsets.dropOffset) if final_offsets else None
 
         if isinstance(params.location, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.location.slotName.id
             )
 
-        location = self._state_view.geometry.ensure_valid_gripper_location(
-            params.location,
-        )
-
         # This is an absorbance reader, move the lid to its dock (staging area).
         if isinstance(location, DeckSlotLocation):
             module = self._state_view.modules.get_by_slot(location.slotName)
@@ -109,30 +129,24 @@ class UnsafePlaceLabwareImplementation(
                     module.id
                 )
 
-        new_offset_id = self._equipment.find_applicable_labware_offset_id(
-            labware_definition_uri=definition_uri,
-            labware_location=location,
-        )
-
-        # NOTE: When the estop is pressed, the gantry loses position,
-        # so the robot needs to home x, y to sync.
-        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G, Axis.X, Axis.Y])
-        state_update = StateUpdate()
+        # NOTE: When the estop is pressed, the gantry loses position, lets use
+        # the encoders to sync position.
+        # Ideally, we'd do a full home, but this command is used when
+        # the gripper is holding the plate reader, and a full home would
+        # bang it into the right window.
+        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
+        await ot3api.engage_axes([Axis.X, Axis.Y])
+        await ot3api.update_axis_position_estimations([Axis.X, Axis.Y])
 
         # Place the labware down
-        await self._start_movement(ot3api, labware_id, location, drop_offset)
+        await self._start_movement(ot3api, definition, location, drop_offset)
 
-        state_update.set_labware_location(
-            labware_id=labware_id,
-            new_location=location,
-            new_offset_id=new_offset_id,
-        )
-        return SuccessData(public=UnsafePlaceLabwareResult(), state_update=state_update)
+        return SuccessData(public=UnsafePlaceLabwareResult())
 
     async def _start_movement(
         self,
         ot3api: OT3HardwareControlAPI,
-        labware_id: str,
+        labware_definition: LabwareDefinition,
         location: OnDeckLabwareLocation,
         drop_offset: Optional[Point],
     ) -> None:
@@ -142,7 +156,7 @@ class UnsafePlaceLabwareImplementation(
         )
 
         to_labware_center = self._state_view.geometry.get_labware_grip_point(
-            labware_id=labware_id, location=location
+            labware_definition=labware_definition, location=location
         )
 
         movement_waypoints = get_gripper_labware_placement_waypoints(

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -23,7 +23,11 @@ class UpdatePositionEstimatorsParams(BaseModel):
     """Payload required for an UpdatePositionEstimators command."""
 
     axes: List[MotorAxis] = Field(
-        ..., description="The axes for which to update the position estimators."
+        ...,
+        description=(
+            "The axes for which to update the position estimators."
+            " Any axes that are not physically present will be ignored."
+        ),
     )
 
 

opentrons/protocol_engine/create_protocol_engine.py

@@ -8,6 +8,9 @@ from opentrons.hardware_control.types import DoorState
 from opentrons.protocol_engine.execution.error_recovery_hardware_state_synchronizer import (
     ErrorRecoveryHardwareStateSynchronizer,
 )
+from opentrons.protocol_engine.resources.labware_data_provider import (
+    LabwareDataProvider,
+)
 from opentrons.util.async_helpers import async_context_manager_in_thread
 
 from opentrons_shared_data.robot import load as load_robot
@@ -81,7 +84,7 @@ async def create_protocol_engine(
     module_data_provider = ModuleDataProvider()
     file_provider = file_provider or FileProvider()
 
-    return ProtocolEngine(
+    pe = ProtocolEngine(
         hardware_api=hardware_api,
         state_store=state_store,
         action_dispatcher=action_dispatcher,
@@ -93,6 +96,20 @@ async def create_protocol_engine(
         file_provider=file_provider,
     )
 
+    # todo(mm, 2024-11-08): This is a quick hack to support the absorbance reader, which
+    # expects the engine to have this special labware definition available. It would be
+    # cleaner for the `loadModule` command to do this I/O and insert the definition
+    # into state. That gets easier after https://opentrons.atlassian.net/browse/EXEC-756.
+    #
+    # NOTE: This needs to stay in sync with LabwareView.get_absorbance_reader_lid_definition().
+    pe.add_labware_definition(
+        await LabwareDataProvider().get_labware_definition(
+            "opentrons_flex_lid_absorbance_plate_reader_module", "opentrons", 1
+        )
+    )
+
+    return pe
+
 
 @contextlib.contextmanager
 def create_protocol_engine_in_thread(

opentrons/protocol_engine/errors/__init__.py

@@ -55,6 +55,7 @@ from .exceptions import (
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
     InvalidHoldTimeError,
+    InvalidWavelengthError,
     CannotPerformModuleAction,
     PauseNotAllowedError,
     ResumeFromRecoveryNotAllowedError,
@@ -137,6 +138,7 @@ __all__ = [
     "InvalidTargetSpeedError",
     "InvalidBlockVolumeError",
     "InvalidHoldTimeError",
+    "InvalidWavelengthError",
     "CannotPerformModuleAction",
     "ResumeFromRecoveryNotAllowedError",
     "PauseNotAllowedError",

opentrons/protocol_engine/errors/exceptions.py

@@ -773,6 +773,19 @@ class InvalidBlockVolumeError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class InvalidWavelengthError(ProtocolEngineError):
+    """Raised when attempting to set an invalid absorbance wavelength."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a InvalidWavelengthError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class InvalidHoldTimeError(ProtocolEngineError):
     """An error raised when attempting to set an invalid temperature hold time."""