opentrons 8.7.0a7__py3-none-any.whl → 8.7.0a9__py3-none-any.whl

opentrons/protocol_engine/state/tips.py

@@ -1,24 +1,27 @@
 """Tip state tracking."""
 
 from dataclasses import dataclass
-from typing import Dict, Iterable, Optional, List, Set
+from enum import Enum
+from typing import Dict, Iterable, Optional, List, Union
 
-from opentrons.types import NozzleMapInterface, NozzleConfigurationType
+from opentrons.types import NozzleMapInterface
 from opentrons.protocol_engine.state import update_types
-from opentrons.protocol_engine.types import TipRackWellState
 
 from ._abstract_store import HasState, HandlesActions
-from ._well_math import (
-    wells_covered_dense,
-    wells_covered_by_pipette_configuration,
-    wells_covered_by_physical_pipette,
-)
-from ..actions import Action, get_state_updates
+from ._well_math import wells_covered_dense
+from ..actions import Action, ResetTipsAction, get_state_updates
 
 from opentrons.hardware_control.nozzle_manager import NozzleMap
 
 
-_TipRackStateByWellName = Dict[str, TipRackWellState]
+class _TipRackWellState(Enum):
+    """The state of a single tip in a tip rack's well."""
+
+    CLEAN = "clean"
+    USED = "used"
+
+
+_TipRackStateByWellName = Dict[str, _TipRackWellState]
 
 
 @dataclass
@@ -46,12 +49,19 @@ class TipStore(HasState[TipState], HandlesActions):
         for state_update in get_state_updates(action):
             self._handle_state_update(state_update)
 
+        if isinstance(action, ResetTipsAction):
+            labware_id = action.labware_id
+
+            for well_name in self._state.tips_by_labware_id[labware_id].keys():
+                self._state.tips_by_labware_id[labware_id][
+                    well_name
+                ] = _TipRackWellState.CLEAN
+
     def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
-        if state_update.tips_state != update_types.NO_CHANGE:
-            self._set_tip_state(
-                labware_id=state_update.tips_state.labware_id,
-                well_names=state_update.tips_state.well_names,
-                tip_state=state_update.tips_state.tip_state,
+        if state_update.tips_used != update_types.NO_CHANGE:
+            self._set_used_tips(
+                labware_id=state_update.tips_used.labware_id,
+                well_names=state_update.tips_used.well_names,
             )
 
         if state_update.loaded_labware != update_types.NO_CHANGE:
@@ -59,7 +69,7 @@ class TipStore(HasState[TipState], HandlesActions):
             definition = state_update.loaded_labware.definition
             if definition.parameters.isTiprack:
                 self._state.tips_by_labware_id[labware_id] = {
-                    well_name: TipRackWellState.CLEAN
+                    well_name: _TipRackWellState.CLEAN
                     for column in definition.ordering
                     for well_name in column
                 }
@@ -73,7 +83,7 @@ class TipStore(HasState[TipState], HandlesActions):
                 ]
                 if definition.parameters.isTiprack:
                     self._state.tips_by_labware_id[labware_id] = {
-                        well_name: TipRackWellState.CLEAN
+                        well_name: _TipRackWellState.CLEAN
                         for column in definition.ordering
                         for well_name in column
                     }
@@ -81,12 +91,10 @@ class TipStore(HasState[TipState], HandlesActions):
                         column for column in definition.ordering
                     ]
 
-    def _set_tip_state(
-        self, labware_id: str, well_names: Iterable[str], tip_state: TipRackWellState
-    ) -> None:
+    def _set_used_tips(self, labware_id: str, well_names: Iterable[str]) -> None:
         well_states = self._state.tips_by_labware_id.get(labware_id, {})
         for well_name in well_names:
-            well_states[well_name] = tip_state
+            well_states[well_name] = _TipRackWellState.USED
 
 
 class TipView:
@@ -109,15 +117,226 @@ class TipView:
         starting_tip_name: Optional[str],
         nozzle_map: Optional[NozzleMapInterface],
     ) -> Optional[str]:
-        """Gets the next available clean tip.
+        """Get the next available clean tip. Does not support use of a starting tip if the pipette used is in a partial configuration."""
+        wells = self._state.tips_by_labware_id.get(labware_id, {})
+        columns = self._state.columns_by_labware_id.get(labware_id, [])
 
-        Does not support use of a starting tip if the pipette used is in a partial configuration.
-        """
-        if starting_tip_name is None and nozzle_map is not None:
-            return self._get_next_tip_with_nozzle_map(labware_id, nozzle_map)
+        # TODO(sf): I'm pretty sure this can be replaced with wells_covered_96 but I'm not quite sure how
+        def _identify_tip_cluster(
+            active_columns: int,
+            active_rows: int,
+            critical_column: int,
+            critical_row: int,
+            entry_well: str,
+        ) -> Optional[List[str]]:
+            tip_cluster: list[str] = []
+            for i in range(active_columns):
+                if entry_well == "A1" or entry_well == "H1":
+                    if critical_column - i >= 0:
+                        column = columns[critical_column - i]
+                    else:
+                        return None
+                elif entry_well == "A12" or entry_well == "H12":
+                    if critical_column + i < len(columns):
+                        column = columns[critical_column + i]
+                    else:
+                        return None
+                else:
+                    raise ValueError(
+                        f"Invalid entry well {entry_well} for tip cluster identification."
+                    )
+                for j in range(active_rows):
+                    if entry_well == "A1" or entry_well == "A12":
+                        if critical_row - j >= 0:
+                            well = column[critical_row - j]
+                        else:
+                            return None
+                    elif entry_well == "H1" or entry_well == "H12":
+                        if critical_row + j < len(column):
+                            well = column[critical_row + j]
+                        else:
+                            return None
+                    tip_cluster.append(well)
+
+            if any(well not in [*wells] for well in tip_cluster):
+                return None
+
+            return tip_cluster
+
+        def _validate_tip_cluster(
+            active_columns: int, active_rows: int, tip_cluster: List[str]
+        ) -> Union[str, int, None]:
+            if not any(wells[well] == _TipRackWellState.USED for well in tip_cluster):
+                return tip_cluster[0]
+            elif all(wells[well] == _TipRackWellState.USED for well in tip_cluster):
+                return None
+            else:
+                # In the case of an 8ch pipette where a column has mixed state tips we may simply progress to the next column in our search
+                if nozzle_map is not None and nozzle_map.physical_nozzle_count == 8:
+                    return None
+
+                # In the case of a 96ch we can attempt to index in by singular rows and columns assuming that indexed direction is safe
+                # The tip cluster list is ordered: Each row from a column in order by columns
+                tip_cluster_final_column: list[str] = []
+                for i in range(active_rows):
+                    tip_cluster_final_column.append(
+                        tip_cluster[((active_columns * active_rows) - 1) - i]
+                    )
+                tip_cluster_final_row: list[str] = []
+                for i in range(active_columns):
+                    tip_cluster_final_row.append(
+                        tip_cluster[(active_rows - 1) + (i * active_rows)]
+                    )
+                if all(
+                    wells[well] == _TipRackWellState.USED
+                    for well in tip_cluster_final_column
+                ):
+                    return None
+                elif all(
+                    wells[well] == _TipRackWellState.USED
+                    for well in tip_cluster_final_row
+                ):
+                    return None
+                else:
+                    # Tiprack has no valid tip selection, cannot progress
+                    return -1
+
+        # Search through the tiprack beginning at A1
+        def _cluster_search_A1(active_columns: int, active_rows: int) -> Optional[str]:
+            critical_column = active_columns - 1
+            critical_row = active_rows - 1
+
+            while critical_column < len(columns):
+                tip_cluster = _identify_tip_cluster(
+                    active_columns, active_rows, critical_column, critical_row, "A1"
+                )
+                if tip_cluster is not None:
+                    result = _validate_tip_cluster(
+                        active_columns, active_rows, tip_cluster
+                    )
+                    if isinstance(result, str):
+                        return result
+                    elif isinstance(result, int) and result == -1:
+                        return None
+                if critical_row + 1 < len(columns[0]):
+                    critical_row = critical_row + 1
+                else:
+                    critical_column += 1
+                    critical_row = active_rows - 1
+            return None
+
+        # Search through the tiprack beginning at A12
+        def _cluster_search_A12(active_columns: int, active_rows: int) -> Optional[str]:
+            critical_column = len(columns) - active_columns
+            critical_row = active_rows - 1
+
+            while critical_column >= 0:
+                tip_cluster = _identify_tip_cluster(
+                    active_columns, active_rows, critical_column, critical_row, "A12"
+                )
+                if tip_cluster is not None:
+                    result = _validate_tip_cluster(
+                        active_columns, active_rows, tip_cluster
+                    )
+                    if isinstance(result, str):
+                        return result
+                    elif isinstance(result, int) and result == -1:
+                        return None
+                if critical_row + 1 < len(columns[0]):
+                    critical_row = critical_row + 1
+                else:
+                    critical_column -= 1
+                    critical_row = active_rows - 1
+            return None
+
+        # Search through the tiprack beginning at H1
+        def _cluster_search_H1(active_columns: int, active_rows: int) -> Optional[str]:
+            critical_column = active_columns - 1
+            critical_row = len(columns[critical_column]) - active_rows
+
+            while critical_column <= len(columns):  # change to max size of labware
+                tip_cluster = _identify_tip_cluster(
+                    active_columns, active_rows, critical_column, critical_row, "H1"
+                )
+                if tip_cluster is not None:
+                    result = _validate_tip_cluster(
+                        active_columns, active_rows, tip_cluster
+                    )
+                    if isinstance(result, str):
+                        return result
+                    elif isinstance(result, int) and result == -1:
+                        return None
+                if critical_row - 1 >= 0:
+                    critical_row = critical_row - 1
+                else:
+                    critical_column += 1
+                    if critical_column >= len(columns):
+                        return None
+                    critical_row = len(columns[critical_column]) - active_rows
+            return None
+
+        # Search through the tiprack beginning at H12
+        def _cluster_search_H12(active_columns: int, active_rows: int) -> Optional[str]:
+            critical_column = len(columns) - active_columns
+            critical_row = len(columns[critical_column]) - active_rows
+
+            while critical_column >= 0:
+                tip_cluster = _identify_tip_cluster(
+                    active_columns, active_rows, critical_column, critical_row, "H12"
+                )
+                if tip_cluster is not None:
+                    result = _validate_tip_cluster(
+                        active_columns, active_rows, tip_cluster
+                    )
+                    if isinstance(result, str):
+                        return result
+                    elif isinstance(result, int) and result == -1:
+                        return None
+                if critical_row - 1 >= 0:
+                    critical_row = critical_row - 1
+                else:
+                    critical_column -= 1
+                    if critical_column < 0:
+                        return None
+                    critical_row = len(columns[critical_column]) - active_rows
+            return None
+
+        if starting_tip_name is None and nozzle_map is not None and columns:
+            num_channels = nozzle_map.physical_nozzle_count
+            num_nozzle_cols = len(nozzle_map.columns)
+            num_nozzle_rows = len(nozzle_map.rows)
+            # Each pipette's cluster search is determined by the point of entry for a given pipette/configuration:
+            # - Single channel pipettes always search a tiprack top to bottom, left to right
+            # - Eight channel pipettes will begin at the top if the primary nozzle is H1 and at the bottom if
+            #   it is A1. The eight channel will always progress across the columns left to right.
+            # - 96 Channel pipettes will begin in the corner opposite their primary/starting nozzle (if starting nozzle = A1, enter tiprack at H12)
+            #   The 96 channel will then progress towards the opposite corner, either going up or down, left or right depending on configuration.
+
+            if num_channels == 1:
+                return _cluster_search_A1(num_nozzle_cols, num_nozzle_rows)
+            elif num_channels == 8:
+                if nozzle_map.starting_nozzle == "A1":
+                    return _cluster_search_H1(num_nozzle_cols, num_nozzle_rows)
+                elif nozzle_map.starting_nozzle == "H1":
+                    return _cluster_search_A1(num_nozzle_cols, num_nozzle_rows)
+            elif num_channels == 96:
+                if nozzle_map.starting_nozzle == "A1":
+                    return _cluster_search_H12(num_nozzle_cols, num_nozzle_rows)
+                elif nozzle_map.starting_nozzle == "A12":
+                    return _cluster_search_H1(num_nozzle_cols, num_nozzle_rows)
+                elif nozzle_map.starting_nozzle == "H1":
+                    return _cluster_search_A12(num_nozzle_cols, num_nozzle_rows)
+                elif nozzle_map.starting_nozzle == "H12":
+                    return _cluster_search_A1(num_nozzle_cols, num_nozzle_rows)
+                else:
+                    raise ValueError(
+                        f"Nozzle {nozzle_map.starting_nozzle} is an invalid starting tip for automatic tip pickup."
+                    )
+            else:
+                raise RuntimeError(
+                    "Invalid number of channels for automatic tip tracking."
+                )
         else:
-            wells = self._state.tips_by_labware_id.get(labware_id, {})
-            columns = self._state.columns_by_labware_id.get(labware_id, [])
             if columns and num_tips == len(columns[0]):  # Get next tips for 8-channel
                 column_head = [column[0] for column in columns]
                 starting_column_index = 0
@@ -131,15 +350,17 @@ class TipView:
                                 starting_column_index = idx
 
                 for column in columns[starting_column_index:]:
-                    if all(wells[well] == TipRackWellState.CLEAN for well in column):
+                    if not any(
+                        wells[well] == _TipRackWellState.USED for well in column
+                    ):
                         return column[0]
 
             elif num_tips == len(wells.keys()):  # Get next tips for 96 channel
                 if starting_tip_name and starting_tip_name != columns[0][0]:
                     return None
 
-                if all(
-                    tip_state == TipRackWellState.CLEAN for tip_state in wells.values()
+                if not any(
+                    tip_state == _TipRackWellState.USED for tip_state in wells.values()
                 ):
                     return next(iter(wells))
 
@@ -148,74 +369,10 @@ class TipView:
                     wells = _drop_wells_before_starting_tip(wells, starting_tip_name)
 
                 for well_name, tip_state in wells.items():
-                    if tip_state == TipRackWellState.CLEAN:
+                    if tip_state == _TipRackWellState.CLEAN:
                         return well_name
         return None
 
-    def _get_next_tip_with_nozzle_map(
-        self,
-        labware_id: str,
-        nozzle_map: NozzleMapInterface,
-    ) -> Optional[str]:
-        """Get the next available clean tip for given nozzle configuration if one can be found."""
-        tip_well_states = self._state.tips_by_labware_id.get(labware_id, {})
-        wells_by_columns = self._state.columns_by_labware_id.get(labware_id, [])
-
-        def _validate_wells(well_list: Set[str], target_well: str) -> bool:
-            # If we are not picking up the correct number of tips it's not valid
-            if len(well_list) != nozzle_map.tip_count:
-                return False
-            # If not all the tips we'll be picking up are clean it's not valid
-            target_well_states = [tip_well_states[well_name] for well_name in well_list]
-            if not all(state == TipRackWellState.CLEAN for state in target_well_states):
-                return False
-            # Since we know a full configuration will always produce zero non-active overlapping wells
-            # we can skip the following checks if it is a full configuration.
-            if nozzle_map.configuration != NozzleConfigurationType.FULL:
-                # If we have a partial configuration we need to ensure that any wells in the way are NOT present
-                wells_covered_physically = set(
-                    wells_covered_by_physical_pipette(
-                        nozzle_map=nozzle_map,  # type: ignore[arg-type]
-                        target_well=target_well,
-                        labware_wells_by_column=wells_by_columns,
-                    )
-                )
-                wells_in_way_well_state = [
-                    tip_well_states[well_name]
-                    for well_name in wells_covered_physically.difference(well_list)
-                ]
-                # TODO(jbl 2025-08-25) this should be changed to ensure all these extra wells are EMPTY when further
-                #   tip return work occurs
-                if any(
-                    well_state == TipRackWellState.CLEAN
-                    for well_state in wells_in_way_well_state
-                ):
-                    return False
-
-            return True
-
-        # Get an ordered list of wells to most efficiently search, depending on pipette configuration
-        target_well_list = _resolve_well_order(wells_by_columns, nozzle_map)
-
-        for well in target_well_list:
-            # If the target well/tip isn't clean, skip to the next one. This will be checked
-            # again in _validate_wells, but we can short circuit the following checks if this is False
-            if tip_well_states[well] != TipRackWellState.CLEAN:
-                continue
-            # Get list of all wells (i.e. tips) that would be covered by the active nozzles
-            targeted_wells = set(
-                wells_covered_by_pipette_configuration(
-                    nozzle_map=nozzle_map,  # type: ignore[arg-type]
-                    target_well=well,
-                    labware_wells_by_column=wells_by_columns,
-                )
-            )
-            # If we are picking up the correct number of tips, return that target well
-            if _validate_wells(targeted_wells, target_well=well):
-                return well
-
-        return None
-
     def has_clean_tip(self, labware_id: str, well_name: str) -> bool:
         """Get whether a well in a labware has a clean tip.
 
@@ -230,12 +387,12 @@ class TipView:
         tip_rack = self._state.tips_by_labware_id.get(labware_id)
         well_state = tip_rack.get(well_name) if tip_rack else None
 
-        return well_state == TipRackWellState.CLEAN
+        return well_state == _TipRackWellState.CLEAN
 
-    def compute_tips_to_mark_as_used_or_empty(
+    def compute_tips_to_mark_as_used(
         self, labware_id: str, well_name: str, nozzle_map: NozzleMap
     ) -> list[str]:
-        """Compute which tips a hypothetical tip pickup/drop should mark as "used" or "empty".
+        """Compute which tips a hypothetical tip pickup should mark as "used".
 
         Params:
             labware_id: The labware ID of the tip rack.
@@ -246,15 +403,7 @@ class TipView:
             The well names of all the tips that the operation will use.
         """
         columns = self._state.columns_by_labware_id.get(labware_id, [])
-        return list(
-            wells_covered_dense(
-                nozzle_map.columns,
-                nozzle_map.rows,
-                nozzle_map.starting_nozzle,
-                well_name,
-                columns,
-            )
-        )
+        return list(wells_covered_dense(nozzle_map, well_name, columns))
 
 
 def _drop_wells_before_starting_tip(
@@ -262,78 +411,10 @@ def _drop_wells_before_starting_tip(
 ) -> _TipRackStateByWellName:
     """Drop any wells that come before the starting tip and return the remaining ones after."""
     seen_starting_well = False
-    remaining_wells: dict[str, TipRackWellState] = {}
+    remaining_wells: dict[str, _TipRackWellState] = {}
     for well_name, tip_state in wells.items():
         if well_name == starting_tip_name:
             seen_starting_well = True
         if seen_starting_well:
             remaining_wells[well_name] = tip_state
     return remaining_wells
-
-
-def _resolve_well_order(  # noqa: C901
-    well_list: List[List[str]], nozzle_map: NozzleMapInterface
-) -> List[str]:
-    """Given a list of ordered columns and pipette information, returns a flat list of wells ordered for tip pick up.
-
-    Wells can be ordered in four different ways:
-        - Top to bottom, left to right (A1, B1, ... A2, B2, ... G12, H12)
-        - Top to bottom, right to left (A12, B12, ... A11, B11, ... G1, H1)
-        - Bottom to top, left to right (H1, G1, ... H2, G2, ... B12, A12)
-        - Bottom to top, right to left (A12, B12, ... A11, B11, ... G1, H1)
-
-    - Full configurations (which will always cover a single channel) will go top to bottom, left to right.
-    - A partial 8-channel pipette configuration will always search left to right, starting at either top to bottom for
-        starting nozzle H1 or bottom to top for starting nozzle A1
-    - A partial 96-channel pipette configuration will always begin in the opposite corner of the starting nozzle
-    """
-    if nozzle_map.configuration == NozzleConfigurationType.FULL:
-        return _get_top_to_bottom_left_to_right(well_list)
-    elif nozzle_map.physical_nozzle_count == 8:
-        if nozzle_map.starting_nozzle == "A1":
-            return _get_bottom_to_top_left_to_right(well_list)
-        elif nozzle_map.starting_nozzle == "H1":
-            return _get_top_to_bottom_left_to_right(well_list)
-        else:
-            raise ValueError(
-                f"Nozzle {nozzle_map.starting_nozzle} is an invalid starting tip for"
-                " 8-channel pipette automatic tip pickup."
-            )
-    elif nozzle_map.physical_nozzle_count == 96:
-        if nozzle_map.starting_nozzle == "A1":
-            return _get_bottom_to_top_right_to_left(well_list)
-        elif nozzle_map.starting_nozzle == "A12":
-            return _get_bottom_to_top_left_to_right(well_list)
-        elif nozzle_map.starting_nozzle == "H1":
-            return _get_top_to_bottom_right_to_left(well_list)
-        elif nozzle_map.starting_nozzle == "H12":
-            return _get_top_to_bottom_left_to_right(well_list)
-        else:
-            raise ValueError(
-                f"Nozzle {nozzle_map.starting_nozzle} is an invalid starting tip for 96-channel automatic tip pickup."
-            )
-    else:
-        raise ValueError(
-            f"Automatic tip pickup does not support {nozzle_map.physical_nozzle_count}-channel pipettes"
-        )
-
-
-def _get_top_to_bottom_left_to_right(well_list: List[List[str]]) -> List[str]:
-    return [well for column in well_list for well in column]
-
-
-def _get_bottom_to_top_left_to_right(well_list: List[List[str]]) -> List[str]:
-    reverse_column_ordering = [list(reversed(column)) for column in well_list]
-    return [well for column in reverse_column_ordering for well in column]
-
-
-def _get_top_to_bottom_right_to_left(well_list: List[List[str]]) -> List[str]:
-    reverse_row_ordering = list(reversed(well_list))
-    return [well for column in reverse_row_ordering for well in column]
-
-
-def _get_bottom_to_top_right_to_left(well_list: List[List[str]]) -> List[str]:
-    reverse_row_column_ordering = [
-        list(reversed(column)) for column in reversed(well_list)
-    ]
-    return [well for column in reverse_row_column_ordering for well in column]

opentrons/protocol_engine/state/update_types.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import dataclasses
 import enum
 import typing
-from typing_extensions import Self
+from typing_extensions import Self, Optional
 from datetime import datetime
 
 from opentrons.hardware_control.nozzle_manager import NozzleMap
@@ -15,7 +15,6 @@ from opentrons.protocol_engine.types import (
     LabwareLocation,
     OnLabwareLocation,
     TipGeometry,
-    TipRackWellState,
     AspiratedFluid,
     LiquidClassRecord,
     ABSMeasureMode,
@@ -236,10 +235,8 @@ class PipetteAspirateReadyUpdate:
 
 
 @dataclasses.dataclass
-class TipsStateUpdate:
-    """Represents an update that marks tips in a tip rack as the requested state."""
-
-    tip_state: TipRackWellState
+class TipsUsedUpdate:
+    """Represents an update that marks tips in a tip rack as used."""
 
     labware_id: str
     """The labware ID of the tip rack."""
@@ -416,7 +413,7 @@ class LoadModuleUpdate:
     definition: ModuleDefinition
     slot_name: DeckSlotName
     requested_model: ModuleModel
-    serial_number: typing.Optional[str]
+    serial_number: Optional[str]
 
 
 @dataclasses.dataclass
@@ -455,7 +452,7 @@ class StateUpdate:
 
     labware_lid: LabwareLidUpdate | NoChangeType = NO_CHANGE
 
-    tips_state: TipsStateUpdate | NoChangeType = NO_CHANGE
+    tips_used: TipsUsedUpdate | NoChangeType = NO_CHANGE
 
     liquid_loaded: LiquidLoadedUpdate | NoChangeType = NO_CHANGE
 
@@ -685,7 +682,7 @@ class StateUpdate:
         definition: ModuleDefinition,
         slot_name: DeckSlotName,
         requested_model: ModuleModel,
-        serial_number: typing.Optional[str],
+        serial_number: Optional[str],
     ) -> Self:
         """Add a new module to state. See `LoadModuleUpdate`."""
         self.loaded_module = LoadModuleUpdate(
@@ -732,13 +729,9 @@ class StateUpdate:
         )
         return self
 
-    def update_tip_rack_well_state(
-        self: Self, tip_state: TipRackWellState, labware_id: str, well_names: list[str]
-    ) -> Self:
-        """Marks tips in a tip rack to provided tip state. See `TipsStateUpdate`."""
-        self.tips_state = TipsStateUpdate(
-            tip_state=tip_state, labware_id=labware_id, well_names=well_names
-        )
+    def mark_tips_as_used(self: Self, labware_id: str, well_names: list[str]) -> Self:
+        """Mark tips in a tip rack as used. See `TipsUsedUpdate`."""
+        self.tips_used = TipsUsedUpdate(labware_id=labware_id, well_names=well_names)
         return self
 
     def set_liquid_loaded(

opentrons/protocol_engine/types/__init__.py

@@ -100,6 +100,7 @@ from .labware import (
     LegacyLabwareOffsetCreate,
     LabwareOffsetCreateInternal,
     LoadedLabware,
+    LabwareParentDefinition,
     LabwareWellId,
     GripSpecs,
 )
@@ -131,7 +132,6 @@ from .instrument import (
     CurrentWell,
     CurrentPipetteLocation,
     InstrumentOffsetVector,
-    GripperMoveType,
 )
 from .execution import EngineStatus, PostRunHardwareState
 from .liquid_level_detection import (
@@ -145,10 +145,9 @@ from .liquid_level_detection import (
 )
 from .liquid_handling import FlowRates
 from .labware_movement import LabwareMovementStrategy, LabwareMovementOffsetData
-from .tip import TipGeometry, TipRackWellState
+from .tip import TipGeometry
 from .hardware_passthrough import MovementAxis, MotorAxis
 from .util import Vec3f, Dimensions
-from .tasks import Task, TaskSummary, FinishedTask
 
 __all__ = [
     # Runtime parameters
@@ -257,6 +256,7 @@ __all__ = [
     "LabwareOffsetCreateInternal",
     "LoadedLabware",
     "LabwareOffsetVector",
+    "LabwareParentDefinition",
     "LabwareWellId",
     "GripSpecs",
     # Liquids
@@ -286,7 +286,6 @@ __all__ = [
     "CurrentWell",
     "CurrentPipetteLocation",
     "InstrumentOffsetVector",
-    "GripperMoveType",
     # Liquid level detection types
     "LoadedVolumeInfo",
     "ProbedHeightInfo",
@@ -302,7 +301,6 @@ __all__ = [
     "LabwareMovementOffsetData",
     # Tips
     "TipGeometry",
-    "TipRackWellState",
     # Hardware passthrough
     "MovementAxis",
     "MotorAxis",
@@ -311,8 +309,4 @@ __all__ = [
     "Dimensions",
     # Convenience re-export
     "LabwareUri",
-    # Tasks
-    "Task",
-    "TaskSummary",
-    "FinishedTask",
 ]