opentrons 8.6.0__py3-none-any.whl

opentrons/protocol_engine/commands/absorbance_reader/__init__.py

@@ -0,0 +1,61 @@
+"""Command models for Absorbance Reader commands."""
+from .close_lid import (
+    CloseLidCommandType,
+    CloseLidParams,
+    CloseLidResult,
+    CloseLid,
+    CloseLidCreate,
+)
+
+from .open_lid import (
+    OpenLidCommandType,
+    OpenLidParams,
+    OpenLidResult,
+    OpenLid,
+    OpenLidCreate,
+)
+
+from .initialize import (
+    InitializeCommandType,
+    InitializeParams,
+    InitializeResult,
+    Initialize,
+    InitializeCreate,
+)
+
+from .read import (
+    ReadAbsorbanceCommandType,
+    ReadAbsorbanceParams,
+    ReadAbsorbanceResult,
+    ReadAbsorbance,
+    ReadAbsorbanceCreate,
+)
+
+
+__all__ = [
+    # absorbanace_reader/closeLid
+    "CloseLidCommandType",
+    "CloseLidParams",
+    "CloseLidResult",
+    "CloseLid",
+    "CloseLidCreate",
+    # absorbanace_reader/openLid
+    "OpenLidCommandType",
+    "OpenLidParams",
+    "OpenLidResult",
+    "OpenLid",
+    "OpenLidCreate",
+    # absorbanace_reader/initialize
+    "InitializeCommandType",
+    "InitializeParams",
+    "InitializeResult",
+    "Initialize",
+    "InitializeCreate",
+    # absorbanace_reader/measure
+    "ReadAbsorbanceCommandType",
+    "ReadAbsorbanceParams",
+    "ReadAbsorbanceResult",
+    "ReadAbsorbance",
+    "ReadAbsorbanceCreate",
+    # union type
+]

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -0,0 +1,154 @@
+"""Command models to close the lid on an Absorbance Reader."""
+from __future__ import annotations
+from typing import Optional, Literal, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...errors import CannotPerformModuleAction
+from opentrons.protocol_engine.types import AddressableAreaLocation
+
+from ...state.update_types import StateUpdate
+
+from .common import LID_Z_CLEARANCE
+
+from opentrons.types import Point
+
+from opentrons.drivers.types import AbsorbanceReaderLidStatus
+
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import (
+        EquipmentHandler,
+        LabwareMovementHandler,
+    )
+
+
+CloseLidCommandType = Literal["absorbanceReader/closeLid"]
+
+
+class CloseLidParams(BaseModel):
+    """Input parameters to close the lid on an absorbance reading."""
+
+    moduleId: str = Field(..., description="Unique ID of the absorbance reader.")
+
+
+class CloseLidResult(BaseModel):
+    """Result data from closing the lid on an aborbance reading."""
+
+
+class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResult]]):
+    """Execution implementation of closing the lid on an Absorbance Reader."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        labware_movement: LabwareMovementHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._labware_movement = labware_movement
+
+    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
+        )
+
+        hardware_lid_status = AbsorbanceReaderLidStatus.OFF
+        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:
+                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 hardware_lid_status is AbsorbanceReaderLidStatus.ON:
+            # 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
+            )
+
+            # we need to move the lid onto the module reader
+            absorbance_model = self._state_view.modules.get_requested_model(
+                params.moduleId
+            )
+            assert absorbance_model is not None
+            new_location = AddressableAreaLocation(
+                addressableAreaName=self._state_view.modules.ensure_and_convert_module_fixture_location(
+                    deck_slot=self._state_view.modules.get_location(
+                        params.moduleId
+                    ).slotName,
+                    model=absorbance_model,
+                )
+            )
+
+            # 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."
+                )
+
+            await self._labware_movement.move_labware_with_gripper(
+                labware_definition=lid_definition,
+                current_location=current_location,
+                new_location=new_location,
+                user_pick_up_offset=Point.from_xyz_attrs(
+                    lid_gripper_offsets.pickUpOffset
+                ),
+                user_drop_offset=Point.from_xyz_attrs(lid_gripper_offsets.dropOffset),
+                post_drop_slide_offset=None,
+                gripper_z_offset=LID_Z_CLEARANCE,
+            )
+            state_update.set_absorbance_reader_lid(
+                module_id=mod_substate.module_id,
+                is_lid_on=True,
+            )
+
+        return SuccessData(
+            public=CloseLidResult(),
+            state_update=state_update,
+        )
+
+
+class CloseLid(BaseCommand[CloseLidParams, CloseLidResult, ErrorOccurrence]):
+    """A command to close the lid on an Absorbance Reader."""
+
+    commandType: CloseLidCommandType = "absorbanceReader/closeLid"
+    params: CloseLidParams
+    result: Optional[CloseLidResult] = None
+
+    _ImplementationCls: Type[CloseLidImpl] = CloseLidImpl
+
+
+class CloseLidCreate(BaseCommandCreate[CloseLidParams]):
+    """A request to execute an Absorbance Reader close lid command."""
+
+    commandType: CloseLidCommandType = "absorbanceReader/closeLid"
+    params: CloseLidParams
+
+    _CommandCls: Type[CloseLid] = CloseLid

opentrons/protocol_engine/commands/absorbance_reader/common.py

@@ -0,0 +1,6 @@
+"""Common absorbance reader defines."""
+
+# This needs to be re-defined because of circular imports
+_PLATE_READER_MAX_LABWARE_Z_MM = 16.0
+# Distance to home the gripper when moving the plate reader lid to/from the dock.
+LID_Z_CLEARANCE = _PLATE_READER_MAX_LABWARE_Z_MM + 40.0

opentrons/protocol_engine/commands/absorbance_reader/initialize.py

@@ -0,0 +1,151 @@
+"""Command models to initialize an Absorbance Reader."""
+from __future__ import annotations
+from typing import List, Optional, Literal, TYPE_CHECKING, Any
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.drivers.types import ABSMeasurementMode
+from opentrons.protocol_engine.types import ABSMeasureMode
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...errors import InvalidWavelengthError
+from ...state import update_types
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+
+InitializeCommandType = Literal["absorbanceReader/initialize"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class InitializeParams(BaseModel):
+    """Input parameters to initialize an absorbance reading."""
+
+    moduleId: str = Field(..., description="Unique ID of the absorbance reader.")
+    measureMode: ABSMeasureMode = Field(
+        ..., description="Initialize single or multi measurement mode."
+    )
+    sampleWavelengths: List[int] = Field(..., description="Sample wavelengths in nm.")
+    referenceWavelength: int | SkipJsonSchema[None] = Field(
+        None,
+        description="Optional reference wavelength in nm.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class InitializeResult(BaseModel):
+    """Result data from initializing an aborbance reading."""
+
+
+class InitializeImpl(
+    AbstractCommandImpl[InitializeParams, SuccessData[InitializeResult]]
+):
+    """Execution implementation of initializing an Absorbance Reader."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+
+    async def execute(self, params: InitializeParams) -> SuccessData[InitializeResult]:
+        """Initiate a single absorbance measurement."""
+        state_update = update_types.StateUpdate()
+        abs_reader_substate = self._state_view.modules.get_absorbance_reader_substate(
+            module_id=params.moduleId
+        )
+        # Allow propagation of ModuleNotAttachedError.
+        abs_reader = self._equipment.get_module_hardware_api(
+            abs_reader_substate.module_id
+        )
+
+        if abs_reader is not None:
+            # Validate the parameters before initializing.
+            sample_wavelengths = set(params.sampleWavelengths)
+            sample_wavelengths_len = len(params.sampleWavelengths)
+            reference_wavelength = params.referenceWavelength
+            supported_wavelengths = set(abs_reader.supported_wavelengths)
+            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 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"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 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"Measure mode `multi` requires 1-6 sample wavelengths,"
+                        f" {sample_wl_str} provided instead."
+                    )
+                if reference_wavelength is not None:
+                    raise ValueError(
+                        "Reference wavelength cannot be used with Measure mode `multi`."
+                    )
+
+            await abs_reader.set_sample_wavelength(
+                ABSMeasurementMode(params.measureMode),
+                params.sampleWavelengths,
+                reference_wavelength=params.referenceWavelength,
+            )
+
+        state_update.initialize_absorbance_reader(
+            abs_reader_substate.module_id,
+            params.measureMode,
+            params.sampleWavelengths,
+            params.referenceWavelength,
+        )
+
+        return SuccessData(public=InitializeResult(), state_update=state_update)
+
+
+class Initialize(BaseCommand[InitializeParams, InitializeResult, ErrorOccurrence]):
+    """A command to initialize an Absorbance Reader."""
+
+    commandType: InitializeCommandType = "absorbanceReader/initialize"
+    params: InitializeParams
+    result: Optional[InitializeResult] = None
+
+    _ImplementationCls: Type[InitializeImpl] = InitializeImpl
+
+
+class InitializeCreate(BaseCommandCreate[InitializeParams]):
+    """A request to execute an Absorbance Reader measurement."""
+
+    commandType: InitializeCommandType = "absorbanceReader/initialize"
+    params: InitializeParams
+
+    _CommandCls: Type[Initialize] = Initialize

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -0,0 +1,154 @@
+"""Command models to close the lid on an Absorbance Reader."""
+from __future__ import annotations
+from typing import Optional, Literal, TYPE_CHECKING
+from typing_extensions import Type
+
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors.error_occurrence import ErrorOccurrence
+from ...errors import CannotPerformModuleAction
+
+from opentrons.protocol_engine.types import AddressableAreaLocation
+from opentrons.types import Point
+
+from opentrons.drivers.types import AbsorbanceReaderLidStatus
+
+from .common import LID_Z_CLEARANCE
+
+from ...state.update_types import StateUpdate
+
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import (
+        EquipmentHandler,
+        LabwareMovementHandler,
+    )
+
+
+OpenLidCommandType = Literal["absorbanceReader/openLid"]
+
+
+class OpenLidParams(BaseModel):
+    """Input parameters to open the lid on an absorbance reading."""
+
+    moduleId: str = Field(..., description="Unique ID of the absorbance reader.")
+
+
+class OpenLidResult(BaseModel):
+    """Result data from opening the lid on an aborbance reading."""
+
+
+class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]):
+    """Execution implementation of opening the lid on an Absorbance Reader."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        labware_movement: LabwareMovementHandler,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._labware_movement = labware_movement
+
+    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
+        )
+
+        hardware_lid_status = AbsorbanceReaderLidStatus.ON
+        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:
+                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 hardware_lid_status is AbsorbanceReaderLidStatus.OFF:
+            # 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
+            )
+            assert absorbance_model is not None
+            current_location = AddressableAreaLocation(
+                addressableAreaName=self._state_view.modules.ensure_and_convert_module_fixture_location(
+                    deck_slot=self._state_view.modules.get_location(
+                        params.moduleId
+                    ).slotName,
+                    model=absorbance_model,
+                )
+            )
+
+            # we need to move the lid to the lid dock
+            new_location = self._state_view.modules.absorbance_reader_dock_location(
+                mod_substate.module_id
+            )
+
+            # 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."
+                )
+
+            await self._labware_movement.move_labware_with_gripper(
+                labware_definition=lid_definition,
+                current_location=current_location,
+                new_location=new_location,
+                user_pick_up_offset=Point.from_xyz_attrs(
+                    lid_gripper_offsets.pickUpOffset
+                ),
+                user_drop_offset=Point.from_xyz_attrs(lid_gripper_offsets.dropOffset),
+                post_drop_slide_offset=None,
+                gripper_z_offset=LID_Z_CLEARANCE,
+            )
+            state_update.set_absorbance_reader_lid(
+                module_id=mod_substate.module_id, is_lid_on=False
+            )
+
+        return SuccessData(
+            public=OpenLidResult(),
+            state_update=state_update,
+        )
+
+
+class OpenLid(BaseCommand[OpenLidParams, OpenLidResult, ErrorOccurrence]):
+    """A command to open the lid on an Absorbance Reader."""
+
+    commandType: OpenLidCommandType = "absorbanceReader/openLid"
+    params: OpenLidParams
+    result: Optional[OpenLidResult] = None
+
+    _ImplementationCls: Type[OpenLidImpl] = OpenLidImpl
+
+
+class OpenLidCreate(BaseCommandCreate[OpenLidParams]):
+    """A request to execute an Absorbance Reader open lid command."""
+
+    commandType: OpenLidCommandType = "absorbanceReader/openLid"
+    params: OpenLidParams
+
+    _CommandCls: Type[OpenLid] = OpenLid