slm_open_api_package 0.2.10__tar.gz → 0.2.11__tar.gz

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: slm_open_api_package
-Version: 0.2.10
+Version: 0.2.11
 Summary: Add your description here
 Author: Sofus Vingaard
 Author-email: Sofus Vingaard <sofus.krebsvingaard@hbkworld.com>
 Requires-Dist: requests
 Requires-Dist: numpy
+Requires-Dist: pandas
 Requires-Dist: websockets
 Requires-Dist: kaitaistruct
 Requires-Dist: packaging
@@ -13,6 +14,7 @@ Requires-Dist: pyqtgraph
 Requires-Dist: pyqt5
 Requires-Dist: pyqt5-qt5<5.15.11
 Requires-Dist: miniaudio
+Requires-Dist: soundfile
 Requires-Dist: matplotlib>=3.11.1
 Requires-Dist: cryptography>=50.0.1
 Requires-Python: >=3.12
@@ -78,7 +80,7 @@ except KeyboardInterrupt:
 	streamer.stopStream()
 ```
 
-`stopStream()` stops the measurement, removes the device stream, and writes buffered saved data. Supported saving formats are `"csv"`, `"json"`, and `"pickle"`; their extensions are added automatically.
+JSON and CSV publish complete snapshots in a background worker, at most once per second while new data arrives, rather than rewriting the file for every sample. They retain records in memory and preserve their existing layouts; full-history snapshot costs still grow with recording length. Construct `JsonDataHandler(path, snapshot_interval=2.0)` or `CsvDataHandler(path, snapshot_interval=2.0)` and attach it with `setDataHandler()` to use a different interval. `close()` waits for the worker and saves all remaining records; background write failures are reported on subsequent updates or during the final flush. WAV still appends each audio chunk without buffering the recording in memory. `stopStream()` stops the measurement, closes saving handlers, and removes the device stream. Measurement saving formats are `"csv"` and `"json"`; audio uses `"wav"`. File extensions are added automatically.
 
 ## Multiple Sequences
 
@@ -147,11 +149,22 @@ streamer = WebXiStreamHandler(
 	host="192.168.1.183",
 	sequenceID=SequenceIdEnums.MP3Signal.value,
 	mode="mp3",
+	saving="wav",
+	saving_path="saved_data/audio",
 )
+
+try:
+	streamer.startStream()
+except KeyboardInterrupt:
+	streamer.stopStream()
 ```
 
 The matching `flac` form uses `SequenceIdEnums.FLACSignal.value` and `mode="flac"`. Audio setup is enabled by the handler. The SLM can take a few seconds to initialize audio recording when its quality setting changes.
 
+WAV saving appends decoded mono samples as recording happens, updating the file header after each chunk so the file is readable before shutdown. Saving happens after decoding and calibration to pascals. Samples are divided by the fixed full-scale pressure `calibrationFactor * (2**23 - 1)` and saved as `PCM_24`, not peak-normalized per chunk. The filename includes `_fullscale-<value>Pa.wav`. To recover pressure values, multiply floating-point samples read from the WAV by that full-scale value (within 24-bit quantization accuracy). Samples outside the calibrated range produce a clipping warning; this scaling cannot repair upstream clipping. MP3 uses the decoded sample rate; the current FLAC decoder uses 65536 Hz. JSON and CSV saving are rejected for audio modes, and WAV saving is rejected for measurement modes. Run `uv sync` to install the `soundfile` dependency used for progressive WAV writing.
+
+To attach the handler directly, use `WavDataHandler("saved_data/audio", sample_rate=65536, full_scale_pa=calibrationFactor * (2**23 - 1))` from `slm_api.helpers.data_handler`, using the device's actual calibration factor. You can instead supply `sample_rate` and `full_scale_pa` to `handle()`; the stream supplies both automatically. Call `close()` when finished. Use a separate WAV handler and output path for each device. Existing float32 pressure WAVs are unchanged; this format applies to new recordings.
+
 ## Synchronized Multi-Device Stream
 
 Based on [multi_device_flac.py](src/slm_api/multi_device_flac.py), pass `multi_device=True` and start/stop the group through the synchronized helpers:
@@ -168,7 +181,7 @@ streams = [
 		mode="mp3",
 		streamName=f"Audio_{host}",
 		multi_device=True,
-		saving="csv",
+		saving="wav",
 		saving_path=f"saved_data/{host}",
 	)
 	for host in hosts
@@ -203,4 +216,4 @@ Legacy flags such as `mp3=True` remain supported, but `mode=` is preferred. Only
 
 - **No values arrive:** Confirm the requested sequences are enabled on the SLM.
 - **Audio returns no samples after first enable:** Allow the SLM a few seconds to initialize audio recording before retrying.
-- **Saved file is missing:** Call `stopStream()` or `stop_all()`; buffered files are written during shutdown.
+- **Saved file is missing:** Files are written when the handler first receives data (nonempty samples for WAV). Check the saving path and that the stream is delivering data. Still call `stopStream()` or `stop_all()` to clean up recording resources.

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/README.md

@@ -58,7 +58,7 @@ except KeyboardInterrupt:
 	streamer.stopStream()
 ```
 
-`stopStream()` stops the measurement, removes the device stream, and writes buffered saved data. Supported saving formats are `"csv"`, `"json"`, and `"pickle"`; their extensions are added automatically.
+JSON and CSV publish complete snapshots in a background worker, at most once per second while new data arrives, rather than rewriting the file for every sample. They retain records in memory and preserve their existing layouts; full-history snapshot costs still grow with recording length. Construct `JsonDataHandler(path, snapshot_interval=2.0)` or `CsvDataHandler(path, snapshot_interval=2.0)` and attach it with `setDataHandler()` to use a different interval. `close()` waits for the worker and saves all remaining records; background write failures are reported on subsequent updates or during the final flush. WAV still appends each audio chunk without buffering the recording in memory. `stopStream()` stops the measurement, closes saving handlers, and removes the device stream. Measurement saving formats are `"csv"` and `"json"`; audio uses `"wav"`. File extensions are added automatically.
 
 ## Multiple Sequences
 
@@ -127,11 +127,22 @@ streamer = WebXiStreamHandler(
 	host="192.168.1.183",
 	sequenceID=SequenceIdEnums.MP3Signal.value,
 	mode="mp3",
+	saving="wav",
+	saving_path="saved_data/audio",
 )
+
+try:
+	streamer.startStream()
+except KeyboardInterrupt:
+	streamer.stopStream()
 ```
 
 The matching `flac` form uses `SequenceIdEnums.FLACSignal.value` and `mode="flac"`. Audio setup is enabled by the handler. The SLM can take a few seconds to initialize audio recording when its quality setting changes.
 
