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

opentrons/protocol_api/core/engine/_default_labware_versions.py

@@ -112,6 +112,38 @@ 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,
+        "opentrons_tough_universal_lid": 2,
+        "usascientific_12_reservoir_22ml": 4,
+        "usascientific_96_wellplate_2.4ml_deep": 4,
+    },
 }
 
 
@@ -139,17 +171,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/deck_conflict.py

@@ -26,6 +26,7 @@ from opentrons.protocol_engine import (
     OnLabwareLocation,
     AddressableAreaLocation,
     InStackerHopperLocation,
+    WASTE_CHUTE_LOCATION,
     OFF_DECK_LOCATION,
     SYSTEM_LOCATION,
 )
@@ -241,7 +242,6 @@ def _map_labware(
     Tuple[Union[DeckSlotName, StagingSlotName], wrapped_deck_conflict.DeckItem]
 ]:
     location_from_engine = engine_state.labware.get_location(labware_id=labware_id)
-
     if isinstance(location_from_engine, AddressableAreaLocation):
         # This will be guaranteed to be either deck slot name or staging slot name
         slot: Union[DeckSlotName, StagingSlotName]
@@ -299,10 +299,12 @@ def _map_labware(
         location_from_engine == OFF_DECK_LOCATION
         or location_from_engine == SYSTEM_LOCATION
         or isinstance(location_from_engine, InStackerHopperLocation)
+        or location_from_engine == WASTE_CHUTE_LOCATION
     ):
         # This labware is off-deck. Exclude it from conflict checking.
         # todo(mm, 2023-02-23): Move this logic into wrapped_deck_conflict.
         return None
+    return None
 
 
 def _map_module(

opentrons/protocol_api/core/engine/instrument.py

@@ -203,7 +203,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         flow_rate: float,
         in_place: bool,
         meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
+        end_location: Optional[Location] = None,
+        end_meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -215,8 +218,9 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             in_place: whether this is a in-place command.
             meniscus_tracking: Optional data about where to aspirate from.
         """
-        if meniscus_tracking == MeniscusTrackingTarget.START:
+        if meniscus_tracking == MeniscusTrackingTarget.START and end_location is None:
             raise ValueError("Cannot aspirate at the starting liquid height.")
+        final_location = location
         if well_core is None:
             if not in_place:
                 self._engine_client.execute_command(
@@ -262,16 +266,34 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 well_location=well_location,
             )
             assert isinstance(well_location, LiquidHandlingWellLocation)
-            if dynamic_liquid_tracking:
+            # the dynamic liquid tracking flag is for the prototype dynamic tracking method
+            if dynamic_liquid_tracking or end_location is not None:
+                # Keep this part when above TODO is done
+                if end_location is None:
+                    end_location = location
+                (
+                    end_well_location,
+                    _,
+                ) = self._engine_client.state.geometry.get_relative_well_location(
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    absolute_point=end_location.point,
+                    location_type=WellLocationFunction.LIQUID_HANDLING,
+                    meniscus_tracking=end_meniscus_tracking,
+                )
+                final_location = end_location
+                assert isinstance(end_well_location, LiquidHandlingWellLocation)
                 self._engine_client.execute_command(
                     cmd.AspirateWhileTrackingParams(
                         pipetteId=self._pipette_id,
                         labwareId=labware_id,
                         wellName=well_name,
-                        wellLocation=well_location,
+                        trackFromLocation=well_location,
+                        trackToLocation=end_well_location,
                         volume=volume,
                         flowRate=flow_rate,
                         correctionVolume=correction_volume,
+                        movement_delay=movement_delay,
                     )
                 )
             else:
@@ -287,7 +309,9 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                     )
                 )
 
-        self._protocol_core.set_last_location(location=location, mount=self.get_mount())
+        self._protocol_core.set_last_location(
+            location=final_location, mount=self.get_mount()
+        )
 
     def dispense(
         self,
@@ -299,7 +323,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         in_place: bool,
         push_out: Optional[float],
         meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
+        end_location: Optional[Location] = None,
+        end_meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
         correction_volume: Optional[float] = None,
+        movement_delay: Optional[float] = None,
     ) -> None:
         """Dispense a given volume of liquid into the specified location.
         Args:
@@ -320,7 +347,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             # Newer API versions raise an error if you try to dispense more than
             # you can. Let the error come from Protocol Engine's validation.
             pass
-
+        final_location = location
         if well_core is None:
             if not in_place:
                 if isinstance(location, (TrashBin, WasteChute)):
@@ -375,17 +402,34 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 well_name=well_name,
                 well_location=well_location,
             )
