opentrons 8.7.0a0__py3-none-any.whl → 8.7.0a2__py3-none-any.whl

opentrons/hardware_control/types.py

@@ -2,12 +2,26 @@ from asyncio import Queue
 import enum
 import logging
 from dataclasses import dataclass
-from typing import cast, Tuple, Union, List, Callable, Dict, TypeVar, Type
+from typing import (
+    cast,
+    Tuple,
+    Union,
+    List,
+    Callable,
+    Dict,
+    TypeVar,
+    Type,
+    TYPE_CHECKING,
+)
 from typing_extensions import Literal
 from opentrons import types as top_types
 from opentrons_shared_data.pipette.types import PipetteChannelType
+from opentrons_shared_data.errors.exceptions import EnumeratedError
 from opentrons.config import feature_flags
 
+if TYPE_CHECKING:
+    from .modules.types import ModuleModel
+
 MODULE_LOG = logging.getLogger(__name__)
 
 
@@ -384,6 +398,7 @@ class HardwareEventType(enum.Enum):
     DOOR_SWITCH_CHANGE = enum.auto()
     ERROR_MESSAGE = enum.auto()
     ESTOP_CHANGE = enum.auto()
+    ASYNCHRONOUS_MODULE_ERROR = enum.auto()
 
 
 @dataclass
@@ -428,10 +443,24 @@ class ErrorMessageNotification:
     event: Literal[HardwareEventType.ERROR_MESSAGE] = HardwareEventType.ERROR_MESSAGE
 
 
+@dataclass(frozen=True)
+class AsynchronousModuleErrorNotification:
+    exception: EnumeratedError
+    module_serial: str | None
+    module_model: "ModuleModel"
+    port: str
+    event: Literal[
+        HardwareEventType.ASYNCHRONOUS_MODULE_ERROR
+    ] = HardwareEventType.ASYNCHRONOUS_MODULE_ERROR
+
+
 # new event types get new dataclasses
 # when we add more event types we add them here
 HardwareEvent = Union[
-    DoorStateNotification, ErrorMessageNotification, EstopStateNotification
+    DoorStateNotification,
+    ErrorMessageNotification,
+    EstopStateNotification,
+    AsynchronousModuleErrorNotification,
 ]
 
 HardwareEventHandler = Callable[[HardwareEvent], None]

opentrons/legacy_commands/protocol_commands.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 from . import types as command_types
+from opentrons.protocol_api.tasks import Task
 
 
 def comment(msg: str) -> command_types.CommentCommand:
@@ -52,3 +53,22 @@ def move_labware(text: str) -> command_types.MoveLabwareCommand:
         "name": command_types.MOVE_LABWARE,
         "payload": {"text": text},
     }
+
+
+def wait_for_tasks(tasks: list[Task]) -> command_types.WaitForTasksCommand:
+    task_ids = [task.created_at.strftime("%Y-%m-%d %H:%M:%S") for task in tasks]
+    msg = f"Waiting for tasks that started at: {task_ids}."
+    return {
+        "name": command_types.WAIT_FOR_TASKS,
+        "payload": {"text": msg},
+    }
+
+
+def create_timer(seconds: float) -> command_types.CreateTimerCommand:
+    return {
+        "name": command_types.CREATE_TIMER,
+        "payload": {
+            "text": f"Creating background timer for {seconds} seconds.",
+            "time": seconds,
+        },
+    }

opentrons/legacy_commands/types.py

@@ -102,6 +102,10 @@ ROBOT_MOVE_RELATIVE_TO: Final = "command.ROBOT_MOVE_RELATIVE_TO"
 ROBOT_OPEN_GRIPPER_JAW: Final = "command.ROBOT_OPEN_GRIPPER_JAW"
 ROBOT_CLOSE_GRIPPER_JAW: Final = "command.ROBOT_CLOSE_GRIPPER_JAW"
 
+# Tasks #
+WAIT_FOR_TASKS: Final = "command.WAIT_FOR_TASKS"
+CREATE_TIMER: Final = "command.CREATE_TIMER"
+
 
 class TextOnlyPayload(TypedDict):
     text: str
@@ -714,6 +718,27 @@ class RobotCloseGripperJawCommand(TypedDict):
     payload: GripperCommandPayload
 
 
