opentrons 8.6.0a11__py3-none-any.whl → 8.7.0__py3-none-any.whl

opentrons/protocol_api/core/engine/instrument.py

@@ -66,7 +66,6 @@ from opentrons.protocol_engine.types.automatic_tip_selection import (
 )
 from opentrons.protocol_engine.errors.exceptions import TipNotAttachedError
 from opentrons.protocol_engine.clients import SyncClient as EngineClient
-from opentrons.protocols.api_support.definitions import MAX_SUPPORTED_VERSION
 from opentrons_shared_data.pipette.types import (
     PIPETTE_API_NAMES_MAP,
     LIQUID_PROBE_START_OFFSET_FROM_WELL_TOP,
@@ -101,6 +100,9 @@ _RESIN_TIP_DEFAULT_FLOW_RATE = 10.0
 _FLEX_PIPETTE_NAMES_FIXED_IN = APIVersion(2, 23)
 """The version after which InstrumentContext.name returns the correct API-specific names of Flex pipettes."""
 
+_DEFAULT_FLOW_RATE_BUG_FIXED_IN = APIVersion(2, 26)
+"""The version after which default flow rates correctly update when pipette tip or volume changes."""
+
 
 class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
     """Instrument API core using a ProtocolEngine.
@@ -122,18 +124,27 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         self._sync_hardware_api = sync_hardware_api
         self._protocol_core = protocol_core
 
-        # TODO(jbl 2022-11-03) flow_rates should not live in the cores, and should be moved to the protocol context
-        #   along with other rate related refactors (for the hardware API)
-        flow_rates = self._engine_client.state.pipettes.get_flow_rates(pipette_id)
-        self._aspirate_flow_rate = find_value_for_api_version(
-            MAX_SUPPORTED_VERSION, flow_rates.default_aspirate
-        )
-        self._dispense_flow_rate = find_value_for_api_version(
-            MAX_SUPPORTED_VERSION, flow_rates.default_dispense
-        )
-        self._blow_out_flow_rate = find_value_for_api_version(
-            MAX_SUPPORTED_VERSION, flow_rates.default_blow_out
+        self._initial_default_flow_rates = (
+            self._engine_client.state.pipettes.get_flow_rates(pipette_id)
         )
+        self._user_aspirate_flow_rate: Optional[float] = None
+        self._user_dispense_flow_rate: Optional[float] = None
+        self._user_blow_out_flow_rate: Optional[float] = None
+
+        if self._protocol_core.api_version < _DEFAULT_FLOW_RATE_BUG_FIXED_IN:
+            # Set to the initial defaults to preserve buggy behavior where the default was not correctly updated
+            self._user_aspirate_flow_rate = find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._initial_default_flow_rates.default_aspirate,
+            )
+            self._user_dispense_flow_rate = find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._initial_default_flow_rates.default_dispense,
+            )
+            self._user_blow_out_flow_rate = find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._initial_default_flow_rates.default_blow_out,
+            )
         self._flow_rates = FlowRates(self)
 
         self.set_default_speed(speed=default_movement_speed)
@@ -1031,13 +1042,64 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         return self._flow_rates
 
     def get_aspirate_flow_rate(self, rate: float = 1.0) -> float:
-        return self._aspirate_flow_rate * rate
+        """Returns the user-set aspirate flow rate if that's been modified, otherwise return the default.
+
+        Note that in API versions 2.25 and below `_user_aspirate_flow_rate` will automatically be set to the initial
+        default flow rate when the pipette is loaded (which is the same as the max tip capacity). This is to preserve
+        buggy behavior in which the default was never correctly updated when the pipette picked up or dropped a tip or
+        had its volume configuration changed.
+        """
+        aspirate_flow_rate = (
+            self._user_aspirate_flow_rate
+            or find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._engine_client.state.pipettes.get_flow_rates(
+                    self._pipette_id
+                ).default_aspirate,
+            )
+        )
+
+        return aspirate_flow_rate * rate
 
     def get_dispense_flow_rate(self, rate: float = 1.0) -> float:
-        return self._dispense_flow_rate * rate
+        """Returns the user-set dispense flow rate if that's been modified, otherwise return the default.
+
+        Note that in API versions 2.25 and below `_user_dispense_flow_rate` will automatically be set to the initial
+        default flow rate when the pipette is loaded (which is the same as the max tip capacity). This is to preserve
+        buggy behavior in which the default was never correctly updated when the pipette picked up or dropped a tip or
+        had its volume configuration changed.
+        """
+        dispense_flow_rate = (
+            self._user_dispense_flow_rate
+            or find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._engine_client.state.pipettes.get_flow_rates(
+                    self._pipette_id
+                ).default_dispense,
+            )
+        )
+
+        return dispense_flow_rate * rate
 
     def get_blow_out_flow_rate(self, rate: float = 1.0) -> float:
-        return self._blow_out_flow_rate * rate
+        """Returns the user-set blow-out flow rate if that's been modified, otherwise return the default.
+
+        Note that in API versions 2.25 and below `_user_dispense_flow_rate` will automatically be set to the initial
+        default flow rate when the pipette is loaded (which is the same as the max tip capacity). This is to preserve
+        buggy behavior in which the default was never correctly updated when the pipette picked up or dropped a tip or
+        had its volume configuration changed.
+        """
+        blow_out_flow_rate = (
+            self._user_blow_out_flow_rate
+            or find_value_for_api_version(
+                self._protocol_core.api_version,
+                self._engine_client.state.pipettes.get_flow_rates(
+                    self._pipette_id
+                ).default_blow_out,
+            )
+        )
+
+        return blow_out_flow_rate * rate
 
     def get_nozzle_configuration(self) -> NozzleConfigurationType:
         return self._engine_client.state.pipettes.get_nozzle_layout_type(
@@ -1084,13 +1146,13 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
     ) -> None:
         if aspirate is not None:
             assert aspirate > 0
-            self._aspirate_flow_rate = aspirate
+            self._user_aspirate_flow_rate = aspirate
         if dispense is not None:
             assert dispense > 0
-            self._dispense_flow_rate = dispense
+            self._user_dispense_flow_rate = dispense
         if blow_out is not None:
             assert blow_out > 0
-            self._blow_out_flow_rate = blow_out
+            self._user_blow_out_flow_rate = blow_out
 
     def set_liquid_presence_detection(self, enable: bool) -> None:
         self._liquid_presence_detection = enable
@@ -1105,6 +1167,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 ),
             )
         )
+        if self._protocol_core.api_version >= _DEFAULT_FLOW_RATE_BUG_FIXED_IN:
+            self._user_aspirate_flow_rate = None
+            self._user_dispense_flow_rate = None
+            self._user_blow_out_flow_rate = None
 
     def prepare_to_aspirate(self) -> None:
         self._engine_client.execute_command(
@@ -1273,6 +1339,13 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             tiprack_uri=tiprack_uri_for_transfer_props,
         )
 
+        original_aspirate_flow_rate = self._user_aspirate_flow_rate
+        original_dispense_flow_rate = self._user_dispense_flow_rate
+        original_blow_out_flow_rate = self._user_blow_out_flow_rate
+        in_low_volume_mode = self._engine_client.state.pipettes.get_is_low_volume_mode(
+            self._pipette_id
+        )
+
         target_destinations: Sequence[
             Union[Tuple[Location, WellCore], TrashBin, WasteChute]
         ]
@@ -1367,6 +1440,14 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         if not keep_last_tip:
             self._drop_tip_for_liquid_class(trash_location, return_tip)
 
+        if self._protocol_core.api_version >= _DEFAULT_FLOW_RATE_BUG_FIXED_IN:
+            self._restore_pipette_flow_rates_and_volume_mode(
+                aspirate_flow_rate=original_aspirate_flow_rate,
+                dispense_flow_rate=original_dispense_flow_rate,
+                blow_out_flow_rate=original_blow_out_flow_rate,
+                is_low_volume=in_low_volume_mode,
+            )
+
     def distribute_with_liquid_class(  # noqa: C901
         self,
         liquid_class: LiquidClass,
@@ -1474,6 +1555,13 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             tiprack_uri=tiprack_uri_for_transfer_props,
         )
 
+        original_aspirate_flow_rate = self._user_aspirate_flow_rate
+        original_dispense_flow_rate = self._user_dispense_flow_rate
+        original_blow_out_flow_rate = self._user_blow_out_flow_rate
+        in_low_volume_mode = self._engine_client.state.pipettes.get_is_low_volume_mode(
+            self._pipette_id
+        )
+
         # This will return a generator that provides pairs of destination well and
         # the volume to dispense into it
         dest_per_volume_step = (
@@ -1617,6 +1705,14 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         if not keep_last_tip:
             self._drop_tip_for_liquid_class(trash_location, return_tip)
 
+        if self._protocol_core.api_version >= _DEFAULT_FLOW_RATE_BUG_FIXED_IN:
+            self._restore_pipette_flow_rates_and_volume_mode(
+                aspirate_flow_rate=original_aspirate_flow_rate,
+                dispense_flow_rate=original_dispense_flow_rate,
+                blow_out_flow_rate=original_blow_out_flow_rate,
+                is_low_volume=in_low_volume_mode,
+            )
+
     def _tip_can_hold_volume_for_multi_dispensing(
         self,
         transfer_volume: float,
@@ -1712,6 +1808,13 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             tiprack_uri=tiprack_uri_for_transfer_props,
         )
 
+        original_aspirate_flow_rate = self._user_aspirate_flow_rate
+        original_dispense_flow_rate = self._user_dispense_flow_rate
+        original_blow_out_flow_rate = self._user_blow_out_flow_rate
+        in_low_volume_mode = self._engine_client.state.pipettes.get_is_low_volume_mode(
+            self._pipette_id
+        )
+
         working_volume = self.get_working_volume_for_tip_rack(tip_racks[0][1])
 
         source_per_volume_step = (
@@ -1796,6 +1899,14 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         if not keep_last_tip:
             self._drop_tip_for_liquid_class(trash_location, return_tip)
 
+        if self._protocol_core.api_version >= _DEFAULT_FLOW_RATE_BUG_FIXED_IN:
+            self._restore_pipette_flow_rates_and_volume_mode(
+                aspirate_flow_rate=original_aspirate_flow_rate,
+                dispense_flow_rate=original_dispense_flow_rate,
+                blow_out_flow_rate=original_blow_out_flow_rate,
+                is_low_volume=in_low_volume_mode,
+            )
+
     def _get_location_and_well_core_from_next_tip_info(
         self,
         tip_info: NextTipInfo,
@@ -1904,6 +2015,20 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 alternate_drop_location=True,
             )
 
+    def _restore_pipette_flow_rates_and_volume_mode(
+        self,
+        aspirate_flow_rate: Optional[float],
+        dispense_flow_rate: Optional[float],
+        blow_out_flow_rate: Optional[float],
+        is_low_volume: bool,
+    ) -> None:
+        # TODO(jbl 2025-09-17) this works for p50 low volume mode but is not guaranteed to work for future low volume
+        #   modes, this should be replaced with something less flaky
+        self.configure_for_volume(self.get_max_volume() if not is_low_volume else 1)
+        self._user_aspirate_flow_rate = aspirate_flow_rate
+        self._user_dispense_flow_rate = dispense_flow_rate
+        self._user_blow_out_flow_rate = blow_out_flow_rate
+
     def aspirate_liquid_class(
         self,
         volume: float,

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -21,7 +21,11 @@ from opentrons.protocol_engine import (
     OnLabwareLocation,
     DropTipWellLocation,
 )
-from opentrons.protocol_engine.types import StagingSlotLocation, WellLocationType
+from opentrons.protocol_engine.types import (
+    StagingSlotLocation,
+    WellLocationType,
+    LoadedModule,
+)
 from opentrons.types import DeckSlotName, StagingSlotName, Point
 from . import point_calculations
 
@@ -136,22 +140,47 @@ def check_safe_for_pipette_movement(  # noqa: C901
             f" will result in collision with thermocycler lid in deck slot A1."
         )
 
+    def _check_for_column_4_module_collision(slot: DeckSlotName) -> None:
+        slot_module = engine_state.modules.get_by_slot(slot)
+        if (
+            slot_module
+            and engine_state.modules.is_column_4_module(slot_module.model)
+            and _slot_has_potential_colliding_object(
+                engine_state=engine_state,
+                pipette_bounds=pipette_bounds_at_well_location,
+                surrounding_location=slot_module,
+            )
+        ):
+            raise PartialTipMovementNotAllowedError(
+                f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
+                f" {slot} with {primary_nozzle} nozzle partial configuration will"
+                f" result in collision with items on {slot_module.model} mounted in {slot}."
+            )
+
+    # We check the labware slot for a module that is mounted in the same cutout
+    # as the labwares slot but does not occupy the same heirarchy (like the stacker).
+    _check_for_column_4_module_collision(labware_slot)
+
     for regular_slot in surrounding_slots.regular_slots:
         if _slot_has_potential_colliding_object(
             engine_state=engine_state,
             pipette_bounds=pipette_bounds_at_well_location,
-            surrounding_slot=regular_slot,
+            surrounding_location=regular_slot,
         ):
             raise PartialTipMovementNotAllowedError(
                 f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
                 f" {labware_slot} with {primary_nozzle} nozzle partial configuration"
                 f" will result in collision with items in deck slot {regular_slot}."
             )
+
+        # Check for Column 4 Modules that may be descendants of a given surrounding slot
+        _check_for_column_4_module_collision(regular_slot)
+
     for staging_slot in surrounding_slots.staging_slots:
         if _slot_has_potential_colliding_object(
             engine_state=engine_state,
             pipette_bounds=pipette_bounds_at_well_location,
-            surrounding_slot=staging_slot,
+            surrounding_location=staging_slot,
         ):
             raise PartialTipMovementNotAllowedError(
                 f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
@@ -178,18 +207,45 @@ def _get_critical_point_to_use(
 def _slot_has_potential_colliding_object(
     engine_state: StateView,
     pipette_bounds: Tuple[Point, Point, Point, Point],
-    surrounding_slot: Union[DeckSlotName, StagingSlotName],
+    surrounding_location: Union[DeckSlotName, StagingSlotName, LoadedModule],
 ) -> bool:
-    """Return the slot, if any, that has an item that the pipette might collide into."""
-    # Check if slot overlaps with pipette position
-    slot_pos = engine_state.addressable_areas.get_addressable_area_position(
-        addressable_area_name=surrounding_slot.id,
-        do_compatibility_check=False,
-    )
-    slot_bounds = engine_state.addressable_areas.get_addressable_area_bounding_box(
-        addressable_area_name=surrounding_slot.id,
-        do_compatibility_check=False,
-    )
+    """Return the slot, if any, that has an item that the pipette might collide into.
+    Can be provided a Deck Slot, Staging Slot, or Column 4 Module.
+    """
+    if isinstance(surrounding_location, LoadedModule):
+        if (
+            engine_state.modules.is_column_4_module(surrounding_location.model)
+            and surrounding_location.location is not None
+        ):
+            module_area = (
+                engine_state.modules.ensure_and_convert_module_fixture_location(
+                    surrounding_location.location.slotName, surrounding_location.model
+                )
+            )
+            slot_pos = engine_state.addressable_areas.get_addressable_area_position(
+                addressable_area_name=module_area,
+                do_compatibility_check=False,
+            )
+            slot_bounds = (
+                engine_state.addressable_areas.get_addressable_area_bounding_box(
+                    addressable_area_name=module_area,
+                    do_compatibility_check=False,
+                )
+            )
+        else:
+            raise ValueError(
+                f"Error during collision validation, Module {surrounding_location.model} must be in Column 4."
+            )
+    else:
+        # Check if slot overlaps with pipette position
+        slot_pos = engine_state.addressable_areas.get_addressable_area_position(
+            addressable_area_name=surrounding_location.id,
+            do_compatibility_check=False,
+        )
+        slot_bounds = engine_state.addressable_areas.get_addressable_area_bounding_box(
+            addressable_area_name=surrounding_location.id,
+            do_compatibility_check=False,
+        )
     slot_back_left_coords = Point(slot_pos.x, slot_pos.y + slot_bounds.y, slot_pos.z)
     slot_front_right_coords = Point(slot_pos.x + slot_bounds.x, slot_pos.y, slot_pos.z)
 
@@ -199,13 +255,17 @@ def _slot_has_potential_colliding_object(
         rectangle2=(slot_back_left_coords, slot_front_right_coords),
     ):
         # Check z-height of items in overlapping slot
-        if isinstance(surrounding_slot, DeckSlotName):
+        if isinstance(surrounding_location, DeckSlotName):
             slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
-                DeckSlotLocation(slotName=surrounding_slot)
+                DeckSlotLocation(slotName=surrounding_location)
+            )
+        elif isinstance(surrounding_location, LoadedModule):
+            slot_highest_z = engine_state.geometry.get_highest_z_of_column_4_module(
+                surrounding_location
             )
         else:
             slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
-                StagingSlotLocation(slotName=surrounding_slot)
+                StagingSlotLocation(slotName=surrounding_location)
             )
         return slot_highest_z >= pipette_bounds[0].z
     return False

opentrons/protocol_api/core/engine/protocol.py

@@ -78,7 +78,12 @@ from .module_core import (
     FlexStackerCore,
 )
 from .exceptions import InvalidModuleLocationError
-from . import load_labware_params, deck_conflict, overlap_versions
+from . import (
+    load_labware_params,
+    deck_conflict,
+    overlap_versions,
+    _default_liquid_class_versions,
+)
 from opentrons.protocol_engine.resources import labware_validation
 
 if TYPE_CHECKING:
@@ -492,13 +497,28 @@ class ProtocolCore(
             )
         # if this is a labware with a lid, we just need to find its lid_id
         else:
-            lid = self._engine_client.state.labware.get_lid_by_labware_id(
-                labware.labware_id
+            # we need to check to see if this labware is hosting a lid stack
+            potential_lid_stack = (
+                self._engine_client.state.labware.get_next_child_labware(
+                    labware.labware_id
+                )
             )
-            if lid is not None:
-                lid_id = lid.id
+            if potential_lid_stack and labware_validation.is_lid_stack(
+                self._engine_client.state.labware.get_load_name(potential_lid_stack)
+            ):
+                lid_id = self._engine_client.state.labware.get_highest_child_labware(
+                    labware.labware_id
+                )
             else:
-                raise ValueError("Cannot move a lid off of a labware with no lid.")
+                lid = self._engine_client.state.labware.get_lid_by_labware_id(
+                    labware.labware_id
+                )
+                if lid is not None:
+                    lid_id = lid.id
+                else:
+                    raise ValueError(
+                        f"Cannot move a lid off of {labware.get_display_name()} because it has no lid."
+                    )
 
         _pick_up_offset = (
             LabwareOffsetVector(
@@ -602,6 +622,9 @@ class ProtocolCore(
         )
 
         # Handle leftover empty lid stack if there is one
+        potential_lid_stack = self._engine_client.state.labware.get_next_child_labware(
+            labware.labware_id
+        )
         if (
             labware_validation.is_lid_stack(labware.load_name)
             and self._engine_client.state.labware.get_highest_child_labware(
@@ -619,6 +642,25 @@ class ProtocolCore(
                     dropOffset=None,
                 )
             )
+        elif (
+            potential_lid_stack
+            and labware_validation.is_lid_stack(
+                self._engine_client.state.labware.get_load_name(potential_lid_stack)
+            )
+            and self._engine_client.state.labware.get_highest_child_labware(
+                potential_lid_stack
+            )
+            == potential_lid_stack
+        ):
+            self._engine_client.execute_command(
+                cmd.MoveLabwareParams(
+                    labwareId=potential_lid_stack,
+                    newLocation=SYSTEM_LOCATION,
+                    strategy=LabwareMovementStrategy.MANUAL_MOVE_WITHOUT_PAUSE,
+                    pickUpOffset=None,
+                    dropOffset=None,
+                )
+            )
 
         if strategy == LabwareMovementStrategy.USING_GRIPPER:
             # Clear out last location since it is not relevant to pipetting
@@ -1068,8 +1110,12 @@ class ProtocolCore(
             display_color=(liquid.displayColor.root if liquid.displayColor else None),
         )
 
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
+        if version is None:
+            version = _default_liquid_class_versions.get_liquid_class_version(
+                self._api_version, name
+            )
         try:
             # Check if we have already loaded this liquid class' definition
             liquid_class_def = self._liquid_class_def_cache[(name, version)]

opentrons/protocol_api/core/engine/transfer_components_executor.py

@@ -5,7 +5,7 @@ import logging
 from copy import deepcopy
 from enum import Enum
 from typing import TYPE_CHECKING, Optional, Union, Literal
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 
 from opentrons_shared_data.liquid_classes.liquid_class_definition import (
     PositionReference,
@@ -21,7 +21,6 @@ from opentrons.protocol_api._liquid_properties import (
     MultiDispenseProperties,
     TouchTipProperties,
 )
-from opentrons.protocol_engine.errors import TouchTipDisabledError
 from opentrons.types import Location, Point, Mount
 from opentrons.protocols.advanced_control.transfers.transfer_liquid_utils import (
     LocationCheckDescriptors,
@@ -466,7 +465,7 @@ class TransferComponentsExecutor:
         2. If blowout is enabled and “destination”
             - Do blow-out (at the retract position)
             - Leave plunger down
-        3. Touch-tip
+        3. Touch-tip in the destination well.
         4. If not ready-to-aspirate
             - Prepare-to-aspirate (at the retract position)
         5. Air-gap (at the retract position)
@@ -479,7 +478,7 @@ class TransferComponentsExecutor:
         6. If blowout is “source” or “trash”
             - Move to location (top of Well)
             - Do blow-out (top of well)
-            - Do touch-tip (?????) (only if it’s in a non-trash location)
+            - Do touch-tip AGAIN at the source well (if blowout in a non-trash location)
             - Prepare-to-aspirate (top of well)
             - Do air-gap (top of well)
         7. If drop tip, move to drop tip location, drop tip
@@ -563,9 +562,9 @@ class TransferComponentsExecutor:
             blowout_props.enabled
             and blowout_props.location != BlowoutLocation.DESTINATION
         ):
-            # TODO: no-op touch tip if touch tip is enabled and blowout is in trash/ reservoir/ any labware with touch-tip disabled
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
+            blowout_touch_tip_props = retract_props.touch_tip
             touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
@@ -584,6 +583,13 @@ class TransferComponentsExecutor:
                     source_well.get_top(0), labware=source_location.labware
                 )
                 touch_tip_and_air_gap_well = source_well
+                # Skip touch tip if blowing out at the SOURCE and it's untouchable:
+                if (
+                    "touchTipDisabled"
+                    in source_location.labware.quirks_from_any_parent()
+                ):
+                    blowout_touch_tip_props = replace(blowout_touch_tip_props)
+                    blowout_touch_tip_props.enabled = False
             else:
                 self._instrument.blow_out(
                     location=trash_location,
@@ -612,7 +618,7 @@ class TransferComponentsExecutor:
             )
             # Do touch tip and air gap again after blowing out into source well or trash
             self._do_touch_tip_and_air_gap_after_dispense(
-                touch_tip_properties=retract_props.touch_tip,
+                touch_tip_properties=blowout_touch_tip_props,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
                 air_gap_volume=air_gap_volume,
@@ -758,6 +764,7 @@ class TransferComponentsExecutor:
         ):
             assert blowout_props.flow_rate is not None
             self._instrument.set_flow_rate(blow_out=blowout_props.flow_rate)
+            blowout_touch_tip_props = retract_props.touch_tip
             touch_tip_and_air_gap_location: Union[Location, TrashBin, WasteChute]
             if blowout_props.location == BlowoutLocation.SOURCE:
                 if source_location is None or source_well is None:
@@ -776,6 +783,13 @@ class TransferComponentsExecutor:
                     source_well.get_top(0), labware=source_location.labware
                 )
                 touch_tip_and_air_gap_well = source_well
+                # Skip touch tip if blowing out at the SOURCE and it's untouchable:
+                if (
+                    "touchTipDisabled"
+                    in source_location.labware.quirks_from_any_parent()
+                ):
+                    blowout_touch_tip_props = replace(blowout_touch_tip_props)
+                    blowout_touch_tip_props.enabled = False
             else:
                 self._instrument.blow_out(
                     location=trash_location,
@@ -807,13 +821,13 @@ class TransferComponentsExecutor:
                 air_gap_volume = 0
             # Do touch tip and air gap again after blowing out into source well or trash
             self._do_touch_tip_and_air_gap_after_dispense(
-                touch_tip_properties=retract_props.touch_tip,
+                touch_tip_properties=blowout_touch_tip_props,
                 location=touch_tip_and_air_gap_location,
                 well=touch_tip_and_air_gap_well,
                 air_gap_volume=air_gap_volume,
             )
 
-    def _do_touch_tip_and_air_gap_after_dispense(  # noqa: C901
+    def _do_touch_tip_and_air_gap_after_dispense(
         self,
         touch_tip_properties: TouchTipProperties,
         location: Union[Location, TrashBin, WasteChute],
@@ -822,6 +836,12 @@ class TransferComponentsExecutor:
     ) -> None:
         """Perform touch tip and air gap as part of post-dispense retract.
 
+        This function can be invoked up to 2 times for each dispense:
+        1) Once for touching tip at the dispense location.
+        2) Then again in the blowout location if it is not the dispense location.
+        For case (2), the caller should disable touch-tip in touch_tip_properties
+        if the blowout location is not touchable (such as reservoirs).
+
         If the retract location is at or above the safe location of
         AIR_GAP_LOC_Z_OFFSET_FROM_WELL_TOP, then add the air gap at the retract location
         (where the pipette is already assumed to be at).
