diff --git a/api/src/opentrons/protocol_api/instrument_context.py b/api/src/opentrons/protocol_api/instrument_context.py index 02ee9ae34ec..b7b75284bdc 100644 --- a/api/src/opentrons/protocol_api/instrument_context.py +++ b/api/src/opentrons/protocol_api/instrument_context.py @@ -56,23 +56,22 @@ class InstrumentContext(publisher.CommandPublisher): - """A context for a specific pipette or instrument. - - The InstrumentContext class provides the objects, - attributes, and methods that allow you to use pipettes in your protocols. + """ + A context for a specific pipette or instrument. - Methods generally fall into one of two categories. + The InstrumentContext class provides the objects, attributes, and methods that allow + you to use pipettes in your protocols. - - They can change the state of the InstrumentContext object, such as how fast - it moves liquid or where it disposes of used tips). - - They can command the instrument to perform an action, like picking up tips, moving - to certain locations, and aspirating or dispensing liquid. + Methods generally fall into one of two categories. - This class also includes action methods (e.g., ``aspirate()`` and ``distribute()``). - We’ve included and defined many of these here for convenience. + - They can change the state of the InstrumentContext object, like how fast + it moves liquid or where it disposes of used tips. + + - They can command the instrument to perform an action, like picking up tips, moving + to certain locations, and aspirating or dispensing liquid. - Finally, objects in this class should not be instantiated directly. Instead, - instances are returned by :py:meth:`ProtocolContext.load_instrument`. + Objects in this class should not be instantiated directly. Instead, + instances are returned by :py:meth:`ProtocolContext.load_instrument`. .. versionadded:: 2.0 @@ -168,12 +167,12 @@ def aspirate( unspecified, defaults to the maximum volume for the pipette and its currently attached tip. :type volume: int or float - :param location: Tells the robot where to aspirate from. The location can be a - :py:class:`.Well` or a :py:class:`.Location`. + :param location: Tells the robot where to aspirate from. The location can be + a :py:class:`.Well` or a :py:class:`.Location`. - If the location is a ``Well``, the robot will aspirate at or above the bottom center of the well. The distance (in mm) from the - well bottom is specified by :py:obj:`well_bottom_clearance.aspirate`. + well bottom is specified by :py:obj:`well_bottom_clearance.aspirate `. - If the location is a ``Location`` (e.g., the result of :py:meth:`.Well.top` or :py:meth:`.Well.bottom`), the robot will aspirate from that specified position. @@ -187,10 +186,9 @@ def aspirate( .. note:: - If ``aspirate`` is called with a single argument, it will not try - to guess whether the argument is a volume or location - it is - required to be a volume. If you want to call ``aspirate`` with only - a location, specify it as a keyword argument: + If ``aspirate`` is called with a single, unnamed argument, it will treat + that argument as ``volume``. If you want to call ``aspirate`` with only + ``location``, specify it as a keyword argument: ``pipette.aspirate(location=plate['A1'])`` """ @@ -279,22 +277,22 @@ def dispense( The location can be a :py:class:`.Well` or a :py:class:`.Location`. - - If the location is a ``well``, the pipette will dispense at or above - the center of the bottom of the well. The distance from the well bottom - (in mm) is specified by the :py:obj:`well_bottom_clearance.dispense ` - object. - - - If the location is a ``location`` (e.g., the result of :py:meth:`.Well.top` or - :py:meth:`.Well.bottom`), the robot will dispense into the specified position. + - If the location is a ``Well``, the pipette will dispense at or above + the bottom center of the well. The distance (in mm) from the well bottom + is specified by :py:obj:`well_bottom_clearance.dispense `. - - If only a ``location`` is passed (e.g., ``(location=plate['A1'])``), - all of the liquid aspirated into the pipette will be dispensed - (the amount is accessible through :py:attr:`current_volume`). + - If the location is a ``Location`` (e.g., the result of :py:meth:`.Well.top` or + :py:meth:`.Well.bottom`), the robot will dispense into that specified position. - If the ``location`` is unspecified, the robot will dispense into its current position. - :param rate: How quickly a pipette dispenses liquid. Measured in µL/s. - Calculated as ``rate`` multiplied by :py:attr:`flow_rate.dispense `. + + If only a ``location`` is passed (e.g., ``pipette.dispense(location=plate['A1'])``), + all of the liquid aspirated into the pipette will be dispensed + (the amount is accessible through :py:attr:`current_volume`). + + :param rate: How quickly a pipette dispenses liquid. The speed in µL/s is + calculated as ``rate`` multiplied by :py:attr:`flow_rate.dispense `. If not specified, defaults to 1.0. See :ref:`new-plunger-flow-rates`. :type rate: float :param push_out: Continue past the plunger bottom to help ensure all liquid @@ -305,10 +303,8 @@ def dispense( .. note:: - If ``dispense`` is called with a single argument, it will not try - to guess whether the argument is a volume or location - it is - required to be a volume. If you want to call ``dispense`` with only - a location, specify it as a keyword argument: + If ``dispense`` is called with a single, unnamed argument, it will treat that argument as ``volume``. If you want to call ``dispense`` with only + ``location``, specify it as a keyword argument: ``pipette.dispense(location=plate['A1'])``. """ @@ -393,38 +389,30 @@ def mix( """ Mix a volume of liquid by repeatedly aspirating and dispensing it in a single location. - See :ref:`mix`. + See :ref:`mix` for examples. :param repetitions: Number of times to mix (default is 1). :param volume: The volume to mix, measured in µL. If 0 or unspecified, defaults to the maximum volume for the pipette and its attached tip. - :param location: A well or a position relative to well - (e.g, ``plate.rows()[0][0].bottom()``). - If unspecified, the pipette will mix from + :param location: The :py:class:`.Well` or :py:class:`~.types.Location` where + the pipette will mix. If unspecified, the pipette will mix at its current position. - :param rate: How quickly a pipette aspirates and dispenses liquid + :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 `. - The dispense flow rate is calculated + The dispensing flow rate is calculated as ``rate`` multiplied by :py:attr:`flow_rate.dispense `. See :ref:`new-plunger-flow-rates`. - :raises: ``UnexpectedTipRemovalError`` -- if no tip is attached to the pipette. + :raises: ``UnexpectedTipRemovalError`` -- If no tip is attached to the pipette. :returns: This instance. .. note:: - All the arguments to ``mix`` are optional; however, if you do - not want to specify one of them, all arguments after that one - should be keyword arguments. For instance, if you do not want - to specify volume, you would call - ``pipette.mix(1, location=wellplate['A1'])``. If you do not - want to specify repetitions, you would call - ``pipette.mix(volume=10, location=wellplate['A1'])``. Unlike - previous API versions, ``mix`` will not attempt to guess your - inputs; the first argument will always be interpreted as - ``repetitions``, the second as ``volume``, and the third as - ``location`` unless you use keywords. + 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( @@ -462,7 +450,7 @@ def blow_out( """ Blow an extra amount of air through a pipette's tip to clear it. - If :py:attr:`dispense` is used to empty a pipette, usually + If :py:meth:`dispense` is used to empty a pipette, usually a small amount of liquid remains in the tip. During a blowout, the pipette moves the plunger beyond its normal limits to help remove all liquid from the pipette tip. @@ -470,13 +458,12 @@ def blow_out( :param location: The blowout location. If no location is specified, the pipette will blow out from its current position. - :type location: :py:class:`.Well` or :py:class:`.Location` or None + :type location: :py:class:`.Well` or :py:class:`.Location` or ``None`` - :raises RuntimeError: If no location is specified and location cache is - ``None``. This should happen if ``blow_out`` is called + :raises RuntimeError: If no location is specified and the location cache is + ``None``. This should happen if ``blow_out()`` is called without first calling a method that takes a - location (e.g., :py:meth:`.aspirate`, - :py:meth:`dispense`) + location, like :py:meth:`.aspirate` or :py:meth:`dispense`. :returns: This instance. """ well: Optional[labware.Well] = None @@ -534,16 +521,17 @@ def touch_tip( speed: float = 60.0, ) -> InstrumentContext: """ - Touch the pipette tip to the sides of a well, with the intent of - removing leftover droplets. See also :ref:`touch-tip`. + Touch the pipette tip to the sides of a well, with the intent of removing leftover droplets. + + See :ref:`touch-tip` for more details and examples. :param location: If no location is passed, the pipette will - touch tip at current well's edges. - :type location: :py:class:`.Well` or None - :param radius: Describes the proportion of the target well's - radius. When ``radius=1.0``, the pipette tip will move to + touch its tip at the edges of the current well. + :type location: :py:class:`.Well` or ``None`` + :param radius: How far to move, as a proportion of the target well's + radius. When ``radius=1.0``, the pipette tip will move all the way to the edge of the target well. When ``radius=0.5``, it will - move to 50% of the well's radius. Default: 1.0 (100%) + move to 50% of the well's radius. Default is 1.0 (100%) :type radius: float :param v_offset: How far above or below the well to touch the tip, measured in mm. A positive offset moves the tip higher above the well. @@ -556,19 +544,13 @@ def touch_tip( - Maximum: 80.0 mm/s - Minimum: 1.0 mm/s :type speed: float - :raises: ``UnexpectedTipRemovalError`` -- if no tip is attached to the pipette - :raises RuntimeError: If no location is specified and location cache is + :raises: ``UnexpectedTipRemovalError`` -- If no tip is attached to the pipette. + :raises RuntimeError: If no location is specified and the location cache is ``None``. This should happen if ``touch_tip`` is called without first calling a method that takes a - location (e.g., :py:meth:`.aspirate`, - :py:meth:`dispense`) + location, like :py:meth:`.aspirate` or + :py:meth:`dispense`. :returns: This instance. - - .. note:: - - This is behavior change from legacy API (which accepts any - ``Placeable`` as the ``location`` parameter) - """ if not self._core.has_tip(): raise UnexpectedTipRemovalError("touch_tip", self.name, self.mount) @@ -630,14 +612,14 @@ def air_gap( :param height: The height, in mm, to move above the current well - before creating the air gap. The default is 5 mm above current well. + before creating the air gap. The default is 5 mm above the current well. :type height: float - :raises: ``UnexpectedTipRemovalError`` -- if no tip is attached to the pipette + :raises: ``UnexpectedTipRemovalError`` -- If no tip is attached to the pipette. - :raises RuntimeError: If location cache is None. - This should happen if ``touch_tip`` is called + :raises RuntimeError: If location cache is ``None``. + This should happen if ``touch_tip()`` is called without first calling a method that takes a location (e.g., :py:meth:`.aspirate`, :py:meth:`dispense`) @@ -646,11 +628,10 @@ def air_gap( .. note:: - Both ``volume`` and height are optional, but unlike previous API - versions, if you want to specify only ``height`` you must do it - as a keyword argument: ``pipette.air_gap(height=2)``. If you - call ``air_gap`` with only one unnamed argument, it will always - be interpreted as a volume. + Both ``volume`` and ``height`` are optional, but if you want to specify only + ``height`` you must do it as a keyword argument: + ``pipette.air_gap(height=2)``. If you call ``air_gap`` with a single, + unnamed argument, it will always be interpreted as a volume. """ @@ -671,14 +652,14 @@ def air_gap( @requires_version(2, 0) def return_tip(self, home_after: Optional[bool] = None) -> InstrumentContext: """ - If a tip is currently attached to the pipette, then the pipette will - return the tip to its location in the tip rack. + Drop the currently attached tip in its original location in the tip rack. - This will not reset tip tracking, so the well flag will remain ``False``. + Returning a tip does not reset tip tracking, so :py:obj:`.Well.has_tip` will remain + ``False`` for the destination. :returns: This instance. - :param home_after: See the ``home_after`` parameter of :py:obj:`drop_tip`. + :param home_after: See the ``home_after`` parameter of :py:meth:`drop_tip`. """ if not self._core.has_tip(): _log.warning("Pipette has no tip to return") @@ -702,60 +683,53 @@ def pick_up_tip( ) -> InstrumentContext: """ Pick up a tip for the pipette to run liquid-handling commands. + See :ref:`basic-tip-pickup`. If no location is passed, the pipette will pick up the next available tip in its :py:attr:`~.InstrumentContext.tip_racks` list. Within each tip rack, tips will be picked up in the order specified by the labware definition and :py:meth:`.Labware.wells`. - To adjust where the sequence starts, see :py:obj:`.starting_tip`. - - The tip to pick up can be manually specified with the ``location`` - argument. The ``location`` argument can be specified in several ways: - - * If the only thing to specify is which well from which to pick up a tip, ``location`` - can be a :py:class:`.Well`. For instance, if you have a tip rack in a variable - called ``tiprack``, you can pick up a specific tip from it with - ``instr.pick_up_tip(tiprack.wells()[0])``. You can use this style of call to - pick up a tip from a rack that is not a member of :py:obj:`.InstrumentContext.tip_racks`. - - * If you want to pick up the next available tip in a specific - tip rack, you may use the tip rack directly - (e.g. ``instr.pick_up_tip(tiprack)``). - - * If the position to move to in the well needs to be specified, - for instance to tell the robot to run its pick up tip routine - starting closer to or farther from the top of the tip, - ``location`` can be a :py:class:`.types.Location`; for instance, - you can call ``instr.pick_up_tip(tiprack.wells()[0].top())``. - - :param location: The location from which to pick up a tip. - :type location: :py:class:`.types.Location` or :py:class:`.Well` + To adjust where the sequence starts, use :py:obj:`.starting_tip`. + + :param location: The location from which to pick up a tip. The ``location`` + argument can be specified in several ways: + + * As a :py:class:`.Well`. For example, + ``pipette.pick_up_tip(tiprack.wells()[0])`` will always pick + up the first tip in ``tiprack``, even if the rack is not a + member of :py:obj:`.InstrumentContext.tip_racks`. + + * As a labware. ``pipette.pick_up_tip(tiprack)`` will pick up + the next available tip in ``tiprack``, even if the rack is + not a member of :py:obj:`.InstrumentContext.tip_racks`. + + * As a :py:class:`~.types.Location`. Use this to make fine + adjustments to the pickup location. For example, to tell + the robot to start its pick up tip routine 1 mm closer to + the top of the well in the tip rack, call + ``pipette.pick_up_tip(tiprack["A1"].top(z=-1))``. + :type location: :py:class:`.Well` or :py:class:`.Labware` or :py:class:`.types.Location` :param presses: The number of times to lower and then raise the pipette when picking up a tip, to ensure a good seal. Zero (``0``) will result in the pipette hovering over the tip but - not picking it up--generally not desirable, but could - be used for dry-run). + not picking it up (generally not desirable, but could + be used for a dry run). - .. deprecated:: 2.14 - Use the Opentrons App to change pipette pick-up settings. + .. deprecated:: 2.14 + Use the Opentrons App to change pipette pick-up settings. :type presses: int - :param increment: The additional distance to travel on each successive - press (e.g.: if ``presses=3`` and ``increment=1.0``, then - the first press will travel down into the tip by - 3.5 mm, the second by 4.5 mm, and the third by 5.5 mm). + :param increment: The additional distance to travel on each successive press. + For example, if ``presses=3`` and ``increment=1.0``, then the first press + will travel down into the tip by 3.5 mm, the second by 4.5 mm, and the + third by 5.5 mm). - .. deprecated:: 2.14 - Use the Opentrons App to change pipette pick-up settings. + .. deprecated:: 2.14 + Use the Opentrons App to change pipette pick-up settings. :type increment: float :param prep_after: Whether the pipette plunger should prepare itself to aspirate immediately after picking up a tip. - .. warning:: - This is provided for compatibility with older - Python Protocol API behavior. You should normally - leave this unset. - If ``True``, the pipette will move its plunger position to bottom in preparation for any following calls to :py:meth:`.aspirate`. @@ -766,6 +740,10 @@ def pick_up_tip( and positioning the plunger outside any potential liquids. .. warning:: + This is provided for compatibility with older + Python Protocol API behavior. You should normally + leave this unset. + Setting ``prep_after=False`` may create an unintended pipette movement, when the pipette automatically moves the tip to the top of the well to prepare the plunger. @@ -889,14 +867,13 @@ def drop_tip( """ Drop the current tip. - See :ref:`pipette-drop-tip`. + See :ref:`pipette-drop-tip` for examples. If no location is passed (e.g. ``pipette.drop_tip()``), the pipette will drop the - attached tip into its default :py:attr:`trash_container`. For the Flex and OT-2 the - default slots for their trash containers are A3 and 12, respectively. + attached tip into its default :py:attr:`trash_container`. Starting with API version 2.15, if the trash container is the default fixed trash, - the API will instruct the pipettes to drop their tips in different locations within + the API will instruct the pipette to drop tips in different locations within the trash container. Varying the tip drop location helps prevent tips from piling up in a single location. @@ -904,29 +881,25 @@ def drop_tip( the ``location`` argument. The ``location`` argument can be specified in several ways: - - If the only thing to specify is the well into which to drop - a tip, ``location`` can be a :py:class:`.Well`. For instance, - if you have a tip rack in a variable called ``tiprack``, you can - drop a tip into a specific well on that tip rack with the call - ``instr.drop_tip(tiprack.wells()[0])``. This style of call can - be used to make the robot drop a tip into labware like a well plate or - a reservoir. - - If the drop position and :py:class:`.Well` to drop the tip into needs to be - specified, for instance to tell the robot to drop a tip from an unusually - large height above the tip rack, ``location`` can be a :py:class:`.types.Location`. - For instance, you can call ``instr.drop_tip(tiprack.wells()[0].top())``. + - As a :py:class:`.Well`. This uses a default location relative to the well. + This style of call can be used to make the robot drop a tip into labware + like a well plate or a reservoir. For example, + ``pipette.drop_tip(location=reservoir["A1"])``. + - As a :py:class:`~.types.Location`. For example, to drop a tip from an + unusually large height above the tip rack, you could call + ``pipette.drop_tip(tip_rack["A1"].top(z=10))``. :param location: The location to drop the tip. :type location: - :py:class:`.types.Location` or :py:class:`.Well` or ``None`` + :py:class:`~.types.Location` or :py:class:`.Well` or ``None`` :param home_after: Whether to home the pipette's plunger after dropping the tip. If not specified, defaults to ``True`` on an OT-2. - When ``home_after=False``, the pipette does not home its plunger. This can - save a few seconds, but is not recommended. Homing helps the robot track the - pipette's position. + When ``False``, the pipette does not home its plunger. This can save a few + seconds, but is not recommended. Homing helps the robot track the pipette's + position. :returns: This instance. """ @@ -1097,7 +1070,9 @@ def transfer( # TODO: What should happen if the user passes a non-first-row well # TODO: ..as src/dest *while using multichannel pipette? """ - Transfer moves liquid from one well or group of wells to another. It is a + Move liquid from one well or group of wells to another. + + Transfer is a higher-level command, incorporating other :py:class:`InstrumentContext` commands, like :py:meth:`aspirate` and :py:meth:`dispense`. It makes writing a protocol easier at the cost of specificity. See :ref:`v2-complex-commands` for @@ -1310,20 +1285,28 @@ def move_to( publish: bool = True, ) -> InstrumentContext: """Move the instrument. + + See :ref:`move-to` for examples. :param location: The location to move to. - :type location: :py:class:`.types.Location` - :param force_direct: If set to true, move directly to destination + :type location: :py:class:`~.types.Location` + :param force_direct: If ``True``, move directly to the destination without arc motion. - :param minimum_z_height: When specified, this Z margin is able to raise - (but never lower) the mid-arc height. + + .. warning:: + Forcing direct motion can cause the pipette to crash + into labware, modules, or other objects on the deck. + + :param minimum_z_height: An amount, measured in mm, to raise + the mid-arc height. The mid-arc height can't be lowered. :param speed: The speed at which to move. By default, :py:attr:`InstrumentContext.default_speed`. This controls - the straight linear speed of the motion; to limit - individual axis speeds, you can use + the straight linear speed of the motion. To limit + individual axis speeds, use :py:obj:`.ProtocolContext.max_speeds`. - :param publish: Whether a call to this function should publish to the - run log or not. + + :param publish: Whether to list this function call in the + run preview. Default is ``True``. """ publish_ctx = nullcontext() @@ -1351,7 +1334,7 @@ def mount(self) -> str: """ Return the name of the mount the pipette is attached to. - The possible names are ``left`` and ``right``. + The possible names are ``"left"`` and ``"right"``. """ return self._core.get_mount().name.lower() @@ -1365,19 +1348,8 @@ def speed(self) -> "PlungerSpeeds": operation. .. note:: - This property is equivalent to :py:attr:`flow_rate`; the only - difference is the units in which this property is specified. - Specifying this attribute uses the units of the linear speed of - the plunger inside the pipette, while :py:attr:`flow_rate` uses - the units of the volumetric flow rate of liquid into or out of the - tip. Because :py:attr:`speed` and :py:attr:`flow_rate` modify the - same values, setting one will override the other. - - For instance, to set the plunger speed during an aspirate action, do - - .. code-block :: python - - instrument.speed.aspirate = 50 + Setting values of :py:attr:`flow_rate` will override the values in + :py:attr:`speed`. .. versionchanged:: 2.14 This property has been removed because it's fundamentally misaligned @@ -1403,23 +1375,11 @@ def flow_rate(self) -> "FlowRates": See :ref:`new-plunger-flow-rates`. This is an object with attributes ``aspirate``, ``dispense``, and - ``blow_out`` holding the flow rates for the corresponding operation. + ``blow_out`` holding the flow rate for the corresponding operation. .. note:: - This property is equivalent to :py:attr:`speed`; the only - difference is the units in which this property is specified. - specifying this property uses the units of the volumetric flow rate - of liquid into or out of the tip, while :py:attr:`speed` uses the - units of the linear speed of the plunger inside the pipette. - Because :py:attr:`speed` and :py:attr:`flow_rate` modify the - same values, setting one will override the other. - - For instance, to change the flow rate for aspiration on an instrument - you would do: - - .. code-block :: python - - instrument.flow_rate.aspirate = 50 + Setting values of :py:attr:`speed`, which is deprecated, will override the + values in :py:attr:`flow_rate`. """ return self._core.get_flow_rate() @@ -1427,7 +1387,7 @@ def flow_rate(self) -> "FlowRates": @property # type: ignore @requires_version(2, 0) def type(self) -> str: - """One of `'single'` or `'multi'`.""" + """One of ``'single'`` or ``'multi'``.""" model = self.name if "single" in model: return "single" @@ -1459,6 +1419,8 @@ def trash_container(self) -> labware.Labware: This is the property used to determine where to drop tips and blow out liquids when calling :py:meth:`drop_tip` or :py:meth:`blow_out` without arguments. + + By default, the trash container is in slot A3 on Flex and in slot 12 on OT-2. """ return self._trash @@ -1478,7 +1440,7 @@ def name(self) -> str: @requires_version(2, 0) def model(self) -> str: """ - The model string for the pipette (e.g. 'p300_single_v1.3') + The model string for the pipette (e.g., ``'p300_single_v1.3'``) """ return self._core.get_model() @@ -1517,7 +1479,12 @@ def current_volume(self) -> float: @property # type: ignore @requires_version(2, 7) def has_tip(self) -> bool: - """Return whether this instrument has a tip attached or not.""" + """Whether this instrument has a tip attached or not. + + The value of this property is determined logically by the API, not by detecting + the physical presence of a tip. This is the case even on Flex, which has sensors + to detect tip attachment. + """ return self._core.has_tip() @property @@ -1543,7 +1510,7 @@ def hw_pipette(self) -> PipetteDict: def channels(self) -> int: """The number of channels on the pipette. - See :ref:`new-pipette`.""" + Possible values are 1, 8, or 96.""" return self._core.get_channels() @property # type: ignore @@ -1552,8 +1519,8 @@ def return_height(self) -> float: """The height to return a tip to its tip rack. :returns: A scaling factor to apply to the tip length. - During a drop tip, this factor will be multiplied by the tip length - to get the distance from the top of the well where the tip is dropped. + During :py:meth:`.drop_tip`, this factor is multiplied by the tip length + to get the distance from the top of the well to drop the tip. """ return self._core.get_return_height() @@ -1563,7 +1530,7 @@ def well_bottom_clearance(self) -> "Clearances": """The distance above the bottom of a well to aspirate or dispense. This is an object with attributes ``aspirate`` and ``dispense``, - describing the default heights of the corresponding operation. The + describing the default height of the corresponding operation. The default is 1.0 mm for both aspirate and dispense. When :py:meth:`aspirate` or :py:meth:`dispense` is given a @@ -1571,11 +1538,9 @@ def well_bottom_clearance(self) -> "Clearances": will move this distance above the bottom of the well to aspirate or dispense. - To change, set the corresponding attribute. For instance: - - .. code-block:: python + To change, set the corresponding attribute:: - instr.well_bottom_clearance.aspirate = 1 + pipette.well_bottom_clearance.aspirate = 2 """ return self._well_bottom_clearances @@ -1610,8 +1575,9 @@ def configure_for_volume(self, volume: float) -> None: in the mode set by this function until it is called again. The Flex 1-Channel 50 µL and Flex 8-Channel 50 µL pipettes must operate in a - low-volume mode to accurately dispense 1 µL of liquid. Low-volume mode can - only be set by calling ``configure_for_volume``. See :ref:`pipette-volume-modes`. + low-volume mode to accurately dispense very small volumes of liquid. Low-volume + mode can only be set by calling ``configure_for_volume()``. See + :ref:`pipette-volume-modes`. .. note ::