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

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -0,0 +1,160 @@
+"""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.resources import labware_validation
+from opentrons.protocol_engine.types import AddressableAreaLocation
+
+from opentrons.drivers.types import AbsorbanceReaderLidStatus
+
+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."""
+        mod_substate = self._state_view.modules.get_absorbance_reader_substate(
+            module_id=params.moduleId
+        )
+        # lid should currently be on the module
+        assert mod_substate.lid_id is not None
+        loaded_lid = self._state_view.labware.get(mod_substate.lid_id)
+        assert labware_validation.is_absorbance_reader_lid(loaded_lid.loadName)
+
+        hardware_lid_status = AbsorbanceReaderLidStatus.ON
+        # If the lid is closed, if the lid is open No-op out
+        if not self._state_view.config.use_virtual_modules:
+            abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
+
+            if abs_reader is not None:
+                result = await abs_reader.get_current_lid_status()
+                hardware_lid_status = result
+            else:
+                raise CannotPerformModuleAction(
+                    "Could not reach the Hardware API for Opentrons Plate Reader Module."
+                )
+
+        # If the lid is already OFF, no-op the lid removal
+        if hardware_lid_status is AbsorbanceReaderLidStatus.OFF:
+            assert isinstance(loaded_lid.location, AddressableAreaLocation)
+            new_location = loaded_lid.location
+            new_offset_id = self._equipment.find_applicable_labware_offset_id(
+                labware_definition_uri=loaded_lid.definitionUri,
+                labware_location=loaded_lid.location,
+            )
+        else:
+            # Allow propagation of ModuleNotAttachedError.
+            _ = self._equipment.get_module_hardware_api(mod_substate.module_id)
+
+            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,
+                    deck_type=self._state_view.config.deck_type,
+                    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
+            )
+
+            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=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]
+
+    _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

opentrons/protocol_engine/commands/absorbance_reader/read.py

