opentrons 8.4.0a6__py2.py3-none-any.whl → 8.4.0a8__py2.py3-none-any.whl

opentrons/protocol_engine/state/geometry.py

@@ -17,7 +17,10 @@ from opentrons.types import (
     MeniscusTrackingTarget,
 )
 
-from opentrons_shared_data.errors.exceptions import InvalidStoredData
+from opentrons_shared_data.errors.exceptions import (
+    InvalidStoredData,
+    PipetteLiquidNotFoundError,
+)
 from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.deck.types import CutoutFixture
@@ -31,6 +34,8 @@ from ..errors import (
     LabwareNotLoadedOnModuleError,
     LabwareMovementNotAllowedError,
     OperationLocationNotInWellError,
+    InvalidLabwarePositionError,
+    LabwareNotOnDeckError,
 )
 from ..errors.exceptions import InvalidLiquidHeightFound
 from ..resources import (
@@ -373,6 +378,59 @@ class GeometryView:
                 "Either it has been loaded off-deck or its been moved off-deck."
             )
 
+    def _get_offset_from_parent_addressable_area(
+        self, child_definition: LabwareDefinition, parent: LabwareLocation
+    ) -> LabwareOffsetVector:
+        """Gets the offset vector of a labware from its eventual parent addressable area.
+
+        This returns the sum of the offsets for any labware-on-labware pairs plus the
+        "base offset", which is (0, 0, 0) in all cases except for modules on the
+        OT-2. See
+        protocol_engine.state.modules.get_nominal_offset_to_child_from_addressable_area
+        for more.
+
+        This does not incorporate LPC offsets or module calibration offsets.
+        """
+        if isinstance(parent, (AddressableAreaLocation, DeckSlotLocation)):
+            return LabwareOffsetVector(x=0, y=0, z=0)
+        elif isinstance(parent, ModuleLocation):
+            module_id = parent.moduleId
+            module_model = self._modules.get_connected_model(module_id)
+            stacking_overlap = self._labware.get_module_overlap_offsets(
+                child_definition, module_model
+            )
+            module_to_child = (
+                self._modules.get_nominal_offset_to_child_from_addressable_area(
+                    module_id=module_id
+                )
+            )
+            return LabwareOffsetVector(
+                x=module_to_child.x - stacking_overlap.x,
+                y=module_to_child.y - stacking_overlap.y,
+                z=module_to_child.z - stacking_overlap.z,
+            )
+        elif isinstance(parent, OnLabwareLocation):
+            on_labware = self._labware.get(parent.labwareId)
+            on_labware_dimensions = self._labware.get_dimensions(
+                labware_id=on_labware.id
+            )
+            stacking_overlap = self._labware.get_labware_overlap_offsets(
+                definition=child_definition, below_labware_name=on_labware.loadName
+            )
+            labware_offset = LabwareOffsetVector(
+                x=stacking_overlap.x,
+                y=stacking_overlap.y,
+                z=on_labware_dimensions.z - stacking_overlap.z,
+            )
+            return labware_offset + self._get_offset_from_parent_addressable_area(
+                self._labware.get_definition(on_labware.id), on_labware.location
+            )
+        else:
+            raise errors.LabwareNotOnDeckError(
+                "Cannot access labware since it is not on the deck. "
+                "Either it has been loaded off-deck or it has been moved off-deck."
+            )
+
     def _normalize_module_calibration_offset(
         self,
         module_location: DeckSlotLocation,
@@ -498,6 +556,30 @@ class GeometryView:
                     f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location below the bottom of the well"
                 )
 
