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

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,12 +23,8 @@ 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.helpers.types import FloatArray
+    from pyglaze.devtools.mock_device import LeMockDevice
+    from pyglaze.helpers._types import FloatArray
 
 
 class DeviceComError(Exception):
@@ -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/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/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/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/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,17 +59,17 @@ 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
                     self._log(
-                        f"{func.__name__} failed {tries+1} time(s) with: '{e}'. Trying again"
+                        f"{func.__name__} failed {tries + 1} time(s) with: '{e}'. Trying again"
                     )
                 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))
+            self._log(f"{func.__name__}: Last try ({tries + 2}).")
+            return cast("T", func(*args, **kwargs))
 
         return wrapper
 

pyglaze/interpolation/__init__.py

@@ -1,3 +1,3 @@
-from .interpolation import ws_interpolate
+from .interpolation import cubic_spline_interpolate, ws_interpolate
 
-__all__ = ["ws_interpolate"]
+__all__ = ["cubic_spline_interpolate", "ws_interpolate"]