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

opentrons/protocol_api/instrument_context.py

@@ -74,6 +74,8 @@ _AIR_GAP_TRACKING_ADDED_IN = APIVersion(2, 22)
 """The version after which air gaps should be implemented with a separate call instead of an aspirate for better liquid volume tracking."""
 _LIQUID_CLASS_TRANSFER_TIP_RACKS_ARG_ADDED_IN = APIVersion(2, 25)
 """The version after which the user can supply liquid class transfers with non-assigned tip racks."""
+_LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN = APIVersion(2, 27)
+"""The version after which the user can supply liquid class transfers with selected tips."""
 
 
 AdvancedLiquidHandling = v1_transfer.AdvancedLiquidHandling
@@ -199,6 +201,8 @@ class InstrumentContext(publisher.CommandPublisher):
         location: Optional[Union[types.Location, labware.Well]] = None,
         rate: float = 1.0,
         flow_rate: Optional[float] = None,
+        end_location: Optional[types.Location] = None,
+        movement_delay: Optional[float] = None,
     ) -> InstrumentContext:
         """
         Draw liquid into a pipette tip.
@@ -238,6 +242,16 @@ class InstrumentContext(publisher.CommandPublisher):
         :param flow_rate: The absolute flow rate in µL/s. If ``flow_rate`` is specified,
                           ``rate`` must not be set.
         :type flow_rate: float
+        :param end_location: Tells the robot to move between location and end_location
+            while aspirating liquid. When this argument is used the location and
+            end_location must both be :py:class:`.Location`.
+        :type end_location: :py:class:`.Location`
+        :param movement_delay: Delay the x/y/z movement during a dynamic aspirate.
+            This option is only valid when using end_location. When this argument
+            is used, the x/y/z movement will wait movement_delay seconds after the pipette
+            starts to aspirate before moving. This may help when dispensing very viscous liquids
+            that need to build up some pressure before liquid starts to flow.
+        :type movement_delay: float
         :returns: This instance.
 
         .. note::
@@ -291,6 +305,50 @@ class InstrumentContext(publisher.CommandPublisher):
         move_to_location, well, meniscus_tracking = self._handle_aspirate_target(
             target=target
         )
+        if (
+            meniscus_tracking is not None
+            and meniscus_tracking == types.MeniscusTrackingTarget.DYNAMIC
+        ):
+            # we're using the old dynamic pipetting
+            if end_location is not None:
+                raise ValueError(
+                    "Dynamic target is depreciated and you cannot use a dynamic target and and end location."
+                )
+            # re-work the dynamic location as a start and end location
+            new_start_location = types.Location(
+                point=move_to_location.point,
+                labware=move_to_location.labware,
+                _meniscus_tracking=types.MeniscusTrackingTarget.START,
+            )
+            target = validation.validate_location(
+                location=new_start_location, last_location=last_location
+            )
+            # Target already checked for this above, this is just for lint
+            assert not isinstance(target, validation.DisposalTarget)
+            move_to_location, well, meniscus_tracking = self._handle_aspirate_target(
+                target=target
+            )
+            end_location = types.Location(
+                point=move_to_location.point,
+                labware=move_to_location.labware,
+                _meniscus_tracking=types.MeniscusTrackingTarget.END,
+            )
+        end_move_to_location: Optional[types.Location] = None
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None
+        if end_location is not None:
+            validation.validate_dynamic_locations(location, end_location)
+            end_target = validation.validate_location(
+                location=end_location, last_location=None
+            )
+            if isinstance(end_target, validation.DisposalTarget):
+                raise ValueError(
+                    "Trash Bin and Waste Chute are not acceptable location parameters for Aspirate commands."
+                )
+            (
+                end_move_to_location,
+                end_well,
+                end_meniscus_tracking,
+            ) = self._handle_aspirate_target(target=end_target)
         if self.api_version >= APIVersion(2, 11):
             instrument.validate_takes_liquid(
                 location=move_to_location,
@@ -322,6 +380,7 @@ class InstrumentContext(publisher.CommandPublisher):
                 location=move_to_location,
                 flow_rate=flow_rate,
                 rate=rate,
+                end_location=end_move_to_location,
             ),
         ):
             self._core.aspirate(
@@ -330,8 +389,11 @@ class InstrumentContext(publisher.CommandPublisher):
                 volume=c_vol,
                 rate=rate,
                 flow_rate=flow_rate,
-                in_place=target.in_place,
+                in_place=target.in_place and end_move_to_location is None,
                 meniscus_tracking=meniscus_tracking,
+                end_location=end_move_to_location,
+                end_meniscus_tracking=end_meniscus_tracking,
+                movement_delay=movement_delay,
             )
 
         return self
@@ -346,6 +408,8 @@ class InstrumentContext(publisher.CommandPublisher):
         rate: float = 1.0,
         push_out: Optional[float] = None,
         flow_rate: Optional[float] = None,
+        end_location: Optional[types.Location] = None,
+        movement_delay: Optional[float] = None,
     ) -> InstrumentContext:
         """
         Dispense liquid from a pipette tip.