@@ -842,18 +862,14 @@ class TransferComponentsExecutor:
             #  whether the touch tip params from transfer props should be used for
             #  both dest-well touch tip and non-dest-well touch tip.
             if isinstance(location, Location) and well is not None:
-                try:
-                    self._instrument.touch_tip(
-                        location=location,
-                        well_core=well,
-                        radius=1,
-                        z_offset=touch_tip_properties.z_offset,
-                        speed=touch_tip_properties.speed,
-                        mm_from_edge=touch_tip_properties.mm_from_edge,
-                    )
-                except TouchTipDisabledError:
-                    # TODO: log a warning
-                    pass
+                self._instrument.touch_tip(
+                    location=location,
+                    well_core=well,
+                    radius=1,
+                    z_offset=touch_tip_properties.z_offset,
+                    speed=touch_tip_properties.speed,
+                    mm_from_edge=touch_tip_properties.mm_from_edge,
+                )
 
                 # Move back to the 'retract' position
                 self._instrument.move_to(

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -599,7 +599,7 @@ class LegacyProtocolCore(
         """Define a liquid to load into a well."""
         assert False, "define_liquid only supported on engine core"
 
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
         assert False, "define_liquid_class is only supported on engine core"
 

opentrons/protocol_api/core/protocol.py

@@ -297,7 +297,7 @@ class AbstractProtocol(
         """Define a liquid to load into a well."""
 
     @abstractmethod
-    def get_liquid_class(self, name: str, version: int) -> LiquidClass:
+    def get_liquid_class(self, name: str, version: Optional[int]) -> LiquidClass:
         """Get an instance of a built-in liquid class."""
 
     @abstractmethod