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

pyaatlibs/__init__.py

@@ -1,7 +1,7 @@
 import os
 import platform
 
-__version__ = "1.5.12rc1"
+__version__ = "1.6"
 __author__ = "Hao-Wei Lee"
 if platform.system() == "Windows":
     SEP = "\\"
@@ -12,5 +12,6 @@ else:
 
 ROOT_DIR = SEP.join(os.path.dirname(os.path.realpath(__file__)).split(SEP)[:-1])
 
+
 def get_path(*names):
-	return "{}{}{}".format(ROOT_DIR, SEP, SEP.join(names))
+    return "{}{}{}".format(ROOT_DIR, SEP, SEP.join(names))

pyaatlibs/aatapp.py

@@ -1,5 +1,6 @@
 import os
 
+
 class AATApp(object):
     INTENT_PREFIX = "am broadcast -a"
     HTC_INTENT_PREFIX = "audio.htc.com.intent."
@@ -19,12 +20,24 @@ class AATApp(object):
 
     @staticmethod
     def playback_nonoffload(device, filename="440Hz.wav"):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "playback.nonoffload", "--es", "file", filename])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "playback.nonoffload",
+            "--es",
+            "file",
+            filename,
+        ])
         device.shell(cmd)
 
     @staticmethod
     def playback_offload(device, filename="440Hz.mp3"):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "playback.offload", "--es", "file", filename])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "playback.offload",
+            "--es",
+            "file",
+            filename,
+        ])
         device.shell(cmd)
 
     @staticmethod
@@ -34,7 +47,13 @@ class AATApp(object):
 
     @staticmethod
     def record_start(device):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "record.start", "--ei", "spt_xmax", "1000"])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "record.start",
+            "--ei",
+            "spt_xmax",
+            "1000",
+        ])
         device.shell(cmd)
 
     @staticmethod
@@ -44,12 +63,20 @@ class AATApp(object):
 
     @staticmethod
     def record_dump(device, path):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "record.dump", "--es", "path", path])
+        cmd = " ".join(
+            [AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "record.dump", "--es", "path", path]
+        )
         device.shell(cmd)
 
     @staticmethod
     def voip_start(device):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "voip.start", "--ei", "spt_xmax", "1000"])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "voip.start",
+            "--ei",
+            "spt_xmax",
+            "1000",
+        ])
         device.shell(cmd)
 
     @staticmethod
@@ -59,7 +86,13 @@ class AATApp(object):
 
     @staticmethod
     def voip_use_speaker(device, use=True):
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "voip.switch.speaker", "--ez", "use", str(1 if use else 0)])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "voip.switch.speaker",
+            "--ez",
+            "use",
+            str(1 if use else 0),
+        ])
         device.shell(cmd)
 
     @staticmethod
@@ -75,17 +108,31 @@ class AATApp(object):
     def print_log(device, severity="i", tag="AATAppAPIs", log=None):
         if not log:
             return
-        cmd = " ".join([AATApp.INTENT_PREFIX, AATApp.HTC_INTENT_PREFIX + "log.print",
-            "--es", "sv", str(severity), "--es", "tag", str(tag), "--es", "log", "\"{}\"".format(log)])
+        cmd = " ".join([
+            AATApp.INTENT_PREFIX,
+            AATApp.HTC_INTENT_PREFIX + "log.print",
+            "--es",
+            "sv",
+            str(severity),
+            "--es",
+            "tag",
+            str(tag),
+            "--es",
+            "log",
+            '"{}"'.format(log),
+        ])
         device.shell(cmd)
 
+
 import threading
 import time
 from pyaatlibs.audiofunction import ToneDetectorThread, ToneDetector
 from pyaatlibs.logger import Logger
 from pyaatlibs.adbutils import Adb
 
+
 class AATAppToneDetectorThread(ToneDetectorThread):
+
     def __init__(self, serialno, target_freq, callback):
         super(AATAppToneDetectorThread, self).__init__(target_freq=target_freq, callback=callback)
         self.serialno = serialno
@@ -114,7 +161,7 @@ class AATAppToneDetectorThread(ToneDetectorThread):
         Logger.log(self.get_tag(), "dump called")
         Logger.log(self.get_tag(), "----------------------------------------------")
         for msg in self.extra["dump"]:
