opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/drivers/absorbance_reader/async_byonoy.py

@@ -1,26 +1,30 @@
-from __future__ import annotations
-
 import asyncio
+import os
 import re
 from concurrent.futures.thread import ThreadPoolExecutor
 from functools import partial
-from typing import Optional, List, Dict
-
+from typing import Any, Optional, List, Dict, Tuple
 
 from .hid_protocol import (
     AbsorbanceHidInterface as AbsProtocol,
     ErrorCodeNames,
     DeviceStateNames,
+    SlotStateNames,
+    MeasurementConfig,
 )
 from opentrons.drivers.types import (
     AbsorbanceReaderLidStatus,
     AbsorbanceReaderPlatePresence,
     AbsorbanceReaderDeviceState,
+    ABSMeasurementMode,
 )
 from opentrons.drivers.rpi_drivers.types import USBPort
+from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
 
 
 SN_PARSER = re.compile(r'ATTRS{serial}=="(?P<serial>.+?)"')
+VERSION_PARSER = re.compile(r"Absorbance (?P<version>V\d+\.\d+\.\d+)")
+SERIAL_PARSER = re.compile(r"(?P<serial>BYO[A-Z]{3}[0-9]{5})")
 
 
 class AsyncByonoy:
@@ -54,7 +58,7 @@ class AsyncByonoy:
         port: str,
         usb_port: USBPort,
         loop: Optional[asyncio.AbstractEventLoop] = None,
-    ) -> AsyncByonoy:
+    ) -> "AsyncByonoy":
         """
         Create an AsyncByonoy instance.
 
@@ -70,13 +74,13 @@ class AsyncByonoy:
         loop = loop or asyncio.get_running_loop()
         executor = ThreadPoolExecutor(max_workers=1)
 
-        import pybyonoy_device_library as byonoy  # type: ignore[import-not-found]
+        import byonoy_devices as byonoy  # type: ignore[import-not-found]
 
         interface: AbsProtocol = byonoy
 
         device_sn = cls.serial_number_from_port(usb_port.name)
         found: List[AbsProtocol.Device] = await loop.run_in_executor(
-            executor=executor, func=byonoy.byonoy_available_devices
+            executor=executor, func=byonoy.available_devices
         )
         device = cls.match_device_with_sn(device_sn, found)
 
@@ -108,191 +112,240 @@ class AsyncByonoy:
         self._loop = loop
         self._supported_wavelengths: Optional[list[int]] = None
         self._device_handle: Optional[int] = None
-        self._current_config: Optional[AbsProtocol.MeasurementConfig] = None
-
-    def _cleanup(self) -> None:
-        self._device_handle = None
-
-    def _open(self) -> None:
-        err, device_handle = self._interface.byonoy_open_device(self._device)
-        if err.name != "BYONOY_ERROR_NO_ERROR":
-            raise RuntimeError(f"Error opening device: {err}")
-        self._device_handle = device_handle
-
-    def _free(self) -> None:
-        if self._device_handle:
-            self._interface.byonoy_free_device(self._device_handle)
-            self._cleanup()
-
-    def verify_device_handle(self) -> int:
-        assert self._device_handle is not None, RuntimeError(
-            "Device handle not set up."
-        )
-        return self._device_handle
-
-    def _raise_if_error(
-        self,
-        err_name: ErrorCodeNames,
-        msg: str = "Error occurred: ",
-    ) -> None:
-        if err_name != "BYONOY_ERROR_NO_ERROR":
-            raise RuntimeError(msg, err_name)
-
-    def _get_device_information(self) -> AbsProtocol.DeviceInfo:
-        handle = self.verify_device_handle()
-        err, device_info = self._interface.byonoy_get_device_information(handle)
-        self._raise_if_error(err.name, "Error getting device information: ")
-        return device_info
-
-    def _get_device_status(self) -> AbsProtocol.DeviceState:
-        handle = self.verify_device_handle()
-        err, status = self._interface.byonoy_get_device_status(handle)
-        self._raise_if_error(err.name, "Error getting device status: ")
-        return status
-
-    def _get_slot_status(self) -> AbsProtocol.SlotState:
-        handle = self.verify_device_handle()
-        err, slot_status = self._interface.byonoy_get_device_slot_status(handle)
-        self._raise_if_error(err.name, "Error getting slot status: ")
-        return slot_status
-
-    def _get_lid_status(self) -> bool:
-        handle = self.verify_device_handle()
-        lid_on: bool
-        err, lid_on = self._interface.byonoy_get_device_parts_aligned(handle)
-        self._raise_if_error(err.name, "Error getting lid status: ")
-        return lid_on
-
-    def _get_supported_wavelengths(self) -> List[int]:
-        handle = self.verify_device_handle()
-        wavelengths: List[int]
-        err, wavelengths = self._interface.byonoy_abs96_get_available_wavelengths(
-            handle
-        )
-        self._raise_if_error(err.name, "Error getting available wavelengths: ")
-        self._supported_wavelengths = wavelengths
-        return wavelengths
-
-    def _initialize_measurement(self, conf: AbsProtocol.MeasurementConfig) -> None:
-        handle = self.verify_device_handle()
-        err = self._interface.byonoy_abs96_initialize_single_measurement(handle, conf)
-        self._raise_if_error(err.name, "Error initializing measurement: ")
-        self._current_config = conf
+        self._current_config: Optional[MeasurementConfig] = None
 
-    def _single_measurement(self, conf: AbsProtocol.MeasurementConfig) -> List[float]:
-        handle = self.verify_device_handle()
-        measurements: List[float]
-        err, measurements = self._interface.byonoy_abs96_single_measure(handle, conf)
-        self._raise_if_error(err.name, "Error getting single measurement: ")
-        return measurements
-
-    def _set_sample_wavelength(self, wavelength: int) -> AbsProtocol.MeasurementConfig:
-        if not self._supported_wavelengths:
-            self._get_supported_wavelengths()
-        assert self._supported_wavelengths
-        if wavelength in self._supported_wavelengths:
-            conf = self._interface.ByonoyAbs96SingleMeasurementConfig()
-            conf.sample_wavelength = wavelength
-            return conf
-        else:
-            raise ValueError(
-                f"Unsupported wavelength: {wavelength}, expected: {self._supported_wavelengths}"
-            )
-
-    def _initialize(self, wavelength: int) -> None:
-        conf = self._set_sample_wavelength(wavelength)
-        self._initialize_measurement(conf)
-
-    def _get_single_measurement(self, wavelength: int) -> List[float]:
-        initialized = self._current_config
-        assert initialized and initialized.sample_wavelength == wavelength
-        return self._single_measurement(initialized)
-
-    async def open(self) -> None:
+    async def open(self) -> bool:
         """
         Open the connection.
 
-        Returns: None
+        Returns: boolean denoting connection success.
         """
-        return await self._loop.run_in_executor(
-            executor=self._executor, func=self._open
+
+        err, device_handle = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.open_device, self._device),
         )
+        self._raise_if_error(err.name, f"Error opening device: {err}")
+        self._device_handle = device_handle
+        return bool(device_handle)
 
     async def close(self) -> None:
-        """
-        Close the connection
-
-        Returns: None
-        """
-        await self._loop.run_in_executor(executor=self._executor, func=self._free)
+        """Close the connection."""
+        handle = self._verify_device_handle()
+        await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.free_device, handle),
+        )
+        self._device_handle = None
 
     async def is_open(self) -> bool:
-        """
-        Check if connection is open.
-
-        Returns: boolean
-        """
-        return self._device_handle is not None
+        """True if connection is open."""
+        if self._device_handle is None:
+            return False
+        handle = self._verify_device_handle()
+        return await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.device_open, handle),
+        )
 
-    async def get_device_static_info(self) -> Dict[str, str]:
-        return {
-            "serial": self._device.sn,
+    async def get_device_information(self) -> Dict[str, str]:
+        """Get serial number and version info."""
+        handle = self._verify_device_handle()
+        err, device_info = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_information, handle),
+        )
+        self._raise_if_error(err.name, f"Error getting device information: {err}")
+        serial_match = SERIAL_PARSER.match(device_info.sn)
+        version_match = VERSION_PARSER.match(device_info.version)
+        serial = serial_match["serial"] if serial_match else "BYOMAA00000"
+        version = version_match["version"].lower() if version_match else "v0.0.0"
+        info = {
+            "serial": serial,
+            "version": version,
             "model": "ABS96",
-            "version": "1.0",
         }
+        return info
 
-    async def get_device_information(self) -> Dict[str, str]:
-        device_info = await self._loop.run_in_executor(
-            executor=self._executor, func=self._get_device_information
+    async def get_device_status(self) -> AbsorbanceReaderDeviceState:
+        """Get state information of the device."""
+        handle = self._verify_device_handle()
+        err, status = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_status, handle),
         )
-        return {
-            "serial_number": device_info.sn,
-            "reference_number": device_info.ref_no,
-            "version": device_info.version,
-        }
+        self._raise_if_error(err.name, f"Error getting device status: {err}")
+        return self.convert_device_state(status.name)
+
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        """Updates the firmware of the device."""
+        handle = self._verify_device_handle()
+        if not os.path.exists(firmware_file_path):
+            return False, f"Firmware file not found: {firmware_file_path}"
+        err = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.update_device, handle, firmware_file_path),
+        )
+        if err.name != "NO_ERROR":
+            return False, f"Byonoy update failed with error: {err}"
+        return True, ""
+
+    async def get_device_uptime(self) -> int:
+        """Get how long in seconds the device has been running for."""
+        handle = self._verify_device_handle()
+        err, uptime = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_uptime, handle),
+        )
+        self._raise_if_error(err.name, "Error getting device uptime: ")
+        return uptime
 
     async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
-        lid_info = await self._loop.run_in_executor(
-            executor=self._executor, func=self._get_lid_status
+        """Get the state of the absorbance lid."""
+        handle = self._verify_device_handle()
+        err, lid_info = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.get_device_parts_aligned, handle),
         )
+        self._raise_if_error(err.name, f"Error getting lid status: {err}")
         return (
             AbsorbanceReaderLidStatus.ON if lid_info else AbsorbanceReaderLidStatus.OFF
         )
 
     async def get_supported_wavelengths(self) -> list[int]:
-        return await self._loop.run_in_executor(
-            executor=self._executor, func=self._get_supported_wavelengths
+        """Get a list of the wavelength readings this device supports."""
+        handle = self._verify_device_handle()
+        err, wavelengths = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(self._interface.abs96_get_available_wavelengths, handle),
         )
+        self._raise_if_error(err.name, "Error getting available wavelengths: ")
+        self._supported_wavelengths = wavelengths
+        return wavelengths
 
-    async def initialize(self, wavelength: int) -> None:
-        return await self._loop.run_in_executor(
-            executor=self._executor, func=partial(self._initialize, wavelength)
+    async def get_measurement(self) -> List[List[float]]:
+        """Gets one or more measurements based on the current configuration."""
+        handle = self._verify_device_handle()
+        assert (
+            self._current_config is not None
+        ), "Cannot get measurement without initializing."
+        measure_func: Any = self._interface.abs96_single_measure
+        if isinstance(self._current_config, AbsProtocol.MultiMeasurementConfig):
+            measure_func = self._interface.abs96_multiple_measure
+        err, measurements = await self._loop.run_in_executor(
+            executor=self._executor,
+            func=partial(
+                measure_func,
+                handle,
+                self._current_config,
+            ),
         )
+        self._raise_if_error(err.name, f"Error getting measurement: {err}")
+        return measurements if isinstance(measurements[0], List) else [measurements]  # type: ignore
 
-    async def get_single_measurement(self, wavelength: int) -> List[float]:
-        return await self._loop.run_in_executor(
+    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
+        """Get the state of the plate for the reader."""
+        handle = self._verify_device_handle()
+        err, presence = await self._loop.run_in_executor(
             executor=self._executor,
-            func=partial(self._get_single_measurement, wavelength),
+            func=partial(self._interface.get_device_slot_status, handle),
         )
+        self._raise_if_error(err.name, f"Error getting slot status: {err}")
+        return self.convert_plate_presence(presence.name)
 
-    async def get_plate_presence(self) -> AbsorbanceReaderPlatePresence:
-        return AbsorbanceReaderPlatePresence.UNKNOWN
+    def _get_supported_wavelengths(self) -> List[int]:
+        handle = self._verify_device_handle()
+        wavelengths: List[int]
+        err, wavelengths = self._interface.abs96_get_available_wavelengths(handle)
+        self._raise_if_error(err.name, f"Error getting available wavelengths: {err}")
+        self._supported_wavelengths = wavelengths
+        return wavelengths
 
-    async def get_device_status(self) -> AbsorbanceReaderDeviceState:
-        status = await self._loop.run_in_executor(
+    def _initialize_measurement(self, conf: MeasurementConfig) -> None:
+        handle = self._verify_device_handle()
+        if isinstance(conf, AbsProtocol.SingleMeasurementConfig):
+            err = self._interface.abs96_initialize_single_measurement(handle, conf)
+        else:
+            err = self._interface.abs96_initialize_multiple_measurement(handle, conf)
+        self._raise_if_error(err.name, f"Error initializing measurement: {err}")
+        self._current_config = conf
+
+    def _initialize(
+        self,
+        mode: ABSMeasurementMode,
+        wavelengths: List[int],
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        if not self._supported_wavelengths:
+            self._get_supported_wavelengths()
+        assert self._supported_wavelengths
+        conf: MeasurementConfig
+        if set(wavelengths).issubset(self._supported_wavelengths):
+            if mode == ABSMeasurementMode.SINGLE:
+                conf = self._interface.Abs96SingleMeasurementConfig()
+                conf.sample_wavelength = wavelengths[0] or 0
+                conf.reference_wavelength = reference_wavelength or 0
+            else:
+                conf = self._interface.Abs96MultipleMeasurementConfig()
+                conf.sample_wavelengths = wavelengths
+        else:
+            raise ValueError(
+                f"Unsupported wavelength: {wavelengths}, expected: {self._supported_wavelengths}"
+            )
+        self._initialize_measurement(conf)
+
+    async def initialize(
+        self,
+        mode: ABSMeasurementMode,
+        wavelengths: List[int],
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        """initialize the device so we can start reading samples from it."""
+        await self._loop.run_in_executor(
             executor=self._executor,
-            func=self._get_device_status,
+            func=partial(self._initialize, mode, wavelengths, reference_wavelength),
         )
-        return self.convert_device_state(status.name)
+
+    def _verify_device_handle(self) -> int:
+        assert self._device_handle is not None, RuntimeError(
+            "Device handle not set up."
+        )
+        return self._device_handle
+
+    def _raise_if_error(
+        self,
+        err_name: ErrorCodeNames,
+        msg: str = "Error occurred: ",
+    ) -> None:
+        if err_name in [
+            "DEVICE_CLOSED",
+            "DEVICE_COMMUNICATION_FAILURE",
+            "UNSUPPORTED_OPERATION",
+        ]:
+            raise AbsorbanceReaderDisconnectedError(self._device.sn)
+        if err_name != "NO_ERROR":
+            raise RuntimeError(msg, err_name)
 
     @staticmethod
     def convert_device_state(
         device_state: DeviceStateNames,
     ) -> AbsorbanceReaderDeviceState:
         state_map: Dict[DeviceStateNames, AbsorbanceReaderDeviceState] = {
-            "BYONOY_DEVICE_STATE_UNKNOWN": AbsorbanceReaderDeviceState.UNKNOWN,
-            "BYONOY_DEVICE_STATE_OK": AbsorbanceReaderDeviceState.OK,
-            "BYONOY_DEVICE_STATE_BROKEN_FW": AbsorbanceReaderDeviceState.BROKEN_FW,
-            "BYONOY_DEVICE_STATE_ERROR": AbsorbanceReaderDeviceState.ERROR,
+            "UNKNOWN": AbsorbanceReaderDeviceState.UNKNOWN,
+            "OK": AbsorbanceReaderDeviceState.OK,
+            "BROKEN_FW": AbsorbanceReaderDeviceState.BROKEN_FW,
+            "ERROR": AbsorbanceReaderDeviceState.ERROR,
         }
         return state_map[device_state]
+
+    @staticmethod
+    def convert_plate_presence(
+        slot_state: SlotStateNames,
+    ) -> AbsorbanceReaderPlatePresence:
+        state_map: Dict[SlotStateNames, AbsorbanceReaderPlatePresence] = {
+            "UNKNOWN": AbsorbanceReaderPlatePresence.UNKNOWN,
+            "EMPTY": AbsorbanceReaderPlatePresence.ABSENT,
+            "OCCUPIED": AbsorbanceReaderPlatePresence.PRESENT,
+            "UNDETERMINED": AbsorbanceReaderPlatePresence.UNKNOWN,
+        }
+        return state_map[slot_state]

opentrons/drivers/absorbance_reader/driver.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Dict, Optional, List, TYPE_CHECKING
+from typing import Dict, Optional, List, Tuple, TYPE_CHECKING
 
 from opentrons.drivers.types import (
+    ABSMeasurementMode,
     AbsorbanceReaderLidStatus,
     AbsorbanceReaderDeviceState,
     AbsorbanceReaderPlatePresence,
 )
-from opentrons.drivers.absorbance_reader.abstract import AbstractAbsorbanceReaderDriver
+from opentrons.drivers.absorbance_reader.abstract import (
+    AbstractAbsorbanceReaderDriver,
+)
 from opentrons.drivers.rpi_drivers.types import USBPort
 
 if TYPE_CHECKING:
@@ -32,15 +35,6 @@ class AbsorbanceReaderDriver(AbstractAbsorbanceReaderDriver):
     def __init__(self, connection: AsyncByonoyType) -> None:
         self._connection = connection
 
-    async def get_device_info(self) -> Dict[str, str]:
-        """Get device info"""
-        connected = await self.is_connected()
-        if not connected:
-            info = await self._connection.get_device_static_info()
-        else:
-            info = await self._connection.get_device_information()
-        return info
-
     async def connect(self) -> None:
         """Connect to absorbance reader"""
         await self._connection.open()
@@ -53,17 +47,32 @@ class AbsorbanceReaderDriver(AbstractAbsorbanceReaderDriver):
         """Check connection to absorbance reader"""
         return await self._connection.is_open()
 
+    async def get_device_info(self) -> Dict[str, str]:
+        """Get device info"""
+        return await self._connection.get_device_information()
+
+    async def update_firmware(self, firmware_file_path: str) -> Tuple[bool, str]:
+        return await self._connection.update_firmware(firmware_file_path)
+
+    async def get_uptime(self) -> int:
+        return await self._connection.get_device_uptime()
+
     async def get_lid_status(self) -> AbsorbanceReaderLidStatus:
         return await self._connection.get_lid_status()
 
     async def get_available_wavelengths(self) -> List[int]:
         return await self._connection.get_supported_wavelengths()
 
-    async def get_single_measurement(self, wavelength: int) -> List[float]:
-        return await self._connection.get_single_measurement(wavelength)
+    async def initialize_measurement(
+        self,
+        wavelengths: List[int],
+        mode: ABSMeasurementMode = ABSMeasurementMode.SINGLE,
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
+        await self._connection.initialize(mode, wavelengths, reference_wavelength)
 
-    async def initialize_measurement(self, wavelength: int) -> None:
-        await self._connection.initialize(wavelength)
+    async def get_measurement(self) -> List[List[float]]:
+        return await self._connection.get_measurement()
 
     async def get_status(self) -> AbsorbanceReaderDeviceState:
         return await self._connection.get_device_status()