python-audio-autotest-3.10 1.5.12rc1__py3-none-any.whl → 1.5.12rc3__py3-none-any.whl

pyaatlibs/audiofunction.py

@@ -9,8 +9,10 @@ from pyaatlibs.adbutils import Adb
 from pyaatlibs.logger import Logger
 from pyaatlibs.timeutils import TimeUtils
 
+
 # Initialization of used variables
 class CommandHandler(object):
+
     def __init__(self):
         self.cmd = None
 
@@ -18,6 +20,7 @@ class CommandHandler(object):
         if self.cmd:
             self.cmd.stop()
 
+
 class AudioFunction(object):
     WORK_THREAD = AudioCommandThread()
     WORK_THREAD.daemon = True
@@ -46,7 +49,9 @@ class AudioFunction(object):
         if not AudioFunction.HAS_BEEN_INIT:
             raise RuntimeError("The AudioFunction should be initialized before calling APIs")
         AudioFunction.COMMAND.stop()
-        AudioFunction.COMMAND.cmd = TonePlayCommand(config=AudioFunction.AUDIO_CONFIG, out_freq=out_freq)
+        AudioFunction.COMMAND.cmd = TonePlayCommand(
+            config=AudioFunction.AUDIO_CONFIG, out_freq=out_freq
+        )
         AudioFunction.WORK_THREAD.push(AudioFunction.COMMAND.cmd)
 
     @staticmethod
@@ -59,11 +64,16 @@ class AudioFunction(object):
             raise RuntimeError("The AudioFunction should be initialized before calling APIs")
         AudioFunction.COMMAND.stop()
         AudioFunction.AUDIO_CONFIG.cb = cb
-        AudioFunction.COMMAND.cmd = cmd if cmd is not None else \
-            ToneDetectCommand(config=AudioFunction.AUDIO_CONFIG, framemillis=50, nfft=2048)
+        AudioFunction.COMMAND.cmd = (
+            cmd
+            if cmd is not None
+            else ToneDetectCommand(config=AudioFunction.AUDIO_CONFIG, framemillis=50, nfft=2048)
+        )
         AudioFunction.WORK_THREAD.push(AudioFunction.COMMAND.cmd)
 
+
 class ToneDetectorThread(threading.Thread):
+
     def __init__(self, target_freq, callback):
         super(ToneDetectorThread, self).__init__()
         self.daemon = True
@@ -87,21 +97,22 @@ class ToneDetectorThread(threading.Thread):
         if self.target_freq == None:
             return True
 
-        diff_semitone = np.abs(np.log(1.0*freq/self.target_freq) / np.log(2) * 12)
+        diff_semitone = np.abs(np.log(1.0 * freq / self.target_freq) / np.log(2) * 12)
         return diff_semitone < 2
 
+
 class ToneDetectorForServerThread(ToneDetectorThread):
+
     def __init__(self, target_freq, callback):
-        super(ToneDetectorForServerThread, self).__init__(target_freq=target_freq, callback=callback)
+        super(ToneDetectorForServerThread, self).__init__(
+            target_freq=target_freq, callback=callback
+        )
 
     def join(self, timeout=None):
         super(ToneDetectorForServerThread, self).join(timeout)
 
     def run(self):
-        shared_vars = {
-            "start_time": None,
-            "last_event": None
-        }
+        shared_vars = {"start_time": None, "last_event": None}
 
         def freq_cb(detected_tones):
             if len(detected_tones) == 0:
@@ -115,14 +126,20 @@ class ToneDetectorForServerThread(ToneDetectorThread):
                 if self.event_counter == 1:
                     shared_vars["start_time"] = time_str
                 if self.event_counter == thresh:
-                    if not shared_vars["last_event"] or shared_vars["last_event"] != ToneDetector.Event.TONE_DETECTED:
+                    if (
+                        not shared_vars["last_event"]
+                        or shared_vars["last_event"] != ToneDetector.Event.TONE_DETECTED
+                    ):
                         self.cb((shared_vars["start_time"], ToneDetector.Event.TONE_DETECTED))
                         shared_vars["last_event"] = ToneDetector.Event.TONE_DETECTED
 
             else:
                 if self.event_counter > thresh:
                     shared_vars["start_time"] = None