+# Task Commands and Payloads
+
+
+class WaitForTasksPayload(TextOnlyPayload):
+    pass
+
+
+class CreateTimerPayload(TextOnlyPayload):
+    time: float
+
+
+class WaitForTasksCommand(TypedDict):
+    name: Literal["command.WAIT_FOR_TASKS"]
+    payload: WaitForTasksPayload
+
+
+class CreateTimerCommand(TypedDict):
+    name: Literal["command.CREATE_TIMER"]
+    payload: CreateTimerPayload
+
+
 Command = Union[
     DropTipCommand,
     DropTipInDisposalLocationCommand,
@@ -782,6 +807,9 @@ Command = Union[
     FlexStackerStoreCommand,
     FlexStackerEmptyCommand,
     FlexStackerFillCommand,
+    # Task commands
+    WaitForTasksCommand,
+    CreateTimerCommand,
 ]
 
 
@@ -842,6 +870,9 @@ CommandPayload = Union[
     RobotMoveAxisRelativeCommandPayload,
     RobotMoveAxisToCommandPayload,
     GripperCommandPayload,
+    # Task payloads
+    WaitForTasksPayload,
+    CreateTimerPayload,
 ]
 
 
@@ -1124,6 +1155,14 @@ class RobotCloseGripperJawMessage(CommandMessageFields, RobotCloseGripperJawComm
     pass
 
 
+class WaitForTasksMessage(CommandMessageFields, WaitForTasksCommand):
+    pass
+
+
+class CreateTimerMessage(CommandMessageFields, CreateTimerCommand):
+    pass
+
+
 CommandMessage = Union[
     DropTipMessage,
     DropTipInDisposalLocationMessage,
@@ -1183,4 +1222,7 @@ CommandMessage = Union[
     FlexStackerStoreMessage,
     FlexStackerEmptyMessage,
     FlexStackerFillMessage,
+    # Task Messages
+    WaitForTasksMessage,
+    CreateTimerMessage,
 ]

opentrons/motion_planning/waypoints.py

@@ -7,7 +7,6 @@ from opentrons.hardware_control.types import CriticalPoint
 
 from .types import Waypoint, MoveType, GripperMovementWaypointsWithJawStatus
 from .errors import DestinationOutOfBoundsError, ArcOutOfBoundsError
-from ..protocol_engine.types import LabwareMovementOffsetData
 
 DEFAULT_GENERAL_ARC_Z_MARGIN: Final[float] = 10.0
 DEFAULT_IN_LABWARE_ARC_Z_MARGIN: Final[float] = 5.0
@@ -125,47 +124,41 @@ def get_gripper_labware_movement_waypoints(
     from_labware_center: Point,
     to_labware_center: Point,
     gripper_home_z: float,
-    offset_data: LabwareMovementOffsetData,
     post_drop_slide_offset: Optional[Point],
     gripper_home_z_offset: Optional[float] = None,
 ) -> List[GripperMovementWaypointsWithJawStatus]:
     """Get waypoints for moving labware using a gripper."""
-    pick_up_offset = offset_data.pickUpOffset
-    drop_offset = offset_data.dropOffset
-
-    pick_up_location = from_labware_center + Point(
-        pick_up_offset.x, pick_up_offset.y, pick_up_offset.z
-    )
-    drop_location = to_labware_center + Point(
-        drop_offset.x, drop_offset.y, drop_offset.z
-    )
-
     gripper_max_z_home = gripper_home_z - (gripper_home_z_offset or 0)
-
-    post_drop_home_pos = Point(drop_location.x, drop_location.y, gripper_home_z)
+    post_drop_home_pos = Point(to_labware_center.x, to_labware_center.y, gripper_home_z)
 
     waypoints_with_jaw_status = [
         GripperMovementWaypointsWithJawStatus(
-            position=Point(pick_up_location.x, pick_up_location.y, gripper_home_z),
+            position=Point(
+                from_labware_center.x, from_labware_center.y, gripper_home_z
+            ),
             jaw_open=False,
             dropping=False,
         ),
         GripperMovementWaypointsWithJawStatus(
-            position=pick_up_location, jaw_open=True, dropping=False
+            position=from_labware_center, jaw_open=True, dropping=False
         ),
         # Gripper grips the labware here
         GripperMovementWaypointsWithJawStatus(
-            position=Point(pick_up_location.x, pick_up_location.y, gripper_max_z_home),
+            position=Point(
+                from_labware_center.x, from_labware_center.y, gripper_max_z_home
+            ),
             jaw_open=False,
             dropping=False,
         ),
         GripperMovementWaypointsWithJawStatus(
-            position=Point(drop_location.x, drop_location.y, gripper_max_z_home),
+            position=Point(
+                to_labware_center.x, to_labware_center.y, gripper_max_z_home
+            ),
             jaw_open=False,
             dropping=False,
         ),
         GripperMovementWaypointsWithJawStatus(
-            position=drop_location, jaw_open=False, dropping=False
+            position=to_labware_center, jaw_open=False, dropping=False
         ),
         # Gripper ungrips here
         GripperMovementWaypointsWithJawStatus(
@@ -189,25 +182,18 @@ def get_gripper_labware_movement_waypoints(
 def get_gripper_labware_placement_waypoints(
     to_labware_center: Point,
     gripper_home_z: float,
-    drop_offset: Optional[Point],
 ) -> List[GripperMovementWaypointsWithJawStatus]:
     """Get waypoints for placing labware using a gripper."""
-    drop_offset = drop_offset or Point()
-
-    drop_location = to_labware_center + Point(
-        drop_offset.x, drop_offset.y, drop_offset.z
-    )
-
-    post_drop_home_pos = Point(drop_location.x, drop_location.y, gripper_home_z)
+    post_drop_home_pos = Point(to_labware_center.x, to_labware_center.y, gripper_home_z)
 
     return [
         GripperMovementWaypointsWithJawStatus(
-            position=Point(drop_location.x, drop_location.y, gripper_home_z),
+            position=Point(to_labware_center.x, to_labware_center.y, gripper_home_z),
             jaw_open=False,
             dropping=False,
         ),
         GripperMovementWaypointsWithJawStatus(
-            position=drop_location, jaw_open=False, dropping=False
+            position=to_labware_center, jaw_open=False, dropping=False
         ),
         # Gripper ungrips here
         GripperMovementWaypointsWithJawStatus(

opentrons/protocol_api/__init__.py

@@ -30,9 +30,11 @@ from .module_contexts import (
     AbsorbanceReaderContext,
     FlexStackerContext,
 )
+from .tasks import Task
 from .disposal_locations import TrashBin, WasteChute
 from ._liquid import Liquid, LiquidClass
 from ._types import (
+    OffDeckType,
     OFF_DECK,
     PLUNGER_BLOWOUT,
     PLUNGER_TOP,
@@ -88,6 +90,7 @@ __all__ = [
     "ROW",
     "ALL",
     # Deck location types
+    "OffDeckType",
     "OFF_DECK",
     # Pipette plunger types
     "PLUNGER_BLOWOUT",
@@ -99,6 +102,8 @@ __all__ = [
     "BLOWOUT_ACTION",
     "RuntimeParameterRequiredError",
     "CSVParameter",
+    # Concurrent task types
+    "Task",
     # For internal Opentrons use only:
     "create_protocol_context",
     "ProtocolEngineCoreRequiredError",

opentrons/protocol_api/_types.py

@@ -3,8 +3,13 @@ from typing_extensions import Final
 import enum
 
 
-# TODO (tz, 5-18-23): think about a better name for it that would also work when we include staging area slots in the type.
+# Implemented with an enum to support type narrowing via `== OFF_DECK`.
 class OffDeckType(enum.Enum):
+    """The type of the :py:obj:`OFF_DECK` constant.
+
+    Do not use directly, except in type annotations and ``isinstance`` calls.
+    """
+
     OFF_DECK = "off-deck"
 
 

opentrons/protocol_api/core/common.py

@@ -16,6 +16,7 @@ from .module import (
 from .protocol import AbstractProtocol
 from .well import AbstractWellCore
 from .robot import AbstractRobot
+from .tasks import AbstractTaskCore
 
 
 WellCore = AbstractWellCore
@@ -30,4 +31,5 @@ MagneticBlockCore = AbstractMagneticBlockCore[LabwareCore]
 AbsorbanceReaderCore = AbstractAbsorbanceReaderCore[LabwareCore]
 FlexStackerCore = AbstractFlexStackerCore[LabwareCore]
 RobotCore = AbstractRobot
-ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore]
+TaskCore = AbstractTaskCore
+ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore, TaskCore]

opentrons/protocol_api/core/engine/_default_labware_versions.py

@@ -112,6 +112,37 @@ DEFAULT_LABWARE_VERSIONS: DefaultLabwareVersions = {
         "thermoscientificnunc_96_wellplate_2000ul": 3,
         "usascientific_96_wellplate_2.4ml_deep": 3,
     },
+    APIVersion(2, 27): {
+        "agilent_1_reservoir_290ml": 4,
+        "axygen_1_reservoir_90ml": 3,
+        "biorad_96_wellplate_200ul_pcr": 5,
+        "corning_12_wellplate_6.9ml_flat": 5,
+        "corning_24_wellplate_3.4ml_flat": 5,
+        "corning_384_wellplate_112ul_flat": 5,
+        "corning_48_wellplate_1.6ml_flat": 6,
+        "corning_6_wellplate_16.8ml_flat": 5,
+        "corning_96_wellplate_360ul_flat": 5,
+        "nest_12_reservoir_15ml": 3,
+        "nest_1_reservoir_195ml": 4,
+        "nest_1_reservoir_290ml": 4,
+        "nest_96_wellplate_100ul_pcr_full_skirt": 5,
+        "nest_96_wellplate_200ul_flat": 5,
+        "nest_96_wellplate_2ml_deep": 5,
+        "opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical": 3,
+        "opentrons_15_tuberack_falcon_15ml_conical": 3,
+        "opentrons_24_aluminumblock_nest_0.5ml_screwcap": 4,
+        "opentrons_24_aluminumblock_nest_1.5ml_screwcap": 3,
+        "opentrons_24_aluminumblock_nest_1.5ml_snapcap": 3,
+        "opentrons_24_aluminumblock_nest_2ml_screwcap": 3,
+        "opentrons_24_aluminumblock_nest_2ml_snapcap": 3,
+        "opentrons_24_tuberack_eppendorf_1.5ml_safelock_snapcap": 3,
+        "opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap": 3,
+        "opentrons_24_tuberack_nest_0.5ml_screwcap": 4,
+        "opentrons_6_tuberack_nest_50ml_conical": 3,
+        "opentrons_96_aluminumblock_generic_pcr_strip_200ul": 4,
+        "usascientific_12_reservoir_22ml": 4,
+        "usascientific_96_wellplate_2.4ml_deep": 4,
+    },
 }
 
 
@@ -139,17 +170,7 @@ KNOWN_EXCEPTIONS_FOR_TESTS: set[str] = {
     "schema3test_flex_tiprack_lid",
     "schema3test_tough_pcr_auto_sealing_lid",
     "schema3test_universal_flat_adapter",
-    # These were supposed to be short-lived drafts as part of of a one-two punch of
-    # https://github.com/Opentrons/opentrons/pull/18266 + https://github.com/Opentrons/opentrons/pull/18284,
-    # but the second punch took a while. We should merge the second punch after v8.6.0
-    # and remove these exceptions as part of that.
-    "agilent_1_reservoir_290ml",
-    "corning_384_wellplate_112ul_flat",
-    "nest_1_reservoir_290ml",
-    "opentrons_24_aluminumblock_nest_0.5ml_screwcap",
-    "opentrons_24_tuberack_nest_0.5ml_screwcap",
-    "opentrons_96_aluminumblock_generic_pcr_strip_200ul",
-    "usascientific_12_reservoir_22ml",
+    "schema3test_96_wellplate_360ul_flat",
 }
 
 

opentrons/protocol_api/core/engine/_default_liquid_class_versions.py

@@ -28,6 +28,8 @@ DefaultLiquidClassVersions: TypeAlias = dict[APIVersion, dict[str, int]]
 # [any]            [anything else]   1
 DEFAULT_LIQUID_CLASS_VERSIONS: DefaultLiquidClassVersions = {
     APIVersion(2, 26): {
+        "ethanol_80": 2,
+        "glycerol_50": 2,
         "water": 2,
     },
 }

opentrons/protocol_api/core/engine/labware.py

@@ -23,6 +23,7 @@ from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
 from opentrons.protocol_engine.types import (
     LabwareOffsetCreate,
     LabwareOffsetVector,
+    TipRackWellState,
 )
 from opentrons.types import DeckSlotName, NozzleMapInterface, Point, StagingSlotName
 
@@ -165,7 +166,13 @@ class LabwareCore(AbstractLabware[WellCore]):
 
     def reset_tips(self) -> None:
         if self.is_tip_rack():
-            self._engine_client.reset_tips(labware_id=self.labware_id)
+            self._engine_client.execute_command(
+                cmd.SetTipStateParams(
+                    labwareId=self._labware_id,
+                    wellNames=list(self._definition.wells),
+                    tipWellState=TipRackWellState.CLEAN,
+                )
+            )
         else:
             raise TypeError(f"{self.get_display_name()} is not a tip rack.")
 

opentrons/protocol_api/core/engine/module_core.py

@@ -317,6 +317,7 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
     def set_target_block_temperature(
         self,
         celsius: float,
+        ramp_rate: Optional[float],
         hold_time_seconds: Optional[float] = None,
         block_max_volume: Optional[float] = None,
     ) -> None:
@@ -327,6 +328,7 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
                 celsius=celsius,
                 blockMaxVolumeUl=block_max_volume,
                 holdTimeSeconds=hold_time_seconds,
+                ramp_rate=ramp_rate,
             )
         )
 
@@ -361,6 +363,7 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
             cmd.thermocycler.RunProfileStepParams(
                 celsius=step["temperature"],
                 holdSeconds=step["hold_time_seconds"],
+                rampRate=step["ramp_rate"],
             )
             for step in steps
         ]
@@ -389,6 +392,7 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
                     cmd.thermocycler.ProfileStep(
                         celsius=step["temperature"],
                         holdSeconds=step["hold_time_seconds"],
+                        rampRate=step["ramp_rate"],
                     )
                     for step in steps
                 ],

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

@@ -1,7 +1,7 @@
 """ProtocolEngine-based Protocol API core implementation."""
 
 from __future__ import annotations
-from typing import Dict, Optional, Type, Union, List, Tuple, TYPE_CHECKING
+from typing import Dict, Optional, Type, Union, List, Tuple, TYPE_CHECKING, Sequence
 
 from opentrons_shared_data.liquid_classes import LiquidClassDefinitionDoesNotExist
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
@@ -64,6 +64,7 @@ from ...disposal_locations import TrashBin, WasteChute
 from ..protocol import AbstractProtocol
 from ..labware import LabwareLoadParams
 from .labware import LabwareCore
+from .tasks import EngineTaskCore
 from .instrument import InstrumentCore
 from .robot import RobotCore
 from .module_core import (
@@ -95,6 +96,7 @@ class ProtocolCore(
         InstrumentCore,
         LabwareCore,
         Union[ModuleCore, NonConnectedModuleCore],
+        EngineTaskCore,
     ]
 ):
     """Protocol API core using a ProtocolEngine.
@@ -875,6 +877,21 @@ class ProtocolCore(
             cmd.WaitForDurationParams(seconds=seconds, message=msg)
         )
 
+    def wait_for_tasks(self, task_cores: Sequence[EngineTaskCore]) -> None:
+        """Wait for specified tasks to complete."""
+        task_ids = [task._id for task in task_cores]
+        self._engine_client.execute_command(cmd.WaitForTasksParams(task_ids=task_ids))
+
+    def create_timer(self, seconds: float) -> EngineTaskCore:
+        """Create a timer task that runs in the background."""
+        result = self._engine_client.execute_command_without_recovery(
+            cmd.CreateTimerParams(time=seconds)
+        )
+        timer_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.task_id
+        )
+        return timer_task
+
     def home(self) -> None:
         """Move all axes to their home positions."""
         self._engine_client.execute_command(cmd.HomeParams(axes=None))

opentrons/protocol_api/core/engine/tasks.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+from ..tasks import AbstractTaskCore
+from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
+from opentrons.protocol_engine.errors.exceptions import NoTaskFoundError
+
+
+class EngineTaskCore(AbstractTaskCore):
+    def __init__(self, task_id: str, engine_client: ProtocolEngineClient) -> None:
+        self._id = task_id
+        self._engine_client = engine_client
+
+    def get_created_at_timestamp(self) -> datetime:
+        task = self._engine_client.state.tasks.get(self._id)
+        return task.createdAt
+
+    def is_done(self) -> bool:
+        try:
+            self._engine_client.state.tasks.get_finished(self._id)
+            return True
+        except NoTaskFoundError:
+            return False
+
+    def is_started(self) -> bool:
+        try:
+            self._engine_client.state.tasks.get_current(self._id)
+            return True
+        except NoTaskFoundError:
+            return self.is_done()
+
+    def get_finished_at_timestamp(self) -> datetime | None:
+        try:
+            finished_task = self._engine_client.state.tasks.get_finished(self._id)
+            return finished_task.finishedAt
+        except NoTaskFoundError:
+            return None