opentrons 8.2.0a0__py2.py3-none-any.whl → 8.2.0a2__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/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]
 
-        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)
+        axes = [ax for ax in axes if self._backend.axis_is_present(ax)]
+
+        await self._backend.update_motor_estimation(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 poition from the encoders, as would be
+        a position estimation (unless there is no tracked position from the encoders, as would be
         true immediately after boot).
 
         Axis encoders have less precision than their position estimators. Calling this function will
@@ -19,6 +19,8 @@ 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/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/initialize.py

@@ -10,6 +10,7 @@ from opentrons.protocol_engine.types import ABSMeasureMode
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
+from ...errors import InvalidWavelengthError
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
@@ -69,30 +70,41 @@ class InitializeImpl(
             unsupported_wavelengths = sample_wavelengths.difference(
                 supported_wavelengths
             )
+            sample_wl_str = ", ".join([str(w) + "nm" for w in sample_wavelengths])
+            supported_wl_str = ", ".join([str(w) + "nm" for w in supported_wavelengths])
+            unsupported_wl_str = ", ".join(
+                [str(w) + "nm" for w in unsupported_wavelengths]
+            )
             if unsupported_wavelengths:
-                raise ValueError(f"Unsupported wavelengths: {unsupported_wavelengths}")
+                raise InvalidWavelengthError(
+                    f"Unsupported wavelengths: {unsupported_wl_str}. "
+                    f" Use one of {supported_wl_str} instead."
+                )
 
             if params.measureMode == "single":
                 if sample_wavelengths_len != 1:
                     raise ValueError(
-                        f"single requires one sample wavelength, provided {sample_wavelengths}"
+                        f"Measure mode `single` requires one sample wavelength,"
+                        f" {sample_wl_str} provided instead."
                     )
                 if (
                     reference_wavelength is not None
                     and reference_wavelength not in supported_wavelengths
                 ):
-                    raise ValueError(
-                        f"Reference wavelength {reference_wavelength} not supported {supported_wavelengths}"
+                    raise InvalidWavelengthError(
+                        f"Reference wavelength {reference_wavelength}nm is not supported."
+                        f" Use one of {supported_wl_str} instead."
                     )
 
             if params.measureMode == "multi":
                 if sample_wavelengths_len < 1 or sample_wavelengths_len > 6:
                     raise ValueError(
-                        f"multi requires 1-6 sample wavelengths, provided {sample_wavelengths}"
+                        f"Measure mode `multi` requires 1-6 sample wavelengths,"
+                        f" {sample_wl_str} provided instead."
                     )
                 if reference_wavelength is not None:
-                    raise RuntimeError(
-                        "Reference wavelength cannot be used with multi mode."
+                    raise ValueError(
+                        "Reference wavelength cannot be used with Measure mode `multi`."
                     )
 
             await abs_reader.set_sample_wavelength(