pyglaze 0.2.0__tar.gz → 0.2.2__tar.gz

{pyglaze-0.2.0/src/pyglaze.egg-info → pyglaze-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglaze
-Version: 0.2.0
+Version: 0.2.2
 Summary: Pyglaze is a library used to operate the devices of Glaze Technologies
 Author: GLAZE Technologies ApS
 License: BSD 3-Clause License

{pyglaze-0.2.0 → pyglaze-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyglaze"
-version = "0.2.0"
+version = "0.2.2"
 description = "Pyglaze is a library used to operate the devices of Glaze Technologies"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -74,7 +74,7 @@ convention = "google"
 ]
 
 [tool.bumpver]
-current_version = "0.2.0"
+current_version = "0.2.2"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
 commit_message = "BUMP VERSION {old_version} -> {new_version}"
 tag_message = "v{new_version}"

pyglaze-0.2.2/src/pyglaze/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

{pyglaze-0.2.0 → pyglaze-0.2.2}/src/pyglaze/device/ampcom.py

@@ -32,6 +32,13 @@ if TYPE_CHECKING:
     from pyglaze.helpers.types import FloatArray
 
 
+class DeviceComError(Exception):
+    """Raised when an error occurs in the communication with the device."""
+
+    def __init__(self: DeviceComError, message: str) -> None:
+        super().__init__(message)
+
+
 @dataclass
 class _ForceAmpCom:
     config: ForceDeviceConfiguration
@@ -98,9 +105,7 @@ class _ForceAmpCom:
 
     def __del__(self: _ForceAmpCom) -> None:
         """Closes connection when class instance goes out of scope."""
-        with contextlib.suppress(AttributeError):
-            # If the serial device does not exist, self.__ser is never created - hence catch
-            self.__ser.close()
+        self.disconnect()
 
     def write_all(self: _ForceAmpCom) -> list[str]:
         responses = []
@@ -183,6 +188,12 @@ class _ForceAmpCom:
             output_array[iteration, 2] = angle
         return output_array
 
+    def disconnect(self: _ForceAmpCom) -> None:
+        """Closes connection."""
+        with contextlib.suppress(AttributeError):
+            # If the serial device does not exist, self.__ser is never created - hence catch
+            self.__ser.close()
+
     def _encode_send_response(self: _ForceAmpCom, command: str) -> str:
         self._encode_and_send(command)
         return self._get_response()
@@ -257,9 +268,7 @@ class _LeAmpCom:
 
     def __del__(self: _LeAmpCom) -> None:
         """Closes connection when class instance goes out of scope."""
-        with contextlib.suppress(AttributeError):
-            # If the serial device does not exist, self.__ser is never created - hence catch
-            self.__ser.close()
+        self.disconnect()
 
     def write_all(self: _LeAmpCom) -> list[str]:
         responses: list[str] = []
@@ -272,12 +281,12 @@ class _LeAmpCom:
         self._raw_byte_send_ints(
             [self.scanning_points, self.config.integration_periods, self.config.use_ema]
         )
-        return self._get_response()
+        return self._get_response(self.SEND_SETTINGS_COMMAND)
 
     def write_list(self: _LeAmpCom) -> str:
         self._encode_send_response(self.SEND_LIST_COMMAND)
         self._raw_byte_send_floats(self.scanning_list)
-        return self._get_response()
+        return self._get_response(self.SEND_LIST_COMMAND)
 
     def start_scan(self: _LeAmpCom) -> tuple[str, np.ndarray, np.ndarray, np.ndarray]:
         self._encode_send_response(self.START_COMMAND)
@@ -287,6 +296,12 @@ class _LeAmpCom:
         radii, angles = self._convert_to_r_angle(Xs, Ys)
         return self.START_COMMAND, np.array(times), np.array(radii), np.array(angles)
 
+    def disconnect(self: _LeAmpCom) -> None:
+        """Closes connection when class instance goes out of scope."""
+        with contextlib.suppress(AttributeError):
+            # If the serial device does not exist, self.__ser is never created - hence catch
+            self.__ser.close()
+
     @cached_property
     def _intervals(self: _LeAmpCom) -> list[Interval]:
         """Intervals squished into effective DAC range."""
@@ -301,7 +316,7 @@ class _LeAmpCom:
 
     def _encode_send_response(self: _LeAmpCom, command: str) -> str:
         self._encode_and_send(command)
-        return self._get_response()
+        return self._get_response(command)
 
     def _encode_and_send(self: _LeAmpCom, command: str) -> None:
         self.__ser.write(command.encode(self.ENCODING))
@@ -326,9 +341,19 @@ class _LeAmpCom:
             time.sleep(self.config._sweep_length_ms * 1e-3 * 0.01)  # noqa: SLF001, access to private attribute for backwards compatibility
             status = self._get_status()
 
-    @_BackoffRetry(backoff_base=0.05, logger=logging.getLogger(LOGGER_NAME))
-    def _get_response(self: _LeAmpCom) -> str:
-        return self.__ser.read_until().decode(self.ENCODING).strip()
+    @_BackoffRetry(
+        backoff_base=1e-2, max_tries=3, logger=logging.getLogger(LOGGER_NAME)
+    )
+    def _get_response(self: _LeAmpCom, command: str) -> str:
+        response = self.__ser.read_until().decode(self.ENCODING).strip()
+
+        if len(response) == 0:
+            msg = f"Command: '{command}'. Empty response received"
+            raise serialutil.SerialException(msg)
+        if response[: len(self.OK_RESPONSE)] != self.OK_RESPONSE:
+            msg = f"Command: '{command}'. Expected response '{self.OK_RESPONSE}', received: '{response}'"
+            raise DeviceComError(msg)
+        return response
 
     @_BackoffRetry(
         backoff_base=1e-2, max_tries=5, logger=logging.getLogger(LOGGER_NAME)

{pyglaze-0.2.0 → pyglaze-0.2.2}/src/pyglaze/devtools/mock_device.py

@@ -26,6 +26,9 @@ class MockDevice(ABC):
         self: MockDevice,
         fail_after: float = np.inf,
         n_fails: float = np.inf,
+        *,
+        empty_responses: bool = False,
+        instant_response: bool = False,
     ) -> None:
         pass
 
@@ -40,6 +43,8 @@ class ForceMockDevice(MockDevice):
         self: ForceMockDevice,
         fail_after: float = np.inf,
         n_fails: float = np.inf,
+        *,
+        instant_response: bool = False,
     ) -> None:
         self.fail_after = fail_after
         self.fails_wanted = n_fails
