slm-open-api-package 0.2.2__tar.gz → 0.2.4__tar.gz

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slm_open_api_package
-Version: 0.2.2
+Version: 0.2.4
 Summary: Add your description here
 Author: Sofus Vingaard
 Author-email: Sofus Vingaard <sofus.krebsvingaard@hbkworld.com>

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slm_open_api_package"
-version = "0.2.2"
+version = "0.2.4"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "slm_open_api_package"
-version = "0.2.2"
+version = "0.2.4"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/example_multi.py

@@ -22,7 +22,7 @@ from slm_api.helpers import stream_handlers as sh
 from slm_api.helpers.data_handler import DataHandler
 from slm_api.helpers.https_requests import UseHttps
 
-UseHttps(use_https=False)
+# UseHttps(use_https=False)
 
 host, ip = webxi_helper.set_host_ip(__file__)
 

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/flac_example.py

@@ -151,7 +151,6 @@ class figureHandler(FigureHandler):
 
 def on_close():
     streamer.stopStream()
-    meas.stop_measurement()
 
 if __name__ == "__main__":
     # streamer = streamHandler()

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/helpers/https_requests.py

@@ -18,6 +18,14 @@ class WebxiAdapter(HTTPAdapter):
         kwargs["assert_hostname"] = False  # urllib3 does its own SAN check independent of ssl_context.check_hostname
         return super().init_poolmanager(*args, **kwargs)
 
+def build_ssl_context():
+    """SSLContext trusting only webxi_root.pem, with hostname checking disabled."""
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    ctx.load_verify_locations(cafile=str(_CERT_FILE))
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_REQUIRED
+    return ctx
+
 
 _session = requests.Session()
 if _CERT_FILE.is_file():
@@ -26,6 +34,8 @@ if _CERT_FILE.is_file():
 class UseHttps:
     use_https = True  # class attribute: shared, module-wide default
 
+    
+
     def __init__(self, use_https=None):
         if use_https is not None:
             UseHttps.use_https = use_https

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/helpers/measurment_handler.py

@@ -17,3 +17,4 @@ def stop_measurement(hostID):
     """Stop a measurement on the device"""
     response = https_requests.put(hostID, "/WebXi/Applications/SLM?Action=Stop")
     assert(response.status_code == 200)
+

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/helpers/stream_handler.py

@@ -20,8 +20,12 @@ def setup_stream(host,ip,sequenceID,StreamName):
     if not (response.status_code == 201):  
         print(response.text)
         raise Exception("Cannot start stream, could be bacause of to many streams open on the device")
-    return 'ws://' + ip + response.json()["URI"][0]
-
+    https = https_requests.UseHttps.use_https
+    if https:
+        return 'wss://' + ip + response.json()["URI"][0]
+    else:
+        return 'ws://' + ip + response.json()["URI"][0]
+    
 def get_stream_ID(host, streamName):
     """This function shows how to find the ID of a specific stream with specific name"""
     streams = https_requests.get(host, "/WebXi/Streams?recursive").json()
@@ -75,6 +79,7 @@ class StreamHandler:
         self._stop_event = asyncio.Event()
         self.loop = asyncio.get_running_loop()
         task = self.loop.create_task(websocket_handler.next_async_websocket(self.uri, self.msg_func))
+        task.add_done_callback(lambda t: t.exception() and print(f"[{self.streamName}] Stream task failed: {t.exception()!r}"))
         await self._stop_event.wait()
         task.cancel()
         measurment_handler.stop_measurement(self.host)

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/helpers/stream_handlers.py

@@ -9,6 +9,7 @@ from datetime import datetime
 from timeit import default_timer as timer
 import numpy as np
 import miniaudio
+import threading
 
 from . import sequence_handler as seq
 from . import stream_handler as stream
@@ -109,6 +110,44 @@ class _TimeStamps:
         self._time_buffer = np.append(self._time_buffer[1:], new_value)
         return self.lastTime
 
