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

opentrons/protocol_engine/actions/actions.py

@@ -3,7 +3,7 @@
 Actions can be passed to the ActionDispatcher, where they will trigger
 reactions in objects that subscribe to the pipeline, like the StateStore.
 """
-from dataclasses import dataclass
+import dataclasses
 from datetime import datetime
 from enum import Enum
 from typing import List, Optional, Union
@@ -18,10 +18,10 @@ from ..commands import (
     Command,
     CommandCreate,
     CommandDefinedErrorData,
-    CommandPrivateResult,
 )
 from ..error_recovery_policy import ErrorRecoveryPolicy, ErrorRecoveryType
 from ..notes.notes import CommandNote
+from ..state.update_types import StateUpdate
 from ..types import (
     LabwareOffsetCreate,
     ModuleDefinition,
@@ -31,7 +31,7 @@ from ..types import (
 )
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class PlayAction:
     """Start or resume processing commands in the engine."""
 
@@ -50,28 +50,28 @@ class PauseSource(str, Enum):
     PROTOCOL = "protocol"
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class PauseAction:
     """Pause processing commands in the engine."""
 
     source: PauseSource
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class StopAction:
     """Request engine execution to stop soon."""
 
     from_estop: bool = False
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class ResumeFromRecoveryAction:
     """See `ProtocolEngine.resume_from_recovery()`."""
 
-    pass
+    state_update: StateUpdate
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class FinishErrorDetails:
     """Error details for the payload of a FinishAction or HardwareStoppedAction."""
 
@@ -80,7 +80,7 @@ class FinishErrorDetails:
     created_at: datetime
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class FinishAction:
     """Gracefully stop processing commands in the engine."""
 
@@ -95,7 +95,7 @@ class FinishAction:
     """The fatal error that caused the run to fail."""
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class HardwareStoppedAction:
     """An action dispatched after hardware has been stopped for good, for this engine instance."""
 
@@ -105,14 +105,14 @@ class HardwareStoppedAction:
     """The error that happened while doing post-run finish steps (homing and dropping tips)."""
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class DoorChangeAction:
     """Handle events coming in from hardware control."""
 
     door_state: DoorState
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class QueueCommandAction:
     """Add a command request to the queue."""
 
@@ -123,7 +123,7 @@ class QueueCommandAction:
     failed_command_id: Optional[str] = None
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class RunCommandAction:
     """Mark a given command as running.
 
@@ -135,7 +135,7 @@ class RunCommandAction:
     started_at: datetime
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class SucceedCommandAction:
     """Mark a given command as succeeded.
 
@@ -145,10 +145,15 @@ class SucceedCommandAction:
     command: Command
     """The command in its new succeeded state."""
 
-    private_result: CommandPrivateResult
+    state_update: StateUpdate = dataclasses.field(
+        # todo(mm, 2024-08-26): This has a default only to make it easier to transition
+        # old tests while https://opentrons.atlassian.net/browse/EXEC-639 is in
+        # progress. Make this mandatory when that's completed.
+        default_factory=StateUpdate
+    )
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class FailCommandAction:
     """Mark a given command as failed.
 
@@ -196,7 +201,7 @@ class FailCommandAction:
     """The command to fail, in its prior `running` state."""
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class AddLabwareOffsetAction:
     """Add a labware offset, to apply to subsequent `LoadLabwareCommand`s."""
 
@@ -205,28 +210,28 @@ class AddLabwareOffsetAction:
     request: LabwareOffsetCreate
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class AddLabwareDefinitionAction:
     """Add a labware definition, to apply to subsequent `LoadLabwareCommand`s."""
 
     definition: LabwareDefinition
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class AddLiquidAction:
     """Add a liquid, to apply to subsequent `LoadLiquid`s."""
 
     liquid: Liquid
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class SetDeckConfigurationAction:
     """See `ProtocolEngine.set_deck_configuration()`."""
 
     deck_configuration: Optional[DeckConfigurationType]
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class AddAddressableAreaAction:
     """Add a single addressable area to state.
 
@@ -238,7 +243,7 @@ class AddAddressableAreaAction:
     addressable_area: AddressableAreaLocation
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class AddModuleAction:
     """Add an attached module directly to state without a location."""
 
@@ -248,14 +253,14 @@ class AddModuleAction:
     module_live_data: LiveData
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class ResetTipsAction:
     """Reset the tip tracking state of a given tip rack."""
 
     labware_id: str
 
 
-@dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True)
 class SetPipetteMovementSpeedAction:
     """Set the speed of a pipette's X/Y/Z movements. Does not affect plunger speed.
 