@@ -48,6 +53,7 @@ class ForceMockDevice(MockDevice):
         self.rng = np.random.default_rng()
         self.valid_input = True
         self.experiment_running = False
+        self.instant_response = instant_response
 
         self._periods = None
         self._frequency = None
@@ -129,7 +135,8 @@ class ForceMockDevice(MockDevice):
         for _ in range(self.in_waiting):
             return_string += self.__create_random_datapoint
         return_string += "!D,DONE\\r"
-        sleep(self.sweep_length * 1e-3)
+        if not self.instant_response:
+            sleep(self.sweep_length * 1e-3)
         self.n_scans += 1
         if self.n_scans > self.fail_after and self.n_failures < self.fails_wanted:
             self.n_failures += 1
@@ -183,7 +190,12 @@ class LeMockDevice(MockDevice):
     DAC_BITWIDTH = 2**12
 
     def __init__(
-        self: LeMockDevice, fail_after: float = np.inf, n_fails: float = np.inf
+        self: LeMockDevice,
+        fail_after: float = np.inf,
+        n_fails: float = np.inf,
+        *,
+        empty_responses: bool = False,
+        instant_response: bool = False,
     ) -> None:
         self.fail_after = fail_after
         self.fails_wanted = n_fails
@@ -197,6 +209,8 @@ class LeMockDevice(MockDevice):
         self.use_ema: bool | None = None
         self.scanning_list: list[float] | None = None
         self._scan_start_time: float | None = None
+        self.empty_responses = empty_responses
+        self.instant_response = instant_response
 
     def write(self: LeMockDevice, input_bytes: bytes) -> None:
         """Mock-write to the serial connection."""
@@ -217,12 +231,16 @@ class LeMockDevice(MockDevice):
 
     def read(self: LeMockDevice, size: int) -> bytes:
         """Mock-read from the serial connection."""
+        if self.empty_responses:
+            return self._create_scan_bytes(n_bytes=0)
         if self.state == _LeMockState.IDLE:
             return self._create_scan_bytes(n_bytes=size)
         raise NotImplementedError
 
     def read_until(self: LeMockDevice, _: bytes = b"\r") -> bytes:  # noqa: PLR0911
         """Mock-read_until from the serial connection."""
+        if self.empty_responses:
+            return "".encode(self.ENCODING)
         if self.state == _LeMockState.WAITING_FOR_SETTINGS:
             return "ACK: Ready to receive settings.".encode(self.ENCODING)
         if self.state == _LeMockState.RECEIVED_SETTINGS:
@@ -353,6 +371,8 @@ def list_mock_devices() -> list[str]:
         "mock_device",
         "mock_device_scan_should_fail",
         "mock_device_fail_first_scan",
+        "mock_device_empty_responses",
+        "mock_device_instant",
     ]
 
 
@@ -362,8 +382,12 @@ def _mock_device_factory(config: DeviceConfiguration) -> MockDevice:
         return mock_class(fail_after=0)
     if config.amp_port == "mock_device":
         return mock_class()
+    if config.amp_port == "mock_device_instant":
+        return mock_class(instant_response=True)
     if config.amp_port == "mock_device_fail_first_scan":
         return mock_class(fail_after=0, n_fails=1)
+    if config.amp_port == "mock_device_empty_responses":
+        return mock_class(empty_responses=True)
 
     msg = f"Unknown mock device requested: {config.amp_port}. Valid options are: {list_mock_devices()}"
     raise ValueError(msg)

{pyglaze-0.2.0 → pyglaze-0.2.2}/src/pyglaze/scanning/_asyncscanner.py

@@ -95,13 +95,15 @@ class _AsyncScanner:
     def _get_scan(self: _AsyncScanner) -> _TimestampedWaveform:
         try:
             return self._shared_mem.get(timeout=self._SCAN_TIMEOUT)
-        except Empty as err:
+        except Exception as err:
+            scanner_err: Exception | None = None
             if self._scanner_conn.poll(timeout=self.startup_timeout):
                 msg: _ScannerHealth = self._scanner_conn.recv()
-                if not msg.is_alive:
-                    self.is_scanning = False
                 if msg.error:
-                    raise msg.error from err
+                    scanner_err = msg.error
+            self.stop_scan()
+            if scanner_err:
+                raise scanner_err from err
             raise
 
     @staticmethod
@@ -121,10 +123,11 @@ class _AsyncScanner:
         while not stop_signal.is_set():
             try:
                 waveform = _TimestampedWaveform(datetime.now(), scanner.scan())  # noqa: DTZ005
-            except (serialutil.SerialException, TimeoutError) as e:
+            except Exception as e:  # noqa: BLE001
                 parent_conn.send(
                     _ScannerHealth(is_alive=False, is_healthy=False, error=e)
                 )
+                scanner.disconnect()
                 break
 
             try:

pyglaze-0.2.2/src/pyglaze/scanning/_exceptions.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+class ScanError(Exception):
+    """Exception raised when an error while scanning occurs."""
+
+    def __init__(self: ScanError, msg: str) -> None:
+        super().__init__(msg)

{pyglaze-0.2.0 → pyglaze-0.2.2}/src/pyglaze/scanning/scanner.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Generic, TypeVar
 
 import numpy as np
+from serial import SerialException
 
 from pyglaze.datamodels import UnprocessedWaveform
 from pyglaze.device.ampcom import _ForceAmpCom, _LeAmpCom
@@ -12,6 +13,7 @@ from pyglaze.device.configuration import (
     ForceDeviceConfiguration,
     LeDeviceConfiguration,
 )
+from pyglaze.scanning._exceptions import ScanError
 
 if TYPE_CHECKING:
     from pyglaze.helpers.types import FloatArray
@@ -42,6 +44,10 @@ class _ScannerImplementation(ABC, Generic[TConfig]):
     def update_config(self: _ScannerImplementation, new_config: TConfig) -> None:
         pass
 
+    @abstractmethod
+    def disconnect(self: _ScannerImplementation) -> None:
+        pass
+
 
 class Scanner:
     """A synchronous scanner for Glaze terahertz devices."""
@@ -76,6 +82,10 @@ class Scanner:
         """
         self._scanner_impl.update_config(new_config)
 
+    def disconnect(self: Scanner) -> None:
+        """Close serial connection."""
+        self._scanner_impl.disconnect()
+
 
 class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
     """Perform synchronous terahertz scanning using a given DeviceConfiguration.
@@ -87,7 +97,7 @@ class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
 
     def __init__(self: ForceScanner, config: ForceDeviceConfiguration) -> None:
         self._config: ForceDeviceConfiguration
-        self._ampcom: _ForceAmpCom
+        self._ampcom: _ForceAmpCom | None = None
         self.config = config
         self._phase_estimator = _LockinPhaseEstimator()
 
@@ -133,6 +143,9 @@ class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
         Returns:
             Unprocessed scan.
         """
+        if self._ampcom is None:
+            msg = "Scanner not configured"
+            raise ScanError(msg)
         _, responses = self._ampcom.start_scan()
 
         time = responses[:, 0]
@@ -152,6 +165,14 @@ class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
         """
         self.config = new_config
 
+    def disconnect(self: ForceScanner) -> None:
+        """Close serial connection."""
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise SerialException(msg)
+        self._ampcom.disconnect()
+        self._ampcom = None
+
 
 class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
     """Perform synchronous terahertz scanning using a given DeviceConfiguration.
@@ -162,7 +183,7 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
 
     def __init__(self: LeScanner, config: LeDeviceConfiguration) -> None:
         self._config: LeDeviceConfiguration
-        self._ampcom: _LeAmpCom
+        self._ampcom: _LeAmpCom | None = None
         self.config = config
         self._phase_estimator = _LockinPhaseEstimator()
 
@@ -198,6 +219,9 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
         Returns:
             Unprocessed scan.
         """
+        if self._ampcom is None:
+            msg = "Scanner not configured"
+            raise ScanError(msg)
         _, time, radius, theta = self._ampcom.start_scan()
         self._phase_estimator.update_estimate(radius=radius, theta=theta)
 
@@ -213,6 +237,14 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
         """
         self.config = new_config
 
+    def disconnect(self: LeScanner) -> None:
+        """Close serial connection."""
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise ScanError(msg)
+        self._ampcom.disconnect()
+        self._ampcom = None
+
 
 def _scanner_factory(config: DeviceConfiguration) -> _ScannerImplementation:
     if isinstance(config, ForceDeviceConfiguration):

{pyglaze-0.2.0 → pyglaze-0.2.2/src/pyglaze.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyglaze
-Version: 0.2.0
+Version: 0.2.2
 Summary: Pyglaze is a library used to operate the devices of Glaze Technologies
 Author: GLAZE Technologies ApS
 License: BSD 3-Clause License

{pyglaze-0.2.0 → pyglaze-0.2.2}/src/pyglaze.egg-info/SOURCES.txt

@@ -25,5 +25,6 @@ src/pyglaze/interpolation/__init__.py
 src/pyglaze/interpolation/interpolation.py
 src/pyglaze/scanning/__init__.py
 src/pyglaze/scanning/_asyncscanner.py
+src/pyglaze/scanning/_exceptions.py
 src/pyglaze/scanning/client.py
 src/pyglaze/scanning/scanner.py

pyglaze-0.2.0/src/pyglaze/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"