opentrons 8.6.0__py3-none-any.whl

opentrons/util/linal.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+import logging
+import numpy as np
+from numpy import insert, dot
+from numpy.linalg import inv
+from numpy.typing import NDArray
+from typing import List, Tuple, Union
+
+from opentrons.calibration_storage.types import AttitudeMatrix
+
+mod_log = logging.getLogger(__name__)
+
+# (TODO(lc, 8/11/2020): temporary type until
+# old calibration data is removed.
+AxisPosition = Union[Tuple[float, float, float], Tuple[float, float]]
+
+SolvePoints = Tuple[
+    Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]
+]
+
+DoubleArray = NDArray[np.double]
+DoubleMatrix = NDArray[np.double]
+
+
+def identity_deck_transform() -> DoubleArray:
+    """The default deck transform"""
+    return np.identity(3)
+
+
+def solve_attitude(expected: SolvePoints, actual: SolvePoints) -> AttitudeMatrix:
+    ex: DoubleMatrix = np.array([list(point) for point in expected]).transpose()
+    ac: DoubleMatrix = np.array([list(point) for point in actual]).transpose()
+    t = np.dot(ac, inv(ex))
+
+    mask_transform: NDArray[np.bool_] = np.array(
+        [[True, True, False], [True, True, False], [False, False, False]]
+    )
+    masked_array = np.ma.masked_array(t, ~mask_transform)  # type: ignore[var-annotated, no-untyped-call]
+
+    no_z_component = np.zeros((3, 3))
+    np.put(no_z_component, [8, 8], 1)
+
+    transform = masked_array.filled(0) + no_z_component  # type: ignore[no-untyped-call]
+    return transform.round(4).tolist()  # type: ignore[no-any-return]
+
+
+def solve(
+    expected: List[Tuple[float, float]],
+    actual: List[Tuple[float, float]],
+) -> DoubleArray:
+    """
+    Takes two lists of 3 x-y points each, and calculates the matrix
+    representing the transformation from one space to the other.
+
+    The 3x3 matrix returned by this method represents the 2-D transformation
+    matrix from the actual point to the expected point.
+
+    Example:
+        If the expected points are:
+            [ (1, 1),
+              (2, 2),
+              (1, 2) ]
+        And the actual measured points are:
+            [ (1.1, 1.1),
+              (2.1, 2.1),
+              (1.1, 2.1) ]
+        (in other words, a shift of exaxtly +0.1 in both x and y)
+
+        Then the resulting transformation matrix T should be:
+            [ 1  0  -0.1 ]
+            [ 0  1  -0.1 ]
+            [ 0  0   1   ]
+
+        Then, if we take a 3x3 matrix B representing one of the measured points
+        on the deck:
+            [ 1  0  1.1 ]
+            [ 0  1  2.1 ]
+            [ 0  0  1   ]
+
+        The B*T will yield the "actual" point:
+            [ 1  0  1 ]
+            [ 0  1  2 ]
+            [ 0  0  1 ]
+
+        The return value of this function is the transformation matrix T
+    """
+    # Note: input list shape validation is handled by the type checker
+
+    # Turn expected and actual matricies into numpy ndarrays with the last row
+    # of [1 1 1] appended, and then take the dot product of the resulting
+    # actual matrix with the inverse of the resulting expected matrix.
+
+    # Shape of `expected` and `actual`:
+    # [ (x1, y1),
+    #   (x2, y2),
+    #   (x3, y3) ]
+    ex: DoubleMatrix = np.array([list(point) + [1] for point in expected]).transpose()
+
+    ac: DoubleMatrix = np.array([list(point) + [1] for point in actual]).transpose()
+    # Shape of `ex` and `ac`:
+    # [ x1 x2 x3 ]
+    # [ y1 y2 y3 ]
+    # [  1  1  1 ]
+
+    transform = np.dot(ac, inv(ex))
+    # `dot` in numpy is a misnomer. When both arguments are square, N-
+    # dimensional arrays, the return type is the result of performing matrix
+    # multiplication, rather than the dot-product (so the return here will be
+    # a 4x4 matrix)
+    return transform  # type: ignore[no-any-return]
+
+
+def add_z(xy: DoubleArray, z: float) -> DoubleArray:
+    """
+    Turn a 2-D transform matrix into a 3-D transform matrix (scale/shift only,
+    no rotation).
+
+    :param xy: A two-dimensional transform matrix (a 3x3 numpy ndarray) in the
+        following form:
+            [ 1  0  x ]
+            [ 0  1  y ]
+            [ 0  0  1 ]
+    :param z: a float for the z component
+    :return: a three-dimensional transformation matrix (a 4x4 numpy ndarray)
+        with x, y, and z from the function parameters, in the following form:
+            [ 1  0  0  x ]
+            [ 0  1  0  y ]
+            [ 0  0  1  z ]
+            [ 0  0  0  1 ]
+    """
+    # First, insert a column of zeros as into the input matrix
+    interm = insert(xy, 2, [0, 0, 0], axis=1)
+    # Result:
+    # [ 1  0  0  x ]
+    # [ 0  1  0  y ]
+    # [ 0  0  0  1 ]
+
+    # Then, insert the z row to create a properly formed 3-D transform matrix:
+    xyz: DoubleMatrix = insert(interm, 2, [0, 0, 1, z], axis=0)
+    # Result:
+    # [ 1  0  0  x ]
+    # [ 0  1  0  y ]
+    # [ 0  0  1  z ]
+    # [ 0  0  0  1 ]
+
+    return xyz.round(11)
+
+
+def add_matrices(
+    t1: Tuple[float, float, float], t2: Tuple[float, float, float]
+) -> Tuple[float, float, float]:
+    """
+    Simple method to convert tuples to numpy arrays and add them.
+    """
+    return tuple(np.asarray(t1) + np.asarray(t2))
+
+
+def apply_transform(
+    t: Union[List[List[float]], DoubleArray],
+    pos: AxisPosition,
+) -> Tuple[float, float, float]:
+    """
+    Change of base using a transform matrix. Primarily used to render a point
+    in space in a way that is more readable for the user.
+
+    :param t: A transformation matrix from one 3D space [A] to another [B]
+    :param pos: XYZ point in space A
+    :return: corresponding XYZ point in space B
+    """
+    return tuple(dot(t, list(pos))[:3])
+
+
+def apply_reverse(
+    t: Union[List[List[float]], DoubleArray],
+    pos: AxisPosition,
+) -> Tuple[float, float, float]:
+    """Like apply_transform but inverts the transform first"""
+    return apply_transform(inv(t), pos)

