slm_open_api_package 0.2.11__tar.gz → 0.2.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slm_open_api_package
-Version: 0.2.11
+Version: 0.2.13
 Summary: Add your description here
 Author: Sofus Vingaard
 Author-email: Sofus Vingaard <sofus.krebsvingaard@hbkworld.com>
@@ -161,6 +161,8 @@ except KeyboardInterrupt:
 
 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.
 
+For GUI plots, check the read-only `streamer.audio_ready` property in the plot's timer callback before reading `DataBuffer`. It becomes `True` after the first nonempty decoded audio has been written to the buffer, without requiring a custom `DataHandler` or event. It resets when the streaming session starts, when a stop is requested, and when the session exits. This is a startup gate, not a full-window availability check or a detector for stalled streams. Keep running the GUI event loop while waiting for audio.
+
 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.

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

@@ -139,6 +139,8 @@ except KeyboardInterrupt:
 
 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.
 
+For GUI plots, check the read-only `streamer.audio_ready` property in the plot's timer callback before reading `DataBuffer`. It becomes `True` after the first nonempty decoded audio has been written to the buffer, without requiring a custom `DataHandler` or event. It resets when the streaming session starts, when a stop is requested, and when the session exits. This is a startup gate, not a full-window availability check or a detector for stalled streams. Keep running the GUI event loop while waiting for audio.
+
 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.

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

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

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

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

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

@@ -53,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, **data):
-        print(f"{timestamp} {name} ({local}):  {value:7.2f} {unit}")
+    def handle(self, timestamp, name, local, value, **data):
+        print(f"{timestamp} {name} ({local}):  {value:7.2f}")
 
 
 
@@ -170,7 +170,7 @@ if __name__ == "__main__":
                                       sequenceID = SEQUENCE_ID, 
                                       mode="fast_logging",
                                       fast_logging_interval=FAST_LOGGING_INTERVAL_MS,
-                                      saving="json",
+                                      saving="csv",
                                       saving_path=f"./saved_data/{filename}",
                                       time=True)
         streamer.setDataHandler(PrintDataHandler())

{slm_open_api_package-0.2.11 → slm_open_api_package-0.2.13}/src/slm_api/helpers/data_handler.py

@@ -53,7 +53,10 @@ class _BufferedFileDataHandler(DataHandler):
             if self._closed:
                 return
             if self._write_error is not None:
-                raise RuntimeError("Background snapshot saving failed") from self._write_error
+                raise RuntimeError(
+                    f"Background snapshot saving failed for {self._path}: "
+                    f"{type(self._write_error).__name__}: {self._write_error}"
+                ) from self._write_error
             if "values" in data:
                 data["values"] = [float(v) for v in data["values"]]
             elif "samples" in data:
@@ -110,8 +113,14 @@ class _BufferedFileDataHandler(DataHandler):
             self._closed = True
             self._stop_event.set()
             worker = self._worker
+
         if worker is not None:
-            worker.join()
+            worker.join(timeout=5.0)
+            if worker.is_alive():
+                raise TimeoutError(
+                    f"Snapshot writer did not stop: {self._path}"
+                )
+
         self._flush_snapshot()
 
     def _group_records(self, records=None):

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

@@ -221,6 +221,7 @@ class WebXiStreamHandler(stream.StreamHandler):
         self.time = time
         self.screen_record = self.mode == "screen_record"
         self.image_bytes = None
+        self._audio_ready = threading.Event()
         self.fast_logging_interval = fast_logging_interval
         self.max_input = 15.6263 / np.sqrt(2)
         self._saving_handler = None
@@ -237,6 +238,22 @@ class WebXiStreamHandler(stream.StreamHandler):
             self.tmpFileSM = TmpfileStateMachine()
         self.streamInit()
 