@@ -415,6 +479,16 @@ class InstrumentContext(publisher.CommandPublisher):
                           ``rate`` must not be set.
         :type flow_rate: float
 
+        :param end_location: Tells the robot to move between location and end_location
+            while dispensing liquid held in the pipette. When this argument is used
+            the location and end_location must both be a :py:class:`.Location`.
+        :type end_location: :py:class:`.Location`
+        :param movement_delay: Delay the x/y/z movement during a dynamic dispense.
+            This option is only valid when using end_location. When this argument
+            is used, the x/y/z movement will wait movement_delay seconds after the pipette
+            starts to dispense before moving. This may help when dispensing very viscous liquids
+            that need to build up some pressure before liquid starts to flow.
+        :type movement_delay: float
         :returns: This instance.
 
         .. note::
@@ -501,12 +575,59 @@ class InstrumentContext(publisher.CommandPublisher):
                     in_place=target.in_place,
                     push_out=push_out,
                     meniscus_tracking=None,
+                    end_location=None,
+                    end_meniscus_tracking=None,
+                    movement_delay=None,
                 )
             return self
 
         move_to_location, well, meniscus_tracking = self._handle_dispense_target(
             target=target
         )
+        if (
+            meniscus_tracking is not None
+            and meniscus_tracking == types.MeniscusTrackingTarget.DYNAMIC
+        ):
+            # we're using the old dynamic pipetting
+            if end_location is not None:
+                raise ValueError(
+                    "Dynamic target is depreciated and you cannot use a dynamic target and and end location."
+                )
+            # re-work the dynamic location as a start and end location
+            new_start_location = types.Location(
+                point=move_to_location.point,
+                labware=move_to_location.labware,
+                _meniscus_tracking=types.MeniscusTrackingTarget.START,
+            )
+            target = validation.validate_location(
+                location=new_start_location, last_location=last_location
+            )
+            # Target already checked for this above, this is just for lint
+            assert not isinstance(target, validation.DisposalTarget)
+            move_to_location, well, meniscus_tracking = self._handle_dispense_target(
+                target=target
+            )
+            end_location = types.Location(
+                point=move_to_location.point,
+                labware=move_to_location.labware,
+                _meniscus_tracking=types.MeniscusTrackingTarget.END,
+            )
+        end_move_to_location: Optional[types.Location] = None
+        end_meniscus_tracking: Optional[types.MeniscusTrackingTarget] = None
+        if end_location is not None:
+            validation.validate_dynamic_locations(location, end_location)
+            end_target = validation.validate_location(
+                location=end_location, last_location=None
+            )
+            if isinstance(end_target, validation.DisposalTarget):
+                raise ValueError(
+                    "Trash Bin and Waste Chute are not acceptable location parameters for dynamic pipetting commands."
+                )
+            (
+                end_move_to_location,
+                end_well,
+                end_meniscus_tracking,
+            ) = self._handle_dispense_target(target=end_target)
 
         if self.api_version >= APIVersion(2, 11):
             instrument.validate_takes_liquid(
@@ -523,6 +644,7 @@ class InstrumentContext(publisher.CommandPublisher):
                 location=move_to_location,
                 rate=rate,
                 flow_rate=flow_rate,
+                end_location=end_move_to_location,
             ),
         ):
             self._core.dispense(
@@ -531,9 +653,12 @@ class InstrumentContext(publisher.CommandPublisher):
                 location=move_to_location,
                 well_core=well._core if well is not None else None,
                 flow_rate=flow_rate,
-                in_place=target.in_place,
+                in_place=target.in_place and end_move_to_location is None,
                 push_out=push_out,
                 meniscus_tracking=meniscus_tracking,
+                end_location=end_move_to_location,
+                end_meniscus_tracking=end_meniscus_tracking,
+                movement_delay=movement_delay,
             )
 
         return self