opentrons/util/logging_config.py

@@ -0,0 +1,265 @@
+import logging
+from logging.config import dictConfig
+from logging.handlers import QueueListener, RotatingFileHandler
+import sys
+from queue import Queue
+
+from opentrons.config import CONFIG, ARCHITECTURE, SystemArchitecture
+
+if ARCHITECTURE is SystemArchitecture.YOCTO:
+    from opentrons_hardware.sensors import SENSOR_LOG_NAME
+else:
+    # we don't use the sensor log on ot2 or host
+    SENSOR_LOG_NAME = "unused"
+
+
+# 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"]
+    config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "basic": {
+                "format": (
+                    "%(asctime)s %(name)s %(levelname)s [Line %(lineno)s] %(message)s"
+                )
+            }
+        },
+        "handlers": {
+            "debug": {
+                "class": "logging.StreamHandler",
+                "formatter": "basic",
+                "level": level_value,
+            },
+            "serial": {
+                "class": "logging.handlers.RotatingFileHandler",
+                "formatter": "basic",
+                "filename": serial_log_filename,
+                "maxBytes": 1000000,
+                "level": logging.DEBUG,
+                "backupCount": 3,
+            },
+            "api": {
+                "class": "logging.handlers.RotatingFileHandler",
+                "formatter": "basic",
+                "filename": api_log_filename,
+                "maxBytes": 1000000,
+                "level": logging.DEBUG,
+                "backupCount": 5,
+            },
+            "sensor": {
+                "class": "logging.handlers.RotatingFileHandler",
+                "formatter": "basic",
+                "filename": sensor_log_filename,
+                "maxBytes": 1000000,
+                "level": logging.DEBUG,
+                "backupCount": 5,
+            },
+        },
+        "loggers": {
+            "opentrons": {
+                "handlers": ["debug", "api"],
+                "level": level_value,
+            },
+            "opentrons.deck_calibration": {
+                "handlers": ["debug", "api"],
+                "level": level_value,
+            },
+            "opentrons.drivers.asyncio.communication.serial_connection": {
+                "handlers": ["serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "opentrons_hardware.drivers.can_bus.can_messenger": {
+                "handlers": ["serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "opentrons_hardware.drivers.binary_usb.bin_serial": {
+                "handlers": ["serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            SENSOR_LOG_NAME: {
+                "handlers": ["sensor"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "__main__": {"handlers": ["api"], "level": level_value},
+        },
+    }
+
+    dictConfig(config)
+
+
+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"]
+
+    sensor_log_queue = Queue[logging.LogRecord](maxsize=_LOG_QUEUE_SIZE)
+
+    config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "message_only": {"format": "%(message)s"},
+        },
+        "handlers": {
+            "api": {
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
+                "level": logging.DEBUG,
+                "formatter": "message_only",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api"},
+                "queue": log_queue,
+            },
+            "serial": {
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
+                "level": logging.DEBUG,
+                "formatter": "message_only",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial"},
+                "queue": log_queue,
+            },
+            "can_serial": {
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
+                "level": logging.DEBUG,
+                "formatter": "message_only",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial-can"},
+                "queue": log_queue,
+            },
+            "usbbin_serial": {
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
+                "level": logging.DEBUG,
+                "formatter": "message_only",
+                "extra": {"SYSLOG_IDENTIFIER": "opentrons-api-serial-usbbin"},
+                "queue": log_queue,
+            },
+            "sensor": {
+                "class": "opentrons.util.logging_queue_handler.CustomQueueHandler",
+                "level": logging.DEBUG,
+                "formatter": "message_only",
+                "queue": sensor_log_queue,
+            },
+        },
+        "loggers": {
+            "opentrons.drivers.asyncio.communication.serial_connection": {
+                "handlers": ["serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "opentrons": {
+                "handlers": ["api"],
+                "level": level_value,
+            },
+            "opentrons_hardware": {
+                "handlers": ["api"],
+                "level": level_value,
+            },
+            "opentrons_hardware.drivers.can_bus.can_messenger": {
+                "handlers": ["can_serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "opentrons_hardware.drivers.binary_usb.bin_serial": {
+                "handlers": ["usbbin_serial"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            SENSOR_LOG_NAME: {
+                "handlers": ["sensor"],
+                "level": logging.DEBUG,
+                "propagate": False,
+            },
+            "__main__": {"handlers": ["api"], "level": level_value},
+        },
+    }
+
+    # 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)
+
+    # 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)
+
+
+def log_init(level_name: str) -> None:
+    """
+    Function that sets log levels and format strings. Checks for the
+    OT_API_LOG_LEVEL environment variable otherwise defaults to INFO
+    """
+    fallback_log_level = "INFO"
+    ot_log_level = level_name.upper()
+    if ot_log_level not in logging._nameToLevel:
+        sys.stderr.write(
+            f"OT Log Level {ot_log_level} not found. "
+            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]
+
+    _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/util/performance_helpers.py

@@ -0,0 +1,157 @@
+"""Performance helpers for tracking robot activity."""
+
+import functools
+from pathlib import Path
+
+from opentrons_shared_data.robot.types import RobotTypeEnum
+import typing
+from opentrons.config import (
+    get_performance_metrics_data_dir,
+    robot_configs,
+    feature_flags as ff,
+)
+
+if typing.TYPE_CHECKING:
+    from performance_metrics import RobotActivityState, SupportsTracking
+
+
+_UnderlyingFunctionParameters = typing.ParamSpec("_UnderlyingFunctionParameters")
+_UnderlyingFunctionReturn = typing.TypeVar("_UnderlyingFunctionReturn")
+_UnderlyingFunction = typing.Callable[
+    _UnderlyingFunctionParameters, _UnderlyingFunctionReturn
+]
+
+
+_should_track = ff.enable_performance_metrics(
+    RobotTypeEnum.robot_literal_to_enum(robot_configs.load().model)
+)
+
+
+class _StubbedTracker:
+    """A stubbed tracker that does nothing."""
+
+    def __init__(self, storage_location: Path, should_track: bool) -> None:
+        """Initialize the stubbed tracker."""
+        pass
+
+    def track(
+        self,
+        state: "RobotActivityState",
+    ) -> typing.Callable[
+        [_UnderlyingFunction[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn]],
+        _UnderlyingFunction[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn],
+    ]:
+        """Return the original function."""
+
+        def inner_decorator(
+            func: _UnderlyingFunction[
+                _UnderlyingFunctionParameters, _UnderlyingFunctionReturn
+            ]
+        ) -> _UnderlyingFunction[
+            _UnderlyingFunctionParameters, _UnderlyingFunctionReturn
+        ]:
+            """Return the original function."""
+            return func
+
+        return inner_decorator
+
+    def store(self) -> None:
+        """Do nothing."""
+        pass
+
+
+# Ensure that _StubbedTracker implements SupportsTracking
+# but do not create a runtime dependency on performance_metrics
+if typing.TYPE_CHECKING:
+    _: typing.Type["SupportsTracking"] = _StubbedTracker
+
+
+def _handle_package_import() -> typing.Type["SupportsTracking"]:
+    """Handle the import of the performance_metrics package.
+
+    If the package is not available, return a stubbed tracker.
+    """
+    try:
+        from performance_metrics import RobotActivityTracker
+
+        return RobotActivityTracker
+    except ImportError:
+        return _StubbedTracker
+
+
+_package_to_use = _handle_package_import()
+_robot_activity_tracker: typing.Optional["SupportsTracking"] = None
+
+# TODO: derek maggio (06-03-2024): investigate if _should_track should be
+# reevaluated each time _get_robot_activity_tracker is called. I think this
+# might get stuck in a state where after the first call, _should_track is
+# always considered the initial value. It might miss changes to the feature
+# flag. The easiest way to test this is on a robot when that is working.
+
+
+def _get_robot_activity_tracker() -> "SupportsTracking":
+    """Singleton for the robot activity tracker."""
+    global _robot_activity_tracker
+    if _robot_activity_tracker is None:
+        _robot_activity_tracker = _package_to_use(
+            get_performance_metrics_data_dir(), _should_track
+        )
+    return _robot_activity_tracker
+
+
+def _track_a_function(
+    state_name: "RobotActivityState",
+    func: _UnderlyingFunction[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn],
+) -> typing.Callable[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn]:
+    """Wrap a passed function with RobotActivityTracker.track.
+
+    This function is a decorator that will track the given state for the
+    decorated function.
+
+    Args:
+        state_name: The state to annotate the tracked function with.
+        func: The function to decorate.
+
+    Returns:
+        The decorated function.
+    """
+    tracker: SupportsTracking = _get_robot_activity_tracker()
+    wrapped = tracker.track(state=state_name)(func)
+
+    @functools.wraps(func)
+    def wrapper(
+        *args: _UnderlyingFunctionParameters.args,
+        **kwargs: _UnderlyingFunctionParameters.kwargs
+    ) -> _UnderlyingFunctionReturn:
+        try:
+            return wrapped(*args, **kwargs)
+        finally:
+            # TODO: derek maggio (06-18-2024): After investigation, it appears on startup
+            # that the first call to tracker.store() will not actually store the data.
+            # The second call stores both rows of data.
+
+            tracker.store()
+
+    return wrapper
+
+
+class TrackingFunctions:
+    """A class for tracking functions."""
+
+    @staticmethod
+    def track_analysis(
+        func: _UnderlyingFunction[
+            _UnderlyingFunctionParameters, _UnderlyingFunctionReturn
+        ]
+    ) -> typing.Callable[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn]:
+        """Track a function that runs an analysis."""
+        return _track_a_function("ANALYZING_PROTOCOL", func)
+
+    @staticmethod
+    def track_getting_cached_protocol_analysis(
+        func: _UnderlyingFunction[
+            _UnderlyingFunctionParameters, _UnderlyingFunctionReturn
+        ]
+    ) -> typing.Callable[_UnderlyingFunctionParameters, _UnderlyingFunctionReturn]:
+        """Track a function that gets cached analysis."""
+        return _track_a_function("GETTING_CACHED_ANALYSIS", func)

opentrons-8.6.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: opentrons
+Version: 8.6.0
+Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
+Project-URL: opentrons.com, https://www.opentrons.com
+Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
+Project-URL: Documentation, https://docs.opentrons.com
+Author-email: Opentrons <engineering@opentrons.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: automation,lab,pcr,protocols,robots,synbio
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: aionotify==0.3.1
+Requires-Dist: anyio<5.0.0,>=4.9.0
+Requires-Dist: click<9,>=8.0.0
+Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
+Requires-Dist: jsonschema<4.18.0,>=3.0.1
+Requires-Dist: numpy<2,>=1.20.0
+Requires-Dist: opentrons-shared-data==8.6.0
+Requires-Dist: packaging>=21.0
+Requires-Dist: pydantic-settings<3,>=2
+Requires-Dist: pydantic<3,>=2.0.0
+Requires-Dist: pyserial>=3.5
+Requires-Dist: pyusb==1.2.1
+Requires-Dist: typing-extensions<5,>=4.0.0
+Provides-Extra: flex-hardware
+Requires-Dist: opentrons-hardware[flex]==8.6.0; extra == 'flex-hardware'
+Provides-Extra: ot2-hardware
+Requires-Dist: opentrons-hardware==8.6.0; extra == 'ot2-hardware'