+    def validate_probed_height(
+        self,
+        labware_id: str,
+        well_name: str,
+        pipette_id: str,
+        probed_height: LiquidTrackingType,
+    ) -> None:
+        """Raise an error if a probed liquid height is not within well bounds."""
+        if isinstance(probed_height, SimulatedProbeResult):
+            return
+        lld_min_height = self._pipettes.get_current_tip_lld_settings(
+            pipette_id=pipette_id
+        )
+        well_def = self._labware.get_well_definition(labware_id, well_name)
+        well_depth = well_def.depth
+        if probed_height < lld_min_height:
+            raise PipetteLiquidNotFoundError(
+                f"Liquid Height of {probed_height} mm is lower minumum allowed lld height {lld_min_height} mm."
+            )
+        if probed_height > well_depth:
+            raise PipetteLiquidNotFoundError(
+                f"Liquid Height of {probed_height} mm is greater than maximum well height {well_depth} mm."
+            )
+
     def get_well_position(
         self,
         labware_id: str,
@@ -520,6 +602,7 @@ class GeometryView:
                 well_location=well_location,
                 well_depth=well_depth,
                 operation_volume=operation_volume,
+                pipette_id=pipette_id,
             )
             if not isinstance(offset_adjustment, SimulatedProbeResult):
                 offset = offset.model_copy(update={"z": offset.z + offset_adjustment})
@@ -694,6 +777,7 @@ class GeometryView:
         labware_id: str,
         well_location: DropTipWellLocation,
         partially_configured: bool = False,
