opentrons 8.4.0a4__py2.py3-none-any.whl → 8.4.0a5__py2.py3-none-any.whl

opentrons/protocol_api/core/engine/instrument.py

@@ -12,6 +12,7 @@ from typing import (
     Tuple,
     NamedTuple,
     Generator,
+    Literal,
 )
 from opentrons.types import (
     Location,
@@ -747,6 +748,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         force_direct: bool,
         minimum_z_height: Optional[float],
         speed: Optional[float],
+        check_for_movement_conflicts: bool = True,
     ) -> None:
         if well_core is not None:
             if isinstance(location, (TrashBin, WasteChute)):
@@ -765,6 +767,14 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             assert isinstance(well_location, LiquidHandlingWellLocation)
             if well_location.volumeOffset and well_location.volumeOffset != 0:
                 raise ValueError("volume offset not supported with move_to")
+            if check_for_movement_conflicts:
+                pipette_movement_conflict.check_safe_for_pipette_movement(
+                    engine_state=self._engine_client.state,
+                    pipette_id=self._pipette_id,
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    well_location=well_location,
+                )
             self._engine_client.execute_command(
                 cmd.MoveToWellParams(
                     pipetteId=self._pipette_id,
@@ -1399,7 +1409,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         volume: float,
         source: Tuple[Location, WellCore],
         dest: List[Tuple[Location, WellCore]],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[Location, LabwareCore]],
         starting_tip: Optional[WellCore],
         trash_location: Union[Location, TrashBin, WasteChute],
@@ -1415,8 +1425,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             dest: List of destination wells, with each well represented as a tuple of
                     types.Location and WellCore.
                     types.Location is only necessary for saving the last accessed location.
-            new_tip: Whether the transfer should use a new tip 'once', 'never', 'always',
-                     or 'per source'.
+            new_tip: Whether the transfer should use a new tip 'once' or 'never'.
             tiprack_uri: The URI of the tiprack that the transfer settings are for.
             tip_drop_location: Location where the tip will be dropped (if appropriate).
 
@@ -1432,6 +1441,8 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             raise RuntimeError(
                 "No tipracks found for pipette in order to perform transfer"
             )
+        assert new_tip in [TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE]
+
         tiprack_uri_for_transfer_props = tip_racks[0][1].get_uri()
         working_volume = min(
             self.get_max_volume(),
@@ -1559,7 +1570,6 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             )
             return tip_well
 
-        tip_used = False
         if new_tip != TransferTipPolicyV2.NEVER:
             last_tip_picked_up_from = _pick_up_tip()
 
@@ -1604,16 +1614,6 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 )
             )
 
-            if new_tip == TransferTipPolicyV2.ALWAYS and tip_used:
-                _drop_tip()
-                last_tip_picked_up_from = _pick_up_tip()
-                tip_contents = [
-                    tx_comps_executor.LiquidAndAirGapPair(
-                        liquid=0,
-                        air_gap=0,
-                    )
-                ]
-
             use_single_dispense = False
             if total_aspirate_volume == volume and len(vol_dest_combo) == 1:
                 # We are only doing a single transfer. Either because this is the last
@@ -1696,7 +1696,6 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                         disposal_volume=disposal_vol,
                     )
                 is_first_step = False
-            tip_used = True
 
         if new_tip != TransferTipPolicyV2.NEVER:
             _drop_tip()
@@ -1728,7 +1727,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         volume: float,
         source: List[Tuple[Location, WellCore]],
         dest: Tuple[Location, WellCore],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[Location, LabwareCore]],
         starting_tip: Optional[WellCore],
         trash_location: Union[Location, TrashBin, WasteChute],
@@ -1738,7 +1737,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             raise RuntimeError(
                 "No tipracks found for pipette in order to perform transfer"
             )
-
+        assert new_tip in [TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE]
         tiprack_uri_for_transfer_props = tip_racks[0][1].get_uri()
         try:
             transfer_props = liquid_class.get_for(
@@ -1841,7 +1840,6 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
         if new_tip == TransferTipPolicyV2.ONCE:
             last_tip_picked_up_from = _pick_up_tip()
 
-        prev_src: Optional[Tuple[Location, WellCore]] = None
         tip_contents = [
             tx_comps_executor.LiquidAndAirGapPair(
                 liquid=0,
@@ -1849,6 +1847,7 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
             )
         ]
         next_step_volume, next_source = next(source_per_volume_step)
+        is_first_step = True
         is_last_step = False
         while not is_last_step:
             total_dispense_volume = 0.0
@@ -1863,21 +1862,17 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                     is_last_step = True
                     break
 
-            if new_tip == TransferTipPolicyV2.ALWAYS:
-                if prev_src is not None:
-                    _drop_tip()
-                last_tip_picked_up_from = _pick_up_tip()
-                tip_contents = [
-                    tx_comps_executor.LiquidAndAirGapPair(
-                        liquid=0,
-                        air_gap=0,
-                    )
-                ]
-            # TODO (spp, 2025-03-24): add LPD feature when 'per source' tip policy is added for consolidate_liquid
-            with self.lpd_for_transfer(enable=False):
-                for step_num, (step_volume, step_source) in enumerate(
-                    vol_aspirate_combo
-                ):
+            if (
+                self.get_liquid_presence_detection()
+                and new_tip != TransferTipPolicyV2.NEVER
+                and is_first_step
+            ):
+                enable_lpd = True
+            else:
+                enable_lpd = False
+
+            for step_num, (step_volume, step_source) in enumerate(vol_aspirate_combo):
+                with self.lpd_for_transfer(enable=enable_lpd):
                     tip_contents = self.aspirate_liquid_class(
                         volume=step_volume,
                         source=step_source,
@@ -1888,6 +1883,8 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                             total_dispense_volume if step_num == 0 else None
                         ),
                     )
+                is_first_step = False
+                enable_lpd = False
             tip_contents = self.dispense_liquid_class(
                 volume=total_dispense_volume,
                 dest=dest,
@@ -1902,7 +1899,6 @@ class InstrumentCore(AbstractInstrument[WellCore, LabwareCore]):
                 ),
                 trash_location=trash_location,
             )
-            prev_src = next_source
         if new_tip != TransferTipPolicyV2.NEVER:
             _drop_tip()
 

opentrons/protocol_api/core/engine/transfer_components_executor.py

@@ -99,6 +99,14 @@ class TipState:
         ), "Last air gap volume doe not match the volume being removed"
         self.last_liquid_and_air_gap_in_tip.air_gap = 0
 
+    def delete_last_air_gap_and_liquid(self) -> None:
+        air_gap_in_tip = self.last_liquid_and_air_gap_in_tip.air_gap
+        liquid_in_tip = self.last_liquid_and_air_gap_in_tip.liquid
+        if air_gap_in_tip:
+            self.delete_air_gap(air_gap_in_tip)
+        if liquid_in_tip:
+            self.delete_liquid(volume=liquid_in_tip)
+
 
 class TransferType(Enum):
     ONE_TO_ONE = "one_to_one"
@@ -525,6 +533,9 @@ class TransferComponentsExecutor:
                     if isinstance(trash_location, Location)
                     else None
                 )
+            # A non-multi-dispense blowout will only have air and maybe droplets in the tip
+            # since we only blowout after dispensing the full tip contents.
+            # So delete the air gap from tip state
             last_air_gap = self._tip_state.last_liquid_and_air_gap_in_tip.air_gap
             self._tip_state.delete_air_gap(last_air_gap)
             self._tip_state.ready_to_aspirate = False
@@ -608,6 +619,10 @@ class TransferComponentsExecutor:
                 well_core=None,
                 in_place=True,
             )
