opentrons 8.6.0__py3-none-any.whl

opentrons/hardware_control/__init__.py

@@ -0,0 +1,65 @@
+"""
+hardware_control: The sole authority for controlling the hardware of an OT2.
+
+The hardware_control module presents a unified api for the lowest level of
+hardware command that takes into account the robot as a whole. For instance,
+it presents an API for moving a specific pipette mount (not a specific motor
+or axis)  to a deck-absolute point (not a Smoothie-coordinate point).
+
+This module is not for use outside the opentrons api module. Higher-level
+functions are available elsewhere.
+"""
+from .adapters import SynchronousAdapter
+from .api import API
+from .pause_manager import PauseManager
+from .backends import Controller, Simulator
+from .types import CriticalPoint, ExecutionState, OT3Mount
+from .constants import DROP_TIP_RELEASE_DISTANCE
+from .thread_manager import ThreadManager
+from .execution_manager import ExecutionManager
+from .threaded_async_lock import ThreadedAsyncLock, ThreadedAsyncForbidden
+from .protocols import HardwareControlInterface, FlexHardwareControlInterface
+from .instruments import AbstractInstrument, Gripper
+from typing import Union
+from .ot3_calibration import OT3Transforms
+from .robot_calibration import RobotCalibration
+from opentrons.config.types import RobotConfig, OT3Config
+
+from opentrons.types import Mount
+
+# TODO (lc 12-05-2022) We should 1. figure out if we need
+# to globally export a class that is strictly used in the hardware controller
+# and 2. how to properly export an ot2 and ot3 pipette.
+from .instruments.ot2.pipette import Pipette
+
+OT2HardwareControlAPI = HardwareControlInterface[RobotCalibration, Mount, RobotConfig]
+OT3HardwareControlAPI = FlexHardwareControlInterface[
+    OT3Transforms, Union[Mount, OT3Mount], OT3Config
+]
+HardwareControlAPI = Union[OT2HardwareControlAPI, OT3HardwareControlAPI]
+
+ThreadManagedHardware = ThreadManager[HardwareControlAPI]
+SyncHardwareAPI = SynchronousAdapter[HardwareControlAPI]
+
+__all__ = [
+    "API",
+    "AbstractInstrument",
+    "Controller",
+    "Simulator",
+    "Pipette",
+    "Gripper",
+    "PauseManager",
+    "SynchronousAdapter",
+    "HardwareControlAPI",
+    "CriticalPoint",
+    "DROP_TIP_RELEASE_DISTANCE",
+    "ThreadManager",
+    "ExecutionManager",
+    "ExecutionState",
+    "ThreadedAsyncLock",
+    "ThreadedAsyncForbidden",
+    "ThreadManagedHardware",
+    "SyncHardwareAPI",
+    "OT2HardwareControlAPI",
+    "OT3HardwareControlAPI",
+]

opentrons/hardware_control/__main__.py

@@ -0,0 +1,77 @@
+""" Entrypoint for the OT2 hardware control server
+
+This server listens on a variety of different interfaces and runs a hardware
+controller. It is the only thing that is allowed to talk to the OT2's hardware,
+including the smoothie, the camera, and the various GPIO interfaces.
+
+This server can only be run on a system with a connected smoothie board, and
+_should_ only be run on an OT-2.
+"""
+
+import argparse
+import asyncio
+import logging
+from typing import Optional, Dict, Any
+
+from . import API
+from .types import HardwareFeatureFlags
+from opentrons.config import robot_configs as rc
+from opentrons.config.types import RobotConfig
+
+LOG = logging.getLogger("opentrons.hardware_control.__main__")
+
+
+def exception_handler(loop: asyncio.AbstractEventLoop, context: Dict[str, Any]) -> None:
+    message = ""
+    if "exception" in context:
+        message += f'exception: {repr(context["exception"])}'
+    if "future" in context:
+        message += f' while running future {repr(context["future"])}'
+    if "protocol" in context:
+        message += f' from protocol {repr(context["protocol"])}'
+    if "transport" in context:
+        message += f' from transport {repr(context["transport"])}'
+    if "socket" in context:
+        message += f' from socket {repr(context["socket"])}'
+    LOG.error(f"Unhandled exception in event loop: {message}")
+    loop.default_exception_handler(context)
+
+
+async def arun(
+    config: Optional[RobotConfig] = None, port: Optional[str] = None
+) -> None:
+    """Asynchronous entrypoint for the server
+
+    :param config: Optional config override
+    :param port: Optional smoothie port override
+    """
+    rconf = config or rc.load()
+    hc = await API.build_hardware_controller(  # noqa: F841
+        config=rconf, port=port, feature_flags=HardwareFeatureFlags.build_from_ff()
+    )
+
+
+def run(config: Optional[RobotConfig] = None, port: Optional[str] = None) -> None:
+    """Synchronous entrypoint for the server.
+
+    Mostly builds a loop and calls arun.
+
+    :param config: Optional config override
+    :param port: Optional Smoothie port override
+    """
+    loop = asyncio.get_event_loop()
+    loop.set_exception_handler(exception_handler)
+    loop.run_until_complete(arun(config, port))
+    loop.run_forever()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Opentrons hardware control server")
+    parser.add_argument(
+        "-s",
+        "--smoothie-port",
+        help="Port on which to talk to smoothie, autodetected by default",
+        default=None,
+    )
+    args = parser.parse_args()
+    run(port=args.port)

opentrons/hardware_control/adapters.py

@@ -0,0 +1,98 @@
+""" Adapters for the :py:class:`.hardware_control.API` instances.
+"""
+import asyncio
+import functools
+from typing import Generic, TypeVar, Callable, Any, cast, Awaitable
+from .protocols import AsyncioConfigurable
+
+
+WrappedObj = TypeVar("WrappedObj", bound=AsyncioConfigurable, covariant=True)
+WrappedReturn = TypeVar("WrappedReturn")
+
+
+# TODO: BC 2020-02-25 instead of overwriting __get_attribute__ in this class
+# use inspect.getmembers to iterate over appropriate members of adapted
+# instance and setattr on the outer instance with the proper async resolution
+# logic injected. This approach avoids requiring calls to
+# object.__get_attribute__(self,...) to opt out of the overwritten
+# functionality. It is more readable and protected from
+# unintentional recursion.
+class SynchronousAdapter(Generic[WrappedObj]):
+    """A wrapper to make every call into :py:class:`.hardware_control.API`
+    synchronous.
+
+    This class expects to wrap an asynchronous object running in its own thread
+    and event loop (obj._loop). Attempting to instantiate a SynchronousAdapter
+    in the main thread within it's event loop will hang unless the adapted
+    async object is running on its own thread and contained loop.
+    In these Cases, it is often helpful to instantiate the API via the
+    :py:class:`opentrons.hardware_control.ThreadManager` to ensure that
+    all API coroutines are resolved in a thread/loop other than the
+    main thread/loop.
+
+    Example
+    -------
+    .. code-block::
+    >>> import opentrons.hardware_control as hc
+    >>> import opentrons.hardware_control.adapters as adapts
+    >>> api = hc.API.build_hardware_simulator()
+    >>> sync_api = adapts.SynchronousAdapter(api)
+    >>> sync_api.home()
+    """
+
+    def __init__(self, asynchronous_instance: WrappedObj) -> None:
+        """Build the SynchronousAdapter.
+
+        :param asynchronous_instance: The asynchronous class instance to wrap
+        """
+        self._obj_to_adapt = asynchronous_instance
+
+    def __repr__(self) -> str:
+        return "<SynchronousAdapter>"
+
+    @staticmethod
+    def call_coroutine_sync(
+        loop: asyncio.AbstractEventLoop,
+        to_call: Callable[..., Awaitable[WrappedReturn]],
+        *args: Any,
+        **kwargs: Any,
+    ) -> WrappedReturn:
+        fut = cast(
+            "asyncio.Future[WrappedReturn]",
+            asyncio.run_coroutine_threadsafe(to_call(*args, **kwargs), loop),
+        )
+        return fut.result()
+
+    def __getattribute__(self, attr_name: str) -> Any:
+        """Retrieve attributes from our API and wrap coroutines"""
+        # Almost every attribute retrieved from us will be for people actually
+        # looking for an attribute of the hardware API, so check there first.
+        obj_to_adapt = object.__getattribute__(self, "_obj_to_adapt")
+        try:
+            inner_attr = getattr(obj_to_adapt, attr_name)
+        except AttributeError:
+            # Maybe this actually was for us? Let’s find it
+            return object.__getattribute__(self, attr_name)
+
+        check = inner_attr
+        if isinstance(inner_attr, functools.partial):
+            # if partial func check passed in func
+            check = inner_attr.func
+        try:
+            # if decorated func check wrapped func
+            check = check.__wrapped__
+        except AttributeError:
+            pass
+        if asyncio.iscoroutinefunction(check):
+            # Return a synchronized version of the coroutine
+            return functools.partial(
+                object.__getattribute__(self, "call_coroutine_sync"),
+                obj_to_adapt._loop,
+                inner_attr,
+            )
+        elif asyncio.iscoroutine(check):
+            # Catch awaitable properties and reify the future before returning
+            fut = asyncio.run_coroutine_threadsafe(check, obj_to_adapt._loop)
+            return fut.result()
+
+        return inner_attr