pytesdaqx 0.1.0__py3-none-any.whl

pytesdaqx/__init__.py

@@ -0,0 +1,10 @@
+"""Python acquisition and instrument-control framework for TES detector readout."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("pytesdaqx")
+except PackageNotFoundError:  # Source tree imported before installation.
+    __version__ = "0+unknown"
+
+__all__ = ["__version__"]

pytesdaqx/acquisition/__init__.py

@@ -0,0 +1,21 @@
+from .fake import FakeAcquisitionBackend
+from .nidaq_ai import NIDAQAIBackend, NIDAQAIConfig, NIDAQAIError
+from .segment import Segment
+from .session import DAQSession
+from .streaming import (
+    SegmentRingBuffer,
+    StreamingAcquisitionLoop,
+    StreamingResult,
+)
+
+__all__ = [
+    "Segment",
+    "FakeAcquisitionBackend",
+    "DAQSession",
+    "NIDAQAIBackend",
+    "NIDAQAIConfig",
+    "NIDAQAIError",
+    "SegmentRingBuffer",
+    "StreamingResult",
+    "StreamingAcquisitionLoop",
+]

pytesdaqx/acquisition/fake.py

@@ -0,0 +1,101 @@
+"""Deterministic, hardware-free acquisition backend for development and tests.
+
+``FakeAcquisitionBackend`` generates synthetic segments (noise around
+zero, seeded for reproducibility) with the same shape/timing contract as
+``NIDAQAIBackend``, so configuration resolution and acquisition
+orchestration can be exercised end to end without contacting hardware.
+"""
+
+from __future__ import annotations
+
+import itertools
+import time
+from typing import Any
+
+import numpy as np
+
+from pytesdaqx.config.durations import parse_duration
+
+from .segment import Segment
+
+
+class FakeAcquisitionBackend:
+    """Synthetic acquisition backend producing seeded noise segments.
+
+    Drop-in stand-in for ``NIDAQAIBackend`` behind ``DAQSession``: same
+    ``configure``/acquire contract, no hardware access.
+    """
+
+    def __init__(self, *, dtype=np.float32, noise_rms=0.01, seed=12345):
+        self.dtype = np.dtype(dtype)
+        self.noise_rms = noise_rms
+        self.rng = np.random.default_rng(seed)
+        self._counter = itertools.count(1)
+
+    def configure(
+        self,
+        *,
+        measurement_name: str,
+        measurement_config: dict[str, Any],
+        detector_channels: list[str],
+    ) -> None:
+        self.measurement_name = measurement_name
+        self.measurement_config = measurement_config
+        self.detector_channels = list(detector_channels)
+
+        adc = measurement_config.get("adc", {}) or {}
+        self.sample_rate_hz = float(adc.get("sample_rate", adc.get("sample_rate_hz", 1000.0)))
+        self.n_samples = int(
+            adc.get(
+                "n_samples",
+                adc.get(
+                    "samples_per_read_block",
+                    adc.get("samples_per_trace", adc.get("samples_per_segment", 0)),
+                ),
+            )
+        )
+        if self.n_samples <= 0:
+            duration = adc.get(
+                "read_block_duration",
+                adc.get("trace_duration", adc.get("segment_duration", "1s")),
+            )
+            self.n_samples = self._samples_from_duration(duration, self.sample_rate_hz)
+
+    def read_segment(self) -> Segment:
+        segment_id = next(self._counter)
+        n_channels = len(self.detector_channels)
+        times = np.arange(self.n_samples) / self.sample_rate_hz
+        data = np.zeros((n_channels, self.n_samples), dtype=float)
+
+        for index in range(n_channels):
+            data[index] = (
+                0.1 * index
+                + 0.02 * np.sin(2 * np.pi * (3 + index) * times)
+                + self.rng.normal(0, self.noise_rms, self.n_samples)
+            )
+
+        return Segment(
+            data=data.astype(self.dtype),
+            detector_channels=self.detector_channels,
+            measurement=self.measurement_name,
+            label=self.measurement_config.get("label", self.measurement_name),
+            sample_rate_hz=self.sample_rate_hz,
+            timestamp=time.time(),
+            segment_id=segment_id,
+            metadata={
+                "backend": "fake",
+                "adc_mode": self.measurement_config.get("adc", {}).get("mode"),
+            },
+        )
+
+    def close(self) -> None:
+        return None
+
+    @staticmethod
+    def _samples_from_duration(duration: Any, sample_rate: float) -> int:
+        parsed = parse_duration(duration)
+        if parsed == "auto_from_cycles":
+            parsed = 1.0
+        if parsed is None or isinstance(parsed, str) or parsed <= 0:
+            raise ValueError(f"Invalid duration {duration!r}")
+        return int(round(float(parsed) * sample_rate))