+            # A blowout will remove all air gap and liquid (disposal volume) from the tip
+            # so delete them from tip state (although practically, there will not be
+            # any air gaps in the tip before blowing out in the destination well)
+            self._tip_state.delete_last_air_gap_and_liquid()
             self._tip_state.ready_to_aspirate = False
 
         # A retract will perform total of two air gaps if we need to blow out in source or trash:
@@ -695,8 +710,9 @@ class TransferComponentsExecutor:
                     if isinstance(trash_location, Location)
                     else None
                 )
-            last_air_gap = self._tip_state.last_liquid_and_air_gap_in_tip.air_gap
-            self._tip_state.delete_air_gap(last_air_gap)
+            # A blowout will remove all air gap and liquid (disposal volume) from the tip
+            # so delete them from tip state
+            self._tip_state.delete_last_air_gap_and_liquid()
             self._tip_state.ready_to_aspirate = False
 
             # Do touch tip and air gap again after blowing out into source well or trash

opentrons/protocol_api/core/instrument.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABC
-from typing import Any, Generic, Optional, TypeVar, Union, List, Tuple
+from typing import Any, Generic, Optional, TypeVar, Union, List, Tuple, Literal
 
 from opentrons import types
 from opentrons.hardware_control.dev_types import PipetteDict
@@ -190,6 +190,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         force_direct: bool,
         minimum_z_height: Optional[float],
         speed: Optional[float],
+        check_for_movement_conflicts: bool,
     ) -> None:
         ...
 
@@ -381,7 +382,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         volume: float,
         source: Tuple[types.Location, WellCoreType],
         dest: List[Tuple[types.Location, WellCoreType]],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LabwareCoreType]],
         starting_tip: Optional[WellCoreType],
         trash_location: Union[types.Location, TrashBin, WasteChute],
@@ -400,7 +401,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType, LabwareCoreType]):
         volume: float,
         source: List[Tuple[types.Location, WellCoreType]],
         dest: Tuple[types.Location, WellCoreType],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LabwareCoreType]],
         starting_tip: Optional[WellCoreType],
         trash_location: Union[types.Location, TrashBin, WasteChute],

opentrons/protocol_api/core/legacy/legacy_instrument_core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Optional, Union, List, Tuple
+from typing import TYPE_CHECKING, Optional, Union, List, Tuple, Literal
 
 from opentrons import types
 from opentrons.hardware_control import CriticalPoint
@@ -367,6 +367,7 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         force_direct: bool = False,
         minimum_z_height: Optional[float] = None,
         speed: Optional[float] = None,
+        check_for_movement_conflicts: bool = False,
     ) -> None:
         """Move the instrument.
 
@@ -376,6 +377,7 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
             force_direct: Force a direct movement instead of an arc.
             minimum_z_height: Set a minimum travel height for a movement arc.
             speed: Override the travel speed in mm/s.
+            check_for_movement_conflicts: Not used in legacy implementation
 
         Raises:
             LabwareHeightError: An item on the deck is taller than
@@ -619,7 +621,7 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         volume: float,
         source: Tuple[types.Location, LegacyWellCore],
         dest: List[Tuple[types.Location, LegacyWellCore]],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
@@ -634,7 +636,7 @@ class LegacyInstrumentCore(AbstractInstrument[LegacyWellCore, LegacyLabwareCore]
         volume: float,
         source: List[Tuple[types.Location, LegacyWellCore]],
         dest: Tuple[types.Location, LegacyWellCore],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],

opentrons/protocol_api/core/legacy_simulator/legacy_instrument_core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Optional, Union, List, Tuple
+from typing import TYPE_CHECKING, Optional, Union, List, Tuple, Literal
 
 from opentrons import types
 from opentrons.hardware_control.dev_types import PipetteDict
@@ -325,6 +325,7 @@ class LegacyInstrumentCoreSimulator(
         force_direct: bool = False,
         minimum_z_height: Optional[float] = None,
         speed: Optional[float] = None,
+        check_for_movement_conflicts: bool = False,  # Not used in this implementation
     ) -> None:
         """Simulation of only the motion planning portion of move_to."""
         if isinstance(location, (TrashBin, WasteChute)):
@@ -534,7 +535,7 @@ class LegacyInstrumentCoreSimulator(
         volume: float,
         source: Tuple[types.Location, LegacyWellCore],
         dest: List[Tuple[types.Location, LegacyWellCore]],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],
@@ -549,7 +550,7 @@ class LegacyInstrumentCoreSimulator(
         volume: float,
         source: List[Tuple[types.Location, LegacyWellCore]],
         dest: Tuple[types.Location, LegacyWellCore],
-        new_tip: TransferTipPolicyV2,
+        new_tip: Literal[TransferTipPolicyV2.NEVER, TransferTipPolicyV2.ONCE],
         tip_racks: List[Tuple[types.Location, LegacyLabwareCore]],
         starting_tip: Optional[LegacyWellCore],
         trash_location: Union[types.Location, TrashBin, WasteChute],

opentrons/protocol_api/instrument_context.py

@@ -1529,7 +1529,7 @@ class InstrumentContext(publisher.CommandPublisher):
         """Move a particular type of liquid from one well or group of wells to another.
 
         :param liquid_class: The type of liquid to move. You must specify the liquid class,
-            even if you have used :py:meth:`.load_liquid` to indicate what liquid the
+            even if you have used :py:meth:`.Labware.load_liquid` to indicate what liquid the
             source contains.
         :type liquid_class: :py:class:`.LiquidClass`
 
@@ -1552,6 +1552,8 @@ class InstrumentContext(publisher.CommandPublisher):
             tips. Depending on the liquid class, the pipette may also blow out liquid here.
         :param return_tip: Whether to drop used tips in their original locations
             in the tip rack, instead of the trash.
+
+            :meta private:
         """
         if volume == 0.0:
             _log.info(
@@ -1634,7 +1636,7 @@ class InstrumentContext(publisher.CommandPublisher):
         Distribute a particular type of liquid from one well to a group of wells.
 
         :param liquid_class: The type of liquid to move. You must specify the liquid class,
-            even if you have used :py:meth:`.load_liquid` to indicate what liquid the
+            even if you have used :py:meth:`.Labware.load_liquid` to indicate what liquid the
             source contains.
         :type liquid_class: :py:class:`.LiquidClass`
 
@@ -1645,8 +1647,7 @@ class InstrumentContext(publisher.CommandPublisher):
         :param new_tip: When to pick up and drop tips during the command.
             Defaults to ``"once"``.
 
-              - ``"once"`` or ``"per source"``: Use one tip for the entire command.
-              - ``"always"``: Use a new tip for each set of aspirate and dispense steps.
+              - ``"once"``: Use one tip for the entire command.
               - ``"never"``: Do not pick up or drop tips at all.
 
             See :ref:`param-tip-handling` for details.
@@ -1655,6 +1656,8 @@ class InstrumentContext(publisher.CommandPublisher):
             tips. Depending on the liquid class, the pipette may also blow out liquid here.
         :param return_tip: Whether to drop used tips in their original locations
             in the tip rack, instead of the trash.
+
+            :meta private:
         """
         if volume == 0.0:
             _log.info(
@@ -1681,9 +1684,14 @@ class InstrumentContext(publisher.CommandPublisher):
                 f"Source should be a single well (or resolve to a single transfer for multi-channel) "
                 f"but received {transfer_args.sources_list}."
             )
-        if transfer_args.tip_policy == TransferTipPolicyV2.PER_SOURCE:
-            raise RuntimeError(
-                'Tip transfer policy "per source" incompatible with distribute.'
+        if transfer_args.tip_policy not in [
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.NEVER,
+        ]:
+            raise ValueError(
+                f"Incompatible `new_tip` value of {new_tip}."
+                f" `distribute_with_liquid_class()` only supports `new_tip` values of"
+                f" 'once' and 'never'."
             )
 
         verified_source = transfer_args.sources_list[0]
@@ -1708,7 +1716,7 @@ class InstrumentContext(publisher.CommandPublisher):
                     (types.Location(types.Point(), labware=well), well._core)
                     for well in transfer_args.destinations_list
                 ],
