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

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

@@ -325,9 +325,9 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
         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,
@@ -336,6 +336,22 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore[LabwareCore]):
                 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
         )
@@ -347,8 +363,16 @@ 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."""
+        self._engine_client.execute_command(
+            cmd.thermocycler.SetTargetLidTemperatureParams(
+                moduleId=self.module_id, celsius=celsius
+            )
+        )
+
+    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

opentrons/protocol_api/core/engine/protocol.py

@@ -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
@@ -1168,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[
@@ -1205,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/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

@@ -268,7 +268,7 @@ class LegacyThermocyclerCore(
         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,
@@ -276,16 +276,27 @@ class LegacyThermocyclerCore(
             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 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."""

opentrons/protocol_api/core/legacy/legacy_protocol_core.py

@@ -613,6 +613,18 @@ 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"