-                    if not shared_vars["last_event"] or shared_vars["last_event"] != ToneDetector.Event.TONE_MISSING:
+                    if (
+                        not shared_vars["last_event"]
+                        or shared_vars["last_event"] != ToneDetector.Event.TONE_MISSING
+                    ):
                         self.cb((time_str, ToneDetector.Event.TONE_MISSING))
                         shared_vars["last_event"] = ToneDetector.Event.TONE_MISSING
                 self.event_counter = 0
@@ -173,7 +190,9 @@ class ToneDetector(object):
         ToneDetector.WORK_THREADS.clear()
         ToneDetector.WORK_THREADS = None
 
+
 class DetectionStateListener(object):
+
     class Event(object):
         ACTIVE = "active"
         INACTIVE = "inactive"
@@ -204,14 +223,18 @@ class DetectionStateListener(object):
         with self.event_q.mutex:
             current_event = self.current_event
         if current_event:
-            active_or_inactive = DetectionStateListener.Event.ACTIVE \
-                            if current_event[1] == ToneDetector.Event.TONE_DETECTED else \
-                                 DetectionStateListener.Event.INACTIVE
+            active_or_inactive = (
+                DetectionStateListener.Event.ACTIVE
+                if current_event[1] == ToneDetector.Event.TONE_DETECTED
+                else DetectionStateListener.Event.INACTIVE
+            )
 
         self.clear()
 
         if active_or_inactive:
-            Logger.log(self.get_tag(), "reset and resend the event ({}, 0)".format(active_or_inactive))
+            Logger.log(
+                self.get_tag(), "reset and resend the event ({}, 0)".format(active_or_inactive)
+            )
             self.event_q.put((active_or_inactive, 0))
 
     def tone_detected_event_cb(self, event):
@@ -219,27 +242,31 @@ class DetectionStateListener(object):
         self._handle_event(event)
 
     def _handle_event(self, event):
-        active_or_inactive = DetectionStateListener.Event.ACTIVE \
-                        if event[1] == ToneDetector.Event.TONE_DETECTED else \
-                             DetectionStateListener.Event.INACTIVE
+        active_or_inactive = (
+            DetectionStateListener.Event.ACTIVE
+            if event[1] == ToneDetector.Event.TONE_DETECTED
+            else DetectionStateListener.Event.INACTIVE
+        )
 
         self.event_q.put((active_or_inactive, 0))
 
         if self.current_event and self.current_event[1] != event[1]:
-            rising_or_falling = DetectionStateListener.Event.RISING_EDGE \
-                            if event[1] == ToneDetector.Event.TONE_DETECTED else \
-                                DetectionStateListener.Event.FALLING_EDGE
+            rising_or_falling = (
+                DetectionStateListener.Event.RISING_EDGE
+                if event[1] == ToneDetector.Event.TONE_DETECTED
+                else DetectionStateListener.Event.FALLING_EDGE
+            )
 
             t2 = TimeUtils.time_from_str(event[0])
             t1 = TimeUtils.time_from_str(self.current_event[0])
             t_diff = t2 - t1
-            self.event_q.put((rising_or_falling, t_diff.total_seconds()*1000.0))
+            self.event_q.put((rising_or_falling, t_diff.total_seconds() * 1000.0))
 
         self.current_event = event
 
     def wait_for_event(self, event, timeout):
         cnt = 0
-        while cnt < timeout*10:
+        while cnt < timeout * 10:
             cnt += 1
             if self.stoprequest.isSet():
                 return -1
@@ -252,10 +279,15 @@ class DetectionStateListener(object):
                 with self.event_q.mutex:
                     current_event = self.current_event
                 if current_event:
-                    active_or_inactive = DetectionStateListener.Event.ACTIVE \
-                        if current_event[1] == ToneDetector.Event.TONE_DETECTED else \
-                             DetectionStateListener.Event.INACTIVE
+                    active_or_inactive = (
+                        DetectionStateListener.Event.ACTIVE
+                        if current_event[1] == ToneDetector.Event.TONE_DETECTED
+                        else DetectionStateListener.Event.INACTIVE
+                    )
                     if active_or_inactive == event:
-                        Logger.log(self.get_tag(), "the current state '{}' fits the waited event".format(event))
+                        Logger.log(
+                            self.get_tag(),
+                            "the current state '{}' fits the waited event".format(event),
+                        )
                         return 0
         return -1

pyaatlibs/audiosignalframelogger.py

@@ -7,6 +7,7 @@ import numpy as np
 
 from pyaatlibs import SEP
 
+
 class AudioSignalFrameLogger(object):
     INFO_FILE = "info.json"
     BIN_FILE = "stream.bin"
@@ -18,14 +19,12 @@ class AudioSignalFrameLogger(object):
 
     def push(self, name, fs, values):
         self.lock.acquire()
-        self.info.append(
-                {
-                    "name": name,
-                    "fs": fs,
-                    "datasize-in-double": values.shape[0],
-                    "createAt": "{} (UTF+8)".format(str(datetime.datetime.now())[:-3])
-                }
-            )
+        self.info.append({
+            "name": name,
+            "fs": fs,
+            "datasize-in-double": values.shape[0],
+            "createAt": "{} (UTF+8)".format(str(datetime.datetime.now())[:-3]),
+        })
         self.databuf.append(np.array(values, dtype=np.float64))
         self.lock.release()
 
@@ -33,7 +32,9 @@ class AudioSignalFrameLogger(object):
         if path.endswith(SEP):
             path = path[:-1]
         self.lock.acquire()