-            Logger.log("{}::dump".format(self.get_tag()), "\"{}\"".format(msg))
+            Logger.log("{}::dump".format(self.get_tag()), '"{}"'.format(msg))
         del self.extra["dump"][:]
         Logger.log(self.get_tag(), "----------------------------------------------")
         self.extra["dump-lock"].release()
@@ -123,11 +170,7 @@ class AATAppToneDetectorThread(ToneDetectorThread):
         super(AATAppToneDetectorThread, self).join(timeout=timeout)
 
     def run(self):
-        shared_vars = {
-            "start_time": None,
-            "last_event": None,
-            "last_freq": -1
-        }
+        shared_vars = {"start_time": None, "last_event": None, "last_freq": -1}
 
         self.extra = {}
         self.extra["adb-read-prop-max-elapsed"] = -1
@@ -144,8 +187,11 @@ class AATAppToneDetectorThread(ToneDetectorThread):
             time_str = the_date + " " + the_time
 
             if shared_vars["last_freq"] != freq:
-                self.push_to_dump( \
-                    "the detected freq has been changed from {} to {} Hz".format(shared_vars["last_freq"], freq))
+                self.push_to_dump(
+                    "the detected freq has been changed from {} to {} Hz".format(
+                        shared_vars["last_freq"], freq
+                    )
+                )
                 shared_vars["last_freq"] = freq
 
             thresh = 10 if self.target_freq else 1
@@ -154,29 +200,42 @@ class AATAppToneDetectorThread(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:
-                        Logger.log(self.get_tag(), "send_cb({}, TONE_DETECTED)".format(shared_vars["start_time"]))
+                    if (
+                        not shared_vars["last_event"]
+                        or shared_vars["last_event"] != ToneDetector.Event.TONE_DETECTED
+                    ):
+                        Logger.log(
+                            self.get_tag(),
+                            "send_cb({}, TONE_DETECTED)".format(shared_vars["start_time"]),
+                        )
                         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
-                    self.push_to_dump("the tone is not detected and the event_counter is over the threshold")
-                    self.push_to_dump("last_event: \"{}\"".format(shared_vars["last_event"]))
-                if not shared_vars["last_event"] or shared_vars["last_event"] != ToneDetector.Event.TONE_MISSING:
+                    self.push_to_dump(
+                        "the tone is not detected and the event_counter is over the threshold"
+                    )
+                    self.push_to_dump('last_event: "{}"'.format(shared_vars["last_event"]))
+                if (
+                    not shared_vars["last_event"]
+                    or shared_vars["last_event"] != ToneDetector.Event.TONE_MISSING
+                ):
                     Logger.log(self.get_tag(), "send_cb({}, TONE_MISSING)".format(time_str))
                     self.cb((time_str, ToneDetector.Event.TONE_MISSING))
                     shared_vars["last_event"] = ToneDetector.Event.TONE_MISSING
                 self.event_counter = 0
 
-            if self.event_counter <= thresh: self.push_to_dump("event_counter: {}".format(self.event_counter))
+            if self.event_counter <= thresh:
+                self.push_to_dump("event_counter: {}".format(self.event_counter))
 
         # Adb.execute(cmd= \
         #     ["shell", "am", "broadcast", "-a", "audio.htc.com.intent.print.properties.enable", "--ez", "v", "1"], \
         #     serialno=self.serialno)
 
         from pyaatlibs.timeutils import TicToc, TimeUtils
+
         freq_cb_tictoc = TicToc()
         adb_tictoc = TicToc()
 
@@ -184,12 +243,18 @@ class AATAppToneDetectorThread(ToneDetectorThread):
         freq_cb_tictoc.tic()
         while not self.stoprequest.isSet():
             adb_tictoc.tic()
-            msg, _ = Adb.execute(cmd=["shell", "cat", "sdcard/AudioFunctionsDemo-record-prop.txt"], \
-                serialno=self.serialno, tolog=False)
+            msg, _ = Adb.execute(
+                cmd=["shell", "cat", "sdcard/AudioFunctionsDemo-record-prop.txt"],
+                serialno=self.serialno,
+                tolog=False,
+            )
             elapsed = adb_tictoc.toc()
             if tcount == 0:
-                Adb.execute(cmd=["shell", "rm", "-f", "sdcard/AudioFunctionsDemo-record-prop.txt"], \
-                    serialno=self.serialno, tolog=False)
+                Adb.execute(
+                    cmd=["shell", "rm", "-f", "sdcard/AudioFunctionsDemo-record-prop.txt"],
+                    serialno=self.serialno,
+                    tolog=False,
+                )
 
             if not "," in msg:
                 msg = "0,-30"
@@ -200,6 +265,7 @@ class AATAppToneDetectorThread(ToneDetectorThread):
             if "," in msg:
                 msg = msg.replace("\n", "")
                 import datetime
+
                 msg = "{} {}".format(TimeUtils.now_str(), msg)
 
                 try:

pyaatlibs/activitystatemachine.py

@@ -1,8 +1,11 @@
 class ActivityStateMachine(object):
+
     def __init__(self, device, serialno):
         self.device = device
         self.serialno = serialno
         self.cache = None
 
     def get_state(self):
-        raise NotImplementedError("the ActivityStateMachine.get_state() is not defined in the base class.")
+        raise NotImplementedError(
+            "the ActivityStateMachine.get_state() is not defined in the base class."
+        )

pyaatlibs/adbutils.py

@@ -5,7 +5,9 @@ import re
 import time
 from pyaatlibs.logger import Logger
 
+
 class AdbScreenRecordingThread(threading.Thread):
+
     def __init__(self, serialno):
         super(AdbScreenRecordingThread, self).__init__()
         self.serialno = serialno
@@ -23,9 +25,12 @@ class AdbScreenRecordingThread(threading.Thread):
         shell_cmd = "screenrecord /sdcard/screenrecord.mp4"
         cmd = ["adb", "-s", self.serialno, "shell", shell_cmd]
         Logger.log(
-            "AdbScreenRecordingThread", "threadloop is running with the command '{}'".format(cmd))
+            "AdbScreenRecordingThread", "threadloop is running with the command '{}'".format(cmd)
+        )
         self.proc = subprocess.Popen(
-            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+
 
 class Adb(object):
     HAS_BEEN_INIT = False
@@ -54,8 +59,11 @@ class Adb(object):
     def execute(child, cmd, serialno=None, tolog=True, timeoutsec=None):
         child._check_init()
 
-        if serialno and not serialno in child.get_devices(tolog=tolog) and \
-            child.is_device_available(serialno=serialno, tolog=tolog):
+        if (
+            serialno
+            and not serialno in child.get_devices(tolog=tolog)
+            and child.is_device_available(serialno=serialno, tolog=tolog)
+        ):
             ip_info = Adb.SERIAL_TO_IP_INFO[serialno]
             ip_addr = "{}:{}".format(ip_info["addr"], ip_info["port"])
             child._log("use Wifi adb: addr[{}] of serialno '{}'".format(ip_addr, serialno), tolog)
@@ -74,9 +82,9 @@ class Adb(object):
 
         cmd = cmd_prefix + cmd
         child._log("exec: {}".format(cmd), tolog)
-        out, err =  subprocess.Popen(
-            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) \
-                .communicate(timeout=timeoutsec)
+        out, err = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        ).communicate(timeout=timeoutsec)
 
         return out, err
 
