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

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/protocol_engine/execution/tip_handler.py

@@ -1,6 +1,6 @@
 """Tip pickup and drop procedures."""
 
-from typing import Optional, Dict
+from typing import Optional, Dict, Tuple
 from typing_extensions import Protocol as TypingProtocol
 
 from opentrons.hardware_control import HardwareControlAPI
@@ -201,6 +201,18 @@ async def _available_for_nozzle_layout(  # noqa: C901
     }
 
 
+def tip_on_left_side_96(back_left_nozzle: str) -> bool:
+    """Return if there is a tip on the left edge of the 96 channel."""
+    left_most_column = int(back_left_nozzle[1:])
+    return left_most_column == 1
+
+
+def tip_on_right_side_96(front_right_nozzle: str) -> bool:
+    """Return if there is a tip on the left edge of the 96 channel."""
+    right_most_column = int(front_right_nozzle[1:])
+    return right_most_column == 12
+
+
 class HardwareTipHandler(TipHandler):
     """Pick up and drop tips, using the Hardware API."""
 
@@ -237,6 +249,50 @@ class HardwareTipHandler(TipHandler):
             channels, style, primary_nozzle, front_right_nozzle, back_left_nozzle
         )
 
+    def get_tip_presence_config(
+        self, pipette_id: str
+    ) -> Tuple[bool, Optional[InstrumentProbeType]]:
+        """Return the supported settings for tip presence on a given pipette depending on it's current nozzle map."""
+        follow_singular_sensor = None
+
+        unsupported_layout_types_96 = [NozzleConfigurationType.SINGLE]
+        # NOTE: (09-20-2024) Current on multi-channel pipettes, utilizing less than 4 nozzles risks false positives on the tip presence sensor
+        supported_partial_nozzle_minimum = 4
+
+        nozzle_configuration = self._state_view.pipettes.get_nozzle_configuration(
+            pipette_id=pipette_id
+        )
+
+        match self._state_view.pipettes.get_channels(pipette_id):
+            case 1:
+                tip_presence_supported = True
+            case 8:
+                tip_presence_supported = (
+                    nozzle_configuration.tip_count >= supported_partial_nozzle_minimum
+                )
+            case 96:
+                tip_presence_supported = (
+                    nozzle_configuration.configuration
+                    not in unsupported_layout_types_96
+                    and nozzle_configuration.tip_count
+                    >= supported_partial_nozzle_minimum
+                )
+                if (
+                    nozzle_configuration.configuration != NozzleConfigurationType.FULL
+                    and tip_presence_supported
+                ):
+                    use_left = tip_on_left_side_96(nozzle_configuration.back_left)
+                    use_right = tip_on_right_side_96(nozzle_configuration.front_right)
+                    if not (use_left and use_right):
+                        if use_left:
+                            follow_singular_sensor = InstrumentProbeType.PRIMARY
+                        else:
+                            follow_singular_sensor = InstrumentProbeType.SECONDARY
+            case _:
+                raise ValueError("Unknown pipette type.")
+
+        return (tip_presence_supported, follow_singular_sensor)
+
     async def pick_up_tip(
         self,
         pipette_id: str,
@@ -266,9 +322,18 @@ class HardwareTipHandler(TipHandler):
         await self._hardware_api.tip_pickup_moves(
             mount=hw_mount, presses=None, increment=None
         )
-        if do_not_ignore_tip_presence:
+
+        tip_presence_supported, follow_singular_sensor = self.get_tip_presence_config(
+            pipette_id
+        )
+
+        if do_not_ignore_tip_presence and tip_presence_supported:
             try:
-                await self.verify_tip_presence(pipette_id, TipPresenceStatus.PRESENT)
+                await self.verify_tip_presence(
+                    pipette_id,
+                    TipPresenceStatus.PRESENT,
+                    follow_singular_sensor=follow_singular_sensor,
+                )
             except TipNotAttachedError as e:
                 raise PickUpTipTipNotAttachedError(tip_geometry=tip_geometry) from e
 
@@ -350,30 +415,6 @@ class HardwareTipHandler(TipHandler):
         follow_singular_sensor: Optional[InstrumentProbeType] = None,
     ) -> None:
         """See documentation on abstract base class."""
-        nozzle_configuration = self._state_view.pipettes.get_nozzle_configuration(
-            pipette_id=pipette_id
-        )
-
-        # Configuration metrics by which tip presence checking is ignored
-        unsupported_pipette_types = [8, 96]
-        unsupported_layout_types = [
-            NozzleConfigurationType.SINGLE,
-            NozzleConfigurationType.COLUMN,
-        ]
-        # NOTE: (09-20-2024) Current on multi-channel pipettes, utilizing less than 4 nozzles risks false positives on the tip presence sensor
-        supported_partial_nozzle_minimum = 4
-
-        if (
-            nozzle_configuration is not None
-            and self._state_view.pipettes.get_channels(pipette_id)
-            in unsupported_pipette_types
-            and nozzle_configuration.configuration in unsupported_layout_types
-            and len(nozzle_configuration.map_store) < supported_partial_nozzle_minimum
-        ):
-            # Tip presence sensing is not supported for single tip pick up on the 96ch Flex Pipette, nor with single and some partial layous of the 8ch Flex Pipette.
-            # This is due in part to a press distance tolerance which creates a risk case for false positives. In the case of single tip, the mechanical tolerance
-            # for presses with 100% success is below the minimum average achieved press distance for a given multi channel pipette in that configuration.
-            return
         try:
             ot3api = ensure_ot3_hardware(hardware_api=self._hardware_api)
             hw_mount = self._get_hw_mount(pipette_id)

opentrons/protocol_engine/state/frustum_helpers.py

@@ -371,7 +371,7 @@ def find_volume_at_well_height(
     max_height = volumetric_capacity[-1][0]
     if target_height < 0 or target_height > max_height:
         raise InvalidLiquidHeightFound(
-            "Invalid target height {target_height} mm; max well height is {max_height} mm."
+            f"Invalid target height {target_height} mm; max well height is {max_height} mm."
         )
     # volumes in volumetric_capacity are relative to each frustum,
     # so we have to find the volume of all the full sections enclosed

opentrons/protocol_engine/state/geometry.py

@@ -7,6 +7,7 @@ from numpy.typing import NDArray
 from typing import Optional, List, Tuple, Union, cast, TypeVar, Dict, Set
 from dataclasses import dataclass
 from functools import cached_property
+from math import isclose
 
 from opentrons.types import (
     Point,
@@ -487,7 +488,7 @@ class GeometryView:
                     raise OperationLocationNotInWellError(
                         f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location that could be below the bottom of the well"
                     )
-        elif z_offset < 0:
+        elif z_offset < 0 and not isclose(z_offset, 0, abs_tol=0.0000001):
             if isinstance(well_location, LiquidHandlingWellLocation):
                 raise OperationLocationNotInWellError(
                     f"Specifying {well_location.origin} with an offset of {well_location.offset} and a volume offset of {well_location.volumeOffset} results in an operation location below the bottom of the well"

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)