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

opentrons/protocol_api/core/engine/module_core.py

@@ -51,6 +51,7 @@ from ..module import (
 from .exceptions import InvalidMagnetEngageHeightError
 
 from .labware import LabwareCore
+from .tasks import EngineTaskCore
 from . import load_labware_params
 
 if TYPE_CHECKING:
@@ -175,13 +176,17 @@ class TemperatureModuleCore(ModuleCore, AbstractTemperatureModuleCore[LabwareCor
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.TempDeck]
 
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> EngineTaskCore:
         """Set the Temperature Module's target temperature in °C."""
-        self._engine_client.execute_command(
+        result = self._engine_client.execute_command_without_recovery(
             cmd.temperature_module.SetTargetTemperatureParams(
                 moduleId=self.module_id, celsius=celsius
             )
         )
+        temperature_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return temperature_task
 
     def wait_for_target_temperature(self, celsius: Optional[float] = None) -> None:
         """Wait until the module's target temperature is reached.
@@ -317,18 +322,24 @@ 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:
+    ) -> EngineTaskCore:
         """Set the target temperature for the well block, in °C."""
-        self._engine_client.execute_command(
+        result = self._engine_client.execute_command_without_recovery(
             cmd.thermocycler.SetTargetBlockTemperatureParams(
                 moduleId=self.module_id,
                 celsius=celsius,
                 blockMaxVolumeUl=block_max_volume,
                 holdTimeSeconds=hold_time_seconds,
+                ramp_rate=ramp_rate,
             )
         )
+        block_temperature_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return block_temperature_task
 
     def wait_for_block_temperature(self) -> None:
         """Wait for target block temperature to be reached."""
@@ -336,13 +347,17 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
             cmd.thermocycler.WaitForBlockTemperatureParams(moduleId=self.module_id)
         )
 
-    def set_target_lid_temperature(self, celsius: float) -> None:
+    def set_target_lid_temperature(self, celsius: float) -> EngineTaskCore:
         """Set the target temperature for the heated lid, in °C."""
-        self._engine_client.execute_command(
+        result = self._engine_client.execute_command_without_recovery(
             cmd.thermocycler.SetTargetLidTemperatureParams(
                 moduleId=self.module_id, celsius=celsius
             )
         )
+        lid_temperature_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return lid_temperature_task
 
     def wait_for_lid_temperature(self) -> None:
         """Wait for target lid temperature to be reached."""
@@ -361,6 +376,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 +405,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
                 ],
@@ -416,6 +433,42 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
         else:
             return self._execute_profile_pre_221(steps, repetitions, block_max_volume)
 
+    def start_execute_profile(
+        self,
+        steps: List[ThermocyclerStep],
+        repetitions: int,
+        block_max_volume: Optional[float] = None,
+    ) -> EngineTaskCore:
+        """Start the execution of a hermocycler profile and return a task."""
+        self._repetitions = repetitions
+        self._step_count = len(steps)
+        engine_steps: List[
+            Union[cmd.thermocycler.ProfileStep, cmd.thermocycler.ProfileCycle]
+        ] = [
+            cmd.thermocycler.ProfileCycle(
+                repetitions=repetitions,
+                steps=[
+                    cmd.thermocycler.ProfileStep(
+                        celsius=step["temperature"],
+                        holdSeconds=step["hold_time_seconds"],
+                        rampRate=step["ramp_rate"],
+                    )
+                    for step in steps
+                ],
+            )
+        ]
+        result = self._engine_client.execute_command_without_recovery(
+            cmd.thermocycler.StartRunExtendedProfileParams(
+                moduleId=self.module_id,
+                profileElements=engine_steps,
+                blockMaxVolumeUl=block_max_volume,
+            )
+        )
+        start_execute_profile_result = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return start_execute_profile_result
+
     def deactivate_lid(self) -> None:
         """Turn off the heated lid."""
         self._engine_client.execute_command(
@@ -507,13 +560,17 @@ class HeaterShakerModuleCore(ModuleCore, AbstractHeaterShakerCore[LabwareCore]):
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.HeaterShaker]
 
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> EngineTaskCore:
         """Set the labware plate's target temperature in °C."""
-        self._engine_client.execute_command(
+        result = self._engine_client.execute_command_without_recovery(
             cmd.heater_shaker.SetTargetTemperatureParams(
                 moduleId=self.module_id, celsius=celsius
             )
         )
+        temperature_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return temperature_task
 
     def wait_for_target_temperature(self) -> None:
         """Wait for the labware plate's target temperature to be reached."""
@@ -529,6 +586,16 @@ class HeaterShakerModuleCore(ModuleCore, AbstractHeaterShakerCore[LabwareCore]):
             )
         )
 
+    def set_shake_speed(self, rpm: int) -> EngineTaskCore:
+        """Set the shaker's target shake speed and wait for it to spin up."""
+        result = self._engine_client.execute_command_without_recovery(
+            cmd.heater_shaker.SetShakeSpeedParams(moduleId=self.module_id, rpm=rpm)
+        )
+        shake_task = EngineTaskCore(
+            engine_client=self._engine_client, task_id=result.taskId
+        )
+        return shake_task
+
     def open_labware_latch(self) -> None:
         """Open the labware latch."""
         self._engine_client.execute_command(

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.
@@ -912,6 +914,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_ids = [task._id for task in task_cores if task._id is not None]
+        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,48 @@
+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 | None, engine_client: ProtocolEngineClient
+    ) -> None:
+        self._id = task_id
+        self._engine_client = engine_client
+
+    def get_created_at_timestamp(self) -> datetime:
+        if self._id is None:
+            raise NoTaskFoundError
+        try:
+            task = self._engine_client.state.tasks.get(self._id)
+            return task.createdAt
+        except NoTaskFoundError:
+            raise NoTaskFoundError
+
+    def is_done(self) -> bool:
+        if self._id is None:
+            raise NoTaskFoundError
+        try:
+            self._engine_client.state.tasks.get_finished(self._id)
+            return True
+        except NoTaskFoundError:
+            return False
+
+    def is_started(self) -> bool:
+        if self._id is None:
+            raise NoTaskFoundError
+        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:
+        if self._id is None:
+            raise NoTaskFoundError
+        try:
+            finished_task = self._engine_client.state.tasks.get_finished(self._id)
+            return finished_task.finishedAt
+        except NoTaskFoundError:
+            return None

opentrons/protocol_api/core/engine/well.py

@@ -216,6 +216,14 @@ class WellCore(AbstractWellCore):
             labware_id=labware_id, well_name=well_name
         )
 
+    def has_tracked_liquid(self) -> bool:
+        """Return true if liquid has been loaded or probed."""
+        labware_id = self.labware_id
+        well_name = self._name
+        return self._engine_client.state.geometry.well_has_tracked_liquid(
+            labware_id=labware_id, well_name=well_name
+        )
+
     def get_liquid_volume(self) -> LiquidTrackingType:
         """Return the current volume in a well."""
         labware_id = self.labware_id

opentrons/protocol_api/core/legacy/legacy_module_core.py

@@ -31,6 +31,7 @@ from ..module import (
 )
 
 from .legacy_labware_core import LegacyLabwareCore
+from .tasks import LegacyTaskCore
 from .module_geometry import ModuleGeometry, ThermocyclerGeometry, HeaterShakerGeometry
 from ...labware import Labware
 
@@ -116,9 +117,10 @@ class LegacyTemperatureModuleCore(
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.TempDeck]
 
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> LegacyTaskCore:
         """Set the Temperature Module's target temperature in °C."""
         self._sync_module_hardware.start_set_temperature(celsius)
+        return LegacyTaskCore()
 
     def wait_for_target_temperature(self, celsius: Optional[float] = None) -> None:
         """Wait until the module's target temperature is reached.
@@ -263,23 +265,27 @@ class LegacyThermocyclerCore(
     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:
+    ) -> LegacyTaskCore:
         """Set the target temperature for the well block, in °C."""
         self._sync_module_hardware.set_target_block_temperature(
             celsius=celsius,
             hold_time_seconds=hold_time_seconds,
             volume=block_max_volume,
+            ramp_rate=ramp_rate,
         )
+        return LegacyTaskCore()
 
     def wait_for_block_temperature(self) -> None:
         """Wait for target block temperature to be reached."""
         self._sync_module_hardware.wait_for_block_target()
 
-    def set_target_lid_temperature(self, celsius: float) -> None:
+    def set_target_lid_temperature(self, celsius: float) -> LegacyTaskCore:
         """Set the target temperature for the heated lid, in °C."""
         self._sync_module_hardware.set_target_lid_temperature(celsius=celsius)
+        return LegacyTaskCore()
 
     def wait_for_lid_temperature(self) -> None:
         """Wait for target lid temperature to be reached."""
@@ -296,6 +302,15 @@ class LegacyThermocyclerCore(
             steps=steps, repetitions=repetitions, volume=block_max_volume
         )
 
+    def start_execute_profile(
+        self,
+        steps: List[ThermocyclerStep],
+        repetitions: int,
+        block_max_volume: Optional[float] = None,
+    ) -> LegacyTaskCore:
+        """Start a Thermocycler Profile."""
+        assert False, "start_execute_profile only supported on engine core"
+
     def deactivate_lid(self) -> None:
         """Turn off the heated lid."""
         self._sync_module_hardware.deactivate_lid()
@@ -413,9 +428,10 @@ class LegacyHeaterShakerCore(
     _sync_module_hardware: SynchronousAdapter[hw_modules.HeaterShaker]
     _geometry: HeaterShakerGeometry
 
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> LegacyTaskCore:
         """Set the labware plate's target temperature in °C."""
         self._sync_module_hardware.start_set_temperature(celsius)
+        return LegacyTaskCore()
 
     def wait_for_target_temperature(self) -> None:
         """Wait for the labware plate's target temperature to be reached."""
@@ -442,6 +458,10 @@ class LegacyHeaterShakerCore(
                 "Cannot start shaking unless labware latch is closed."
             )
 
+    def set_shake_speed(self, rpm: int) -> LegacyTaskCore:
+        """Set heatershaker speed."""
+        assert False, "set_shake_speed only supported on engine core."
+
     def open_labware_latch(self) -> None:
         """Open the labware latch."""
         if self.get_speed_status() != SpeedStatus.IDLE:

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, List, Optional, Set, Union, cast, Tuple
+from typing import Dict, List, Optional, Set, Union, cast, Tuple, Sequence
 
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.labware.types import LabwareDefinition
@@ -34,6 +34,7 @@ from .legacy_instrument_core import LegacyInstrumentCore
 from .labware_offset_provider import AbstractLabwareOffsetProvider
 from .legacy_labware_core import LegacyLabwareCore
 from .load_info import LoadInfo, InstrumentLoadInfo, LabwareLoadInfo, ModuleLoadInfo
+from .tasks import LegacyTaskCore
 
 logger = logging.getLogger(__name__)
 
@@ -43,6 +44,7 @@ class LegacyProtocolCore(
         LegacyInstrumentCore,
         LegacyLabwareCore,
         legacy_module_core.LegacyModuleCore,
+        LegacyTaskCore,
     ]
 ):
     def __init__(
@@ -610,3 +612,11 @@ class LegacyProtocolCore(
     ]:
         """Get labware parent location."""
         assert False, "get_labware_location only supported on engine core"
+
+    def wait_for_tasks(self, task: Sequence[LegacyTaskCore]) -> None:
+        """Wait for list of tasks to complete before executing subsequent commands."""
+        assert False, "wait_for_tasks only supported on engine core"
+
+    def create_timer(self, seconds: float) -> LegacyTaskCore:
+        """Create a timer task that runs in the background."""
+        assert False, "create_timer only supported on engine core"

opentrons/protocol_api/core/legacy/legacy_well_core.py

@@ -151,6 +151,10 @@ class LegacyWellCore(AbstractWellCore):
         """Return the volume contained in a well at any height."""
         return 0.0
 
+    def has_tracked_liquid(self) -> bool:
+        """Return true if liquid has been loaded or probed."""
+        return False
+
     # TODO(mc, 2022-10-28): is this used and/or necessary?
     def __repr__(self) -> str:
         """Use the well's display name as its repr."""

opentrons/protocol_api/core/legacy/tasks.py

@@ -0,0 +1,19 @@
+from ..tasks import AbstractTaskCore
+from datetime import datetime
+
+
+class LegacyTaskCore(AbstractTaskCore):
+    def __init__(self) -> None:
+        pass
+
+    def get_created_at_timestamp(self) -> datetime:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def is_done(self) -> bool:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def is_started(self) -> bool:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def get_finished_at_timestamp(self) -> datetime | None:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")

opentrons/protocol_api/core/legacy_simulator/legacy_protocol_core.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Optional
+from typing import Dict, Optional, Sequence
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 from opentrons_shared_data.pipette.pipette_load_name_conversions import (
@@ -16,6 +16,7 @@ from ..legacy.legacy_module_core import LegacyModuleCore
 from ..legacy.load_info import InstrumentLoadInfo
 
 from .legacy_instrument_core import LegacyInstrumentCoreSimulator
+from .tasks import LegacyTaskCore
 
 logger = logging.getLogger(__name__)
 
@@ -23,7 +24,10 @@ logger = logging.getLogger(__name__)
 class LegacyProtocolCoreSimulator(
     LegacyProtocolCore,
     AbstractProtocol[
-        LegacyInstrumentCoreSimulator, LegacyLabwareCore, LegacyModuleCore
+        LegacyInstrumentCoreSimulator,
+        LegacyLabwareCore,
+        LegacyModuleCore,
+        LegacyTaskCore,
     ],
 ):
     _instruments: Dict[Mount, Optional[LegacyInstrumentCoreSimulator]]  # type: ignore[assignment]
@@ -83,3 +87,11 @@ class LegacyProtocolCoreSimulator(
         )
 
         return new_instr
+
+        def wait_for_tasks(self, task: Sequence[LegacyTaskCore]) -> None:
+            """Wait for list of tasks to complete before executing subsequent commands."""
+            assert False, "wait_for_tasks only supported on engine core"
+
+        def create_timer(self, seconds: float) -> LegacyTaskCore:
+            """Create a timer task that runs in the background."""
+            assert False, "create_timer only supported on engine core"

opentrons/protocol_api/core/legacy_simulator/tasks.py

@@ -0,0 +1,19 @@
+from ..tasks import AbstractTaskCore
+from datetime import datetime
+
+
+class LegacyTaskCore(AbstractTaskCore):
+    def __init__(self, created_at: datetime) -> None:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def get_created_at_timestamp(self) -> datetime:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def is_done(self) -> bool:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def is_started(self) -> bool:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")
+
+    def get_finished_at_timestamp(self) -> datetime | None:
+        raise NotImplementedError("Legacy protocols do not implement tasks.")

opentrons/protocol_api/core/module.py

@@ -18,6 +18,7 @@ from opentrons.hardware_control.modules.types import (
     SpeedStatus,
 )
 from .labware import LabwareCoreType, AbstractLabware
+from .tasks import AbstractTaskCore
 from opentrons.protocol_engine.types import ABSMeasureMode
 from opentrons.types import DeckSlotName
 
@@ -59,7 +60,7 @@ class AbstractTemperatureModuleCore(
         """Get the module's unique hardware serial number."""
 
     @abstractmethod
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> AbstractTaskCore:
         """Set the Temperature Module's target temperature in °C."""
 
     @abstractmethod
@@ -161,9 +162,10 @@ class AbstractThermocyclerCore(
     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:
+    ) -> AbstractTaskCore:
         """Set the target temperature for the well block, in °C.
 
         Note:
@@ -183,7 +185,7 @@ class AbstractThermocyclerCore(
         """Wait for target block temperature to be reached."""
 
     @abstractmethod
-    def set_target_lid_temperature(self, celsius: float) -> None:
+    def set_target_lid_temperature(self, celsius: float) -> AbstractTaskCore:
         """Set the target temperature for the heated lid, in °C."""
 
     @abstractmethod
@@ -217,6 +219,33 @@ class AbstractThermocyclerCore(
                 will default to 25µL/well.
         """
 
+    @abstractmethod
+    def start_execute_profile(
+        self,
+        steps: List[ThermocyclerStep],
+        repetitions: int,
+        block_max_volume: Optional[float] = None,
+    ) -> AbstractTaskCore:
+        """Start a Thermocycler Profile.
+
+        Profile defined as a cycle of ``steps`` to repeat for a given number of ``repetitions``
+
+        Note:
+            Unlike the :py:meth:`execute_profile`, once the profile has started
+            the protocol will immediately move on to the next command, rather than waiting
+            for it to finish.
+        Args:
+            steps: List of unique steps that make up a single cycle.
+                Each list item should be a dictionary that maps to
+                the parameters of the :py:meth:`set_block_temperature`
+                method with keys 'temperature', 'hold_time_seconds',
+                and 'hold_time_minutes'.
+            repetitions: The number of times to repeat the cycled steps.
+            block_max_volume: The maximum volume of any individual well
+                of the loaded labware. If not supplied, the thermocycler
+                will default to 25µL/well.
+        """
+
     @abstractmethod
     def deactivate_lid(self) -> None:
         """Turn off the heated lid."""
@@ -294,7 +323,7 @@ class AbstractHeaterShakerCore(
         """Get the module's unique hardware serial number."""
 
     @abstractmethod
-    def set_target_temperature(self, celsius: float) -> None:
+    def set_target_temperature(self, celsius: float) -> AbstractTaskCore:
         """Set the labware plate's target temperature in °C."""
 
     @abstractmethod
@@ -305,6 +334,10 @@ class AbstractHeaterShakerCore(
     def set_and_wait_for_shake_speed(self, rpm: int) -> None:
         """Set the shaker's target shake speed and wait for it to spin up."""
 
+    @abstractmethod
+    def set_shake_speed(self, rpm: int) -> AbstractTaskCore:
+        """Set the shaker's target shake speed."""
+
     @abstractmethod
     def open_labware_latch(self) -> None:
         """Open the labware latch."""

opentrons/protocol_api/core/protocol.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
-from typing import Generic, List, Optional, Union, Tuple, Dict, TYPE_CHECKING
+from typing import Generic, List, Optional, Union, Tuple, Dict, TYPE_CHECKING, Sequence
 
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.pipette.types import PipetteNameType
@@ -24,6 +24,7 @@ from opentrons.protocols.api_support.util import AxisMaxSpeeds
 from .instrument import InstrumentCoreType
 from .labware import LabwareCoreType, LabwareLoadParams
 from .module import ModuleCoreType
+from .tasks import TaskCoreType
 from .._liquid import Liquid, LiquidClass
 from .robot import AbstractRobot
 from .._types import OffDeckType
@@ -34,7 +35,7 @@ if TYPE_CHECKING:
 
 
 class AbstractProtocol(
-    ABC, Generic[InstrumentCoreType, LabwareCoreType, ModuleCoreType]
+    ABC, Generic[InstrumentCoreType, LabwareCoreType, ModuleCoreType, TaskCoreType]
 ):
     @property
     @abstractmethod
@@ -192,6 +193,14 @@ class AbstractProtocol(
     def delay(self, seconds: float, msg: Optional[str]) -> None:
         ...
 
+    @abstractmethod
+    def wait_for_tasks(self, task_cores: Sequence[TaskCoreType]) -> None:
+        ...
+
+    @abstractmethod
+    def create_timer(self, seconds: float) -> TaskCoreType:
+        ...
+
     @abstractmethod
     def home(self) -> None:
         ...

opentrons/protocol_api/core/tasks.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod, ABC
+from datetime import datetime
+from typing import TypeVar
+
+
+class AbstractTaskCore(ABC):
+    @abstractmethod
+    def get_created_at_timestamp(self) -> datetime:
+        """Get the createdAt timestamp of the task."""
+        ...
+
+    @abstractmethod
+    def is_done(self) -> bool:
+        """Returns ``True`` if the task is done."""
+        ...
+
+    @abstractmethod
+    def is_started(self) -> bool:
+        """Returns ``True`` if the task has started."""
+        ...
+
+    @abstractmethod
+    def get_finished_at_timestamp(self) -> datetime | None:
+        """The timestamp of the when the task finished.
+
+        Returns ``None`` if the task hasn't finished yet.
+        """
+        ...
+
+
+TaskCoreType = TypeVar("TaskCoreType", bound=AbstractTaskCore)

opentrons/protocol_api/core/well.py

@@ -112,5 +112,9 @@ class AbstractWellCore(ABC):
     def volume_from_height(self, height: LiquidTrackingType) -> LiquidTrackingType:
         """Return the volume contained in a well at any height."""
 
+    @abstractmethod
+    def has_tracked_liquid(self) -> bool:
+        """Return true if liquid has been loaded or probed."""
+
 
 WellCoreType = TypeVar("WellCoreType", bound=AbstractWellCore)