opentrons 8.2.0a3__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/frustum_helpers.py

@@ -82,19 +82,12 @@ def _circular_frustum_polynomial_roots(
 
 
 def _volume_from_height_circular(
-    target_height: float,
-    total_frustum_height: float,
-    bottom_radius: float,
-    top_radius: float,
+    target_height: float, segment: ConicalFrustum
 ) -> float:
     """Find the volume given a height within a circular frustum."""
-    a, b, c = _circular_frustum_polynomial_roots(
-        bottom_radius=bottom_radius,
-        top_radius=top_radius,
-        total_frustum_height=total_frustum_height,
-    )
-    volume = a * (target_height**3) + b * (target_height**2) + c * target_height
-    return volume
+    heights = segment.height_to_volume_table.keys()
+    best_fit_height = min(heights, key=lambda x: abs(x - target_height))
+    return segment.height_to_volume_table[best_fit_height]
 
 
 def _volume_from_height_rectangular(
@@ -138,26 +131,12 @@ def _volume_from_height_squared_cone(
 
 
 def _height_from_volume_circular(
-    volume: float,
-    total_frustum_height: float,
-    bottom_radius: float,
-    top_radius: float,
+    target_volume: float, segment: ConicalFrustum
 ) -> float:
-    """Find the height given a volume within a circular frustum."""
-    a, b, c = _circular_frustum_polynomial_roots(
-        bottom_radius=bottom_radius,
-        top_radius=top_radius,
-        total_frustum_height=total_frustum_height,
-    )
-    d = volume * -1
-    x_intercept_roots = (a, b, c, d)
-
-    height_from_volume_roots = roots(x_intercept_roots)
-    height = _reject_unacceptable_heights(
-        potential_heights=list(height_from_volume_roots),
-        max_height=total_frustum_height,
-    )
-    return height
+    """Find the height given a volume within a squared cone segment."""
+    volumes = segment.volume_to_height_table.keys()
+    best_fit_volume = min(volumes, key=lambda x: abs(x - target_volume))
+    return segment.volume_to_height_table[best_fit_volume]
 
 
 def _height_from_volume_rectangular(
@@ -220,28 +199,38 @@ def _get_segment_capacity(segment: WellSegment) -> float:
     section_height = segment.topHeight - segment.bottomHeight
     match segment:
         case SphericalSegment():
-            return _volume_from_height_spherical(
-                target_height=segment.topHeight,
-                radius_of_curvature=segment.radiusOfCurvature,
+            return (
+                _volume_from_height_spherical(
+                    target_height=segment.topHeight,
+                    radius_of_curvature=segment.radiusOfCurvature,
+                )
+                * segment.count
             )
         case CuboidalFrustum():
-            return _volume_from_height_rectangular(
-                target_height=section_height,
-                bottom_length=segment.bottomYDimension,
-                bottom_width=segment.bottomXDimension,
-                top_length=segment.topYDimension,
-                top_width=segment.topXDimension,
-                total_frustum_height=section_height,
+            return (
+                _volume_from_height_rectangular(
+                    target_height=section_height,
+                    bottom_length=segment.bottomYDimension,
+                    bottom_width=segment.bottomXDimension,
+                    top_length=segment.topYDimension,
+                    top_width=segment.topXDimension,
+                    total_frustum_height=section_height,
+                )
+                * segment.count
             )
         case ConicalFrustum():
-            return _volume_from_height_circular(
-                target_height=section_height,
-                total_frustum_height=section_height,
-                bottom_radius=(segment.bottomDiameter / 2),
-                top_radius=(segment.topDiameter / 2),
+            return (
+                _volume_from_height_circular(
+                    target_height=section_height,
+                    segment=segment,
+                )
+                * segment.count
             )
         case SquaredConeSegment():
-            return _volume_from_height_squared_cone(section_height, segment)
+            return (
+                _volume_from_height_squared_cone(section_height, segment)
+                * segment.count
+            )
         case _:
             # TODO: implement volume calculations for truncated circular and rounded rectangular segments
             raise NotImplementedError(
@@ -272,6 +261,7 @@ def height_at_volume_within_section(
     section_height: float,
 ) -> float:
     """Calculate a height within a bounded section according to geometry."""
+    target_volume_relative = target_volume_relative / section.count
     match section:
         case SphericalSegment():
             return _height_from_volume_spherical(
@@ -280,12 +270,7 @@ def height_at_volume_within_section(
                 radius_of_curvature=section.radiusOfCurvature,
             )
         case ConicalFrustum():
-            return _height_from_volume_circular(
-                volume=target_volume_relative,
-                top_radius=(section.bottomDiameter / 2),
-                bottom_radius=(section.topDiameter / 2),
-                total_frustum_height=section_height,
-            )
+            return _height_from_volume_circular(target_volume_relative, section)
         case CuboidalFrustum():
             return _height_from_volume_rectangular(
                 volume=target_volume_relative,
@@ -311,28 +296,37 @@ def volume_at_height_within_section(
     """Calculate a volume within a bounded section according to geometry."""
     match section:
         case SphericalSegment():
-            return _volume_from_height_spherical(
-                target_height=target_height_relative,
-                radius_of_curvature=section.radiusOfCurvature,
+            return (
+                _volume_from_height_spherical(
+                    target_height=target_height_relative,
+                    radius_of_curvature=section.radiusOfCurvature,
+                )
+                * section.count
             )
         case ConicalFrustum():
-            return _volume_from_height_circular(
-                target_height=target_height_relative,
-                total_frustum_height=section_height,
-                bottom_radius=(section.bottomDiameter / 2),
-                top_radius=(section.topDiameter / 2),
+            return (
+                _volume_from_height_circular(
+                    target_height=target_height_relative, segment=section
+                )
+                * section.count
             )
         case CuboidalFrustum():
-            return _volume_from_height_rectangular(
-                target_height=target_height_relative,
-                total_frustum_height=section_height,
-                bottom_width=section.bottomXDimension,
-                bottom_length=section.bottomYDimension,
-                top_width=section.topXDimension,
-                top_length=section.topYDimension,
+            return (
+                _volume_from_height_rectangular(
+                    target_height=target_height_relative,
+                    total_frustum_height=section_height,
+                    bottom_width=section.bottomXDimension,
+                    bottom_length=section.bottomYDimension,
+                    top_width=section.topXDimension,
+                    top_length=section.topYDimension,
+                )
+                * section.count
             )
         case SquaredConeSegment():
-            return _volume_from_height_squared_cone(target_height_relative, section)
+            return (
+                _volume_from_height_squared_cone(target_height_relative, section)
+                * section.count
+            )
         case _:
             # TODO(cm): this would be the NEST-96 2uL wells referenced in EXEC-712
             # we need to input the math attached to that issue
@@ -402,7 +396,7 @@ def _find_height_in_partial_frustum(
         if (
             bottom_section_volume
             < target_volume
-            < (bottom_section_volume + section_volume)
+            <= (bottom_section_volume + section_volume)
         ):
             relative_target_volume = target_volume - bottom_section_volume
             section_height = section.topHeight - section.bottomHeight

opentrons/protocol_engine/state/geometry.py

@@ -1,4 +1,5 @@
 """Geometry state getters."""
+
 import enum
 from numpy import array, dot, double as npdouble
 from numpy.typing import NDArray
@@ -8,6 +9,7 @@ from functools import cached_property
 
 from opentrons.types import Point, DeckSlotName, StagingSlotName, MountType
 
+from opentrons_shared_data.errors.exceptions import InvalidStoredData
 from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 from opentrons_shared_data.deck.types import CutoutFixture
 from opentrons_shared_data.pipette import PIPETTE_X_SPAN
@@ -61,6 +63,7 @@ from .frustum_helpers import (
     find_volume_at_well_height,
     find_height_at_well_volume,
 )
+from ._well_math import wells_covered_by_pipette_configuration, nozzles_per_well
 
 
 SLOT_WIDTH = 128
@@ -486,7 +489,7 @@ class GeometryView:
                 well_depth=well_depth,
                 operation_volume=operation_volume,
             )
-            offset = offset.copy(update={"z": offset.z + offset_adjustment})
+            offset = offset.model_copy(update={"z": offset.z + offset_adjustment})
             self.validate_well_position(
                 well_location=well_location, z_offset=offset.z, pipette_id=pipette_id
             )
@@ -1559,3 +1562,46 @@ class GeometryView:
                 raise errors.InvalidDispenseVolumeError(
                     f"Attempting to dispense {volume}µL of liquid into a well that can only hold {well_volumetric_capacity}µL (well {well_name} in labware_id: {labware_id})"
                 )
+
+    def get_wells_covered_by_pipette_with_active_well(
+        self, labware_id: str, target_well_name: str, pipette_id: str
+    ) -> list[str]:
+        """Get a flat list of wells that are covered by a pipette when moved to a specified well.
+
+        When you move a pipette in a multichannel configuration  to a specific well - the target well -
+        the pipette will operate on other wells as well.
+
+        For instance, a pipette with a COLUMN configuration with well A1 of an SBS standard labware target
+        will also "cover", under this definition, wells B1-H1. That same pipette, when C5 is the target well, will "cover"
+        wells C5-H5.
+
+        This math only works, and may only be applied, if one of the following is true:
+        - The pipette is in a SINGLE configuration
+        - The pipette is in a non-SINGLE configuration, and the labware is an SBS-format 96 or 384 well plate (and is so
+          marked in its definition's parameters.format key, as 96Standard or 384Standard)
+
+        If all of the following do not apply, regardless of the nozzle configuration of the pipette this function will
+        return only the labware covered by the primary well.
+        """
+        pipette_nozzle_map = self._pipettes.get_nozzle_configuration(pipette_id)
+        labware_columns = [
+            column for column in self._labware.get_definition(labware_id).ordering
+        ]
+        try:
+            return list(
+                wells_covered_by_pipette_configuration(
+                    pipette_nozzle_map, target_well_name, labware_columns
+                )
+            )
+        except InvalidStoredData:
+            return [target_well_name]
+
+    def get_nozzles_per_well(
+        self, labware_id: str, target_well_name: str, pipette_id: str
+    ) -> int:
+        """Get the number of nozzles that will interact with each well."""
+        return nozzles_per_well(
+            self._pipettes.get_nozzle_configuration(pipette_id),
+            target_well_name,
+            self._labware.get_definition(labware_id).ordering,
+        )

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.
@@ -479,7 +524,6 @@ class LabwareView(HasState[LabwareState]):
         will be used.
         """
         definition = self.get_definition(labware_id)
-
         if well_name is None:
             well_name = definition.ordering[0][0]
 
@@ -815,6 +859,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(
@@ -837,6 +886,19 @@ class LabwareView(HasState[LabwareState]):
                     f"Labware {labware.loadName} is already present at {location}."
                 )
 
+    def raise_if_labware_cannot_be_ondeck(
+        self,
+        location: LabwareLocation,
+        labware_definition: LabwareDefinition,
+    ) -> None:
+        """Raise an error if the labware cannot be in the specified location."""
+        if isinstance(
+            location, (DeckSlotLocation, AddressableAreaLocation)
+        ) and not labware_validation.validate_labware_can_be_ondeck(labware_definition):
+            raise errors.LabwareCannotSitOnDeckError(
+                f"{labware_definition.parameters.loadName} cannot sit in a slot by itself."
+            )
+
     def raise_if_labware_incompatible_with_plate_reader(
         self,
         labware_definition: LabwareDefinition,
@@ -998,11 +1060,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