+        override_default_offset: float | None = None,
     ) -> WellLocation:
         """Get tip drop location given labware and hardware pipette.
 
@@ -712,8 +796,9 @@ class GeometryView:
                 origin=WellOrigin(well_location.origin.value),
                 offset=well_location.offset,
             )
-
-        if self._labware.get_definition(labware_id).parameters.isTiprack:
+        if override_default_offset is not None:
+            z_offset = override_default_offset
+        elif self._labware.get_definition(labware_id).parameters.isTiprack:
             z_offset = self._labware.get_tip_drop_z_offset(
                 labware_id=labware_id,
                 length_scale=self._pipettes.get_return_tip_scale(pipette_id),
@@ -794,6 +879,32 @@ class GeometryView:
 
         return slot_name
 
+    def get_ancestor_addressable_area_name(self, labware_id: str) -> str:
+        """Get the name of the addressable area the labware is eventually on."""
+        labware = self._labware.get(labware_id)
+        original_display_name = self._labware.get_display_name(labware_id)
+        seen: Set[str] = set((labware_id,))
+        while isinstance(labware.location, OnLabwareLocation):
+            labware = self._labware.get(labware.location.labwareId)
+            if labware.id in seen:
+                raise InvalidLabwarePositionError(
+                    f"Cycle detected in labware positioning for {original_display_name}"
+                )
+            seen.add(labware.id)
+        if isinstance(labware.location, DeckSlotLocation):
+            return labware.location.slotName.id
+        elif isinstance(labware.location, AddressableAreaLocation):
+            return labware.location.addressableAreaName
+        elif isinstance(labware.location, ModuleLocation):
+            return self._modules.get_provided_addressable_area(
+                labware.location.moduleId
+            )
+        else:
+            raise LabwareNotOnDeckError(
+                f"Labware {original_display_name} is not loaded on deck",
+                details={"eventual-location": repr(labware.location)},
+            )
+
     def ensure_location_not_occupied(
         self,
         location: _LabwareLocation,
@@ -961,70 +1072,23 @@ class GeometryView:
             self._labware.get_grip_height_from_labware_bottom(labware_definition)
         )
         location_name: str
-        module_location: ModuleLocation | None = None
-
+        offset = self._get_offset_from_parent_addressable_area(
+            child_definition=labware_definition, parent=location
+        ) + self._get_calibrated_module_offset(location)
         if isinstance(location, DeckSlotLocation):
             location_name = location.slotName.id
-            offset = LabwareOffsetVector(x=0, y=0, z=0)
         elif isinstance(location, AddressableAreaLocation):
             location_name = location.addressableAreaName
-            if fixture_validation.is_gripper_waste_chute(location_name):
-                drop_labware_location = (
-                    self._addressable_areas.get_addressable_area_move_to_location(
-                        location_name
-                    )
-                )
-                return drop_labware_location + Point(z=grip_height_from_labware_bottom)
-            # Location should have been pre-validated so this will be a deck/staging area slot
-            else:
-                offset = LabwareOffsetVector(x=0, y=0, z=0)
-        else:
-            if isinstance(location, ModuleLocation):
-                location_name = self._modules.get_provided_addressable_area(
-                    location.moduleId
-                )
-                module_location = location
-            else:  # OnLabwareLocation
-                labware_loc = self._labware.get(location.labwareId).location
-                if isinstance(labware_loc, ModuleLocation):
-                    location_name = self._modules.get_provided_addressable_area(
-                        labware_loc.moduleId
-                    )
-                    module_location = labware_loc
-                else:
-                    location_name = self.get_ancestor_slot_name(location.labwareId).id
-            labware_offset = self._get_offset_from_parent(
-                child_definition=labware_definition, parent=location
-            )
-            # Get the calibrated offset if the on labware location is on top of a module, otherwise return empty one
-            cal_offset = self._get_calibrated_module_offset(location)
-            offset = LabwareOffsetVector(
-                x=labware_offset.x + cal_offset.x,
-                y=labware_offset.y + cal_offset.y,
-                z=labware_offset.z + cal_offset.z,
-            )
-
-        if module_location is not None:
-            # Location center must be determined from the cutout the Module is loaded in
-            position = deck_configuration_provider.get_cutout_position(
-                cutout_id=self._addressable_areas.get_cutout_id_by_deck_slot_name(
-                    self._modules.get_location(module_location.moduleId).slotName
-                ),
-                deck_definition=self._addressable_areas.deck_definition,
-            )
-            bounding_box = self._addressable_areas.get_addressable_area(
-                location_name
-            ).bounding_box
-            location_center = Point(
-                position.x + bounding_box.x / 2,
-                position.y + bounding_box.y / 2,
-                position.z,
+        elif isinstance(location, ModuleLocation):
+            location_name = self._modules.get_provided_addressable_area(
+                location.moduleId
             )
+        else:  # OnLabwareLocation
+            location_name = self.get_ancestor_addressable_area_name(location.labwareId)
 
-        else:
-            location_center = self._addressable_areas.get_addressable_area_center(
-                location_name
-            )
+        location_center = self._addressable_areas.get_addressable_area_center(
+            location_name
+        )
 
         return Point(
             location_center.x + offset.x,
@@ -1463,10 +1527,6 @@ class GeometryView:
     # * The "additional offset" or "user offset", e.g. the `pickUpOffset` and `dropOffset`
     #   params in the `moveLabware` command.
     #
-    # And this *does* take these extra offsets into account:
-    #
-    # * The labware's Labware Position Check offset
-    #
     # For robustness, we should combine this with `get_gripper_labware_movement_waypoints()`.
     #
     # We should also be more explicit about which offsets act to move the gripper paddles
@@ -1488,23 +1548,17 @@ class GeometryView:
                 return
 
             tip = self._pipettes.get_attached_tip(pipette.id)
-            if tip:
-                # NOTE: This call to get_labware_highest_z() uses the labware's LPC offset,
-                # which is an inconsistency between this and the actual gripper movement.
-                # See the todo comment above this function.
-                labware_top_z_when_gripped = gripper_homed_position_z + (
-                    self.get_labware_highest_z(labware_id=labware_id)
-                    - self.get_labware_grip_point(
-                        labware_definition=labware_definition, location=current_location
-                    ).z
+            if not tip:
+                continue
+            labware_top_z_when_gripped = gripper_homed_position_z + (
+                self._labware.get_dimensions(labware_definition=labware_definition).z
+                - self._labware.get_grip_height_from_labware_bottom(labware_definition)
+            )
+            # TODO(cb, 2024-01-18): Utilizing the nozzle map and labware X coordinates verify if collisions will occur on the X axis (analysis will use hard coded data to measure from the gripper critical point to the pipette mount)
+            if (_PIPETTE_HOMED_POSITION_Z - tip.length) < labware_top_z_when_gripped:
+                raise LabwareMovementNotAllowedError(
+                    f"Cannot move labware '{labware_definition.parameters.loadName}' when {int(tip.volume)} µL tips are attached."
                 )
-                # TODO(cb, 2024-01-18): Utilizing the nozzle map and labware X coordinates verify if collisions will occur on the X axis (analysis will use hard coded data to measure from the gripper critical point to the pipette mount)
-                if (
-                    _PIPETTE_HOMED_POSITION_Z - tip.length
-                ) < labware_top_z_when_gripped:
-                    raise LabwareMovementNotAllowedError(
-                        f"Cannot move labware '{labware_definition.parameters.loadName}' when {int(tip.volume)} µL tips are attached."
-                    )
         return
 
     def _nominal_gripper_offsets_for_location(
@@ -1844,6 +1898,7 @@ class GeometryView:
         self,
         labware_id: str,
         well_name: str,
+        pipette_id: str,
         operation_volume: float,
     ) -> float:
         """Get the change in height from a liquid handling operation."""
@@ -1853,6 +1908,7 @@ class GeometryView:
         final_height = self.get_well_height_after_liquid_handling(
             labware_id=labware_id,
             well_name=well_name,
+            pipette_id=pipette_id,
             initial_height=initial_handling_height,
             volume=operation_volume,
         )
@@ -1873,6 +1929,7 @@ class GeometryView:
         well_name: str,
         well_location: WellLocationType,
         well_depth: float,
+        pipette_id: Optional[str] = None,
         operation_volume: Optional[float] = None,
     ) -> LiquidTrackingType:
         """Return a z-axis distance that accounts for well handling height and operation volume.
