opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/resources/__init__.py

@@ -0,0 +1,26 @@
+"""Interfaces to provide data and other external system resources.
+
+Classes in this module do not maintain state and can be instantiated
+as needed. Some classes may contain solely static methods.
+"""
+from . import pipette_data_provider
+from . import labware_validation
+from .model_utils import ModelUtils
+from .deck_data_provider import DeckDataProvider, DeckFixedLabware
+from .labware_data_provider import LabwareDataProvider
+from .module_data_provider import ModuleDataProvider
+from .file_provider import FileProvider
+from .ot3_validation import ensure_ot3_hardware
+
+
+__all__ = [
+    "ModelUtils",
+    "LabwareDataProvider",
+    "DeckDataProvider",
+    "DeckFixedLabware",
+    "ModuleDataProvider",
+    "FileProvider",
+    "ensure_ot3_hardware",
+    "pipette_data_provider",
+    "labware_validation",
+]

opentrons/protocol_engine/resources/deck_configuration_provider.py

@@ -0,0 +1,232 @@
+"""Deck configuration resource provider."""
+
+from typing import List, Set, Tuple
+
+from opentrons_shared_data.deck.types import (
+    DeckDefinitionV5,
+    CutoutFixture,
+)
+
+from opentrons.types import DeckSlotName
+
+from ..types import (
+    AddressableArea,
+    AreaType,
+    PotentialCutoutFixture,
+    DeckPoint,
+    Dimensions,
+    AddressableOffsetVector,
+)
+from ..errors import (
+    CutoutDoesNotExistError,
+    FixtureDoesNotExistError,
+    AddressableAreaDoesNotExistError,
+    SlotDoesNotExistError,
+)
+
+
+def get_cutout_position(cutout_id: str, deck_definition: DeckDefinitionV5) -> DeckPoint:
+    """Get the base position of a cutout on the deck."""
+    for cutout in deck_definition["locations"]["cutouts"]:
+        if cutout_id == cutout["id"]:
+            position = cutout["position"]
+            return DeckPoint(x=position[0], y=position[1], z=position[2])
+    else:
+        raise CutoutDoesNotExistError(f"Could not find cutout with name {cutout_id}")
+
+
+def get_cutout_fixture(
+    cutout_fixture_id: str, deck_definition: DeckDefinitionV5
+) -> CutoutFixture:
+    """Gets cutout fixture from deck that matches the cutout fixture ID provided."""
+    for cutout_fixture in deck_definition["cutoutFixtures"]:
+        if cutout_fixture["id"] == cutout_fixture_id:
+            return cutout_fixture
+    raise FixtureDoesNotExistError(
+        f"Could not find cutout fixture with name {cutout_fixture_id}"
+    )
+
+
+def get_provided_addressable_area_names(
+    cutout_fixture_id: str, cutout_id: str, deck_definition: DeckDefinitionV5
+) -> List[str]:
+    """Gets a list of the addressable areas provided by the cutout fixture on the cutout."""
+    cutout_fixture = get_cutout_fixture(cutout_fixture_id, deck_definition)
+    try:
+        return cutout_fixture["providesAddressableAreas"][cutout_id]
+    except KeyError:
+        return []
+
+
+def get_addressable_area_display_name(
+    addressable_area_name: str, deck_definition: DeckDefinitionV5
+) -> str:
+    """Get the display name for an addressable area name."""
+    for addressable_area in deck_definition["locations"]["addressableAreas"]:
+        if addressable_area["id"] == addressable_area_name:
+            return addressable_area["displayName"]
+    raise AddressableAreaDoesNotExistError(
+        f"Could not find addressable area with name {addressable_area_name}"
+    )
+
+
+def get_potential_cutout_fixtures(
+    addressable_area_name: str, deck_definition: DeckDefinitionV5
+) -> Tuple[str, Set[PotentialCutoutFixture]]:
+    """Given an addressable area name, gets the cutout ID associated with it and a set of potential fixtures."""
+    potential_fixtures = []
+    for cutout_fixture in deck_definition["cutoutFixtures"]:
+        for cutout_id, provided_areas in cutout_fixture[
+            "providesAddressableAreas"
+        ].items():
+            if addressable_area_name in provided_areas:
+                potential_fixtures.append(
+                    PotentialCutoutFixture(
+                        cutout_id=cutout_id,
+                        cutout_fixture_id=cutout_fixture["id"],
+                        provided_addressable_areas=frozenset(provided_areas),
+                    )
+                )
+    # This following logic is making the assumption that every addressable area can only go on one cutout, though
+    # it may have multiple cutout fixtures that supply it on that cutout. If this assumption changes, some of the
+    # following logic will have to be readjusted
+    if not potential_fixtures:
+        raise AddressableAreaDoesNotExistError(
+            f"{addressable_area_name} is not provided by any cutout fixtures"
+            f" in deck definition {deck_definition['otId']}"
+        )
+    cutout_id = potential_fixtures[0].cutout_id
+    assert all(cutout_id == fixture.cutout_id for fixture in potential_fixtures)
+    return cutout_id, set(potential_fixtures)
+
+
+def get_addressable_area_from_name(
+    addressable_area_name: str,
+    cutout_position: DeckPoint,
+    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,
+                y=area_offset[1] + cutout_position.y,
+                z=area_offset[2] + cutout_position.z,
+            )
+            bounding_box = Dimensions(
+                x=addressable_area["boundingBox"]["xDimension"],
+                y=addressable_area["boundingBox"]["yDimension"],
+                z=addressable_area["boundingBox"]["zDimension"],
+            )
+            features = addressable_area["features"]
+            mating_surface_unit_vector = addressable_area.get("matingSurfaceUnitVector")
+
+            return AddressableArea(
+                area_name=addressable_area["id"],
+                area_type=AreaType(addressable_area["areaType"]),
+                mating_surface_unit_vector=mating_surface_unit_vector,
+                base_slot=base_slot,
+                display_name=addressable_area["displayName"],
+                bounding_box=bounding_box,
+                position=position,
+                compatible_module_types=addressable_area.get(
+                    "compatibleModuleTypes", []
+                ),
+                features=features,
+            )
+    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

