opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

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
@@ -49,6 +49,7 @@ from opentrons.protocol_engine.types import (
     OFF_DECK_LOCATION,
     SYSTEM_LOCATION,
     LoadableLabwareLocation,
+    WASTE_CHUTE_LOCATION,
     NonStackedLocation,
 )
 from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
@@ -64,6 +65,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 +97,7 @@ class ProtocolCore(
         InstrumentCore,
         LabwareCore,
         Union[ModuleCore, NonConnectedModuleCore],
+        EngineTaskCore,
     ]
 ):
     """Protocol API core using a ProtocolEngine.
@@ -912,6 +915,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))
@@ -1151,9 +1169,38 @@ class ProtocolCore(
             return self._module_cores_by_id[labware_location.moduleId]
         elif isinstance(labware_location, OnLabwareLocation):
             return self._labware_cores_by_id[labware_location.labwareId]
-
+        elif labware_location == WASTE_CHUTE_LOCATION:
+            return OffDeckType.WASTE_CHUTE
         return OffDeckType.OFF_DECK
 
+    def capture_image(
+        self,
+        filename: Optional[str] = None,
+        resolution: Optional[Tuple[int, int]] = None,
+        zoom: Optional[float] = None,
+        contrast: Optional[float] = None,
+        brightness: Optional[float] = None,
+        saturation: Optional[float] = None,
+    ) -> None:
+        """Capture an image using a camera.
+        Args:
+            resolution: Width by height resolution in pixels for the image to be captured with.
+            zoom: Multiplier to use when cropping and scaling a captured image. Scale is 1.0 to 2.0.
+            contrast: The contrast to use when processing an image. Scale is 0% to 100%
+            brightness: The brightness to use when processing an image. Scale is 0% to 100%.
+            saturation: The saturation to use when processing an image. Scale is 0% to 100%.
+        """
+        self._engine_client.execute_command(
+            cmd.CaptureImageParams(
+                fileName=filename,
+                resolution=resolution,
+                zoom=zoom,
+                contrast=contrast,
+                brightness=brightness,
+                saturation=saturation,
+            )
+        )
+
     def _convert_labware_location(
         self,
         location: Union[
@@ -1188,6 +1235,8 @@ class ProtocolCore(
             return ModuleLocation(moduleId=location.module_id)
         elif location is OffDeckType.OFF_DECK:
             return OFF_DECK_LOCATION
+        elif location is OffDeckType.WASTE_CHUTE:
+            return AddressableAreaLocation(addressableAreaName="gripperWasteChute")
         elif isinstance(location, DeckSlotName):
             return DeckSlotLocation(slotName=location)
         elif isinstance(location, StagingSlotName):

opentrons/protocol_api/core/engine/stringify.py

@@ -60,6 +60,8 @@ def _labware_location_string(
         return (
             f"stored in {_module_in_location_string(location.moduleId, engine_client)}"
         )
+    elif location == "wasteChuteLocation":
+        return "in waste chute"
 
 
 def _labware_name(engine_client: SyncClient, labware_id: str) -> str:

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/instrument.py

@@ -48,7 +48,10 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         flow_rate: float,
         in_place: bool,
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -74,7 +77,10 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         in_place: bool,
         push_out: Optional[float],
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Dispense a given volume of liquid into the specified location.
         Args:
@@ -378,6 +384,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCoreType]],
     ) -> None:
         """Transfer a liquid from source to dest according to liquid class properties."""
         ...
@@ -389,12 +396,17 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         volume: float,
         source: Tuple[types.Location, WellCoreType],
         dest: List[Tuple[types.Location, WellCoreType]],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LabwareCoreType]],
         starting_tip: Optional[WellCoreType],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCoreType]],
     ) -> None:
         """
         Distribute a liquid from single source to multiple destinations
@@ -409,12 +421,17 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         volume: float,
         source: List[Tuple[types.Location, WellCoreType]],
         dest: Union[Tuple[types.Location, WellCoreType], TrashBin, WasteChute],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LabwareCoreType]],
         starting_tip: Optional[WellCoreType],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCoreType]],
     ) -> None:
         """
         Consolidate liquid from multiple sources to a single destination

opentrons/protocol_api/core/legacy/legacy_instrument_core.py

@@ -93,7 +93,10 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         flow_rate: float,
         in_place: bool,
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -139,7 +142,10 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         in_place: bool,
         push_out: Optional[float],
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Dispense a given volume of liquid into the specified location.
         Args:
@@ -622,6 +628,7 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23"""
         assert False, "transfer_liquid is not supported in legacy context"