@@ -1906,9 +1963,14 @@ class GeometryView:
                 volume = well_location.volumeOffset
 
         if volume:
+            if pipette_id is None:
+                raise ValueError(
+                    "cannot get liquid handling offset without pipette id."
+                )
             liquid_height_after = self.get_well_height_after_liquid_handling(
                 labware_id=labware_id,
                 well_name=well_name,
+                pipette_id=pipette_id,
                 initial_height=initial_handling_height,
                 volume=volume,
             )
@@ -2030,6 +2092,7 @@ class GeometryView:
         self,
         labware_id: str,
         well_name: str,
+        pipette_id: str,
         initial_height: LiquidTrackingType,
         volume: float,
     ) -> LiquidTrackingType:
@@ -2044,7 +2107,14 @@ class GeometryView:
             initial_volume = find_volume_at_well_height(
                 target_height=initial_height, well_geometry=well_geometry
             )
-            final_volume = initial_volume + volume
+            final_volume = initial_volume + (
+                volume
+                * self.get_nozzles_per_well(
+                    labware_id=labware_id,
+                    target_well_name=well_name,
+                    pipette_id=pipette_id,
+                )
+            )
             return find_height_at_well_volume(
                 target_volume=final_volume, well_geometry=well_geometry
             )
@@ -2058,6 +2128,7 @@ class GeometryView:
         self,
         labware_id: str,
         well_name: str,
+        pipette_id: str,
         initial_height: LiquidTrackingType,
         volume: float,
     ) -> LiquidTrackingType:
@@ -2073,7 +2144,14 @@ class GeometryView:
             initial_volume = find_volume_at_well_height(
                 target_height=initial_height, well_geometry=well_geometry
             )