@@ -0,0 +1,94 @@
+"""Deck data resource provider."""
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from typing_extensions import final
+
+import anyio
+
+from opentrons_shared_data.deck import (
+    load as load_deck,
+    DEFAULT_DECK_DEFINITION_VERSION,
+)
+from opentrons_shared_data.deck.types import DeckDefinitionV5
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from opentrons.types import DeckSlotName
+
+from ..types import (
+    DeckSlotLocation,
+    DeckType,
+    LabwareLocation,
+    DeckConfigurationType,
+)
+from .labware_data_provider import LabwareDataProvider
+
+
+@final
+@dataclass(frozen=True)
+class DeckFixedLabware:
+    """A labware fixture that is always present on a deck."""
+
+    labware_id: str
+    location: LabwareLocation
+    definition: LabwareDefinition
+
+
+class DeckDataProvider:
+    """Provider class to wrap deck definition and data retrieval."""
+
+    _labware_data: LabwareDataProvider
+
+    def __init__(
+        self, deck_type: DeckType, labware_data: Optional[LabwareDataProvider] = None
+    ) -> None:
+        """Initialize a DeckDataProvider."""
+        self._deck_type = deck_type
+        self._labware_data = labware_data or LabwareDataProvider()
+
+    async def get_deck_definition(self) -> DeckDefinitionV5:
+        """Get a labware definition given the labware's identification."""
+
+        def sync() -> DeckDefinitionV5:
+            return load_deck(
+                name=self._deck_type.value, version=DEFAULT_DECK_DEFINITION_VERSION
+            )
+
+        return await anyio.to_thread.run_sync(sync)
+
+    async def get_deck_fixed_labware(
+        self,
+        load_fixed_trash: bool,
+        deck_definition: DeckDefinitionV5,
+        deck_configuration: Optional[DeckConfigurationType] = None,
+    ) -> List[DeckFixedLabware]:
+        """Get a list of all labware fixtures from a given deck definition."""
+        labware: List[DeckFixedLabware] = []
+
+        for fixture in deck_definition["locations"]["legacyFixtures"]:
+            labware_id = fixture["id"]
+            load_name = cast(Optional[str], fixture.get("labware"))
+            slot = cast(Optional[str], fixture.get("slot"))
+
+            if (
+                load_fixed_trash
+                and load_name is not None
+                and slot is not None
+                and slot in DeckSlotName._value2member_map_
+            ):
+                deck_slot_location = DeckSlotLocation(
+                    slotName=DeckSlotName.from_primitive(slot)
+                )
+                definition = await self._labware_data.get_labware_definition(
+                    load_name=load_name,
+                    namespace="opentrons",
+                    version=1,
+                )
+
+                labware.append(
+                    DeckFixedLabware(
+                        labware_id=labware_id,
+                        definition=definition,
+                        location=deck_slot_location,
+                    )
+                )
+
+        return labware

opentrons/protocol_engine/resources/file_provider.py