@@ -95,7 +103,7 @@ class Adb(object):
             time.sleep(1)
 
         if retry == 0:
-            raise(RuntimeError("\"adb device\" might have some problems."))
+            raise (RuntimeError('"adb device" might have some problems.'))
 
         devices = [l.split()[0] for l in lines if l.split()[1] == "device"]
         return devices
@@ -115,7 +123,8 @@ class Adb(object):
                 continue
 
             out, err = child.execute(
-                ["shell", "getprop ro.serialno"], serialno=device, tolog=tolog, **kwargs)
+                ["shell", "getprop ro.serialno"], serialno=device, tolog=tolog, **kwargs
+            )
             if len(err) > 0:
                 continue
 
@@ -136,7 +145,8 @@ class Adb(object):
     @classmethod
     def get_wifi_status(child, serialno, tolog=True, **kwargs):
         out, err = child.execute(
-            ["shell", "cmd wifi status"], serialno=serialno, tolog=tolog, **kwargs)
+            ["shell", "cmd wifi status"], serialno=serialno, tolog=tolog, **kwargs
+        )
         if len(err) > 0:
             child._log("got error: {}".format(err.strip()), tolog)
             return None
@@ -145,7 +155,7 @@ class Adb(object):
         child._log("get_wifi_status: ret:\n{}".format(out), tolog)
 
         if not out.startswith("Wifi is "):
-            child._log("get_wifi_status: not starts with \"Wifi is\".", tolog)
+            child._log('get_wifi_status: not starts with "Wifi is".', tolog)
             return None
 
         lines = out.splitlines()