-        out, _ = subprocess.Popen(["mkdir", "-p", path], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
+        out, _ = subprocess.Popen(
+            ["mkdir", "-p", path], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        ).communicate()
 
         with open("{}{}{}".format(path, SEP, AudioSignalFrameLogger.INFO_FILE), "w") as f:
             f.write(json.dumps(self.info, indent=4) + "\n")

pyaatlibs/audiothread.py

@@ -10,18 +10,24 @@ try:
 except ImportError:
     import Queue as queue
 
+
 class AudioConfig(object):
+
     def __init__(self, fs, ch=1, dtype="float32", cb=None):
         self.fs = fs
         self.ch = ch
         self.dtype = dtype
         self.cb = cb
 
+
 class AudioCommand(object):
+
     def __init__(self, config):
         self.config = config
 
+
 class RawRecordCommand(AudioCommand):
+
     def __init__(self, config, framemillis=100):
         super(RawRecordCommand, self).__init__(config)
         self.framemillis = framemillis
@@ -33,7 +39,9 @@ class RawRecordCommand(AudioCommand):
     def reset(self):
         self.is_recording = True
 
+
 class TonePlayCommand(AudioCommand):
+
     def __init__(self, config, out_freq):
         super(TonePlayCommand, self).__init__(config)
         self.out_freq = out_freq
@@ -45,13 +53,15 @@ class TonePlayCommand(AudioCommand):
     def reset(self):
         self.is_playing = True
 
+
 class ToneDetectCommand(AudioCommand):
+
     def __init__(self, config, framemillis=100, nfft=-1):
         super(ToneDetectCommand, self).__init__(config)
         self.framemillis = framemillis
         self.nfft = nfft
         if self.nfft < 0:
-            self.nfft = int(framemillis*self.config.fs/1000)
+            self.nfft = int(framemillis * self.config.fs / 1000)
         self.is_detecting = True
 
     def stop(self):
@@ -60,7 +70,9 @@ class ToneDetectCommand(AudioCommand):
     def reset(self):
         self.is_detecting = True
 
+
 class AudioCommandThread(threading.Thread):
+
     def __init__(self, cmd_q=None):
         super(AudioCommandThread, self).__init__()
         self.cmd_q = cmd_q if cmd_q else queue.Queue()
@@ -103,10 +115,7 @@ class AudioCommandThread(threading.Thread):
         cfg = cmd.config
 
         # Make the code adaptive to both python 2 and 3
-        shared_vars = {
-            "cmd"         : cmd,
-            "phase_offset": phase_offset
-        }
+        shared_vars = {"cmd": cmd, "phase_offset": phase_offset}
 
         def playback_cb(outdata, frames, time, status):
             phase_offset = shared_vars["phase_offset"]
@@ -114,8 +123,8 @@ class AudioCommandThread(threading.Thread):
             cfg = cmd.config
 
             signal = np.arange(outdata.shape[0])
-            signal = signal * 2*np.pi/cfg.fs + phase_offset
-            phase_offset += outdata.shape[0] * 2*np.pi/cfg.fs
+            signal = signal * 2 * np.pi / cfg.fs + phase_offset
+            phase_offset += outdata.shape[0] * 2 * np.pi / cfg.fs
             signal = 0.99 * np.sin(signal * cmd.out_freq)
 
             for cidx in range(outdata.shape[1]):
@@ -124,21 +133,19 @@ class AudioCommandThread(threading.Thread):
             shared_vars["phase_offset"] = phase_offset
             shared_vars["cmd"] = cmd
 
-        with sd.OutputStream(channels=cfg.ch, callback=playback_cb, samplerate=cfg.fs, dtype="float32"):
+        with sd.OutputStream(
+            channels=cfg.ch, callback=playback_cb, samplerate=cfg.fs, dtype="float32"
+        ):
             while cmd.is_playing:
                 sd.sleep(500)
 
     def _process_tone_detect_command(self, cmd):
         cfg = cmd.config
         buff = np.array([])
-        framesize = int(cfg.fs*cmd.framemillis/1000)
+        framesize = int(cfg.fs * cmd.framemillis / 1000)
 
         # Make the code adaptive to both python 2 and 3
-        shared_vars = {
-            "cmd"      : cmd,
-            "buff"     : buff,
-            "framesize": framesize
-        }
+        shared_vars = {"cmd": cmd, "buff": buff, "framesize": framesize}
 
         def record_cb(indata, frames, time, status):
             cmd = shared_vars["cmd"]
@@ -153,10 +160,10 @@ class AudioCommandThread(threading.Thread):
 
             while buff.size >= framesize:
                 spectrum = np.abs(fft(buff[:framesize, 0], cmd.nfft))
-                spectrum = spectrum[:int(cmd.nfft/2.0)]
-                unit_freq = 1.0*cfg.fs / cmd.nfft
+                spectrum = spectrum[: int(cmd.nfft / 2.0)]
+                unit_freq = 1.0 * cfg.fs / cmd.nfft
                 peaks = find_peaks(spectrum)
-                tones = list(map(lambda x: (x[0]*unit_freq, 20*np.log10(x[1])), peaks))
+                tones = list(map(lambda x: (x[0] * unit_freq, 20 * np.log10(x[1])), peaks))
                 if cfg.cb:
                     cfg.cb(detected_tones=tones)
 
@@ -166,21 +173,19 @@ class AudioCommandThread(threading.Thread):
             shared_vars["buff"] = buff
             shared_vars["framesize"] = framesize
 
-        with sd.InputStream(channels=cfg.ch, callback=record_cb, samplerate=cfg.fs, dtype="float32"):
+        with sd.InputStream(
+            channels=cfg.ch, callback=record_cb, samplerate=cfg.fs, dtype="float32"
+        ):
             while cmd.is_detecting:
                 sd.sleep(500)
 
     def _process_raw_record_command(self, cmd):
         cfg = cmd.config
         buff = np.array([])
-        framesize = int(cfg.fs*cmd.framemillis/1000)
+        framesize = int(cfg.fs * cmd.framemillis / 1000)
 
         # Make the code adaptive to both python 2 and 3
-        shared_vars = {
-            "cmd"      : cmd,
-            "buff"     : buff,
-            "framesize": framesize
-        }
+        shared_vars = {"cmd": cmd, "buff": buff, "framesize": framesize}
 
         def record_cb(indata, frames, time, status):
             cmd = shared_vars["cmd"]
@@ -203,6 +208,8 @@ class AudioCommandThread(threading.Thread):
             shared_vars["buff"] = buff
             shared_vars["framesize"] = framesize
 
-        with sd.InputStream(channels=cfg.ch, callback=record_cb, samplerate=cfg.fs, dtype="float32"):
+        with sd.InputStream(
+            channels=cfg.ch, callback=record_cb, samplerate=cfg.fs, dtype="float32"
+        ):
             while cmd.is_recording:
                 sd.sleep(500)