+WAV saving appends decoded mono samples as recording happens, updating the file header after each chunk so the file is readable before shutdown. Saving happens after decoding and calibration to pascals. Samples are divided by the fixed full-scale pressure `calibrationFactor * (2**23 - 1)` and saved as `PCM_24`, not peak-normalized per chunk. The filename includes `_fullscale-<value>Pa.wav`. To recover pressure values, multiply floating-point samples read from the WAV by that full-scale value (within 24-bit quantization accuracy). Samples outside the calibrated range produce a clipping warning; this scaling cannot repair upstream clipping. MP3 uses the decoded sample rate; the current FLAC decoder uses 65536 Hz. JSON and CSV saving are rejected for audio modes, and WAV saving is rejected for measurement modes. Run `uv sync` to install the `soundfile` dependency used for progressive WAV writing.
+
+To attach the handler directly, use `WavDataHandler("saved_data/audio", sample_rate=65536, full_scale_pa=calibrationFactor * (2**23 - 1))` from `slm_api.helpers.data_handler`, using the device's actual calibration factor. You can instead supply `sample_rate` and `full_scale_pa` to `handle()`; the stream supplies both automatically. Call `close()` when finished. Use a separate WAV handler and output path for each device. Existing float32 pressure WAVs are unchanged; this format applies to new recordings.
+
 ## Synchronized Multi-Device Stream
 
 Based on [multi_device_flac.py](src/slm_api/multi_device_flac.py), pass `multi_device=True` and start/stop the group through the synchronized helpers:
@@ -148,7 +159,7 @@ streams = [
 		mode="mp3",
 		streamName=f"Audio_{host}",
 		multi_device=True,
-		saving="csv",
+		saving="wav",
 		saving_path=f"saved_data/{host}",
 	)
 	for host in hosts
@@ -183,4 +194,4 @@ Legacy flags such as `mp3=True` remain supported, but `mode=` is preferred. Only
 
 - **No values arrive:** Confirm the requested sequences are enabled on the SLM.
 - **Audio returns no samples after first enable:** Allow the SLM a few seconds to initialize audio recording before retrying.
-- **Saved file is missing:** Call `stopStream()` or `stop_all()`; buffered files are written during shutdown.
+- **Saved file is missing:** Files are written when the handler first receives data (nonempty samples for WAV). Check the saving path and that the stream is delivering data. Still call `stopStream()` or `stop_all()` to clean up recording resources.

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "slm_open_api_package"
-version = "0.2.10"
+version = "0.2.11"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "requests",
     "numpy",
+    "pandas",
     "websockets",
     "kaitaistruct",
     "packaging",
@@ -14,6 +15,7 @@ dependencies = [
     "PyQt5",
     "PyQt5-Qt5<5.15.11",
     "miniaudio",
+    "soundfile",
     "matplotlib>=3.11.1",
     "cryptography>=50.0.1",
 ]

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "slm_open_api_package"
-version = "0.2.10"
+version = "0.2.11"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -10,6 +10,7 @@ requires-python = ">=3.12"
 dependencies = [
     "requests",
     "numpy",
+    "pandas",
     "websockets",
     "kaitaistruct",
     "packaging",
@@ -17,6 +18,7 @@ dependencies = [
     "PyQt5",
     "PyQt5-Qt5<5.15.11",
     "miniaudio",
+    "soundfile",
     "matplotlib>=3.11.1",
     "cryptography>=50.0.1",
 ]

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/CPB_example.py

@@ -6,7 +6,8 @@ from matplotlib.animation import FuncAnimation
 from slm_api.helpers.stream_handlers import WebXiStreamHandler
 from slm_api.helpers import webxi_helper_functions as webxi_helper 
 from slm_api.enums.sequence_id_enum import SequenceIdEnums
-from slm_api.helpers.data_handler import CsvDataHandler,PickleDataHandler,JsonDataHandler,MultiDataHandler, DataHandler
+from slm_api.helpers.data_handler import CsvDataHandler,JsonDataHandler,MultiDataHandler, DataHandler
+import datetime
 
 
 host = webxi_helper.set_host(__file__)
@@ -17,8 +18,8 @@ cpb_sequence_names = ["CPBLAeq"]
 sequenceID= SequenceIdEnums.CPBLAeq.value   
 
 class PrintHandler(DataHandler):
-    def handle(self, value, **data ):
-        print(f"{value}")
+    def handle(self, timestamp, value, **data ):
+        print(f"time = {timestamp} value: {value}")
 
 
 class FigureHandler:
@@ -59,12 +60,16 @@ if __name__ == "__main__":
     # turns on the CPB eq we want to use
     webxi_helper.turn_on_cpb_leq(host, cpb_sequence_names)
 
+    filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
+
     streamer = WebXiStreamHandler(host,
                                   sequenceID=sequenceID, 
                                   mode="cpb",
                                   sequenceNames=cpb_sequence_names, 
-                                  saving_path=r"./saved_data/test_file",
-                                  saving="json")
+                                  saving_path=f"./saved_data/{filename}",
+                                  saving="json",
+                                  time=True)
     # streamer.setDataHandler(JsonDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt"))
     streamer.setDataHandler(PrintHandler())
     

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/example_multi.py

@@ -8,6 +8,8 @@ from matplotlib.animation import FuncAnimation
 from slm_api.helpers import webxi_helper_functions as webxi_helper
 from slm_api.helpers import stream_handlers as sh
 from slm_api.helpers.data_handler import DataHandler, MultiDataHandler
+import datetime
+
 
 # UseHttps(use_https=False)
 
@@ -15,7 +17,7 @@ host = webxi_helper.set_host(__file__)
 
 # This example will stream LAeq. Add more names to the list to plot several sequences at once.
 # Incase of error make sure the sequences are enabled on the SLM.
-sequenceNames = ["LAeq", "LCeq", "LAF"]
+sequenceNames = ["LAeq", "LCeq"]
 
 class PrintHandler(DataHandler):
     def handle(self, *, name, value, **data):
@@ -70,7 +72,9 @@ if __name__ == "__main__":
     # sets the sequences to true. You can add or remove sequences at the top of the file.
     webxi_helper.turn_on_bb_leq(host, sequenceNames)
 