-            final_volume = initial_volume + volume
+            final_volume = initial_volume + (
+                volume
+                * self.get_nozzles_per_well(
+                    labware_id=labware_id,
+                    target_well_name=well_name,
+                    pipette_id=pipette_id,
+                )
+            )
             well_volume = find_height_at_well_volume(
                 target_volume=final_volume,
                 well_geometry=well_geometry,

opentrons/protocol_engine/state/modules.py

@@ -930,10 +930,39 @@ class ModuleView:
         Includes the slot-specific transform. Does not include the child's
         Labware Position Check offset.
         """
-        if (
-            self._state.deck_type == DeckType.OT2_STANDARD
-            or self._state.deck_type == DeckType.OT2_SHORT_TRASH
-        ):
+        base = self.get_nominal_offset_to_child_from_addressable_area(module_id)
+        if self.get_deck_supports_module_fixtures():
+            module_addressable_area = self.get_provided_addressable_area(module_id)
+            module_addressable_area_position = (
+                addressable_areas.get_addressable_area_offsets_from_cutout(
+                    module_addressable_area
+                )
+            )
+            return base + LabwareOffsetVector(
+                x=module_addressable_area_position.x,
+                y=module_addressable_area_position.y,
+                z=module_addressable_area_position.z,
+            )
+        else:
+            return base
+
+    def get_nominal_offset_to_child_from_addressable_area(
+        self, module_id: str
+    ) -> LabwareOffsetVector:
+        """Get the position offset for a child of this module from the nearest AA.
+
+        On the Flex, this is always (0, 0, 0); on the OT-2, since modules load on top
+        of addressable areas rather than providing addressable areas, the offset is
+        the labwareOffset from the module definition, rotated by the module's
+        slotTransform if appropriate.
+        """
+        if self.get_deck_supports_module_fixtures():
+            return LabwareOffsetVector(
+                x=0,
+                y=0,
+                z=0,
+            )
+        else:
             definition = self.get_definition(module_id)
             slot = self.get_location(module_id).slotName.id
 
@@ -968,18 +997,6 @@ class ModuleView:
                 y=xformed[1],
                 z=xformed[2],
             )
-        else:
-            module_addressable_area = self.get_provided_addressable_area(module_id)
-            module_addressable_area_position = (
-                addressable_areas.get_addressable_area_offsets_from_cutout(
-                    module_addressable_area
-                )
-            )
-            return LabwareOffsetVector(
-                x=module_addressable_area_position.x,
-                y=module_addressable_area_position.y,
-                z=module_addressable_area_position.z,
-            )
 
     def get_module_calibration_offset(
         self, module_id: str

opentrons/protocol_engine/types/__init__.py

@@ -135,6 +135,7 @@ from .liquid_level_detection import (
     WellInfoSummary,
     WellLiquidInfo,
     LiquidTrackingType,
+    SimulatedProbeResult,
 )
 from .liquid_handling import FlowRates
 from .labware_movement import LabwareMovementStrategy, LabwareMovementOffsetData
@@ -280,6 +281,7 @@ __all__ = [
     "WellInfoSummary",
     "WellLiquidInfo",
     "LiquidTrackingType",
+    "SimulatedProbeResult",
     # Liquid handling
     "FlowRates",
     # Labware movement

opentrons/protocol_engine/types/liquid_level_detection.py

@@ -1,9 +1,10 @@
 """Protocol Engine types to do with liquid level detection."""
+
 from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional, List
-from pydantic import BaseModel, model_serializer, field_validator
+from typing import Optional, List, Any
+from pydantic import BaseModel, model_serializer, model_validator
 
 
 class SimulatedProbeResult(BaseModel):
@@ -17,6 +18,14 @@ class SimulatedProbeResult(BaseModel):
         """Serialize instances of this class as a string."""
         return "SimulatedProbeResult"
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_model(cls, data: object) -> Any:
+        """Handle deserializing from a simulated probe result."""
+        if isinstance(data, str) and data == "SimulatedProbeResult":
+            return {}
+        return data
+
     def __add__(
         self, other: float | SimulatedProbeResult
     ) -> float | SimulatedProbeResult:
@@ -75,7 +84,9 @@ class SimulatedProbeResult(BaseModel):
         self.operations_after_probe.append(volume)
 
 
-LiquidTrackingType = SimulatedProbeResult | float
+# Work around https://github.com/pydantic/pydantic/issues/6830 - do not change the order of
+# this union
+LiquidTrackingType = float | SimulatedProbeResult
 
 
 class LoadedVolumeInfo(BaseModel):
@@ -104,23 +115,6 @@ class ProbedVolumeInfo(BaseModel):
 class WellInfoSummary(BaseModel):
     """Payload for a well's liquid info in StateSummary."""
 
-    # TODO(cm): 3/21/25: refactor SimulatedLiquidProbe in a way that
-    # doesn't require models like this one that are just using it to
-    # need a custom validator
-    @field_validator("probed_height", "probed_volume", mode="before")
-    @classmethod
-    def validate_simulated_probe_result(
-        cls, input_val: object
-    ) -> LiquidTrackingType | None:
-        """Return the appropriate input to WellInfoSummary from json data."""
-        if input_val is None:
-            return None
-        if isinstance(input_val, LiquidTrackingType):
-            return input_val
-        if isinstance(input_val, str) and input_val == "SimulatedProbeResult":
-            return SimulatedProbeResult()
-        raise ValueError(f"Invalid input value {input_val} to WellInfoSummary")
-
     labware_id: str
     well_name: str
     loaded_volume: Optional[float] = None

opentrons/protocol_engine/types/module.py

@@ -253,6 +253,38 @@ class ModuleOffsetVector(BaseModel):
     y: float
     z: float
 
+    def __add__(self, other: Any) -> ModuleOffsetVector:
+        """Adds two vectors together."""
+        if not isinstance(other, (LabwareOffsetVector, ModuleOffsetVector)):
+            return NotImplemented
+        return ModuleOffsetVector(
+            x=self.x + other.x, y=self.y + other.y, z=self.z + other.z
+        )
+
+    def __radd__(self, other: Any) -> ModuleOffsetVector:
+        """Adds two vectors together, the other way."""
+        if not isinstance(other, (LabwareOffsetVector, ModuleOffsetVector)):
+            return NotImplemented
+        return ModuleOffsetVector(
+            x=other.x + self.x, y=other.y + self.y, z=other.z + self.z
+        )
+
+    def __sub__(self, other: Any) -> ModuleOffsetVector:
+        """Subtracts two vectors."""
+        if not isinstance(other, (LabwareOffsetVector, ModuleOffsetVector)):
+            return NotImplemented
+        return ModuleOffsetVector(
+            x=self.x - other.x, y=self.y - other.y, z=self.z - other.z
+        )
+
+    def __rsub__(self, other: Any) -> ModuleOffsetVector:
+        """Subtracts two vectors, the other way."""
+        if not isinstance(other, (LabwareOffsetVector, ModuleOffsetVector)):
+            return NotImplemented
+        return ModuleOffsetVector(
+            x=other.x - self.x, y=other.y - self.y, z=other.z - self.z
+        )
+
 
 @dataclass
 class ModuleOffsetData:

{opentrons-8.4.0a6.dist-info → opentrons-8.4.0a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentrons
-Version: 8.4.0a6
+Version: 8.4.0a8
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Author: Opentrons
 Author-email: engineering@opentrons.com
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 License-File: ../LICENSE
-Requires-Dist: opentrons-shared-data (==8.4.0a6)
+Requires-Dist: opentrons-shared-data (==8.4.0a8)
 Requires-Dist: aionotify (==0.3.1)
 Requires-Dist: anyio (<4.0.0,>=3.6.1)
 Requires-Dist: jsonschema (<4.18.0,>=3.0.1)
@@ -35,9 +35,9 @@ Requires-Dist: pyusb (==1.2.1)
 Requires-Dist: packaging (>=21.0)
 Requires-Dist: importlib-metadata (>=1.0) ; python_version < "3.8"
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex] (==8.4.0a6) ; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex] (==8.4.0a8) ; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware (==8.4.0a6) ; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware (==8.4.0a8) ; extra == 'ot2-hardware'
 
 .. _Full API Documentation: http://docs.opentrons.com