@@ -632,12 +639,17 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         volume: float,
         source: Tuple[types.Location, LegacyWellCore],
         dest: List[Tuple[types.Location, LegacyWellCore]],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23"""
         assert False, "distribute_liquid is not supported in legacy context"
@@ -648,12 +660,17 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         volume: float,
         source: List[Tuple[types.Location, LegacyWellCore]],
         dest: Union[Tuple[types.Location, LegacyWellCore], TrashBin, WasteChute],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23."""
         assert False, "consolidate_liquid is not supported in legacy context"

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,6 +265,7 @@ 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:
@@ -271,6 +274,7 @@ class LegacyThermocyclerCore(
             celsius=celsius,
             hold_time_seconds=hold_time_seconds,
             volume=block_max_volume,
+            ramp_rate=ramp_rate,
         )
 
     def wait_for_block_temperature(self) -> None:
@@ -281,6 +285,19 @@ class LegacyThermocyclerCore(
         """Set the target temperature for the heated lid, in °C."""
         self._sync_module_hardware.set_target_lid_temperature(celsius=celsius)
 
+    def start_set_target_lid_temperature(self, celsius: float) -> LegacyTaskCore:
+        """Set the target temperature for the heated lid, in °C."""
+        assert False, "start_set_target_lid_temperature only supported on engine core"
+
+    def start_set_target_block_temperature(
+        self,
+        celsius: float,
+        ramp_rate: Optional[float],
+        block_max_volume: Optional[float] = None,
+    ) -> LegacyTaskCore:
+        """Set the target temperature for the heated block, in °C."""
+        assert False, "start_set_target_block_temperature only supported on engine core"
+
     def wait_for_lid_temperature(self) -> None:
         """Wait for target lid temperature to be reached."""
         self._sync_module_hardware.wait_for_lid_target()
@@ -296,6 +313,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 +439,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 +469,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,23 @@ class LegacyProtocolCore(
     ]:
         """Get labware parent location."""
         assert False, "get_labware_location only supported on engine core"
+
+    def capture_image(
+        self,
+        filename: Optional[str] = None,
+        resolution: Optional[Tuple[int, int]] = None,
+        zoom: Optional[float] = None,
+        contrast: Optional[float] = None,
+        brightness: Optional[float] = None,
+        saturation: Optional[float] = None,
+    ) -> None:
+        "Capture an image using a camera."
+        assert False, "capture_image 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_instrument_core.py

@@ -106,7 +106,10 @@ class LegacyInstrumentCoreSimulator(
         flow_rate: float,
         in_place: bool,
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         if self.get_current_volume() == 0:
             # Make sure we're at the top of the labware and clear of any
@@ -149,7 +152,10 @@ class LegacyInstrumentCoreSimulator(
         in_place: bool,
         push_out: Optional[float],
         meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
+        end_location: Optional[types.Location] = None,
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         if isinstance(location, (TrashBin, WasteChute)):
             raise APIVersionError(
@@ -536,6 +542,7 @@ class LegacyInstrumentCoreSimulator(
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23."""
         assert False, "transfer_liquid is not supported in legacy context"
@@ -546,12 +553,17 @@ class LegacyInstrumentCoreSimulator(
         volume: float,
         source: Tuple[types.Location, LegacyWellCore],
         dest: List[Tuple[types.Location, LegacyWellCore]],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23."""
         assert False, "distribute_liquid is not supported in legacy context"
@@ -562,12 +574,17 @@ class LegacyInstrumentCoreSimulator(
         volume: float,
         source: List[Tuple[types.Location, LegacyWellCore]],
         dest: Union[Tuple[types.Location, LegacyWellCore], TrashBin, WasteChute],
-        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
+        new_tip: Literal[
+            TransferTipPolicyV2.NEVER,
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.ALWAYS,
+        ],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[LegacyWellCore]],
     ) -> None:
         """This will never be called because it was added in API 2.23."""
         assert False, "consolidate_liquid is not supported in legacy context"

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.")