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

opentrons/drivers/absorbance_reader/async_byonoy.py

@@ -23,9 +23,8 @@ from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnect
 
 
 SN_PARSER = re.compile(r'ATTRS{serial}=="(?P<serial>.+?)"')
-# match semver V0.0.0 (old format) or one integer (latest format)
-VERSION_PARSER = re.compile(r"(?P<version>(V\d+\.\d+\.\d+|^\d+$))")
-SERIAL_PARSER = re.compile(r"(?P<serial>(OPT|BYO)[A-Z]{3}[0-9]+)")
+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})")
 
 
 class AsyncByonoy:
@@ -158,9 +157,9 @@ class AsyncByonoy:
         )
         self._raise_if_error(err.name, f"Error getting device information: {err}")
         serial_match = SERIAL_PARSER.match(device_info.sn)
-        version_match = VERSION_PARSER.search(device_info.version)
-        serial = serial_match["serial"].strip() if serial_match else "OPTMAA00000"
-        version = version_match["version"].lower() if version_match else "v0"
+        version_match = VERSION_PARSER.match(device_info.version)
+        serial = serial_match["serial"] if serial_match else "BYOMAA00000"
+        version = version_match["version"].lower() if version_match else "v0.0.0"
         info = {
             "serial": serial,
             "version": version,

opentrons/hardware_control/backends/ot3utils.py

@@ -652,7 +652,6 @@ _gripper_jaw_state_lookup: Dict[FirmwareGripperjawState, GripperJawState] = {
     FirmwareGripperjawState.force_controlling_home: GripperJawState.HOMED_READY,
     FirmwareGripperjawState.force_controlling: GripperJawState.GRIPPING,
     FirmwareGripperjawState.position_controlling: GripperJawState.HOLDING,
-    FirmwareGripperjawState.stopped: GripperJawState.STOPPED,
 }
 
 

opentrons/hardware_control/modules/absorbance_reader.py

@@ -312,8 +312,6 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         log.debug(f"Updating {self.name}: {self.port} with {firmware_file_path}")
         self._updating = True
         success, res = await self._driver.update_firmware(firmware_file_path)
-        # it takes time for the plate reader to re-init after an update.
-        await asyncio.sleep(10)
         self._device_info = await self._driver.get_device_info()
         await self._poller.start()
         self._updating = False

opentrons/hardware_control/ot3api.py

@@ -775,12 +775,12 @@ class OT3API(
         """
         Function to update motor estimation for a set of axes
         """
-        if axes is None:
-            axes = [ax for ax in Axis]
 
-        axes = [ax for ax in axes if self._backend.axis_is_present(ax)]
-
-        await self._backend.update_motor_estimation(axes)
+        if axes:
+            checked_axes = [ax for ax in axes if ax in Axis]
+        else:
+            checked_axes = [ax for ax in Axis]
+        await self._backend.update_motor_estimation(checked_axes)
 
     # Global actions API
     def pause(self, pause_type: PauseType) -> None:

opentrons/hardware_control/protocols/position_estimator.py

@@ -10,7 +10,7 @@ class PositionEstimator(Protocol):
         """Update the specified axes' position estimators from their encoders.
 
         This will allow these axes to make a non-home move even if they do not currently have
-        a position estimation (unless there is no tracked position from the encoders, as would be
+        a position estimation (unless there is no tracked poition from the encoders, as would be
         true immediately after boot).
 
         Axis encoders have less precision than their position estimators. Calling this function will
@@ -19,8 +19,6 @@ class PositionEstimator(Protocol):
 
         This function updates only the requested axes. If other axes have bad position estimation,
         moves that require those axes or attempts to get the position of those axes will still fail.
-        Axes that are not currently available (like a plunger for a pipette that is not connected)
-        will be ignored.
         """
         ...
 

opentrons/hardware_control/types.py

@@ -625,8 +625,6 @@ class GripperJawState(enum.Enum):
     #: the gripper is actively force-control gripping something
     HOLDING = enum.auto()
     #: the gripper is in position-control mode
-    STOPPED = enum.auto()
-    #: the gripper has been homed before but is stopped now
 
 
 class InstrumentProbeType(enum.Enum):

opentrons/legacy_commands/helpers.py

@@ -49,9 +49,7 @@ def stringify_disposal_location(location: Union[TrashBin, WasteChute]) -> str:
 
 
 def _stringify_labware_movement_location(
-    location: Union[
-        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
-    ]
+    location: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute]
 ) -> str:
     if isinstance(location, (int, str)):
         return f"slot {location}"
@@ -63,15 +61,11 @@ 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, TrashBin
-    ],
+    destination: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute],
     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, StagingSlotName