@@ -704,6 +829,204 @@ class InstrumentContext(publisher.CommandPublisher):
                     dispense_with_delay(push_out=None)
         return self
 
+    @requires_version(2, 27)
+    def dynamic_mix(  # noqa: C901
+        self,
+        aspirate_start_location: types.Location,
+        dispense_start_location: types.Location,
+        repetitions: int = 1,
+        volume: Optional[float] = None,
+        aspirate_end_location: Optional[types.Location] = None,
+        dispense_end_location: Optional[types.Location] = None,
+        rate: float = 1.0,
+        aspirate_flow_rate: Optional[float] = None,
+        dispense_flow_rate: Optional[float] = None,
+        aspirate_delay: Optional[float] = None,
+        dispense_delay: Optional[float] = None,
+        final_push_out: Optional[float] = None,
+        movement_delay: Optional[float] = None,
+    ) -> InstrumentContext:
+        """
+        Mix a volume of liquid by repeatedly aspirating and dispensing it in a multiple locations.
+
+        See :ref:`dynamic_mix` for examples.
+
+        :param repetitions: Number of times to mix (default is 1).
+        :param volume: The volume to mix, measured in µL. If unspecified, defaults
+                       to the maximum volume for the pipette and its attached tip.
+
+                       If ``mix`` is called with a volume of precisely 0, its behavior
+                       depends on the API level of the protocol. On API levels below 2.16,
+                       it will behave the same as a volume of ``None``/unspecified: mix
+                       the full working volume of the pipette. On API levels at or above 2.16,
+                       no liquid will be mixed.
+        :param aspirate_start_location: The :py:class:`~.types.Location` where the pipette will aspirate from.
+        :param aspirate_end_location: The :py:class:`~.types.Location` If this argument is supplied
+                    the pipette will move between aspirate_start_location and aspirate_end_location
+                    while performing the aspirate.
+        :param dispense_start_location: The :py:class:`~.types.Location` where the pipette will dispense to.
+        :param dispense_end_location: The :py:class:`~.types.Location` If this argument is supplied
+                    the pipette will move between dispense_start_location and dispense_end_location
+                    while performing the dispense.
+        :param rate: How quickly the pipette aspirates and dispenses liquid while
+                     mixing. The aspiration flow rate is calculated as ``rate``
+                     multiplied by :py:attr:`flow_rate.aspirate <flow_rate>`. The
+                     dispensing flow rate is calculated as ``rate`` multiplied by
+                     :py:attr:`flow_rate.dispense <flow_rate>`. See
+                     :ref:`new-plunger-flow-rates`.
+        :param aspirate_flow_rate: The absolute flow rate for each aspirate in the mix, in µL/s.
+                                   If this is specified, ``rate`` must not be set.
+        :param dispense_flow_rate: The absolute flow rate for each dispense in the mix, in µL/s.
+                                   If this is specified, ``rate`` must not be set.
+        :param aspirate_delay: How long to wait after each aspirate in the mix, in seconds.
+        :param dispense_delay: How long to wait after each dispense in the mix, in seconds.
+        :param final_push_out: How much volume to push out after the final mix repetition. The
+                               pipette will not push out after earlier repetitions. If
+                               not specified or ``None``, the pipette will push out the
+                               default non-zero amount. See :ref:`push-out-dispense`.
+        :param movement_delay: Delay the x/y/z movement during a dynamic mix.
+            This option is only valid when using aspirate_end_location or dispense_end_location.
+            When this argument is used, the x/y/z movement will wait movement_delay seconds
+            after the pipette starts to aspirate/dispense before moving. This may help when mixing
+            very viscous liquids that need to build up some pressure before liquid starts to flow.
+        :type movement_delay: float
+        :raises: ``UnexpectedTipRemovalError`` -- If no tip is attached to the pipette.
+        :returns: This instance.
+
+        .. note::
+
+            All the arguments of ``mix`` are optional. However, if you omit one of them,
+            all subsequent arguments must be passed as keyword arguments. For instance,
+            ``pipette.mix(1, location=wellplate['A1'])`` is a valid call, but
+            ``pipette.mix(1, wellplate['A1'])`` is not.
+
+        """
+        _log.debug(
+            "mixing {}uL with {} repetitions in {} and {} at rate={}".format(
+                volume,
+                repetitions,
+                aspirate_start_location,
+                dispense_start_location,
+                rate,
+            )
+        )
+        # Verify all locations are within the same well
+        if not aspirate_start_location.labware.is_well:
+            raise ValueError(
+                "Dynamic mix aspirate start location must be within a well"
+            )
+        if not dispense_start_location.labware.is_well:
+            raise ValueError(
+                "Dynamic mix dispense start location must be within a well"
+            )
+
+        if (
+            aspirate_end_location is not None
+            and not aspirate_end_location.labware.is_well
+        ):
+            raise ValueError("Dynamic mix aspirate end location must be within a well")
+        if (
+            dispense_end_location is not None
+            and not dispense_end_location.labware.is_well
+        ):
+            raise ValueError("Dynamic mix dispense end location must be within a well")
+
+        (
+            _,
+            asp_start_well,
+        ) = aspirate_start_location.labware.get_parent_labware_and_well()
+        (
+            _,
+            disp_start_well,
+        ) = dispense_start_location.labware.get_parent_labware_and_well()
+
+        if asp_start_well != disp_start_well:
+            raise ValueError(
+                "Aspirate and Dispense locations must be within the same well"
+            )
+
+        if not self._core.has_tip():
+            raise UnexpectedTipRemovalError("mix", self.name, self.mount)
+
+        c_vol = self._core.get_available_volume() if volume is None else volume
+
+        if aspirate_flow_rate:
+            if rate != 1.0:
+                raise ValueError(
+                    "rate must not be set if aspirate_flow_rate is specified"
+                )
+        if dispense_flow_rate:
+            if rate != 1.0:
+                raise ValueError(
+                    "rate must not be set if dispense_flow_rate is specified"
+                )
+
+        def delay_with_publish(seconds: float) -> None:
+            # We don't have access to ProtocolContext.delay() which would automatically
+            # publish a message to the broker, so we have to do it manually:
+            with publisher.publish_context(
+                broker=self.broker,
+                command=protocol_cmds.delay(seconds=seconds, minutes=0, msg=None),
+            ):
+                self._protocol_core.delay(seconds=seconds, msg=None)
+
+        def aspirate_with_delay() -> None:
+            self.aspirate(
+                volume,
+                aspirate_start_location,
+                rate,
+                flow_rate=aspirate_flow_rate,
+                end_location=aspirate_end_location,
+                movement_delay=movement_delay,
+            )
+            if aspirate_delay:
+                delay_with_publish(aspirate_delay)
+
+        def dispense_with_delay(push_out: Optional[float]) -> None:
+            self.dispense(
+                volume=volume,
+                location=dispense_start_location,
+                rate=rate,
+                flow_rate=dispense_flow_rate,
+                push_out=push_out,
+                end_location=dispense_end_location,
+                movement_delay=movement_delay,
+            )
+            if dispense_delay:
+                delay_with_publish(dispense_delay)
+
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.dynamic_mix(
+                instrument=self,
+                repetitions=repetitions,
+                volume=c_vol,
+                aspirate_start_location=aspirate_start_location,
+                aspirate_end_location=aspirate_end_location,
+                dispense_start_location=dispense_start_location,
+                dispense_end_location=dispense_end_location,
+                movement_delay=movement_delay or 0.0,
+            ),
+        ):
+            aspirate_with_delay()
+            with AutoProbeDisable(self):
+                while repetitions - 1 > 0:
+                    # starting in 2.16, we disable push_out on all but the last
+                    # dispense() to prevent the tip from jumping out of the liquid
+                    # during the mix (PR #14004):
+                    self.move_to(dispense_start_location, force_direct=True)
+                    dispense_with_delay(push_out=0.0)
+                    self.move_to(aspirate_start_location, force_direct=True)
+                    aspirate_with_delay()
+                    repetitions -= 1
+
+                self.move_to(dispense_start_location, force_direct=True)
+                if final_push_out is not None:
+                    dispense_with_delay(push_out=final_push_out)
+                else:
+                    dispense_with_delay(push_out=None)
+        return self
+
     @requires_version(2, 0)
     def blow_out(
         self,
@@ -1799,6 +2122,9 @@ class InstrumentContext(publisher.CommandPublisher):
         group_wells: bool = True,
         keep_last_tip: Optional[bool] = None,
         tip_racks: Optional[List[labware.Labware]] = None,
+        tips: Optional[
+            Union[Sequence[labware.Well], Sequence[Sequence[labware.Well]]]
+        ] = None,
     ) -> InstrumentContext:
         """Move a particular type of liquid from one well or group of wells to another.
 
@@ -1838,9 +2164,14 @@ class InstrumentContext(publisher.CommandPublisher):
         :param tip_racks: A list of tip racks to pick up from for this command. If not provided, the pipette will pick
             up from its associated :py:obj:`.InstrumentContext.tip_racks`. Providing this argument does not change the
             value of ``InstrumentContext.tip_racks``.
+        :param tips: An ordered list of tips to use for the transfer. If the list contains fewer tips than needed to
+            complete the transfer, the API will raise an error. The pipette will use only these tips even if
+            ``InstrumentContext.tip_racks`` or the ``tip_racks`` parameter of this method is set.
 
             .. versionchanged:: 2.25
                 Added the ``tip_racks`` parameter.
+            .. versionchanged:: 2.27
+                Added the ``tips`` parameter.
 
         """
         if volume == 0.0:
@@ -1859,6 +2190,15 @@ class InstrumentContext(publisher.CommandPublisher):
                 until_version=f"{_LIQUID_CLASS_TRANSFER_TIP_RACKS_ARG_ADDED_IN}",
                 current_version=f"{self.api_version}",
             )
+        if (
+            tips is not None
+            and self.api_version < _LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN
+        ):
+            raise APIVersionError(
+                api_element="tips",
+                until_version=f"{_LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN}",
+                current_version=f"{self.api_version}",
+            )
 
         transfer_args = verify_and_normalize_transfer_args(
             source=source,
@@ -1872,6 +2212,7 @@ class InstrumentContext(publisher.CommandPublisher):
             trash_location=(
                 trash_location if trash_location is not None else self.trash_container
             ),
+            tips=tips,
         )
         verified_keep_last_tip = resolve_keep_last_tip(
             keep_last_tip, transfer_args.tip_policy
@@ -1926,6 +2267,9 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
+                tips=[tip._core for tip in transfer_args.tips]
+                if transfer_args.tips is not None
+                else None,
             )
 
         return self
@@ -1947,6 +2291,9 @@ class InstrumentContext(publisher.CommandPublisher):
         group_wells: bool = True,
         keep_last_tip: Optional[bool] = None,
         tip_racks: Optional[List[labware.Labware]] = None,