@@ -165,10 +175,11 @@ class Adb(object):
             return info
         detail_str = m.group()
 
-        key_strings = detail_str[len("WifiInfo: "):].split(", ")
+        key_strings = detail_str[len("WifiInfo: ") :].split(", ")
         matches = [re.match("(?P<key>[\\d\\w\\s\\-]+): (?P<value>.*)", s) for s in key_strings]
         info.update(
-            {d["key"]: d["value"] for d in [m.groupdict() for m in matches if m is not None]})
+            {d["key"]: d["value"] for d in [m.groupdict() for m in matches if m is not None]}
+        )
 
         for k, v in info.items():
             try:
@@ -215,8 +226,9 @@ class Adb(object):
     def enable_wifi_adb(child, serialno, port=5555, tolog=True, **kwargs):
         child._check_init()
 
-        if not serialno in Adb.SERIAL_TO_IP_INFO \
-            and not child.is_wifi_adb_supported(serialno=serialno, tolog=tolog, **kwargs):
+        if not serialno in Adb.SERIAL_TO_IP_INFO and not child.is_wifi_adb_supported(
+            serialno=serialno, tolog=tolog, **kwargs
+        ):
             child._log("Wifi adb is not supported on device '{}'".format(serialno), tolog)
             return False
 
@@ -251,8 +263,11 @@ class Adb(object):
 
         if not "port" in ip_info:
             child._log(
-                ("Wifi adb might not be connected on device '{}', "
-                "the port cannot be found.").format(serialno), tolog)
+                (
+                    "Wifi adb might not be connected on device '{}', the port cannot be found."
+                ).format(serialno),
+                tolog,
+            )
             return False
 
         ip_addr = "{}:{}".format(ip_info["addr"], ip_info["port"])
@@ -271,8 +286,9 @@ class Adb(object):
 
     @classmethod
     def get_wifi_adb_ip_addr(child, serialno, tolog=True, **kwargs):
-        if not serialno in Adb.SERIAL_TO_IP_INFO \
-            and not child.is_wifi_adb_supported(serialno=serialno, tolog=tolog, **kwargs):
+        if not serialno in Adb.SERIAL_TO_IP_INFO and not child.is_wifi_adb_supported(
+            serialno=serialno, tolog=tolog, **kwargs
+        ):
             child._log("Wifi adb is not supported on device '{}'".format(serialno), tolog)
             return None
 
@@ -283,18 +299,23 @@ class Adb(object):
 
         ip_addr = "{}:{}".format(ip_info["addr"], ip_info["port"])
         child._log(
-            "get_wifi_adb_ip_addr: addr[{}] of serialno '{}'".format(ip_addr, serialno), tolog)
+            "get_wifi_adb_ip_addr: addr[{}] of serialno '{}'".format(ip_addr, serialno), tolog
+        )
 
         out, err = child.execute(
-            ["shell", "getprop ro.serialno"], serialno=ip_addr, tolog=tolog, **kwargs)
+            ["shell", "getprop ro.serialno"], serialno=ip_addr, tolog=tolog, **kwargs
+        )
         out = out.strip()
         if len(err):
             child._log("get_wifi_adb_ip_addr: get error: {}".format(err), tolog)
             return None
 
         if out != serialno:
-            child._log("get_wifi_adb_ip_addr: the serialno does not match: " \
-                "detected[{}], expected[{}]".format(serialno, out), tolog)
+            child._log(
+                "get_wifi_adb_ip_addr: the serialno does not match: "
+                "detected[{}], expected[{}]".format(serialno, out),
+                tolog,
+            )
             return None
 
         return ip_addr
@@ -308,21 +329,24 @@ class Adb(object):
     @classmethod
     def device_fingerprint(child, serialno=None, **kwargs):
         return child.execute(
-            ["shell", "getprop", "ro.vendor.build.fingerprint"], serialno=serialno, **kwargs)
+            ["shell", "getprop", "ro.vendor.build.fingerprint"], serialno=serialno, **kwargs
+        )
 
     @classmethod
     def device_stayon(child, serialno=None, on=None, **kwargs):
         if on == None or type(on) is not bool:
             return
         return child.execute(
-            ["shell", "svc", "power", "stayon", str(on).lower()], serialno=serialno, **kwargs)
+            ["shell", "svc", "power", "stayon", str(on).lower()], serialno=serialno, **kwargs
+        )
 
     @classmethod
     def device_keyevent(child, serialno=None, keyevent=None, **kwargs):
         if not keyevent:
             return
         return child.execute(
-            ["shell", "input", "keyevent", str(keyevent)], serialno=serialno, **kwargs)
+            ["shell", "input", "keyevent", str(keyevent)], serialno=serialno, **kwargs
+        )
 
     @classmethod
     def device_keyevent_menu(child, serialno=None, **kwargs):
