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

opentrons/drivers/absorbance_reader/async_byonoy.py

@@ -24,7 +24,7 @@ from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnect
 
 SN_PARSER = re.compile(r'ATTRS{serial}=="(?P<serial>.+?)"')
 VERSION_PARSER = re.compile(r"Absorbance (?P<version>V\d+\.\d+\.\d+)")
-SERIAL_PARSER = re.compile(r"(?P<serial>BYO[A-Z]{3}[0-9]{5})")
+SERIAL_PARSER = re.compile(r"(?P<serial>(OPT|BYO)[A-Z]{3}[0-9]+)")
 
 
 class AsyncByonoy:
@@ -156,9 +156,9 @@ class AsyncByonoy:
             func=partial(self._interface.get_device_information, handle),
         )
         self._raise_if_error(err.name, f"Error getting device information: {err}")
-        serial_match = SERIAL_PARSER.match(device_info.sn)
+        serial_match = SERIAL_PARSER.fullmatch(device_info.sn)
         version_match = VERSION_PARSER.match(device_info.version)
-        serial = serial_match["serial"] if serial_match else "BYOMAA00000"
+        serial = serial_match["serial"].strip() if serial_match else "OPTMAA00000"
         version = version_match["version"].lower() if version_match else "v0.0.0"
         info = {
             "serial": serial,

opentrons/legacy_commands/helpers.py

@@ -49,7 +49,9 @@ def stringify_disposal_location(location: Union[TrashBin, WasteChute]) -> str:
 
 
 def _stringify_labware_movement_location(
-    location: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute]
+    location: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ]
 ) -> str:
     if isinstance(location, (int, str)):
         return f"slot {location}"
@@ -61,11 +63,15 @@ def _stringify_labware_movement_location(
         return str(location)
     elif isinstance(location, WasteChute):
         return "Waste Chute"
+    elif isinstance(location, TrashBin):
+        return "Trash Bin " + location.location.name
 
 
 def stringify_labware_movement_command(
     source_labware: Labware,
-    destination: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute],
+    destination: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ],
     use_gripper: bool,
 ) -> str:
     source_labware_text = _stringify_labware_movement_location(source_labware)

opentrons/protocol_api/core/engine/labware.py

@@ -19,7 +19,7 @@ from opentrons.protocol_engine.types import (
     LabwareOffsetCreate,
     LabwareOffsetVector,
 )
-from opentrons.types import DeckSlotName, Point
+from opentrons.types import DeckSlotName, Point, StagingSlotName
 from opentrons.hardware_control.nozzle_manager import NozzleMap
 
 
@@ -139,6 +139,10 @@ class LabwareCore(AbstractLabware[WellCore]):
         """Whether the labware is an adapter."""
         return LabwareRole.adapter in self._definition.allowedRoles
 