+        tips: Optional[
+            Union[Sequence[labware.Well], Sequence[Sequence[labware.Well]]]
+        ] = None,
     ) -> InstrumentContext:
         """
         Distribute a particular type of liquid from one well to a group of wells.
@@ -1983,9 +2330,14 @@ class InstrumentContext(publisher.CommandPublisher):
         :param tip_racks: A list of tip racks to pick up from for this command. If not provided, the pipette will pick
             up from its associated :py:obj:`.InstrumentContext.tip_racks`. Providing this argument does not change the
             value of ``InstrumentContext.tip_racks``.
+        :param tips: An ordered list of tips to use for the transfer. If the list contains fewer tips than needed to
+            complete the transfer, the API will raise an error. The pipette will use only these tips even if
+            ``InstrumentContext.tip_racks`` or the ``tip_racks`` parameter of this method is set.
 
             .. versionchanged:: 2.25
                 Added the ``tip_racks`` parameter.
+            .. versionchanged:: 2.27
+                Added the ``tips`` parameter.
 
         """
         if volume == 0.0:
@@ -2004,6 +2356,15 @@ class InstrumentContext(publisher.CommandPublisher):
                 until_version=f"{_LIQUID_CLASS_TRANSFER_TIP_RACKS_ARG_ADDED_IN}",
                 current_version=f"{self.api_version}",
             )
