opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/protocol_engine/state/addressable_areas.py

@@ -1,4 +1,5 @@
 """Basic addressable area data state and store."""
+
 from dataclasses import dataclass
 from functools import cached_property
 from typing import Dict, List, Optional, Set
@@ -112,43 +113,6 @@ def _get_conflicting_addressable_areas_error_string(
     return ", ".join(display_names)
 
 
-# This is a temporary shim while Protocol Engine's conflict-checking code
-# can only take deck slots as input.
-# Long-term solution: Check for conflicts based on bounding boxes, not slot adjacencies.
-# Shorter-term: Change the conflict-checking code to take cutouts instead of deck slots.
-CUTOUT_TO_DECK_SLOT_MAP: Dict[str, DeckSlotName] = {
-    # OT-2
-    "cutout1": DeckSlotName.SLOT_1,
-    "cutout2": DeckSlotName.SLOT_2,
-    "cutout3": DeckSlotName.SLOT_3,
-    "cutout4": DeckSlotName.SLOT_4,
-    "cutout5": DeckSlotName.SLOT_5,
-    "cutout6": DeckSlotName.SLOT_6,
-    "cutout7": DeckSlotName.SLOT_7,
-    "cutout8": DeckSlotName.SLOT_8,
-    "cutout9": DeckSlotName.SLOT_9,
-    "cutout10": DeckSlotName.SLOT_10,
-    "cutout11": DeckSlotName.SLOT_11,
-    "cutout12": DeckSlotName.FIXED_TRASH,
-    # Flex
-    "cutoutA1": DeckSlotName.SLOT_A1,
-    "cutoutA2": DeckSlotName.SLOT_A2,
-    "cutoutA3": DeckSlotName.SLOT_A3,
-    "cutoutB1": DeckSlotName.SLOT_B1,
-    "cutoutB2": DeckSlotName.SLOT_B2,
-    "cutoutB3": DeckSlotName.SLOT_B3,
-    "cutoutC1": DeckSlotName.SLOT_C1,
-    "cutoutC2": DeckSlotName.SLOT_C2,
-    "cutoutC3": DeckSlotName.SLOT_C3,
-    "cutoutD1": DeckSlotName.SLOT_D1,
-    "cutoutD2": DeckSlotName.SLOT_D2,
-    "cutoutD3": DeckSlotName.SLOT_D3,
-}
-DECK_SLOT_TO_CUTOUT_MAP = {
-    deck_slot: cutout for cutout, deck_slot in CUTOUT_TO_DECK_SLOT_MAP.items()
-}
-
-
 class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
     """Addressable area state container."""
 
@@ -221,13 +185,11 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
             cutout_position = deck_configuration_provider.get_cutout_position(
                 cutout_id, deck_definition
             )
-            base_slot = CUTOUT_TO_DECK_SLOT_MAP[cutout_id]
             for addressable_area_name in provided_addressable_areas:
                 addressable_areas.append(
                     deck_configuration_provider.get_addressable_area_from_name(
                         addressable_area_name=addressable_area_name,
                         cutout_position=cutout_position,
-                        base_slot=base_slot,
                         deck_definition=deck_definition,
                     )
                 )
@@ -242,12 +204,10 @@ class AddressableAreaStore(HasState[AddressableAreaState], HandlesActions):
             cutout_position = deck_configuration_provider.get_cutout_position(
                 cutout_id, self._state.deck_definition
             )
-            base_slot = CUTOUT_TO_DECK_SLOT_MAP[cutout_id]
             addressable_area = (
                 deck_configuration_provider.get_addressable_area_from_name(
                     addressable_area_name=addressable_area_name,
                     cutout_position=cutout_position,
-                    base_slot=base_slot,
                     deck_definition=self._state.deck_definition,
                 )
             )
@@ -300,6 +260,11 @@ class AddressableAreaView:
         """
         self._state = state
 
+    @cached_property
+    def deck_definition(self) -> DeckDefinitionV5:
+        """The full deck definition."""
+        return self._state.deck_definition
+
     @cached_property
     def deck_extents(self) -> Point:
         """The maximum space on the deck."""
@@ -426,11 +391,9 @@ class AddressableAreaView:
         cutout_position = deck_configuration_provider.get_cutout_position(
             cutout_id, self._state.deck_definition
         )
-        base_slot = CUTOUT_TO_DECK_SLOT_MAP[cutout_id]
         return deck_configuration_provider.get_addressable_area_from_name(
             addressable_area_name=addressable_area_name,
             cutout_position=cutout_position,
-            base_slot=base_slot,
             deck_definition=self._state.deck_definition,
         )
 
@@ -526,7 +489,7 @@ class AddressableAreaView:
 
     def get_cutout_id_by_deck_slot_name(self, slot_name: DeckSlotName) -> str:
         """Get the Cutout ID of a given Deck Slot by Deck Slot Name."""
-        return DECK_SLOT_TO_CUTOUT_MAP[slot_name]
+        return deck_configuration_provider.get_cutout_id_by_deck_slot_name(slot_name)
 
     def get_fixture_by_deck_slot_name(
         self, slot_name: DeckSlotName
@@ -534,7 +497,9 @@ class AddressableAreaView:
         """Get the Cutout Fixture currently loaded where a specific Deck Slot would be."""
         deck_config = self._state.deck_configuration
         if deck_config:
-            slot_cutout_id = DECK_SLOT_TO_CUTOUT_MAP[slot_name]
+            slot_cutout_id = (
+                deck_configuration_provider.get_cutout_id_by_deck_slot_name(slot_name)
+            )
             slot_cutout_fixture = None
             # This will only ever be one under current assumptions
             for (
@@ -571,7 +536,9 @@ class AddressableAreaView:
         """Get the serial number provided by the deck configuration for a Fixture at a given location."""
         deck_config = self._state.deck_configuration
         if deck_config:
-            slot_cutout_id = DECK_SLOT_TO_CUTOUT_MAP[slot_name]
+            slot_cutout_id = (
+                deck_configuration_provider.get_cutout_id_by_deck_slot_name(slot_name)
+            )
             # This will only ever be one under current assumptions
             for (
                 cutout_id,
@@ -582,6 +549,44 @@ class AddressableAreaView:
                     return opentrons_module_serial_number
         return None
 
+    def get_serial_number_by_cutout_id(self, slot_cutout_id: str) -> str | None:
+        """Gets serial number from deck at a given cutout ID if one exists."""
+        deck_config = self._state.deck_configuration
+        if deck_config:
+            for (
+                cutout_id,
+                cutout_fixture_id,
+                opentrons_module_serial_number,
+            ) in deck_config:
+                if cutout_id == slot_cutout_id:
+                    return opentrons_module_serial_number
+        return None
+
+    def get_fixture_serial_from_deck_configuration_by_addressable_area(
+        self, addressable_area_name: str
+    ) -> Optional[str]:
+        """Get the serial number provided by the deck configuration for a Fixture that provides a given addressable area."""
+        deck_config = self._state.deck_configuration
+        if deck_config:
+            potential_fixtures = (
+                deck_configuration_provider.get_potential_cutout_fixtures(
+                    addressable_area_name, self._state.deck_definition
+                )
+            )
+            slot_cutout_id = potential_fixtures[0]
+            fixture_ids = [
+                fixture.cutout_fixture_id for fixture in potential_fixtures[1]
+            ]
+            # This will only ever be one under current assumptions
+            for (
+                cutout_id,
+                cutout_fixture_id,
+                opentrons_module_serial_number,
+            ) in deck_config:
+                if cutout_id == slot_cutout_id and cutout_fixture_id in fixture_ids:
+                    return opentrons_module_serial_number
+        return None
+
     def get_slot_definition(self, slot_id: str) -> SlotDefV3:
         """Get the definition of a slot in the deck.
 
@@ -658,3 +663,36 @@ class AddressableAreaView:
                 raise AreaNotInDeckConfigurationError(
                     f"{addressable_area_name} not provided by deck configuration."
                 )
+
+    def get_current_potential_cutout_fixtures_for_addressable_area(
+        self, addressable_area_name: str
+    ) -> tuple[str, Set[PotentialCutoutFixture]]:
+        """Get the set of cutout fixtures that might provide a given addressable area.
+
+        This takes into account the constraints already established by load commands or by a loaded deck
+        configuration, and may therefore return different results for the same addressable area at
+        different points in the protocol after deck configuration constraints have changed.
+
+        This returns the common cutout id and the potential fixtures.
+        """
+        (
+            cutout_id,
+            base_potential_fixtures,
+        ) = deck_configuration_provider.get_potential_cutout_fixtures(
+            addressable_area_name, self._state.deck_definition
+        )
+        try:
+            loaded_potential_fixtures = (
+                self._state.potential_cutout_fixtures_by_cutout_id[cutout_id]
+            )
+            return cutout_id, loaded_potential_fixtures.intersection(
+                base_potential_fixtures
+            )
+        except KeyError:
+            # If there was a key error here, it's because this function was (eventually) called
+            # from the body of a command implementation whose state update will load the
+            # addressable area it's querying... but that state update has not been submitted
+            # and processed, so nothing has created the entry for this cutout id yet. Do what
+            # we'll do when we actually get to that state update, which is apply the base
+            # potential fixtures from the deck def.
+            return cutout_id, base_potential_fixtures

opentrons/protocol_engine/state/frustum_helpers.py

@@ -5,6 +5,10 @@ from math import isclose
 
 from ..errors.exceptions import InvalidLiquidHeightFound
 
+from opentrons.protocol_engine.types.liquid_level_detection import (
+    LiquidTrackingType,
+    SimulatedProbeResult,
+)
 from opentrons_shared_data.labware.labware_definition import (
     InnerWellGeometry,
     WellSegment,
@@ -241,9 +245,8 @@ def _get_segment_capacity(segment: WellSegment) -> float:
 def get_well_volumetric_capacity(
     well_geometry: InnerWellGeometry,
 ) -> List[Tuple[float, float]]:
-    """Return the total volumetric capacity of a well as a map of height borders to volume."""
-    # dictionary map of heights to volumetric capacities within their respective segment
-    # {top_height_0: volume_0, top_height_1: volume_1, top_height_2: volume_2}
+    """Return the volumetric capacity of a well as a list of pairs relating segment heights to volumes."""
+    #  [(top_height_0, section_0_volume), (top_height_1, section_1_volume), ...]
     well_volume = []
 
     # get the well segments sorted in ascending order
@@ -341,7 +344,7 @@ def _find_volume_in_partial_frustum(
 ) -> float:
     """Look through a sorted list of frusta for a target height, and find the volume at that height."""
     for segment in sorted_well:
-        if segment.bottomHeight < target_height < segment.topHeight:
+        if segment.bottomHeight <= target_height <= segment.topHeight:
             relative_target_height = target_height - segment.bottomHeight
             section_height = segment.topHeight - segment.bottomHeight
             return volume_at_height_within_section(
@@ -350,19 +353,26 @@ def _find_volume_in_partial_frustum(
                 section_height=section_height,
             )
     # if we've looked through all sections and can't find the target volume, raise an error
+    # this code should never be reached- an error should be raised by find_volume_at_well_height
     raise InvalidLiquidHeightFound(
-        f"Unable to find volume at given well-height {target_height}."
+        f"Target height {target_height} mm exceeds the well height."
     )
 
 
 def find_volume_at_well_height(
-    target_height: float, well_geometry: InnerWellGeometry
-) -> float:
+    target_height: LiquidTrackingType,
+    well_geometry: InnerWellGeometry,
+) -> LiquidTrackingType:
     """Find the volume within a well, at a known height."""
+    # comparisons with SimulatedProbeResult objects aren't meaningful, just return
+    if isinstance(target_height, SimulatedProbeResult):
+        return target_height
     volumetric_capacity = get_well_volumetric_capacity(well_geometry)
     max_height = volumetric_capacity[-1][0]
     if target_height < 0 or target_height > max_height:
-        raise InvalidLiquidHeightFound("Invalid target height.")
+        raise InvalidLiquidHeightFound(
+            f"Invalid target height {target_height} mm; max well height is {max_height} mm."
+        )
     # volumes in volumetric_capacity are relative to each frustum,
     # so we have to find the volume of all the full sections enclosed
     # beneath the target height
@@ -395,7 +405,7 @@ def _find_height_in_partial_frustum(
         section_top_height, section_volume = capacity
         if (
             bottom_section_volume
-            < target_volume
+            <= target_volume
             <= (bottom_section_volume + section_volume)
         ):
             relative_target_volume = target_volume - bottom_section_volume
@@ -410,21 +420,33 @@ def _find_height_in_partial_frustum(
         # viewed section
         bottom_section_volume += section_volume
 
+    # if we finish looping through the whole well, bottom_section will be the well's volume
+    total_well_volume = bottom_section_volume
     # if we've looked through all sections and can't find the target volume, raise an error
+    # also this code should never be reached bc an invalid target volume should be changed
+    # by find_height_at_well_volume
     raise InvalidLiquidHeightFound(
-        f"Unable to find height at given volume {target_volume}."
+        f"Target volume {target_volume} uL exceeds the well volume {total_well_volume} uL."
     )
 
 
 def find_height_at_well_volume(
-    target_volume: float, well_geometry: InnerWellGeometry
-) -> float:
+    target_volume: LiquidTrackingType,
+    well_geometry: InnerWellGeometry,
+) -> LiquidTrackingType:
     """Find the height within a well, at a known volume."""
+    # comparisons with SimulatedProbeResult objects aren't meaningful, just
+    # return if we have one of those
+    if isinstance(target_volume, SimulatedProbeResult):
+        return target_volume
+
     volumetric_capacity = get_well_volumetric_capacity(well_geometry)
     max_volume = sum(row[1] for row in volumetric_capacity)
-    if target_volume < 0 or target_volume > max_volume:
-        raise InvalidLiquidHeightFound("Invalid target volume.")
 
+    if target_volume < 0:
+        target_volume = 0
+    elif target_volume > max_volume:
+        target_volume = max_volume
     sorted_well = sorted(well_geometry.sections, key=lambda section: section.topHeight)
     # find the section the target volume is in and compute the height
     return _find_height_in_partial_frustum(