@@ -379,26 +403,31 @@ class Adb(object):
         time.sleep(1)
         if pullto:
             Adb.execute(
-                ["pull", "/sdcard/screenrecord.mp4", pullto], serialno=serialno, tolog=tolog)
+                ["pull", "/sdcard/screenrecord.mp4", pullto], serialno=serialno, tolog=tolog
+            )
         return True
 
+
 try:
     import functools
+
     reduce = functools.reduce
 except:
     pass
 
 import time
 
+
 class AudioAdb(Adb):
     TAG = "AudioAdb"
 
     @staticmethod
     def get_stream_volumes(serialno=None, **kwargs):
         out, _ = AudioAdb.execute(["shell", "dumpsys audio"], serialno=serialno, **kwargs)
-        lines = [line.strip() \
-            if isinstance(line, str) \
-            else line.decode("utf-8").strip() for line in out.splitlines()]
+        lines = [
+            line.strip() if isinstance(line, str) else line.decode("utf-8").strip()
+            for line in out.splitlines()
+        ]
         idices = [idx for idx, line in enumerate(lines) if line.startswith("- STREAM")]
         if len(idices) < 2:
             return None
@@ -421,7 +450,7 @@ class AudioAdb(Adb):
         for idx in idices:
             stream = lines[idx].split()[1][:-1]
             volumes[stream] = {}
-            for line in lines[idx+1:idx+nlines]:
+            for line in lines[idx + 1 : idx + nlines]:
                 result = [fragment.split(",") for fragment in line.split(":")]
                 result = reduce(lambda x, y: x + y, result)
                 if len(result) == 2:
@@ -431,7 +460,7 @@ class AudioAdb(Adb):
                     k = result[0]
                     volumes[stream][k] = {}
                     for idx in range(1, len(result), 2):
-                        subk, v = result[idx], result[idx+1]
+                        subk, v = result[idx], result[idx + 1]
                         volumes[stream][k][subk.strip()] = parse_str_v(v)
 
         return volumes
@@ -444,9 +473,8 @@ class AudioAdb(Adb):
 
     @staticmethod
     def inc_volume(serialno=None, volume_steps=1, **kwargs):
-        AudioAdb.adj_volume(serialno=serialno, keycode=24, times=volume_steps+1, **kwargs)
+        AudioAdb.adj_volume(serialno=serialno, keycode=24, times=volume_steps + 1, **kwargs)
 
     @staticmethod
     def dec_volume(serialno=None, volume_steps=1, **kwargs):
-        AudioAdb.adj_volume(serialno=serialno, keycode=25, times=volume_steps+1, **kwargs)
-
+        AudioAdb.adj_volume(serialno=serialno, keycode=25, times=volume_steps + 1, **kwargs)

pyaatlibs/appinterface.py

@@ -1,26 +1,28 @@
 from pyaatlibs.adbutils import Adb
 from pyaatlibs.logger import Logger
 
+
 class AppInterface(object):
+
     @classmethod
     def log(child, msg):
         Logger.log(child.TAG, msg)
 
     @staticmethod
     def get_apk_version():
-        raise(NotImplementedError("not implemented"))
+        raise (NotImplementedError("not implemented"))
 
     @staticmethod
     def get_apk_path():
-        raise(NotImplementedError("not implemented"))
+        raise (NotImplementedError("not implemented"))
 
     @staticmethod
     def get_launch_component():
-        raise(NotImplementedError("not implemented"))
+        raise (NotImplementedError("not implemented"))
 
     @staticmethod
     def get_package():
-        raise(NotImplementedError("not implemented"))
+        raise (NotImplementedError("not implemented"))
 
     @classmethod
     def clear_data(child, serialno=None, tolog=True):
@@ -29,7 +31,9 @@ class AppInterface(object):
     @classmethod
     def installed(child, serialno=None, tolog=True):
         out, _ = Adb.execute(["shell", "pm list packages"], serialno=serialno, tolog=tolog)