+    @property
+    def audio_ready(self):
+        """Whether nonempty decoded audio has reached the buffer in this session."""
+        return self._audio_ready.is_set()
+
+    async def runStream(self):
+        self._audio_ready.clear()
+        try:
+            await super().runStream()
+        finally:
+            self._audio_ready.clear()
+
+    def request_stop(self):
+        super().request_stop()
+        self._audio_ready.clear()
+
     def setDataHandler(self, data_handler):
         """Attach a DataHandler (see data_handler.py) before calling startStream().
         Without one, WebXiStreamHandler stays silent and does nothing with decoded values.
@@ -263,6 +280,10 @@ class WebXiStreamHandler(stream.StreamHandler):
             raise ValueError(
                 "FLAC and MP3 streams must be saved as WAV, not JSON or CSV."
             )
+        if (self.mp3 or self.flac) and self.time == True:
+                    raise ValueError(
+                        "Time is not supported for flac and mp3."
+                    )
         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)
@@ -360,9 +381,10 @@ class WebXiStreamHandler(stream.StreamHandler):
     def _msg_func_laeq(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
-            leq_value = stream.data_type_conv(self.data_type, value, None) / 100
-            self._handle_data(timestamp=self._time_prefix(), value=leq_value)
+            for block in package.content.sequence_blocks:
+                if block.sequence_id == self.ID:
+                    leq_value = stream.data_type_conv(self.data_type, block.values, None) / 100
+                    self._handle_data(timestamp=self._time_prefix(), name=self.sequence["Name"], value=leq_value)
 
     def _msg_func_cpb(self, message):
         package = webxi_stream.WebxiStream.from_bytes(message)
@@ -420,7 +442,7 @@ class WebXiStreamHandler(stream.StreamHandler):
         unit = self.sequence.get("Unit", "dB re 20uPa")
         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)
+            self._handle_data(timestamp=timestamp, name=name, local=local, value=value)
 
     def _msg_func_screen_record(self, message):
         package = webxi_stream.WebxiStream.from_bytes(message)
@@ -446,7 +468,11 @@ class WebXiStreamHandler(stream.StreamHandler):
                 else:
                     decoded = flac2samples.decode(block, self.calibrationFactor)
                     sample_rate = 2 ** 16
+                if len(decoded) == 0:
+                    continue
                 DataBuffer.append(decoded)
+                if not self._stop_requested:
+                    self._audio_ready.set()
                 self._handle_data(
                     samples=decoded, sample_rate=sample_rate,
                     full_scale_pa=self.calibrationFactor * (2 ** 23 - 1),

slm_open_api_package-0.2.13/src/slm_api/leq.py

@@ -0,0 +1,73 @@
+from slm_api.helpers import webxi_helper_functions as webxi_helper 
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.stream_handler import delete_stream
+from slm_api.helpers.measurment_handler import stop_measurement
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.helpers.https_requests import UseHttps
+from slm_api.helpers import webxi_helper_functions as webxi_helper 
+import datetime
+
+
+
+"""
+set_host creates/reads the `slm_ip` file in the project root. If the IP changes, update or delete `slm_ip` to be prompted again.
+"""
+host = webxi_helper.set_host(__file__)
+
+# By default https is enabled
+# If https is not needed the line below this shows how to disable it for all request calls
+UseHttps(use_https=False)
+
+
+# Used to create file with a custom name and attach the current date and time to it.
+filename = f'name-of-file_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+
+
+# Setup what sequence to stream on
+sequenceId = SequenceIdEnums.LAeq.value
+sequenceName = SequenceIdEnums.LAeq.name
+
+class PrintHandler(DataHandler):
+    """Handler to control what gets printed. It must subclass DataHandler and
+    implement a handle() method. If unsure what data is available, print data
+    itself to see it in the terminal, e.g.:
+        def handle(self, **data):
+            print(data)
+    """
+    def handle(self, value, **data):
+        print(f"{sequenceName}: " + "%.1f" % value)
+
+
+
+
+if __name__ == "__main__":
+    # 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'])
+
+    # sets the sequences to true.
+    webxi_helper.turn_on_bb_leq(host, ['LAeq'])
+
+    streamer = None
+    try:
+        # WebXiStreamHandler takes several parameters to control what data is streamed:
+        #   host            - needed to connect to the device
+        #   sequenceID      - an enum selecting which sequence to listen on
+        #   leq_window_sec  - moving average window length in seconds (default 10 if not specified)
+        #   saving          - "csv", "json", or "pickle"; the format to save data as
+        #   saving_path     - the file path to save the data to
+        #   mode            - selects which mode to use. leq is the default mode.
+        streamer = WebXiStreamHandler(host, sequenceID=sequenceId, mode="leq", time=True, saving="json", saving_path=f"./saved_data/{filename}")
+        # To print incoming data, call setDataHandler() with an instance of your own
+        # DataHandler subclass (see the PrintHandler class above for an example).
+        streamer.setDataHandler(PrintHandler())
+        # Start the stream
+        streamer.startStream()
+    except KeyboardInterrupt:
+        if streamer is not None:
+            # stop measurements, closes the stream and saves the data if saving is enabled.
+            streamer.stopStream()
+        print("User exited the program")