slm_open_api_package 0.2.10__py3-none-any.whl

slm_api/flac_example.py

@@ -0,0 +1,164 @@
+import asyncio
+import requests
+import sys
+import pyqtgraph as pg
+import numpy as np
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+
+# Modules to convert webxi data
+from slm_api.webxi import webxi_stream as webxiStream
+# Help functions located in the helpers folder
+# Read these files to get examples on how to communicate with the SLM
+from slm_api.helpers import stream_handler as stream           # SLM stream functions
+# Start/pause/Stop measurments functions
+from slm_api.helpers import measurment_handler as meas
+# Get sequences, 
+from slm_api.helpers import sequence_handler as seq
+# Stream handler
+from slm_api.helpers import stream_handlers as sh
+
+
+# Async functions to control communication
+from slm_api.helpers import websocket_handler as webSocket
+from timeit import default_timer as timer
+# Buffer and decoder for the flac stream
+from slm_api.helpers.buffer import DataBuffer
+from slm_api.helpers.fft import dBfft
+from slm_api.helpers import flac_stream_2_samples as flac2samples
+import threading
+
+from slm_api.helpers.FigureHandler import FigureHandler
+from slm_api.helpers.data_handler import  MultiDataHandler, CsvDataHandler
+
+
+# FLAC streaming is only available on 2255
+
+host = webxi_helper.set_host(__file__)
+
+sequenceID = 157
+
+
+# class streamHandler:
+#     def __init__(self, startStream=False):
+#         self.i = 0
+#         self.max_input = 15.6263 / np.sqrt(2) 
+#         self.streamInit()
+#         if startStream:
+#             self.startStream()
+    
+#     def decode_flac_stream(self, message):
+#         start = timer()
+#         package = webxiStream.WebxiStream.from_bytes(message)
+#         if package.header.message_type == webxiStream.WebxiStream.Header.EMessageType.e_sequence_data:
+#             # Get the encoded flac block
+#             flac = package.content.sequence_blocks[0]          
+#             # Decode the compressed samples and add it to the data bufffer 
+#             DataBuffer.append(flac2samples.decode(flac, self.calibrationFactor))
+#             end = timer()
+#             total = (end - start)
+#             if 0.0625 < total:
+#                 print(f"TotalTime: {total}")
+#         if not self.StreamRun:
+#             self._resolve()
+
+#     def get_calibration_factor(self):
+#         # Calculate calibration factor from the microphone sensitivity
+#         response = requests.get(f"{host}/WebXi/Applications/SLM/Outputs/Sensitivity")
+#         assert (response.status_code == 200)
+#         mic_sens = float(response.text) # V/Pa
+#         max_lvl = 20 * np.log10((self.max_input / mic_sens) / 20e-6)  # dB SPL re 20 uPa
+#         self.calibrationFactor = (20e-6 * 10 ** (max_lvl / 20)) / (2 ** 23 - 1) * np.sqrt(2)
+
+#     def streamInit(self):
+#         # Enable audio recording analysis quality
+#         response = requests.put(f"{host}/WebXi/Applications/SLM/setup/AudioRecordingAnalysisQuality", json = 1)
+#         assert(response.status_code == 200)
+#         self.get_calibration_factor()
+#         self.ID, self.sequence = seq.get_sequence(host, sequenceID)
+#         # Get URI for stream
+#         self.streamName = "Flac stream"
+#         self.uri = stream.setup_stream(host, self.ID, self.streamName)
+
+#         # Start a measurement. This is needed to obtain data from the device
+#         meas.start_pause_measurement(host, True)
+
+#     def startStream(self):
+#         self.StreamRun = True
+
+#         asyncio.run(self.runStream())
+
+#     async def runStream(self):
+#         self.loop = asyncio.get_running_loop()
+#         self.fut = self.loop.create_future()
+#         # Create lambda function to use for the stream message. In this example is a function
+#         # call used
+#         self.msg_func = lambda msg : self.decode_flac_stream(msg) 
+#         # Initilize and run the websocket to retrive data
+
+#         task = self.loop.create_task(webSocket.next_async_websocket(self.uri, self.msg_func))
+#         await self.fut
+#         task.cancel()
+#         meas.stop_measurement(host)
+
+
+#     def stopStream(self):
+#         self.StreamRun = False
+#         # Resolve the future directly; waiting for the next message may never happen
+#         if hasattr(self, "loop"):
+#             self.loop.call_soon_threadsafe(self._resolve)
+#         stream.delete_stream(host, self.streamName) # Cleaning up and deleting the stream used
+
+#     def _resolve(self):
+#         if not self.fut.done():
+#             self.fut.set_result(True)
+
+
+class figureHandler(FigureHandler):
+
+    def axisConfig(self):
+        self.plotTime.getAxis('left').setStyle(tickFont=pg.QtGui.QFont('Arial', 11))
+        self.plotTime.getAxis('bottom').setStyle(tickFont=pg.QtGui.QFont('Arial', 11))
+        self.plotTime.getAxis('left').setLabel('Pressure', units='Pa', **self.labelStyle)
+        self.plotTime.getAxis('bottom').setLabel('Time', units='s', **self.labelStyle)
+        self.plotFreq.getAxis('left').setStyle(tickFont=pg.QtGui.QFont('Arial', 14))
+        self.plotFreq.getAxis('bottom').setStyle(tickFont=pg.QtGui.QFont('Arial', 14))
+        self.plotFreq.getAxis('left').setLabel('dB SPL re 20 µPa', **self.labelStyle)
+        self.plotFreq.getAxis('bottom').setLabel('Frequency', units='Hz', **self.labelStyle)
+
+    def update(self):
+        signal = DataBuffer.getPart(self.chunkToShow)
+        x = np.linspace(np.min(self.axis), np.max(self.axis), len(signal))
+        freq, s_dbfs = dBfft(signal, 2**16, self.fftHamming, ref=20e-6)  #Reference = 20µPa
+        # Average the fft for a smoother plot
+        avg = s_dbfs / 3 + self.old / 3 + self.oldold / 3
+        self.curveTime.setData(x, signal)
+        self.curveFreq.setData(freq, avg)
+        self.oldold = self.old
+        self.old = s_dbfs
+        if (self.i % 5 == 0):
+            # Autoscale and print min/max values every 0.5 seconds
+            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.plotTime.setYRange(min_Pa * 1.2, max_Pa * 1.2)
+            if (np.isinf(fft_peak) == False):
+                self.plotFreq.setYRange(fft_min, fft_peak * 1.2)
+            print(f"Min: {min_Pa} Pa, Max: {max_Pa} Pa, Peak: {fft_peak} dB SPL, Peak freq: {peak_freq} Hz")
+        self.i += 1
+
+def on_close():
+    streamer.stopStream()
+
+if __name__ == "__main__":
+    # streamer = streamHandler()
+    streamer = sh.WebXiStreamHandler(host, sequenceID=sequenceID, mode="flac", saving="csv", saving_path=r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")
+    # streamer.setDataHandler(MultiDataHandler(PrintDataHandler(), CsvDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")))
+    fig = figureHandler()
+    fig.app.aboutToQuit.connect(on_close)
+    threading.Thread(target=streamer.startStream, daemon=True).start()
+    fig.run()
+
+ 

slm_api/helpers/FigureHandler.py

@@ -0,0 +1,65 @@
+import pyqtgraph as pg
+import sys
+import numpy as np
+from PyQt5 import QtWidgets
+
+from abc import ABC, abstractmethod
+
+class FigureHandler(ABC):
+    def __init__(self):
+        self.i = 0
+        self.chunkToShow = 2 ** 15
+        self.fftSize = self.chunkToShow
+        self.fftHamming = np.hamming(self.fftSize)
+        # Used to store "old" spectrums for fft averaging
+        self.old = 0
+        self.oldold = 0
+
+        self.x = np.linspace(0.0, 10, self.chunkToShow)
+
+        ## Figures
+        self.axis = np.arange(self.chunkToShow)
+        self.axis = np.flip(self.axis * -1 / self.chunkToShow)
+        self.x = np.zeros(len(self.axis))
+        self.app = QtWidgets.QApplication(sys.argv)
+        self.win = pg.GraphicsLayoutWidget(title="Streaming")
+        self.win.setBackground('w')
+        self.win.resize(1000, 600)
+        self.plotTime = self.win.addPlot()
+        self.curveTime = self.plotTime.plot(self.x, self.axis)
+        self.curveTime.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+        self.plotTime.showGrid(x=True, y=True)
+        self.plotTime.setXRange(np.min(self.axis), np.max(self.axis))
+        self.plotTime.setYRange(-2, 2)
+        self.labelStyle = {'color': '#000', 'font-size': '13pt'}
+
+        # Subplot 2 (FFT)
+        # Calculate the frequency vector
+        self.win.nextRow()
+        self.plotFreq = self.win.addPlot()
+        freq = np.arange(self.fftSize//2 + 1) / (float(self.fftSize) / 32e3)
+        self.curveFreq = self.plotFreq.plot(freq, np.arange(len(freq)))
+        self.curveFreq.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+        self.plotFreq.setXRange(0, np.max(freq))
+        self.plotFreq.setYRange(-20, 130)
+        self.plotFreq.getAxis('bottom').enableAutoSIPrefix(enable=False)
+        self.plotFreq.setLogMode(x=True, y=False)
+        self.plotFreq.showGrid(x=True, y=True)
+        self.axisConfig()
+        self.win.show()
+
+        self.timer = pg.QtCore.QTimer()
+        self.timer.timeout.connect(self.update)
+        self.timer.start(int(0.1 * 1000))
+
+    def run(self):
+        QtWidgets.QApplication.instance().exec_()
+
+    @abstractmethod
+    def axisConfig(self):
+        pass
+
+    @abstractmethod
+    def update(self):
+        pass
+

slm_api/helpers/Leq.py

@@ -0,0 +1,87 @@
+import numpy as np
+from . import https_requests
+
+
+def SLM_Setup_LAeq(host):
+    # Enable logging mode
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/ControlLoggingMode", json=1)
+    # Set the device in free runnign mode
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/ControlMeasurementTimeControl", json=0)
+    # Enable A weight frequency broad band weighting, but first clear the other once to be sure
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/BBFreqWeightB", json=False)
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/BBFreqWeightC", json=False)
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/BBFreqWeightZ", json=False)
+    https_requests.put(host, "/webxi/Applications/SLM/Setup/BBFreqWeightA", json=True)
+    # Enable LAeq mode on the device
+    https_requests.put(host, "/webxi/applications/slm/setup/BBLAeq", json=True)
+
+class MovingLeq:
+    """Class to create a moving Leq object.\n
+       Stores a window of Leq logging intervals to be combined into a total Leq\n
+       Calling move(new_interval) on the object will overwrite the oldest value in the       
+       window, recalculate the total Leq and return it."""
+
+    def __init__(self, window_length_sec, storedata=False, windowSize=None):
+        self.window_length = window_length_sec
+        windowSize = self.window_length * 10 + 1 if windowSize is None else windowSize
+
+        # Intialize an empty array, index to track oldest value, and window status
+        self.leq_window = np.zeros(window_length_sec)
+        self.leq_window.fill(np.nan)
+        self.storedata = storedata
+        if self.storedata:
+            self.rawData = LeqData(windowSize) # Used to store the raw data for plotting
+            self.leqData = LeqData(windowSize) # Used to store the Leq data for plotting
+        self.oldest_value_index = 0
+        self.leq_total = 0.0
+        self.window_full = False
+
+    def total_leq(self,window):
+        """ Function to combine several Leq periods into a total Leq, as per:\n
+            10 * log10(10^(L1/10) + 10^(L2/10) + ... 10^(Ln/10) / n)"""
+        sound_Pa = np.sum(np.power(10,window/10)) / len(window)
+        return 10 * np.log10(sound_Pa)
+
+    def move(self, new_value):
+        """Overwrite the oldest value in the array with the new logging interval
+         and update the oldest value index to point to the next oldest value"""
+        self.leq_window[self.oldest_value_index] = new_value
+        self.oldest_value_index += 1
+        
+        # Calculate the total Leq for the moving window and return it.
+        if self.window_full:            
+            self.leq_total = self.total_leq(self.leq_window)
+            self.oldest_value_index = self.oldest_value_index % self.window_length
+            if self.storedata:
+                self.leqData.move(self.leq_total)
+                self.rawData.move(new_value)
+            return self.leq_total
+
+        # If the moving window is not full of measured data, simply calculate total Leq
+        # for the data that is in the window (and ignore the empty part of the array)
+        else:
+            self.leq_total = self.total_leq(self.leq_window[:self.oldest_value_index])
+            self.oldest_value_index = self.oldest_value_index % self.window_length
+            if self.oldest_value_index == self.window_length - 1:
+                self.window_full = True
+            if self.storedata:
+                self.leqData.move(self.leq_total)
+                self.rawData.move(new_value)
+            return self.leq_total
+
+    def getPlotData(self,Leq):
+        if Leq:
+            return self.leqData.getData()
+        else:
+            return self.rawData.getData()
+
+class LeqData:
+    def __init__(self,window_length_sec):
+        self.leq_window = np.zeros(window_length_sec)
+        self.leq_window[:] = np.nan
+
+    def move(self, new_value):
+        self.leq_window = np.insert(self.leq_window[1:], self.leq_window.size-1,new_value)
+
+    def getData(self):
+        return self.leq_window

slm_api/helpers/__init__.py

@@ -0,0 +1,5 @@
+from .stream_handler import * 
+from .measurment_handler import *
+from .sequence_handler import * 
+from .Leq import *
+from .stream_handlers import *

slm_api/helpers/buffer.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+class buffer:
+    def __init__(self, size):
+        self.size = size
+        self.data = np.zeros(self.size)
+
+    def append(self, x):
+        """
+        Adds data in the front of the buffer. Discard the oldest data if buffer is full
+        """
+        self.data =  np.append(self.data[-(self.size - len(x)) :: ] , x)
+
+    def get(self):
+        """
+        Returns the whole buffer
+        """
+        return self.data
+
+    def getPart(self, start = 2**16):
+        """
+        Returns X points of the newest data.
+        """
+        return self.data[-start :: ]
+
+# Create databuffer to store the converted package data
+DataBuffer = buffer(2**16)

slm_api/helpers/data_handler.py

@@ -0,0 +1,94 @@
+"""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()

slm_api/helpers/fft.py

@@ -0,0 +1,38 @@
+import numpy as np 
+
+def dBfft(x, fs, win=None, ref=32768):
+    """
+    Calculate spectrum in dB scale
+    Args:
+        x: input signal
+        fs: sampling frequency
+        win: vector containing window samples (same length as x).
+             If not provided, then rectangular window is used by default.
+        ref: reference value used for dBFS scale. 32768 for int16 and 1 for float
+
+    Returns:
+        freq: frequency vector
+        s_db: spectrum in dB scale
+    """
+    N = len(x)  # Length of input sequence
+
+    if win is None:
+        win = np.ones(1, N)
+    if len(x) != len(win):
+            raise ValueError('Signal and window must be of the same length')
+    x = x * win
+
+    # Calculate real FFT and frequency vector
+    sp = np.fft.rfft(x)
+    freq = np.arange((N / 2) + 1) / (float(N) / fs)
+
+    # Scale the magnitude of FFT by window and factor of 2,
+    # because we are using half of FFT spectrum.
+    s_mag = (np.abs(sp) * np.sqrt(2)) / np.sum(win)
+
+    for i in range(len(s_mag)):
+        if s_mag[i] == 0:
+            s_mag[i] = 1e-10
+    # Convert to dBFS
+    s_dbfs = 20 * np.log10(s_mag/ref)
+    return freq, s_dbfs

slm_api/helpers/flac_stream_2_samples.py

@@ -0,0 +1,64 @@
+import miniaudio
+import numpy as np
+from io import BytesIO  
+
+class BitBuffer:
+	def __init__(self, buf):
+		self.out = buf
+		self.bitbuffer = 0
+		self.bitbufferlen = 0
+
+	def write_int(self, n, val):
+		self.bitbuffer <<= n
+		self.bitbuffer |= val & ((1 << n) - 1)
+		self.bitbufferlen += n
+		while self.bitbufferlen >= 8:
+			self.bitbufferlen -= 8
+			b = (self.bitbuffer >> self.bitbufferlen) & 0xFF
+			self.out.write(bytes((b,)))
+		self.bitbuffer &= (1 << self.bitbufferlen) - 1
+
+	def close(self):
+		self.out.close()
+
+	def __enter__(self):
+		return self
+
+	def __exit__(self, type, value, traceback):
+		return
+
+def add_header(buf, BLOCK_SIZE,  NUMCHANNEL=1, BITDEPTH=24, SAMPLEDATALENGTH=4096, stream_data=0):
+    # Stream
+	buf.write_int(32, 0x664C6143)  # fLaC
+	# METADATA_BLOCK_HEADER
+	buf.write_int(1, 1)
+	buf.write_int(7, 0)
+	buf.write_int(24, 34)
+	# METADATA_BLOCK_STREAMINFO
+	buf.write_int(16, BLOCK_SIZE * 3)   # BLOCK SIZE
+	buf.write_int(16, BLOCK_SIZE * 3)   # BLOCK SIZE
+	buf.write_int(24, 0)                # Frame size
+	buf.write_int(24, 0)                # Frame size
+	buf.write_int(20, 2**16)            # SAMPLERATE
+	buf.write_int(3, NUMCHANNEL - 1)   # NumChannels
+	buf.write_int(5, BITDEPTH - 1)   # BIT DEPTH
+	buf.write_int(36, SAMPLEDATALENGTH)
+	for _ in range(16):
+		buf.write_int(8, 0)
+
+    # End flac header begin of writing data
+	for t in stream_data:
+	    buf.write_int(8, t)
+	    
+def decode(flac_stream, calibrationFactor):
+    # Add the header in front of the encoded samples 
+    fp = BytesIO()
+    with BitBuffer(fp) as buf:
+        add_header(buf, BLOCK_SIZE=flac_stream.frame_length, stream_data = flac_stream.frame)
+        fp.seek(0)
+		# Decode samples  
+        tmp = miniaudio.flac_read_s32(fp.read())
+	# now the samples is scaled to Pa 
+    tmp = (np.array(tmp.samples) >> 8) # 32 bit -> 24 bit 
+    samples = tmp * calibrationFactor
+    return samples 

slm_api/helpers/https_requests.py

@@ -0,0 +1,79 @@
+import ssl
+import requests
+from pathlib import Path
+from requests.adapters import HTTPAdapter
+
+_CERT_FILE = Path(__file__).resolve().parent / "webxi_root.pem"
+
+
+class WebxiAdapter(HTTPAdapter):
+    """Trusts only webxi_root.pem; skips hostname check since device certs are per-serial, not per-IP."""
+
+    def init_poolmanager(self, *args, **kwargs):
+        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
+        kwargs["ssl_context"] = ctx
+        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():
+    _session.mount("https://", WebxiAdapter())
+
+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
+
+    def request(self, method, host, endpoint, **kwargs):
+        """Send a request to the SLM. HTTPS calls are verified against webxi_root.pem via WebxiAdapter."""
+        if UseHttps.use_https:
+            if host.startswith("http://"):
+                stripped_host = host.removeprefix("http://")
+                url = f"https://{stripped_host}{endpoint}"
+            elif host.startswith("https://"):
+                url = host + endpoint
+            else:
+                url = f"https://{host}{endpoint}"
+        else:
+            stripped_host = host.removeprefix("https://").removeprefix("http://")
+            url = f"http://{stripped_host}{endpoint}"
+
+        kwargs.setdefault("timeout", 10)
+        kwargs.setdefault("verify", str(_CERT_FILE))
+
+        # print(f"[https_requests] {method} {url}")
+        response = _session.request(method, url, **kwargs)
+        response.raise_for_status()
+        return response
+
+
+def get(host, endpoint, **kwargs):
+    return UseHttps().request("GET", host, endpoint, **kwargs)
+
+
+def put(host, endpoint, **kwargs):
+    return UseHttps().request("PUT", host, endpoint, **kwargs)
+
+
+def post(host, endpoint, **kwargs):
+    return UseHttps().request("POST", host, endpoint, **kwargs)
+
+
+def delete(host, endpoint, **kwargs):
+    return UseHttps().request("DELETE", host, endpoint, **kwargs)

slm_api/helpers/measurment_handler.py

@@ -0,0 +1,20 @@
+from . import https_requests
+
+def start_pause_measurement(hostID,start):
+    """This function starts or pause a measurement. 
+    If trying to start a measurement and the device is already running 
+    will this function do nothing, same for pause."""
+    response = https_requests.get(hostID, "/webxi/Applications/SLM/State")
+    print(response.json())
+    if start and response.json() != "Running":
+        response = https_requests.put(hostID, "/WebXi/Applications/SLM?Action=StartPause")
+        assert(response.status_code == 200)
+    elif not start and response.json() == "Running":
+        response = https_requests.put(hostID, "/WebXi/Applications/SLM?Action=StartPause")
+        assert(response.status_code == 200)
+
+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)
+