@@ -266,7 +271,18 @@ class SetPipetteMovementSpeedAction:
     speed: Optional[float]
 
 
-@dataclass(frozen=True)
+@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()`."""
 
@@ -293,5 +309,6 @@ Action = Union[
     AddLiquidAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
+    AddAbsorbanceReaderLidAction,
     SetErrorRecoveryPolicyAction,
 ]

opentrons/protocol_engine/actions/get_state_update.py

@@ -0,0 +1,38 @@
+# noqa: D100
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from .actions import (
+    Action,
+    ResumeFromRecoveryAction,
+    SucceedCommandAction,
+    FailCommandAction,
+)
+from ..commands.command import DefinedErrorData
+from ..error_recovery_policy import ErrorRecoveryType
+
+if TYPE_CHECKING:
+    from ..state.update_types import StateUpdate
+
+
+def get_state_updates(action: Action) -> list[StateUpdate]:
+    """Extract all the StateUpdates that the StateStores should apply when they apply an action."""
+    if isinstance(action, SucceedCommandAction):
+        return [action.state_update]
+
+    elif isinstance(action, FailCommandAction) and isinstance(
+        action.error, DefinedErrorData
+    ):
+        if action.type == ErrorRecoveryType.ASSUME_FALSE_POSITIVE_AND_CONTINUE:
+            return [
+                action.error.state_update,
+                action.error.state_update_if_false_positive,
+            ]
+        else:
+            return [action.error.state_update]
+
+    elif isinstance(action, ResumeFromRecoveryAction):
+        return [action.state_update]
+
+    else:
+        return []

opentrons/protocol_engine/clients/sync_client.py

@@ -7,7 +7,7 @@ from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
 from .. import commands
 from ..commands.command_unions import CREATE_TYPES_BY_PARAMS_TYPE
-from ..state import StateView
+from ..state.state import StateView
 from ..types import (
     Liquid,
     LabwareOffsetCreate,
@@ -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:

opentrons/protocol_engine/clients/transports.py

@@ -10,7 +10,7 @@ from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from ..protocol_engine import ProtocolEngine
 from ..errors import ProtocolCommandFailedError
 from ..error_recovery_policy import ErrorRecoveryType
-from ..state import StateView
+from ..state.state import StateView
 from ..commands import Command, CommandCreate, CommandResult, CommandStatus
 
 

opentrons/protocol_engine/commands/__init__.py

@@ -38,7 +38,6 @@ from .command_unions import (
     CommandCreate,
     CommandResult,
     CommandType,
-    CommandPrivateResult,
     CommandDefinedErrorData,
 )
 
@@ -153,7 +152,6 @@ from .load_pipette import (
     LoadPipetteCreate,
     LoadPipetteResult,
     LoadPipetteCommandType,
-    LoadPipettePrivateResult,
 )
 
 from .move_labware import (
@@ -306,7 +304,6 @@ from .configure_nozzle_layout import (
     ConfigureNozzleLayoutCreate,
     ConfigureNozzleLayoutParams,
     ConfigureNozzleLayoutResult,
-    ConfigureNozzleLayoutPrivateResult,
     ConfigureNozzleLayoutCommandType,
 )
 
@@ -569,7 +566,6 @@ __all__ = [
     "ConfigureNozzleLayoutParams",
     "ConfigureNozzleLayoutResult",
     "ConfigureNozzleLayoutCommandType",
-    "ConfigureNozzleLayoutPrivateResult",
     # get pipette tip presence bundle
     "GetTipPresence",
     "GetTipPresenceCreate",

opentrons/protocol_engine/commands/absorbance_reader/__init__.py

@@ -1,4 +1,19 @@
 """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,
@@ -8,15 +23,29 @@ from .initialize import (
     InitializeCreate,
 )
 
-from .measure import (
-    MeasureAbsorbanceCommandType,
-    MeasureAbsorbanceParams,
-    MeasureAbsorbanceResult,
-    MeasureAbsorbance,
-    MeasureAbsorbanceCreate,
+from .read import (
+    ReadAbsorbanceCommandType,
+    ReadAbsorbanceParams,
+    ReadAbsorbanceResult,
+    ReadAbsorbance,
+    ReadAbsorbanceCreate,
 )
 
+
 __all__ = [
+    "MoveLidResult",
+    # absorbanace_reader/closeLid
+    "CloseLidCommandType",
+    "CloseLidParams",
+    "CloseLidResult",
+    "CloseLid",
+    "CloseLidCreate",
+    # absorbanace_reader/openLid
+    "OpenLidCommandType",
+    "OpenLidParams",
+    "OpenLidResult",
+    "OpenLid",
+    "OpenLidCreate",
     # absorbanace_reader/initialize
     "InitializeCommandType",
     "InitializeParams",
@@ -24,9 +53,10 @@ __all__ = [
     "Initialize",
     "InitializeCreate",
     # absorbanace_reader/measure
-    "MeasureAbsorbanceCommandType",
-    "MeasureAbsorbanceParams",
-    "MeasureAbsorbanceResult",
-    "MeasureAbsorbance",
-    "MeasureAbsorbanceCreate",
+    "ReadAbsorbanceCommandType",
+    "ReadAbsorbanceParams",
+    "ReadAbsorbanceResult",
+    "ReadAbsorbance",
+    "ReadAbsorbanceCreate",
+    # union type
 ]

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -0,0 +1,161 @@
+"""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.protocol_engine.resources import labware_validation
+from ...state.update_types import StateUpdate
+
+
+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."""
+        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
+            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,
+            )
+        else:
+            # Allow propagation of ModuleNotAttachedError.
+            _ = self._equipment.get_module_hardware_api(mod_substate.module_id)
+
+            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,
+                    deck_type=self._state_view.config.deck_type,
+                    model=absorbance_model,
+                )
+            )
+
+            lid_gripper_offsets = self._state_view.labware.get_labware_gripper_offsets(
+                loaded_lid.id, 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,
+                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 = 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,
+        )
+
+
+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]
+
+    _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/initialize.py

@@ -1,15 +1,18 @@
 """Command models to initialize an Absorbance Reader."""
 from __future__ import annotations
-from typing import Optional, Literal, TYPE_CHECKING
+from typing import List, Optional, Literal, TYPE_CHECKING
 from typing_extensions import Type
 
 from pydantic import BaseModel, Field
 
+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
 
 if TYPE_CHECKING:
-    from opentrons.protocol_engine.state import StateView
+    from opentrons.protocol_engine.state.state import StateView
     from opentrons.protocol_engine.execution import EquipmentHandler
 
 
@@ -20,7 +23,13 @@ class InitializeParams(BaseModel):
     """Input parameters to initialize an absorbance reading."""
 
     moduleId: str = Field(..., description="Unique ID of the absorbance reader.")
-    sampleWavelength: int = Field(..., description="Sample wavelength in nm.")
+    measureMode: ABSMeasureMode = Field(
+        ..., description="Initialize single or multi measurement mode."
+    )
+    sampleWavelengths: List[int] = Field(..., description="Sample wavelengths in nm.")
+    referenceWavelength: Optional[int] = Field(
+        None, description="Optional reference wavelength in nm."
+    )
 
 
 class InitializeResult(BaseModel):
@@ -28,7 +37,7 @@ class InitializeResult(BaseModel):
 
 
 class InitializeImpl(
-    AbstractCommandImpl[InitializeParams, SuccessData[InitializeResult, None]]
+    AbstractCommandImpl[InitializeParams, SuccessData[InitializeResult]]
 ):
     """Execution implementation of initializing an Absorbance Reader."""
 
@@ -41,9 +50,7 @@ class InitializeImpl(
         self._state_view = state_view
         self._equipment = equipment
 
-    async def execute(
-        self, params: InitializeParams
-    ) -> SuccessData[InitializeResult, None]:
+    async def execute(self, params: InitializeParams) -> SuccessData[InitializeResult]:
         """Initiate a single absorbance measurement."""
         abs_reader_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
@@ -54,11 +61,48 @@ class InitializeImpl(
         )
 
         if abs_reader is not None:
-            await abs_reader.set_sample_wavelength(wavelength=params.sampleWavelength)
+            # 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
+            )
+            if unsupported_wavelengths:
+                raise ValueError(f"Unsupported wavelengths: {unsupported_wavelengths}")
+
+            if params.measureMode == "single":
+                if sample_wavelengths_len != 1:
+                    raise ValueError(
+                        f"single requires one sample wavelength, provided {sample_wavelengths}"
+                    )
+                if (
+                    reference_wavelength is not None
+                    and reference_wavelength not in supported_wavelengths
+                ):
+                    raise ValueError(
+                        f"Reference wavelength {reference_wavelength} not supported {supported_wavelengths}"
+                    )
+
+            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}"
+                    )
+                if reference_wavelength is not None:
+                    raise RuntimeError(
+                        "Reference wavelength cannot be used with multi mode."
+                    )
+
+            await abs_reader.set_sample_wavelength(
+                ABSMeasurementMode(params.measureMode),
+                params.sampleWavelengths,
+                reference_wavelength=params.referenceWavelength,
+            )
 
         return SuccessData(
             public=InitializeResult(),
-            private=None,
         )