-        packages = [line.split(":")[-1].strip() for line in out.splitlines() if line.startswith("package:")]
+        packages = [
+            line.split(":")[-1].strip() for line in out.splitlines() if line.startswith("package:")
+        ]
         return child.get_package() in packages
 
     @classmethod
@@ -50,27 +54,54 @@ class AppInterface(object):
             child.log("{} should be installed on the device.".format(child.TAG))
             return None
 
-        out, _ = Adb.execute(["shell", "dumpsys package {}".format(child.get_package())], serialno=serialno, tolog=tolog)
+        out, _ = Adb.execute(
+            ["shell", "dumpsys package {}".format(child.get_package())],
+            serialno=serialno,
+            tolog=tolog,
+        )
         lines = out.splitlines()
-        requested_perm_idx = [idx for idx, line in enumerate(lines) \
-            if "requested permissions:" == line.strip()][0]
-        install_perm_idx = [idx for idx, line in enumerate(lines) \
-            if "install permissions:" == line.strip()][0]
-        install_perm_idx_end = [idx for idx, line in enumerate(lines[install_perm_idx+1:]) \
-            if not "android.permission." in line][0] + install_perm_idx + 1
-
-        runtime_perm_idx = [idx for idx, line in enumerate(lines) \
-            if "runtime permissions:" == line.strip()][0]
+        requested_perm_idx = [
+            idx for idx, line in enumerate(lines) if "requested permissions:" == line.strip()
+        ][0]
+        install_perm_idx = [
+            idx for idx, line in enumerate(lines) if "install permissions:" == line.strip()
+        ][0]
+        install_perm_idx_end = (
+            [
+                idx
+                for idx, line in enumerate(lines[install_perm_idx + 1 :])
+                if not "android.permission." in line
+            ][0]
+            + install_perm_idx
+            + 1
+        )
+
+        runtime_perm_idx = [
+            idx for idx, line in enumerate(lines) if "runtime permissions:" == line.strip()
+        ][0]
 
         try:
-            runtime_perm_idx_end = [idx for idx, line in enumerate(lines[runtime_perm_idx+1:]) \
-                if not "android.permission." in line][0] + runtime_perm_idx + 1
+            runtime_perm_idx_end = (
+                [
+                    idx
+                    for idx, line in enumerate(lines[runtime_perm_idx + 1 :])
+                    if not "android.permission." in line
+                ][0]
+                + runtime_perm_idx
+                + 1
+            )
         except IndexError:
             runtime_perm_idx_end = len(lines)
 
-        requested_perms = [line.strip() for line in lines[requested_perm_idx+1:install_perm_idx]]
-        install_perms = [line.strip() for line in lines[install_perm_idx+1:install_perm_idx_end]]
-        runtime_perms = [line.strip() for line in lines[runtime_perm_idx+1:runtime_perm_idx_end]]
+        requested_perms = [
+            line.strip() for line in lines[requested_perm_idx + 1 : install_perm_idx]
+        ]
+        install_perms = [
+            line.strip() for line in lines[install_perm_idx + 1 : install_perm_idx_end]
+        ]
+        runtime_perms = [
+            line.strip() for line in lines[runtime_perm_idx + 1 : runtime_perm_idx_end]
+        ]
 
         perms = {}
         for perm in requested_perms:
@@ -82,7 +113,9 @@ class AppInterface(object):
         for perm in runtime_perms:
             if not "granted=" in perm:
                 continue
-            perms[perm.split(":")[0]] = perm.split(":")[-1].split(",")[0].split("granted=")[-1].lower() == "true"
+            perms[perm.split(":")[0]] = (
+                perm.split(":")[-1].split(",")[0].split("granted=")[-1].lower() == "true"
+            )
 
         return perms
 
@@ -98,7 +131,9 @@ class AppInterface(object):
 
     @classmethod
     def launch_app(child, device=None, serialno=None):
-        Adb.execute(["shell", "am start -n {}".format(child.get_launch_component())], serialno=serialno)
+        Adb.execute(
+            ["shell", "am start -n {}".format(child.get_launch_component())], serialno=serialno
+        )
 
     @classmethod
     def stop_app(child, device=None, serialno=None):

pyaatlibs/argutils.py

@@ -1,6 +1,8 @@
 import getopt
 
+
 class AATArgParseUtils(object):
+
     @staticmethod
     def parse_arg(argv, options, required=[]):
         opts, args = getopt.getopt(argv, "", options)