+from opentrons.types import DeckSlotName, Point
 from opentrons.hardware_control.nozzle_manager import NozzleMap
 
 
@@ -139,10 +139,6 @@ 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(
@@ -190,13 +186,9 @@ class LabwareCore(AbstractLabware[WellCore]):
     def get_deck_slot(self) -> Optional[DeckSlotName]:
         """Get the deck slot the labware is in, if on deck."""
         try:
-            ancestor = self._engine_client.state.geometry.get_ancestor_slot_name(
+            return 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,11 +41,6 @@ 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:
@@ -586,39 +581,7 @@ class AbsorbanceReaderCore(ModuleCore, AbstractAbsorbanceReaderCore):
                 "Cannot perform Initialize action on Absorbance Reader without calling `.close_lid()` first."
             )
 
-        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."
-                )
-
+        # TODO: check that the wavelengths are within the supported wavelengths
         self._engine_client.execute_command(
             cmd.absorbance_reader.InitializeParams(
                 moduleId=self.module_id,

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -9,7 +9,6 @@ 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
@@ -64,7 +63,7 @@ _FLEX_TC_LID_FRONT_RIGHT_PT = Point(
 )
 
 
-def check_safe_for_pipette_movement(  # noqa: C901
+def check_safe_for_pipette_movement(
     engine_state: StateView,
     pipette_id: str,
     labware_id: str,
@@ -122,12 +121,8 @@ def check_safe_for_pipette_movement(  # noqa: C901
             f"Requested motion with the {primary_nozzle} nozzle partial configuration"
             f" is outside of robot bounds for the pipette."
         )
-    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
+
+    labware_slot = engine_state.geometry.get_ancestor_slot_name(labware_id)
 
     surrounding_slots = adjacent_slots_getters.get_surrounding_slots(
         slot=labware_slot.as_int(), robot_type=engine_state.config.robot_type
@@ -287,10 +282,8 @@ 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=labware_id).z
-        adapter_height = engine_state.labware.get_dimensions(
-            labware_id=tiprack_parent.labwareId
-        ).z
+        tiprack_height = engine_state.labware.get_dimensions(labware_id).z
+        adapter_height = engine_state.labware.get_dimensions(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,7 +329,6 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
-            TrashBin,
         ],
         use_gripper: bool,
         pause_for_manual_move: bool,
@@ -448,10 +447,40 @@ 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:
@@ -778,7 +807,6 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
-            TrashBin,
         ],
     ) -> LabwareLocation:
         if isinstance(location, LabwareCore):
@@ -795,7 +823,6 @@ class ProtocolCore(
             NonConnectedModuleCore,
             OffDeckType,
             WasteChute,
-            TrashBin,
         ]
     ) -> NonStackedLocation:
         if isinstance(location, (ModuleCore, NonConnectedModuleCore)):
@@ -809,5 +836,3 @@ 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,10 +97,6 @@ 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,11 +138,6 @@ 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,7 +277,6 @@ class LegacyProtocolCore(
             legacy_module_core.LegacyModuleCore,
             OffDeckType,
             WasteChute,
-            TrashBin,
         ],
         use_gripper: bool,
         pause_for_manual_move: bool,

opentrons/protocol_api/core/protocol.py

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

opentrons/protocol_api/module_contexts.py

@@ -3,8 +3,6 @@ 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
@@ -161,18 +159,7 @@ 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,
@@ -581,7 +568,7 @@ class ThermocyclerContext(ModuleContext):
                                  individual well of the loaded labware, in µL.
                                  If not specified, the default is 25 µL.
 
-        .. note::
+        .. note:
 
             If ``hold_time_minutes`` and ``hold_time_seconds`` are not
             specified, the Thermocycler will proceed to the next command
@@ -605,7 +592,7 @@ class ThermocyclerContext(ModuleContext):
         :param temperature: A value between 37 and 110, representing the target
                             temperature in °C.
 
-        .. note::
+        .. note:
 
             The Thermocycler will proceed to the next command immediately after
             ``temperature`` has been reached.
@@ -635,13 +622,13 @@ class ThermocyclerContext(ModuleContext):
                                  individual well of the loaded labware, in µL.
                                  If not specified, the default is 25 µL.
 
-        .. note::
+        .. note:
 
             Unlike with :py:meth:`set_block_temperature`, either or both of
             ``hold_time_minutes`` and ``hold_time_seconds`` must be defined
             and for each step.
 
-        .. note::
+        .. note:
 
             Before API Version 2.21, Thermocycler profiles run with this command
             would be listed in the app as having a number of repetitions equal to
@@ -991,7 +978,7 @@ class MagneticBlockContext(ModuleContext):
 
 
 class AbsorbanceReaderContext(ModuleContext):
-    """An object representing a connected Absorbance Plate Reader Module.
+    """An object representing a connected Absorbance Reader Module.
 
     It should not be instantiated directly; instead, it should be
     created through :py:meth:`.ProtocolContext.load_module`.
@@ -1009,21 +996,17 @@ class AbsorbanceReaderContext(ModuleContext):
 
     @requires_version(2, 21)
     def close_lid(self) -> None:
-        """Use the Flex Gripper to close the lid of the Absorbance Plate Reader.
-
-        You must call this method before initializing the reader, even if the reader was
-        in the closed position at the start of the protocol.
-        """
+        """Close the lid of the Absorbance Reader."""
         self._core.close_lid()
 
     @requires_version(2, 21)
     def open_lid(self) -> None:
-        """Use the Flex Gripper to open the lid of the Absorbance Plate Reader."""
+        """Open the lid of the Absorbance Reader."""
         self._core.open_lid()
 
     @requires_version(2, 21)
     def is_lid_on(self) -> bool:
-        """Return ``True`` if the Absorbance Plate Reader's lid is currently closed."""
+        """Return ``True`` if the Absorbance Reader's lid is currently closed."""
         return self._core.is_lid_on()
 
     @requires_version(2, 21)
@@ -1033,28 +1016,19 @@ class AbsorbanceReaderContext(ModuleContext):
         wavelengths: List[int],
         reference_wavelength: Optional[int] = None,
     ) -> None:
-        """Prepare the Absorbance Plate Reader to read a plate.
-
-        See :ref:`absorbance-initialization` for examples.
+        """Take a zero reading on the Absorbance Plate Reader Module.
 
         :param mode: Either ``"single"`` or ``"multi"``.
 
-            - In single measurement mode, :py:meth:`.AbsorbanceReaderContext.read` uses
-              one sample wavelength and an optional reference wavelength.
-            - In multiple measurement mode, :py:meth:`.AbsorbanceReaderContext.read` uses
-              a list of up to six sample wavelengths.
-        :param wavelengths: A list of wavelengths, in nm, to measure.
-
-            - In the default hardware configuration, each wavelength must be one of
-              ``450`` (blue), ``562`` (green), ``600`` (orange), or ``650`` (red). In
-              custom hardware configurations, the module may accept other integers
-              between 350 and 1000.
-            - The list must contain only one item when initializing a single measurement.
-            - The list can contain one to six items when initializing a multiple measurement.
-        :param reference_wavelength: An optional reference wavelength, in nm. If provided,
-            :py:meth:`.AbsorbanceReaderContext.read` will read at the reference
-            wavelength and then subtract the reference wavelength values from the
-            measurement wavelength values. Can only be used with single measurements.
+             - In single measurement mode, :py:meth:`.AbsorbanceReaderContext.read` uses
+               one sample wavelength and an optional reference wavelength.
+             - In multiple measurement mode, :py:meth:`.AbsorbanceReaderContext.read` uses
+               a list of up to six sample wavelengths.
+        :param wavelengths: A list of wavelengths, in mm, to measure.
+             - Must contain only one item when initializing a single measurement.
+             - Must contain one to six items when initializing a multiple measurement.
+        :param reference_wavelength: An optional reference wavelength, in mm. Cannot be
+             used with multiple measurements.
         """
         self._core.initialize(
             mode, wavelengths, reference_wavelength=reference_wavelength
@@ -1064,33 +1038,16 @@ class AbsorbanceReaderContext(ModuleContext):
     def read(
         self, export_filename: Optional[str] = None
     ) -> Dict[int, Dict[str, float]]:
-        """Read a plate on the Absorbance Plate Reader.
-
-        This method always returns a dictionary of measurement data. It optionally will
-        save a CSV file of the results to the Flex filesystem, which you can access from
-        the Recent Protocol Runs screen in the Opentrons App. These files are `only` saved
-        if you specify ``export_filename``.
-
-        In simulation, the values for each well key in the dictionary are set to zero, and
-        no files are written.
-
-        .. note::
-
-            Avoid divide-by-zero errors when simulating and using the results of this
-            method later in the protocol. If you divide by any of the measurement
-            values, use :py:meth:`.ProtocolContext.is_simulating` to use alternate dummy
-            data or skip the division step.
+        """Initiate read on the Absorbance Reader.
 
-        :param export_filename: An optional file basename. If provided, this method
-            will write a CSV file for each measurement in the read operation. File
-            names will use the value of this parameter, the measurement wavelength
-            supplied in :py:meth:`~.AbsorbanceReaderContext.initialize`, and a
-            ``.csv`` extension. For example, when reading at wavelengths 450 and 562
-            with ``export_filename="my_data"``, there will be two output files:
-            ``my_data_450.csv`` and ``my_data_562.csv``.
+        Returns a dictionary of wavelengths to dictionary of values ordered by well name.
 
-            See :ref:`absorbance-csv` for information on working with these CSV files.
+        :param export_filename: Optional, if a filename is provided a CSV file will be saved
+             as a result of the read action containing measurement data. The filename will
+             be modified to include the wavelength used during measurement. If multiple
+             measurements are taken, then a file will be generated for each wavelength provided.
 
-        :returns: A dictionary of wavelengths to dictionary of values ordered by well name.
+        Example: If `export_filename="my_data"` and wavelengths 450 and 531 are used during
+        measurement, the output files will be "my_data_450.csv" and "my_data_531.csv".
         """
         return self._core.read(filename=export_filename)