@@ -0,0 +1,196 @@
+"""Command models to read absorbance."""
+from __future__ import annotations
+from datetime import datetime
+from typing import Optional, Dict, TYPE_CHECKING, List
+from typing_extensions import Literal, Type
+
+from pydantic import BaseModel, Field
+
+from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ...errors import CannotPerformModuleAction, StorageLimitReachedError
+from ...errors.error_occurrence import ErrorOccurrence
+
+from ...resources.file_provider import (
+    PlateReaderData,
+    ReadData,
+    MAXIMUM_CSV_FILE_LIMIT,
+)
+from ...resources import FileProvider
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.state.state import StateView
+    from opentrons.protocol_engine.execution import EquipmentHandler
+
+
+ReadAbsorbanceCommandType = Literal["absorbanceReader/read"]
+
+
+class ReadAbsorbanceParams(BaseModel):
+    """Input parameters for an absorbance reading."""
+
+    moduleId: str = Field(..., description="Unique ID of the Absorbance Reader.")
+    fileName: Optional[str] = Field(
+        None,
+        description="Optional file name to use when storing the results of a measurement.",
+    )
+
+
+class ReadAbsorbanceResult(BaseModel):
+    """Result data from running an aborbance reading, returned as a dictionary map of wavelengths containing a map of values by well name (eg. {450: {"A1": 0.0, ...}})."""
+
+    data: Optional[Dict[int, Dict[str, float]]] = Field(
+        ..., description="Absorbance data points per wavelength."
+    )
+    fileIds: Optional[List[str]] = Field(
+        ...,
+        description="List of file IDs for files output as a result of a Read action.",
+    )
+
+
+class ReadAbsorbanceImpl(
+    AbstractCommandImpl[ReadAbsorbanceParams, SuccessData[ReadAbsorbanceResult]]
+):
+    """Execution implementation of an Absorbance Reader measurement."""
+
+    def __init__(
+        self,
+        state_view: StateView,
+        equipment: EquipmentHandler,
+        file_provider: FileProvider,
+        **unused_dependencies: object,
+    ) -> None:
+        self._state_view = state_view
+        self._equipment = equipment
+        self._file_provider = file_provider
+
+    async def execute(  # noqa: C901
+        self, params: ReadAbsorbanceParams
+    ) -> SuccessData[ReadAbsorbanceResult]:
+        """Initiate an absorbance measurement."""
+        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_substate.configured is False:
+            raise CannotPerformModuleAction(
+                "Cannot perform Read action on Absorbance Reader without calling `.initialize(...)` first."
+            )
+
+        # TODO: we need to return a file ID and increase the file count even when a moduel is not attached
+        if (
+            params.fileName is not None
+            and abs_reader_substate.configured_wavelengths is not None
+        ):
+            # Validate that the amount of files we are about to generate does not put us higher than the limit
+            if (
+                self._state_view.files.get_filecount()
+                + len(abs_reader_substate.configured_wavelengths)
+                > MAXIMUM_CSV_FILE_LIMIT
+            ):
+                raise StorageLimitReachedError(
+                    message=f"Attempt to write file {params.fileName} exceeds file creation limit of {MAXIMUM_CSV_FILE_LIMIT} files."
+                )
+
+        asbsorbance_result: Dict[int, Dict[str, float]] = {}
+        transform_results = []
+        # Handle the measurement and begin building data for return
+        if abs_reader is not None:
+            start_time = datetime.now()
+            results = await abs_reader.start_measure()
+            finish_time = datetime.now()
+            if abs_reader._measurement_config is not None:
+                sample_wavelengths = abs_reader._measurement_config.sample_wavelengths
+                for wavelength, result in zip(sample_wavelengths, results):
+                    converted_values = (
+                        self._state_view.modules.convert_absorbance_reader_data_points(
+                            data=result
+                        )
+                    )
+                    asbsorbance_result[wavelength] = converted_values
+                    transform_results.append(
+                        ReadData.construct(wavelength=wavelength, data=converted_values)
+                    )
+        # Handle the virtual module case for data creation (all zeroes)
+        elif self._state_view.config.use_virtual_modules:
+            start_time = finish_time = datetime.now()
+            if abs_reader_substate.configured_wavelengths is not None:
+                for wavelength in abs_reader_substate.configured_wavelengths:
+                    converted_values = (
+                        self._state_view.modules.convert_absorbance_reader_data_points(
+                            data=[0] * 96
+                        )
+                    )
+                    asbsorbance_result[wavelength] = converted_values
+                    transform_results.append(
+                        ReadData.construct(wavelength=wavelength, data=converted_values)
+                    )
+            else:
+                raise CannotPerformModuleAction(
+                    "Plate Reader data cannot be requested with a module that has not been initialized."
+                )
+
+        # TODO (cb, 10-17-2024): FILE PROVIDER - Some day we may want to break the file provider behavior into a seperate API function.
+        # When this happens, we probably will to have the change the command results handler we utilize to track file IDs in engine.
+        # Today, the action handler for the FileStore looks for a ReadAbsorbanceResult command action, this will need to be delinked.
+
+        # Begin interfacing with the file provider if the user provided a filename
+        file_ids = []
+        if params.fileName is not None:
+            # Create the Plate Reader Transform
+            plate_read_result = PlateReaderData.construct(
+                read_results=transform_results,
+                reference_wavelength=abs_reader_substate.reference_wavelength,
+                start_time=start_time,
+                finish_time=finish_time,
+                serial_number=abs_reader.serial_number
+                if (abs_reader is not None and abs_reader.serial_number is not None)
+                else "VIRTUAL_SERIAL",
+            )
+
+            if isinstance(plate_read_result, PlateReaderData):
+                # Write a CSV file for each of the measurements taken
+                for measurement in plate_read_result.read_results:
+                    file_id = await self._file_provider.write_csv(
+                        write_data=plate_read_result.build_generic_csv(
+                            filename=params.fileName,
+                            measurement=measurement,
+                        )
+                    )
+                    file_ids.append(file_id)
+
+                # Return success data to api
+                return SuccessData(
+                    public=ReadAbsorbanceResult(
+                        data=asbsorbance_result, fileIds=file_ids
+                    ),
+                )
+
+        return SuccessData(
+            public=ReadAbsorbanceResult(data=asbsorbance_result, fileIds=file_ids),
+        )
+
+
+class ReadAbsorbance(
+    BaseCommand[ReadAbsorbanceParams, ReadAbsorbanceResult, ErrorOccurrence]
+):
+    """A command to execute an Absorbance Reader measurement."""
+
+    commandType: ReadAbsorbanceCommandType = "absorbanceReader/read"
+    params: ReadAbsorbanceParams
+    result: Optional[ReadAbsorbanceResult]
+
+    _ImplementationCls: Type[ReadAbsorbanceImpl] = ReadAbsorbanceImpl
+
+
+class ReadAbsorbanceCreate(BaseCommandCreate[ReadAbsorbanceParams]):
+    """A request to execute an Absorbance Reader measurement."""
+
+    commandType: ReadAbsorbanceCommandType = "absorbanceReader/read"
+    params: ReadAbsorbanceParams
+
+    _CommandCls: Type[ReadAbsorbance] = ReadAbsorbance

