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

opentrons/protocol_engine/labware_offset_standardization.py

@@ -0,0 +1,194 @@
+"""Convert labware offset creation requests and stored elements between legacy and new."""
+
+from opentrons_shared_data.robot.types import RobotType
+from opentrons_shared_data.deck.types import DeckDefinitionV5
+from .errors import (
+    OffsetLocationInvalidError,
+    FixtureDoesNotExistError,
+)
+from .types import (
+    LabwareOffsetCreate,
+    LegacyLabwareOffsetCreate,
+    LabwareOffsetCreateInternal,
+    LegacyLabwareOffsetLocation,
+    LabwareOffsetLocationSequence,
+    OnLabwareOffsetLocationSequenceComponent,
+    OnAddressableAreaOffsetLocationSequenceComponent,
+    OnModuleOffsetLocationSequenceComponent,
+    ModuleModel,
+)
+from .resources import deck_configuration_provider
+
+
+def standardize_labware_offset_create(
+    request: LabwareOffsetCreate | LegacyLabwareOffsetCreate,
+    robot_type: RobotType,
+    deck_definition: DeckDefinitionV5,
+) -> LabwareOffsetCreateInternal:
+    """Turn a union of old and new labware offset create requests into a new one."""
+    location_sequence, legacy_location = _locations_for_create(
+        request, robot_type, deck_definition
+    )
+    return LabwareOffsetCreateInternal(
+        definitionUri=request.definitionUri,
+        locationSequence=location_sequence,
+        legacyLocation=legacy_location,
+        vector=request.vector,
+    )
+
+
+def legacy_offset_location_to_offset_location_sequence(
+    location: LegacyLabwareOffsetLocation, deck_definition: DeckDefinitionV5
+) -> LabwareOffsetLocationSequence:
+    """Convert a legacy location to a new-style sequence."""
+    sequence: LabwareOffsetLocationSequence = []
+    if location.definitionUri:
+        sequence.append(
+            OnLabwareOffsetLocationSequenceComponent(labwareUri=location.definitionUri)
+        )
+    if location.moduleModel:
+        sequence.append(
+            OnModuleOffsetLocationSequenceComponent(moduleModel=location.moduleModel)
+        )
+        cutout_id = deck_configuration_provider.get_cutout_id_by_deck_slot_name(
+            location.slotName
+        )
+
+        # Given a module model, try to figure out the equivalent cutout fixture.
+        #
+        # The Thermocycler is special. A single Thermocycler is represented in a deck
+        # configuration as two separate cutout fixtures, because it spans two separate
+        # cutouts. This makes it the only module whose module model string does not map
+        # 1:1 with a cutout fixture ID string.
+        #
+        # TODO(mm, 2025-04-11): This is fragile, and the failure mode when it does the
+        # wrong thing can mean labware offsets don't apply, which is pretty bad. We
+        # either need a more explicit module<->cutout-fixture mapping, or we need to
+        # avoid this mapping entirely.
+        if (
+            # Check for v2 specifically because v1 is OT-2-only and OT-2s don't have
+            # modules in their deck definitions; and v3 does not exist at the time of writing.
+            location.moduleModel
+            == ModuleModel.THERMOCYCLER_MODULE_V2
+        ):
+            possible_cutout_fixture_id = "thermocyclerModuleV2Front"
+        else:
+            possible_cutout_fixture_id = location.moduleModel.value
+
+        try:
+            addressable_area = deck_configuration_provider.get_labware_hosting_addressable_area_name_for_cutout_and_cutout_fixture(
+                cutout_id, possible_cutout_fixture_id, deck_definition
+            )
+            sequence.append(
+                OnAddressableAreaOffsetLocationSequenceComponent(
+                    addressableAreaName=addressable_area
+                )
+            )
+        except FixtureDoesNotExistError:
+            # this is an OT-2 (or this module isn't supported in the deck definition) and we should use a
+            # slot addressable area name
+            sequence.append(
+                OnAddressableAreaOffsetLocationSequenceComponent(
+                    addressableAreaName=location.slotName.value
+                )
+            )
+
+    else:
+        # Slight hack: we should have a more formal association here. However, since the slot
+        # name is already standardized, and since the addressable areas for slots are just the
+        # name of the slots, we can rely on this.
+        sequence.append(
+            OnAddressableAreaOffsetLocationSequenceComponent(
+                addressableAreaName=location.slotName.value
+            )
+        )
+    return sequence
+
+
+def _offset_location_sequence_head_to_labware_and_module(
+    location_sequence: LabwareOffsetLocationSequence,
+) -> tuple[ModuleModel | None, str | None]:
+    labware_uri: str | None = None
+    module_model: ModuleModel | None = None
+    for location in location_sequence:
+        if isinstance(location, OnAddressableAreaOffsetLocationSequenceComponent):
+            raise OffsetLocationInvalidError(
+                "Addressable areas may only be the final element of an offset location."
+            )
+        elif isinstance(location, OnLabwareOffsetLocationSequenceComponent):
+            if labware_uri is not None:
+                # We only take the first location
+                continue
+            if module_model is not None:
+                # Labware can't be underneath modules
+                raise OffsetLocationInvalidError(
+                    "Labware must not be underneath a module."
+                )
+            labware_uri = location.labwareUri
+        elif isinstance(location, OnModuleOffsetLocationSequenceComponent):
+            if module_model is not None:
+                # Bad, somebody put more than one module in here
+                raise OffsetLocationInvalidError(
+                    "Only one module location may exist in an offset location."
+                )
+            module_model = location.moduleModel
+        else:
+            raise OffsetLocationInvalidError(
+                f"Invalid location component in offset location: {repr(location)}"
+            )
+    return module_model, labware_uri
+
+
+def _offset_location_sequence_to_legacy_offset_location(
+    location_sequence: LabwareOffsetLocationSequence, deck_definition: DeckDefinitionV5
+) -> LegacyLabwareOffsetLocation:
+    if len(location_sequence) == 0:
+        raise OffsetLocationInvalidError(
+            "Offset locations must contain at least one component."
+        )
+    last_element = location_sequence[-1]
+    if not isinstance(last_element, OnAddressableAreaOffsetLocationSequenceComponent):
+        raise OffsetLocationInvalidError(
+            "Offset locations must end with an addressable area."
+        )
+    module_model, labware_uri = _offset_location_sequence_head_to_labware_and_module(
+        location_sequence[:-1]
+    )
+    (
+        cutout_id,
+        _cutout_fixtures,
+    ) = deck_configuration_provider.get_potential_cutout_fixtures(
+        last_element.addressableAreaName, deck_definition
+    )
+    slot_name = deck_configuration_provider.get_deck_slot_for_cutout_id(cutout_id)
+    return LegacyLabwareOffsetLocation(
+        slotName=slot_name, moduleModel=module_model, definitionUri=labware_uri
+    )
+
+
+def _locations_for_create(
+    request: LabwareOffsetCreate | LegacyLabwareOffsetCreate,
+    robot_type: RobotType,
+    deck_definition: DeckDefinitionV5,
+) -> tuple[LabwareOffsetLocationSequence, LegacyLabwareOffsetLocation]:
+    if isinstance(request, LabwareOffsetCreate):
+        return (
+            request.locationSequence,
+            _offset_location_sequence_to_legacy_offset_location(
+                request.locationSequence, deck_definition
+            ),
+        )
+    else:
+        normalized = request.location.model_copy(
+            update={
+                "slotName": request.location.slotName.to_equivalent_for_robot_type(
+                    robot_type
+                )
+            }
+        )
+        return (
+            legacy_offset_location_to_offset_location_sequence(
+                normalized, deck_definition
+            ),
+            normalized,
+        )