+    def is_lid(self) -> bool:
+        """Whether the labware is a lid."""
+        return LabwareRole.lid in self._definition.allowedRoles
+
     def is_fixed_trash(self) -> bool:
         """Whether the labware is a fixed trash."""
         return self._engine_client.state.labware.is_fixed_trash(
@@ -186,9 +190,13 @@ class LabwareCore(AbstractLabware[WellCore]):
     def get_deck_slot(self) -> Optional[DeckSlotName]:
         """Get the deck slot the labware is in, if on deck."""
         try:
-            return self._engine_client.state.geometry.get_ancestor_slot_name(
+            ancestor = self._engine_client.state.geometry.get_ancestor_slot_name(
                 self.labware_id
             )
+            if isinstance(ancestor, StagingSlotName):
+                # The only use case for get_deck_slot is with a legacy OT-2 function which resolves to a numerical deck slot, so we can ignore staging area slots for now
+                return None
+            return ancestor
         except (
             LabwareNotOnDeckError,
             ModuleNotOnDeckError,

opentrons/protocol_api/core/engine/module_core.py

@@ -41,6 +41,11 @@ from ..module import (
 from .exceptions import InvalidMagnetEngageHeightError
 
 
+# Valid wavelength range for absorbance reader
+ABS_WAVELENGTH_MIN = 350
+ABS_WAVELENGTH_MAX = 1000
+
+
 class ModuleCore(AbstractModuleCore):
     """Module core logic implementation for Python protocols.
     Args:
@@ -581,7 +586,39 @@ class AbsorbanceReaderCore(ModuleCore, AbstractAbsorbanceReaderCore):
                 "Cannot perform Initialize action on Absorbance Reader without calling `.close_lid()` first."
             )
 
-        # TODO: check that the wavelengths are within the supported wavelengths
+        wavelength_len = len(wavelengths)
+        if mode == "single" and wavelength_len != 1:
+            raise ValueError(
+                f"Single mode can only be initialized with 1 wavelength"
+                f" {wavelength_len} wavelengths provided instead."
+            )
+
+        if mode == "multi" and (wavelength_len < 1 or wavelength_len > 6):
+            raise ValueError(
+                f"Multi mode can only be initialized with 1 - 6 wavelengths."
+                f" {wavelength_len} wavelengths provided instead."
+            )
+
+        if reference_wavelength is not None and (
+            reference_wavelength < ABS_WAVELENGTH_MIN
+            or reference_wavelength > ABS_WAVELENGTH_MAX
+        ):
+            raise ValueError(
+                f"Unsupported reference wavelength: ({reference_wavelength}) needs"
+                f" to between {ABS_WAVELENGTH_MIN} and {ABS_WAVELENGTH_MAX} nm."
+            )
+
+        for wavelength in wavelengths:
+            if (
+                not isinstance(wavelength, int)
+                or wavelength < ABS_WAVELENGTH_MIN
+                or wavelength > ABS_WAVELENGTH_MAX
+            ):
+                raise ValueError(
+                    f"Unsupported sample wavelength: ({wavelength}) needs"
+                    f" to between {ABS_WAVELENGTH_MIN} and {ABS_WAVELENGTH_MAX} nm."
+                )
+
         self._engine_client.execute_command(
             cmd.absorbance_reader.InitializeParams(
                 moduleId=self.module_id,

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -9,6 +9,7 @@ from typing import (
 )
 
 from opentrons_shared_data.errors.exceptions import MotionPlanningFailureError
+from opentrons.protocol_engine.errors import LocationIsStagingSlotError
 from opentrons_shared_data.module import FLEX_TC_LID_COLLISION_ZONE
 
 from opentrons.hardware_control import CriticalPoint
@@ -63,7 +64,7 @@ _FLEX_TC_LID_FRONT_RIGHT_PT = Point(
 )
 
 
-def check_safe_for_pipette_movement(
+def check_safe_for_pipette_movement(  # noqa: C901
     engine_state: StateView,
     pipette_id: str,
     labware_id: str,
@@ -121,8 +122,12 @@ def check_safe_for_pipette_movement(
             f"Requested motion with the {primary_nozzle} nozzle partial configuration"
             f" is outside of robot bounds for the pipette."
         )
-
-    labware_slot = engine_state.geometry.get_ancestor_slot_name(labware_id)
+    ancestor = engine_state.geometry.get_ancestor_slot_name(labware_id)
+    if isinstance(ancestor, StagingSlotName):
+        raise LocationIsStagingSlotError(
+            "Cannot perform pipette actions on labware in Staging Area Slot."
+        )
+    labware_slot = ancestor
 
     surrounding_slots = adjacent_slots_getters.get_surrounding_slots(
         slot=labware_slot.as_int(), robot_type=engine_state.config.robot_type
@@ -282,8 +287,10 @@ def check_safe_for_tip_pickup_and_return(
         is_96_ch_tiprack_adapter = engine_state.labware.get_has_quirk(
             labware_id=tiprack_parent.labwareId, quirk="tiprackAdapterFor96Channel"
         )
-        tiprack_height = engine_state.labware.get_dimensions(labware_id).z
-        adapter_height = engine_state.labware.get_dimensions(tiprack_parent.labwareId).z
+        tiprack_height = engine_state.labware.get_dimensions(labware_id=labware_id).z
+        adapter_height = engine_state.labware.get_dimensions(
+            labware_id=tiprack_parent.labwareId
+        ).z
         if is_partial_config and tiprack_height < adapter_height:
             raise PartialTipMovementNotAllowedError(
                 f"{tiprack_name} cannot be on an adapter taller than the tip rack"

opentrons/protocol_api/core/engine/protocol.py

@@ -329,6 +329,7 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
+            TrashBin,
         ],
         use_gripper: bool,
         pause_for_manual_move: bool,
@@ -447,40 +448,10 @@ class ProtocolCore(
             existing_module_ids=list(self._module_cores_by_id.keys()),
         )
 
-        # When the protocol engine is created, we add Module Lids as part of the deck fixed labware
-        # If a valid module exists in the deck config. For analysis, we add the labware here since
-        # deck fixed labware is not created under the same conditions. We also need to inject the Module
-        # lids when the module isnt already on the deck config, like when adding a new
-        # module during a protocol setup.
-        self._load_virtual_module_lid(module_core)
-
         self._module_cores_by_id[module_core.module_id] = module_core
 
         return module_core
 
-    def _load_virtual_module_lid(
-        self, module_core: Union[ModuleCore, NonConnectedModuleCore]
-    ) -> None:
-        if isinstance(module_core, AbsorbanceReaderCore):
-            substate = self._engine_client.state.modules.get_absorbance_reader_substate(
-                module_core.module_id
-            )
-            if substate.lid_id is None:
-                lid = self._engine_client.execute_command_without_recovery(
-                    cmd.LoadLabwareParams(
-                        loadName="opentrons_flex_lid_absorbance_plate_reader_module",
-                        location=ModuleLocation(moduleId=module_core.module_id),
-                        namespace="opentrons",
-                        version=1,
-                        displayName="Absorbance Reader Lid",
-                    )
-                )
-
-                self._engine_client.add_absorbance_reader_lid(
-                    module_id=module_core.module_id,
-                    lid_id=lid.labwareId,
-                )
-
     def _create_non_connected_module_core(
         self, load_module_result: LoadModuleResult
     ) -> NonConnectedModuleCore:
@@ -807,6 +778,7 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
+            TrashBin,
         ],
     ) -> LabwareLocation:
         if isinstance(location, LabwareCore):
@@ -823,6 +795,7 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
+            TrashBin,
         ]
     ) -> NonStackedLocation:
         if isinstance(location, (ModuleCore, NonConnectedModuleCore)):
@@ -836,3 +809,5 @@ class ProtocolCore(
         elif isinstance(location, WasteChute):
             # TODO(mm, 2023-12-06) This will need to determine the appropriate Waste Chute to return, but only move_labware uses this for now
             return AddressableAreaLocation(addressableAreaName="gripperWasteChute")
+        elif isinstance(location, TrashBin):
+            return AddressableAreaLocation(addressableAreaName=location.area_name)

opentrons/protocol_api/core/labware.py

@@ -97,6 +97,10 @@ class AbstractLabware(ABC, Generic[WellCoreType]):
     def is_adapter(self) -> bool:
         """Whether the labware is an adapter."""
 
+    @abstractmethod
+    def is_lid(self) -> bool:
+        """Whether the labware is a lid."""
+
     @abstractmethod
     def is_fixed_trash(self) -> bool:
         """Whether the labware is a fixed trash."""

opentrons/protocol_api/core/legacy/legacy_labware_core.py

@@ -138,6 +138,11 @@ class LegacyLabwareCore(AbstractLabware[LegacyWellCore]):
     def is_adapter(self) -> bool:
         return False  # Adapters were introduced in v2.15 and not supported in legacy protocols
 
+    def is_lid(self) -> bool:
+        return (
+            False  # Lids were introduced in v2.21 and not supported in legacy protocols
+        )
+
     def is_fixed_trash(self) -> bool:
         """Whether the labware is fixed trash."""
         return "fixedTrash" in self.get_quirks()

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -277,6 +277,7 @@ class LegacyProtocolCore(
             legacy_module_core.LegacyModuleCore,
             OffDeckType,
             WasteChute,
+            TrashBin,
         ],
         use_gripper: bool,
         pause_for_manual_move: bool,

opentrons/protocol_api/core/protocol.py

@@ -104,6 +104,7 @@ class AbstractProtocol(
             ModuleCoreType,
             OffDeckType,
             WasteChute,
+            TrashBin,
         ],
         use_gripper: bool,
         pause_for_manual_move: bool,

opentrons/protocol_api/module_contexts.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import logging
 from typing import List, Dict, Optional, Union, cast
 
+from opentrons_shared_data.errors.exceptions import CommandPreconditionViolated
+
 from opentrons.protocol_engine.types import ABSMeasureMode
 from opentrons_shared_data.labware.types import LabwareDefinition
 from opentrons_shared_data.module.types import ModuleModel, ModuleType
@@ -159,7 +161,18 @@ class ModuleContext(CommandPublisher):
             load_location = loaded_adapter._core
         else:
             load_location = self._core
+
         name = validation.ensure_lowercase_name(name)
+
+        # todo(mm, 2024-11-08): This check belongs in opentrons.protocol_api.core.engine.deck_conflict.
+        # We're currently doing it here, at the ModuleContext level, for consistency with what
+        # ProtocolContext.load_labware() does. (It should also be moved to the deck_conflict module.)
+        if isinstance(self._core, AbsorbanceReaderCore):
+            if self._core.is_lid_on():
+                raise CommandPreconditionViolated(
+                    f"Cannot load {name} onto the Absorbance Reader Module when its lid is closed."
+                )
+
         labware_core = self._protocol_core.load_labware(
             load_name=name,
             label=label,

opentrons/protocol_api/protocol_context.py

@@ -45,6 +45,7 @@ from opentrons.protocols.api_support.util import (
     UnsupportedAPIError,
 )
 from opentrons_shared_data.errors.exceptions import CommandPreconditionViolated
+from opentrons.protocol_engine.errors import LabwareMovementNotAllowedError
 
 from ._types import OffDeckType
 from .core.common import ModuleCore, LabwareCore, ProtocolCore
@@ -668,7 +669,7 @@ class ProtocolContext(CommandPublisher):
         self,
         labware: Labware,
         new_location: Union[
-            DeckLocation, Labware, ModuleTypes, OffDeckType, WasteChute
+            DeckLocation, Labware, ModuleTypes, OffDeckType, WasteChute, TrashBin
         ],
         use_gripper: bool = False,
         pick_up_offset: Optional[Mapping[str, float]] = None,
@@ -713,7 +714,8 @@ class ProtocolContext(CommandPublisher):
                 f"Expected labware of type 'Labware' but got {type(labware)}."
             )
 
-        # Ensure that when moving to an absorbance reader than the lid is open
+        # Ensure that when moving to an absorbance reader that the lid is open
+        # todo(mm, 2024-11-08): Unify this with opentrons.protocol_api.core.engine.deck_conflict.
         if isinstance(new_location, AbsorbanceReaderContext):
             if new_location.is_lid_on():
                 raise CommandPreconditionViolated(
@@ -727,11 +729,19 @@ class ProtocolContext(CommandPublisher):
             OffDeckType,
             DeckSlotName,
             StagingSlotName,
+            TrashBin,
         ]
         if isinstance(new_location, (Labware, ModuleContext)):
             location = new_location._core
         elif isinstance(new_location, (OffDeckType, WasteChute)):
             location = new_location
+        elif isinstance(new_location, TrashBin):
+            if labware._core.is_lid():
+                location = new_location
+            else:
+                raise LabwareMovementNotAllowedError(
+                    "Can only dispose of tips and Lid-type labware in a Trash Bin. Did you mean to use a Waste Chute?"
+                )
         else:
             location = validation.ensure_and_convert_deck_slot(
                 new_location, self._api_version, self._core.robot_type

opentrons/protocol_engine/actions/__init__.py

@@ -28,7 +28,6 @@ from .actions import (
     DoorChangeAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
-    AddAbsorbanceReaderLidAction,
 )
 from .get_state_update import get_state_updates
 
@@ -58,7 +57,6 @@ __all__ = [
     "DoorChangeAction",
     "ResetTipsAction",
     "SetPipetteMovementSpeedAction",
-    "AddAbsorbanceReaderLidAction",
     # action payload values
     "PauseSource",
     "FinishErrorDetails",

opentrons/protocol_engine/actions/actions.py

@@ -271,17 +271,6 @@ class SetPipetteMovementSpeedAction:
     speed: Optional[float]
 
 
-@dataclasses.dataclass(frozen=True)
-class AddAbsorbanceReaderLidAction:
-    """Add the absorbance reader lid id to the absorbance reader module substate.
-
-    This action is dispatched the absorbance reader module is first loaded.
-    """
-
-    module_id: str
-    lid_id: str
-
-
 @dataclasses.dataclass(frozen=True)
 class SetErrorRecoveryPolicyAction:
     """See `ProtocolEngine.set_error_recovery_policy()`."""
@@ -309,6 +298,5 @@ Action = Union[
     AddLiquidAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
-    AddAbsorbanceReaderLidAction,
     SetErrorRecoveryPolicyAction,
 ]

opentrons/protocol_engine/clients/sync_client.py

@@ -119,12 +119,6 @@ class SyncClient:
             "add_addressable_area", addressable_area_name=addressable_area_name
         )
 
-    def add_absorbance_reader_lid(self, module_id: str, lid_id: str) -> None:
-        """Add an absorbance reader lid to the module state."""
-        self._transport.call_method(
-            "add_absorbance_reader_lid", module_id=module_id, lid_id=lid_id
-        )
-
     def add_liquid(
         self, name: str, color: Optional[str], description: Optional[str]
     ) -> Liquid:

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -10,7 +10,6 @@ from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import CannotPerformModuleAction
 from opentrons.protocol_engine.types import AddressableAreaLocation
 
-from opentrons.protocol_engine.resources import labware_validation
 from ...state.update_types import StateUpdate
 
 
@@ -53,41 +52,35 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
 
     async def execute(self, params: CloseLidParams) -> SuccessData[CloseLidResult]:
         """Execute the close lid command."""
+        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.OFF
-        # 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 ON, no-op losing lid
         if hardware_lid_status is AbsorbanceReaderLidStatus.ON:
-            # The lid is already On, so we can no-op and return the lids current location data
-            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 ON, so we can no-op physically closing it
+            state_update.set_absorbance_reader_lid(
+                module_id=mod_substate.module_id, is_lid_on=True
             )
         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()
+            )
+
             current_location = self._state_view.modules.absorbance_reader_dock_location(
                 params.moduleId
             )
@@ -107,35 +100,29 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
                 )
             )
 
-            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=True,
             )
 
-        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=CloseLidResult(),
             state_update=state_update,

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(