-                new_tip=transfer_args.tip_policy,
+                new_tip=transfer_args.tip_policy,  # type: ignore[arg-type]
                 tip_racks=[
                     (types.Location(types.Point(), labware=rack), rack._core)
                     for rack in transfer_args.tip_racks
@@ -1741,7 +1749,7 @@ class InstrumentContext(publisher.CommandPublisher):
         Consolidate a particular type of liquid from a group of wells to one well.
 
         :param liquid_class: The type of liquid to move. You must specify the liquid class,
-            even if you have used :py:meth:`.load_liquid` to indicate what liquid the
+            even if you have used :py:meth:`.Labware.load_liquid` to indicate what liquid the
             source contains.
         :type liquid_class: :py:class:`.LiquidClass`
 
@@ -1753,8 +1761,6 @@ class InstrumentContext(publisher.CommandPublisher):
             Defaults to ``"once"``.
 
               - ``"once"``: Use one tip for the entire command.
-              - ``"always"``: Use a new tip for each set of aspirate and dispense steps.
-              - ``"per source"``: Not available when consolidating.
               - ``"never"``: Do not pick up or drop tips at all.
 
             See :ref:`param-tip-handling` for details.
@@ -1763,6 +1769,8 @@ class InstrumentContext(publisher.CommandPublisher):
             tips. Depending on the liquid class, the pipette may also blow out liquid here.
         :param return_tip: Whether to drop used tips in their original locations
             in the tip rack, instead of the trash.
+
+            :meta private:
         """
         if volume == 0.0:
             _log.info(
@@ -1789,9 +1797,14 @@ class InstrumentContext(publisher.CommandPublisher):
                 f"Destination should be a single well (or resolve to a single transfer for multi-channel) "
                 f"but received {transfer_args.destinations_list}."
             )
-        if transfer_args.tip_policy == TransferTipPolicyV2.PER_SOURCE:
-            raise RuntimeError(
-                'Tip transfer policy "per source" incompatible with consolidate.'
+        if transfer_args.tip_policy not in [
+            TransferTipPolicyV2.ONCE,
+            TransferTipPolicyV2.NEVER,
+        ]:
+            raise ValueError(
+                f"Incompatible `new_tip` value of {new_tip}."
+                f" `consolidate_with_liquid_class()` only supports `new_tip` values of"
+                f" 'once' and 'never'."
             )
 
         verified_dest = transfer_args.destinations_list[0]
@@ -1816,7 +1829,7 @@ class InstrumentContext(publisher.CommandPublisher):
                     types.Location(types.Point(), labware=verified_dest),
                     verified_dest._core,
                 ),
-                new_tip=transfer_args.tip_policy,
+                new_tip=transfer_args.tip_policy,  # type: ignore[arg-type]
                 tip_racks=[
                     (types.Location(types.Point(), labware=rack), rack._core)
                     for rack in transfer_args.tip_racks
@@ -1907,6 +1920,7 @@ class InstrumentContext(publisher.CommandPublisher):
                     force_direct=force_direct,
                     minimum_z_height=minimum_z_height,
                     speed=speed,
+                    check_for_movement_conflicts=False,
                 )
             else:
                 if publish:
@@ -1925,6 +1939,7 @@ class InstrumentContext(publisher.CommandPublisher):
                     force_direct=force_direct,
                     minimum_z_height=minimum_z_height,
                     speed=speed,
+                    check_for_movement_conflicts=False,
                 )
 
         return self

opentrons/protocol_api/labware.py

@@ -263,15 +263,15 @@ class Well:
 
     @requires_version(2, 21)
     def meniscus(
-        self, target: Literal["start", "end", "dynamic"], z: float = 0.0
+        self, z: float = 0.0, target: Literal["start", "end", "dynamic"] = "end"
     ) -> Location:
         """
         :param z: An offset on the z-axis, in mm. Positive offsets are higher and
             negative offsets are lower.
-        :param target: The relative position inside the well to target when performing a liquid handling operation.
-        :return: A :py:class:`~opentrons.types.Location` that indicates location is meniscus and that holds the ``z`` offset in its point.z field.
+        :param target: The relative position of the liquid meniscus inside the well to target when performing a liquid handling operation.
+
+        :return: A :py:class:`~opentrons.types.Location` corresponding to the liquid meniscus, plus a target position and ``z`` offset as specified.
 
-        :meta private:
         """
         return Location(
             point=Point(x=0, y=0, z=z),
@@ -326,9 +326,9 @@ class Well:
         :param Liquid liquid: The liquid to load into the well.
         :param float volume: The volume of liquid to load, in µL.
 
-        .. TODO: flag as deprecated in 2.22 docs
-            In API version 2.22 and later, use :py:meth:`~Labware.load_liquid`, :py:meth:`~Labware.load_liquid_by_well`,
-            or :py:meth:`~Labware.load_empty` to load liquid into a well.
+        .. deprecated:: 2.22
+            Use :py:meth:`.Labware.load_liquid`, :py:meth:`.Labware.load_liquid_by_well`, or :py:meth:`.Labware.load_empty` instead.
+
         """
         self._core.load_liquid(
             liquid=liquid,
@@ -1270,22 +1270,15 @@ class Labware:
     ) -> None:
         """Mark several wells as containing the same amount of liquid.
 
-        This method should be called at the beginning of a protocol, soon after loading the labware and before
-        liquid handling operations begin. It is a base of information for liquid tracking functionality. If a well in a labware
-        has not been named in a call to :py:meth:`~Labware.load_empty`, :py:meth:`~Labware.load_liquid`, or
-        :py:meth:`~Labware.load_liquid_by_well`, the volume it contains is unknown and the well's liquid will not be tracked.
-
-        For example, to load 10µL of a liquid named ``water`` (defined with :py:meth:`~ProtocolContext.define_liquid`)
-        into all the wells of a labware, you could call ``labware.load_liquid(labware.wells(), 10, water)``.
-
-        If you want to load different volumes of liquid into different wells, use :py:meth:`~Labware.load_liquid_by_well`.
-
-        If you want to mark the well as containing no liquid, use :py:meth:`~Labware.load_empty`.
+        This method should be called at the beginning of a protocol, soon after loading labware and before
+        liquid handling operations begin. Loading liquids is required for liquid tracking functionality. If a well
+        hasn't been assigned a starting volume with :py:meth:`~Labware.load_empty`, :py:meth:`~Labware.load_liquid`, or
+        :py:meth:`~Labware.load_liquid_by_well`, the volume it contains is unknown and the well's liquid will not be tracked throughout the protocol.
 
         :param wells: The wells to load the liquid into.
-        :type wells: List of well names or list of Well objects, for instance from :py:meth:`~Labware.wells`.
+        :type wells: List of string well names or list of :py:class:`.Well` objects (e.g., from :py:meth:`~Labware.wells`).
 
-        :param volume: The volume of liquid to load into each well, in 10µL.
+        :param volume: The volume of liquid to load into each well.
         :type volume: float
 
         :param liquid: The liquid to load into each well, previously defined by :py:meth:`~ProtocolContext.define_liquid`
@@ -1321,18 +1314,9 @@ class Labware:
     ) -> None:
         """Mark several wells as containing unique volumes of liquid.
 
-        This method should be called at the beginning of a protocol, soon after loading the labware and before
-        liquid handling operations begin. It is a base of information for liquid tracking functionality. If a well in a labware
-        has not been named in a call to :py:meth:`~Labware.load_empty`, :py:meth:`~Labware.load_liquid`, or
-        :py:meth:`~Labware.load_liquid_by_well`, the volume it contains is unknown and the well's liquid will not be tracked.
-
-        For example, to load a decreasing amount of of a liquid named ``water`` (defined with :py:meth:`~ProtocolContext.define_liquid`)
-        into each successive well of a row, you could call
-        ``labware.load_liquid_by_well({'A1': 1000, 'A2': 950, 'A3': 900, ..., 'A12': 600}, water)``
-
-        If you want to load the same volume of a liquid into multiple wells, it is often easier to use :py:meth:`~Labware.load_liquid`.
-
-        If you want to mark the well as containing no liquid, use :py:meth:`~Labware.load_empty`.
+        This method should be called at the beginning of a protocol, soon after loading labware and before
+        liquid handling begins. Loading liquids is required for liquid tracking functionality. If a well hasn't been assigned a starting volume with :py:meth:`~Labware.load_empty`, :py:meth:`~Labware.load_liquid`, or
+        :py:meth:`~Labware.load_liquid_by_well`, the volume it contains is unknown and the well's liquid will not be tracked throughout the protocol.
 
         :param volumes: A dictionary of well names (or :py:class:`Well` objects, for instance from ``labware['A1']``)
         :type wells: Dict[Union[str, Well], float]
@@ -1368,12 +1352,9 @@ class Labware:
     def load_empty(self, wells: Sequence[Union[Well, str]]) -> None:
         """Mark several wells as empty.
 
-        This method should be called at the beginning of a protocol, soon after loading the labware and before liquid handling
-        operations begin. It is a base of information for liquid tracking functionality. If a well in a labware has not been named
-        in a call to :py:meth:`Labware.load_empty`, :py:meth:`Labware.load_liquid`, or :py:meth:`Labware.load_liquid_by_well`, the
-        volume it contains is unknown and the well's liquid will not be tracked.
-
-        For instance, to mark all wells in the labware as empty, you can call ``labware.load_empty(labware.wells())``.
+        This method should be called at the beginning of a protocol, after loading the labware and before liquid handling
+        begins. Loading liquids is required for liquid tracking functionality. If a well in a labware hasn't been assigned a starting volume with :py:meth:`Labware.load_empty`, :py:meth:`Labware.load_liquid`, or :py:meth:`Labware.load_liquid_by_well`, the
+        volume it contains is unknown and the well's liquid will not be tracked throughout the protocol.
 
         :param wells: The list of wells to mark empty. To mark all wells as empty, pass ``labware.wells()``. You can also specify
                       wells by their names (for instance, ``labware.load_empty(['A1', 'A2'])``).

opentrons/protocol_engine/commands/aspirate_while_tracking.py

@@ -29,7 +29,7 @@ from ..state.update_types import StateUpdate
 from ..errors.exceptions import PipetteNotReadyToAspirateError
 from opentrons.hardware_control import HardwareControlAPI
 from ..state.update_types import CLEAR
-from ..types import CurrentWell, DeckPoint
+from ..types import DeckPoint
 
 if TYPE_CHECKING:
     from ..execution import PipettingHandler, GantryMover, MovementHandler
@@ -104,11 +104,8 @@ class AspirateWhileTrackingImplementation(
                 " The first aspirate following a blow-out must be from a specific well"
                 " so the plunger can be reset in a known safe position."
             )
-
-        current_position = await self._gantry_mover.get_position(params.pipetteId)
-        current_location = self._state_view.pipettes.get_current_location()
-
         state_update = StateUpdate()
+
         move_result = await move_to_well(
             movement=self._movement,
             model_utils=self._model_utils,
@@ -132,9 +129,9 @@ class AspirateWhileTrackingImplementation(
             flow_rate=params.flowRate,
             location_if_error={
                 "retryLocation": (
-                    current_position.x,
-                    current_position.y,
-                    current_position.z,
+                    move_result.public.position.x,
+                    move_result.public.position.y,
+                    move_result.public.position.z,
                 )
             },
             command_note_adder=self._command_note_adder,
@@ -150,58 +147,40 @@ class AspirateWhileTrackingImplementation(
             z=position_after_aspirate.z,
         )
         if isinstance(aspirate_result, DefinedErrorData):
-            if (
-                isinstance(current_location, CurrentWell)
-                and current_location.pipette_id == params.pipetteId
-            ):
-                return DefinedErrorData(
-                    public=aspirate_result.public,
-                    state_update=aspirate_result.state_update.set_liquid_operated(
-                        labware_id=current_location.labware_id,
-                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                            current_location.labware_id,
-                            current_location.well_name,
-                            params.pipetteId,
-                        ),
-                        volume_added=CLEAR,
-                    ),
-                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
-                )
-            else:
-                return aspirate_result
-        else:
-            if (
-                isinstance(current_location, CurrentWell)
-                and current_location.pipette_id == params.pipetteId
-            ):
-                return SuccessData(
-                    public=AspirateWhileTrackingResult(
-                        volume=aspirate_result.public.volume,
-                        position=result_deck_point,
-                    ),
-                    state_update=aspirate_result.state_update.set_liquid_operated(
-                        labware_id=current_location.labware_id,
-                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                            current_location.labware_id,
-                            current_location.well_name,
-                            params.pipetteId,
-                        ),
-                        volume_added=-aspirate_result.public.volume
-                        * self._state_view.geometry.get_nozzles_per_well(
-                            current_location.labware_id,
-                            current_location.well_name,
-                            params.pipetteId,
-                        ),
-                    ),
-                )
-            else:
-                return SuccessData(
-                    public=AspirateWhileTrackingResult(
-                        volume=aspirate_result.public.volume,
-                        position=result_deck_point,
+            return DefinedErrorData(
+                public=aspirate_result.public,
+                state_update=aspirate_result.state_update.set_liquid_operated(
+                    labware_id=params.labwareId,
+                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                        params.labwareId,
+                        params.wellName,
+                        params.pipetteId,
                     ),
-                    state_update=aspirate_result.state_update,
-                )
+                    volume_added=CLEAR,
+                ),
+                state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+            )
+
+        return SuccessData(
+            public=AspirateWhileTrackingResult(
+                volume=aspirate_result.public.volume,
+                position=result_deck_point,
+            ),
+            state_update=aspirate_result.state_update.set_liquid_operated(
+                labware_id=params.labwareId,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+                volume_added=-aspirate_result.public.volume
+                * self._state_view.geometry.get_nozzles_per_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+            ),
+        )
 
 
 class AspirateWhileTracking(

opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -9,7 +9,7 @@ from pydantic import Field
 from pydantic.json_schema import SkipJsonSchema
 
 from ..state.update_types import CLEAR, StateUpdate
-from ..types import CurrentWell, DeckPoint
+from ..types import DeckPoint
 from .pipetting_common import (
     PipetteIdMixin,
     DispenseVolumeMixin,
@@ -99,9 +99,6 @@ class DispenseWhileTrackingImplementation(
 
         # TODO(pbm, 10-15-24): call self._state_view.geometry.validate_dispense_volume_into_well()
 
-        current_location = self._state_view.pipettes.get_current_location()
-        current_position = await self._gantry_mover.get_position(params.pipetteId)
-
         state_update = StateUpdate()
         move_result = await move_to_well(
             movement=self._movement,
@@ -110,7 +107,6 @@ class DispenseWhileTrackingImplementation(
             labware_id=params.labwareId,
             well_name=params.wellName,
             well_location=params.wellLocation,
-            operation_volume=-params.volume,
         )
         state_update.append(move_result.state_update)
         if isinstance(move_result, DefinedErrorData):
@@ -127,9 +123,9 @@ class DispenseWhileTrackingImplementation(
             push_out=params.pushOut,
             location_if_error={
                 "retryLocation": (
-                    current_position.x,
-                    current_position.y,
-                    current_position.z,
+                    move_result.public.position.x,
+                    move_result.public.position.y,
+                    move_result.public.position.z,
                 )
             },
             pipetting=self._pipetting,
@@ -145,67 +141,40 @@ class DispenseWhileTrackingImplementation(
         )
 
         if isinstance(dispense_result, DefinedErrorData):
-            if (
-                isinstance(current_location, CurrentWell)
-                and current_location.pipette_id == params.pipetteId
-            ):
-                return DefinedErrorData(
-                    public=dispense_result.public,
-                    state_update=dispense_result.state_update.set_liquid_operated(
-                        labware_id=current_location.labware_id,
-                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                            current_location.labware_id,
-                            current_location.well_name,
-                            params.pipetteId,
-                        ),
-                        volume_added=CLEAR,
-                    ),
-                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
-                )
-            else:
-                return dispense_result
-        else:
-            if (
-                isinstance(current_location, CurrentWell)
-                and current_location.pipette_id == params.pipetteId
-            ):
-                volume_added = (
-                    self._state_view.pipettes.get_liquid_dispensed_by_ejecting_volume(
-                        pipette_id=params.pipetteId,
-                        volume=dispense_result.public.volume,
-                    )
-                )
-                if volume_added is not None:
-                    volume_added *= self._state_view.geometry.get_nozzles_per_well(
-                        current_location.labware_id,
-                        current_location.well_name,
+            return DefinedErrorData(
+                public=dispense_result.public,
+                state_update=dispense_result.state_update.set_liquid_operated(
+                    labware_id=params.labwareId,
+                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                        params.labwareId,
+                        params.wellName,
                         params.pipetteId,
-                    )
-                return SuccessData(
-                    public=DispenseWhileTrackingResult(
-                        volume=dispense_result.public.volume,
-                        position=result_deck_point,
-                    ),
-                    state_update=dispense_result.state_update.set_liquid_operated(
-                        labware_id=current_location.labware_id,
-                        well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                            current_location.labware_id,
-                            current_location.well_name,
-                            params.pipetteId,
-                        ),
-                        volume_added=volume_added
-                        if volume_added is not None
-                        else CLEAR,
                     ),
-                )
-            else:
-                return SuccessData(
-                    public=DispenseWhileTrackingResult(
-                        volume=dispense_result.public.volume,
-                        position=result_deck_point,
-                    ),
-                    state_update=dispense_result.state_update,
-                )
+                    volume_added=CLEAR,
+                ),
+                state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+            )
+
+        return SuccessData(
+            public=DispenseWhileTrackingResult(
+                volume=dispense_result.public.volume,
+                position=result_deck_point,
+            ),
+            state_update=dispense_result.state_update.set_liquid_operated(
+                labware_id=params.labwareId,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+                volume_added=dispense_result.public.volume
+                * self._state_view.geometry.get_nozzles_per_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+            ),
+        )
 
 
 class DispenseWhileTracking(

opentrons/protocol_engine/execution/pipetting.py

@@ -246,6 +246,7 @@ class HardwarePipettingHandler(PipettingHandler):
                 flow_rate=flow_rate,
                 volume=adjusted_volume,
                 push_out=push_out,
+                is_full_dispense=is_full_dispense,
             )
         return adjusted_volume
 

opentrons/util/logging_config.py

@@ -1,7 +1,8 @@
 import logging
 from logging.config import dictConfig
+from logging.handlers import QueueListener, RotatingFileHandler
 import sys
-from typing import Any, Dict
+from queue import Queue
 
 from opentrons.config import CONFIG, ARCHITECTURE, SystemArchitecture
 
@@ -12,11 +13,33 @@ else:
     SENSOR_LOG_NAME = "unused"
 
 
-def _host_config(level_value: int) -> Dict[str, Any]:
+# We want this big enough to smooth over any temporary stalls in journald's ability
+# to consume our records--but bounded, so if we consistently outpace journald for
+# some reason, we don't leak memory or get latency from buffer bloat.
+# 50000 is basically an arbitrary guess.
+_LOG_QUEUE_SIZE = 50000
+
+
+log_queue = Queue[logging.LogRecord](maxsize=_LOG_QUEUE_SIZE)
+"""A buffer through which log records will pass.
+
+This is intended to work around problems when our logs are going to journald:
+we think journald can block for a while when it flushes records to the filesystem,
+and the backpressure from that will cause calls like `log.debug()` to block and
+interfere with timing-sensitive hardware control.
+https://github.com/Opentrons/opentrons/issues/18034
+
+`log_init()` will configure all the logs that this package knows about to pass through
+this queue. This queue is exposed so consumers of this package (i.e. robot-server)
+can do the same thing with their own logs, which is important to preserve ordering.
+"""
+
+
+def _config_for_host(level_value: int) -> None:
     serial_log_filename = CONFIG["serial_log_file"]
     api_log_filename = CONFIG["api_log_file"]
     sensor_log_filename = CONFIG["sensor_log_file"]
-    return {
+    config = {
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
@@ -90,13 +113,20 @@ def _host_config(level_value: int) -> Dict[str, Any]:
         },
     }
 
+    dictConfig(config)
 
-def _buildroot_config(level_value: int) -> Dict[str, Any]:
+
+def _config_for_robot(level_value: int) -> None:
     # Import systemd.journald here since it is generally unavailble on non
     # linux systems and we probably don't want to use it on linux desktops
     # either
+    from systemd.journal import JournalHandler  # type: ignore
+
     sensor_log_filename = CONFIG["sensor_log_file"]
-    return {
+
+    sensor_log_queue = Queue[logging.LogRecord](maxsize=_LOG_QUEUE_SIZE)
+
+    config = {
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
@@ -104,36 +134,38 @@ def _buildroot_config(level_value: int) -> Dict[str, Any]:
         },
         "handlers": {
             "api": {
-                "class": "systemd.journal.JournalHandler",
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
                 "level": logging.DEBUG,
                 "formatter": "message_only",
-                "SYSLOG_IDENTIFIER": "opentrons-api",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api"},
+                "queue": log_queue,
             },
             "serial": {
-                "class": "systemd.journal.JournalHandler",
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
                 "level": logging.DEBUG,
                 "formatter": "message_only",
-                "SYSLOG_IDENTIFIER": "opentrons-api-serial",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial"},
+                "queue": log_queue,
             },
             "can_serial": {
-                "class": "systemd.journal.JournalHandler",
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
                 "level": logging.DEBUG,
                 "formatter": "message_only",
-                "SYSLOG_IDENTIFIER": "opentrons-api-serial-can",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial-can"},
+                "queue": log_queue,
             },
             "usbbin_serial": {
-                "class": "systemd.journal.JournalHandler",
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
                 "level": logging.DEBUG,
                 "formatter": "message_only",
-                "SYSLOG_IDENTIFIER": "opentrons-api-serial-usbbin",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial-usbbin"},
+                "queue": log_queue,
             },
             "sensor": {
-                "class": "logging.handlers.RotatingFileHandler",
-                "formatter": "message_only",
-                "filename": sensor_log_filename,
-                "maxBytes": 1000000,
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
                 "level": logging.DEBUG,
-                "backupCount": 3,
+                "formatter": "message_only",
+                "queue": sensor_log_queue,
             },
         },
         "loggers": {
@@ -169,12 +201,47 @@ def _buildroot_config(level_value: int) -> Dict[str, Any]:
         },
     }
 
+    # Start draining from the queue and sending messages to journald.
+    # Then, stash the queue listener in a global variable so it doesn't get garbage-collected.
+    # I don't know if we actually need to do this, but let's not find out the hard way.
+    global _queue_listener
+    if _queue_listener is not None:
+        # In case this log init function was called multiple times for some reason.
+        _queue_listener.stop()
+    _queue_listener = QueueListener(log_queue, JournalHandler())
+    _queue_listener.start()
+
+    # Sensor logs are a special one-off thing that go to their own file instead of journald.
+    # We apply the same QueueListener performance workaround for basically the same reasons.
+    sensor_rotating_file_handler = RotatingFileHandler(
+        filename=sensor_log_filename, maxBytes=1000000, backupCount=3
+    )
+    sensor_rotating_file_handler.setLevel(logging.DEBUG)
+    sensor_rotating_file_handler.setFormatter(logging.Formatter(fmt="%(message)s"))
+    global _sensor_queue_listener
+    if _sensor_queue_listener is not None:
+        _sensor_queue_listener.stop()
+    _sensor_queue_listener = QueueListener(
+        sensor_log_queue, sensor_rotating_file_handler
+    )
+    _sensor_queue_listener.start()
+
+    dictConfig(config)
 
-def _config(arch: SystemArchitecture, level_value: int) -> Dict[str, Any]:
-    return {
-        SystemArchitecture.YOCTO: _buildroot_config,
-        SystemArchitecture.BUILDROOT: _buildroot_config,
-        SystemArchitecture.HOST: _host_config,
+    # TODO(2025-04-15): We need some kind of log_deinit() function to call
+    # queue_listener.stop() before the process ends. Not doing that means we're
+    # dropping some records when the process shuts down.
+
+
+_queue_listener: QueueListener | None = None
+_sensor_queue_listener: QueueListener | None = None
+
+
+def _config(arch: SystemArchitecture, level_value: int) -> None:
+    {
+        SystemArchitecture.YOCTO: _config_for_robot,
+        SystemArchitecture.BUILDROOT: _config_for_robot,
+        SystemArchitecture.HOST: _config_for_host,
     }[arch](level_value)
 
 
@@ -191,6 +258,8 @@ def log_init(level_name: str) -> None:
             f"Defaulting to {fallback_log_level}\n"
         )
         ot_log_level = fallback_log_level
+
+    # todo(mm, 2025-04-14): Use logging.getLevelNamesMapping() when we have Python >=3.11.
     level_value = logging._nameToLevel[ot_log_level]
-    logging_config = _config(ARCHITECTURE, level_value)
-    dictConfig(logging_config)
+
+    _config(ARCHITECTURE, level_value)

opentrons/util/logging_queue_handler.py

@@ -0,0 +1,61 @@
+# noqa: D100
+
+
+import logging.handlers
+import logging
+from queue import Queue
+from typing import cast
+from typing_extensions import override
+
+
+class CustomQueueHandler(logging.handlers.QueueHandler):
+    """A logging.QueueHandler with some customizations.
+
+    - Allow adding `extra` data to handled log records.
+
+    - Simplify and optimize for single-process use.
+
+    - If a new message comes in but the queue is full, block until it has room.
+      (The default QueueHandler drops records in a way we probably wouldn't notice.)
+    """
+
+    def __init__(
+        self, *, queue: Queue[logging.LogRecord], extra: dict[str, object] | None = None
+    ) -> None:
+        """Construct the handler.
+
+        Args:
+            queue: When this handler receives a log record, it will insert the message
+                into this queue.
+            extra: Extra data to attach to each log record, to be interpreted by
+                whatever handler is on the consuming side of the queue. e.g. if that's
+                `systemd.journal.JournalHandler`, you could add a "SYSLOG_IDENTIFIER"
+                key here. This corresponds to the `extra` arg of `Logger.debug()`.
+        """
+        super().__init__(queue=queue)
+
+        # Double underscore because we're subclassing external code so we should try to
+        # avoid collisions with its attributes.
+        self.__extra = extra
+
+    @override
+    def prepare(self, record: logging.LogRecord) -> logging.LogRecord:
+        """Called internally by the superclass before enqueueing a record."""
+        if self.__extra is not None:
+            # This looks questionable, but updating __dict__ is the documented behavior
+            # of `Logger.debug(msg, extra=...)`.
+            record.__dict__.update(self.__extra)
+
+        # We intentionally do *not* call `super().prepare(record)`. It's documented to
+        # muck with the data in the LogRecord, apparently as part of supporting
+        # inter-process use. Since we don't need that, we can preserve the original
+        # data and also save some compute time.
+        return record
+
+    @override
+    def enqueue(self, record: logging.LogRecord) -> None:
+        """Called internally by the superclass to enqueue a record."""
+        # This cast is safe because we constrain the type of `self.queue`
+        # in our `__init__()` and nobody should mutate it after-the-fact, in practice.
+        queue = cast(Queue[logging.LogRecord], self.queue)
+        queue.put(record)

{opentrons-8.4.0a4.dist-info → opentrons-8.4.0a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentrons
-Version: 8.4.0a4
+Version: 8.4.0a5
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Author: Opentrons
 Author-email: engineering@opentrons.com
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 License-File: ../LICENSE
-Requires-Dist: opentrons-shared-data (==8.4.0a4)
+Requires-Dist: opentrons-shared-data (==8.4.0a5)
 Requires-Dist: aionotify (==0.3.1)
 Requires-Dist: anyio (<4.0.0,>=3.6.1)
 Requires-Dist: jsonschema (<4.18.0,>=3.0.1)
@@ -35,9 +35,9 @@ Requires-Dist: pyusb (==1.2.1)
 Requires-Dist: packaging (>=21.0)
 Requires-Dist: importlib-metadata (>=1.0) ; python_version < "3.8"
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex] (==8.4.0a4) ; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex] (==8.4.0a5) ; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware (==8.4.0a4) ; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware (==8.4.0a5) ; extra == 'ot2-hardware'
 
 .. _Full API Documentation: http://docs.opentrons.com
 

{opentrons-8.4.0a4.dist-info → opentrons-8.4.0a5.dist-info}/RECORD

@@ -228,8 +228,8 @@ opentrons/protocol_api/config.py,sha256=r9lyvXjagTX_g3q5FGURPpcz2IA9sSF7Oa_1mKx-
 opentrons/protocol_api/create_protocol_context.py,sha256=wwsZje0L__oDnu1Yrihau320_f-ASloR9eL1QCtkOh8,7612
 opentrons/protocol_api/deck.py,sha256=94vFceg1SC1bAGd7TvC1ZpYwnJR-VlzurEZ6jkacYeg,8910
 opentrons/protocol_api/disposal_locations.py,sha256=NRiSGmDR0LnbyEkWSOM-o64uR2fUoB1NWJG7Y7SsJSs,7920
-opentrons/protocol_api/instrument_context.py,sha256=t6axAJrF-0CajwWeTqKNObI7huMSx5YKibbsfyITWeI,117544
-opentrons/protocol_api/labware.py,sha256=X1SP7BGPG7Nqk7HSZTZoVhHDk0brgqA2_eGZKjPbwlY,61546
+opentrons/protocol_api/instrument_context.py,sha256=XUVIxnylpkhviFy5jxYJv-o7Lvmb2FJIbdoEjQ_9Vro,117886
+opentrons/protocol_api/labware.py,sha256=1m1y7h70bBBqW60LjiCPQWwFfVXzY_goJrB773yUN0A,60407
 opentrons/protocol_api/module_contexts.py,sha256=3tVXj6Q7n-WuTJPU_dvIQLzzGv1P-jsMuDtMVpuhAf8,48291
 opentrons/protocol_api/module_validation_and_errors.py,sha256=XL_m72P8rcvGO2fynY7UzXLcpGuI6X4s0V6Xf735Iyc,1464
 opentrons/protocol_api/protocol_context.py,sha256=CHMG5xbx_wxHDQYcobOWo2E9vsRw7FPSNy9J3YV99fM,66126
@@ -238,7 +238,7 @@ opentrons/protocol_api/validation.py,sha256=uiVTHyJF3wSh5LLfaIDBTELoMNCAT17E767u
 opentrons/protocol_api/core/__init__.py,sha256=-g74o8OtBB0LmmOvwkRvPgrHt7fF7T8FRHDj-x_-Onk,736
 opentrons/protocol_api/core/common.py,sha256=q9ZbfpRdBvB3iDAOCyONtupvkYP5n1hjE-bwqGcwP_U,1172
 opentrons/protocol_api/core/core_map.py,sha256=gq3CIYPxuPvozf8yj8FprqBfs3e4ZJGQ6s0ViPbwV08,1757
-opentrons/protocol_api/core/instrument.py,sha256=SzhVUR_ZdLfACs8blxKoJHU5aKwwoCBC2UZ07Hpmrvg,13570
+opentrons/protocol_api/core/instrument.py,sha256=MQHI1_MkrtrKM9lN-7BsVQ-xNc4on39TRr8M3HB3WPY,13705
 opentrons/protocol_api/core/labware.py,sha256=-ZOjkalikXCV3ptehKCNaWGAdKxIdwne8LRFQW9NAm4,4290
 opentrons/protocol_api/core/module.py,sha256=z2STDyqqxZX3y6UyJVDnajeFXMEn1ie2NRBYHhry_XE,13838
 opentrons/protocol_api/core/protocol.py,sha256=v7v28jfeHSfOf-tqFDW2chGtrEatPiZ1y6YNwHfmtAs,9058
@@ -248,7 +248,7 @@ opentrons/protocol_api/core/well_grid.py,sha256=BU28DKaBgEU_JdZ6pEzrwNxmuh6TkO4z
 opentrons/protocol_api/core/engine/__init__.py,sha256=B_5T7zgkWDb1mXPg4NbT-wBkQaK-WVokMMnJRNu7xiM,582
 opentrons/protocol_api/core/engine/deck_conflict.py,sha256=q3JViIAHDthIqq6ce7h2gxw3CHRfYsm5kkwzuXB-Gnc,12334
 opentrons/protocol_api/core/engine/exceptions.py,sha256=aZgNrmYEeuPZm21nX_KZYtvyjv5h_zPjxxgPkEV7_bw,725
-opentrons/protocol_api/core/engine/instrument.py,sha256=gvCUJo7Oy1KL7VUBeIQQedxFdTFFRhQGGeH-VOCtMuk,95899
+opentrons/protocol_api/core/engine/instrument.py,sha256=qkoNv0KO_jQZffQDV4ixU2r-CkLIJl5IOz1dgs1G5V8,95869
 opentrons/protocol_api/core/engine/labware.py,sha256=1xvzguNnK7aecFLiJK0gtRrZ5kpwtzLS73HnKvdJ5lc,8413
 opentrons/protocol_api/core/engine/load_labware_params.py,sha256=I4Cb8rqpBhmykQuZE8QRG802APrdCy_TYS88rm_9oGA,7159
 opentrons/protocol_api/core/engine/module_core.py,sha256=MLPgYSRJHUZPZ9rTLvsg3GlpL5b6-Pjk5UBgXCGrL6U,30994
@@ -258,12 +258,12 @@ opentrons/protocol_api/core/engine/point_calculations.py,sha256=C2eF0fvJQGMqQv3D
 opentrons/protocol_api/core/engine/protocol.py,sha256=_1gdg4lq2B21LWV9Tqb924E39HCPCgozAHxaCRGDSIk,46759
 opentrons/protocol_api/core/engine/robot.py,sha256=o252HrC11tmZ5LRKT6NwXCoTeqcQFXHeNjszfxbJHjo,5366
 opentrons/protocol_api/core/engine/stringify.py,sha256=GwFgEhFMk-uPfFQhQG_2mkaf4cxaItiY8RW7rZwiooQ,2794
-opentrons/protocol_api/core/engine/transfer_components_executor.py,sha256=2fO_SFt4Uf7Z5Byo8bJLcrieTO1DnNqbfq5ASY_Wyas,36644
+opentrons/protocol_api/core/engine/transfer_components_executor.py,sha256=96SsftBRPB5WCeChLokXkdPJcmjP8FqlXEZXhNAlZKA,37582
 opentrons/protocol_api/core/engine/well.py,sha256=PEtDwdC8NkHjqasJaDaVDtzc_WFw-qv5Lf7IU1DkrLY,7570
 opentrons/protocol_api/core/legacy/__init__.py,sha256=_9jCJNKG3SlS_vljVu8HHkZmtLf4F-f-JHALLF5d5go,401
 opentrons/protocol_api/core/legacy/deck.py,sha256=qHqcGo-Kdkl9L1aOE0pwrm9tsAnwkXbt4rIOr_VEP-s,13955
 opentrons/protocol_api/core/legacy/labware_offset_provider.py,sha256=2DLIby9xmUrwLb2ht8hZbvNTxqPhNzWijd7yCb2cqP8,3783
-opentrons/protocol_api/core/legacy/legacy_instrument_core.py,sha256=kX5QD9aeWv-ytHASwTqPUZyaiwtczWSnKwsygAJZIjM,26282
+opentrons/protocol_api/core/legacy/legacy_instrument_core.py,sha256=k-aM8Eu4qHqfhb8iRyn3jn3dZOGiq8JzQes8YUwY2v4,26501
 opentrons/protocol_api/core/legacy/legacy_labware_core.py,sha256=WQOgtMlq--zv0Ch7mmraYr9rQBT4ie2zHqwgamBq9J8,8606
 opentrons/protocol_api/core/legacy/legacy_module_core.py,sha256=tUhj88NKBMjCmCg6wjh1e2HX4d5hxjh8ZeJiYXaTaGY,23111
 opentrons/protocol_api/core/legacy/legacy_protocol_core.py,sha256=ZIFC7W6YA61oWWkq5xYGTcI_2S2pmALz16uB1R8HVyQ,23670
@@ -272,7 +272,7 @@ opentrons/protocol_api/core/legacy/load_info.py,sha256=r-WaH5ZJb3TRCp_zvbMMh0P4B
 opentrons/protocol_api/core/legacy/module_geometry.py,sha256=lvWFHZ81-JFw-1VZUW1R3yUIb59xpXT6H3jwlRintRo,21082
 opentrons/protocol_api/core/legacy/well_geometry.py,sha256=n5bEsvYZXXTAqYSAqlXd5t40bUPPrJ2Oj2frBZafQHA,4719
 opentrons/protocol_api/core/legacy_simulator/__init__.py,sha256=m9bLHGDJ6LSYC2WPm8tpOuu0zWSOPIrlybQgjRQBw9k,647
-opentrons/protocol_api/core/legacy_simulator/legacy_instrument_core.py,sha256=vScFZnEGswGLeIHPLGyJraeNoM3CJEeZ9ED4Puf7V1Y,22762
+opentrons/protocol_api/core/legacy_simulator/legacy_instrument_core.py,sha256=pV-PEw8jMcdXMi2U5yplIkFJUUlugXd7OMJl_riiVf4,22940
 opentrons/protocol_api/core/legacy_simulator/legacy_protocol_core.py,sha256=28HrrHzeUfnGKXpZqQ-VM8WbPiadqVhKj2S9y33q6Lo,2910
 opentrons/protocol_engine/__init__.py,sha256=UPSk7MbidkiSH_h4V3yxMvyTePKpRr5DM9-wfkJrlSo,4094
 opentrons/protocol_engine/create_protocol_engine.py,sha256=tfDIsC7_JKlRiCXPB_8tuxRsssU6o0ViRmWbGPtX9QA,7582
@@ -294,7 +294,7 @@ opentrons/protocol_engine/commands/__init__.py,sha256=b073p4seq9bnyqMydVrYl9b_yC
 opentrons/protocol_engine/commands/air_gap_in_place.py,sha256=Z1Tz2wFtEnlJBf_0xW0tEvX1yYJbA8ZmdZcHG_YIKwE,5387
 opentrons/protocol_engine/commands/aspirate.py,sha256=ZxpwQ5Zq-AS11aNfgxx6PsL_MrBEaawAxAi7jWwpIRE,7920
 opentrons/protocol_engine/commands/aspirate_in_place.py,sha256=vJiLSZqEzuMj-kuQESZevHM5g9brXAo159GhaFyEQm8,6530
-opentrons/protocol_engine/commands/aspirate_while_tracking.py,sha256=PTTqg-rEEzq43ukSdA8XiMxF1wY55MR6YR7bXqpZooo,8378
+opentrons/protocol_engine/commands/aspirate_while_tracking.py,sha256=se1GIJWxxVCmvYQF_nhJK11D54KKeoN5Yne5Sti93-A,7224
 opentrons/protocol_engine/commands/blow_out.py,sha256=3gboq4x5S8fq7j4ZZGNClXFDlOjcdW1v2g58GPdhaPI,4338
 opentrons/protocol_engine/commands/blow_out_in_place.py,sha256=jm2XXyJfIP9-AAFwXhD59_13nX18-i6QqpLGb-lK7sI,3391
 opentrons/protocol_engine/commands/command.py,sha256=1hWH_KWg_WDL4R4VXe1ZH2vO6pYt5SA-ZpuPPF1oV5E,10149
@@ -305,7 +305,7 @@ opentrons/protocol_engine/commands/configure_nozzle_layout.py,sha256=M_s5Ee03a7s
 opentrons/protocol_engine/commands/custom.py,sha256=vOJc7QSNnYTpLvJm98OfDKjgcvVFRZs1eEKEd9WkPN0,2157
 opentrons/protocol_engine/commands/dispense.py,sha256=gmjBXgGuWhB-SEUboXiNHqkaUrmpRTqSN4Dy362ln8w,6444
 opentrons/protocol_engine/commands/dispense_in_place.py,sha256=gcj0HXUkPrU3Qz_DbWzP3XZHuB8tXSMTo9CFoGi25lw,6263
-opentrons/protocol_engine/commands/dispense_while_tracking.py,sha256=4AU1W0f6W4W_MgvaCQk2xQXkZQRZqMIHvWoZTEEtnik,8227
+opentrons/protocol_engine/commands/dispense_while_tracking.py,sha256=vn0nw5D4ggpTEwarConFPHUVI4gNShehs5v1U5Kn9sY,6644
 opentrons/protocol_engine/commands/drop_tip.py,sha256=ZZ63IoiT4dgWcemAHhNQfV4DUhkl-ToJyTRTxIiyAkc,7895
 opentrons/protocol_engine/commands/drop_tip_in_place.py,sha256=gwSNEKBwds7kOTucXKSK74ozrDe7Cqhta7NR6IqKV3g,7062
 opentrons/protocol_engine/commands/generate_command_schema.py,sha256=21Al_XQyRMNTb2ssVaxcNSPlgreOsCtKVXf8kZgpvR4,2296
@@ -418,7 +418,7 @@ opentrons/protocol_engine/execution/hardware_stopper.py,sha256=wlIl7U3gvnOiCvwri
 opentrons/protocol_engine/execution/heater_shaker_movement_flagger.py,sha256=BSFLzSSeELAYZCrCUfJZx5DdlrwU06Ur92TYd0T-hzM,9084
 opentrons/protocol_engine/execution/labware_movement.py,sha256=XYVcxZOQ6_udpxcpwkIJpVD8-lgWLhizJAcRD9BclIo,12247
 opentrons/protocol_engine/execution/movement.py,sha256=AWcj7xlrOh3QrvoaH0sZO63yrPCEc7VE8hKfJNxxtP0,12527
-opentrons/protocol_engine/execution/pipetting.py,sha256=PSWU3c1woM4lPmMGktvq30a3BlhXtho9UrJv80e32ik,22043
+opentrons/protocol_engine/execution/pipetting.py,sha256=0_OAxIDCQBAtdNOvdYwV0kEYfJvUrJWr-63rocqf75E,22094
 opentrons/protocol_engine/execution/queue_worker.py,sha256=riVVywKIOQ3Lx-woFuuSqqBtfeKFt23nCUnsk7gSVoI,2860
 opentrons/protocol_engine/execution/rail_lights.py,sha256=eiJT6oI_kFk7rFuFkZzISZiLNnpf7Kkh86Kyk9wQ_Jo,590
 opentrons/protocol_engine/execution/run_control.py,sha256=ksvI2zkguC4G3lR3HJgAF8uY1PNcaRfi7UOYu-oIZgo,1144
@@ -580,11 +580,12 @@ opentrons/util/entrypoint_util.py,sha256=C0KN-09_WgNkqLbCyIB3yVm-kJoe7RGrZTb7qh9
 opentrons/util/get_union_elements.py,sha256=H1KqLnG1zYvI2kanhc3MXRZT-S07E5a2vF1jEkhXpCs,1073
 opentrons/util/helpers.py,sha256=3hr801bWGbxEcOFAS7f-iOhmnUhoK5qahbB8SIvaCfY,165
 opentrons/util/linal.py,sha256=IlKAP9HkNBBgULeSf4YVwSKHdx9jnCjSr7nvDvlRALg,5753
-opentrons/util/logging_config.py,sha256=UHoY7dyD6WMYNP5GKowbMxUSG_hlXeI5TaIwksR5u-U,6887
+opentrons/util/logging_config.py,sha256=7et4YYuQdWdq_e50U-8vFS_QyNBRgdnqPGAQJm8qrIo,9954
+opentrons/util/logging_queue_handler.py,sha256=ZsSJwy-oV8DXwpYiZisQ1PbYwmK2cOslD46AcyJ1E4I,2484
 opentrons/util/performance_helpers.py,sha256=ew7H8XD20iS6-2TJAzbQeyzStZkkE6PzHt_Adx3wbZQ,5172
-opentrons-8.4.0a4.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-opentrons-8.4.0a4.dist-info/METADATA,sha256=yXaEzAGJCCs5doztDC3sU4iNZ72LUclkvtfeHAQ3G0I,5084
-opentrons-8.4.0a4.dist-info/WHEEL,sha256=qUzzGenXXuJTzyjFah76kDVqDvnk-YDzY00svnrl84w,109
-opentrons-8.4.0a4.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
-opentrons-8.4.0a4.dist-info/top_level.txt,sha256=wk6whpbMZdBQpcK0Fg0YVfUGrAgVOFON7oQAhOMGMW8,10
-opentrons-8.4.0a4.dist-info/RECORD,,
+opentrons-8.4.0a5.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+opentrons-8.4.0a5.dist-info/METADATA,sha256=dVv_Zex7NX_Yf6tBwmhxcaTUWKOKDvYAmuqkq99qwEU,5084
+opentrons-8.4.0a5.dist-info/WHEEL,sha256=qUzzGenXXuJTzyjFah76kDVqDvnk-YDzY00svnrl84w,109
+opentrons-8.4.0a5.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
+opentrons-8.4.0a5.dist-info/top_level.txt,sha256=wk6whpbMZdBQpcK0Fg0YVfUGrAgVOFON7oQAhOMGMW8,10
+opentrons-8.4.0a5.dist-info/RECORD,,