opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0a1__py2.py3-none-any.whl

opentrons/protocol_engine/state/labware.py

@@ -131,7 +131,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
             for fixed_labware in deck_fixed_labware
         }
         labware_by_id = {
-            fixed_labware.labware_id: LoadedLabware.construct(
+            fixed_labware.labware_id: LoadedLabware.model_construct(
                 id=fixed_labware.labware_id,
                 location=fixed_labware.location,
                 loadName=fixed_labware.definition.parameters.loadName,
@@ -156,10 +156,12 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
         """Modify state in reaction to an action."""
         for state_update in get_state_updates(action):
             self._add_loaded_labware(state_update)
+            self._add_loaded_lid_stack(state_update)
             self._set_labware_location(state_update)
+            self._set_labware_lid(state_update)
 
         if isinstance(action, AddLabwareOffsetAction):
-            labware_offset = LabwareOffset.construct(
+            labware_offset = LabwareOffset.model_construct(
                 id=action.labware_offset_id,
                 createdAt=action.created_at,
                 definitionUri=action.request.definitionUri,
@@ -212,7 +214,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
 
             self._state.labware_by_id[
                 loaded_labware_update.labware_id
-            ] = LoadedLabware.construct(
+            ] = LoadedLabware.model_construct(
                 id=loaded_labware_update.labware_id,
                 location=location,
                 loadName=loaded_labware_update.definition.parameters.loadName,
@@ -221,6 +223,63 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
                 displayName=display_name,
             )
 
+    def _add_loaded_lid_stack(self, state_update: update_types.StateUpdate) -> None:
+        loaded_lid_stack_update = state_update.loaded_lid_stack
+        if loaded_lid_stack_update != update_types.NO_CHANGE:
+            # Add the stack object
+            stack_definition_uri = uri_from_details(
+                namespace=loaded_lid_stack_update.stack_object_definition.namespace,
+                load_name=loaded_lid_stack_update.stack_object_definition.parameters.loadName,
+                version=loaded_lid_stack_update.stack_object_definition.version,
+            )
+            self.state.definitions_by_uri[
+                stack_definition_uri
+            ] = loaded_lid_stack_update.stack_object_definition
+            self._state.labware_by_id[
+                loaded_lid_stack_update.stack_id
+            ] = LoadedLabware.construct(
+                id=loaded_lid_stack_update.stack_id,
+                location=loaded_lid_stack_update.stack_location,
+                loadName=loaded_lid_stack_update.stack_object_definition.parameters.loadName,
+                definitionUri=stack_definition_uri,
+                offsetId=None,
+                displayName=None,
+            )
+
+            # Add the Lids on top of the stack object
+            for i in range(len(loaded_lid_stack_update.labware_ids)):
+                definition_uri = uri_from_details(
+                    namespace=loaded_lid_stack_update.definition.namespace,
+                    load_name=loaded_lid_stack_update.definition.parameters.loadName,
+                    version=loaded_lid_stack_update.definition.version,
+                )
+
+                self._state.definitions_by_uri[
+                    definition_uri
+                ] = loaded_lid_stack_update.definition
+
+                location = loaded_lid_stack_update.new_locations_by_id[
+                    loaded_lid_stack_update.labware_ids[i]
+                ]
+
+                self._state.labware_by_id[
+                    loaded_lid_stack_update.labware_ids[i]
+                ] = LoadedLabware.construct(
+                    id=loaded_lid_stack_update.labware_ids[i],
+                    location=location,
+                    loadName=loaded_lid_stack_update.definition.parameters.loadName,
+                    definitionUri=definition_uri,
+                    offsetId=None,
+                    displayName=None,
+                )
+
+    def _set_labware_lid(self, state_update: update_types.StateUpdate) -> None:
+        labware_lid_update = state_update.labware_lid
+        if labware_lid_update != update_types.NO_CHANGE:
+            parent_labware_id = labware_lid_update.parent_labware_id
+            lid_id = labware_lid_update.lid_id
+            self._state.labware_by_id[parent_labware_id].lid_id = lid_id
+
     def _set_labware_location(self, state_update: update_types.StateUpdate) -> None:
         labware_location_update = state_update.labware_location
         if labware_location_update != update_types.NO_CHANGE:
@@ -244,7 +303,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
                 self._state.labware_by_id[labware_id].location = new_location
 
 
-class LabwareView(HasState[LabwareState]):
+class LabwareView:
     """Read-only labware state view."""
 
     _state: LabwareState
@@ -268,7 +327,7 @@ class LabwareView(HasState[LabwareState]):
 
     def get_id_by_module(self, module_id: str) -> str:
         """Return the ID of the labware loaded on the given module."""
-        for labware_id, labware in self.state.labware_by_id.items():
+        for labware_id, labware in self._state.labware_by_id.items():
             if (
                 isinstance(labware.location, ModuleLocation)
                 and labware.location.moduleId == module_id
@@ -281,7 +340,7 @@ class LabwareView(HasState[LabwareState]):
 
     def get_id_by_labware(self, labware_id: str) -> str:
         """Return the ID of the labware loaded on the given labware."""
-        for labware in self.state.labware_by_id.values():
+        for labware in self._state.labware_by_id.values():
             if (
                 isinstance(labware.location, OnLabwareLocation)
                 and labware.location.labwareId == labware_id
@@ -441,21 +500,7 @@ class LabwareView(HasState[LabwareState]):
 
         If not defined within a labware, defaults to one.
         """
-        stacking_quirks = {
-            "stackingMaxFive": 5,
-            "stackingMaxFour": 4,
-            "stackingMaxThree": 3,
-            "stackingMaxTwo": 2,
-            "stackingMaxOne": 1,
-            "stackingMaxZero": 0,
-        }
-        for quirk in stacking_quirks.keys():
-            if (
-                labware.parameters.quirks is not None
-                and quirk in labware.parameters.quirks
-            ):
-                return stacking_quirks[quirk]
-        return 1
+        return labware.stackLimit if labware.stackLimit is not None else 1
 
     def get_should_center_pipette_on_target_well(self, labware_id: str) -> bool:
         """True if a pipette moving to a well of this labware should center its body on the target.
@@ -815,6 +860,11 @@ class LabwareView(HasState[LabwareState]):
             return self.raise_if_labware_inaccessible_by_pipette(
                 labware_location.labwareId
             )
+        elif labware.lid_id is not None:
+            raise errors.LocationNotAccessibleByPipetteError(
+                f"Cannot move pipette to {labware.loadName} "
+                "because labware is currently covered by a lid."
+            )
         elif isinstance(labware_location, AddressableAreaLocation):
             if fixture_validation.is_staging_slot(labware_location.addressableAreaName):
                 raise errors.LocationNotAccessibleByPipetteError(
@@ -998,11 +1048,15 @@ class LabwareView(HasState[LabwareState]):
             return None
         else:
             return LabwareMovementOffsetData(
-                pickUpOffset=cast(
-                    LabwareOffsetVector, parsed_offsets[offset_key].pickUpOffset
+                pickUpOffset=LabwareOffsetVector.model_construct(
+                    x=parsed_offsets[offset_key].pickUpOffset.x,
+                    y=parsed_offsets[offset_key].pickUpOffset.y,
+                    z=parsed_offsets[offset_key].pickUpOffset.z,
                 ),
-                dropOffset=cast(
-                    LabwareOffsetVector, parsed_offsets[offset_key].dropOffset
+                dropOffset=LabwareOffsetVector.model_construct(
+                    x=parsed_offsets[offset_key].dropOffset.x,
+                    y=parsed_offsets[offset_key].dropOffset.y,
+                    z=parsed_offsets[offset_key].dropOffset.z,
                 ),
             )
 

opentrons/protocol_engine/state/liquid_classes.py

@@ -0,0 +1,82 @@
+"""A data store of liquid classes."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Dict
+from typing_extensions import Optional
+
+from .. import errors
+from ..actions import Action, get_state_updates
+from ..types import LiquidClassRecord
+from . import update_types
+from ._abstract_store import HasState, HandlesActions
+
+
+@dataclasses.dataclass
+class LiquidClassState:
+    """Our state is a bidirectional mapping between IDs <-> LiquidClassRecords."""
+
+    # We use the bidirectional map to see if we've already assigned an ID to a liquid class when the
+    # engine is asked to store a new liquid class.
+    liquid_class_record_by_id: Dict[str, LiquidClassRecord]
+    liquid_class_record_to_id: Dict[LiquidClassRecord, str]
+
+
+class LiquidClassStore(HasState[LiquidClassState], HandlesActions):
+    """Container for LiquidClassState."""
+
+    _state: LiquidClassState
+
+    def __init__(self) -> None:
+        self._state = LiquidClassState(
+            liquid_class_record_by_id={},
+            liquid_class_record_to_id={},
+        )
+
+    def handle_action(self, action: Action) -> None:
+        """Update the state in response to the action."""
+        for state_update in get_state_updates(action):
+            if state_update.liquid_class_loaded != update_types.NO_CHANGE:
+                self._handle_liquid_class_loaded_update(
+                    state_update.liquid_class_loaded
+                )
+
+    def _handle_liquid_class_loaded_update(
+        self, state_update: update_types.LiquidClassLoadedUpdate
+    ) -> None:
+        # We're just a data store. All the validation and ID generation happens in the command implementation.
+        self._state.liquid_class_record_by_id[
+            state_update.liquid_class_id
+        ] = state_update.liquid_class_record
+        self._state.liquid_class_record_to_id[
+            state_update.liquid_class_record
+        ] = state_update.liquid_class_id
+
+
+class LiquidClassView:
+    """Read-only view of the LiquidClassState."""
+
+    _state: LiquidClassState
+
+    def __init__(self, state: LiquidClassState) -> None:
+        self._state = state
+
+    def get(self, liquid_class_id: str) -> LiquidClassRecord:
+        """Get the LiquidClassRecord with the given identifier."""
+        try:
+            return self._state.liquid_class_record_by_id[liquid_class_id]
+        except KeyError as e:
+            raise errors.LiquidClassDoesNotExistError(
+                f"Liquid class ID {liquid_class_id} not found."
+            ) from e
+
+    def get_id_for_liquid_class_record(
+        self, liquid_class_record: LiquidClassRecord
+    ) -> Optional[str]:
+        """See if the given LiquidClassRecord if already in the store, and if so, return its identifier."""
+        return self._state.liquid_class_record_to_id.get(liquid_class_record)
+
+    def get_all(self) -> Dict[str, LiquidClassRecord]:
+        """Get all the LiquidClassRecords in the store."""
+        return self._state.liquid_class_record_by_id.copy()

opentrons/protocol_engine/state/liquids.py

@@ -1,11 +1,11 @@
 """Basic liquid data state and store."""
 from dataclasses import dataclass
 from typing import Dict, List
-from opentrons.protocol_engine.types import Liquid
+from opentrons.protocol_engine.types import Liquid, LiquidId
 
 from ._abstract_store import HasState, HandlesActions
 from ..actions import Action, AddLiquidAction
-from ..errors import LiquidDoesNotExistError
+from ..errors import LiquidDoesNotExistError, InvalidLiquidError
 
 
 @dataclass
@@ -34,7 +34,7 @@ class LiquidStore(HasState[LiquidState], HandlesActions):
         self._state.liquids_by_id[action.liquid.id] = action.liquid
 
 
-class LiquidView(HasState[LiquidState]):
+class LiquidView:
     """Read-only liquid state view."""
 
     _state: LiquidState
@@ -51,11 +51,23 @@ class LiquidView(HasState[LiquidState]):
         """Get all protocol liquids."""
         return list(self._state.liquids_by_id.values())
 
-    def validate_liquid_id(self, liquid_id: str) -> str:
+    def validate_liquid_id(self, liquid_id: LiquidId) -> LiquidId:
         """Check if liquid_id exists in liquids."""
+        is_empty = liquid_id == "EMPTY"
+        if is_empty:
+            return liquid_id
         has_liquid = liquid_id in self._state.liquids_by_id
         if not has_liquid:
             raise LiquidDoesNotExistError(
                 f"Supplied liquidId: {liquid_id} does not exist in the loaded liquids."
             )
         return liquid_id
+
+    def validate_liquid_allowed(self, liquid: Liquid) -> Liquid:
+        """Validate that a liquid is legal to load."""
+        is_empty = liquid.id == "EMPTY"
+        if is_empty:
+            raise InvalidLiquidError(
+                message='Protocols may not define a liquid with the special id "EMPTY".'
+            )
+        return liquid

opentrons/protocol_engine/state/modules.py

@@ -35,6 +35,7 @@ from opentrons.protocol_engine.state.module_substates.absorbance_reader_substate
     AbsorbanceReaderMeasureMode,
 )
 from opentrons.types import DeckSlotName, MountType, StagingSlotName
+from .update_types import AbsorbanceReaderStateUpdate
 from ..errors import ModuleNotConnectedError
 
 from ..types import (
@@ -63,7 +64,6 @@ from ..commands import (
     heater_shaker,
     temperature_module,
     thermocycler,
-    absorbance_reader,
 )
 from ..actions import (
     Action,
@@ -296,40 +296,10 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         ):
             self._handle_thermocycler_module_commands(command)
 
-        if isinstance(
-            command.result,
-            (
-                absorbance_reader.InitializeResult,
-                absorbance_reader.ReadAbsorbanceResult,
-            ),
-        ):
-            self._handle_absorbance_reader_commands(command)
-
     def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
-        if state_update.absorbance_reader_lid != update_types.NO_CHANGE:
-            module_id = state_update.absorbance_reader_lid.module_id
-            is_lid_on = state_update.absorbance_reader_lid.is_lid_on
-
-            # Get current values:
-            absorbance_reader_substate = self._state.substate_by_module_id[module_id]
-            assert isinstance(
-                absorbance_reader_substate, AbsorbanceReaderSubState
-            ), f"{module_id} is not an absorbance plate reader."
-            configured = absorbance_reader_substate.configured
-            measure_mode = absorbance_reader_substate.measure_mode
-            configured_wavelengths = absorbance_reader_substate.configured_wavelengths
-            reference_wavelength = absorbance_reader_substate.reference_wavelength
-            data = absorbance_reader_substate.data
-
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=is_lid_on,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=data,
+        if state_update.absorbance_reader_state_update != update_types.NO_CHANGE:
+            self._handle_absorbance_reader_commands(
+                state_update.absorbance_reader_state_update
             )
 
     def _add_module_substate(
@@ -589,50 +559,61 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             )
 
     def _handle_absorbance_reader_commands(
-        self,
-        command: Union[
-            absorbance_reader.Initialize,
-            absorbance_reader.ReadAbsorbance,
-        ],
+        self, absorbance_reader_state_update: AbsorbanceReaderStateUpdate
     ) -> None:
-        module_id = command.params.moduleId
+        # Get current values:
+        module_id = absorbance_reader_state_update.module_id
         absorbance_reader_substate = self._state.substate_by_module_id[module_id]
         assert isinstance(
             absorbance_reader_substate, AbsorbanceReaderSubState
         ), f"{module_id} is not an absorbance plate reader."
-
-        # Get current values
+        is_lid_on = absorbance_reader_substate.is_lid_on
+        measured = True
         configured = absorbance_reader_substate.configured
         measure_mode = absorbance_reader_substate.measure_mode
         configured_wavelengths = absorbance_reader_substate.configured_wavelengths
         reference_wavelength = absorbance_reader_substate.reference_wavelength
-        is_lid_on = absorbance_reader_substate.is_lid_on
-
-        if isinstance(command.result, absorbance_reader.InitializeResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=True,
-                measured=False,
-                is_lid_on=is_lid_on,
-                measure_mode=AbsorbanceReaderMeasureMode(command.params.measureMode),
-                configured_wavelengths=command.params.sampleWavelengths,
-                reference_wavelength=command.params.referenceWavelength,
-                data=None,
+        data = absorbance_reader_substate.data
+        if (
+            absorbance_reader_state_update.absorbance_reader_lid
+            != update_types.NO_CHANGE
+        ):
+            is_lid_on = absorbance_reader_state_update.absorbance_reader_lid.is_lid_on
+        elif (
+            absorbance_reader_state_update.initialize_absorbance_reader_update
+            != update_types.NO_CHANGE
+        ):
+            configured = True
+            measured = False
+            is_lid_on = is_lid_on
+            measure_mode = AbsorbanceReaderMeasureMode(
+                absorbance_reader_state_update.initialize_absorbance_reader_update.measure_mode
             )
-        elif isinstance(command.result, absorbance_reader.ReadAbsorbanceResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=is_lid_on,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=command.result.data,
+            configured_wavelengths = (
+                absorbance_reader_state_update.initialize_absorbance_reader_update.sample_wave_lengths
+            )
+            reference_wavelength = (
+                absorbance_reader_state_update.initialize_absorbance_reader_update.reference_wave_length
             )
+            data = None
+        elif (
+            absorbance_reader_state_update.absorbance_reader_data
+            != update_types.NO_CHANGE
+        ):
+            data = absorbance_reader_state_update.absorbance_reader_data.read_result
+        self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
+            module_id=AbsorbanceReaderId(module_id),
+            configured=configured,
+            measured=measured,
+            is_lid_on=is_lid_on,
+            measure_mode=measure_mode,
+            configured_wavelengths=configured_wavelengths,
+            reference_wavelength=reference_wavelength,
+            data=data,
+        )
 
 
-class ModuleView(HasState[ModuleState]):
+class ModuleView:
     """Read-only view of computed module state."""
 
     _state: ModuleState
@@ -654,7 +635,7 @@ class ModuleView(HasState[ModuleState]):
             DeckSlotLocation(slotName=slot_name) if slot_name is not None else None
         )
 
-        return LoadedModule.construct(
+        return LoadedModule.model_construct(
             id=module_id,
             location=location,
             model=attached_module.definition.model,
@@ -860,8 +841,8 @@ class ModuleView(HasState[ModuleState]):
         Labware Position Check offset.
         """
         if (
-            self.state.deck_type == DeckType.OT2_STANDARD
-            or self.state.deck_type == DeckType.OT2_SHORT_TRASH
+            self._state.deck_type == DeckType.OT2_STANDARD
+            or self._state.deck_type == DeckType.OT2_SHORT_TRASH
         ):
             definition = self.get_definition(module_id)
             slot = self.get_location(module_id).slotName.id
@@ -908,7 +889,7 @@ class ModuleView(HasState[ModuleState]):
                     "Module location invalid for nominal module offset calculation."
                 )
             module_addressable_area = self.ensure_and_convert_module_fixture_location(
-                location, self.state.deck_type, module.model
+                location, module.model
             )
             module_addressable_area_position = (
                 addressable_areas.get_addressable_area_offsets_from_cutout(
@@ -1281,13 +1262,14 @@ class ModuleView(HasState[ModuleState]):
     def ensure_and_convert_module_fixture_location(
         self,
         deck_slot: DeckSlotName,
-        deck_type: DeckType,
         model: ModuleModel,
     ) -> str:
         """Ensure module fixture load location is valid.
 
         Also, convert the deck slot to a valid module fixture addressable area.
         """
+        deck_type = self._state.deck_type
+
         if deck_type == DeckType.OT2_STANDARD or deck_type == DeckType.OT2_SHORT_TRASH:
             raise ValueError(
                 f"Invalid Deck Type: {deck_type.name} - Does not support modules as fixtures."

opentrons/protocol_engine/state/motion.py

@@ -327,6 +327,7 @@ class MotionView:
         labware_id: str,
         well_name: str,
         center_point: Point,
+        mm_from_edge: float = 0,
         radius: float = 1.0,
     ) -> List[motion_planning.Waypoint]:
         """Get a list of touch points for a touch tip operation."""
@@ -346,7 +347,11 @@ class MotionView:
         )
 
         positions = _move_types.get_edge_point_list(
-            center_point, x_offset, y_offset, edge_path_type
+            center=center_point,
+            x_radius=x_offset,
+            y_radius=y_offset,
+            mm_from_edge=mm_from_edge,
+            edge_path_type=edge_path_type,
         )
         critical_point: Optional[CriticalPoint] = None