pyglaze 0.1.2__tar.gz → 0.2.1__tar.gz

{pyglaze-0.1.2/src/pyglaze.egg-info → pyglaze-0.2.1}/PKG-INFO

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

{pyglaze-0.1.2 → pyglaze-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyglaze"
-version = "0.1.2"
+version = "0.2.1"
 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.1.2"
+current_version = "0.2.1"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
 commit_message = "BUMP VERSION {old_version} -> {new_version}"
 tag_message = "v{new_version}"

pyglaze-0.2.1/src/pyglaze/__init__.py

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

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze/datamodels/pulse.py

@@ -457,6 +457,24 @@ class Pulse:
 
         return cast(float, np.max(max_estimate) - np.min(min_estimate))
 
+    def estimate_zero_crossing(self: Pulse) -> float:
+        """Estimates the zero crossing of the pulse between the maximum and minimum value.
+
+        Returns:
+            float: Estimated zero crossing.
+        """
+        argmax = np.argmax(self.signal)
+        argmin = np.argmin(self.signal)
+        if argmax < argmin:
+            idx = np.searchsorted(-self.signal[argmax:argmin], 0) + argmax - 1
+        else:
+            idx = np.searchsorted(self.signal[argmin:argmax], 0) + argmin - 1
+
+        # To find the zero crossing, solve 0 = s1 + a * (t - t1) for t: t = t1 - s1 / a
+        t1, s1 = self.time[idx], self.signal[idx]
+        a = (self.signal[idx + 1] - self.signal[idx]) / self.dt
+        return cast(float, t1 - s1 / a)
+
     def to_native_dict(self: Pulse) -> dict[str, list[float] | None]:
         """Converts the Pulse object to a native dictionary.
 

pyglaze-0.2.1/src/pyglaze/device/__init__.py

@@ -0,0 +1,7 @@
+from .configuration import ForceDeviceConfiguration, Interval, LeDeviceConfiguration
+
+__all__ = [
+    "LeDeviceConfiguration",
+    "ForceDeviceConfiguration",
+    "Interval",
+]

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze/device/ampcom.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from functools import cached_property
 from math import modf
-from typing import TYPE_CHECKING, ClassVar, overload
+from typing import TYPE_CHECKING, Callable, ClassVar, overload
 
 import numpy as np
 import serial
@@ -20,7 +20,6 @@ from pyglaze.device.configuration import (
     Interval,
     LeDeviceConfiguration,
 )
-from pyglaze.device.delayunit import Delay, load_delayunit
 from pyglaze.devtools.mock_device import _mock_device_factory
 from pyglaze.helpers.utilities import LOGGER_NAME, _BackoffRetry
 
@@ -33,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
@@ -67,7 +73,7 @@ class _ForceAmpCom:
     @cached_property
     def times(self: _ForceAmpCom) -> FloatArray:
         return _delay_from_intervals(
-            delayunit=load_delayunit(self.config.delayunit),
+            delayunit=lambda x: x,
             intervals=self.config.scan_intervals,
             points_per_interval=_points_per_interval(
                 self.scanning_points, self._squished_intervals
@@ -216,7 +222,6 @@ class _LeAmpCom:
     __ser: serial.Serial | LeMockDevice = field(init=False)
 
     ENCODING: ClassVar[str] = "utf-8"
-    DAC_BITWIDTH: ClassVar[int] = 4096  # 12-bit DAC
 
     OK_RESPONSE: ClassVar[str] = "ACK"
     START_COMMAND: ClassVar[str] = "G"
@@ -230,30 +235,30 @@ class _LeAmpCom:
         return self.config.n_points
 
     @cached_property
-    def times(self: _LeAmpCom) -> FloatArray:
-        return _delay_from_intervals(
-            delayunit=load_delayunit(self.config.delayunit),
-            intervals=self.config.scan_intervals,
-            points_per_interval=_points_per_interval(
-                self.scanning_points, self._squished_intervals
-            ),
-        )
-
-    @cached_property
-    def scanning_list(self: _LeAmpCom) -> list[int]:
-        scanning_list: list[int] = []
+    def scanning_list(self: _LeAmpCom) -> list[float]:
+        scanning_list: list[float] = []
         for interval, n_points in zip(
-            self._squished_intervals,
-            _points_per_interval(self.scanning_points, self._squished_intervals),
+            self._intervals,
+            _points_per_interval(self.scanning_points, self._intervals),
         ):
-            denormalized = self._denormalize_interval(interval)
             scanning_list.extend(
                 np.linspace(
-                    denormalized[0], denormalized[1], n_points, endpoint=False
-                ).astype(int),
+                    interval.lower,
+                    interval.upper,
+                    n_points,
+                    endpoint=len(self._intervals) == 1,
+                ),
             )
         return scanning_list
 
+    @cached_property
+    def bytes_to_receive(self: _LeAmpCom) -> int:
+        """Number of bytes to receive for a single scan.
+
+        We expect to receive 3 arrays of floats (delays, X and Y), each with self.scanning_points elements.
+        """
+        return self.scanning_points * 12
+
     def __post_init__(self: _LeAmpCom) -> None:
         self.__ser = _serial_factory(self.config)
 
@@ -271,39 +276,28 @@ class _LeAmpCom:
 
     def write_list_length_and_integration_periods_and_use_ema(self: _LeAmpCom) -> str:
         self._encode_send_response(self.SEND_SETTINGS_COMMAND)
-        self._raw_byte_send(
+        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(self.scanning_list)
-        return self._get_response()
+        self._raw_byte_send_floats(self.scanning_list)
+        return self._get_response(self.SEND_LIST_COMMAND)
 
-    def start_scan(self: _LeAmpCom) -> tuple[str, np.ndarray]:
+    def start_scan(self: _LeAmpCom) -> tuple[str, np.ndarray, np.ndarray, np.ndarray]:
         self._encode_send_response(self.START_COMMAND)
         self._await_scan_finished()
-        Xs, Ys = self._read_scan()
+        times, Xs, Ys = self._read_scan()
 
         radii, angles = self._convert_to_r_angle(Xs, Ys)
-
-        output_array = np.zeros((self.scanning_points, 3))
-        output_array[:, 0] = self.times
-        output_array[:, 1] = radii
-        output_array[:, 2] = angles
-
-        return self.START_COMMAND, output_array
+        return self.START_COMMAND, np.array(times), np.array(radii), np.array(angles)
 
     @cached_property
-    def _squished_intervals(self: _LeAmpCom) -> list[Interval]:
+    def _intervals(self: _LeAmpCom) -> list[Interval]:
         """Intervals squished into effective DAC range."""
-        return _squish_intervals(
-            intervals=self.config.scan_intervals or [Interval(lower=0.0, upper=1.0)],
-            lower_bound=self.config.fs_dac_lower_bound,
-            upper_bound=self.config.fs_dac_upper_bound,
-            bitwidth=self.DAC_BITWIDTH,
-        )
+        return self.config.scan_intervals or [Interval(lower=0.0, upper=1.0)]
 
     def _convert_to_r_angle(
         self: _LeAmpCom, Xs: list, Ys: list
@@ -312,24 +306,25 @@ class _LeAmpCom:
         angle = np.arctan2(np.array(Ys), np.array(Xs))
         return r, np.rad2deg(angle)
 
-    def _denormalize_interval(self: _LeAmpCom, interval: Interval) -> list[int]:
-        lower = int(interval.lower * self.DAC_BITWIDTH)
-        upper = int(interval.upper * self.DAC_BITWIDTH)
-        return [lower, upper]
-
     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))
 
-    def _raw_byte_send(self: _LeAmpCom, values: list[int]) -> None:
+    def _raw_byte_send_ints(self: _LeAmpCom, values: list[int]) -> None:
         c = BitArray()
         for value in values:
             c.append(BitArray(uintle=value, length=16))
         self.__ser.write(c.tobytes())
 
+    def _raw_byte_send_floats(self: _LeAmpCom, values: list[float]) -> None:
+        c = BitArray()
+        for value in values:
+            c.append(BitArray(floatle=value, length=32))
+        self.__ser.write(c.tobytes())
+
     def _await_scan_finished(self: _LeAmpCom) -> None:
         time.sleep(self.config._sweep_length_ms * 1.0e-3)  # noqa: SLF001, access to private attribute for backwards compatibility
         status = self._get_status()
@@ -338,33 +333,48 @@ 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)
     )
-    def _read_scan(self: _LeAmpCom) -> tuple[list[float], list[float]]:
+    def _read_scan(self: _LeAmpCom) -> tuple[list[float], list[float], list[float]]:
         self._encode_and_send(self.FETCH_COMMAND)
+        scan_bytes = self.__ser.read(self.bytes_to_receive)
 
-        bytes_to_receive = self.scanning_points * 4 + self.scanning_points * 4
-        scan_bytes = self.__ser.read(bytes_to_receive)
-        if len(scan_bytes) != bytes_to_receive:
-            msg = f"received {len(scan_bytes)} bytes, expected {bytes_to_receive}"
+        if len(scan_bytes) != self.bytes_to_receive:
+            msg = f"received {len(scan_bytes)} bytes, expected {self.bytes_to_receive}"
             raise serialutil.SerialException(msg)
 
-        Xs = [
-            BitArray(bytes=scan_bytes[d : d + 4]).floatle
-            for d in range(0, self.scanning_points * 4, 4)
-        ]
-        Ys = [
+        times = self._bytes_to_floats(scan_bytes, 0, self.scanning_points * 4)
+        Xs = self._bytes_to_floats(
+            scan_bytes, self.scanning_points * 4, self.scanning_points * 8
+        )
+        Ys = self._bytes_to_floats(
+            scan_bytes, self.scanning_points * 8, self.scanning_points * 12
+        )
+        return times, Xs, Ys
+
+    def _bytes_to_floats(
+        self: _LeAmpCom, scan_bytes: bytes, from_idx: int, to_idx: int
+    ) -> list[float]:
+        return [
             BitArray(bytes=scan_bytes[d : d + 4]).floatle
-            for d in range(self.scanning_points * 4, self.scanning_points * 8, 4)
+            for d in range(from_idx, to_idx, 4)
         ]
 
-        return Xs, Ys
-
     def _get_status(self: _LeAmpCom) -> _LeStatus:
         msg = self._encode_send_response(self.STATUS_COMMAND)
         if msg == _LeStatus.SCANNING.value:
@@ -434,7 +444,9 @@ def _squish_intervals(
 
 
 def _delay_from_intervals(
-    delayunit: Delay, intervals: list[Interval], points_per_interval: list[int]
+    delayunit: Callable[[FloatArray], FloatArray],
+    intervals: list[Interval],
+    points_per_interval: list[int],
 ) -> FloatArray:
     """Convert a list of intervals to a list of delay times."""
     times: list[float] = []

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze/device/configuration.py

@@ -5,8 +5,6 @@ from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass, field
 from typing import TYPE_CHECKING, ClassVar, TypeVar
 
-from .delayunit import validate_delayunit
-
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -83,7 +81,6 @@ class ForceDeviceConfiguration(DeviceConfiguration):
     Args:
         amp_port: The name of the serial port the amp is connected to.
         sweep_length_ms: The length of the sweep in milliseconds.
-        delayunit: Name of the delay calculator.
         scan_intervals: The intervals to scan.
         integration_periods: The number of integration periods to use.
         modulation_frequency: The frequency of the modulation in Hz.
@@ -97,7 +94,6 @@ class ForceDeviceConfiguration(DeviceConfiguration):
 
     amp_port: str
     sweep_length_ms: float
-    delayunit: str
     scan_intervals: list[Interval] = field(default_factory=lambda: [Interval(0.0, 1.0)])
     integration_periods: int = 100
     modulation_frequency: int = 10000  # Hz
@@ -114,9 +110,6 @@ class ForceDeviceConfiguration(DeviceConfiguration):
     def _sweep_length_ms(self: ForceDeviceConfiguration) -> float:
         return self.sweep_length_ms
 
-    def __post_init__(self: ForceDeviceConfiguration) -> None:  # noqa: D105
-        validate_delayunit(self.delayunit)
-
     def save(self: ForceDeviceConfiguration, path: Path) -> str:
         """Save a DeviceConfiguration to a file.
 
@@ -172,7 +165,6 @@ class LeDeviceConfiguration(DeviceConfiguration):
 
     Args:
         amp_port: The name of the serial port the amp is connected to.
-        delayunit: Name of the delay calculator.
         use_ema: Whether to use en exponentially moving average filter during lockin detection.
         n_points: The number of points to scan.
         scan_intervals: The intervals to scan.
@@ -181,21 +173,15 @@ class LeDeviceConfiguration(DeviceConfiguration):
     """
 
     amp_port: str
-    delayunit: str
     use_ema: bool = True
     n_points: int = 1000
     scan_intervals: list[Interval] = field(default_factory=lambda: [Interval(0.0, 1.0)])
     integration_periods: int = 10
     amp_timeout_seconds: float = 0.2
+    modulation_frequency: int = 10000  # Hz
 
-    modulation_frequency: ClassVar[int] = 10000  # Hz
-    fs_dac_lower_bound: ClassVar[int] = 300
-    fs_dac_upper_bound: ClassVar[int] = 3700
     amp_baudrate: ClassVar[int] = 1000000  # bit/s
 
-    def __post_init__(self: LeDeviceConfiguration) -> None:  # noqa: D105
-        validate_delayunit(self.delayunit)
-
     @property
     def _sweep_length_ms(self: LeDeviceConfiguration) -> float:
         return self.n_points * self._time_constant_ms

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze/devtools/mock_device.py

@@ -26,6 +26,8 @@ class MockDevice(ABC):
         self: MockDevice,
         fail_after: float = np.inf,
         n_fails: float = np.inf,
+        *,
+        empty_responses: bool = False,
     ) -> None:
         pass
 
@@ -183,7 +185,11 @@ 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,
     ) -> None:
         self.fail_after = fail_after
         self.fails_wanted = n_fails
@@ -195,8 +201,9 @@ class LeMockDevice(MockDevice):
         self.n_scanning_points: int | None = None
         self.integration_periods: int | None = None
         self.use_ema: bool | None = None
-        self.scanning_list: list[int] | None = None
+        self.scanning_list: list[float] | None = None
         self._scan_start_time: float | None = None
+        self.empty_responses = empty_responses
 
     def write(self: LeMockDevice, input_bytes: bytes) -> None:
         """Mock-write to the serial connection."""
@@ -217,12 +224,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:
@@ -297,7 +308,7 @@ class LeMockDevice(MockDevice):
         self.state = _LeMockState.RECEIVED_SETTINGS
 
     def _handle_waiting_for_list(self: LeMockDevice, input_bytes: bytes) -> None:
-        self.scanning_list = self._decode_ints(input_bytes)
+        self.scanning_list = self._decode_floats(input_bytes)
         self.state = _LeMockState.RECEIVED_LIST
 
     def _decode_ints(self: LeMockDevice, input_bytes: bytes) -> list[int]:
@@ -307,6 +318,13 @@ class LeMockDevice(MockDevice):
             for i in range(0, len(input_bytes), 2)
         ]
 
+    def _decode_floats(self: LeMockDevice, input_bytes: bytes) -> list[float]:
+        # Convert every four bytes to a 32-bit float (assuming little-endian format)
+        return [
+            struct.unpack("<f", input_bytes[i : i + 4])[0]
+            for i in range(0, len(input_bytes), 4)
+        ]
+
     def _scan_has_finished(self: LeMockDevice) -> bool:
         if not self.is_scanning:
             return True
@@ -329,7 +347,12 @@ class LeMockDevice(MockDevice):
             self.n_failures += 1
             numbers = np.array([])
         else:
-            numbers = self.rng.random(2 * len(self.scanning_list))
+            numbers = np.concatenate(
+                (
+                    np.array(self.scanning_list) * 100e-12,  # mock time values
+                    self.rng.random(2 * len(self.scanning_list)),
+                )
+            )
 
         # Each scanning point will generate an X and a Y value (lockin detection)
         return struct.pack("<" + "f" * len(numbers), *numbers)
@@ -341,6 +364,7 @@ def list_mock_devices() -> list[str]:
         "mock_device",
         "mock_device_scan_should_fail",
         "mock_device_fail_first_scan",
+        "mock_device_empty_responses",
     ]
 
 
@@ -352,6 +376,8 @@ def _mock_device_factory(config: DeviceConfiguration) -> MockDevice:
         return mock_class()
     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.1.2 → pyglaze-0.2.1}/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,7 +123,7 @@ 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)
                 )

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze/scanning/scanner.py

@@ -198,11 +198,7 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
         Returns:
             Unprocessed scan.
         """
-        _, responses = self._ampcom.start_scan()
-
-        time = responses[:, 0]
-        radius = responses[:, 1]
-        theta = responses[:, 2]
+        _, time, radius, theta = self._ampcom.start_scan()
         self._phase_estimator.update_estimate(radius=radius, theta=theta)
 
         return UnprocessedWaveform.from_polar_coords(

{pyglaze-0.1.2 → pyglaze-0.2.1/src/pyglaze.egg-info}/PKG-INFO

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

{pyglaze-0.1.2 → pyglaze-0.2.1}/src/pyglaze.egg-info/SOURCES.txt

@@ -15,13 +15,6 @@ src/pyglaze/datamodels/waveform.py
 src/pyglaze/device/__init__.py
 src/pyglaze/device/ampcom.py
 src/pyglaze/device/configuration.py
-src/pyglaze/device/delayunit.py
-src/pyglaze/device/identifiers.py
-src/pyglaze/device/_delayunit_data/carmen-nonuniform-2023-10-20.pickle
-src/pyglaze/device/_delayunit_data/g1-linearized-2023-04-04.pickle
-src/pyglaze/device/_delayunit_data/g2-linearized-2023-04-04.pickle
-src/pyglaze/device/_delayunit_data/g2-nonuniform-2023-04-04.pickle
-src/pyglaze/device/_delayunit_data/mock_delay.pickle
 src/pyglaze/devtools/__init__.py
 src/pyglaze/devtools/mock_device.py
 src/pyglaze/devtools/thz_pulse.py

pyglaze-0.1.2/src/pyglaze/__init__.py

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

pyglaze-0.1.2/src/pyglaze/device/__init__.py

@@ -1,15 +0,0 @@
-from .configuration import ForceDeviceConfiguration, Interval, LeDeviceConfiguration
-from .delayunit import NonuniformDelay, UniformDelay, list_delayunits, load_delayunit
-from .identifiers import get_device_id, list_devices
-
-__all__ = [
-    "LeDeviceConfiguration",
-    "ForceDeviceConfiguration",
-    "Interval",
-    "NonuniformDelay",
-    "UniformDelay",
-    "list_delayunits",
-    "load_delayunit",
-    "get_device_id",
-    "list_devices",
-]

pyglaze-0.1.2/src/pyglaze/device/delayunit.py

@@ -1,151 +0,0 @@
-from __future__ import annotations
-
-import pickle
-from abc import ABC, abstractmethod
-from dataclasses import asdict, dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import TYPE_CHECKING, Callable, cast
-from uuid import UUID, uuid4
-
-import numpy as np
-
-if TYPE_CHECKING:
-    from pyglaze.helpers.types import FloatArray
-
-__all__ = ["UniformDelay", "NonuniformDelay", "list_delayunits", "load_delayunit"]
-
-_DELAYUNITS_PATH = Path(__file__).parent / "_delayunit_data"
-
-
-def validate_delayunit(name: str) -> None:
-    delayunits = list_delayunits()
-    if name not in delayunits:
-        msg = f"Unknown delayunit '{name}'. Valid options are: {', '.join(delayunits)}."
-        raise ValueError(msg)
-
-
-def list_delayunits() -> list[str]:
-    """List all available delayunits.
-
-    Returns:
-        A list of all available delayunits.
-
-    """
-    return [delayunit.stem for delayunit in _DELAYUNITS_PATH.iterdir()]
-
-
-def load_delayunit(name: str) -> Delay:
-    """Load a delayunit by name.
-
-    Args:
-        name: The name of the delayunit to load.
-
-    Returns:
-        The loaded delayunit.
-    """
-    try:
-        return _load_delayunit_from_path(_DELAYUNITS_PATH / f"{name}.pickle")
-    except FileNotFoundError as e:
-        msg = f"Unknown delayunit requested ('{name}'). Known units are: {list_delayunits()}"
-        raise NameError(msg) from e
-
-
-def _load_delayunit_from_path(path: Path) -> Delay:
-    with Path(path).open("rb") as f:
-        _dict: dict = pickle.load(f)
-    delay_type = _dict.pop("type")
-    return cast(Delay, globals()[delay_type](**_dict))
-
-
-@dataclass(frozen=True)
-class Delay(ABC):
-    friendly_name: str
-    unique_id: UUID
-    creation_time: datetime
-
-    def __call__(self: Delay, x: FloatArray) -> FloatArray:
-        if np.max(x) > 1.0 or np.min(x) < 0.0:
-            msg = "All values of 'x' must be between 0 and 1."
-            raise ValueError(msg)
-
-        return self._call(x)
-
-    @property
-    def filename(self: Delay) -> str:
-        return f"{self.friendly_name}-{self.creation_time.strftime('%Y-%m-%d')}.pickle"
-
-    @abstractmethod
-    def _call(self: Delay, x: FloatArray) -> FloatArray: ...
-
-    def save(self: Delay, path: Path) -> None:
-        with Path(path).open("wb") as f:
-            pickle.dump({"type": self.__class__.__name__, **asdict(self)}, f)
-
-
-@dataclass(frozen=True)
-class UniformDelay(Delay):
-    """A delay calculator that calculates equidisant delays."""
-
-    time_window: float
-
-    def _call(self: UniformDelay, x: FloatArray) -> FloatArray:
-        return x * self.time_window
-
-    @classmethod
-    def new(cls: type[UniformDelay], time_window: float, friendly_name: str) -> Delay:
-        """Create a new Delay object.
-
-        Args:
-            time_window: The time window for the delay.
-            friendly_name: The friendly name of the delay.
-
-        Returns:
-            Delay: The newly created Delay object.
-        """
-        return cls(
-            friendly_name=friendly_name,
-            unique_id=uuid4(),
-            creation_time=datetime.now(),  # noqa: DTZ005
-            time_window=time_window,
-        )
-
-
-@dataclass(frozen=True)
-class NonuniformDelay(Delay):
-    """A delay calculator that calculates non-equidistant delays."""
-
-    time_window: float
-    residual_interpolator: Callable[[FloatArray], FloatArray]
-
-    def _call(self: NonuniformDelay, x: FloatArray) -> FloatArray:
-        return (
-            x * self.time_window
-            + self.residual_interpolator(x)
-            - self.residual_interpolator(np.asarray(0.0))
-        )
-
-    @classmethod
-    def new(
-        cls: type[NonuniformDelay],
-        friendly_name: str,
-        time_window: float,
-        residual_interpolator: Callable[[FloatArray], FloatArray],
-    ) -> Delay:
-        """Create a new NonuniformDelay object.
-
-        Args:
-            friendly_name: The friendly name of the NonuniformDelay object.
-            time_window: The time window of the pulse.
-            residual_interpolator: a residual interpolator for calculating the nonuniform part of the delay.
-
-        Returns:
-            Delay: The newly created Delay object.
-        """
-        return cls(
-            friendly_name=friendly_name,
-            unique_id=uuid4(),
-            creation_time=datetime.now(),  # noqa: DTZ005
-            time_window=time_window,
-            residual_interpolator=residual_interpolator,
-        )

pyglaze-0.1.2/src/pyglaze/device/identifiers.py

@@ -1,41 +0,0 @@
-from typing import Literal, get_args
-from uuid import UUID
-
-from typing_extensions import TypeAlias
-
-DeviceName: TypeAlias = Literal["glaze1", "glaze2", "carmen"]
-
-
-def _device_ids() -> dict[DeviceName, UUID]:
-    return {
-        "glaze1": UUID("5042dbda-e9bc-4216-a614-ac56d0a32023"),
-        "glaze2": UUID("66fa482a-1ef4-4076-a883-72d7bf43e151"),
-        "carmen": UUID("6a54db26-fa88-4146-b04f-b84b945bfea8"),
-    }
-
-
-def list_devices() -> list[DeviceName]:
-    """List all available devices.
-
-    Returns:
-        A list of all available devices.
-    """
-    return list(_device_ids().keys())
-
-
-def get_device_id(name: DeviceName) -> UUID:
-    """Get the UUID of a device by its name.
-
-    Args:
-        name: The name of the device.
-
-    Returns:
-        Unique identifier of a device.
-    """
-    try:
-        return _device_ids()[name]
-    except KeyError as e:
-        msg = (
-            f"Device {name} does not exist. Possible values are {get_args(DeviceName)}"
-        )
-        raise ValueError(msg) from e