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

opentrons/protocol_api/__init__.py

@@ -14,7 +14,7 @@ from opentrons.protocols.parameters.exceptions import (
     RuntimeParameterRequired as RuntimeParameterRequiredError,
 )
 from opentrons.protocols.parameters.csv_parameter_interface import CSVParameter
-from .tasks import Task
+
 from .protocol_context import ProtocolContext
 from .deck import Deck
 from .robot_context import RobotContext
@@ -33,7 +33,6 @@ from .module_contexts import (
 from .disposal_locations import TrashBin, WasteChute
 from ._liquid import Liquid, LiquidClass
 from ._types import (
-    OffDeckType,
     OFF_DECK,
     PLUNGER_BLOWOUT,
     PLUNGER_TOP,
@@ -89,7 +88,6 @@ __all__ = [
     "ROW",
     "ALL",
     # Deck location types
-    "OffDeckType",
     "OFF_DECK",
     # Pipette plunger types
     "PLUNGER_BLOWOUT",
@@ -101,8 +99,6 @@ __all__ = [
     "BLOWOUT_ACTION",
     "RuntimeParameterRequiredError",
     "CSVParameter",
-    # Concurrent task types
-    "Task",
     # For internal Opentrons use only:
     "create_protocol_context",
     "ProtocolEngineCoreRequiredError",

opentrons/protocol_api/_types.py

@@ -3,13 +3,8 @@ from typing_extensions import Final
 import enum
 
 
-# Implemented with an enum to support type narrowing via `== OFF_DECK`.
+# 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.
 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,7 +16,6 @@ from .module import (
 from .protocol import AbstractProtocol
 from .well import AbstractWellCore
 from .robot import AbstractRobot
-from .tasks import AbstractTaskCore
 
 
 WellCore = AbstractWellCore
@@ -31,5 +30,4 @@ MagneticBlockCore = AbstractMagneticBlockCore[LabwareCore]
 AbsorbanceReaderCore = AbstractAbsorbanceReaderCore[LabwareCore]
 FlexStackerCore = AbstractFlexStackerCore[LabwareCore]
 RobotCore = AbstractRobot
-TaskCore = AbstractTaskCore
-ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore, TaskCore]
+ProtocolCore = AbstractProtocol[InstrumentCore, LabwareCore, ModuleCore]

opentrons/protocol_api/core/engine/_default_labware_versions.py

@@ -112,37 +112,6 @@ 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,
-    },
 }
 
 
@@ -170,7 +139,17 @@ KNOWN_EXCEPTIONS_FOR_TESTS: set[str] = {
     "schema3test_flex_tiprack_lid",
     "schema3test_tough_pcr_auto_sealing_lid",
     "schema3test_universal_flat_adapter",
-    "schema3test_96_wellplate_360ul_flat",
+    # 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",
 }
 
 

opentrons/protocol_api/core/engine/labware.py

@@ -23,7 +23,6 @@ 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
 
@@ -166,13 +165,7 @@ class LabwareCore(AbstractLabware[WellCore]):
 
     def reset_tips(self) -> None:
         if self.is_tip_rack():
-            self._engine_client.execute_command(
-                cmd.SetTipStateParams(
-                    labwareId=self._labware_id,
-                    wellNames=list(self._definition.wells),
-                    tipWellState=TipRackWellState.CLEAN,
-                )
-            )
+            self._engine_client.reset_tips(labware_id=self.labware_id)
         else:
             raise TypeError(f"{self.get_display_name()} is not a tip rack.")
 

opentrons/protocol_api/core/engine/module_core.py

@@ -51,7 +51,6 @@ from ..module import (
 from .exceptions import InvalidMagnetEngageHeightError
 
 from .labware import LabwareCore
-from .tasks import EngineTaskCore
 from . import load_labware_params
 
 if TYPE_CHECKING:
@@ -176,17 +175,13 @@ class TemperatureModuleCore(ModuleCore, AbstractTemperatureModuleCore[LabwareCor
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.TempDeck]
 
-    def set_target_temperature(self, celsius: float) -> EngineTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """Set the Temperature Module's target temperature in °C."""
-        result = self._engine_client.execute_command_without_recovery(
+        self._engine_client.execute_command(
             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.
@@ -322,24 +317,18 @@ 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,
-    ) -> EngineTaskCore:
+    ) -> None:
         """Set the target temperature for the well block, in °C."""
-        result = self._engine_client.execute_command_without_recovery(
+        self._engine_client.execute_command(
             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."""
@@ -347,17 +336,13 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
             cmd.thermocycler.WaitForBlockTemperatureParams(moduleId=self.module_id)
         )
 
-    def set_target_lid_temperature(self, celsius: float) -> EngineTaskCore:
+    def set_target_lid_temperature(self, celsius: float) -> None:
         """Set the target temperature for the heated lid, in °C."""
-        result = self._engine_client.execute_command_without_recovery(
+        self._engine_client.execute_command(
             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."""
@@ -376,7 +361,6 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
             cmd.thermocycler.RunProfileStepParams(
                 celsius=step["temperature"],
                 holdSeconds=step["hold_time_seconds"],
-                rampRate=step["ramp_rate"],
             )
             for step in steps
         ]
@@ -405,7 +389,6 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
                     cmd.thermocycler.ProfileStep(
                         celsius=step["temperature"],
                         holdSeconds=step["hold_time_seconds"],
-                        rampRate=step["ramp_rate"],
                     )
                     for step in steps
                 ],
@@ -433,42 +416,6 @@ 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(
@@ -560,17 +507,13 @@ class HeaterShakerModuleCore(ModuleCore, AbstractHeaterShakerCore[LabwareCore]):
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.HeaterShaker]
 
-    def set_target_temperature(self, celsius: float) -> EngineTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """Set the labware plate's target temperature in °C."""
-        result = self._engine_client.execute_command_without_recovery(
+        self._engine_client.execute_command(
             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."""
@@ -586,16 +529,6 @@ 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, Sequence
+from typing import Dict, Optional, Type, Union, List, Tuple, TYPE_CHECKING
 
 from opentrons_shared_data.liquid_classes import LiquidClassDefinitionDoesNotExist
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
@@ -64,7 +64,6 @@ 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 (
@@ -96,7 +95,6 @@ class ProtocolCore(
         InstrumentCore,
         LabwareCore,
         Union[ModuleCore, NonConnectedModuleCore],
-        EngineTaskCore,
     ]
 ):
     """Protocol API core using a ProtocolEngine.
@@ -914,21 +912,6 @@ 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/well.py

@@ -216,14 +216,6 @@ 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,7 +31,6 @@ from ..module import (
 )
 
 from .legacy_labware_core import LegacyLabwareCore
-from .tasks import LegacyTaskCore
 from .module_geometry import ModuleGeometry, ThermocyclerGeometry, HeaterShakerGeometry
 from ...labware import Labware
 
@@ -117,10 +116,9 @@ class LegacyTemperatureModuleCore(
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.TempDeck]
 
-    def set_target_temperature(self, celsius: float) -> LegacyTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """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.
@@ -265,27 +263,23 @@ 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,
-    ) -> LegacyTaskCore:
+    ) -> None:
         """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) -> LegacyTaskCore:
+    def set_target_lid_temperature(self, celsius: float) -> None:
         """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."""
@@ -302,15 +296,6 @@ 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()
@@ -428,10 +413,9 @@ class LegacyHeaterShakerCore(
     _sync_module_hardware: SynchronousAdapter[hw_modules.HeaterShaker]
     _geometry: HeaterShakerGeometry
 
-    def set_target_temperature(self, celsius: float) -> LegacyTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """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."""
@@ -458,10 +442,6 @@ 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, Sequence
+from typing import Dict, List, Optional, Set, Union, cast, Tuple
 
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.labware.types import LabwareDefinition
@@ -34,7 +34,6 @@ 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__)
 
@@ -44,7 +43,6 @@ class LegacyProtocolCore(
         LegacyInstrumentCore,
         LegacyLabwareCore,
         legacy_module_core.LegacyModuleCore,
-        LegacyTaskCore,
     ]
 ):
     def __init__(
@@ -612,11 +610,3 @@ 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,10 +151,6 @@ 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_simulator/legacy_protocol_core.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Optional, Sequence
+from typing import Dict, Optional
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 from opentrons_shared_data.pipette.pipette_load_name_conversions import (
@@ -16,7 +16,6 @@ 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__)
 
@@ -24,10 +23,7 @@ logger = logging.getLogger(__name__)
 class LegacyProtocolCoreSimulator(
     LegacyProtocolCore,
     AbstractProtocol[
-        LegacyInstrumentCoreSimulator,
-        LegacyLabwareCore,
-        LegacyModuleCore,
-        LegacyTaskCore,
+        LegacyInstrumentCoreSimulator, LegacyLabwareCore, LegacyModuleCore
     ],
 ):
     _instruments: Dict[Mount, Optional[LegacyInstrumentCoreSimulator]]  # type: ignore[assignment]
@@ -87,11 +83,3 @@ 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/module.py

@@ -18,7 +18,6 @@ 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
 
@@ -60,7 +59,7 @@ class AbstractTemperatureModuleCore(
         """Get the module's unique hardware serial number."""
 
     @abstractmethod
-    def set_target_temperature(self, celsius: float) -> AbstractTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """Set the Temperature Module's target temperature in °C."""
 
     @abstractmethod
@@ -162,10 +161,9 @@ 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,
-    ) -> AbstractTaskCore:
+    ) -> None:
         """Set the target temperature for the well block, in °C.
 
         Note:
@@ -185,7 +183,7 @@ class AbstractThermocyclerCore(
         """Wait for target block temperature to be reached."""
 
     @abstractmethod
-    def set_target_lid_temperature(self, celsius: float) -> AbstractTaskCore:
+    def set_target_lid_temperature(self, celsius: float) -> None:
         """Set the target temperature for the heated lid, in °C."""
 
     @abstractmethod
@@ -219,33 +217,6 @@ 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."""
@@ -323,7 +294,7 @@ class AbstractHeaterShakerCore(
         """Get the module's unique hardware serial number."""
 
     @abstractmethod
-    def set_target_temperature(self, celsius: float) -> AbstractTaskCore:
+    def set_target_temperature(self, celsius: float) -> None:
         """Set the labware plate's target temperature in °C."""
 
     @abstractmethod
@@ -334,10 +305,6 @@ 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."""