-            if dynamic_liquid_tracking:
+            # the dynamic liquid tracking flag is for the prototype dynamic tracking method
+            if dynamic_liquid_tracking or end_location is not None:
+                if end_location is None:
+                    end_location = location
+                final_location = end_location
+                (
+                    end_well_location,
+                    _,
+                ) = self._engine_client.state.geometry.get_relative_well_location(
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    absolute_point=end_location.point,
+                    location_type=WellLocationFunction.LIQUID_HANDLING,
+                    meniscus_tracking=end_meniscus_tracking,
+                )
+                assert isinstance(end_well_location, LiquidHandlingWellLocation)
                 self._engine_client.execute_command(
                     cmd.DispenseWhileTrackingParams(
                         pipetteId=self._pipette_id,
                         labwareId=labware_id,
                         wellName=well_name,
-                        wellLocation=well_location,
+                        trackFromLocation=well_location,
+                        trackToLocation=end_well_location,
                         volume=volume,
                         flowRate=flow_rate,
                         pushOut=push_out,
                         correctionVolume=correction_volume,
+                        movement_delay=movement_delay,
                     )
                 )
             else:
@@ -402,7 +446,9 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                     )
                 )
 
-        self._protocol_core.set_last_location(location=location, mount=self.get_mount())
+        self._protocol_core.set_last_location(
+            location=final_location, mount=self.get_mount()
+        )
 
     def blow_out(
         self,
@@ -1300,6 +1346,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         trash_location: Union[Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCore]],
     ) -> None:
         """Execute transfer using liquid class properties.
 
@@ -1322,10 +1369,12 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             return_tip: If `True`, return tips to the tip rack location they were picked up from,
                         otherwise drop in `trash_location`
             keep_last_tip: When set to `True`, do not drop the final tip used in the transfer.
+            tips: If provided, transfer will pick up the tips in the order given. If this
+                  is less than the amount of tips needed, an error will be raised.
         """
