opentrons 8.6.0a1__py3-none-any.whl

opentrons/drivers/absorbance_reader/hid_protocol.py

@@ -0,0 +1,161 @@
+from typing import (
+    Dict,
+    Optional,
+    Protocol,
+    List,
+    Literal,
+    Tuple,
+    Union,
+    runtime_checkable,
+    TypeVar,
+)
+
+Response = TypeVar("Response")
+
+ErrorCodeNames = Literal[
+    "NO_ERROR",
+    "UNKNOWN_ERROR",
+    "DEVICE_CLOSED",
+    "INVALID_ARGUMENT",
+    "NO_MEMORY",
+    "UNSUPPORTED_OPERATION",
+    "DEVICE_COMMUNICATION_FAILURE",
+    "DEVICE_OPERATION_FAILED",
+    "DEVICE_OPEN_PREFIX",
+    "DEVICE_NOT_FOUND",
+    "DEVICE_TOO_NEW",
+    "DEVICE_ALREADY_OPEN",
+    "FIRMWARE_UPDATE_ERROR_PREFIX",
+    "FIRMWARE_UPDATE_FILE_NOT_FOUND",
+    "FIRMWARE_UPDATE_FILE_NOT_VALID",
+    "FIRMWARE_UPDATE_FAILED",
+    "FILE_ERROR_PREFIX",
+    "FILE_WRITE_ERROR",
+    "MEASUTEMNT_ERROR_PREFIX",
+    "MEASUTEMNT_SLOT_NOT_EMPTY",
+    "NOT_INITIALIZED",
+    "INTERNAL",
+]
+
+SlotStateNames = Literal[
+    "UNKNOWN",
+    "EMPTY",
+    "OCCUPIED",
+    "UNDETERMINED",
+]
+
+DeviceStateNames = Literal[
+    "UNKNOWN",
+    "OK",
+    "BROKEN_FW",
+    "ERROR",
+]
+
+
+@runtime_checkable
+class AbsorbanceHidInterface(Protocol):
+    @runtime_checkable
+    class Device(Protocol):
+        sn: str
+
+    @runtime_checkable
+    class ErrorCode(Protocol):
+        __members__: Dict[ErrorCodeNames, int]
+        name: ErrorCodeNames
+        value: int
+
+    @runtime_checkable
+    class SlotState(Protocol):
+        __members__: Dict[SlotStateNames, int]
+        name: SlotStateNames
+        value: int
+
+    @runtime_checkable
+    class SingleMeasurementConfig(Protocol):
+        sample_wavelength: int
+        reference_wavelength: Optional[int]
+
+    @runtime_checkable
+    class MultiMeasurementConfig(Protocol):
+        sample_wavelengths: List[int]
+
+    @runtime_checkable
+    class DeviceInfo(Protocol):
+        ref_no: str
+        sn: str
+        version: str
+
+    @runtime_checkable
+    class DeviceState(Protocol):
+        __members__: Dict[DeviceStateNames, int]
+        name: DeviceStateNames
+        value: int
+
+    def Abs96SingleMeasurementConfig(self) -> SingleMeasurementConfig:
+        ...
+
+    def Abs96MultipleMeasurementConfig(self) -> MultiMeasurementConfig:
+        ...
+
+    def open_device(self, device: Device) -> Tuple[ErrorCode, int]:
+        ...
+
+    def free_device(self, device_handle: int) -> Tuple[ErrorCode, bool]:
+        ...
+
+    def device_open(self, device_handle: int) -> bool:
+        ...
+
+    def get_device_information(
+        self, device_handle: int
+    ) -> Tuple[ErrorCode, DeviceInfo]:
+        ...
+
+    def update_device(self, device_handle: int, firmware_file_path: str) -> ErrorCode:
+        ...
+
+    def get_device_status(self, device_handle: int) -> Tuple[ErrorCode, DeviceState]:
+        ...
+
+    def get_device_uptime(self, device_handle: int) -> Tuple[ErrorCode, int]:
+        ...
+
+    def get_device_slot_status(self, device_handle: int) -> Tuple[ErrorCode, SlotState]:
+        ...
+
+    def get_device_parts_aligned(self, device_handle: int) -> Tuple[ErrorCode, bool]:
+        ...
+
+    def abs96_get_available_wavelengths(
+        self, device_handle: int
+    ) -> Tuple[ErrorCode, List[int]]:
+        ...
+
+    def abs96_initialize_single_measurement(
+        self, device_handle: int, conf: SingleMeasurementConfig
+    ) -> ErrorCode:
+        ...
+
+    def abs96_initialize_multiple_measurement(
+        self, device_handle: int, conf: MultiMeasurementConfig
+    ) -> ErrorCode:
+        ...
+
+    def abs96_single_measure(
+        self, device_handle: int, conf: SingleMeasurementConfig
+    ) -> Tuple[ErrorCode, List[float]]:
+        ...
+
+    def abs96_multiple_measure(
+        self, device_handle: int, conf: MultiMeasurementConfig
+    ) -> Tuple[ErrorCode, List[List[float]]]:
+        ...
+
+    def available_devices(self) -> List[Device]:
+        ...
+
+
+MeasurementConfig = Union[
+    AbsorbanceHidInterface.SingleMeasurementConfig,
+    AbsorbanceHidInterface.MultiMeasurementConfig,
+]

opentrons/drivers/absorbance_reader/simulator.py

@@ -0,0 +1,84 @@
+from typing import Dict, List, Optional, Tuple
+from opentrons.util.async_helpers import ensure_yield
+
+from opentrons.drivers.types import (
+    ABSMeasurementMode,
+    AbsorbanceReaderLidStatus,
+    AbsorbanceReaderDeviceState,
+    AbsorbanceReaderPlatePresence,
+)
+
+from .abstract import AbstractAbsorbanceReaderDriver
+
+
+class SimulatingDriver(AbstractAbsorbanceReaderDriver):
+    def __init__(
+        self, model: Optional[str] = None, serial_number: Optional[str] = None
+    ) -> None:
+        self._lid_status = AbsorbanceReaderLidStatus.ON
+        self._model = model if model else "absorbanceReaderV1"
+        self._serial_number = serial_number
+
+    def model(self) -> str:
+        return self._model
+
+    @ensure_yield
+    async def get_device_info(self) -> Dict[str, str]:
+        """Get device info"""
+        return {
+            "serial": self._serial_number if self._serial_number else "dummySerialAR",
+            "model": "dummyModelAR",
+            "version": "dummyVersionAR",
+        }
+
+    @ensure_yield
+    async def connect(self) -> None:
+        """Connect to absorbance reader"""
+        pass
+
+    @ensure_yield
+    async def disconnect(self) -> None:
+        """Disconnect from absorbance reader"""
+        pass
+
+    @ensure_yield
+    async def is_connected(self) -> bool:
+        """Check connection to absorbance reader"""
+        return True
+
+    @ensure_yield
+    async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
+        return self._lid_status
+
+    @ensure_yield
+    async def get_available_wavelengths(self) -> List[int]:
+        return [450, 570, 600, 650]
+
+    @ensure_yield
+    async def get_measurement(self) -> List[List[float]]:
+        return [[0.0]]
+
+    @ensure_yield
+    async def initialize_measurement(
+        self,
+        wavelengths: List[int],
+        mode: ABSMeasurementMode = ABSMeasurementMode.SINGLE,
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        pass
+
+    @ensure_yield
+    async def get_uptime(self) -> int:
+        return 10
+
+    @ensure_yield
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        return True, ""
+
+    @ensure_yield
+    async def get_status(self) -> AbsorbanceReaderDeviceState:
+        return AbsorbanceReaderDeviceState.OK
+
+    @ensure_yield
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        return AbsorbanceReaderPlatePresence.PRESENT

opentrons/drivers/asyncio/communication/__init__.py

@@ -0,0 +1,22 @@
+from .serial_connection import SerialConnection, AsyncResponseSerialConnection
+from opentrons.drivers.asyncio.communication.errors import (
+    SerialException,
+    NoResponse,
+    AlarmResponse,
+    ErrorResponse,
+    UnhandledGcode,
+    DefaultErrorCodes,
+)
+from .async_serial import AsyncSerial
+
+__all__ = [
+    "SerialConnection",
+    "AsyncResponseSerialConnection",
+    "AsyncSerial",
+    "SerialException",
+    "NoResponse",
+    "AlarmResponse",
+    "ErrorResponse",
+    "UnhandledGcode",
+    "DefaultErrorCodes",
+]

opentrons/drivers/asyncio/communication/async_serial.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from concurrent.futures.thread import ThreadPoolExecutor
+from functools import partial
+from typing import Optional, AsyncGenerator, Union
+from typing_extensions import Literal
+
+from serial import Serial, serial_for_url  # type: ignore[import-untyped]
+
+TimeoutProperties = Union[Literal["write_timeout"], Literal["timeout"]]
+
+
+class AsyncSerial:
+    """Async wrapper around Serial."""
+
+    @classmethod
+    async def create(
+        cls,
+        port: str,
+        baud_rate: int,
+        timeout: Optional[float] = None,
+        write_timeout: Optional[float] = None,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        reset_buffer_before_write: bool = False,
+    ) -> AsyncSerial:
+        """
+        Create an AsyncSerial instance.
+
+        Args:
+            port: url or port name
+            baud_rate: the baud rate
+            timeout: optional timeout in seconds
+            write_timeout: optional write timeout in seconds
+            loop: optional event loop. if None get_running_loop will be used
+            reset_buffer_before_write: reset the serial input buffer before
+             writing to it
+        """
+        loop = loop or asyncio.get_running_loop()
+        executor = ThreadPoolExecutor(max_workers=1)
+        serial = await loop.run_in_executor(
+            executor=executor,
+            func=partial(
+                serial_for_url,
+                url=port,
+                baudrate=baud_rate,
+                timeout=timeout,
+                write_timeout=write_timeout,
+            ),
+        )
+        return cls(
+            serial=serial,
+            executor=executor,
+            loop=loop,
+            reset_buffer_before_write=reset_buffer_before_write,
+        )
+
+    def __init__(
+        self,
+        serial: Serial,
+        executor: ThreadPoolExecutor,
+        loop: asyncio.AbstractEventLoop,
+        reset_buffer_before_write: bool,
+    ) -> None:
+        """
+        Constructor
+
+        Args:
+            serial: connected Serial object
+            executor: a thread pool executor
+            loop: event loop
+        """
+        self._serial = serial
+        self._executor = executor
+        self._loop = loop
+        self._reset_buffer_before_write = reset_buffer_before_write
+
+    async def read_until(self, match: bytes) -> bytes:
+        """
+        Read data until match.
+
+        Args:
+            match: a sequence of bytes to match
+            timeout: optional timeout in seconds. this is a temporary override
+                of parameter supplied to `create`
+
+        Returns:
+            read data.
+        """
+        return await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._serial.read_until, expected=match),
+        )
+
+    async def write(self, data: bytes) -> None:
+        """
+        Write data
+
+        Args:
+            data: data to write.
+
+        Returns:
+            None
+        """
+        await self._loop.run_in_executor(
+            executor=self._executor,
+            func=lambda: self._sync_write(data=data),
+        )
+
+    def _sync_write(self, data: bytes) -> None:
+        """
+        The synchronous write function
+
+        Args:
+            data: data to write.
+
+        Returns:
+            None
+        """
+        if self._reset_buffer_before_write:
+            self._serial.reset_input_buffer()
+        self._serial.write(data=data)
+        self._serial.flush()
+
+    async def open(self) -> None:
+        """
+        Open the connection.
+
+        Returns: None
+        """
+        return await self._loop.run_in_executor(
+            executor=self._executor, func=self._serial.open
+        )
+
+    async def close(self) -> None:
+        """
+        Close the connection
+
+        Returns: None
+        """
+        return await self._loop.run_in_executor(
+            executor=self._executor, func=self._serial.close
+        )
+
+    async def is_open(self) -> bool:
+        """
+        Check if connection is open.
+
+        Returns: boolean
+        """
+        return self._serial.is_open is True
+
+    def reset_input_buffer(self) -> None:
+        """Reset the input buffer"""
+        self._serial.reset_input_buffer()
+
+    def reset_output_buffer(self) -> None:
+        """Reset the output buffer"""
+        self._serial.reset_output_buffer()
+
+    @contextlib.asynccontextmanager
+    async def timeout_override(
+        self, timeout_property: TimeoutProperties, timeout: Optional[float]
+    ) -> AsyncGenerator[None, None]:
+        """Context manager that will temporarily override the default timeout."""
+        default_timeout = getattr(self._serial, timeout_property)
+        override = timeout is not None and default_timeout != timeout
+        try:
+            if override:
+                await self._loop.run_in_executor(
+                    executor=self._executor,
+                    func=lambda: setattr(self._serial, timeout_property, timeout),
+                )
+            yield
+        finally:
+            if override:
+                await self._loop.run_in_executor(
+                    executor=self._executor,
+                    func=lambda: setattr(
+                        self._serial, timeout_property, default_timeout
+                    ),
+                )

opentrons/drivers/asyncio/communication/errors.py

@@ -0,0 +1,88 @@
+"""Errors raised by serial connection."""
+
+from enum import Enum
+from typing import Dict, Type, Optional
+
+
+class SerialException(Exception):
+    """Base serial exception"""
+
+    def __init__(self, port: str, description: str) -> None:
+        super().__init__(f"{port}: {description}")
+        self.port = port
+        self.description = description
+
+
+class NoResponse(SerialException):
+    def __init__(self, port: str, command: str) -> None:
+        super().__init__(port=port, description=f"No response to '{command}'")
+        self.command = command
+
+
+class FailedCommand(SerialException):
+    def __init__(self, port: str, response: str) -> None:
+        super().__init__(
+            port=port, description=f"'Received error response '{response}'"
+        )
+        self.response = response
+
+
+class AlarmResponse(FailedCommand):
+    pass
+
+
+class ErrorResponse(FailedCommand):
+    def __init__(self, port: str, response: str, command: Optional[str] = None) -> None:
+        super().__init__(port, response)
+        self.command = command
+
+
+class UnhandledGcode(ErrorResponse):
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class GCodeCacheFull(ErrorResponse):
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class TaskNotReady(ErrorResponse):
+    def __init__(self, port: str, response: str, command: str) -> None:
+        super().__init__(port, response, command)
+
+
+class BaseErrorCode(Enum):
+    """Base class for error code enums.
+
+    This class should be inherited to define specific sets of error codes.
+    """
+
+    @property
+    def code_string(self) -> str:
+        """Return the error code string."""
+        code: str = self.value[0]
+        return code.lower()
+
+    @property
+    def exception(self) -> Type[ErrorResponse]:
+        """Return the exception class associated with this error code."""
+        exc: Type[ErrorResponse] = self.value[1]
+        return exc
+
+    def raise_exception(self, port: str, response: str, command: str) -> None:
+        """Raise the appropriate exception for this error code."""
+        raise self.exception(port=port, response=response, command=command)
+
+    @classmethod
+    def get_error_codes(cls) -> Dict[str, "BaseErrorCode"]:
+        """Get all error codes as a dictionary mapping code string to ErrorCode instance."""
+        return {code.code_string: code for code in cls}
+
+
+class DefaultErrorCodes(BaseErrorCode):
+    """
+    Default error codes that are previously handled by the SerialConnection class.
+    """
+
+    UNHANDLED_GCODE = ("ERR003", UnhandledGcode)