slm_open_api_package 0.2.10__py3-none-any.whl

slm_api/webxi/webxi_stream.py

@@ -0,0 +1,450 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from packaging.version import Version as parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class WebxiStream(KaitaiStruct):
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._read()
+
+    def _read(self):
+        self.header = self._root.Header(self._io, self, self._root)
+        _on = self.header.message_type
+        if _on == self._root.Header.EMessageType.e_state:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.State(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_sequence_data:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.SequenceData(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_debug:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Debug(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_sync:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Sync(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_aux_sequence_data:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.AuxSequenceData(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_package:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Package(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_data_quality:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.DataQuality(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_node:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Node(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_status:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Status(_io__raw_content, self, self._root)
+        elif _on == self._root.Header.EMessageType.e_trigger:
+            self._raw_content = self._io.read_bytes(self.header.content_length)
+            _io__raw_content = KaitaiStream(BytesIO(self._raw_content))
+            self.content = self._root.Trigger(_io__raw_content, self, self._root)
+        else:
+            self.content = self._io.read_bytes(self.header.content_length)
+
+    class NodeChange(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.flags = self._io.read_u2le()
+            self.reserved = self._io.read_u2le()
+            self.path = self._root.String(self._io, self, self._root)
+            self.json = self._root.String(self._io, self, self._root)
+
+
+    class Package(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_packages = self._io.read_u2le()
+            self.reserved = self._io.read_u2le()
+            self.packages = [None] * (self.number_of_packages)
+            for i in range(self.number_of_packages):
+                self.packages[i] = self._root.PackageBlock(self._io, self, self._root)
+
+
+
+    class AuxValue(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.relative_time = self._io.read_u4le()
+            self.values = self._root.Value(self._io, self, self._root)
+
+
+    class FlacSequenceDataBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_sequences = self._io.read_u2le()
+            self.sequence_ids = [None] * (self.number_of_sequences)
+            for i in range(self.number_of_sequences):
+                self.sequence_ids[i] = self._io.read_u2le()
+
+            self.frame_length = self._io.read_u4le()
+            self.frame = [None] * (self.frame_length)
+            for i in range(self.frame_length):
+                self.frame[i] = self._io.read_u1()
+
+
+
+    class AuxSequenceDataBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.sequence_id = self._io.read_u2le()
+            self.number_of_values = self._io.read_u2le()
+            self.values = [None] * (self.number_of_values)
+            for i in range(self.number_of_values):
+                self.values[i] = self._root.AuxValue(self._io, self, self._root)
+
+
+
+    class State(KaitaiStruct):
+
+        class EState(Enum):
+            initial = 0
+            error = 1
+            deactivated = 2
+            activated = 3
+            running = 4
+            ramping_down = 5
+            pause = 6
+            stopping = 7
+            result_measured = 8
+            result_loaded = 9
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.state = KaitaiStream.resolve_enum(self._root.State.EState, self._io.read_u2le())
+            self.reserved = self._io.read_u2le()
+            self.application_name = self._root.String(self._io, self, self._root)
+
+
+    class DataQuality(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_qualities = self._io.read_u2le()
+            self.reserved = self._io.read_u2le()
+            self.qualities = [None] * (self.number_of_qualities)
+            for i in range(self.number_of_qualities):
+                self.qualities[i] = self._root.QualityBlock(self._io, self, self._root)
+
+
+
+    class AuxSequenceData(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_sequences = self._io.read_u2le()
+            self.reserved = self._io.read_u2le()
+            self.aux_sequence_data_blocks = [None] * (self.number_of_sequences)
+            for i in range(self.number_of_sequences):
+                self.aux_sequence_data_blocks[i] = self._root.AuxSequenceDataBlock(self._io, self, self._root)
+
+
+
+    class SequenceData(KaitaiStruct):
+
+        class EMessageFormat(Enum):
+            raw = 0
+            mp3 = 1
+            flac = 2
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_blocks = self._io.read_u2le()
+            self.message_format = KaitaiStream.resolve_enum(self._root.SequenceData.EMessageFormat, self._io.read_u1())
+            self.reserved = self._io.read_u1()
+            self.sequence_blocks = [None] * (self.number_of_blocks)
+            for i in range(self.number_of_blocks):
+                _on = self.message_format
+                if _on == self._root.SequenceData.EMessageFormat.raw:
+                    self.sequence_blocks[i] = self._root.RawSequenceDataBlock(self._io, self, self._root)
+                elif _on == self._root.SequenceData.EMessageFormat.mp3:
+                    self.sequence_blocks[i] = self._root.Mp3SequenceDataBlock(self._io, self, self._root)
+                elif _on == self._root.SequenceData.EMessageFormat.flac:
+                    self.sequence_blocks[i] = self._root.FlacSequenceDataBlock(self._io, self, self._root)
+
+
+
+    class String(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.count = self._io.read_u4le()
+            self.content = (self._io.read_bytes(self.count)).decode(u"UTF-8")
+
+
+    class PackageBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.package_id = self._io.read_u2le()
+            self.data_length = self._io.read_u2le()
+            self.data = [None] * (self.data_length)
+            for i in range(self.data_length):
+                self.data[i] = self._io.read_u1()
+
+
+
+    class Debug(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.message = self._root.String(self._io, self, self._root)
+
+
+    class TimeFamily(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.k = self._io.read_u1()
+            self.l = self._io.read_u1()
+            self.m = self._io.read_u1()
+            self.n = self._io.read_u1()
+
+
+    class Status(KaitaiStruct):
+
+        class EChannelType(Enum):
+            todo = 0
+
+        class EStatusType(Enum):
+            todo1 = 0
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.channel_type = KaitaiStream.resolve_enum(self._root.Status.EChannelType, self._io.read_u2le())
+            self.channel_id = self._io.read_u2le()
+            self.status_type = KaitaiStream.resolve_enum(self._root.Status.EStatusType, self._io.read_u2le())
+            self.reserved = self._io.read_u2le()
+            self.value1 = self._io.read_s4le()
+            self.value2 = self._io.read_s4le()
+            self.str = self._root.String(self._io, self, self._root)
+
+
+    class QualityBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.quality_id = self._io.read_u2le()
+            self.validity = self._io.read_u2le()
+            self.reserved = self._io.read_u4le()
+
+
+    class Sync(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.sync_id = self._io.read_u4le()
+
+
+    class Header(KaitaiStruct):
+
+        class EMessageType(Enum):
+            e_sequence_data = 1
+            e_data_quality = 2
+            e_state = 3
+            e_status = 4
+            e_trigger = 5
+            e_node = 6
+            e_sync = 7
+            e_debug = 9
+            e_package = 10
+            e_aux_sequence_data = 11
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.magic = self._io.read_bytes(2)
+            if not self.magic == b"\x42\x4B":
+                raise kaitaistruct.ValidationNotEqualError(b"\x42\x4B", self.magic, self._io, u"/types/header/seq/0")
+            self.header_length = self._io.read_u2le()
+            self.message_type = KaitaiStream.resolve_enum(self._root.Header.EMessageType, self._io.read_u2le())
+            self.content_version = self._io.read_u2le()
+            self.reserved2 = self._io.read_u4le()
+            self.time = self._io.read_u8le()
+            self.content_length = self._io.read_u4le()
+
+
+    class Node(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.n_changes = self._io.read_u2le()
+            self.reserved = self._io.read_u2le()
+            self.changes = [None] * (self.n_changes)
+            for i in range(self.n_changes):
+                self.changes[i] = self._root.NodeChange(self._io, self, self._root)
+
+
+
+    class Value(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.value1 = self._io.read_u1()
+            self.value2 = self._io.read_u1()
+            self.value3 = self._io.read_s1()
+            self.value4 = self._io.read_s1()
+
+        @property
+        def calc_value(self):
+            if hasattr(self, '_m_calc_value'):
+                return self._m_calc_value if hasattr(self, '_m_calc_value') else None
+
+            self._m_calc_value = ((self.value1 + (self.value2 << 8)) + (self.value3 << 16))
+            return self._m_calc_value if hasattr(self, '_m_calc_value') else None
+
+
+    class Mp3SequenceDataBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.number_of_sequences = self._io.read_u2le()
+            self.sequence_ids = [None] * (self.number_of_sequences)
+            for i in range(self.number_of_sequences):
+                self.sequence_ids[i] = self._io.read_u2le()
+
+            self.frame_length = self._io.read_u4le()
+            self.frame = [None] * (self.frame_length)
+            for i in range(self.frame_length):
+                self.frame[i] = self._io.read_u1()
+
+
+
+    class RawSequenceDataBlock(KaitaiStruct):
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.sequence_id = self._io.read_u2le()
+            self.value_length = self._io.read_u4le()
+            self.values = [None] * (self.value_length)
+            for i in range(self.value_length):
+                self.values[i] = self._io.read_u1()
+
+
+
+    class Trigger(KaitaiStruct):
+
+        class ETriggerType(Enum):
+            unkown = 0
+            level = 1
+            start = 2
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._read()
+
+        def _read(self):
+            self.sequence_id = self._io.read_u2le()
+            self.trigger_type = KaitaiStream.resolve_enum(self._root.Trigger.ETriggerType, self._io.read_u2le())
+
+
+

slm_open_api_package-0.2.10.dist-info/METADATA

@@ -0,0 +1,206 @@
+Metadata-Version: 2.3
+Name: slm_open_api_package
+Version: 0.2.10
+Summary: Add your description here
+Author: Sofus Vingaard
+Author-email: Sofus Vingaard <sofus.krebsvingaard@hbkworld.com>
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: websockets
+Requires-Dist: kaitaistruct
+Requires-Dist: packaging
+Requires-Dist: pyqtgraph
+Requires-Dist: pyqt5
+Requires-Dist: pyqt5-qt5<5.15.11
+Requires-Dist: miniaudio
+Requires-Dist: matplotlib>=3.11.1
+Requires-Dist: cryptography>=50.0.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# SLM Open API Package
+
+Python helpers for streaming measurements and audio from an HBK sound level meter (SLM) through WebXi.
+
+This PyPI package is made for the [Open Interface for Sound Level Meter](https://github.com/hbkworld/Open-Interface-for-Sound-Level-Meter) repository. Refer to that repository for more detailed usage information and additional examples.
+
+
+
+## Install
+
+```powershell
+pip install slm_open_api_package
+```
+
+Or add it to an `uv` project:
+
+```powershell
+uv add slm_open_api_package
+```
+
+The package requires Python 3.12 or newer and a network connection to a compatible SLM.
+
+## Connect To A Device
+
+Give every stream one `host`, either an IP address or host name:
+
+```python
+host = "192.168.1.183"
+```
+
+The bundled examples use `set_host()` to read a host from a local `slm_ip` file. If the file is missing, it prompts once and creates it:
+
+```python
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+
+host = webxi_helper.set_host(__file__)
+```
+
+## Basic Leq Stream
+
+`WebXiStreamHandler` is the main API. `mode="leq"` is the default and streams one sequence selected by `sequenceID`.
+
+```python
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+
+streamer = WebXiStreamHandler(
+	host="192.168.1.183",
+	sequenceID=SequenceIdEnums.LAeq.value,
+	mode="leq",
+	saving="csv",
+	saving_path="saved_data/laeq",
+)
+
+try:
+	streamer.startStream()
+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.
+
+## Multiple Sequences
+
+Based on [example_multi.py](src/slm_api/example_multi.py), use `mode="multi"` for several enabled broadband sequences in a single stream:
+
+```python
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+
+
+class PrintHandler(DataHandler):
+	def handle(self, *, host, name, value, **data):
+		print(f"{host} {name}: {value}")
+
+
+streamer = WebXiStreamHandler(
+	host="192.168.1.183",
+	sequenceNames=["LAeq", "LCeq", "LAF"],
+	mode="multi",
+	saving="json",
+	saving_path="saved_data/broadband",
+)
+streamer.setDataHandler(PrintHandler())
+
+try:
+	streamer.startStream()
+except KeyboardInterrupt:
+	streamer.stopStream()
+```
+
+Enable the requested sequences and frequency weightings on the SLM before starting the stream. Each `DataHandler.handle()` call receives the source `host`, `name`, and `value`. The `saving=` handler continues saving when a custom handler is attached.
+
+## Fast Logging
+
+Based on [fast_log_example.py](src/slm_api/fast_log_example.py), use `mode="fast_logging"` for fast broadband samples:
+
+```python
+from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+
+streamer = WebXiStreamHandler(
+	host="192.168.1.183",
+	sequenceID=SequenceIdEnums.FastLAF.value,
+	mode="fast_logging",
+	fast_logging_interval=FastLogInterval.interval_1000ms.value,
+	saving="csv",
+	saving_path="saved_data/fast_laf",
+)
+
+try:
+	streamer.startStream()
+except KeyboardInterrupt:
+	streamer.stopStream()
+```
+
+## Audio
+
+Use the MP3 or FLAC examples for decoded audio samples:
+
+```python
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+
+streamer = WebXiStreamHandler(
+	host="192.168.1.183",
+	sequenceID=SequenceIdEnums.MP3Signal.value,
+	mode="mp3",
+)
+```
+
+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.
+
+## 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:
+
+```python
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.stream_handlers import WebXiStreamHandler, start_all_synced, stop_all
+
+hosts = ["192.168.1.183", "192.168.1.216"]
+streams = [
+	WebXiStreamHandler(
+		host=host,
+		sequenceID=SequenceIdEnums.MP3Signal.value,
+		mode="mp3",
+		streamName=f"Audio_{host}",
+		multi_device=True,
+		saving="csv",
+		saving_path=f"saved_data/{host}",
+	)
+	for host in hosts
+]
+
+start_all_synced(streams)
+
+try:
+    while True:
+        time.sleep(1)
+except KeyboardInterrupt:
+    stop_all(streams)
+```
+
+`stop_all()` synchronizes the device measurement stops, flushes saving handlers, and removes each device stream.
+
+## Modes
+
+| Mode | Use |
+| --- | --- |
+| `"leq"` | One broadband sequence; this is the default. |
+| `"multi"` | Several named broadband sequences. |
+| `"cpb"` | Constant-percentage-band data. |
+| `"fast_logging"` | Fast broadband samples. |
+| `"flac"` / `"mp3"` | Decoded audio samples. |
+| `"screen_record"` | Latest SLM screen image in `streamer.image_bytes`. |
+
+Legacy flags such as `mp3=True` remain supported, but `mode=` is preferred. Only select one mode per stream.
+```
+
+## Troubleshooting
+
+- **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.

slm_open_api_package-0.2.10.dist-info/RECORD

@@ -0,0 +1,37 @@
+slm_api/CPB_example.py,sha256=dFioae4gS2NWm5Wod87dCglbmO26n7WBvh0mklK_H8Q,2652
+slm_api/__init__.py,sha256=Gl2zixNPabXv08KWFtImHPCBA3YhqkqHfk3V4QF2E84,136
+slm_api/enums/fast_log_intervals_enum.py,sha256=o8JVtxBOiNYhGe9wRtrtpiQZMEm2jjfFQu9ehZWTSn8,398
+slm_api/enums/sequence_id_enum.py,sha256=zFFiS0RzDQPSF4d6mg0iYfaRyyDmKe9YHnKGo7l03_k,6305
+slm_api/example_multi.py,sha256=Tlf7opQBF1wvmaYR3WhKRA_IPkWhSiY3PtP_khTyJZw,2962
+slm_api/fast_log_example.py,sha256=p2mwo8S6NLUazBEA2NDhIUS5Yd0d9CYm_jmyGIDe0pQ,6544
+slm_api/flac_example.py,sha256=eJwxVNzS1D8xAVWibW9-Szu9D9KCVfNYBj6-d4TfCX0,6900
+slm_api/helpers/FigureHandler.py,sha256=WCK7YxSDd1p3-1M2xhmiEh2Qu1teN0-NYIiikcLneZw,2251
+slm_api/helpers/Leq.py,sha256=2ZDTP9pkIZHcZeEDqQtU-nL1dHgvYsbVxR6Sonnw5ck,4021
+slm_api/helpers/__init__.py,sha256=hB7KKDrb-Xuzvjc7WeZRPEyCTlRfizOz3VBJ0qTj1r4,147
+slm_api/helpers/buffer.py,sha256=k1lCKkCKT8mhHCzs28LTU_JaRRo1X7eo9jg5RduYPCk,670
+slm_api/helpers/data_handler.py,sha256=mmKh4dCirCR32yJE12PntzBeNQpHijvV-oPhMrpHlgg,2984
+slm_api/helpers/fft.py,sha256=p31aiPqnvsFhXwncB9Ixuz7DQEJBtNnm_obQzL8sYNI,1146
+slm_api/helpers/flac_stream_2_samples.py,sha256=--WXFeQLnMZ4EMmYMxV9uogn98N98RYRRbQsZwQjA-s,1886
+slm_api/helpers/https_requests.py,sha256=fL7U-_c4r6Ho1LTBkbkVoUy5pvwiNGTBW6WBOJjqxr4,2701
+slm_api/helpers/measurment_handler.py,sha256=BzoRnd2REWPwG7KKrK9zyWdyADLNWoDRih3almUv7vg,920
+slm_api/helpers/sequence_handler.py,sha256=a6jIgSZwXJaaR5QI1PSX-S7Lsr77pBNF-Q-3hGfVw1Y,1596
+slm_api/helpers/stream_handler.py,sha256=dilwA5Y81G1R2yEleFLCveQJqor4e3QYJ-nNyBzQvMg,4283
+slm_api/helpers/stream_handlers.py,sha256=N1Q7g8ihhrjtGT5sNfKXo9p48kiZpVh_oxSMtvY-NU0,20853
+slm_api/helpers/tmpFileStateMachine.py,sha256=mDBL7PjPfEDoo8Tj-7ds4sx4W6-lavsYGLOHi6n5F-E,3431
+slm_api/helpers/websocket_handler.py,sha256=QQtoMtSE3lojIQ2WpNb6dl5u1iKVGTbynu_oqaX4uVE,497
+slm_api/helpers/webxi_helper_functions.py,sha256=Kc8YECW4wL63JW2DDw1iUY4k_DfYa9ih_TnaQYQ5_K4,3651
+slm_api/helpers/webxi_root.pem,sha256=Vo-uzcN0ZomwWJWp1xaLzSA8mDqlxUAp_c1P31820Jc,1456
+slm_api/mp3_example.py,sha256=Hh8m9emaIOVStgCqG-Vj3KA8mWqn39bfE-IeW3buMXg,6810
+slm_api/multi_device_flac.py,sha256=eiZ0NYhuMbAHfVhf--qhyRU33v8YwIyc5nn_CPGiF0Q,3767
+slm_api/multi_instrument_example.py,sha256=Rg21SSrQ5Ly6ze66cT21jpH-8JOXvdlkBZrxXwOrWLI,1997
+slm_api/screen_record_example.py,sha256=hgeWpEYI2YcsHt8IvB3FOzC19S_5h_sq8jCvSo4BeeA,2183
+slm_api/webxi/README.md,sha256=tlACB4cUWebZTrzmzzGlRwwW5hCpO4tSv6tOasx7uxc,1345
+slm_api/webxi/__init__.py,sha256=iT4laRwuAPXHLZNrYBvwrBHEoIwNyQ0fG6CbQYcVCEY,118
+slm_api/webxi/webxi-header.ksy,sha256=vapyptJbqS8n9c7FiQFbWRv4GuO50KG5_D1a2gJEji8,500
+slm_api/webxi/webxi-stream.ksy,sha256=tve0OzI0ANE-HfPxQLgDHX3-jNwJ3wfwEJKTC38Ne2U,6557
+slm_api/webxi/webxi_header.py,sha256=xHuL3h6OXol2iK6yjXouw9QFvtTQbDn0JpZK-zsadtg,1469
+slm_api/webxi/webxi_stream.py,sha256=CBo6-AqtWvk60WKyFYCkOAI_pDQBd5Kf-0zuPi73iWQ,17310
+slm_open_api_package-0.2.10.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
+slm_open_api_package-0.2.10.dist-info/entry_points.txt,sha256=jJT0x7ixsqHY2_HAjA_WRaBt-4vgmpYS4bzCIIcnIXg,51
+slm_open_api_package-0.2.10.dist-info/METADATA,sha256=D94TMF6PpcvbiOz5-LSEWI7jxVe5QJGgbKrK0lre630,6073
+slm_open_api_package-0.2.10.dist-info/RECORD,,

slm_open_api_package-0.2.10.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.1
+Root-Is-Purelib: true
+Tag: py3-none-any