pyglaze 0.3.0__tar.gz → 0.4.1__tar.gz

{pyglaze-0.3.0/src/pyglaze.egg-info → pyglaze-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyglaze
-Version: 0.3.0
+Version: 0.4.1
 Summary: Pyglaze is a library used to operate the devices of Glaze Technologies
 Author: GLAZE Technologies ApS
 License: BSD 3-Clause License
@@ -35,14 +35,15 @@ Project-URL: Homepage, https://www.glazetech.dk/
 Project-URL: Documentation, https://glazetech.github.io/pyglaze/latest
 Project-URL: Repository, https://github.com/GlazeTech/pyglaze
 Project-URL: Issues, https://github.com/GlazeTech/pyglaze/issues
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0.0,>=1.26.4
+Requires-Dist: numpy>=1.26.4
 Requires-Dist: pyserial>=3.5
 Requires-Dist: scipy>=1.7.3
 Requires-Dist: bitstring>=4.1.2
 Requires-Dist: typing_extensions>=4.12.2
+Dynamic: license-file
 
 # Pyglaze
 Pyglaze is a python library used to operate the devices of [Glaze Technologies](https://www.glazetech.dk/).

{pyglaze-0.3.0 → pyglaze-0.4.1}/pyproject.toml

@@ -1,16 +1,16 @@
 [project]
 name = "pyglaze"
-version = "0.3.0"
+version = "0.4.1"
 description = "Pyglaze is a library used to operate the devices of Glaze Technologies"
 readme = "README.md"
 license = { file = "LICENSE" }
 authors = [
     {name = "GLAZE Technologies ApS"},
 ]
-requires-python = ">=3.9,<3.13"
+requires-python = ">=3.9,<3.14"
 
 dependencies = [
-    "numpy>=1.26.4,<2.0.0",
+    "numpy>=1.26.4",
     "pyserial>=3.5",
     "scipy>=1.7.3",
     "bitstring>=4.1.2",
@@ -74,7 +74,7 @@ convention = "google"
 ]
 
 [tool.bumpver]
-current_version = "0.3.0"
+current_version = "0.4.1"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
 commit_message = "BUMP VERSION {old_version} -> {new_version}"
 tag_message = "v{new_version}"

pyglaze-0.4.1/src/pyglaze/__init__.py

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

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/datamodels/pulse.py

@@ -1,20 +1,22 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, Literal, cast
+from typing import TYPE_CHECKING, Callable, Literal, cast
 
 import numpy as np
 from scipy import optimize as opt
 from scipy import signal
 from scipy.stats import linregress
 
-from pyglaze.helpers._types import ComplexArray, FloatArray
 from pyglaze.interpolation import ws_interpolate
 
+if TYPE_CHECKING:
+    from pyglaze.helpers._types import ComplexArray, FloatArray
+
 __all__ = ["Pulse"]
 
 
-@dataclass
+@dataclass(frozen=True)
 class Pulse:
     """Data class for a THz pulse. The pulse is expected to be preprocessed such that times are uniformly spaced.
 
@@ -39,6 +41,24 @@ class Pulse:
             and np.array_equal(self.signal, obj.signal)
         )
 
+    def __hash__(self: Pulse) -> int:
+        """Return a hash based on the contents of ``time`` and ``signal``.
+
+        The hash combines shape, dtype and raw bytes of both arrays, ensuring that
+        two :class:`Pulse` instances that compare equal also have identical hashes.
+
+        """
+        return hash(
+            (
+                self.time.shape,
+                self.time.dtype.str,
+                self.time.tobytes(),
+                self.signal.shape,
+                self.signal.dtype.str,
+                self.signal.tobytes(),
+            )
+        )
+
     @property
     def fft(self: Pulse) -> ComplexArray:
         """Return the Fourier Transform of a signal."""
@@ -95,7 +115,7 @@ class Pulse:
 
         Note that the energy is not the same as the physical energy of the pulse, but rather the integral of the square of the pulse.
         """
-        return cast(float, np.trapz(self.signal * self.signal, x=self.time))  # noqa: NPY201 - trapz removed in numpy 2.0
+        return cast("float", np.trapezoid(self.signal * self.signal, x=self.time))  # type: ignore[attr-defined, unused-ignore]
 
     @classmethod
     def from_dict(
@@ -161,10 +181,12 @@ class Pulse:
         ]
 
         if translate_to_zero:
-            for scan in roughly_aligned:
-                scan.time = scan.time - scan.time[0]
+            roughly_aligned = [
+                s.timeshift(scale=1.0, offset=-s.time[0]) for s in roughly_aligned
+            ]
+
         zerocrossings = [p.estimate_zero_crossing() for p in roughly_aligned]
-        mean_zerocrossing = cast(float, np.mean(zerocrossings))
+        mean_zerocrossing = cast("float", np.mean(zerocrossings))
 
         return [
             p.propagate(mean_zerocrossing - zc)
@@ -195,7 +217,7 @@ class Pulse:
         Returns:
             complex: Fourier Transform at the given frequency
         """
-        return cast(complex, self.fft[np.searchsorted(self.frequency, f)])
+        return cast("complex", self.fft[np.searchsorted(self.frequency, f)])
 
     def timeshift(self: Pulse, scale: float, offset: float = 0) -> Pulse:
         """Rescales and offsets the time axis as.
@@ -255,7 +277,7 @@ class Pulse:
         Returns:
             Signal at the given time
         """
-        return cast(float, ws_interpolate(self.time, self.signal, np.array([t]))[0])
+        return cast("float", ws_interpolate(self.time, self.signal, np.array([t]))[0])
 
     def subtract_mean(self: Pulse, fraction: float = 0.99) -> Pulse:
         """Subtracts the mean of the pulse.
@@ -427,7 +449,7 @@ class Pulse:
 
         # Combine signal before spectrum maximum with interpolated values
         y_values = cast(
-            FloatArray,
+            "FloatArray",
             np.concatenate(
                 [
                     self.spectrum_dB()[:_from],
@@ -487,7 +509,7 @@ class Pulse:
             ),
         )
 
-        return cast(float, np.max(max_estimate) - np.min(min_estimate))
+        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.
@@ -505,7 +527,7 @@ class Pulse:
         # 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)
+        return cast("float", t1 - s1 / a)
 
     def propagate(self: Pulse, time: float) -> Pulse:
         """Propagates the pulse in time by a given amount.
@@ -579,7 +601,7 @@ def _estimate_bw_idx(x: FloatArray, y: FloatArray, segments: int) -> int:
         fun=model, x0=[x[len(x) // 2]], bounds=[(x[0], x[-1])], method="Nelder-Mead"
     ).x[0]
 
-    return cast(int, x.searchsorted(BW_estimate))
+    return cast("int", x.searchsorted(BW_estimate))
 
 
 def _fit_linear_segments(x: FloatArray, y: FloatArray, n_segments: int) -> FloatArray:

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

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

{pyglaze-0.3.0 → pyglaze-0.4.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, Callable, ClassVar, overload
+from typing import TYPE_CHECKING, Callable, ClassVar
 
 import numpy as np
 import serial
@@ -16,7 +16,6 @@ from serial import serialutil
 
 from pyglaze.device.configuration import (
     DeviceConfiguration,
-    ForceDeviceConfiguration,
     Interval,
     LeDeviceConfiguration,
 )
@@ -24,11 +23,7 @@ from pyglaze.devtools.mock_device import _mock_device_factory
 from pyglaze.helpers.utilities import LOGGER_NAME, _BackoffRetry
 
 if TYPE_CHECKING:
-    from pyglaze.devtools.mock_device import (
-        ForceMockDevice,
-        LeMockDevice,
-        MockDevice,
-    )
+    from pyglaze.devtools.mock_device import LeMockDevice
     from pyglaze.helpers._types import FloatArray
 
 
@@ -39,186 +34,6 @@ class DeviceComError(Exception):
         super().__init__(message)
 
 
-@dataclass
-class _ForceAmpCom:
-    config: ForceDeviceConfiguration
-    CONT_SCAN_UPDATE_FREQ: float = 1  # seconds
-    __ser: ForceMockDevice | serial.Serial = field(init=False)
-
-    ENCODING: ClassVar[str] = "utf-8"
-    OK_RESPONSE: ClassVar[str] = "!A,OK"
-    N_POINTS: ClassVar[int] = 10000
-    DAC_BITWIDTH: ClassVar[int] = 65535  # bit-width of amp DAC
-    # DO NOT change - antennas will break.
-    MIN_ALLOWED_MOD_VOLTAGE: ClassVar[float] = -1.0
-    MAX_ALLOWED_MOD_VOLTAGE: ClassVar[float] = 0.5
-
-    @cached_property
-    def scanning_points(self: _ForceAmpCom) -> int:
-        time_pr_point = (
-            self.config.integration_periods / self.config.modulation_frequency
-        )
-        return int(self.config.sweep_length_ms * 1e-3 / time_pr_point)
-
-    @cached_property
-    def _squished_intervals(self: _ForceAmpCom) -> 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.dac_lower_bound,
-            upper_bound=self.config.dac_upper_bound,
-            bitwidth=self.DAC_BITWIDTH,
-        )
-
-    @cached_property
-    def times(self: _ForceAmpCom) -> FloatArray:
-        return _delay_from_intervals(
-            delayunit=lambda x: x,
-            intervals=self.config.scan_intervals,
-            points_per_interval=_points_per_interval(
-                self.scanning_points, self._squished_intervals
-            ),
-        )
-
-    @cached_property
-    def scanning_list(self: _ForceAmpCom) -> list[float]:
-        scanning_list: list[float] = []
-        for interval, n_points in zip(
-            self._squished_intervals,
-            _points_per_interval(self.N_POINTS, self._squished_intervals),
-        ):
-            scanning_list.extend(
-                np.linspace(interval.lower, interval.upper, n_points, endpoint=False)
-            )
-
-        return scanning_list
-
-    @property
-    def datapoints_per_update(self: _ForceAmpCom) -> int:
-        return int(
-            self.CONT_SCAN_UPDATE_FREQ
-            / (self.config.integration_periods / self.config.modulation_frequency)
-        )
-
-    def __post_init__(self: _ForceAmpCom) -> None:
-        self.__ser = _serial_factory(self.config)
-
-    def __del__(self: _ForceAmpCom) -> None:
-        """Closes connection when class instance goes out of scope."""
-        self.disconnect()
-
-    def write_all(self: _ForceAmpCom) -> list[str]:
-        responses = []
-        responses.append(self.write_period_and_frequency())
-        responses.append(self.write_sweep_length())
-        responses.append(self.write_waveform())
-        responses.append(self.write_modulation_voltage())
-        responses.extend(self.write_list())
-        return responses
-
-    def write_period_and_frequency(self: _ForceAmpCom) -> str:
-        s = f"!set timing,{self.config.integration_periods},{self.config.modulation_frequency}\r"
-        return self._encode_send_response(s)
-
-    def write_sweep_length(self: _ForceAmpCom) -> str:
-        s = f"!set sweep length,{self.config.sweep_length_ms}\r"
-        return self._encode_send_response(s)
-
-    def write_waveform(self: _ForceAmpCom) -> str:
-        s = f"!set wave,{self.config.modulation_waveform}\r"
-        return self._encode_send_response(s)
-
-    def write_modulation_voltage(self: _ForceAmpCom) -> str:
-        min_v = self.config.min_modulation_voltage
-        max_v = self.config.max_modulation_voltage
-        crit1 = self.MIN_ALLOWED_MOD_VOLTAGE <= min_v <= self.MAX_ALLOWED_MOD_VOLTAGE
-        crit2 = self.MIN_ALLOWED_MOD_VOLTAGE <= max_v <= self.MAX_ALLOWED_MOD_VOLTAGE
-
-        if crit1 and crit2:
-            s = f"!set generator,{min_v},{max_v}\r"
-            return self._encode_send_response(s)
-
-        msg = f"Modulation voltages min: {min_v:.1f}, max: {max_v:.1f} not allowed."
-        raise ValueError(msg)
-
-    def write_list(self: _ForceAmpCom) -> list[str]:
-        for iteration, entry in enumerate(self.scanning_list):
-            string = f"!lut,{iteration},{entry}\r"
-            self._encode_and_send(string)
-        return self._get_response().split("\r")
-
-    def start_scan(self: _ForceAmpCom) -> tuple[str, np.ndarray]:
-        start_command = "!s,\r"
-        self._encode_and_send(start_command)
-        responses = self._get_response().split("\r")
-        output_array = np.zeros((self.scanning_points, 3))
-        output_array[:, 0] = self.times
-        iteration = 0
-        for entry in responses:
-            if "!R" in entry:
-                radius, angle = self._format_output(entry)
-                output_array[iteration, 1] = radius
-                output_array[iteration, 2] = angle
-                iteration += 1
-            elif "!D" in entry:
-                break
-        return start_command, output_array
-
-    def start_continuous_scan(self: _ForceAmpCom) -> tuple[str, list[str]]:
-        start_command = "!dat,1\r"
-        self._encode_and_send(start_command)
-        # Call self._read_until() twice, because amp returns !A,OK twice for
-        # continuous output (for some unknown reason)
-        responses = [self._read_until(expected=b"\r") for _ in range(2)]
-        return start_command, responses
-
-    def stop_continuous_scan(self: _ForceAmpCom) -> tuple[str, str]:
-        start_command = "!dat,0\r"
-        self._encode_and_send(start_command)
-        response = self._read_until(expected=b"!A,OK\r")
-        return start_command, response
-
-    def read_continuous_data(self: _ForceAmpCom) -> FloatArray:
-        output_array = np.zeros((self.datapoints_per_update, 3))
-        output_array[:, 0] = np.linspace(0, 1, self.datapoints_per_update)
-        for iteration in range(self.datapoints_per_update):
-            amp_output = self._read_until(expected=b"\r")
-            radius, angle = self._format_output(amp_output)
-            output_array[iteration, 1] = radius
-            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()
-
-    def _encode_and_send(self: _ForceAmpCom, command: str) -> None:
-        self.__ser.write(command.encode(self.ENCODING))
-
-    @_BackoffRetry(backoff_base=0.2, logger=logging.getLogger(LOGGER_NAME))
-    def _get_response(self: _ForceAmpCom) -> str:
-        r = self.__ser.readline().decode(self.ENCODING).strip()
-        if r[: len(self.OK_RESPONSE)] != self.OK_RESPONSE:
-            msg = f"Expected response '{self.OK_RESPONSE}', received: '{r}'"
-            raise serialutil.SerialException(msg)
-
-        return r
-
-    def _read_until(self: _ForceAmpCom, expected: bytes) -> str:
-        return self.__ser.read_until(expected=expected).decode(self.ENCODING).strip()
-
-    def _format_output(self: _ForceAmpCom, amp_output: str) -> tuple[float, float]:
-        """Format output from Force LIA to radius and angle."""
-        response_list = amp_output.split(",")
-        return float(response_list[1]), float(response_list[2])
-
-
 @dataclass
 class _LeAmpCom:
     config: LeDeviceConfiguration
@@ -233,6 +48,8 @@ class _LeAmpCom:
     STATUS_COMMAND: ClassVar[str] = "H"
     SEND_LIST_COMMAND: ClassVar[str] = "L"
     SEND_SETTINGS_COMMAND: ClassVar[str] = "S"
+    SERIAL_NUMBER_COMMAND: ClassVar[str] = "s"
+    FIRMWARE_VERSION_COMMAND: ClassVar[str] = "v"
 
     @cached_property
     def scanning_points(self: _LeAmpCom) -> int:
@@ -263,6 +80,14 @@ class _LeAmpCom:
         """
         return self.scanning_points * 12
 
+    @property
+    def serial_number_bytes(self: _LeAmpCom) -> int:
+        """Number of bytes to receive for a serial number.
+
+        Serial number has the form "<CHARACTER>-<4_DIGITS>, hence expect 6 bytes."
+        """
+        return 6
+
     def __post_init__(self: _LeAmpCom) -> None:
         self.__ser = _serial_factory(self.config)
 
@@ -302,6 +127,17 @@ class _LeAmpCom:
             # If the serial device does not exist, self.__ser is never created - hence catch
             self.__ser.close()
 
+    def get_serial_number(self: _LeAmpCom) -> str:
+        """Get the serial number of the connected device."""
+        return "X-9999"
+        # self._encode_and_send(self.SERIAL_NUMBER_COMMAND)   # noqa: ERA001
+        # return self.__ser.read(self.serial_number_bytes).decode(self.ENCODING)  # noqa: ERA001
+
+    def get_firmware_version(self: _LeAmpCom) -> str:
+        """Get the firmware version of the connected device."""
+        self._encode_and_send(self.FIRMWARE_VERSION_COMMAND)
+        return self.__ser.read_until().decode(self.ENCODING).strip()
+
     @cached_property
     def _intervals(self: _LeAmpCom) -> list[Interval]:
         """Intervals squished into effective DAC range."""
@@ -398,17 +234,7 @@ class _LeStatus(Enum):
     IDLE = "ACK: Idle."
 
 
-@overload
-def _serial_factory(
-    config: ForceDeviceConfiguration,
-) -> serial.Serial | ForceMockDevice: ...
-
-
-@overload
-def _serial_factory(config: LeDeviceConfiguration) -> serial.Serial | LeMockDevice: ...
-
-
-def _serial_factory(config: DeviceConfiguration) -> serial.Serial | MockDevice:
+def _serial_factory(config: DeviceConfiguration) -> serial.Serial | LeMockDevice:
     if "mock_device" in config.amp_port:
         return _mock_device_factory(config)
 

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/device/configuration.py

@@ -74,91 +74,6 @@ class DeviceConfiguration(ABC):
         """Load a DeviceConfiguration from a file."""
 
 
-@dataclass
-class ForceDeviceConfiguration(DeviceConfiguration):
-    """Represents a configuration that can be sent to the lock-in amp for scans.
-
-    Args:
-        amp_port: The name of the serial port the amp is connected to.
-        sweep_length_ms: The length of the sweep in milliseconds.
-        scan_intervals: The intervals to scan.
-        integration_periods: The number of integration periods to use.
-        modulation_frequency: The frequency of the modulation in Hz.
-        dac_lower_bound: The lower bound of the modulation voltage in bits.
-        dac_upper_bound: The upper bound of the modulation voltage in bits.
-        min_modulation_voltage: The minimum modulation voltage in volts.
-        max_modulation_voltage: The maximum modulation voltage in volts.
-        modulation_waveform: The waveform to use for modulation.
-        amp_timeout_seconds: The timeout for the amp in seconds.
-    """
-
-    amp_port: str
-    sweep_length_ms: float
-    scan_intervals: list[Interval] = field(default_factory=lambda: [Interval(0.0, 1.0)])
-    integration_periods: int = 100
-    modulation_frequency: int = 10000  # Hz
-    dac_lower_bound: int = 6400
-    dac_upper_bound: int = 59300
-    min_modulation_voltage: float = -1.0  # V
-    max_modulation_voltage: float = 0.5  # V
-    modulation_waveform: str = "square"
-    amp_timeout_seconds: float = 0.05
-
-    amp_baudrate: ClassVar[int] = 1200000  # bit/s
-
-    @property
-    def _sweep_length_ms(self: ForceDeviceConfiguration) -> float:
-        return self.sweep_length_ms
-
-    def save(self: ForceDeviceConfiguration, path: Path) -> str:
-        """Save a DeviceConfiguration to a file.
-
-        Args:
-            path: The path to save the configuration to.
-
-        Returns:
-            str: Final path component of the saved file, without the extension.
-
-        """
-        with path.open("w") as f:
-            json.dump(asdict(self), f, indent=4, sort_keys=True)
-
-        return path.stem
-
-    @classmethod
-    def from_dict(
-        cls: type[ForceDeviceConfiguration], amp_config: dict
-    ) -> ForceDeviceConfiguration:
-        """Create a DeviceConfiguration from a dict.
-
-        Args:
-            amp_config: An amp configuration in dict form.
-
-        Raises:
-            ValueError: If the dictionary is empty.
-
-        Returns:
-            DeviceConfiguration: A DeviceConfiguration object.
-        """
-        return _config_w_intervals_from_dict(cls, amp_config)
-
-    @classmethod
-    def load(
-        cls: type[ForceDeviceConfiguration], file_path: Path
-    ) -> ForceDeviceConfiguration:
-        """Load a DeviceConfiguration from a file.
-
-        Args:
-            file_path: The path to the file to load.
-
-        Returns:
-            DeviceConfiguration: A DeviceConfiguration object.
-        """
-        with file_path.open() as f:
-            configuration_dict = json.load(f)
-        return cls.from_dict(configuration_dict)
-
-
 @dataclass
 class LeDeviceConfiguration(DeviceConfiguration):
     """Represents a configuration that can be sent to a Le-type lock-in amp for scans.
@@ -220,7 +135,13 @@ class LeDeviceConfiguration(DeviceConfiguration):
         Returns:
             DeviceConfiguration: A DeviceConfiguration object.
         """
-        return _config_w_intervals_from_dict(cls, amp_config)
+        if not amp_config:
+            msg = "'amp_config' is empty."
+            raise ValueError(msg)
+
+        config = cls(**amp_config)
+        config.scan_intervals = [Interval.from_dict(d) for d in config.scan_intervals]  # type: ignore[arg-type]
+        return config
 
     @classmethod
     def load(
@@ -237,16 +158,3 @@ class LeDeviceConfiguration(DeviceConfiguration):
         with file_path.open() as f:
             configuration_dict = json.load(f)
         return cls.from_dict(configuration_dict)
-
-
-C = TypeVar("C", LeDeviceConfiguration, ForceDeviceConfiguration)
-
-
-def _config_w_intervals_from_dict(cls: type[C], amp_config: dict) -> C:
-    if amp_config:
-        config = cls(**amp_config)
-        config.scan_intervals = [Interval.from_dict(d) for d in config.scan_intervals]  # type: ignore[arg-type]
-        return config
-
-    msg = "'amp_config' is empty."
-    raise ValueError(msg)

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/devtools/mock_device.py

@@ -1,21 +1,13 @@
 from __future__ import annotations
 
-import json
 import struct
 import time
 from abc import ABC, abstractmethod
 from enum import Enum, auto
-from pathlib import Path
-from time import sleep
 
 import numpy as np
-from serial import serialutil
 
-from pyglaze.device.configuration import (
-    DeviceConfiguration,
-    ForceDeviceConfiguration,
-    LeDeviceConfiguration,
-)
+from pyglaze.device.configuration import DeviceConfiguration, LeDeviceConfiguration
 
 
 class MockDevice(ABC):
@@ -33,143 +25,6 @@ class MockDevice(ABC):
         pass
 
 
-class ForceMockDevice(MockDevice):
-    """Mock device for devices using a FORCE lockin for testing purposes."""
-
-    CONFIG_PATH = Path(__file__).parents[1] / "devtools" / "mockup_config.json"
-    ENCODING: str = "utf-8"
-
-    def __init__(
-        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
-        self.n_failures = 0
-        self.n_scans = 0
-        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
-        self._sweep_length = None
-        if not self.CONFIG_PATH.exists():
-            conf = {"periods": None, "frequency": None, "sweep_length_ms": None}
-            self.__save(conf)
-
-    @property
-    def periods(self: ForceMockDevice) -> int:
-        """Number of integration periods."""
-        return int(self.__get_val("periods"))
-
-    @periods.setter
-    def periods(self: ForceMockDevice, value: int) -> None:
-        self.__set_val("periods", value)
-
-    @property
-    def frequency(self: ForceMockDevice) -> int:
-        """Modulation frequency in Hz."""
-        return int(self.__get_val("frequency"))
-
-    @frequency.setter
-    def frequency(self: ForceMockDevice, value: int) -> None:
-        self.__set_val("frequency", value)
-
-    @property
-    def sweep_length(self: ForceMockDevice) -> int:
-        """Total sweep length for one pulse."""
-        return int(self.__get_val("sweep_length"))
-
-    @sweep_length.setter
-    def sweep_length(self: ForceMockDevice, value: int) -> None:
-        self.__set_val("sweep_length", value)
-
-    def close(self: ForceMockDevice) -> None:
-        """Mock-close the serial connection."""
-
-    def write(self: ForceMockDevice, input_string: bytes) -> None:
-        """Mock-write to the serial connection."""
-        decoded_input_string = input_string.decode("utf-8")
-        split_input_string = decoded_input_string.split(",")
-        cmd = split_input_string[0]
-        if cmd == "!set timing":
-            self.periods = int(split_input_string[1])
-            self.frequency = int(split_input_string[2])
-        elif cmd == "!set sweep length":
-            self.sweep_length = int(split_input_string[1])
-        elif cmd == "!s":
-            time_pr_point = self.periods / self.frequency
-            self.in_waiting = int(self.sweep_length * 1e-3 / time_pr_point)
-            self.experiment_running = True
-        elif cmd in ["!lut", "!set wave", "!set generator"]:
-            pass
-        elif cmd != "!dat":
-            self.valid_input = False
-
-    def readline(self: ForceMockDevice) -> bytes:
-        """Mock-readline from the serial connection."""
-        if self.valid_input:
-            return self.__run_experiment() if self.experiment_running else b"!A,OK\r"
-
-        return b"A,FAULT\r"
-
-    def read_until(self: ForceMockDevice, expected: bytes = b"\r") -> bytes:  # noqa: ARG002
-        """Mock-read_until from the serial connection."""
-        random_datapoint = self.__create_random_datapoint
-        return random_datapoint.encode(self.ENCODING)
-
-    def __run_experiment(self: ForceMockDevice) -> bytes:
-        return_string = "!A,OK\\r"
-        return_string += (
-            f"!S,ip: {self.periods}, "
-            f"Freq: {self.frequency}, "
-            f"sl: {self.sweep_length}, "
-            f"from: 0.0000, "
-            f"to:1.0000\r"
-        )
-        for _ in range(self.in_waiting):
-            return_string += self.__create_random_datapoint
-        return_string += "!D,DONE\\r"
-        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
-            msg = "MOCK_DEVICE: scan failed"
-            raise serialutil.SerialException(msg)
-
-        return return_string.encode("utf-8")
-
-    @property
-    def __create_random_datapoint(self: ForceMockDevice) -> str:
-        radius = self.rng.random() * 10
-        theta = self.rng.random() * 360
-        return f"!R,{radius},{theta}\r"
-
-    def __save(self: ForceMockDevice, conf: dict) -> None:
-        with self.CONFIG_PATH.open("w") as f:
-            json.dump(conf, f)
-
-    def __get_val(self: ForceMockDevice, key: str) -> int:
-        val: int = getattr(self, f"_{key}")
-        if not val:
-            with self.CONFIG_PATH.open() as f:
-                val = json.load(f)[key]
-        return val
-
-    def __set_val(self: ForceMockDevice, key: str, val: str | float) -> None:
-        with self.CONFIG_PATH.open() as f:
-            config = json.load(f)
-            config[key] = val
-        setattr(self, f"_{key}", val)
-        self.__save(config)
-
-
 class _LeMockState(Enum):
     IDLE = auto()
     WAITING_FOR_SETTINGS = auto()
@@ -177,6 +32,8 @@ class _LeMockState(Enum):
     RECEIVED_SETTINGS = auto()
     RECEIVED_LIST = auto()
     RECEIVED_STATUS_REQUEST = auto()
+    RECEIVED_SERIAL_NUMBER_REQUEST = auto()
+    RECEIVED_FIRMWARE_VERSION_REQUEST = auto()
     STARTING_SCAN = auto()
     SCANNING = auto()
 
@@ -235,6 +92,9 @@ class LeMockDevice(MockDevice):
             return self._create_scan_bytes(n_bytes=0)
         if self.state == _LeMockState.IDLE:
             return self._create_scan_bytes(n_bytes=size)
+        if self.state == _LeMockState.RECEIVED_SERIAL_NUMBER_REQUEST:
+            self.state = _LeMockState.IDLE
+            return "M-9999".encode(self.ENCODING)
         raise NotImplementedError
 
     def read_until(self: LeMockDevice, _: bytes = b"\r") -> bytes:  # noqa: PLR0911
@@ -255,6 +115,9 @@ class LeMockDevice(MockDevice):
             self.state = _LeMockState.SCANNING
             self.is_scanning = True
             return "ACK: Scan started.".encode(self.ENCODING)
+        if self.state == _LeMockState.RECEIVED_FIRMWARE_VERSION_REQUEST:
+            self.state = _LeMockState.IDLE
+            return "v0.1.0".encode(self.ENCODING)
         if self.state == _LeMockState.RECEIVED_STATUS_REQUEST:
             if self._scan_has_finished():
                 self.state = _LeMockState.IDLE
@@ -291,6 +154,10 @@ class LeMockDevice(MockDevice):
             self._scan_start_time = time.time()
         elif msg == "R":
             self._scan_has_finished()
+        elif msg == "s":
+            self.state = _LeMockState.RECEIVED_SERIAL_NUMBER_REQUEST
+        elif msg == "v":
+            self.state = _LeMockState.RECEIVED_FIRMWARE_VERSION_REQUEST
         else:
             msg = f"Unknown message: {msg}"
             raise NotImplementedError(msg)
@@ -376,7 +243,7 @@ def list_mock_devices() -> list[str]:
     ]
 
 
-def _mock_device_factory(config: DeviceConfiguration) -> MockDevice:
+def _mock_device_factory(config: DeviceConfiguration) -> LeMockDevice:
     mock_class = _get_mock_class(config)
     if config.amp_port == "mock_device_scan_should_fail":
         return mock_class(fail_after=0)
@@ -393,9 +260,7 @@ def _mock_device_factory(config: DeviceConfiguration) -> MockDevice:
     raise ValueError(msg)
 
 
-def _get_mock_class(config: DeviceConfiguration) -> type[MockDevice]:
-    if isinstance(config, ForceDeviceConfiguration):
-        return ForceMockDevice
+def _get_mock_class(config: DeviceConfiguration) -> type[LeMockDevice]:
     if isinstance(config, LeDeviceConfiguration):
         return LeMockDevice
 

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/devtools/thz_pulse.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
 
-from pyglaze.helpers._types import FloatArray
+if TYPE_CHECKING:
+    from pyglaze.helpers._types import FloatArray
 
 
 def gaussian_derivative_pulse(
@@ -32,4 +33,4 @@ def gaussian_derivative_pulse(
             scale=1.0 / signal_to_noise, size=len(signal)
         )
     )
-    return cast(FloatArray, signal / np.max(signal) + noise)
+    return cast("FloatArray", signal / np.max(signal) + noise)

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/helpers/utilities.py

@@ -8,11 +8,11 @@ from typing import TYPE_CHECKING, Callable, cast
 import serial
 import serial.tools.list_ports
 
-from pyglaze.helpers._types import P, T
-
 if TYPE_CHECKING:
     import logging
 
+    from pyglaze.helpers._types import P, T
+
 APP_NAME = "Glaze"
 LOGGER_NAME = "glaze-logger"
 
@@ -59,7 +59,7 @@ class _BackoffRetry:
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
             for tries in range(self.max_tries - 1):
                 try:
-                    return cast(T, func(*args, **kwargs))
+                    return cast("T", func(*args, **kwargs))
                 except (KeyboardInterrupt, SystemExit):
                     raise
                 except Exception as e:  # noqa: BLE001
@@ -69,7 +69,7 @@ class _BackoffRetry:
                 backoff = min(self.backoff_base * 2**tries, self.max_backoff)
                 time.sleep(backoff)
             self._log(f"{func.__name__}: Last try ({tries + 2}).")
-            return cast(T, func(*args, **kwargs))
+            return cast("T", func(*args, **kwargs))
 
         return wrapper
 

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/interpolation/interpolation.py

@@ -24,7 +24,7 @@ def ws_interpolate(
     # times must be zero-centered for formula to work
     sinc = np.sinc((interp_times[:, np.newaxis] - times[0] - dt * _range) / dt)
 
-    return cast(FloatArray, np.sum(pulse * sinc, axis=1))
+    return cast("FloatArray", np.sum(pulse * sinc, axis=1))
 
 
 def cubic_spline_interpolate(
@@ -41,4 +41,4 @@ def cubic_spline_interpolate(
         FloatArray: Interpolated values
     """
     spline = CubicSpline(times, pulse, bc_type="natural")
-    return cast(FloatArray, spline(interp_times))
+    return cast("FloatArray", spline(interp_times))

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/scanning/_asyncscanner.py

@@ -6,7 +6,7 @@ from multiprocessing import Event, Pipe, Process, Queue, synchronize
 from queue import Empty, Full
 from typing import TYPE_CHECKING
 
-from serial import serialutil
+from serial import SerialException, serialutil
 
 from pyglaze.datamodels.waveform import UnprocessedWaveform, _TimestampedWaveform
 from pyglaze.scanning.scanner import Scanner
@@ -25,6 +25,12 @@ class _ScannerHealth:
     error: Exception | None
 
 
+@dataclass
+class _ScannerMetadata:
+    serial_number: str
+    firmware_version: str
+
+
 @dataclass
 class _AsyncScanner:
     """Used by GlazeClient to starts a scanner in a new process and read scans from shared memory."""
@@ -34,6 +40,7 @@ class _AsyncScanner:
     logger: logging.Logger | None = None
     is_scanning: bool = False
     _child_process: Process = field(init=False)
+    _metadata: _ScannerMetadata = field(init=False)
     _shared_mem: Queue[_TimestampedWaveform] = field(init=False)
     _SCAN_TIMEOUT: float = field(init=False)
     _stop_signal: synchronize.Event = field(init=False)
@@ -72,6 +79,10 @@ class _AsyncScanner:
                 self.logger.error(str(msg.error))
             raise msg.error
 
+        # As part of startup, metadata is sent from scanner
+        metadata: _ScannerMetadata = self._scanner_conn.recv()
+        self._metadata = metadata
+
     def stop_scan(self: _AsyncScanner) -> None:
         self._stop_signal.set()
         self._child_process.join()
@@ -90,6 +101,19 @@ class _AsyncScanner:
     def get_next(self: _AsyncScanner) -> UnprocessedWaveform:
         return self._get_scan().waveform
 
+    def get_serial_number(self: _AsyncScanner) -> str:
+        if not self.is_scanning:
+            msg = "Scanner not connected"
+            raise SerialException(msg)
+        return self._metadata.serial_number
+
+    def get_firmware_version(self: _AsyncScanner) -> str:
+        if not self.is_scanning:
+            msg = "Scanner not connected"
+            raise SerialException(msg)
+
+        return self._metadata.firmware_version
+
     def _get_scan(self: _AsyncScanner) -> _TimestampedWaveform:
         try:
             return self._shared_mem.get(timeout=self._SCAN_TIMEOUT)
@@ -113,7 +137,12 @@ class _AsyncScanner:
     ) -> None:
         try:
             scanner = Scanner(config=config)
+            device_metadata = _ScannerMetadata(
+                serial_number=scanner.get_serial_number(),
+                firmware_version=scanner.get_firmware_version(),
+            )
             parent_conn.send(_ScannerHealth(is_alive=True, is_healthy=True, error=None))
+            parent_conn.send(device_metadata)
         except (serialutil.SerialException, TimeoutError) as e:
             parent_conn.send(_ScannerHealth(is_alive=False, is_healthy=False, error=e))
             return

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/scanning/client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from serial import serialutil
+from serial import SerialException, serialutil
 from typing_extensions import Self
 
 from ._asyncscanner import _AsyncScanner
@@ -57,3 +57,19 @@ class GlazeClient:
             n_pulses: The number of terahertz pulses to read from the CCS server.
         """
         return self._scanner.get_scans(n_pulses)
+
+    def get_serial_number(self: GlazeClient) -> str:
+        """Get the serial number of the connected device."""
+        try:
+            return self._scanner.get_serial_number()
+        except AttributeError as e:
+            msg = "No connection to device."
+            raise SerialException(msg) from e
+
+    def get_firmware_version(self: GlazeClient) -> str:
+        """Get the firmware version of the connected device."""
+        try:
+            return self._scanner.get_firmware_version()
+        except AttributeError as e:
+            msg = "No connection to device."
+            raise SerialException(msg) from e

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze/scanning/scanner.py

@@ -4,15 +4,10 @@ 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
-from pyglaze.device.configuration import (
-    DeviceConfiguration,
-    ForceDeviceConfiguration,
-    LeDeviceConfiguration,
-)
+from pyglaze.device.ampcom import _LeAmpCom
+from pyglaze.device.configuration import DeviceConfiguration, LeDeviceConfiguration
 from pyglaze.scanning._exceptions import ScanError
 
 if TYPE_CHECKING:
@@ -48,6 +43,14 @@ class _ScannerImplementation(ABC, Generic[TConfig]):
     def disconnect(self: _ScannerImplementation) -> None:
         pass
 
+    @abstractmethod
+    def get_serial_number(self: _ScannerImplementation) -> str:
+        pass
+
+    @abstractmethod
+    def get_firmware_version(self: _ScannerImplementation) -> str:
+        pass
+
 
 class Scanner:
     """A synchronous scanner for Glaze terahertz devices."""
@@ -86,92 +89,21 @@ class Scanner:
         """Close serial connection."""
         self._scanner_impl.disconnect()
 
-
-class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
-    """Perform synchronous terahertz scanning using a given DeviceConfiguration.
-
-    Args:
-        config: A DeviceConfiguration to use for the scan.
-
-    """
-
-    def __init__(self: ForceScanner, config: ForceDeviceConfiguration) -> None:
-        self._config: ForceDeviceConfiguration
-        self._ampcom: _ForceAmpCom | None = None
-        self.config = config
-        self._phase_estimator = _LockinPhaseEstimator()
-
-    @property
-    def config(self: ForceScanner) -> ForceDeviceConfiguration:
-        """The device configuration to use for the scan.
+    def get_serial_number(self: Scanner) -> str:
+        """Get the serial number of the connected device.
 
         Returns:
-            DeviceConfiguration: a DeviceConfiguration.
+            str: The serial number of the connected device.
         """
-        return self._config
-
-    @config.setter
-    def config(self: ForceScanner, new_config: ForceDeviceConfiguration) -> None:
-        amp = _ForceAmpCom(new_config)
-        if getattr(self, "_config", None):
-            if (
-                self._config.integration_periods != new_config.integration_periods
-                or self._config.modulation_frequency != new_config.modulation_frequency
-            ):
-                amp.write_period_and_frequency()
-            if self._config.sweep_length_ms != new_config.sweep_length_ms:
-                amp.write_sweep_length()
-            if self._config.modulation_waveform != new_config.modulation_waveform:
-                amp.write_waveform()
-            if (
-                self._config.min_modulation_voltage != new_config.min_modulation_voltage
-                or self._config.max_modulation_voltage
-                != new_config.max_modulation_voltage
-            ):
-                amp.write_modulation_voltage()
-            if self._config.scan_intervals != new_config.scan_intervals:
-                amp.write_list()
-        else:
-            amp.write_all()
+        return self._scanner_impl.get_serial_number()
 
-        self._config = new_config
-        self._ampcom = amp
-
-    def scan(self: ForceScanner) -> UnprocessedWaveform:
-        """Perform a scan.
+    def get_firmware_version(self: Scanner) -> str:
+        """Get the firmware version of the connected device.
 
         Returns:
-            Unprocessed scan.
+            str: The firmware version of the connected device.
         """
-        if self._ampcom is None:
-            msg = "Scanner not configured"
-            raise ScanError(msg)
-        _, responses = self._ampcom.start_scan()
-
-        time = responses[:, 0]
-        radius = responses[:, 1]
-        theta = responses[:, 2]
-        self._phase_estimator.update_estimate(radius=radius, theta=theta)
-
-        return UnprocessedWaveform.from_polar_coords(
-            time, radius, theta, self._phase_estimator.phase_estimate
-        )
-
-    def update_config(self: ForceScanner, new_config: ForceDeviceConfiguration) -> None:
-        """Update the DeviceConfiguration used in the scan.
-
-        Args:
-            new_config: A DeviceConfiguration to use for the scan.
-        """
-        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
+        return self._scanner_impl.get_firmware_version()
 
 
 class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
@@ -245,10 +177,30 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
         self._ampcom.disconnect()
         self._ampcom = None
 
+    def get_serial_number(self: LeScanner) -> str:
+        """Get the serial number of the connected device.
+
+        Returns:
+            str: The serial number of the connected device.
+        """
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise ScanError(msg)
+        return self._ampcom.get_serial_number()
+
+    def get_firmware_version(self: LeScanner) -> str:
+        """Get the firmware version of the connected device.
+
+        Returns:
+            str: The firmware version of the connected device.
+        """
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise ScanError(msg)
+        return self._ampcom.get_firmware_version()
+
 
 def _scanner_factory(config: DeviceConfiguration) -> _ScannerImplementation:
-    if isinstance(config, ForceDeviceConfiguration):
-        return ForceScanner(config)
     if isinstance(config, LeDeviceConfiguration):
         return LeScanner(config)
 

{pyglaze-0.3.0 → pyglaze-0.4.1/src/pyglaze.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyglaze
-Version: 0.3.0
+Version: 0.4.1
 Summary: Pyglaze is a library used to operate the devices of Glaze Technologies
 Author: GLAZE Technologies ApS
 License: BSD 3-Clause License
@@ -35,14 +35,15 @@ Project-URL: Homepage, https://www.glazetech.dk/
 Project-URL: Documentation, https://glazetech.github.io/pyglaze/latest
 Project-URL: Repository, https://github.com/GlazeTech/pyglaze
 Project-URL: Issues, https://github.com/GlazeTech/pyglaze/issues
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0.0,>=1.26.4
+Requires-Dist: numpy>=1.26.4
 Requires-Dist: pyserial>=3.5
 Requires-Dist: scipy>=1.7.3
 Requires-Dist: bitstring>=4.1.2
 Requires-Dist: typing_extensions>=4.12.2
+Dynamic: license-file
 
 # Pyglaze
 Pyglaze is a python library used to operate the devices of [Glaze Technologies](https://www.glazetech.dk/).

{pyglaze-0.3.0 → pyglaze-0.4.1}/src/pyglaze.egg-info/requires.txt

@@ -1,4 +1,4 @@
-numpy<2.0.0,>=1.26.4
+numpy>=1.26.4
 pyserial>=3.5
 scipy>=1.7.3
 bitstring>=4.1.2

pyglaze-0.3.0/src/pyglaze/__init__.py

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

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

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