opentrons/protocol_api/protocol_context.py

@@ -45,7 +45,6 @@ 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
@@ -669,7 +668,7 @@ class ProtocolContext(CommandPublisher):
         self,
         labware: Labware,
         new_location: Union[
-            DeckLocation, Labware, ModuleTypes, OffDeckType, WasteChute, TrashBin
+            DeckLocation, Labware, ModuleTypes, OffDeckType, WasteChute
         ],
         use_gripper: bool = False,
         pick_up_offset: Optional[Mapping[str, float]] = None,
@@ -714,8 +713,7 @@ class ProtocolContext(CommandPublisher):
                 f"Expected labware of type 'Labware' but got {type(labware)}."
             )
 
-        # 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.
+        # Ensure that when moving to an absorbance reader than the lid is open
         if isinstance(new_location, AbsorbanceReaderContext):
             if new_location.is_lid_on():
                 raise CommandPreconditionViolated(
@@ -729,19 +727,11 @@ 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,6 +28,7 @@ from .actions import (
     DoorChangeAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
+    AddAbsorbanceReaderLidAction,
 )
 from .get_state_update import get_state_updates
 
@@ -57,6 +58,7 @@ __all__ = [
     "DoorChangeAction",
     "ResetTipsAction",
     "SetPipetteMovementSpeedAction",
+    "AddAbsorbanceReaderLidAction",
     # action payload values
     "PauseSource",
     "FinishErrorDetails",

opentrons/protocol_engine/actions/actions.py

@@ -271,6 +271,17 @@ 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()`."""
@@ -298,5 +309,6 @@ Action = Union[
     AddLiquidAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
+    AddAbsorbanceReaderLidAction,
     SetErrorRecoveryPolicyAction,
 ]

opentrons/protocol_engine/clients/sync_client.py

@@ -119,6 +119,12 @@ 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: