pyglaze 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

pyglaze/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.0"
+__version__ = "0.2.2"

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/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/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/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/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.dist-info → pyglaze-0.2.2.dist-info}/METADATA

@@ -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.dist-info → pyglaze-0.2.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
-pyglaze/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+pyglaze/__init__.py,sha256=m6kyaNpwBcP1XYcqrelX2oS3PJuOnElOcRdBa9pEb8c,22
 pyglaze/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyglaze/datamodels/__init__.py,sha256=DJLByl2C7pC4RM4Uh6PW-McM5RIGBjcopzGywCKhSlI,111
 pyglaze/datamodels/pulse.py,sha256=BoW_GDvkwEpn_UYUFPoUfi5E_oCnvv8cU4nZKG7Ph2U,20911
 pyglaze/datamodels/waveform.py,sha256=n31DhJHFeBNZ3hHqQUiCGXssm5Dc8wV6tGPkhmFYB4Q,5809
 pyglaze/device/__init__.py,sha256=5RjCHuFKMi9g2KLUkxixO9hNpAgkUBcOURNTuhAdoUk,177
-pyglaze/device/ampcom.py,sha256=mtsprV51UeRwqkvbbLRbO2WeRd2XdFcU4_Q8AMul28g,16523
+pyglaze/device/ampcom.py,sha256=9smeYg5-3accfYWRg3K2wg1tGfirnWmPxPa4IYSvyRI,17465
 pyglaze/device/configuration.py,sha256=gh_eerX8TdXx3LnFxHieJqOpfDfE9cV6Xgm5WYVnvO0,7994
 pyglaze/devtools/__init__.py,sha256=9EW20idoaZv_5GuSgDmfpTPjfCZ-Rl27EV3oJebmwnQ,90
-pyglaze/devtools/mock_device.py,sha256=XJ1jwOOYPDqynX3QDYfEJk9n3sTMmefNPAe9N3M1T5Q,13522
+pyglaze/devtools/mock_device.py,sha256=Fz0ZCRIslokBz6gFEztv1-V1UJhdTDqujl7-l8seX7U,14394
 pyglaze/devtools/thz_pulse.py,sha256=xp-T9psdOrUMtSUFu8HEwQJVu_aMixJdZHtg_BCVu_k,923
 pyglaze/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyglaze/helpers/types.py,sha256=p9xSAP5Trr1FcCWl7ynCWqDOUZKgMQYzMUXSwDpAKHg,599
@@ -15,11 +15,12 @@ pyglaze/helpers/utilities.py,sha256=n_x9Tqm305MUorS29O6CoJM8Mi4apo2bsN_odrRaVAw,
 pyglaze/interpolation/__init__.py,sha256=WCxHPsiI7zvJykp-jfytoEbO4Tla-YIF6A7fjDfcDvU,72
 pyglaze/interpolation/interpolation.py,sha256=rQWzPD7W8TXETps7VZI0gcfAOCWO8pGL1HhhBnyxaMw,735
 pyglaze/scanning/__init__.py,sha256=uCBaeDTufOrC9KWf30ICqcmvFg_YT85olb3M9jkvZRg,99
-pyglaze/scanning/_asyncscanner.py,sha256=n4PhRBSZLFSSeGgBkgVwFsdY4rnduXJnQo6TQ0ujVkw,5224
+pyglaze/scanning/_asyncscanner.py,sha256=blnpdKBieSrUyTqmm1wZtBqp7X66WE-sFae_PpimFNU,5314
+pyglaze/scanning/_exceptions.py,sha256=vS28Dijj76jVuF6cSDBKqM9SQIa9rbIyUaHF-RA3PyM,213
 pyglaze/scanning/client.py,sha256=3qrQStkeLQzCeu4yMHJ_ENLGQ7E5GMc4CP9J55rk-ug,1817
-pyglaze/scanning/scanner.py,sha256=PSjXVpSpHpYIl-sW34pIThocbM9GSHJ_E4gGcsePeTw,8139
-pyglaze-0.2.0.dist-info/LICENSE,sha256=LCP3sGBX7LxuQopcjeug1fW4tngWCHF4zB7QCgB28xM,1504
-pyglaze-0.2.0.dist-info/METADATA,sha256=ZWjcLSzB9CD-_MmxsXdaX2tEcQbia3zLTH2kp5cnp1E,3498
-pyglaze-0.2.0.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-pyglaze-0.2.0.dist-info/top_level.txt,sha256=X7d5rqVVuWNmtK4-Uh4sgOLlqye8vaHZOr5RYba0REo,8
-pyglaze-0.2.0.dist-info/RECORD,,
+pyglaze/scanning/scanner.py,sha256=5KYVUboK4f8DWp-qRHWbvdtQ0x46AIdnCkquAO4vQOI,9205
+pyglaze-0.2.2.dist-info/LICENSE,sha256=LCP3sGBX7LxuQopcjeug1fW4tngWCHF4zB7QCgB28xM,1504
+pyglaze-0.2.2.dist-info/METADATA,sha256=fZcMCJSLAWa1ZrZDV6CPQ0jdGjhQLt5jBJ9srEgYjQM,3498
+pyglaze-0.2.2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+pyglaze-0.2.2.dist-info/top_level.txt,sha256=X7d5rqVVuWNmtK4-Uh4sgOLlqye8vaHZOr5RYba0REo,8
+pyglaze-0.2.2.dist-info/RECORD,,

{pyglaze-0.2.0.dist-info → pyglaze-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any