-    streamer = sh.WebXiStreamHandler(host=host, sequenceNames=sequenceNames, mode="multi", saving="json", saving_path=f"./saved_data/test")
+    filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
+    streamer = sh.WebXiStreamHandler(host=host, sequenceNames=sequenceNames, time=True, mode="multi", saving="csv", saving_path=f"./saved_data/{filename}")
     fig = FigHandler(sequenceNames)
     streamer.setDataHandler(MultiDataHandler(PrintHandler(), fig))
     fig.startAnimation()

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/fast_log_example.py

@@ -36,6 +36,7 @@ from slm_api.helpers import webxi_helper_functions as webxi_helper
 # enums
 from slm_api.enums.sequence_id_enum import SequenceIdEnums
 from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+import datetime
 
 # ---------- Configuration ---------- 
 host = webxi_helper.set_host(__file__)
@@ -52,8 +53,8 @@ FAST_LOGGING_INTERVAL_MS = FastLogInterval.interval_1000ms.value
 SEQUENCE_ID = SequenceIdEnums.FastLAF.value
 
 class PrintDataHandler(DataHandler):
-    def handle(self, timestamp, name, local, value, unit):
-        print(f"{timestamp}{name} ({local}):  {value:7.2f} {unit}")
+    def handle(self, timestamp, name, local, value, unit, **data):
+        print(f"{timestamp} {name} ({local}):  {value:7.2f} {unit}")
 
 
 
@@ -150,14 +151,28 @@ class PrintDataHandler(DataHandler):
 
 
 if __name__ == "__main__":
+
+    filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
+
+    # turns off all BB freq weights to prevent interference
+    webxi_helper.turn_off_bb_freq_weight(host)
+
+    # turns on the wanted BB freq weights for this example
+    webxi_helper.turn_on_bb_freq_weight(host, ["A"], fast=True)
+
+    # sets the sequences to true. 
+    # For fastlogging add fast=True so it routes to the correct endpoint
+    webxi_helper.turn_on_bb_leq(host, "LAF", fast=True)
     
     try:
         streamer = WebXiStreamHandler(host,
                                       sequenceID = SEQUENCE_ID, 
                                       mode="fast_logging",
                                       fast_logging_interval=FAST_LOGGING_INTERVAL_MS,
-                                      saving="csv",
-                                      saving_path=r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")
+                                      saving="json",
+                                      saving_path=f"./saved_data/{filename}",
+                                      time=True)
         streamer.setDataHandler(PrintDataHandler())
                                                  
 

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/flac_example.py

@@ -29,6 +29,7 @@ import threading
 
 from slm_api.helpers.FigureHandler import FigureHandler
 from slm_api.helpers.data_handler import  MultiDataHandler, CsvDataHandler
+import datetime
 
 
 # FLAC streaming is only available on 2255
@@ -153,8 +154,10 @@ def on_close():
     streamer.stopStream()
 
 if __name__ == "__main__":
+    filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
     # streamer = streamHandler()