opentrons/protocol_engine/protocol_engine.py

@@ -1,29 +1,32 @@
 """ProtocolEngine class definition."""
+
 from contextlib import AsyncExitStack
 from logging import getLogger
 from typing import Dict, Optional, Union, AsyncGenerator, Callable
-from opentrons.protocol_engine.actions.actions import (
-    ResumeFromRecoveryAction,
-    SetErrorRecoveryPolicyAction,
-)
 
-from opentrons.protocols.models import LabwareDefinition
-from opentrons.hardware_control import HardwareControlAPI
-from opentrons.hardware_control.modules import AbstractModule as HardwareModuleAPI
-from opentrons.hardware_control.types import PauseType as HardwarePauseType
 from opentrons_shared_data.errors import (
     ErrorCodes,
     EnumeratedError,
 )
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.modules import AbstractModule as HardwareModuleAPI
+from opentrons.hardware_control.types import PauseType as HardwarePauseType
+
+from .actions.actions import (
+    ResumeFromRecoveryAction,
+    SetErrorRecoveryPolicyAction,
+)
 from .errors import ProtocolCommandFailedError, ErrorOccurrence, CommandNotAllowedError
 from .errors.exceptions import EStopActivatedError
 from .error_recovery_policy import ErrorRecoveryPolicy