opentrons/protocol_engine/commands/aspirate.py

@@ -6,11 +6,10 @@ from typing_extensions import Literal
 
 from .pipetting_common import (
     OverpressureError,
-    OverpressureErrorInternalData,
     PipetteIdMixin,
     AspirateVolumeMixin,
     FlowRateMixin,
-    WellLocationMixin,
+    LiquidHandlingWellLocationMixin,
     BaseLiquidHandlingResult,
     DestinationPositionResult,
 )
@@ -25,12 +24,13 @@ from ..errors.error_occurrence import ErrorOccurrence
 
 from opentrons.hardware_control import HardwareControlAPI
 
+from ..state.update_types import StateUpdate, CLEAR
 from ..types import WellLocation, WellOrigin, CurrentWell, DeckPoint
 
 if TYPE_CHECKING:
     from ..execution import MovementHandler, PipettingHandler
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
     from ..notes import CommandNoteAdder
 
 
@@ -38,7 +38,7 @@ AspirateCommandType = Literal["aspirate"]
 
 
 class AspirateParams(
-    PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin, WellLocationMixin
+    PipetteIdMixin, AspirateVolumeMixin, FlowRateMixin, LiquidHandlingWellLocationMixin
 ):
     """Parameters required to aspirate from a specific well."""
 
@@ -52,8 +52,8 @@ class AspirateResult(BaseLiquidHandlingResult, DestinationPositionResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[AspirateResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[AspirateResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -92,6 +92,7 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
         )
 
         current_well = None
+        state_update = StateUpdate()
 
         if not ready_to_aspirate:
             await self._movement.move_to_well(
@@ -117,6 +118,14 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
             well_name=well_name,
             well_location=params.wellLocation,
             current_well=current_well,
+            operation_volume=-params.volume,
+        )
+        deck_point = DeckPoint.construct(x=position.x, y=position.y, z=position.z)
+        state_update.set_pipette_location(
+            pipette_id=pipette_id,
+            new_labware_id=labware_id,
+            new_well_name=well_name,
+            new_deck_point=deck_point,
         )
 
         try:
@@ -127,6 +136,11 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                 command_note_adder=self._command_note_adder,
             )
         except PipetteOverpressureError as e:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=CLEAR,
+            )
             return DefinedErrorData(
                 public=OverpressureError(
                     id=self._model_utils.generate_id(),
@@ -140,25 +154,24 @@ class AspirateImplementation(AbstractCommandImpl[AspirateParams, _ExecuteReturn]
                     ],
                     errorInfo={"retryLocation": (position.x, position.y, position.z)},
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint.construct(
-                        x=position.x, y=position.y, z=position.z
-                    )
-                ),
+                state_update=state_update,
             )
         else:
+            state_update.set_liquid_operated(
+                labware_id=labware_id,
+                well_name=well_name,
+                volume_added=-volume_aspirated,
+            )
             return SuccessData(
                 public=AspirateResult(
                     volume=volume_aspirated,
-                    position=DeckPoint.construct(
-                        x=position.x, y=position.y, z=position.z
-                    ),
+                    position=deck_point,
                 ),
-                private=None,
+                state_update=state_update,
             )
 
 
-class Aspirate(BaseCommand[AspirateParams, AspirateResult, ErrorOccurrence]):
+class Aspirate(BaseCommand[AspirateParams, AspirateResult, OverpressureError]):
     """Aspirate command model."""
 
     commandType: AspirateCommandType = "aspirate"

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -14,7 +14,6 @@ from .pipetting_common import (
     FlowRateMixin,
     BaseLiquidHandlingResult,
     OverpressureError,
-    OverpressureErrorInternalData,
 )
 from .command import (
     AbstractCommandImpl,
@@ -25,12 +24,13 @@ from .command import (
 )
 from ..errors.error_occurrence import ErrorOccurrence
 from ..errors.exceptions import PipetteNotReadyToAspirateError
-from ..types import DeckPoint
+from ..state.update_types import StateUpdate, CLEAR
+from ..types import CurrentWell
 
 if TYPE_CHECKING:
     from ..execution import PipettingHandler, GantryMover
     from ..resources import ModelUtils
-    from ..state import StateView
+    from ..state.state import StateView
     from ..notes import CommandNoteAdder
 
 AspirateInPlaceCommandType = Literal["aspirateInPlace"]
@@ -49,8 +49,8 @@ class AspirateInPlaceResult(BaseLiquidHandlingResult):
 
 
 _ExecuteReturn = Union[
-    SuccessData[AspirateInPlaceResult, None],
-    DefinedErrorData[OverpressureError, OverpressureErrorInternalData],
+    SuccessData[AspirateInPlaceResult],
+    DefinedErrorData[OverpressureError],
 ]
 
 
@@ -93,7 +93,12 @@ class AspirateInPlaceImplementation(
                 " The first aspirate following a blow-out must be from a specific well"
                 " so the plunger can be reset in a known safe position."
             )
+
+        state_update = StateUpdate()
+        current_location = self._state_view.pipettes.get_current_location()
+
         try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
             volume = await self._pipetting.aspirate_in_place(
                 pipette_id=params.pipetteId,
                 volume=params.volume,
@@ -101,7 +106,15 @@ class AspirateInPlaceImplementation(
                 command_note_adder=self._command_note_adder,
             )
         except PipetteOverpressureError as e:
-            current_position = await self._gantry_mover.get_position(params.pipetteId)
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                state_update.set_liquid_operated(
+                    labware_id=current_location.labware_id,
+                    well_name=current_location.well_name,
+                    volume_added=CLEAR,
+                )
             return DefinedErrorData(
                 public=OverpressureError(
                     id=self._model_utils.generate_id(),
@@ -123,22 +136,26 @@ class AspirateInPlaceImplementation(
                         }
                     ),
                 ),
-                private=OverpressureErrorInternalData(
-                    position=DeckPoint(
-                        x=current_position.x,
-                        y=current_position.y,
-                        z=current_position.z,
-                    ),
-                ),
+                state_update=state_update,
             )
         else:
+            if (
+                isinstance(current_location, CurrentWell)
+                and current_location.pipette_id == params.pipetteId
+            ):
+                state_update.set_liquid_operated(
+                    labware_id=current_location.labware_id,
+                    well_name=current_location.well_name,
+                    volume_added=-volume,
+                )
             return SuccessData(
-                public=AspirateInPlaceResult(volume=volume), private=None
+                public=AspirateInPlaceResult(volume=volume),
+                state_update=state_update,
             )
 
 
 class AspirateInPlace(
-    BaseCommand[AspirateInPlaceParams, AspirateInPlaceResult, ErrorOccurrence]
+    BaseCommand[AspirateInPlaceParams, AspirateInPlaceResult, OverpressureError]
 ):
     """AspirateInPlace command model."""