@@ -0,0 +1,161 @@
+"""File interaction resource provider."""
+from datetime import datetime
+from typing import List, Optional, Callable, Awaitable, Dict
+from pydantic import BaseModel
+from ..errors import StorageLimitReachedError
+
+
+MAXIMUM_CSV_FILE_LIMIT = 400
+
+
+class GenericCsvTransform:
+    """Generic CSV File Type data for rows of data to be seperated by a delimeter."""
+
+    filename: str
+    rows: List[List[str]]
+    delimiter: str = ","
+
+    @staticmethod
+    def build(
+        filename: str, rows: List[List[str]], delimiter: str = ","
+    ) -> "GenericCsvTransform":
+        """Build a Generic CSV datatype class."""
+        if "." in filename and not filename.endswith(".csv"):
+            raise ValueError(
+                f"Provided filename {filename} invalid. Only CSV file format is accepted."
+            )
+        elif "." not in filename:
+            filename = f"{filename}.csv"
+        csv = GenericCsvTransform()
+        csv.filename = filename
+        csv.rows = rows
+        csv.delimiter = delimiter
+        return csv
+
+
+class ReadData(BaseModel):
+    """Read Data type containing the wavelength for a Plate Reader read alongside the Measurement Data of that read."""
+
+    wavelength: int
+    data: Dict[str, float]
+
+
+class PlateReaderData(BaseModel):
+    """Data from a Opentrons Plate Reader Read. Can be converted to CSV template format."""
+
+    read_results: List[ReadData]
+    reference_wavelength: Optional[int] = None
+    start_time: datetime
+    finish_time: datetime
+    serial_number: str
+
+    def build_generic_csv(  # noqa: C901
+        self, filename: str, measurement: ReadData
+    ) -> GenericCsvTransform:
+        """Builds a CSV compatible object containing Plate Reader Measurements.
+
+        This will also automatically reformat the provided filename to include the wavelength of those measurements.
+        """
+        plate_alpharows = ["A", "B", "C", "D", "E", "F", "G", "H"]
+        rows = []
+
+        rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
+        for i in range(8):
+            row = [plate_alpharows[i]]
+            for j in range(12):
+                row.append(str(measurement.data[f"{plate_alpharows[i]}{j+1}"]))
+            rows.append(row)
+        for i in range(3):
+            rows.append([])
+        rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
+        for i in range(8):
+            row = [plate_alpharows[i]]
+            for j in range(12):
+                row.append("")
+            rows.append(row)
+        for i in range(3):
+            rows.append([])
+        rows.append(
+            [
+                "",
+                "ID",
+                "Well",
+                "Absorbance (OD)",
+                "Mean Absorbance (OD)",
+                "Absorbance %CV",
+            ]
+        )
+        for i in range(3):
+            rows.append([])
+        rows.append(
+            [
+                "",
+                "ID",
+                "Well",
+                "Absorbance (OD)",
+                "Mean Absorbance (OD)",
+                "Dilution Factor",
+                "Absorbance %CV",
+            ]
+        )
+        rows.append(["1", "Sample 1", "", "", "", "1", "", "", "", "", "", ""])
+        for i in range(3):
+            rows.append([])
+
+        # end of file metadata
+        rows.append(["Protocol"])
+        rows.append(["Assay"])
+        rows.append(["Sample Wavelength (nm)", str(measurement.wavelength)])
+        if self.reference_wavelength is not None:
+            rows.append(["Reference Wavelength (nm)", str(self.reference_wavelength)])
+        rows.append(["Serial No.", self.serial_number])
+        rows.append(
+            ["Measurement started at", self.start_time.strftime("%m %d %H:%M:%S %Y")]
+        )
+        rows.append(
+            ["Measurement finished at", self.finish_time.strftime("%m %d %H:%M:%S %Y")]
+        )
+
+        # Ensure the filename adheres to ruleset contains the wavelength for a given measurement
+        if filename.endswith(".csv"):
+            filename = filename[:-4]
+        filename = filename + str(measurement.wavelength) + "nm.csv"
+
+        return GenericCsvTransform.build(
+            filename=filename,
+            rows=rows,
+            delimiter=",",
+        )
+
+
+class FileProvider:
+    """Provider class to wrap file read write interactions to the data files directory in the engine."""
+
+    def __init__(
+        self,
+        data_files_write_csv_callback: Optional[
+            Callable[[GenericCsvTransform], Awaitable[str]]
+        ] = None,
+        data_files_filecount: Optional[Callable[[], Awaitable[int]]] = None,
+    ) -> None:
+        """Initialize the interface callbacks of the File Provider for data file handling within the Protocol Engine.
+
+        Params:
+            data_files_write_csv_callback: Callback to write a CSV file to the data files directory and add it to the database.
+            data_files_filecount: Callback to check the amount of data files already present in the data files directory.
+        """
+        self._data_files_write_csv_callback = data_files_write_csv_callback
+        self._data_files_filecount = data_files_filecount
+
+    async def write_csv(self, write_data: GenericCsvTransform) -> str:
+        """Writes the provided CSV object to a file in the Data Files directory. Returns the File ID of the file created."""
+        if self._data_files_filecount is not None:
+            file_count = await self._data_files_filecount()
+            if file_count >= MAXIMUM_CSV_FILE_LIMIT:
+                raise StorageLimitReachedError(
+                    f"Not enough space to store file {write_data.filename}."
+                )
+            if self._data_files_write_csv_callback is not None:
+                return await self._data_files_write_csv_callback(write_data)
+        # If we are in an analysis or simulation state, return an empty file ID
+        return ""