-from . import commands, slot_standardization
+from . import commands, slot_standardization, labware_offset_standardization
 from .resources import ModelUtils, ModuleDataProvider, FileProvider
 from .types import (
     LabwareOffset,
     LabwareOffsetCreate,
+    LegacyLabwareOffsetCreate,
     LabwareUri,
     ModuleModel,
     Liquid,
@@ -516,15 +519,21 @@ class ProtocolEngine:
             )
         )
 
-    def add_labware_offset(self, request: LabwareOffsetCreate) -> LabwareOffset:
+    def add_labware_offset(
+        self, request: LabwareOffsetCreate | LegacyLabwareOffsetCreate
+    ) -> LabwareOffset:
         """Add a new labware offset and return it.
 
         The added offset will apply to subsequent `LoadLabwareCommand`s.
 
         To retrieve offsets later, see `.state_view.labware`.
         """
-        request = slot_standardization.standardize_labware_offset(
-            request, self.state_view.config.robot_type
+        internal_request = (
+            labware_offset_standardization.standardize_labware_offset_create(
+                request,
+                self.state_view.config.robot_type,
+                self.state_view.addressable_areas.deck_definition,
+            )
         )
 
         labware_offset_id = self._model_utils.generate_id()
@@ -533,7 +542,7 @@ class ProtocolEngine:
             AddLabwareOffsetAction(
                 labware_offset_id=labware_offset_id,
                 created_at=created_at,
-                request=request,
+                request=internal_request,
             )
         )
         return self.state_view.labware.get_labware_offset(

opentrons/protocol_engine/resources/deck_configuration_provider.py

@@ -1,7 +1,11 @@
 """Deck configuration resource provider."""
+
 from typing import List, Set, Tuple
 
-from opentrons_shared_data.deck.types import DeckDefinitionV5, CutoutFixture
+from opentrons_shared_data.deck.types import (
+    DeckDefinitionV5,
+    CutoutFixture,
+)
 
 from opentrons.types import DeckSlotName
 
@@ -17,6 +21,7 @@ from ..errors import (
     CutoutDoesNotExistError,
     FixtureDoesNotExistError,
     AddressableAreaDoesNotExistError,
+    SlotDoesNotExistError,
 )
 
 
@@ -98,12 +103,15 @@ def get_potential_cutout_fixtures(
 def get_addressable_area_from_name(
     addressable_area_name: str,
     cutout_position: DeckPoint,
-    base_slot: DeckSlotName,
     deck_definition: DeckDefinitionV5,
 ) -> AddressableArea:
     """Given a name and a cutout position, get an addressable area on the deck."""
     for addressable_area in deck_definition["locations"]["addressableAreas"]:
         if addressable_area["id"] == addressable_area_name:
+            cutout_id, _ = get_potential_cutout_fixtures(
+                addressable_area_name, deck_definition
+            )
+            base_slot = get_deck_slot_for_cutout_id(cutout_id)
             area_offset = addressable_area["offsetFromCutoutFixture"]
             position = AddressableOffsetVector(
                 x=area_offset[0] + cutout_position.x,
@@ -130,3 +138,91 @@ def get_addressable_area_from_name(
     raise AddressableAreaDoesNotExistError(
         f"Could not find addressable area with name {addressable_area_name}"
     )
+
+
+def get_deck_slot_for_cutout_id(cutout_id: str) -> DeckSlotName:
+    """Get the corresponding deck slot for an addressable area."""
+    try:
+        return CUTOUT_TO_DECK_SLOT_MAP[cutout_id]
+    except KeyError as e:
+        raise CutoutDoesNotExistError(
+            f"Could not find data for cutout {cutout_id}"
+        ) from e
+
+
+def get_cutout_id_by_deck_slot_name(slot_name: DeckSlotName) -> str:
+    """Get the Cutout ID of a given Deck Slot by Deck Slot Name."""
+    try:
+        return DECK_SLOT_TO_CUTOUT_MAP[slot_name]
+    except KeyError as e:
+        raise SlotDoesNotExistError(
+            f"Could not find data for slot {slot_name.value}"
+        ) from e
+
+
+def get_labware_hosting_addressable_area_name_for_cutout_and_cutout_fixture(
+    cutout_id: str, cutout_fixture_id: str, deck_definition: DeckDefinitionV5
+) -> str:
+    """Get the first addressable area that can contain labware for a cutout and fixture.
+
+    This probably isn't relevant outside of labware offset locations, where (for now) nothing
+    provides more than one labware-containing addressable area.
+    """
+    for cutoutFixture in deck_definition["cutoutFixtures"]:
+        if cutoutFixture["id"] != cutout_fixture_id:
+            continue
+        provided_aas = cutoutFixture["providesAddressableAreas"].get(cutout_id, None)
+        if provided_aas is None:
+            raise CutoutDoesNotExistError(
+                f"{cutout_fixture_id} does not go in {cutout_id}"
+            )
+        for aa_id in provided_aas:
+            for addressable_area in deck_definition["locations"]["addressableAreas"]:
+                if addressable_area["id"] != aa_id:
+                    continue
+                # TODO: In deck def v6 this will be easier, but as of right now there isn't really
+                # a way to tell from an addressable area whether it takes labware so let's take the
+                # first one
+                return aa_id
+            raise AddressableAreaDoesNotExistError(
+                f"Could not find an addressable area that allows labware from cutout fixture {cutout_fixture_id} in cutout {cutout_id}"
+            )
+
+    raise FixtureDoesNotExistError(f"Could not find entry for {cutout_fixture_id}")
+
+
+# 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()
+}

opentrons/protocol_engine/resources/deck_data_provider.py

@@ -10,7 +10,7 @@ from opentrons_shared_data.deck import (
     DEFAULT_DECK_DEFINITION_VERSION,
 )
 from opentrons_shared_data.deck.types import DeckDefinitionV5
-from opentrons.protocols.models import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons.types import DeckSlotName
 
 from ..types import (

opentrons/protocol_engine/resources/labware_data_provider.py

@@ -6,7 +6,12 @@ abstract away rough edges until we can improve those underlying interfaces.
 import logging
 from anyio import to_thread
 
-from opentrons.protocols.models import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import (
+    LabwareDefinition,
+    LabwareDefinition3,
+    labware_definition_type_adapter,
+)
+
 from opentrons.protocols.labware import get_labware_definition
 
 # TODO (lc 09-26-2022) We should conditionally import ot2 or ot3 calibration
@@ -44,7 +49,7 @@ class LabwareDataProvider:
     def _get_labware_definition_sync(
         load_name: str, namespace: str, version: int
     ) -> LabwareDefinition:
-        return LabwareDefinition.model_validate(
+        return labware_definition_type_adapter.validate_python(
             get_labware_definition(load_name, namespace, version)
         )
 
@@ -72,15 +77,30 @@ class LabwareDataProvider:
         labware_definition: LabwareDefinition,
         nominal_fallback: float,
     ) -> float:
-        try:
-            return instr_cal.load_tip_length_for_pipette(
-                pipette_serial, labware_definition
-            ).tip_length
-
-        except TipLengthCalNotFound as e:
-            message = (
-                f"No calibrated tip length found for {pipette_serial},"
-                f" using nominal fallback value of {nominal_fallback}"
+        if isinstance(labware_definition, LabwareDefinition3):
+            # FIXME(mm, 2025-02-19): This needs to be resolved for v8.4.0.
+            # Tip length calibration internals don't yet support schema 3 because
+            # it's probably an incompatible change at the filesystem level
+            # (not downgrade-safe), and because robot-server's calibration sessions
+            # are built atop opentrons.protocol_api.core.legacy, which does not (yet?)
+            # support labware schema 3.
+            # https://opentrons.atlassian.net/browse/EXEC-1230
+            log.warning(
+                f"Tip rack"
+                f" {labware_definition.namespace}/{labware_definition.parameters.loadName}/{labware_definition.version}"
+                f" has schema 3, so tip length calibration is currently unsupported."
+                f" Using nominal fallback of {nominal_fallback}."
             )
-            log.debug(message, exc_info=e)
             return nominal_fallback
+        else:
+            try:
+                return instr_cal.load_tip_length_for_pipette(
+                    pipette_serial, labware_definition
+                ).tip_length
+            except TipLengthCalNotFound as e:
+                message = (
+                    f"No calibrated tip length found for {pipette_serial},"
+                    f" using nominal fallback value of {nominal_fallback}"
+                )
+                log.debug(message, exc_info=e)
+                return nominal_fallback

opentrons/protocol_engine/resources/labware_validation.py

@@ -1,7 +1,9 @@
 """Validation file for labware role and location checking functions."""
 
-from opentrons_shared_data.labware.labware_definition import LabwareRole
-from opentrons.protocols.models import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import (
+    LabwareDefinition,
+    LabwareRole,
+)
 
 
 def is_flex_trash(load_name: str) -> bool:
@@ -14,9 +16,9 @@ def is_absorbance_reader_lid(load_name: str) -> bool:
     return load_name == "opentrons_flex_lid_absorbance_plate_reader_module"
 
 
-def is_evotips(load_name: str) -> bool:
-    """Check if a labware is an evotips tiprack."""
-    return load_name == "evotips_opentrons_96_labware"
+def is_lid_stack(load_name: str) -> bool:
+    """Check if a labware object is a system lid stack object."""
+    return load_name == "protocol_engine_lid_stack_object"
 
 
 def validate_definition_is_labware(definition: LabwareDefinition) -> bool:

opentrons/protocol_engine/slot_standardization.py

@@ -14,7 +14,6 @@ This module does that conversion, for any Protocol Engine input that contains a
 deck slot.
 """
 
-
 from typing import Any, Callable, Dict, Type
 
 from opentrons_shared_data.robot.types import RobotType
@@ -22,32 +21,15 @@ from opentrons_shared_data.robot.types import RobotType
 from . import commands
 from .types import (
     OFF_DECK_LOCATION,
+    SYSTEM_LOCATION,
     DeckSlotLocation,
-    LabwareLocation,
+    LoadableLabwareLocation,
     AddressableAreaLocation,
-    LabwareOffsetCreate,
     ModuleLocation,
     OnLabwareLocation,
 )
 
 
-def standardize_labware_offset(
-    original: LabwareOffsetCreate, robot_type: RobotType
-) -> LabwareOffsetCreate:
-    """Convert the deck slot in the given `LabwareOffsetCreate` to match the given robot type."""
-    return original.model_copy(
-        update={
-            "location": original.location.model_copy(
-                update={
-                    "slotName": original.location.slotName.to_equivalent_for_robot_type(
-                        robot_type
-                    )
-                }
-            )
-        }
-    )
-
-
 def standardize_command(
     original: commands.CommandCreate, robot_type: RobotType
 ) -> commands.CommandCreate:
@@ -119,15 +101,21 @@ _standardize_command_functions: Dict[
 
 
 def _standardize_labware_location(
-    original: LabwareLocation, robot_type: RobotType
-) -> LabwareLocation:
+    original: LoadableLabwareLocation, robot_type: RobotType
+) -> LoadableLabwareLocation:
     if isinstance(original, DeckSlotLocation):
         return _standardize_deck_slot_location(original, robot_type)
     elif (
         isinstance(
-            original, (ModuleLocation, OnLabwareLocation, AddressableAreaLocation)
+            original,
+            (
+                ModuleLocation,
+                OnLabwareLocation,
+                AddressableAreaLocation,
+            ),
         )
         or original == OFF_DECK_LOCATION
+        or original == SYSTEM_LOCATION
     ):
         return original