-    streamer = sh.WebXiStreamHandler(host, sequenceID=sequenceID, mode="flac", saving="csv", saving_path=r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")
+    streamer = sh.WebXiStreamHandler(host, sequenceID=sequenceID, mode="flac", saving="wav", saving_path=f"./saved_data/flac_{filename}")
     # streamer.setDataHandler(MultiDataHandler(PrintDataHandler(), CsvDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")))
     fig = figureHandler()
     fig.app.aboutToQuit.connect(on_close)

slm_open_api_package-0.2.11/src/slm_api/helpers/data_handler.py

@@ -0,0 +1,251 @@
+"""Optional DataHandler for WebXiStreamHandler. By default WebXiStreamHandler
+does nothing with decoded values - call streamer.setDataHandler(...) with an
+instance of one of these (or your own subclass) before startStream() to
+receive/print/save them."""
+
+import csv
+import json
+import tempfile
+import threading
+import warnings
+from contextlib import contextmanager
+from pathlib import Path
+import numpy as np
+import soundfile as sf
+
+
+class DataHandler:
+    """Override handle() to decide what happens with decoded stream values.
+    """
+    
+
+    def handle(self, **data):
+        pass
+
+
+class _BufferedFileDataHandler(DataHandler):
+    """Buffers records and publishes snapshots in a background worker.
+    Call close() to stop the worker and save remaining records. WAV writes chunks.
+    """
+
+    _extension = None  # set by subclasses, e.g. "json", "csv", "wav"
+
+    def __init__(self, path, snapshot_interval=1.0):
+        if not np.isfinite(snapshot_interval) or snapshot_interval <= 0:
+            raise ValueError("Snapshot interval must be positive and finite")
+        path = Path(path)
+        if self._extension and path.suffix.lower() != f".{self._extension}":
+            path = path.with_name(path.name + f".{self._extension}")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._path = path
+        self._records = []
+        self._lock = threading.RLock()
+        self._write_lock = threading.Lock()
+        self._snapshot_interval = snapshot_interval
+        self._stop_event = threading.Event()
+        self._worker = None
+        self._saved_count = -1
+        self._closed = False
+        self._write_error = None
+
+    def handle(self, **data):
+        with self._lock:
+            if self._closed:
+                return
+            if self._write_error is not None:
+                raise RuntimeError("Background snapshot saving failed") from self._write_error
+            if "values" in data:
+                data["values"] = [float(v) for v in data["values"]]
+            elif "samples" in data:
+                samples = data.pop("samples")
+                data.update(count=len(samples), min=float(min(samples)), max=float(max(samples)))
+            self._records.append(data)
+            if self._worker is None:
+                self._worker = threading.Thread(
+                    target=self._run_snapshots, name=f"snapshot-{self._path.name}", daemon=True,
+                )
+                self._worker.start()
+
+    def _run_snapshots(self):
+        while not self._stop_event.wait(self._snapshot_interval):
+            try:
+                self._flush_snapshot()
+            except Exception as error:
+                with self._lock:
+                    self._write_error = error
+                self._stop_event.set()
+                return
+
+    def _flush_snapshot(self):
+        with self._write_lock:
+            with self._lock:
+                count = len(self._records)
+                if count == self._saved_count:
+                    return
+                records = self._records.copy()
+            self._write_snapshot(records)
+            with self._lock:
+                self._saved_count = count
+
+    def _write_snapshot(self, records):
+        raise NotImplementedError
+
+    @contextmanager
+    def _snapshot_file(self, mode, **options):
+        temporary_path = None
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode=mode, dir=self._path.parent, prefix=f".{self._path.name}.",
+                suffix=".tmp", delete=False, **options,
+            ) as target:
+                temporary_path = Path(target.name)
+                yield target
+            temporary_path.replace(self._path)
+        finally:
+            if temporary_path is not None:
+                temporary_path.unlink(missing_ok=True)
+
+    def close(self):
+        with self._lock:
+            self._closed = True
+            self._stop_event.set()
+            worker = self._worker
+        if worker is not None:
+            worker.join()
+        self._flush_snapshot()
+
+    def _group_records(self, records=None):
+        hosts = {}
+        for record in self._records if records is None else records:
+            row = record.copy()
+            if not row.get("timestamp"):
+                row.pop("timestamp", None)
+            host = row.pop("host", None)
+            rows = hosts.setdefault(host, [])
+            if "name" in row and "value" in row:
+                name = row.pop("name")
+                value = row.pop("value")
+                if (rows and rows[-1].get("timestamp") == row.get("timestamp")
+                        and name not in rows[-1]):
+                    rows[-1].update(row)
+                    rows[-1][name] = value
+                else:
+                    row[name] = value
+                    rows.append(row)
+            else:
+                rows.append(row)
+        return hosts
+
+
+class JsonDataHandler(_BufferedFileDataHandler):
+    """Writes records grouped by host, combining named values per timestamp."""
+    _extension = "json"
+
+    def _write_snapshot(self, records):
+        with self._snapshot_file("w", encoding="utf-8") as target:
+            records = [{"host": host, "data": rows} for host, rows in self._group_records(records).items()]
+            json.dump(
+                records,
+                target,
+                indent=2,
+                default=lambda value: (
+                    value.tolist()
+                    if isinstance(value, (np.ndarray, np.generic))
+                    else str(value)
+                ),
+            )
+
+class CsvDataHandler(_BufferedFileDataHandler):
+    """Writes rows per host and timestamp, storing vectors as JSON list cells."""
+    _extension = "csv"
+
+    def _write_snapshot(self, records):
+        with self._snapshot_file("w", encoding="utf-8", newline="") as target:
+            records = [
+                {"host": host, **row}
+                for host, rows in self._group_records(records).items()
+                for row in rows
+            ]
+            for record in records:
+                for name, value in record.items():
+                    if isinstance(value, np.ndarray):
+                        record[name] = json.dumps(value.tolist())
+                    elif isinstance(value, (list, tuple)):
+                        record[name] = json.dumps(value)
+            fields = dict.fromkeys(key for record in records for key in record)
+            fieldnames = [key for key in ("host", "timestamp") if key in fields]
+            fieldnames.extend(key for key in fields if key not in fieldnames)
+            writer = csv.DictWriter(target, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(records)
+
+
+class WavDataHandler(_BufferedFileDataHandler):
+    """Writes PCM_24 chunks scaled by the full-scale pressure in the filename."""
+    _extension = "wav"
+
+    def __init__(self, path, sample_rate=None, full_scale_pa=None):
+        super().__init__(path)
+        self._sample_rate = sample_rate
+        self._full_scale_pa = full_scale_pa
+        self._started = False
+        self._closed = False
+
+    def handle(self, *, samples, sample_rate=None, full_scale_pa=None, **data):
+        with self._lock:
+            if self._closed:
+                return
+            rate = sample_rate if sample_rate is not None else self._sample_rate
+            if rate is None or rate <= 0 or int(rate) != rate:
+                raise ValueError("WAV samples require a positive integer sample rate")
+            if self._sample_rate is not None and rate != self._sample_rate:
+                raise ValueError("Sample rate cannot change within a WAV file")
+            scale = full_scale_pa if full_scale_pa is not None else self._full_scale_pa
+            if scale is None or not np.isfinite(scale) or scale <= 0:
+                raise ValueError("PCM_24 WAV samples require a positive finite full_scale_pa")
+            if self._full_scale_pa is not None and scale != self._full_scale_pa:
+                raise ValueError("Full-scale pressure cannot change within a WAV file")
+            values = np.asarray(samples, dtype=np.float64)
+            if values.ndim != 1:
+                raise ValueError("WAV samples must be a mono, one-dimensional array")
+            if not np.isfinite(values).all():
+                raise ValueError("WAV samples must be finite")
+            self._sample_rate = int(rate)
+            self._full_scale_pa = float(scale)
+            if values.size:
+                normalized = values / self._full_scale_pa
+                if np.any(normalized > 1.0) or np.any(normalized < -(2 ** 23) / (2 ** 23 - 1)):
+                    warnings.warn("Audio exceeds the calibrated full-scale pressure; PCM_24 samples will clip", RuntimeWarning, stacklevel=2)
+                normalized = np.clip(normalized, -1.0, 1.0)
+                if not self._started:
+                    self._path = self._path.with_name(
+                        f"{self._path.stem}_fullscale-{self._full_scale_pa:.17g}Pa.wav"
+                    )
+                options = {"mode": "r+"} if self._started else {
+                    "mode": "w", "samplerate": self._sample_rate,
+                    "channels": 1, "format": "WAV", "subtype": "PCM_24",
+                }
+                with sf.SoundFile(self._path, **options) as target:
+                    target.seek(0, sf.SEEK_END)
+                    target.write(normalized)
+                self._started = True
+
+    def close(self):
+        with self._lock:
+            self._closed = True
+
+
+class MultiDataHandler(DataHandler):
+    """Fans out to several handlers at once (e.g. print AND save AND plot)."""
+
+    def __init__(self, *handlers):
+        self._handlers = handlers
+
+    def handle(self, **data):
+        for h in self._handlers:
+            h.handle(**data)
+
+    def close(self):
+        for h in self._handlers:
+            if hasattr(h, "close"):
+                h.close()

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/helpers/stream_handlers.py

@@ -5,7 +5,7 @@ is picked with boolean flags (cpb, multi, flac, mp3) instead of subclassing."""
 from . import https_requests
 import time
 import re
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from timeit import default_timer as timer
 import numpy as np
 import miniaudio
@@ -19,14 +19,14 @@ from . import flac_stream_2_samples as flac2samples
 from .tmpFileStateMachine import TmpfileStateMachine
 from ..webxi import webxi_stream
 from slm_api.enums.fast_log_intervals_enum import FastLogInterval
-from .data_handler import MultiDataHandler, JsonDataHandler, CsvDataHandler, PickleDataHandler
+from .data_handler import MultiDataHandler, JsonDataHandler, CsvDataHandler, WavDataHandler
 
 _SAVING_HANDLERS = {
     "json": JsonDataHandler,
     "csv": CsvDataHandler,
-    "pickle": PickleDataHandler,
+    "wav": WavDataHandler,
 }
-_SAVING_DEFAULT_EXTENSIONS = {"json": "json", "csv": "csv", "pickle": "pkl"}
+_SAVING_DEFAULT_EXTENSIONS = {"json": "json", "csv": "csv", "wav": "wav"}
 
 # WebXi header timestamps are 64-bit fixed-point seconds since the Unix epoch
 # (Q32.32): upper 32 bits = whole seconds, lower 32 bits = fraction of a second.
@@ -65,15 +65,21 @@ def _set_fast_logging_interval(host, enum_value):
 def _get_slm_utc_offset_seconds(host):
     """Read the SLM's own configured time zone offset from UTC, in seconds.
     The device reports it as a string like 'GMT+02:00'."""
-    response = https_requests.get(host, "/WebXi/Applications/SLM/Outputs/TimeZone")
-    response.raise_for_status()
-    value = str(response.json()).strip()
-    match = re.search(r"([+-])(\d{2}):?(\d{2})", value)
-    if not match:
-        raise ValueError(f"Unexpected TimeZone value: {value!r}")
-    sign, hours, minutes = match.groups()
-    offset = int(hours) * 3600 + int(minutes) * 60
-    return -offset if sign == "-" else offset
+    endpoints = (
+        "/WebXi/Applications/SLM/Outputs/TimeZone",
+        "/WebXi/Applications/SLM/Setup/RegionalTimeZoneGMT",
+    )
+    for endpoint in endpoints:
+        response = https_requests.get(host, endpoint)
+        response.raise_for_status()
+        value = str(response.json()).strip()
+        match = re.fullmatch(r"(?:GMT|UTC)?([+-])(\d{2}):?(\d{2})", value)
+        if match:
+            sign, hours, minutes = match.groups()
+            if int(hours) < 24 and int(minutes) < 60:
+                offset = int(hours) * 3600 + int(minutes) * 60
+                return -offset if sign == "-" else offset
+    raise ValueError("SLM reported no valid timezone in Outputs/TimeZone or Setup/RegionalTimeZoneGMT")
 
 
 class _TimeStamps:
@@ -176,8 +182,9 @@ class WebXiStreamHandler(stream.StreamHandler):
     - mode="screen_record": streams the device's ScreenImage sequence, keeping the latest
       received PNG in `self.image_bytes`.
 
-    time=True additionally subscribes the device's StartTime/ElapsedTime sequences and
-    prefixes each printed line (laeq/cpb/multi modes) with the resolved wall-clock time.
+    time=True additionally subscribes the device's SLMTime sequence and supplies
+    ISO timestamps in the SLM's configured time zone. Fast logging uses the device
+    header time plus the sample interval for per-sample timestamps.
     """
 
     def __init__(self, host, sequenceID=None, sequenceNames=None,
@@ -220,6 +227,8 @@ class WebXiStreamHandler(stream.StreamHandler):
         if saving is not None:
             if saving.lower() not in _SAVING_HANDLERS:
                 raise ValueError(f"Invalid saving format: {saving!r}, must be one of {list(_SAVING_HANDLERS)}")
+            if saving.lower() == "wav" and not (self.mp3 or self.flac):
+                raise ValueError("WAV saving is only supported for FLAC and MP3 streams")
             if saving_path is None:
                 saving_path = "stream_data"
             self._saving_handler = _SAVING_HANDLERS[saving.lower()](saving_path)
@@ -247,6 +256,13 @@ class WebXiStreamHandler(stream.StreamHandler):
         self.calibrationFactor = (20e-6 * 10 ** (max_lvl / 20)) / (2 ** 23 - 1) * np.sqrt(2)
 
     def streamInit(self):
+        if (self.mp3 or self.flac) and isinstance(
+            self._saving_handler,
+            (JsonDataHandler, CsvDataHandler),
+        ):
+            raise ValueError(
+                "FLAC and MP3 streams must be saved as WAV, not JSON or CSV."
+            )
         if self.mp3 or self.flac:
             quality_setting = "AudioRecordingListenQuality" if self.mp3 else "AudioRecordingAnalysisQuality"
             response = https_requests.put(self.host, f"/WebXi/Applications/SLM/setup/{quality_setting}", json=1)
@@ -286,17 +302,17 @@ class WebXiStreamHandler(stream.StreamHandler):
             self.data_type = self.sequence["DataType"]
 
         stream_ids = list(self.ID) if isinstance(self.ID, list) else [self.ID]
-        self.stream_ids = stream_ids  # saved for start_all_synced() when multi_device=True
+        if self.time:
+            utc_offset_seconds = _get_slm_utc_offset_seconds(self.host)
+            self._slm_timezone = timezone(timedelta(seconds=utc_offset_seconds))
+            self._slm_time = None
+            time_id, _ = seq.get_sequence(self.host, seq.getSequenceID(self.host, "SLMTime"))
+            self._time_ids = {"SLMTime": time_id}
+            stream_ids.append(time_id)
+        self.stream_ids = stream_ids
         if self.multi_device:
             return
 
-        if self.time:
-            utc_offset_seconds = _get_slm_utc_offset_seconds(self.host)
-            self._time_stamps = _TimeStamps(utc_offset_seconds=utc_offset_seconds)
-            start_id, _ = seq.get_sequence(self.host, seq.getSequenceID(self.host, "StartTime"))
-            elapsed_id, _ = seq.get_sequence(self.host, seq.getSequenceID(self.host, "ElapsedTime"))
-            self._time_ids = {"StartTime": start_id, "ElapsedTime": elapsed_id}
-            stream_ids += [start_id, elapsed_id]
         self.uri = stream.setup_stream(self.host, stream_ids, self.streamName)
         meas.start_pause_measurement(self.host, True)
 
@@ -321,13 +337,20 @@ class WebXiStreamHandler(stream.StreamHandler):
         if package.header.message_type != webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
             return
         for block in package.content.sequence_blocks:
-            if block.sequence_id == self._time_ids["StartTime"]:
-                self._time_stamps.StartTime = stream.data_type_conv("BKTimeSpan", block.values, None)
-            elif block.sequence_id == self._time_ids["ElapsedTime"] and self._time_stamps.StartTime is not None:
-                self._time_stamps.move(stream.data_type_conv("BKTimeSpan", block.values, None))
-
-    def _time_prefix(self):
-        return f"{self._time_stamps.lastTime}  " if self.time else ""
+            if getattr(block, "sequence_id", None) == self._time_ids["SLMTime"]:
+                self._slm_time = int.from_bytes(block.values, "little", signed=True)
+
+    def _time_prefix(self, epoch_seconds=None):
+        if not self.time:
+            return ""
+        if epoch_seconds is None:
+            epoch_seconds = self._slm_time
+        if epoch_seconds is None:
+            return ""
+        timestamp = datetime.fromtimestamp(epoch_seconds, self._slm_timezone)
+        if self.fast_logging:
+            return timestamp.isoformat(timespec="microseconds")
+        return timestamp.strftime("%Y-%m-%dT%H:%M:%S")
 
     def _handle_data(self, **data):
         """Deliver a stream record with the host it originated from."""
@@ -344,9 +367,10 @@ class WebXiStreamHandler(stream.StreamHandler):
     def _msg_func_cpb(self, message):
         package = webxi_stream.WebxiStream.from_bytes(message)
         if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
-            value = package.content.sequence_blocks[0].values
-            self.CPB_values = np.array(stream.data_type_conv(self.sequence["DataType"], value, self.sequence["VectorLength"])) / 100
-            self._handle_data(timestamp=self._time_prefix(), value=self.CPB_values)
+            for block in package.content.sequence_blocks:
+                if block.sequence_id == self.ID:
+                    self.CPB_values = np.array(stream.data_type_conv(self.sequence["DataType"], block.values, self.sequence["VectorLength"])) / 100
+                    self._handle_data(timestamp=self._time_prefix(), name=self.sequence["Name"], value=self.CPB_values)
 
     def calcFreqBands(self):
         """Only meaningful when cpb=True."""
@@ -371,11 +395,7 @@ class WebXiStreamHandler(stream.StreamHandler):
         if package.header.message_type != webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
             return
 
-        # The header time is the time of the first sample; fall back to wall clock if
-        # it is not in the expected Q32.32 format/epoch.
         start = _webxi_time_to_epoch(package.header.time)
-        if abs(start - time.time()) > 86400:
-            start = time.time()
 
         # A 1-second package batches many fast-logged samples.
         samples = []
@@ -398,8 +418,9 @@ class WebXiStreamHandler(stream.StreamHandler):
         name = self.sequence.get("Name", "FastLAeq")
         local = self.sequence.get("LocalName", "LAeq")
         unit = self.sequence.get("Unit", "dB re 20uPa")
-        for n, v in enumerate(samples):
-            self._handle_data(timestamp=self._time_prefix(), name=name, local=local, value=v, unit=unit)
+        for sample_index, value in enumerate(samples):
+            timestamp = self._time_prefix(start + sample_index * self.fast_logging_interval_s)
+            self._handle_data(timestamp=timestamp, name=name, local=local, value=value, unit=unit)
 
     def _msg_func_screen_record(self, message):
         package = webxi_stream.WebxiStream.from_bytes(message)
@@ -414,16 +435,22 @@ class WebXiStreamHandler(stream.StreamHandler):
         start = timer()
         package = webxi_stream.WebxiStream.from_bytes(message)
         if package.header.message_type == webxi_stream.WebxiStream.Header.EMessageType.e_sequence_data:
-            block = package.content.sequence_blocks[0]
-            if self.mp3:
-                data = self.tmpFileSM.runStateMachine(block.frame)
-                mp3DecodedData = miniaudio.mp3_read_s16(data)
-                samples = mp3DecodedData.samples[-mp3DecodedData.num_frames:]
-                decoded = (np.asarray(samples, dtype=np.int32) << 8) * self.calibrationFactor
-            else:
-                decoded = flac2samples.decode(block, self.calibrationFactor)
-            DataBuffer.append(decoded)
-            self._handle_data(samples=decoded)
+            for block in package.content.sequence_blocks:
+                if self.ID not in getattr(block, "sequence_ids", ()):
+                    continue
+                if self.mp3:
+                    samples, sample_rate = self.tmpFileSM.decode(block.frame)
+                    if not samples:
+                        continue
+                    decoded = (np.asarray(samples, dtype=np.int32) << 8) * self.calibrationFactor
+                else:
+                    decoded = flac2samples.decode(block, self.calibrationFactor)
+                    sample_rate = 2 ** 16
+                DataBuffer.append(decoded)
+                self._handle_data(
+                    samples=decoded, sample_rate=sample_rate,
+                    full_scale_pa=self.calibrationFactor * (2 ** 23 - 1),
+                )
             total = timer() - start
             if 0.0625 < total:
                 print(f"TotalTime: {total}")

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/helpers/tmpFileStateMachine.py

@@ -1,5 +1,6 @@
 import enum
 import tempfile
+import miniaudio
 
 # a dual bufferfile stores the data which is used for decoding the mp3 stream.
 class TmpfileStateMachine:
@@ -15,6 +16,29 @@ class TmpfileStateMachine:
         self.tempFile1 = None
         self.tempFile2 = None
         self.state = self.State.init
+        self._decoded_file = None
+        self._decoded_frames = 0
+
+    def decode(self, mp3Data):
+        active_file = (
+            self.tempFile1
+            if self.state in (self.State.init, self.State.file1, self.State.preFile2)
+            else self.tempFile2
+        )
+        if active_file is not self._decoded_file:
+            self._decoded_frames = 0
+            if active_file is not None:
+                active_file.seek(0)
+                overlap = active_file.read()
+                if overlap:
+                    self._decoded_frames = miniaudio.mp3_read_s16(overlap).num_frames
+        decoded = miniaudio.mp3_read_s16(self.runStateMachine(mp3Data))
+        if decoded.nchannels != 1:
+            raise ValueError("SLM MP3 audio must be mono")
+        samples = decoded.samples[self._decoded_frames:]
+        self._decoded_frames = decoded.num_frames
+        self._decoded_file = active_file if active_file is not None else self.tempFile1
+        return samples, decoded.sample_rate
 
     def runStateMachine(self, mp3Data):
         readData = None
@@ -46,9 +70,10 @@ class TmpfileStateMachine:
         if self.tempFile2:
             self.tempFile2.close()
             self.tempFile2 = None
+        self.tempFile1.seek(0, 2)
+        self.tempFile1.write(bytes(mp3Data))
         self.tempFile1.seek(0)
         dataFromFile = self.tempFile1.read()
-        self.tempFile1.write(bytes(mp3Data))
         if (len(dataFromFile) > 20 * 1024):
             self.state = self.State.preFile2
         return dataFromFile
@@ -57,12 +82,12 @@ class TmpfileStateMachine:
         if not self.tempFile2:
             self.tempFile2 = tempfile.SpooledTemporaryFile(max_size=1 * 1024 * 1024, mode='w+b', suffix=".mp3",
                                                            prefix="tmp2")
-        self.tempFile1.seek(0)
-        self.tempFile2.seek(0)
-        dataFromFile = self.tempFile1.read()
-        tmp = self.tempFile2.read()
+        self.tempFile1.seek(0, 2)
+        self.tempFile2.seek(0, 2)
         self.tempFile1.write(bytes(mp3Data))
         self.tempFile2.write(bytes(mp3Data))
+        self.tempFile1.seek(0)
+        dataFromFile = self.tempFile1.read()
         if (len(dataFromFile) > 30 * 1024):
             self.state = self.State.file2
         return dataFromFile
@@ -71,9 +96,10 @@ class TmpfileStateMachine:
         if self.tempFile1:
             self.tempFile1.close()
             self.tempFile1 = None
+        self.tempFile2.seek(0, 2)
+        self.tempFile2.write(bytes(mp3Data))
         self.tempFile2.seek(0)
         dataFromFile = self.tempFile2.read()
-        self.tempFile2.write(bytes(mp3Data))
         if (len(dataFromFile) > 20 * 1024):
             self.state = self.State.preFile1
         return dataFromFile
@@ -82,12 +108,12 @@ class TmpfileStateMachine:
         if not self.tempFile1:
             self.tempFile1 = tempfile.SpooledTemporaryFile(max_size=1 * 1024 * 1024, mode='w+b', suffix=".mp3",
                                                            prefix="tmp1")
-        self.tempFile1.seek(0)
-        self.tempFile2.seek(0)
-        dataFromFile = self.tempFile2.read()
-        tmp = self.tempFile1.read()
+        self.tempFile1.seek(0, 2)
+        self.tempFile2.seek(0, 2)
         self.tempFile1.write(bytes(mp3Data))
         self.tempFile2.write(bytes(mp3Data))
+        self.tempFile2.seek(0)
+        dataFromFile = self.tempFile2.read()
         if (len(dataFromFile) > 30 * 1024):
             self.state = self.State.file1
         return dataFromFile

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/helpers/webxi_helper_functions.py

@@ -22,6 +22,8 @@ def turn_on_bb_freq_weight(host, weights, fast=False):
         for weight in weights:
             put(host , f"/webxi/Applications/SLM/Setup/BBFreqWeight{weight}", json=True)
     else:
+        for weight in weights:
+                    put(host , f"/webxi/Applications/SLM/Setup/BBFreqWeight{weight}", json=True)
         for weight in weights:
             put(host , f"/webxi/Applications/SLM/Setup/FastBBFreqWeight{weight}", json=True)
 

{slm_open_api_package-0.2.10 → slm_open_api_package-0.2.11}/src/slm_api/mp3_example.py

@@ -29,6 +29,7 @@ from slm_api.helpers.FigureHandler import FigureHandler
 from slm_api.helpers import TmpfileStateMachine
 from slm_api.helpers import webxi_helper_functions as webxi_helper
 from slm_api.helpers.data_handler import CsvDataHandler, MultiDataHandler, DataHandler
+import datetime
 
 host = webxi_helper.set_host(__file__)
 sequenceID = 156
@@ -154,9 +155,11 @@ def on_close():
 
 
 if __name__ == "__main__":
+
+    filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
     # streamer = streamHandler()
-    streamer = sh.WebXiStreamHandler(host, sequenceID, mode="mp3")
-    # streamer.setDataHandler(CsvDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt"))
+    streamer = sh.WebXiStreamHandler(host, sequenceID, mode="mp3", saving="wav", saving_path=f"./saved_data/mp3_{filename}")
     # streamer.setDataHandler(PrintDataHandler())
 
     fig = figureHandler()

slm_open_api_package-0.2.11/src/slm_api/plot_saved_data_example.py

@@ -0,0 +1,163 @@
+"""Plot saved JSON/CSV measurements without connecting to an SLM.
+
+Usage: uv run src/slm_api/plot_saved_data_example.py saved_data/measurements.json
+Add --output-dir saved_data/plots to save PNGs instead of opening plot windows.
+CPB bars energy-average equally weighted saved readings, not measurement durations.
+Band numbers are used because the saved files do not include centre frequencies.
+"""
+
+import argparse
+import json
+from datetime import datetime
+from pathlib import Path
+
+import matplotlib.dates as mdates
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+
+def load_records(path):
+    path = Path(path)
+    if path.suffix.lower() == ".csv":
+        frame = pd.read_csv(path, encoding="utf-8-sig", dtype=str, keep_default_na=False)
+        return frame.to_dict(orient="records")
+    if path.suffix.lower() != ".json":
+        raise ValueError("Select a .json or .csv measurement file")
+    frame = pd.read_json(path, encoding="utf-8-sig", orient="records", convert_dates=False, dtype=False)
+    frame = frame.astype(object).where(pd.notna(frame), None)
+    records = []
+    for entry in frame.to_dict(orient="records"):
+        entry = {key: value for key, value in entry.items() if value is not None}
+        if "data" in entry:
+            if not isinstance(entry["data"], list):
+                raise ValueError("Each host's data must be a list")
+            for row in entry["data"]:
+                if not isinstance(row, dict):
+                    raise ValueError("Each measurement row must be an object")
+                records.append({**row, "host": entry.get("host", "Unknown")})
+        else:
+            records.append(entry)
+    return records
+
+
+def measurement_value(value, name):
+    if isinstance(value, str):
+        if not value.strip():
+            return None
+        try:
+            value = json.loads(value)
+        except ValueError:
+            if name.upper().startswith("CPB"):
+                raise ValueError(f"{name} must contain a numeric JSON array, not array display text") from None
+            return None
+    if isinstance(value, bool) or value is None:
+        return None
+    if not isinstance(value, (int, float, list)):
+        return None
+    values = np.asarray(value, dtype=float)
+    if values.ndim > 1:
+        raise ValueError(f"{name} must be a scalar or a one-dimensional band array")
+    return values
+
+
+def plot_records(records):
+    hosts = {}
+    for record in records:
+        hosts.setdefault(record.get("host") or "Unknown", []).append(record)
+    figures = []
+    metadata = {"host", "timestamp", "name", "local", "unit", "count", "min", "max"}
+    for host, rows in hosts.items():
+        broadband = {}
+        spectra = {}
+        for row_index, row in enumerate(rows):
+            measurements = (
+                {row["name"]: row["value"]}
+                if "name" in row and "value" in row else row
+            )
+            for name, value in measurements.items():
+                if name in metadata:
+                    continue
+                values = measurement_value(value, name)
+                if values is None or values.size == 0:
+                    continue
+                if values.ndim == 1:
+                    spectra.setdefault(name, []).append(values)
+                elif np.isfinite(values):
+                    broadband.setdefault(name, []).append((row_index, float(values)))
+
+        if broadband:
+            timed = all(row.get("timestamp") for row in rows)
+            if timed:
+                try:
+                    positions = [datetime.fromisoformat(row["timestamp"].strip()) for row in rows]
+                    offsets = {position.utcoffset() for position in positions}
+                    if len(offsets) != 1:
+                        raise ValueError("Inconsistent timezone offsets")
+                except ValueError:
+                    timed = False
+            if not timed:
+                positions = list(range(1, len(rows) + 1))
+            figure, axis = plt.subplots(figsize=(12, 5), layout="constrained")
+            for name, points in broadband.items():
+                indices, levels = zip(*points)
+                axis.plot([positions[index] for index in indices], levels, label=name)
+            if timed:
+                locator = mdates.AutoDateLocator()
+                axis.xaxis.set_major_locator(locator)
+                axis.xaxis.set_major_formatter(mdates.ConciseDateFormatter(locator))
+            axis.set(title=f"{host} - Broadband", xlabel="Time" if timed else "Record number", ylabel="Level [dB SPL]")
+            axis.grid(alpha=0.3)
+            axis.legend()
+            figures.append(figure)
+
+        for name, readings in spectra.items():
+            band_count = len(readings[0])
+            if any(len(reading) != band_count for reading in readings):
+                raise ValueError(f"{host}: {name} changes band count within the file")
+            matrix = np.stack(readings)
+            bands = [column[np.isfinite(column)] for column in matrix.T]
+            if not any(band.size for band in bands):
+                continue
+            levels = []
+            for band in bands:
+                if band.size:
+                    peak = band.max()
+                    levels.append(peak + 10 * np.log10(np.mean(10 ** ((band - peak) / 10))))
+                else:
+                    levels.append(np.nan)
+            figure, axis = plt.subplots(figsize=(12, 5), layout="constrained")
+            positions = np.arange(1, band_count + 1)
+            axis.bar(positions, levels, width=0.9)
+            axis.set_xticks(positions)
+            axis.set(title=f"{host} - {name} (energy average of {len(readings)} readings)", xlabel="Frequency band number", ylabel="Level [dB SPL]")
+            axis.grid(axis="y", alpha=0.3)
+            axis.tick_params(axis="x", labelsize=8)
+            figures.append(figure)
+    if not figures:
+        raise ValueError("No numeric measurement data found in the file")
+    return figures
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Plot broadband levels as lines and CPB bands as energy-averaged bars")
+    parser.add_argument("path", type=Path, help="Saved JSON or CSV measurement file")
+    parser.add_argument("--output-dir", type=Path, help="Save PNG plots instead of opening windows")
+    arguments = parser.parse_args()
+    try:
+        figures = plot_records(load_records(arguments.path))
+    except (OSError, ValueError) as error:
+        parser.error(str(error))
+    if arguments.output_dir:
+        arguments.output_dir.mkdir(parents=True, exist_ok=True)
+        for index, figure in enumerate(figures, start=1):
+            output = arguments.output_dir / f"{arguments.path.stem}_plot_{index}.png"
+            figure.savefig(output, dpi=150)
+            print(output)
+            plt.close(figure)
+    else:
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()

slm_open_api_package-0.2.10/src/slm_api/helpers/data_handler.py

@@ -1,94 +0,0 @@
-"""Optional DataHandler for WebXiStreamHandler. By default WebXiStreamHandler
-does nothing with decoded values - call streamer.setDataHandler(...) with an
-instance of one of these (or your own subclass) before startStream() to
-receive/print/save them."""
-
-import csv
-import json
-import pickle
-from pathlib import Path
-
-
-class DataHandler:
-    """Override handle() to decide what happens with decoded stream values.
-    """
-    
-
-    def handle(self, **data):
-        pass
-
-
-class _BufferedFileDataHandler(DataHandler):
-    """Base class for handlers that buffer records in memory and write them
-    all to disk in close(). Call streamer.setDataHandler(...) before startStream(),
-    then handler.close() (or MultiDataHandler.close()) when you stop the stream."""
-
-    _extension = None  # set by subclasses, e.g. "json", "csv", "pkl"
-
-    def __init__(self, path):
-        path = Path(path)
-        if self._extension and path.suffix.lower() != f".{self._extension}":
-            path = path.with_name(path.name + f".{self._extension}")
-        path.parent.mkdir(parents=True, exist_ok=True)
-        self._path = path
-        self._records = []
-
-    def handle(self, **data):
-        if "values" in data:
-            data["values"] = [float(v) for v in data["values"]]
-        elif "samples" in data:
-            samples = data.pop("samples")
-            data.update(count=len(samples), min=float(min(samples)), max=float(max(samples)))
-        self._records.append(data)
-
-    def close(self):
-        raise NotImplementedError
-
-
-class JsonDataHandler(_BufferedFileDataHandler):
-    """Writes all buffered records to a single JSON file on close()."""
-    _extension = "json"
-
-    def close(self):
-        with open(self._path, "w") as f:
-            json.dump(self._records, f, indent=2, default=str)
-
-
-class CsvDataHandler(_BufferedFileDataHandler):
-    """Writes all buffered records to a CSV file on close(). Columns vary per
-    row since different modes carry different fields."""
-    _extension = "csv"
-
-    def close(self):
-        fieldnames = list(dict.fromkeys(key for record in self._records for key in record))
-        with open(self._path, "w", newline="") as f:
-            writer = csv.DictWriter(f, fieldnames=fieldnames)
-            writer.writeheader()
-            writer.writerows(self._records)
-
-
-class PickleDataHandler(_BufferedFileDataHandler):
-    """Writes all buffered records (as Python objects) to a pickle file on close()."""
-    _extension = "pkl"
-
-    def close(self):
-        with open(self._path, "wb") as f:
-            pickle.dump(self._records, f)
-
-
-
-
-class MultiDataHandler(DataHandler):
-    """Fans out to several handlers at once (e.g. print AND save AND plot)."""
-
-    def __init__(self, *handlers):
-        self._handlers = handlers
-
-    def handle(self, **data):
-        for h in self._handlers:
-            h.handle(**data)
-
-    def close(self):
-        for h in self._handlers:
-            if hasattr(h, "close"):
-                h.close()