opentrons/protocol_engine/resources/fixture_validation.py

@@ -0,0 +1,58 @@
+"""Validation file for addressable area reference checking functions."""
+
+from opentrons.types import DeckSlotName
+
+
+def is_waste_chute(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a Waste Chute."""
+    return addressable_area_name in {
+        "1ChannelWasteChute",
+        "8ChannelWasteChute",
+        "96ChannelWasteChute",
+        "gripperWasteChute",
+    }
+
+
+def is_gripper_waste_chute(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a gripper-movement-compatible Waste Chute."""
+    return addressable_area_name == "gripperWasteChute"
+
+
+def is_drop_tip_waste_chute(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a Waste Chute compatible for dropping tips."""
+    return addressable_area_name in {
+        "1ChannelWasteChute",
+        "8ChannelWasteChute",
+        "96ChannelWasteChute",
+    }
+
+
+def is_trash(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a trash bin."""
+    return any(
+        [
+            s in addressable_area_name
+            for s in {"movableTrash", "fixedTrash", "shortFixedTrash"}
+        ]
+    )
+
+
+def is_staging_slot(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a staging area slot."""
+    return addressable_area_name in {"A4", "B4", "C4", "D4"}
+
+
+def is_deck_slot(addressable_area_name: str) -> bool:
+    """Check if an addressable area is a deck slot (including staging area slots)."""
+    if is_staging_slot(addressable_area_name):
+        return True
+    try:
+        DeckSlotName.from_primitive(addressable_area_name)
+    except ValueError:
+        return False
+    return True
+
+
+def is_abs_reader(addressable_area_name: str) -> bool:
+    """Check if an addressable area is an absorbance plate reader area."""
+    return "absorbanceReaderV1" in addressable_area_name

opentrons/protocol_engine/resources/labware_data_provider.py

@@ -0,0 +1,106 @@
+"""Labware data resource provider.
+
+This module is a wrapper around existing, but older, internal APIs to
+abstract away rough edges until we can improve those underlying interfaces.
+"""
+import logging
+from anyio import to_thread
+
+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
+from opentrons.hardware_control.instruments.ot2 import (
+    instrument_calibration as instr_cal,
+)
+from opentrons.calibration_storage.types import TipLengthCalNotFound
+
+
+log = logging.getLogger(__name__)
+
+
+class LabwareDataProvider:
+    """Labware data provider."""
+
+    @staticmethod
+    async def get_labware_definition(
+        load_name: str,
+        namespace: str,
+        version: int,
+    ) -> LabwareDefinition:
+        """Get a labware definition given the labware's identification.
+
+        Note: this method hits the filesystem, which will have performance
+        implications if it is called often.
+        """
+        return await to_thread.run_sync(
+            LabwareDataProvider._get_labware_definition_sync,
+            load_name,
+            namespace,
+            version,
+        )
+
+    @staticmethod
+    def _get_labware_definition_sync(
+        load_name: str, namespace: str, version: int
+    ) -> LabwareDefinition:
+        return labware_definition_type_adapter.validate_python(
+            get_labware_definition(load_name, namespace, version)
+        )
+
+    @staticmethod
+    async def get_calibrated_tip_length(
+        pipette_serial: str,
+        labware_definition: LabwareDefinition,
+        nominal_fallback: float,
+    ) -> float:
+        """Get the calibrated tip length of a tip rack / pipette pair.
+
+        Note: this method hits the filesystem, which will have performance
+        implications if it is called often.
+        """
+        return await to_thread.run_sync(
+            LabwareDataProvider._get_calibrated_tip_length_sync,
+            pipette_serial,
+            labware_definition,
+            nominal_fallback,
+        )
+
+    @staticmethod
+    def _get_calibrated_tip_length_sync(
+        pipette_serial: str,
+        labware_definition: LabwareDefinition,
+        nominal_fallback: float,
+    ) -> float:
+        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}."
+            )
+            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