-        if not tip_racks:
+        if not tip_racks and not tips:
             raise RuntimeError(
-                "No tipracks found for pipette in order to perform transfer"
+                "No tip racks or tips found for pipette in order to perform transfer"
             )
         tiprack_uri_for_transfer_props = tip_racks[0][1].get_uri()
         transfer_props = self._get_transfer_properties_for_tip_rack(
@@ -1367,7 +1416,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
 
         if new_tip == TransferTipPolicyV2.ONCE:
             self._pick_up_tip_for_liquid_class(
-                tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                tip_racks, starting_tip, tiprack_uri_for_transfer_props, tips
             )
 
         prev_src: Optional[Tuple[Location, WellCore]] = None
@@ -1407,7 +1456,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 if prev_src is not None and prev_dest is not None:
                     self._drop_tip_for_liquid_class(trash_location, return_tip)
                 self._pick_up_tip_for_liquid_class(
-                    tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                    tip_racks,
+                    starting_tip,
+                    tiprack_uri_for_transfer_props,
+                    tips,
                 )
                 post_disp_tip_contents = [
                     tx_comps_executor.LiquidAndAirGapPair(
@@ -1464,6 +1516,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         trash_location: Union[Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCore]],
     ) -> None:
         """Execute a distribution using liquid class properties.
 
@@ -1487,6 +1540,8 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             return_tip: If `True`, return tips to the tip rack location they were picked up from,
                         otherwise drop in `trash_location`
             keep_last_tip: When set to `True`, do not drop the final tip used in the distribute.
+            tips: If provided, transfer will pick up the tips in the order given. If this
+                  is less than the amount of tips needed, an error will be raised.
 
         This method distributes the liquid in the source well into multiple destinations.
         It can accomplish this by either doing a multi-dispense (aspirate once and then
@@ -1498,7 +1553,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         """
         if not tip_racks:
             raise RuntimeError(
-                "No tipracks found for pipette in order to perform transfer"
+                "No tip racks found for pipette in order to perform transfer"
             )
         assert new_tip in [
             TransferTipPolicyV2.NEVER,
@@ -1546,6 +1601,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 trash_location=trash_location,
                 return_tip=return_tip,
                 keep_last_tip=keep_last_tip,
+                tips=tips,
             )
 
         # TODO: use the ID returned by load_liquid_class in command annotations
@@ -1576,7 +1632,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
 
         if new_tip != TransferTipPolicyV2.NEVER:
             self._pick_up_tip_for_liquid_class(
-                tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                tip_racks,
+                starting_tip,
+                tiprack_uri_for_transfer_props,
+                tips,
             )
 
         tip_contents = [
@@ -1644,7 +1703,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             if not is_first_step and new_tip == TransferTipPolicyV2.ALWAYS:
                 self._drop_tip_for_liquid_class(trash_location, return_tip)
                 self._pick_up_tip_for_liquid_class(
-                    tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                    tip_racks,
+                    starting_tip,
+                    tiprack_uri_for_transfer_props,
+                    tips,
                 )
                 tip_contents = [
                     tx_comps_executor.LiquidAndAirGapPair(
@@ -1750,6 +1812,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         trash_location: Union[Location, TrashBin, WasteChute],
         return_tip: bool,
         keep_last_tip: bool,
+        tips: Optional[List[WellCore]],
     ) -> None:
         """Execute consolidate using liquid class properties.
 
@@ -1774,10 +1837,12 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             return_tip: If `True`, return tips to the tip rack location they were picked up from,
                         otherwise drop in `trash_location`
             keep_last_tip: When set to `True`, do not drop the final tip used in the consolidate.
+            tips: If provided, transfer will pick up the tips in the order given. If this
+                  is less than the amount of tips needed, an error will be raised.
         """
         if not tip_racks:
             raise RuntimeError(
-                "No tipracks found for pipette in order to perform transfer"
+                "No tip racks found for pipette in order to perform transfer"
             )
         # NOTE: Tip option of "always" in consolidate is equivalent to "after every dispense",
         #       or more specifically, "before the next chunk of aspirates".
@@ -1828,7 +1893,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
 
         if new_tip in [TransferTipPolicyV2.ONCE, TransferTipPolicyV2.ALWAYS]:
             self._pick_up_tip_for_liquid_class(
-                tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                tip_racks,
+                starting_tip,
+                tiprack_uri_for_transfer_props,
+                tips,
             )
 
         aspirate_air_gap_by_volume = transfer_props.aspirate.retract.air_gap_by_volume
@@ -1861,7 +1929,10 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             if not is_first_step and new_tip == TransferTipPolicyV2.ALWAYS:
                 self._drop_tip_for_liquid_class(trash_location, return_tip)
                 self._pick_up_tip_for_liquid_class(
-                    tip_racks, starting_tip, tiprack_uri_for_transfer_props
+                    tip_racks,
+                    starting_tip,
+                    tiprack_uri_for_transfer_props,
+                    tips,
                 )
                 tip_contents = [
                     tx_comps_executor.LiquidAndAirGapPair(
@@ -1957,22 +2028,34 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         tip_racks: List[Tuple[Location, LabwareCore]],
         starting_tip: Optional[WellCore],
         tiprack_uri_for_transfer_props: str,
+        selected_tips: Optional[List[WellCore]],
     ) -> None:
         """Resolve next tip and pick it up, for use in liquid class transfer code."""
-        next_tip = self.get_next_tip(
-            tip_racks=[core for loc, core in tip_racks],
-            starting_well=starting_tip,
-        )
-        if next_tip is None:
-            raise RuntimeError(
-                f"No tip available among the tipracks assigned for {self.get_pipette_name()}:"
-                f" {[f'{tip_rack[1].get_display_name()} in {tip_rack[1].get_deck_slot()}' for tip_rack in tip_racks]}"
+        next_tip: Optional[NextTipInfo]
+        if selected_tips is not None:
+            try:
+                tip_core = selected_tips.pop(0)
+            except IndexError:
+                raise RuntimeError("No more selected tips available for liquid class.")
+            next_tip = NextTipInfo(
+                labwareId=tip_core.labware_id, tipStartingWell=tip_core.get_name()
+            )
+        else:
+            next_tip = self.get_next_tip(
+                tip_racks=[core for loc, core in tip_racks],
+                starting_well=starting_tip,
             )
+            if next_tip is None:
+                raise RuntimeError(
+                    f"No tip available among the tipracks assigned for {self.get_pipette_name()}:"
+                    f" {[f'{tip_rack[1].get_display_name()} in {tip_rack[1].get_deck_slot()}' for tip_rack in tip_racks]}"
+                )
         (
             tiprack_loc,
             tiprack_uri,
             tip_well,
         ) = self._get_location_and_well_core_from_next_tip_info(next_tip, tip_racks)
+
         if tiprack_uri != tiprack_uri_for_transfer_props:
             raise RuntimeError(
                 f"Tiprack {tiprack_uri} does not match the tiprack designated "

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

@@ -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,6 +322,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,9 +333,30 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
                 celsius=celsius,
                 blockMaxVolumeUl=block_max_volume,
                 holdTimeSeconds=hold_time_seconds,
+                ramp_rate=ramp_rate,
             )
         )
 
+    def start_set_target_block_temperature(
+        self,
+        celsius: float,
+        ramp_rate: Optional[float],
+        block_max_volume: Optional[float] = None,
+    ) -> EngineTaskCore:
+        """Start setting the target temperature for the well block, in °C."""
+        result = self._engine_client.execute_command_without_recovery(
+            cmd.thermocycler.SetTargetBlockTemperatureParams(
+                moduleId=self.module_id,
+                celsius=celsius,
+                blockMaxVolumeUl=block_max_volume,
+                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."""
         self._engine_client.execute_command(
@@ -344,6 +371,18 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
             )
         )
 
+    def start_set_target_lid_temperature(self, celsius: float) -> EngineTaskCore:
+        """Start setting the target temperature for the heated lid, in °C."""
+        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."""
         self._engine_client.execute_command(
@@ -361,6 +400,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 +429,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 +457,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 +584,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 +610,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/pipette_movement_conflict.py

@@ -1,8 +1,8 @@
 """A Protocol-Engine-friendly wrapper for opentrons.motion_planning.deck_conflict."""
+
 from __future__ import annotations
 import logging
 from typing import (
-    Optional,
     Tuple,
     Union,
     List,
@@ -12,7 +12,6 @@ from opentrons_shared_data.errors.exceptions import MotionPlanningFailureError
 from opentrons.protocol_engine.errors import LocationIsStagingSlotError
 from opentrons_shared_data.module import FLEX_TC_LID_COLLISION_ZONE
 
-from opentrons.hardware_control import CriticalPoint
 from opentrons.motion_planning import adjacent_slots_getters
 
 from opentrons.protocol_engine import (
@@ -101,7 +100,9 @@ def check_safe_for_pipette_movement(  # noqa: C901
     )
     primary_nozzle = engine_state.pipettes.get_primary_nozzle(pipette_id)
 
-    destination_cp = _get_critical_point_to_use(engine_state, labware_id)
+    destination_cp = engine_state.motion.get_critical_point_for_wells_in_labware(
+        labware_id
+    )
     pipette_bounds_at_well_location = (
         engine_state.pipettes.get_pipette_bounds_at_specified_move_to_position(
             pipette_id=pipette_id,
@@ -189,21 +190,6 @@ def check_safe_for_pipette_movement(  # noqa: C901
             )
 
 
-def _get_critical_point_to_use(
-    engine_state: StateView, labware_id: str
-) -> Optional[CriticalPoint]:
-    """Return the critical point to use when accessing the given labware."""
-    # TODO (spp, 2024-09-17): looks like Y_CENTER of column is the same as its XY_CENTER.
-    #   I'm using this if-else ladder to be consistent with what we do in
-    #   `MotionPlanning.get_movement_waypoints_to_well()`.
-    #   We should probably use only XY_CENTER in both places.
-    if engine_state.labware.get_should_center_column_on_target_well(labware_id):
-        return CriticalPoint.Y_CENTER
-    elif engine_state.labware.get_should_center_pipette_on_target_well(labware_id):
-        return CriticalPoint.XY_CENTER
-    return None
-
-
 def _slot_has_potential_colliding_object(
     engine_state: StateView,
     pipette_bounds: Tuple[Point, Point, Point, Point],