+def start_all_synced(streams):
+    """For handlers constructed with multi_device=True: open each device's stream/websocket,
+    then trigger start_pause_measurement on all of them at (nearly) the same instant."""
+    for s in streams:
+        s.uri = stream.setup_stream(s.host, s.ip, s.stream_ids, s.streamName)
+        threading.Thread(target=s.startStream, daemon=True).start()
+
+    barrier = threading.Barrier(len(streams))
+
+    def _start_one(s):
+        barrier.wait()
+        https_requests.put(s.host, "/WebXi/Applications/SLM?Action=StartPause")
+
+    start_threads = [threading.Thread(target=_start_one, args=(s,)) for s in streams]
+    for t in start_threads:
+        t.start()
+    for t in start_threads:
+        t.join()
+
+
+def stop_all(streams):
+    """Tear down every stream: stop all measurements at (nearly) the same instant
+    via a barrier (mirroring start_all_synced), then delete each device-side stream resource."""
+    barrier = threading.Barrier(len(streams))
+
+    def _stop_one(s):
+        barrier.wait()
+        meas.stop_measurement(s.host)
+
+    stop_threads = [threading.Thread(target=_stop_one, args=(s,)) for s in streams]
+    for t in stop_threads:
+        t.start()
+    for t in stop_threads:
+        t.join()
+
+    for s in streams:
+        stream.delete_stream(s.host, s.streamName)
+
 
 class WebXiStreamHandler(stream.StreamHandler):
     """Configurable WebXi stream handler.
@@ -138,7 +177,7 @@ class WebXiStreamHandler(stream.StreamHandler):
 
     def __init__(self, host, ip, sequenceID=None, sequenceNames=None,
                  streamName="Stream", cpb=False, multi=False, flac=False, mp3=False, fast_logging=False,
-                 time=False, screen_record=False, leq_window_sec=10, windowSize=None, fast_logging_interval=None,
+                 time=False, screen_record=False, multi_device=False,leq_window_sec=10, windowSize=None, fast_logging_interval=None,
                  saving=None, saving_path=None):
         super().__init__(streamName)
         self.host = host
@@ -149,6 +188,7 @@ class WebXiStreamHandler(stream.StreamHandler):
         self.multi = multi
         self.flac = flac
         self.mp3 = mp3
+        self.multi_device = multi_device
         self.fast_logging = fast_logging
         self.time = time
         self.screen_record = screen_record
@@ -231,6 +271,11 @@ class WebXiStreamHandler(stream.StreamHandler):
             self.leq_mov = MovingLeq(self.leq_window_sec, storedata=True)
 
         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.multi_device:
+            return
+
+            return
         if self.time:
             utc_offset_seconds = _get_slm_utc_offset_seconds(self.host)
             self._time_stamps = _TimeStamps(self.windowSize or (self.leq_window_sec * 10 + 1), utc_offset_seconds)
@@ -287,7 +332,7 @@ class WebXiStreamHandler(stream.StreamHandler):
             value = package.content.sequence_blocks[0].values
             self.CPB_values = np.array(stream.data_type_conv(self.sequence["DataType"], value, self.sequence["VectorLength"])) / 100
             if self.data_handler:
-                self.data_handler.handle(timestamp=self._time_prefix(), values=self.CPB_values)
+                self.data_handler.handle(timestamp=self._time_prefix(), value=self.CPB_values)
 
     def calcFreqBands(self):
         """Only meaningful when cpb=True."""

slm_open_api_package-0.2.4/src/slm_api/helpers/websocket_handler.py

@@ -0,0 +1,12 @@
+import websockets
+import asyncio
+from . import https_requests
+
+async def next_async_websocket(uri, packetHandler):
+    ssl_context = https_requests.build_ssl_context() if uri.startswith("wss://") else None
+    async with websockets.connect(uri, ping_interval=None, ssl=ssl_context) as websocket:
+        async for message in websocket:
+            try:
+                packetHandler(message)
+            except Exception as exc:
+                print(f"Error handling message from {uri}: {exc!r}")

{slm_open_api_package-0.2.2 → slm_open_api_package-0.2.4}/src/slm_api/helpers/webxi_helper_functions.py

@@ -7,13 +7,17 @@ from slm_api.helpers.https_requests import get, put
 
 # Functions to turn on/off BB freq weights and sequences. These are used in the examples to make sure the wanted sequences are enabled on the SLM.
 def turn_off_bb_freq_weight(host):
+    
     for endpoint in (
         "/webxi/Applications/SLM/Setup/BBFreqWeightB",
         "/webxi/Applications/SLM/Setup/BBFreqWeightZ",
         "/webxi/Applications/SLM/Setup/BBFreqWeightA",
         "/webxi/Applications/SLM/Setup/BBFreqWeightC",
     ):
-        put(host , endpoint, json=False, timeout=10)
+        try:
+            put(host , endpoint, json=False, timeout=10)
+        except requests.exceptions.HTTPError as exc:
+            print(f"Skipping {endpoint}: {exc}")
 
 def turn_on_bb_freq_weight(host, weights, fast=False):
     weights = [weights] if isinstance(weights, str) else weights

slm_open_api_package-0.2.4/src/slm_api/multi_device_flac.py

@@ -0,0 +1,155 @@
+"""
+Multi-device FLAC/mp3 audio streaming
+--------------------------------------
+Streams FLAC- (or mp3-)encoded audio from several devices at once and plots
+each device's waveform + spectrum, same as flac_example.py/mp3_example.py's
+figureHandler, stacked in one window (one time/freq row pair per device).
+
+Note: WebXiStreamHandler._msg_func_audio also appends decoded samples to the
+module-level `DataBuffer` (helpers/buffer.py), which is a single shared buffer.
+With multiple devices, samples from all of them interleave in that shared
+buffer, so it isn't usable for per-device plotting here - each device instead
+gets its own `buffer` instance (BufferDataHandler below).
+"""
+
+import sys
+import time
+
+import numpy as np
+import pyqtgraph as pg
+from PyQt5 import QtWidgets
+
+from slm_api.helpers.buffer import buffer as Buffer
+from slm_api.helpers.fft import dBfft
+from slm_api.helpers.stream_handlers import WebXiStreamHandler, start_all_synced, stop_all
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+
+USE_MP3 = True  # False = FLAC (SequenceIdEnums.FLACSignal), True = mp3 (SequenceIdEnums.MP3Signal)
+SEQUENCE_ID = SequenceIdEnums.MP3Signal.value if USE_MP3 else SequenceIdEnums.FLACSignal.value
+SAMPLE_RATE = 32e3 if USE_MP3 else 2 ** 16  # matches mp3_example.py / flac_example.py dBfft() calls
+
+CHUNK_TO_SHOW = 2 ** 15
+
+
+class BufferDataHandler(DataHandler):
+    """Per-device handler: appends decoded samples into its own buffer instead
+    of the shared DataBuffer singleton, so devices don't mix samples together."""
+
+    def __init__(self):
+        self.buffer = Buffer(2 ** 16)
+
+    def handle(self, samples, **data):
+        self.buffer.append(samples)
+
+
+class MultiDeviceFigureHandler:
+    """One time-domain + spectrum plot pair per device, stacked in one window."""
+
+    def __init__(self, labels_and_handlers):
+        self.labels_and_handlers = labels_and_handlers
+        self.fft_hamming = np.hamming(CHUNK_TO_SHOW)
+        self.axis = np.flip(np.arange(CHUNK_TO_SHOW) * -1 / CHUNK_TO_SHOW)
+        self.old = [0] * len(labels_and_handlers)
+        self.oldold = [0] * len(labels_and_handlers)
+        self.i = 0
+
+        self.app = QtWidgets.QApplication(sys.argv)
+        self.win = pg.GraphicsLayoutWidget(title="Multi-device streaming")
+        self.win.setBackground('w')
+        self.win.resize(1000, 300 * len(labels_and_handlers))
+        label_style = {'color': '#000', 'font-size': '13pt'}
+
+        self.plots_time, self.plots_freq, self.curves_time, self.curves_freq = [], [], [], []
+        freq = np.arange(CHUNK_TO_SHOW // 2 + 1) / (float(CHUNK_TO_SHOW) / SAMPLE_RATE)
+        for label, _ in labels_and_handlers:
+            plot_time = self.win.addPlot(title=label)
+            curve_time = plot_time.plot(self.axis, np.zeros(CHUNK_TO_SHOW))
+            curve_time.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+            plot_time.showGrid(x=True, y=True)
+            plot_time.setXRange(np.min(self.axis), np.max(self.axis))
+            plot_time.setYRange(-2, 2)
+            plot_time.getAxis('left').setLabel('Pressure', units='Pa', **label_style)
+            plot_time.getAxis('bottom').setLabel('Time', units='s', **label_style)
+            self.win.nextRow()
+
+            plot_freq = self.win.addPlot()
+            curve_freq = plot_freq.plot(freq, np.zeros(len(freq)))
+            curve_freq.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+            plot_freq.setXRange(0, np.max(freq))
+            plot_freq.setYRange(-20, 130)
+            plot_freq.getAxis('bottom').enableAutoSIPrefix(enable=False)
+            plot_freq.setLogMode(x=True, y=False)
+            plot_freq.showGrid(x=True, y=True)
+            plot_freq.getAxis('left').setLabel('dB SPL re 20 µPa', **label_style)
+            plot_freq.getAxis('bottom').setLabel('Frequency', units='Hz', **label_style)
+            self.win.nextRow()
+
+            self.plots_time.append(plot_time)
+            self.plots_freq.append(plot_freq)
+            self.curves_time.append(curve_time)
+            self.curves_freq.append(curve_freq)
+
+        self.win.show()
+        self.timer = pg.QtCore.QTimer()
+        self.timer.timeout.connect(self.update)
+        self.timer.start(int(0.1 * 1000))
+
+    def update(self):
+        # Recomputing dBfft (32768-sample FFT) for every device on every 100ms
+        # tick can hold the GIL long enough to stall the decode threads (seen as
+        # audio decode's own "TotalTime" warnings), so only do it every 5th tick.
+        if self.i % 5 != 0:
+            self.i += 1
+            return
+        for idx, (label, handler) in enumerate(self.labels_and_handlers):
+            signal = handler.buffer.getPart(CHUNK_TO_SHOW)
+            x = np.linspace(np.min(self.axis), np.max(self.axis), len(signal))
+            freq, s_dbfs = dBfft(signal, SAMPLE_RATE, self.fft_hamming, ref=20e-6)  # Reference = 20µPa
+            avg = s_dbfs / 3 + self.old[idx] / 3 + self.oldold[idx] / 3
+            self.curves_time[idx].setData(x, signal)
+            self.curves_freq[idx].setData(freq, avg)
+            self.oldold[idx] = self.old[idx]
+            self.old[idx] = s_dbfs
+            min_Pa = np.round(min(signal), 2)
+            max_Pa = np.round(max(signal), 2)
+            fft_peak = np.round(max(avg), 2)
+            fft_min = np.round(min(avg), 2)
+            peak_freq = freq[np.argmax(avg)]
+            if min_Pa != max_Pa:
+                self.plots_time[idx].setYRange(min_Pa * 1.2, max_Pa * 1.2)
+            if not np.isinf(fft_peak):
+                self.plots_freq[idx].setYRange(fft_min, fft_peak * 1.2)
+            print(f"{label}  Min: {min_Pa} Pa, Max: {max_Pa} Pa, Peak: {fft_peak} dB SPL, Peak freq: {peak_freq} Hz")
+        self.i += 1
+
+    def run(self):
+        QtWidgets.QApplication.instance().exec_()
+
+
+if __name__ == "__main__":
+    devices = [
+        ("http://192.168.1.183", "192.168.1.183"),
+        ("http://192.168.1.216", "192.168.1.216"),
+        ("http://192.168.1.191", "192.168.1.191"),
+
+    ]
+
+    streams = [
+        WebXiStreamHandler(
+            host=dev_host, ip=dev_ip, sequenceID=SEQUENCE_ID,
+            streamName=f"Stream_{dev_ip}", multi_device=True,
+            mp3=USE_MP3, flac=not USE_MP3,
+        )
+        for dev_host, dev_ip in devices
+    ]
+    handlers = [BufferDataHandler() for _ in streams]
+    for s, h in zip(streams, handlers):
+        s.setDataHandler(h)
+
+    fig = MultiDeviceFigureHandler([(s.ip, h) for s, h in zip(streams, handlers)])
+    fig.app.aboutToQuit.connect(lambda: stop_all(streams))
+
+    time.sleep(1)
+    start_all_synced(streams)
+    fig.run()

slm_open_api_package-0.2.4/src/slm_api/multi_instrument_example.py

@@ -0,0 +1,75 @@
+"""
+18. Stream FastLAF (Sequence 115)
+-----------------------------------
+Streams the FastLAF (LAeq) broadband Leq value from sequence 115
+and pretty-prints each received value to the terminal.
+
+Sequence 115 properties:
+  Name:            FastLAF
+  LocalName:       LAeq
+  FunctionType:    BroadbandLeq
+  DataType:        Int16
+  Scale:           0.01
+  Weighting:       A
+  AveragingMode:   Linear
+  Unit:            dB re 20uPa
+"""
+
+
+
+import time
+import threading
+from slm_api.helpers.stream_handlers import WebXiStreamHandler, start_all_synced, stop_all
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+
+
+FAST_LOGGING_INTERVAL_MS = FastLogInterval.interval_1000ms.value
+SEQUENCE_ID = SequenceIdEnums.LAeq.value
+SEQUENCE_NAME = SequenceIdEnums.LAeq.name
+
+
+class PrintDataHandler(DataHandler):
+    def __init__(self, label):
+        self.label = label
+
+    def handle(self, value, **data):
+        print(f"{self.label}  {SEQUENCE_NAME}: {value}")
+
+
+if __name__ == "__main__":
+    devices = [
+        ("http://192.168.1.183", "192.168.1.183"),
+        ("http://192.168.1.216", "192.168.1.216"),
+        ("http://192.168.1.191", "192.168.1.191")
+    ]
+
+    # for dev_host, dev_ip in devices:
+    #     # webxi_helper.turn_off_CPB_freq_weight(dev_host)
+    #     # webxi_helper.turn_on_CPB_freq_weight(dev_host, "A")
+    #     # webxi_helper.turn_on_cpb_leq(dev_host, SEQUENCE_NAME)
+    #     webxi_helper.turn_off_bb_freq_weight(dev_host)
+    #     webxi_helper.turn_on_bb_freq_weight(dev_host, "A")
+    #     webxi_helper.turn_on_bb_leq(dev_host, 'LAF')
+
+    streams = [
+        WebXiStreamHandler(
+            host=dev_host, ip=dev_ip, sequenceID=SEQUENCE_ID,
+            streamName=f"Stream_{dev_ip}", multi_device=True
+        )
+        for dev_host, dev_ip in devices
+    ]
+    for s in streams:
+        s.setDataHandler(PrintDataHandler(s.ip))
+
+    time.sleep(1)
+    start_all_synced(streams)
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        stop_all(streams)
+        print("\nStreams stopped by user.")

slm_open_api_package-0.2.2/src/slm_api/helpers/websocket_handler.py

@@ -1,8 +0,0 @@
-import websockets
-import asyncio
-
-async def next_async_websocket(uri, packetHandler):
-    """Function which awaits response from the websocket and calls the packetHandler"""
-    async with websockets.connect(uri, ping_interval = None) as websocket:
-        async for message in websocket:
-            packetHandler(message)