+        if (
+            tips is not None
+            and self.api_version < _LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN
+        ):
+            raise APIVersionError(
+                api_element="tips",
+                until_version=f"{_LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN}",
+                current_version=f"{self.api_version}",
+            )
 
         transfer_args = verify_and_normalize_transfer_args(
             source=source,
@@ -2017,6 +2378,7 @@ class InstrumentContext(publisher.CommandPublisher):
             trash_location=(
                 trash_location if trash_location is not None else self.trash_container
             ),
+            tips=tips,
         )
         verified_keep_last_tip = resolve_keep_last_tip(
             keep_last_tip, transfer_args.tip_policy
@@ -2079,6 +2441,9 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
+                tips=[tip._core for tip in transfer_args.tips]
+                if transfer_args.tips is not None
+                else None,
             )
 
         return self
@@ -2100,6 +2465,9 @@ class InstrumentContext(publisher.CommandPublisher):
         group_wells: bool = True,
         keep_last_tip: Optional[bool] = None,
         tip_racks: Optional[List[labware.Labware]] = None,
+        tips: Optional[
+            Union[Sequence[labware.Well], Sequence[Sequence[labware.Well]]]
+        ] = None,
     ) -> InstrumentContext:
         """
         Consolidate a particular type of liquid from a group of wells to one well.
@@ -2137,9 +2505,14 @@ class InstrumentContext(publisher.CommandPublisher):
         :param tip_racks: A list of tip racks to pick up from for this command. If not provided, the pipette will pick
             up from its associated :py:obj:`.InstrumentContext.tip_racks`. Providing this argument does not change the
             value of ``InstrumentContext.tip_racks``.
+        :param tips: An ordered list of tips to use for the transfer. If the list contains fewer tips than needed to
+            complete the transfer, the API will raise an error. The pipette will use only these tips even if
+            ``InstrumentContext.tip_racks`` or the ``tip_racks`` parameter of this method is set.
 
             .. versionchanged:: 2.25
                 Added the ``tip_racks`` parameter.
+            .. versionchanged:: 2.27
+                Added the ``tips`` parameter.
 
         """
         if volume == 0.0:
@@ -2158,6 +2531,15 @@ class InstrumentContext(publisher.CommandPublisher):
                 until_version=f"{_LIQUID_CLASS_TRANSFER_TIP_RACKS_ARG_ADDED_IN}",
                 current_version=f"{self.api_version}",
             )
+        if (
+            tips is not None
+            and self.api_version < _LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN
+        ):
+            raise APIVersionError(
+                api_element="tips",
+                until_version=f"{_LIQUID_CLASS_TRANSFER_TIPS_ARG_ADDED_IN}",
+                current_version=f"{self.api_version}",
+            )
 
         transfer_args = verify_and_normalize_transfer_args(
             source=source,
@@ -2171,6 +2553,7 @@ class InstrumentContext(publisher.CommandPublisher):
             trash_location=(
                 trash_location if trash_location is not None else self.trash_container
             ),
+            tips=tips,
         )
         verified_keep_last_tip = resolve_keep_last_tip(
             keep_last_tip, transfer_args.tip_policy
@@ -2232,6 +2615,9 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
+                tips=[tip._core for tip in transfer_args.tips]
+                if transfer_args.tips is not None
+                else None,
             )
 
         return self

opentrons/protocol_api/labware.py

@@ -347,6 +347,11 @@ class Well:
         """Get the current liquid volume in a well."""
         return self._core.get_liquid_volume()
 
+    @requires_version(2, 27)
+    def has_tracked_liquid(self) -> bool:
+        """Get the current liquid volume in a well."""
+        return self._core.has_tracked_liquid()
+
     @requires_version(2, 24)
     def volume_from_height(self, height: LiquidTrackingType) -> LiquidTrackingType:
         """Return the volume contained in a well at any height."""
@@ -817,8 +822,8 @@ class Labware:
     def set_offset(self, x: float, y: float, z: float) -> None:
         """Set the labware's position offset.
 
-        The offset is an x, y, z vector in deck coordinates
-        (see :ref:`protocol-api-deck-coords`).
+        An offset of `(x=0, y=0, z=0)` means the labware's uncalibrated position before
+        any offset from Labware Position Check is applied.
 
         How the motion system applies the offset depends on the API level of the protocol.
 
@@ -877,6 +882,9 @@ class Labware:
     def calibrated_offset(self) -> Point:
         """The front-left-bottom corner of the labware, including its labware offset.
 
+        The offset is an x, y, z vector in deck coordinates
+        (see :ref:`protocol-api-deck-coords`).
+
         When running a protocol in the Opentrons App or on the touchscreen, Labware
         Position Check sets the labware offset.
         """