pymobiledevice3 4.27.4__py3-none-any.whl → 5.1.2__py3-none-any.whl

pymobiledevice3/cli/developer.py

@@ -1,5 +1,5 @@
-# flake8: noqa: C901
 import asyncio
+import contextlib
 import json
 import logging
 import os
@@ -24,10 +24,21 @@ from plumbum import local
 from pykdebugparser.pykdebugparser import PyKdebugParser
 
 import pymobiledevice3
-from pymobiledevice3.cli.cli_common import BASED_INT, Command, RSDCommand, default_json_encoder, print_json, \
-    user_requested_colored_output
-from pymobiledevice3.exceptions import DeviceAlreadyInUseError, DvtDirListError, ExtractingStackshotError, \
-    RSDRequiredError, UnrecognizedSelectorError
+from pymobiledevice3.cli.cli_common import (
+    BASED_INT,
+    Command,
+    RSDCommand,
+    default_json_encoder,
+    print_json,
+    user_requested_colored_output,
+)
+from pymobiledevice3.exceptions import (
+    DeviceAlreadyInUseError,
+    DvtDirListError,
+    ExtractingStackshotError,
+    RSDRequiredError,
+    UnrecognizedSelectorError,
+)
 from pymobiledevice3.lockdown import LockdownClient, create_using_usbmux
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.osu.os_utils import get_os_utils
@@ -65,10 +76,10 @@ from pymobiledevice3.tcp_forwarder import LockdownTcpForwarder
 from pymobiledevice3.utils import try_decode
 
 OSUTILS = get_os_utils()
-BSC_SUBCLASS = 0x40c
+BSC_SUBCLASS = 0x40C
 BSC_CLASS = 0x4
-VFS_AND_TRACES_SET = {0x03010000, 0x07ff0000}
-DEBUGSERVER_CONNECTION_STEPS = '''
+VFS_AND_TRACES_SET = {0x03010000, 0x07FF0000}
+DEBUGSERVER_CONNECTION_STEPS = """
 Follow the following connections steps from LLDB:
 
 (lldb) platform select remote-ios
@@ -76,9 +87,9 @@ Follow the following connections steps from LLDB:
 (lldb) script lldb.target.module[0].SetPlatformFileSpec(lldb.SBFileSpec('/private/var/containers/Bundle/Application/<APP-UUID>/application.app'))
 (lldb) process connect connect://[{host}]:{port}   <-- ACTUAL CONNECTION DETAILS!
 (lldb) process launch
-'''
+"""
 
-MatchedProcessByPid = namedtuple('MatchedProcess', 'name pid')
+MatchedProcessByPid = namedtuple("MatchedProcess", "name pid")
 
 logger = logging.getLogger(__name__)
 
@@ -105,148 +116,160 @@ def developer() -> None:
     pass
 
 
-@developer.command('shell', cls=Command)
-@click.argument('service')
-@click.option('-r', '--remove-ssl-context', is_flag=True)
+@developer.command("shell", cls=Command)
+@click.argument("service")
+@click.option("-r", "--remove-ssl-context", is_flag=True)
 def developer_shell(service_provider: LockdownClient, service, remove_ssl_context):
-    """ Launch developer IPython shell (used for pymobiledevice3 R&D) """
+    """Launch developer IPython shell (used for pymobiledevice3 R&D)"""
     with RemoteServer(service_provider, service, remove_ssl_context) as service:
         service.shell()
 
 
 @developer.group()
 def dvt() -> None:
-    """ Access advanced instrumentation APIs """
+    """Access advanced instrumentation APIs"""
     pass
 
 
-@dvt.command('proclist', cls=Command)
+@dvt.command("proclist", cls=Command)
 def proclist(service_provider: LockdownClient) -> None:
-    """ Show process list """
+    """Show process list"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         processes = DeviceInfo(dvt).proclist()
         for process in processes:
-            if 'startDate' in process:
-                process['startDate'] = str(process['startDate'])
+            if "startDate" in process:
+                process["startDate"] = str(process["startDate"])
 
         print_json(processes)
 
 
-@dvt.command('is-running-pid', cls=Command)
-@click.argument('pid', type=click.INT)
+@dvt.command("is-running-pid", cls=Command)
+@click.argument("pid", type=click.INT)
 def is_running_pid(service_provider: LockdownClient, pid: int) -> None:
-    """ Simple check if PID is running """
+    """Simple check if PID is running"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         print_json(DeviceInfo(dvt).is_running_pid(pid))
 
 
-@dvt.command('memlimitoff', cls=Command)
-@click.argument('pid', type=click.INT)
+@dvt.command("memlimitoff", cls=Command)
+@click.argument("pid", type=click.INT)
 def memlimitoff(service_provider: LockdownServiceProvider, pid: int) -> None:
-    """ Disable process memory limit """
+    """Disable process memory limit"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         ProcessControl(dvt).disable_memory_limit_for_pid(pid)
 
 
-@dvt.command('applist', cls=Command)
+@dvt.command("applist", cls=Command)
 def applist(service_provider: LockdownServiceProvider) -> None:
-    """ Show application list """
+    """Show application list"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         apps = ApplicationListing(dvt).applist()
         print_json(apps)
 
 
-@dvt.command('signal', cls=Command)
-@click.argument('pid', type=click.INT)
-@click.argument('sig', type=click.INT, required=False)
-@click.option('-s', '--signal-name', type=click.Choice([s.name for s in signal.Signals]))
+@dvt.command("signal", cls=Command)
+@click.argument("pid", type=click.INT)
+@click.argument("sig", type=click.INT, required=False)
+@click.option("-s", "--signal-name", type=click.Choice([s.name for s in signal.Signals]))
 def send_signal(service_provider, pid, sig, signal_name) -> None:
-    """ Send a signal to process by its PID """
+    """Send a signal to process by its PID"""
     if not sig and not signal_name:
-        raise MissingParameter(param_type='argument|option', param_hint='\'SIG|SIGNAL-NAME\'')
+        raise MissingParameter(param_type="argument|option", param_hint="'SIG|SIGNAL-NAME'")
     if sig and signal_name:
-        raise UsageError(message='Cannot give SIG and SIGNAL-NAME together')
+        raise UsageError(message="Cannot give SIG and SIGNAL-NAME together")
     sig = sig or signal.Signals[signal_name].value
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         ProcessControl(dvt).signal(pid, sig)
 
 
-@dvt.command('kill', cls=Command)
-@click.argument('pid', type=click.INT)
+@dvt.command("kill", cls=Command)
+@click.argument("pid", type=click.INT)
 def kill(service_provider: LockdownClient, pid) -> None:
-    """ Kill a process by its pid. """
+    """Kill a process by its pid."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         ProcessControl(dvt).kill(pid)
 
 
 @dvt.command(cls=Command)
-@click.argument('app_bundle_identifier')
+@click.argument("app_bundle_identifier")
 def process_id_for_bundle_id(service_provider: LockdownServiceProvider, app_bundle_identifier: str) -> None:
-    """ Get PID of a bundle identifier (only returns a valid value if its running). """
+    """Get PID of a bundle identifier (only returns a valid value if its running)."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         print(ProcessControl(dvt).process_identifier_for_bundle_identifier(app_bundle_identifier))
 
 
-def get_matching_processes(service_provider: LockdownServiceProvider, name: Optional[str] = None,
-                           bundle_identifier: Optional[str] = None) \
-        -> list[MatchedProcessByPid]:
+def get_matching_processes(
+    service_provider: LockdownServiceProvider, name: Optional[str] = None, bundle_identifier: Optional[str] = None
+) -> list[MatchedProcessByPid]:
     result = []
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         device_info = DeviceInfo(dvt)
         for process in device_info.proclist():
-            current_name = process.get('name')
-            current_bundle_identifier = process.get('bundleIdentifier', '')
-            pid = process['pid']
-            if (bundle_identifier is not None and bundle_identifier in current_bundle_identifier) or \
-                    (name is not None and name in current_name):
+            current_name = process.get("name")
+            current_bundle_identifier = process.get("bundleIdentifier", "")
+            pid = process["pid"]
+            if (bundle_identifier is not None and bundle_identifier in current_bundle_identifier) or (
+                name is not None and name in current_name
+            ):
                 result.append(MatchedProcessByPid(name=current_name, pid=pid))
     return result
 
 
-@dvt.command('pkill', cls=Command)
-@click.argument('expression')
-@click.option('--bundle', is_flag=True, help='Treat given expression as a bundle-identifier instead of a process name')
+@dvt.command("pkill", cls=Command)
+@click.argument("expression")
+@click.option("--bundle", is_flag=True, help="Treat given expression as a bundle-identifier instead of a process name")
 def pkill(service_provider: LockdownServiceProvider, expression: str, bundle: False) -> None:
-    """ kill all processes containing `expression` in their name. """
+    """kill all processes containing `expression` in their name."""
     matching_name = expression if not bundle else None
     matching_bundle_identifier = expression if bundle else None
-    matching_processes = get_matching_processes(service_provider, name=matching_name,
-                                                bundle_identifier=matching_bundle_identifier)
+    matching_processes = get_matching_processes(
+        service_provider, name=matching_name, bundle_identifier=matching_bundle_identifier
+    )
 
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         process_control = ProcessControl(dvt)
 
         for process in matching_processes:
-            logger.info(f'killing {process.name}({process.pid})')
+            logger.info(f"killing {process.name}({process.pid})")
             process_control.kill(process.pid)
 
 
-@dvt.command('launch', cls=Command)
-@click.argument('arguments', type=click.STRING)
-@click.option('--kill-existing/--no-kill-existing', default=True,
-              help='Whether to kill an existing instance of this process')
-@click.option('--suspended', is_flag=True, help='Same as WaitForDebugger')
-@click.option('--env', multiple=True, type=click.Tuple((str, str)),
-              help='Environment variables to pass to process given as a list of key value')
-@click.option('--stream', is_flag=True)
-def launch(service_provider: LockdownClient, arguments: str, kill_existing: bool, suspended: bool, env: tuple,
-           stream: bool) -> None:
-    """ Launch a process. """
+@dvt.command("launch", cls=Command)
+@click.argument("arguments", type=click.STRING)
+@click.option(
+    "--kill-existing/--no-kill-existing", default=True, help="Whether to kill an existing instance of this process"
+)
+@click.option("--suspended", is_flag=True, help="Same as WaitForDebugger")
+@click.option(
+    "--env",
+    multiple=True,
+    type=click.Tuple((str, str)),
+    help="Environment variables to pass to process given as a list of key value",
+)
+@click.option("--stream", is_flag=True)
+def launch(
+    service_provider: LockdownClient, arguments: str, kill_existing: bool, suspended: bool, env: tuple, stream: bool
+) -> None:
+    """Launch a process."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         parsed_arguments = shlex.split(arguments)
         process_control = ProcessControl(dvt)
-        pid = process_control.launch(bundle_id=parsed_arguments[0], arguments=parsed_arguments[1:],
-                                     kill_existing=kill_existing, start_suspended=suspended,
-                                     environment=dict(env))
-        print(f'Process launched with pid {pid}')
+        pid = process_control.launch(
+            bundle_id=parsed_arguments[0],
+            arguments=parsed_arguments[1:],
+            kill_existing=kill_existing,
+            start_suspended=suspended,
+            environment=dict(env),
+        )
+        print(f"Process launched with pid {pid}")
         while stream:
             for output_received in process_control:
-                logging.getLogger(f'PID:{output_received.pid}').info(output_received.message.strip())
+                logging.getLogger(f"PID:{output_received.pid}").info(output_received.message.strip())
 
 
-@dvt.command('shell', cls=Command)
+@dvt.command("shell", cls=Command)
 def dvt_shell(service_provider: LockdownClient):
-    """ Launch developer shell (used for pymobiledevice3 R&D) """
+    """Launch developer shell (used for pymobiledevice3 R&D)"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         dvt.shell()
 
@@ -264,55 +287,53 @@ def show_dirlist(device_info: DeviceInfo, dirname, recursive=False):
             show_dirlist(device_info, filename, recursive=recursive)
 
 
-@dvt.command('ls', cls=Command)
-@click.argument('path', type=click.Path(exists=False, readable=False))
-@click.option('-r', '--recursive', is_flag=True)
+@dvt.command("ls", cls=Command)
+@click.argument("path", type=click.Path(exists=False, readable=False))
+@click.option("-r", "--recursive", is_flag=True)
 def ls(service_provider: LockdownClient, path, recursive):
-    """ List directory """
+    """List directory"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         show_dirlist(DeviceInfo(dvt), path, recursive=recursive)
 
 
-@dvt.command('device-information', cls=Command)
+@dvt.command("device-information", cls=Command)
 def device_information(service_provider: LockdownClient):
-    """ Print system information """
+    """Print system information"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         device_info = DeviceInfo(dvt)
         info = {
-            'hardware': device_info.hardware_information(),
-            'network': device_info.network_information(),
-            'kernel-name': device_info.mach_kernel_name(),
-            'kpep-database': device_info.kpep_database(),
+            "hardware": device_info.hardware_information(),
+            "network": device_info.network_information(),
+            "kernel-name": device_info.mach_kernel_name(),
+            "kpep-database": device_info.kpep_database(),
         }
-        try:
-            info['system'] = device_info.system_information()
-        except UnrecognizedSelectorError:
-            pass
+        with contextlib.suppress(UnrecognizedSelectorError):
+            info["system"] = device_info.system_information()
         print_json(info)
 
 
-@dvt.command('netstat', cls=Command)
+@dvt.command("netstat", cls=Command)
 def netstat(service_provider: LockdownClient):
-    """ Print information about current network activity. """
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with NetworkMonitor(dvt) as monitor:
-            for event in monitor:
-                if isinstance(event, ConnectionDetectionEvent):
-                    logger.info(
-                        f'Connection detected: {event.local_address.data.address}:{event.local_address.port} -> '
-                        f'{event.remote_address.data.address}:{event.remote_address.port}')
-
-
-@dvt.command('screenshot', cls=Command)
-@click.argument('out', type=click.File('wb'))
-def screenshot(service_provider: LockdownClient, out):
-    """ Take device screenshot """
+    """Print information about current network activity."""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, NetworkMonitor(dvt) as monitor:
+        for event in monitor:
+            if isinstance(event, ConnectionDetectionEvent):
+                logger.info(
+                    f"Connection detected: {event.local_address.data.address}:{event.local_address.port} -> "
+                    f"{event.remote_address.data.address}:{event.remote_address.port}"
+                )
+
+
+@dvt.command("screenshot", cls=Command)
+@click.argument("out", type=click.File("wb"))
+def dvt_screenshot(service_provider: LockdownClient, out):
+    """Take device screenshot"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         out.write(Screenshot(dvt).get_screenshot())
 
 
-@dvt.command('xcuitest', cls=Command)
-@click.argument('bundle-id')
+@dvt.command("xcuitest", cls=Command)
+@click.argument("bundle-id")
 def xcuitest(service_provider: LockdownClient, bundle_id: str) -> None:
     """\b
     Start XCUITest
@@ -323,40 +344,44 @@ def xcuitest(service_provider: LockdownClient, bundle_id: str) -> None:
     XCUITestService(service_provider).run(bundle_id)
 
 
-@dvt.group('sysmon')
+@dvt.group("sysmon")
 def sysmon():
-    """ System monitor options. """
+    """System monitor options."""
 
 
-@sysmon.group('process')
+@sysmon.group("process")
 def sysmon_process():
-    """ Process monitor options. """
+    """Process monitor options."""
 
 
-@sysmon_process.command('monitor', cls=Command)
-@click.argument('threshold', type=click.FLOAT)
+@sysmon_process.command("monitor", cls=Command)
+@click.argument("threshold", type=click.FLOAT)
 def sysmon_process_monitor(service_provider: LockdownClient, threshold):
-    """ monitor all most consuming processes by given cpuUsage threshold. """
+    """monitor all most consuming processes by given cpuUsage threshold."""
 
-    Process = namedtuple('process', 'pid name cpuUsage physFootprint')
+    Process = namedtuple("process", "pid name cpuUsage physFootprint")
 
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with Sysmontap(dvt) as sysmon:
-            for process_snapshot in sysmon.iter_processes():
-                entries = []
-                for process in process_snapshot:
-                    if (process['cpuUsage'] is not None) and (process['cpuUsage'] >= threshold):
-                        entries.append(Process(pid=process['pid'], name=process['name'], cpuUsage=process['cpuUsage'],
-                                               physFootprint=process['physFootprint']))
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, Sysmontap(dvt) as sysmon:
+        for process_snapshot in sysmon.iter_processes():
+            entries = []
+            for process in process_snapshot:
+                if (process["cpuUsage"] is not None) and (process["cpuUsage"] >= threshold):
+                    entries.append(
+                        Process(
+                            pid=process["pid"],
+                            name=process["name"],
+                            cpuUsage=process["cpuUsage"],
+                            physFootprint=process["physFootprint"],
+                        )
+                    )
 
-                logger.info(entries)
+            logger.info(entries)
 
 
-@sysmon_process.command('single', cls=Command)
-@click.option('-a', '--attributes', multiple=True,
-              help='filter processes by given attribute value given as key=value')
+@sysmon_process.command("single", cls=Command)
+@click.option("-a", "--attributes", multiple=True, help="filter processes by given attribute value given as key=value")
 def sysmon_process_single(service_provider: LockdownClient, attributes: list[str]):
-    """ show a single snapshot of currently running processes. """
+    """show a single snapshot of currently running processes."""
 
     count = 0
 
@@ -376,7 +401,7 @@ def sysmon_process_single(service_provider: LockdownClient, attributes: list[str
                     skip = False
                     if attributes is not None:
                         for filter_attr in attributes:
-                            filter_attr, filter_value = filter_attr.split('=')
+                            filter_attr, filter_value = filter_attr.split("=")
                             if str(process[filter_attr]) != filter_value:
                                 skip = True
                                 break
@@ -385,7 +410,7 @@ def sysmon_process_single(service_provider: LockdownClient, attributes: list[str
                         continue
 
                     # adding "artificially" the execName field
-                    process['execName'] = device_info.execname_for_pid(process['pid'])
+                    process["execName"] = device_info.execname_for_pid(process["pid"])
                     result.append(process)
 
                 # exit after single snapshot
@@ -393,13 +418,13 @@ def sysmon_process_single(service_provider: LockdownClient, attributes: list[str
     print_json(result)
 
 
-@sysmon.command('system', cls=Command)
-@click.option('-f', '--fields', help='field names splitted by ",".')
+@sysmon.command("system", cls=Command)
+@click.option("-f", "--fields", help='field names splitted by ",".')
 def sysmon_system(service_provider: LockdownClient, fields):
-    """ show current system stats. """
+    """show current system stats."""
 
     if fields is not None:
-        fields = fields.split(',')
+        fields = fields.split(",")
 
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         sysmontap = Sysmontap(dvt)
@@ -409,16 +434,17 @@ def sysmon_system(service_provider: LockdownClient, fields):
             system_usage_seen = False  # Tracks if the first occurrence of SystemCPUUsage
 
             for row in sysmon:
-                if 'System' in row and system is None:
-                    system = sysmon.system_attributes_cls(*row['System'])
+                if "System" in row and system is None:
+                    system = sysmon.system_attributes_cls(*row["System"])
 
-                if 'SystemCPUUsage' in row:
+                if "SystemCPUUsage" in row:
                     if system_usage_seen:
                         system_usage = {
-                            **row['SystemCPUUsage'], **{
-                                'CPUCount': row['CPUCount'],
-                                'EnabledCPUs': row['EnabledCPUs'],
-                            }
+                            **row["SystemCPUUsage"],
+                            **{
+                                "CPUCount": row["CPUCount"],
+                                "EnabledCPUs": row["EnabledCPUs"],
+                            },
                         }
                     else:  # Ignore the first occurrence because first occurrence always gives a incorrect value - 100 or 0
                         system_usage_seen = True
@@ -429,19 +455,21 @@ def sysmon_system(service_provider: LockdownClient, fields):
     attrs_dict = {**asdict(system), **system_usage}
     for name, value in attrs_dict.items():
         if (fields is None) or (name in fields):
-            print(f'{name}: {value}')
+            print(f"{name}: {value}")
 
 
-@dvt.group('core-profile-session')
+@dvt.group("core-profile-session")
 def core_profile_session():
-    """ Access tailspin features """
+    """Access tailspin features"""
 
 
-bsc_filter = click.option('--bsc/--no-bsc', default=False, help='Whether to print BSC events or not.')
-class_filter = click.option('-cf', '--class-filters', multiple=True, type=BASED_INT,
-                            help='Events class filter. Omit for all.')
-subclass_filter = click.option('-sf', '--subclass-filters', multiple=True, type=BASED_INT,
-                               help='Events subclass filter. Omit for all.')
+bsc_filter = click.option("--bsc/--no-bsc", default=False, help="Whether to print BSC events or not.")
+class_filter = click.option(
+    "-cf", "--class-filters", multiple=True, type=BASED_INT, help="Events class filter. Omit for all."
+)
+subclass_filter = click.option(
+    "-sf", "--subclass-filters", multiple=True, type=BASED_INT, help="Events subclass filter. Omit for all."
+)
 
 
 def parse_filters(subclasses: list[int], classes: list[int]):
@@ -455,30 +483,42 @@ def parse_filters(subclasses: list[int], classes: list[int]):
     for class_ in classes:
         if class_ == BSC_CLASS:
             parsed |= VFS_AND_TRACES_SET
-        parsed.add((class_ << 24) | 0x00ff0000)
+        parsed.add((class_ << 24) | 0x00FF0000)
     return parsed
 
 
-@core_profile_session.command('live', cls=Command)
-@click.option('-c', '--count', type=click.INT, default=-1, help='Number of events to print. Omit to endless sniff.')
+@core_profile_session.command("live", cls=Command)
+@click.option("-c", "--count", type=click.INT, default=-1, help="Number of events to print. Omit to endless sniff.")
 @bsc_filter
 @class_filter
 @subclass_filter
-@click.option('--tid', type=click.INT, default=None, help='Thread ID to filter. Omit for all.')
-@click.option('--timestamp/--no-timestamp', default=True, help='Whether to print timestamp or not.')
-@click.option('--event-name/--no-event-name', default=True, help='Whether to print event name or not.')
-@click.option('--func-qual/--no-func-qual', default=True, help='Whether to print function qualifier or not.')
-@click.option('--show-tid/--no-show-tid', default=True, help='Whether to print thread id or not.')
-@click.option('--process-name/--no-process-name', default=True, help='Whether to print process name or not.')
-@click.option('--args/--no-args', default=True, help='Whether to print event arguments or not.')
-def live_profile_session(service_provider: LockdownClient, count, bsc, class_filters, subclass_filters, tid, timestamp,
-                         event_name, func_qual, show_tid, process_name, args):
-    """ Print kevents received from the device in real time. """
+@click.option("--tid", type=click.INT, default=None, help="Thread ID to filter. Omit for all.")
+@click.option("--timestamp/--no-timestamp", default=True, help="Whether to print timestamp or not.")
+@click.option("--event-name/--no-event-name", default=True, help="Whether to print event name or not.")
+@click.option("--func-qual/--no-func-qual", default=True, help="Whether to print function qualifier or not.")
+@click.option("--show-tid/--no-show-tid", default=True, help="Whether to print thread id or not.")
+@click.option("--process-name/--no-process-name", default=True, help="Whether to print process name or not.")
+@click.option("--args/--no-args", default=True, help="Whether to print event arguments or not.")
+def live_profile_session(
+    service_provider: LockdownClient,
+    count,
+    bsc,
+    class_filters,
+    subclass_filters,
+    tid,
+    timestamp,
+    event_name,
+    func_qual,
+    show_tid,
+    process_name,
+    args,
+):
+    """Print kevents received from the device in real time."""
 
     parser = PyKdebugParser()
     parser.filter_class = class_filters
     if bsc:
-        subclass_filters = list(subclass_filters) + [BSC_SUBCLASS]
+        subclass_filters = [*list(subclass_filters), BSC_SUBCLASS]
     parser.filter_subclass = subclass_filters
     filters = parse_filters(subclass_filters, class_filters)
     parser.filter_tid = tid
@@ -491,78 +531,75 @@ def live_profile_session(service_provider: LockdownClient, count, bsc, class_fil
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         trace_codes_map = DeviceInfo(dvt).trace_codes()
         time_config = CoreProfileSessionTap.get_time_config(dvt)
-        parser.numer = time_config['numer']
-        parser.denom = time_config['denom']
-        parser.mach_absolute_time = time_config['mach_absolute_time']
-        parser.usecs_since_epoch = time_config['usecs_since_epoch']
-        parser.timezone = time_config['timezone']
+        parser.numer = time_config["numer"]
+        parser.denom = time_config["denom"]
+        parser.mach_absolute_time = time_config["mach_absolute_time"]
+        parser.usecs_since_epoch = time_config["usecs_since_epoch"]
+        parser.timezone = time_config["timezone"]
         with CoreProfileSessionTap(dvt, time_config, filters) as tap:
-            i = 0
-            for event in parser.formatted_kevents(tap.get_kdbuf_stream(), trace_codes_map):
+            for i, event in enumerate(parser.formatted_kevents(tap.get_kdbuf_stream(), trace_codes_map)):
                 print(event)
-                i += 1
                 if i == count:
                     break
 
 
-@core_profile_session.command('save', cls=Command)
-@click.argument('out', type=click.File('wb'))
+@core_profile_session.command("save", cls=Command)
+@click.argument("out", type=click.File("wb"))
 @bsc_filter
 @class_filter
 @subclass_filter
 def save_profile_session(service_provider: LockdownClient, out, bsc, class_filters, subclass_filters):
-    """ Dump core profiling information. """
+    """Dump core profiling information."""
     if bsc:
-        subclass_filters = list(subclass_filters) + [BSC_SUBCLASS]
+        subclass_filters = [*list(subclass_filters), BSC_SUBCLASS]
     filters = parse_filters(subclass_filters, class_filters)
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with CoreProfileSessionTap(dvt, {}, filters) as tap:
-            tap.dump(out)
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, CoreProfileSessionTap(dvt, {}, filters) as tap:
+        tap.dump(out)
 
 
-@core_profile_session.command('stackshot', cls=Command)
-@click.option('--out', type=click.File('w'), default=None)
+@core_profile_session.command("stackshot", cls=Command)
+@click.option("--out", type=click.File("w"), default=None)
 def stackshot(service_provider: LockdownClient, out):
-    """ Dump stackshot information. """
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with CoreProfileSessionTap(dvt, {}) as tap:
-            try:
-                data = tap.get_stackshot()
-            except ExtractingStackshotError:
-                logger.error(f'Extracting stackshot failed')
-                return
-
-            if out is not None:
-                json.dump(data, out, indent=4, default=default_json_encoder)
-            else:
-                print_json(data)
+    """Dump stackshot information."""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, CoreProfileSessionTap(dvt, {}) as tap:
+        try:
+            data = tap.get_stackshot()
+        except ExtractingStackshotError:
+            logger.exception("Extracting stackshot failed")
+            return
+
+        if out is not None:
+            json.dump(data, out, indent=4, default=default_json_encoder)
+        else:
+            print_json(data)
 
 
-@core_profile_session.command('parse-live', cls=Command)
-@click.option('-c', '--count', type=click.INT, default=-1, help='Number of events to print. Omit to endless sniff.')
-@click.option('--tid', type=click.INT, default=None, help='Thread ID to filter. Omit for all.')
-@click.option('--show-tid/--no-show-tid', default=False, help='Whether to print thread id or not.')
+@core_profile_session.command("parse-live", cls=Command)
+@click.option("-c", "--count", type=click.INT, default=-1, help="Number of events to print. Omit to endless sniff.")
+@click.option("--tid", type=click.INT, default=None, help="Thread ID to filter. Omit for all.")
+@click.option("--show-tid/--no-show-tid", default=False, help="Whether to print thread id or not.")
 @bsc_filter
 @class_filter
 @subclass_filter
-@click.option('--process', default=None, help='Process ID / name to filter. Omit for all.')
-def parse_live_profile_session(service_provider: LockdownClient, count, tid, show_tid, bsc, class_filters,
-                               subclass_filters, process):
-    """ Print traces (syscalls, thread events, etc.) received from the device in real time. """
+@click.option("--process", default=None, help="Process ID / name to filter. Omit for all.")
+def parse_live_profile_session(
+    service_provider: LockdownClient, count, tid, show_tid, bsc, class_filters, subclass_filters, process
+):
+    """Print traces (syscalls, thread events, etc.) received from the device in real time."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        print('Receiving time information')
+        print("Receiving time information")
         time_config = CoreProfileSessionTap.get_time_config(dvt)
         parser = PyKdebugParser()
         parser.filter_class = list(class_filters)
         if bsc:
-            subclass_filters = list(subclass_filters) + [BSC_SUBCLASS]
+            subclass_filters = [*list(subclass_filters), BSC_SUBCLASS]
         parser.filter_subclass = subclass_filters
         filters = parse_filters(subclass_filters, class_filters)
-        parser.numer = time_config['numer']
-        parser.denom = time_config['denom']
-        parser.mach_absolute_time = time_config['mach_absolute_time']
-        parser.usecs_since_epoch = time_config['usecs_since_epoch']
-        parser.timezone = time_config['timezone']
+        parser.numer = time_config["numer"]
+        parser.denom = time_config["denom"]
+        parser.mach_absolute_time = time_config["mach_absolute_time"]
+        parser.usecs_since_epoch = time_config["usecs_since_epoch"]
+        parser.timezone = time_config["timezone"]
         parser.filter_tid = tid
         parser.filter_process = process
         parser.show_tid = show_tid
@@ -570,14 +607,12 @@ def parse_live_profile_session(service_provider: LockdownClient, count, tid, sho
 
         with CoreProfileSessionTap(dvt, time_config, filters) as tap:
             if show_tid:
-                print('{:^32}|{:^11}|{:^33}|   Event'.format('Time', 'Thread', 'Process'))
+                print("{:^32}|{:^11}|{:^33}|   Event".format("Time", "Thread", "Process"))
             else:
-                print('{:^32}|{:^33}|   Event'.format('Time', 'Process'))
+                print("{:^32}|{:^33}|   Event".format("Time", "Process"))
 
-            i = 0
-            for trace in parser.formatted_traces(tap.get_kdbuf_stream()):
+            for i, trace in enumerate(parser.formatted_traces(tap.get_kdbuf_stream())):
                 print(trace, flush=True)
-                i += 1
                 if i == count:
                     break
 
@@ -594,152 +629,150 @@ def get_image_name(dsc_uuid_map, image_uuid, current_dsc_map):
 def format_callstack(callstack, dsc_uuid_map, current_dsc_map):
     lines = callstack.splitlines()
     for i, line in enumerate(lines[1:]):
-        if ':' in line:
-            uuid = line.split(':')[0].strip()
+        if ":" in line:
+            uuid = line.split(":")[0].strip()
             lines[i + 1] = line.replace(uuid, get_image_name(dsc_uuid_map, uuid, current_dsc_map))
-    return '\n'.join(lines)
+    return "\n".join(lines)
 
 
-@core_profile_session.command('callstacks-live', cls=Command)
-@click.option('-c', '--count', type=click.INT, default=-1, help='Number of events to print. Omit to endless sniff.')
-@click.option('--process', default=None, help='Process to filter. Omit for all.')
-@click.option('--tid', type=click.INT, default=None, help='Thread ID to filter. Omit for all.')
-@click.option('--show-tid/--no-show-tid', default=False, help='Whether to print thread id or not.')
+@core_profile_session.command("callstacks-live", cls=Command)
+@click.option("-c", "--count", type=click.INT, default=-1, help="Number of events to print. Omit to endless sniff.")
+@click.option("--process", default=None, help="Process to filter. Omit for all.")
+@click.option("--tid", type=click.INT, default=None, help="Thread ID to filter. Omit for all.")
+@click.option("--show-tid/--no-show-tid", default=False, help="Whether to print thread id or not.")
 def callstacks_live_profile_session(service_provider: LockdownClient, count, process, tid, show_tid):
-    """ Print callstacks received from the device in real time. """
+    """Print callstacks received from the device in real time."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        print('Receiving time information')
+        print("Receiving time information")
         time_config = CoreProfileSessionTap.get_time_config(dvt)
         parser = PyKdebugParser()
-        parser.numer = time_config['numer']
-        parser.denom = time_config['denom']
-        parser.mach_absolute_time = time_config['mach_absolute_time']
-        parser.usecs_since_epoch = time_config['usecs_since_epoch']
-        parser.timezone = time_config['timezone']
+        parser.numer = time_config["numer"]
+        parser.denom = time_config["denom"]
+        parser.mach_absolute_time = time_config["mach_absolute_time"]
+        parser.usecs_since_epoch = time_config["usecs_since_epoch"]
+        parser.timezone = time_config["timezone"]
         parser.filter_tid = tid
         parser.filter_process = process
         parser.color = user_requested_colored_output()
         parser.show_tid = show_tid
 
-        with open(os.path.join(pymobiledevice3.__path__[0], 'resources', 'dsc_uuid_map.json')) as fd:
+        with open(os.path.join(pymobiledevice3.__path__[0], "resources", "dsc_uuid_map.json")) as fd:
             dsc_uuid_map = json.load(fd)
 
         current_dsc_map = {}
         with CoreProfileSessionTap(dvt, time_config) as tap:
-            i = 0
-            for callstack in parser.formatted_callstacks(tap.get_kdbuf_stream()):
+            for i, callstack in enumerate(parser.formatted_callstacks(tap.get_kdbuf_stream())):
                 print(format_callstack(callstack, dsc_uuid_map, current_dsc_map))
-                i += 1
                 if i == count:
                     break
 
 
-@dvt.command('trace-codes', cls=Command)
+@dvt.command("trace-codes", cls=Command)
 def dvt_trace_codes(service_provider: LockdownClient):
-    """ Print KDebug trace codes. """
+    """Print KDebug trace codes."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         device_info = DeviceInfo(dvt)
         print_json({hex(k): v for k, v in device_info.trace_codes().items()})
 
 
-@dvt.command('name-for-uid', cls=Command)
-@click.argument('uid', type=click.INT)
+@dvt.command("name-for-uid", cls=Command)
+@click.argument("uid", type=click.INT)
 def dvt_name_for_uid(service_provider: LockdownClient, uid):
-    """ Print the assiciated username for the given uid. """
+    """Print the assiciated username for the given uid."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         device_info = DeviceInfo(dvt)
         print(device_info.name_for_uid(uid))
 
 
-@dvt.command('name-for-gid', cls=Command)
-@click.argument('gid', type=click.INT)
+@dvt.command("name-for-gid", cls=Command)
+@click.argument("gid", type=click.INT)
 def dvt_name_for_gid(service_provider: LockdownClient, gid):
-    """ Print the assiciated group name for the given gid. """
+    """Print the assiciated group name for the given gid."""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         device_info = DeviceInfo(dvt)
         print(device_info.name_for_gid(gid))
 
 
-@dvt.command('oslog', cls=Command)
-@click.option('--pid', type=click.INT)
+@dvt.command("oslog", cls=Command)
+@click.option("--pid", type=click.INT)
 def dvt_oslog(service_provider: LockdownClient, pid):
-    """ Sniff device oslog (not very stable, but includes more data and normal syslog) """
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with ActivityTraceTap(dvt) as tap:
-            for message in tap:
-                message_pid = message.process
-                # without message_type maybe signpost have event_type
-                message_type = message.message_type if hasattr(message, 'message_type') else message.event_type \
-                    if hasattr(message, 'event_type') else 'unknown'
-                sender_image_path = message.sender_image_path
-                image_name = os.path.basename(sender_image_path)
-                subsystem = message.subsystem
-                category = message.category
-                timestamp = datetime.now()
-
-                if pid is not None and message_pid != pid:
-                    continue
-
-                if message.message:
-                    formatted_message = decode_message_format(message.message)
-                else:
-                    formatted_message = message.name
-
-                if user_requested_colored_output():
-                    timestamp = click.style(str(timestamp), bold=True)
-                    message_pid = click.style(str(message_pid), 'magenta')
-                    subsystem = click.style(subsystem, 'green')
-                    category = click.style(category, 'green')
-                    image_name = click.style(image_name, 'yellow')
-                    message_type = click.style(message_type, 'cyan')
-
-                print(f'[{timestamp}][{subsystem}][{category}][{message_pid}][{image_name}] '
-                      f'<{message_type}>: {formatted_message}')
+    """Sniff device oslog (not very stable, but includes more data and normal syslog)"""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, ActivityTraceTap(dvt) as tap:
+        for message in tap:
+            message_pid = message.process
+            # without message_type maybe signpost have event_type
+            message_type = (
+                message.message_type
+                if hasattr(message, "message_type")
+                else message.event_type
+                if hasattr(message, "event_type")
+                else "unknown"
+            )
+            sender_image_path = message.sender_image_path
+            image_name = os.path.basename(sender_image_path)
+            subsystem = message.subsystem
+            category = message.category
+            timestamp = datetime.now()
+
+            if pid is not None and message_pid != pid:
+                continue
+
+            formatted_message = decode_message_format(message.message) if message.message else message.name
+
+            if user_requested_colored_output():
+                timestamp = click.style(str(timestamp), bold=True)
+                message_pid = click.style(str(message_pid), "magenta")
+                subsystem = click.style(subsystem, "green")
+                category = click.style(category, "green")
+                image_name = click.style(image_name, "yellow")
+                message_type = click.style(message_type, "cyan")
+
+            print(
+                f"[{timestamp}][{subsystem}][{category}][{message_pid}][{image_name}] "
+                f"<{message_type}>: {formatted_message}"
+            )
 
 
-@dvt.command('energy', cls=Command)
-@click.argument('pid-list', nargs=-1)
+@dvt.command("energy", cls=Command)
+@click.argument("pid-list", nargs=-1)
 def dvt_energy(service_provider: LockdownClient, pid_list):
-    """ Monitor the energy consumption for given PIDs """
+    """Monitor the energy consumption for given PIDs"""
 
     if len(pid_list) == 0:
-        logger.error('pid_list must not be empty')
+        logger.error("pid_list must not be empty")
         return
 
     pid_list = [int(pid) for pid in pid_list]
 
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with EnergyMonitor(dvt, pid_list) as energy_monitor:
-            for telemetry in energy_monitor:
-                logger.info(telemetry)
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, EnergyMonitor(dvt, pid_list) as energy_monitor:
+        for telemetry in energy_monitor:
+            logger.info(telemetry)
 
 
-@dvt.command('notifications', cls=Command)
+@dvt.command("notifications", cls=Command)
 def dvt_notifications(service_provider: LockdownClient):
-    """ Monitor memory and app notifications """
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with Notifications(dvt) as notifications:
-            for notification in notifications:
-                logger.info(notification)
+    """Monitor memory and app notifications"""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, Notifications(dvt) as notifications:
+        for notification in notifications:
+            logger.info(notification)
 
 
-@dvt.command('graphics', cls=Command)
-def dvt_notifications(service_provider: LockdownClient):
-    """ Monitor graphics-related information """
-    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        with Graphics(dvt) as graphics:
-            for stats in graphics:
-                logger.info(stats)
+@dvt.command("graphics", cls=Command)
+def dvt_graphics(service_provider: LockdownClient):
+    """Monitor graphics-related information"""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, Graphics(dvt) as graphics:
+        for stats in graphics:
+            logger.info(stats)
 
 
-@developer.group('fetch-symbols')
+@developer.group("fetch-symbols")
 def fetch_symbols():
-    """ Download the DSC (and dyld) from the device """
+    """Download the DSC (and dyld) from the device"""
     pass
 
 
 async def fetch_symbols_list_task(service_provider: LockdownServiceProvider) -> None:
-    if Version(service_provider.product_version) < Version('17.0'):
+    if Version(service_provider.product_version) < Version("17.0"):
         print_json(DtFetchSymbols(service_provider).list_files())
     else:
         if not isinstance(service_provider, RemoteServiceDiscoveryService):
@@ -749,9 +782,9 @@ async def fetch_symbols_list_task(service_provider: LockdownServiceProvider) ->
             print_json([f.file_path for f in await fetch_symbols.get_dsc_file_list()])
 
 
-@fetch_symbols.command('list', cls=Command)
+@fetch_symbols.command("list", cls=Command)
 def fetch_symbols_list(service_provider: LockdownServiceProvider) -> None:
-    """ list of files to be downloaded """
+    """list of files to be downloaded"""
     asyncio.run(fetch_symbols_list_task(service_provider), debug=True)
 
 
@@ -759,14 +792,14 @@ async def fetch_symbols_download_task(service_provider: LockdownServiceProvider,
     out = Path(out)
     out.mkdir(parents=True, exist_ok=True)
 
-    if Version(service_provider.product_version) < Version('17.0'):
+    if Version(service_provider.product_version) < Version("17.0"):
         fetch_symbols = DtFetchSymbols(service_provider)
         files = fetch_symbols.list_files()
 
         downloaded_files = set()
 
         for i, file in enumerate(files):
-            if file.startswith('/'):
+            if file.startswith("/"):
                 # trim root to allow relative download
                 file = file[1:]
             file = out / file
@@ -777,9 +810,9 @@ async def fetch_symbols_download_task(service_provider: LockdownServiceProvider,
 
             downloaded_files.add(file)
             file.parent.mkdir(parents=True, exist_ok=True)
-            with open(file, 'ab') as f:
+            with open(file, "ab") as f:
                 # same file may appear twice, so we'll need to append data into it
-                logger.info(f'writing to: {file}')
+                logger.info(f"writing to: {file}")
                 fetch_symbols.get_file(i, f)
     else:
         if not isinstance(service_provider, RemoteServiceDiscoveryService):
@@ -788,28 +821,28 @@ async def fetch_symbols_download_task(service_provider: LockdownServiceProvider,
             await fetch_symbols.download(out)
 
 
-@fetch_symbols.command('download', cls=Command)
-@click.argument('out', type=click.Path(dir_okay=True, file_okay=False))
+@fetch_symbols.command("download", cls=Command)
+@click.argument("out", type=click.Path(dir_okay=True, file_okay=False))
 def fetch_symbols_download(service_provider: LockdownServiceProvider, out: str) -> None:
-    """ download the linker and dyld cache to a specified directory """
+    """download the linker and dyld cache to a specified directory"""
     asyncio.run(fetch_symbols_download_task(service_provider, out), debug=True)
 
 
-@developer.group('simulate-location')
+@developer.group("simulate-location")
 def simulate_location():
-    """ Simulate device location by given input """
+    """Simulate device location by given input"""
     pass
 
 
-@simulate_location.command('clear', cls=Command)
+@simulate_location.command("clear", cls=Command)
 def simulate_location_clear(service_provider: LockdownClient):
-    """ clear simulated location """
+    """clear simulated location"""
     DtSimulateLocation(service_provider).clear()
 
 
-@simulate_location.command('set', cls=Command)
-@click.argument('latitude', type=click.FLOAT)
-@click.argument('longitude', type=click.FLOAT)
+@simulate_location.command("set", cls=Command)
+@click.argument("latitude", type=click.FLOAT)
+@click.argument("longitude", type=click.FLOAT)
 def simulate_location_set(service_provider: LockdownClient, latitude, longitude):
     """
     set a simulated location.
@@ -819,58 +852,58 @@ def simulate_location_set(service_provider: LockdownClient, latitude, longitude)
     DtSimulateLocation(service_provider).set(latitude, longitude)
 
 
-@simulate_location.command('play', cls=Command)
-@click.argument('filename', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('timing_randomness_range', type=click.INT)
-@click.option('--disable-sleep', is_flag=True, default=False)
+@simulate_location.command("play", cls=Command)
+@click.argument("filename", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("timing_randomness_range", type=click.INT)
+@click.option("--disable-sleep", is_flag=True, default=False)
 def simulate_location_play(service_provider: LockdownClient, filename, timing_randomness_range, disable_sleep):
-    """ play a .gpx file """
+    """play a .gpx file"""
     DtSimulateLocation(service_provider).play_gpx_file(filename, timing_randomness_range, disable_sleep=disable_sleep)
 
 
-@developer.group('accessibility')
+@developer.group("accessibility")
 def accessibility():
-    """ Interact with accessibility-related features """
+    """Interact with accessibility-related features"""
     pass
 
 
-@accessibility.command('run-audit', cls=Command)
-@click.argument('test_types', nargs=-1)
+@accessibility.command("run-audit", cls=Command)
+@click.argument("test_types", nargs=-1)
 def accessibility_run_audit(service_provider: LockdownServiceProvider, test_types):
-    """ runs accessibility audit tests """
+    """runs accessibility audit tests"""
     param = list(test_types)
     audit_issues = AccessibilityAudit(service_provider).run_audit(param)
     print_json([audit_issue.json() for audit_issue in audit_issues], False)
 
 
-@accessibility.command('supported-audit-types', cls=Command)
+@accessibility.command("supported-audit-types", cls=Command)
 def accessibility_supported_audit_types(service_provider: LockdownServiceProvider):
-    """ lists supported accessibility audit test types """
+    """lists supported accessibility audit test types"""
     print_json(AccessibilityAudit(service_provider).supported_audits_types())
 
 
-@accessibility.command('capabilities', cls=Command)
+@accessibility.command("capabilities", cls=Command)
 def accessibility_capabilities(service_provider: LockdownClient):
-    """ display accessibility capabilities """
+    """display accessibility capabilities"""
     print_json(AccessibilityAudit(service_provider).capabilities)
 
 
-@accessibility.group('settings')
+@accessibility.group("settings")
 def accessibility_settings():
-    """ accessibility settings. """
+    """accessibility settings."""
     pass
 
 
-@accessibility_settings.command('show', cls=Command)
+@accessibility_settings.command("show", cls=Command)
 def accessibility_settings_show(service_provider: LockdownClient):
-    """ show current settings """
+    """show current settings"""
     for setting in AccessibilityAudit(service_provider).settings:
         print(setting)
 
 
-@accessibility_settings.command('set', cls=Command)
-@click.argument('setting')
-@click.argument('value')
+@accessibility_settings.command("set", cls=Command)
+@click.argument("setting")
+@click.argument("value")
 def accessibility_settings_set(service_provider: LockdownClient, setting, value):
     """
     change current settings
@@ -882,7 +915,7 @@ def accessibility_settings_set(service_provider: LockdownClient, setting, value)
     OSUTILS.wait_return()
 
 
-@accessibility_settings.command('reset', cls=Command)
+@accessibility_settings.command("reset", cls=Command)
 def accessibility_settings_reset(service_provider: LockdownClient):
     """
     reset accessibility settings to default
@@ -891,25 +924,27 @@ def accessibility_settings_reset(service_provider: LockdownClient):
     service.reset_settings()
 
 
-@accessibility.command('shell', cls=Command)
+@accessibility.command("shell", cls=Command)
 def accessibility_shell(service_provider: LockdownClient):
-    """ start and ipython accessibility shell """
+    """start and ipython accessibility shell"""
     AccessibilityAudit(service_provider).shell()
 
 
-@accessibility.command('notifications', cls=Command)
+@accessibility.command("notifications", cls=Command)
 def accessibility_notifications(service_provider: LockdownClient):
-    """ show notifications """
+    """show notifications"""
 
     service = AccessibilityAudit(service_provider)
     for event in service.iter_events():
-        if event.name in ('hostAppStateChanged:',
-                          'hostInspectorCurrentElementChanged:',):
+        if event.name in (
+            "hostAppStateChanged:",
+            "hostInspectorCurrentElementChanged:",
+        ):
             for focus_item in event.data:
                 logger.info(focus_item)
 
 
-@accessibility.command('list-items', cls=Command)
+@accessibility.command("list-items", cls=Command)
 def accessibility_list_items(service_provider: LockdownClient):
     """List elements available in the currently shown menu."""
 
@@ -920,56 +955,56 @@ def accessibility_list_items(service_provider: LockdownClient):
     print_json(elements)
 
 
-@developer.group('condition')
+@developer.group("condition")
 def condition():
-    """ Force a predefined condition """
+    """Force a predefined condition"""
     pass
 
 
-@condition.command('list', cls=Command)
+@condition.command("list", cls=Command)
 def condition_list(service_provider: LockdownServiceProvider) -> None:
-    """ list all available conditions """
+    """list all available conditions"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         print_json(ConditionInducer(dvt).list())
 
 
-@condition.command('clear', cls=Command)
+@condition.command("clear", cls=Command)
 def condition_clear(service_provider: LockdownClient):
-    """ clear current condition """
+    """clear current condition"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         ConditionInducer(dvt).clear()
 
 
-@condition.command('set', cls=Command)
-@click.argument('profile_identifier')
+@condition.command("set", cls=Command)
+@click.argument("profile_identifier")
 def condition_set(service_provider: LockdownClient, profile_identifier):
-    """ set a specific condition """
+    """set a specific condition"""
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
         ConditionInducer(dvt).set(profile_identifier)
         OSUTILS.wait_return()
 
 
 @developer.command(cls=Command)
-@click.argument('out', type=click.File('wb'))
+@click.argument("out", type=click.File("wb"))
 def screenshot(service_provider: LockdownClient, out):
-    """ Take a screenshot in PNG format """
+    """Take a screenshot in PNG format"""
     out.write(ScreenshotService(lockdown=service_provider).take_screenshot())
 
 
-@developer.group('debugserver')
+@developer.group("debugserver")
 def debugserver():
-    """ Interact with debugserver """
+    """Interact with debugserver"""
     pass
 
 
-@debugserver.command('applist', cls=Command)
+@debugserver.command("applist", cls=Command)
 def debugserver_applist(service_provider: LockdownClient):
-    """ Get applist xml """
+    """Get applist xml"""
     print_json(DebugServerAppList(service_provider).get())
 
 
-@debugserver.command('start-server', cls=Command)
-@click.argument('local_port', type=click.INT, required=False)
+@debugserver.command("start-server", cls=Command)
+@click.argument("local_port", type=click.INT, required=False)
 def debugserver_start_server(service_provider: LockdownClient, local_port: Optional[int] = None):
     """
     if local_port is provided, start a debugserver at remote listening on a given port locally.
@@ -979,17 +1014,17 @@ def debugserver_start_server(service_provider: LockdownClient, local_port: Optio
     This can be done using the following commands within lldb shell.
     """
 
-    if Version(service_provider.product_version) < Version('17.0'):
-        service_name = 'com.apple.debugserver.DVTSecureSocketProxy'
+    if Version(service_provider.product_version) < Version("17.0"):
+        service_name = "com.apple.debugserver.DVTSecureSocketProxy"
     else:
-        service_name = 'com.apple.internal.dt.remote.debugproxy'
+        service_name = "com.apple.internal.dt.remote.debugproxy"
 
     if local_port is not None:
-        print(DEBUGSERVER_CONNECTION_STEPS.format(host='127.0.0.1', port=local_port))
-        print('Started port forwarding. Press Ctrl-C to close this shell when done')
+        print(DEBUGSERVER_CONNECTION_STEPS.format(host="127.0.0.1", port=local_port))
+        print("Started port forwarding. Press Ctrl-C to close this shell when done")
         sys.stdout.flush()
         LockdownTcpForwarder(service_provider, local_port, service_name).start()
-    elif Version(service_provider.product_version) >= Version('17.0'):
+    elif Version(service_provider.product_version) >= Version("17.0"):
         if not isinstance(service_provider, RemoteServiceDiscoveryService):
             raise RSDRequiredError(service_provider.identifier)
         debugserver_port = service_provider.get_service_port(service_name)
@@ -998,21 +1033,21 @@ def debugserver_start_server(service_provider: LockdownClient, local_port: Optio
         print("local_port is required for iOS < 17.0")
 
 
-@debugserver.command('lldb', cls=RSDCommand)
-@click.argument('xcodeproj_path', type=click.Path(exists=True, file_okay=False, dir_okay=True))
-@click.option('--configuration', default='Debug', help='Usually Release/Debug')
-@click.option('--lldb-command', default='lldb')
-@click.option('--launch', is_flag=True, default=False, help='Launch the app after connecting to lldb')
-@click.option('breakpoints', '-b', '--break', multiple=True, help='Add multiple startup breakpoints')
-@click.option('user_commands', '--command', '-c', multiple=True, help='Additional commands to run at startup')
+@debugserver.command("lldb", cls=RSDCommand)
+@click.argument("xcodeproj_path", type=click.Path(exists=True, file_okay=False, dir_okay=True))
+@click.option("--configuration", default="Debug", help="Usually Release/Debug")
+@click.option("--lldb-command", default="lldb")
+@click.option("--launch", is_flag=True, default=False, help="Launch the app after connecting to lldb")
+@click.option("breakpoints", "-b", "--break", multiple=True, help="Add multiple startup breakpoints")
+@click.option("user_commands", "--command", "-c", multiple=True, help="Additional commands to run at startup")
 def debugserver_lldb(
-        service_provider: LockdownServiceProvider,
-        xcodeproj_path: str,
-        configuration: str,
-        lldb_command: str,
-        launch: bool,
-        breakpoints: tuple[str],
-        user_commands: tuple[str],
+    service_provider: LockdownServiceProvider,
+    xcodeproj_path: str,
+    configuration: str,
+    lldb_command: str,
+    launch: bool,
+    breakpoints: tuple[str],
+    user_commands: tuple[str],
 ) -> None:
     """
     Automate lldb launch for a given xcodeproj.
@@ -1027,49 +1062,49 @@ def debugserver_lldb(
     - Execute any additional commands if requested
     - Switch to lldb shell
     """
-    if Version(service_provider.product_version) < Version('17.0'):
-        logger.error('lldb is only supported on iOS >= 17.0')
+    if Version(service_provider.product_version) < Version("17.0"):
+        logger.error("lldb is only supported on iOS >= 17.0")
         return
 
     commands = []
     xcodeproj_path = Path(xcodeproj_path)
     with local.cwd(xcodeproj_path.parent):
-        logger.info(f'Building {xcodeproj_path} for {configuration} configuration')
-        local['xcodebuild']['-configuration', configuration, 'build']()
-        local_app = list(Path(f'build/{configuration}-iphoneos').glob('*.app'))[0]
-        logger.info(f'Using app: {local_app}')
+        logger.info(f"Building {xcodeproj_path} for {configuration} configuration")
+        local["xcodebuild"]["-configuration", configuration, "build"]()
+        local_app = next(iter(Path(f"build/{configuration}-iphoneos").glob("*.app")))
+        logger.info(f"Using app: {local_app}")
 
-        info_plist_path = local_app / 'Info.plist'
+        info_plist_path = local_app / "Info.plist"
         info_plist = plistlib.loads(info_plist_path.read_bytes())
-        bundle_identifier = info_plist['CFBundleIdentifier']
-        logger.info(f'Bundle identifier: {bundle_identifier}')
+        bundle_identifier = info_plist["CFBundleIdentifier"]
+        logger.info(f"Bundle identifier: {bundle_identifier}")
 
-        commands.append('platform select remote-ios')
+        commands.append("platform select remote-ios")
         commands.append(f'target create "{local_app.absolute()}"')
 
         with InstallationProxyService(create_using_usbmux()) as installation_proxy:
-            logger.info('Installing app')
+            logger.info("Installing app")
             installation_proxy.install_from_local(local_app)
-            remote_path = installation_proxy.get_apps(bundle_identifiers=[bundle_identifier])[bundle_identifier]['Path']
-            logger.info(f'Remote path: {remote_path}')
+            remote_path = installation_proxy.get_apps(bundle_identifiers=[bundle_identifier])[bundle_identifier]["Path"]
+            logger.info(f"Remote path: {remote_path}")
 
         commands.append(f'script lldb.target.module[0].SetPlatformFileSpec(lldb.SBFileSpec("{remote_path}"))')
 
-        debugserver_port = service_provider.get_service_port('com.apple.internal.dt.remote.debugproxy')
+        debugserver_port = service_provider.get_service_port("com.apple.internal.dt.remote.debugproxy")
 
         # Add connection and launch commands
-        commands.append(f'process connect connect://[{service_provider.service.address[0]}]:{debugserver_port}')
+        commands.append(f"process connect connect://[{service_provider.service.address[0]}]:{debugserver_port}")
 
-        for breakpoint in breakpoints:
-            commands.append(f'breakpoint set -n "{breakpoint}"')
+        for bp in breakpoints:
+            commands.append(f'breakpoint set -n "{bp}"')
 
         if launch:
-            commands.append('process launch')
+            commands.append("process launch")
 
         # Add user commands
         commands += user_commands
 
-        logger.info(f'Starting lldb with automated setup and connection')
+        logger.info("Starting lldb with automated setup and connection")
 
         # Works only on unix-based systems, so keep these imports here
         import fcntl
@@ -1085,9 +1120,10 @@ def debugserver_lldb(
         # Copy terminal size from the current terminal to PTY
         def resize_pty() -> None:
             """Update PTY size to match current terminal size"""
-            size = struct.unpack('HHHH',
-                                 fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0)))
-            fcntl.ioctl(master, termios.TIOCSWINSZ, struct.pack('HHHH', *size))
+            size = struct.unpack(
+                "HHHH", fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ, struct.pack("HHHH", 0, 0, 0, 0))
+            )
+            fcntl.ioctl(master, termios.TIOCSWINSZ, struct.pack("HHHH", *size))
             # Send SIGWINCH to the child process to notify it of the resize
             if process is not None and process.poll() is None:
                 process.send_signal(signal.SIGWINCH)
@@ -1107,22 +1143,16 @@ def debugserver_lldb(
         try:
             # Set TERM environment variable to enable colors
             env = os.environ.copy()
-            env['TERM'] = os.environ.get('TERM', 'xterm-256color')
-
-            process = subprocess.Popen(
-                [lldb_command],
-                stdin=slave,
-                stdout=slave,
-                stderr=slave,
-                env=env
-            )
+            env["TERM"] = os.environ.get("TERM", "xterm-256color")
+
+            process = subprocess.Popen([lldb_command], stdin=slave, stdout=slave, stderr=slave, env=env)
             os.close(slave)
 
             # Put terminal in raw mode for proper interaction
             tty.setraw(sys.stdin.fileno())
             # Send all commands through stdin
             for command in commands:
-                os.write(master, (command + '\n').encode())
+                os.write(master, (command + "\n").encode())
 
             # Now redirect stdin from the terminal to lldb so user can interact
             while True:
@@ -1157,24 +1187,24 @@ def debugserver_lldb(
                 process.wait()
 
 
-@developer.group('arbitration')
+@developer.group("arbitration")
 def arbitration():
-    """ Mark/Unmark device as "in-use" """
+    """Mark/Unmark device as "in-use" """
     pass
 
 
-@arbitration.command('version', cls=Command)
+@arbitration.command("version", cls=Command)
 def version(service_provider: LockdownClient):
-    """ get arbitration version """
+    """get arbitration version"""
     with DtDeviceArbitration(service_provider) as device_arbitration:
         print_json(device_arbitration.version)
 
 
-@arbitration.command('check-in', cls=Command)
-@click.argument('hostname')
-@click.option('-f', '--force', default=False, is_flag=True)
+@arbitration.command("check-in", cls=Command)
+@click.argument("hostname")
+@click.option("-f", "--force", default=False, is_flag=True)
 def check_in(service_provider: LockdownClient, hostname, force):
-    """ owner check-in """
+    """owner check-in"""
     with DtDeviceArbitration(service_provider) as device_arbitration:
         try:
             device_arbitration.check_in(hostname, force=force)
@@ -1183,14 +1213,14 @@ def check_in(service_provider: LockdownClient, hostname, force):
             logger.error(e.message)
 
 
-@arbitration.command('check-out', cls=Command)
+@arbitration.command("check-out", cls=Command)
 def check_out(service_provider: LockdownClient):
-    """ owner check-out """
+    """owner check-out"""
     with DtDeviceArbitration(service_provider) as device_arbitration:
         device_arbitration.check_out()
 
 
-@dvt.command('har', cls=Command)
+@dvt.command("har", cls=Command)
 def dvt_har(service_provider: LockdownClient):
     """
     Enable har-logging
@@ -1199,28 +1229,28 @@ def dvt_har(service_provider: LockdownClient):
         https://github.com/doronz88/harlogger?tab=readme-ov-file#enable-http-instrumentation-method
     """
     with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
-        print('> Press Ctrl-C to abort')
+        print("> Press Ctrl-C to abort")
         with ActivityTraceTap(dvt, enable_http_archive_logging=True) as tap:
             while True:
                 tap.channel.receive_message()
 
 
-@dvt.group('simulate-location')
+@dvt.group("simulate-location")
 def dvt_simulate_location():
-    """ Simulate device location by given input """
+    """Simulate device location by given input"""
     pass
 
 
-@dvt_simulate_location.command('clear', cls=Command)
+@dvt_simulate_location.command("clear", cls=Command)
 def dvt_simulate_location_clear(service_provider: LockdownClient):
-    """ Clear currently simulated location """
+    """Clear currently simulated location"""
     with DvtSecureSocketProxyService(service_provider) as dvt:
         LocationSimulation(dvt).clear()
 
 
-@dvt_simulate_location.command('set', cls=Command)
-@click.argument('latitude', type=click.FLOAT)
-@click.argument('longitude', type=click.FLOAT)
+@dvt_simulate_location.command("set", cls=Command)
+@click.argument("latitude", type=click.FLOAT)
+@click.argument("longitude", type=click.FLOAT)
 def dvt_simulate_location_set(service_provider: LockdownClient, latitude, longitude):
     """
     Set a simulated location.
@@ -1232,44 +1262,48 @@ def dvt_simulate_location_set(service_provider: LockdownClient, latitude, longit
         OSUTILS.wait_return()
 
 
-@dvt_simulate_location.command('play', cls=Command)
-@click.argument('filename', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('timing_randomness_range', type=click.INT, default=0)
-@click.option('--disable-sleep', is_flag=True, default=False)
-def dvt_simulate_location_play(service_provider: LockdownClient, filename: str, timing_randomness_range: int,
-                               disable_sleep: bool) -> None:
-    """ Simulate inputs from a given .gpx file """
+@dvt_simulate_location.command("play", cls=Command)
+@click.argument("filename", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("timing_randomness_range", type=click.INT, default=0)
+@click.option("--disable-sleep", is_flag=True, default=False)
+def dvt_simulate_location_play(
+    service_provider: LockdownClient, filename: str, timing_randomness_range: int, disable_sleep: bool
+) -> None:
+    """Simulate inputs from a given .gpx file"""
     with DvtSecureSocketProxyService(service_provider) as dvt:
-        LocationSimulation(dvt).play_gpx_file(filename, disable_sleep=disable_sleep,
-                                              timing_randomness_range=timing_randomness_range)
+        LocationSimulation(dvt).play_gpx_file(
+            filename, disable_sleep=disable_sleep, timing_randomness_range=timing_randomness_range
+        )
         OSUTILS.wait_return()
 
 
 @developer.group()
 def core_device() -> None:
-    """ Access features exposed by the DeveloperDiskImage """
+    """Access features exposed by the DeveloperDiskImage"""
     pass
 
 
 async def core_device_list_directory_task(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str) -> None:
+    service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str
+) -> None:
     async with FileServiceService(service_provider, APPLE_DOMAIN_DICT[domain], identifier) as file_service:
         print_json(await file_service.retrieve_directory_list(path))
 
 
-@core_device.command('list-directory', cls=RSDCommand)
-@click.argument('domain', type=click.Choice(APPLE_DOMAIN_DICT.keys()))
-@click.argument('path')
-@click.option('--identifier', default='')
+@core_device.command("list-directory", cls=RSDCommand)
+@click.argument("domain", type=click.Choice(APPLE_DOMAIN_DICT.keys()))
+@click.argument("path")
+@click.option("--identifier", default="")
 def core_device_list_directory(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str) -> None:
-    """ List directory at given domain-path """
+    service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str
+) -> None:
+    """List directory at given domain-path"""
     asyncio.run(core_device_list_directory_task(service_provider, domain, path, identifier))
 
 
 async def core_device_read_file_task(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str,
-        output: Optional[IO]) -> None:
+    service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str, output: Optional[IO]
+) -> None:
     async with FileServiceService(service_provider, APPLE_DOMAIN_DICT[domain], identifier) as file_service:
         buf = await file_service.retrieve_file(path)
         if output is not None:
@@ -1278,65 +1312,110 @@ async def core_device_read_file_task(
             print(try_decode(buf))
 
 
-@core_device.command('read-file', cls=RSDCommand)
-@click.argument('domain', type=click.Choice(APPLE_DOMAIN_DICT.keys()))
-@click.argument('path')
-@click.option('--identifier', default='')
-@click.option('-o', '--output', type=click.File('wb'))
+@core_device.command("read-file", cls=RSDCommand)
+@click.argument("domain", type=click.Choice(APPLE_DOMAIN_DICT.keys()))
+@click.argument("path")
+@click.option("--identifier", default="")
+@click.option("-o", "--output", type=click.File("wb"))
 def core_device_read_file(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str,
-        output: Optional[IO]) -> None:
-    """ Read file from given domain-path """
+    service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str, output: Optional[IO]
+) -> None:
+    """Read file from given domain-path"""
     asyncio.run(core_device_read_file_task(service_provider, domain, path, identifier, output))
 
 
 async def core_device_propose_empty_file_task(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str, file_permissions: int,
-        uid: int, gid: int, creation_time: int, last_modification_time: int) -> None:
+    service_provider: RemoteServiceDiscoveryService,
+    domain: str,
+    path: str,
+    identifier: str,
+    file_permissions: int,
+    uid: int,
+    gid: int,
+    creation_time: int,
+    last_modification_time: int,
+) -> None:
     async with FileServiceService(service_provider, APPLE_DOMAIN_DICT[domain], identifier) as file_service:
         await file_service.propose_empty_file(path, file_permissions, uid, gid, creation_time, last_modification_time)
 
 
-@core_device.command('propose-empty-file', cls=RSDCommand)
-@click.argument('domain', type=click.Choice(APPLE_DOMAIN_DICT.keys()))
-@click.argument('path')
-@click.option('--identifier', default='')
-@click.option('--file-permissions', type=click.INT, default=0o644)
-@click.option('--uid', type=click.INT, default=501)
-@click.option('--gid', type=click.INT, default=501)
-@click.option('--creation-time', type=click.INT, default=time.time())
-@click.option('--last-modification-time', type=click.INT, default=time.time())
+@core_device.command("propose-empty-file", cls=RSDCommand)
+@click.argument("domain", type=click.Choice(APPLE_DOMAIN_DICT.keys()))
+@click.argument("path")
+@click.option("--identifier", default="")
+@click.option("--file-permissions", type=click.INT, default=0o644)
+@click.option("--uid", type=click.INT, default=501)
+@click.option("--gid", type=click.INT, default=501)
+@click.option("--creation-time", type=click.INT, default=time.time())
+@click.option("--last-modification-time", type=click.INT, default=time.time())
 def core_device_propose_empty_file(
-        service_provider: RemoteServiceDiscoveryService, domain: str, path: str, identifier: str, file_permissions: int,
-        uid: int, gid: int, creation_time: int, last_modification_time: int) -> None:
-    """ Write an empty file to given domain-path """
-    asyncio.run(core_device_propose_empty_file_task(service_provider, domain, path, identifier, file_permissions, uid,
-                                                    gid, creation_time, last_modification_time))
+    service_provider: RemoteServiceDiscoveryService,
+    domain: str,
+    path: str,
+    identifier: str,
+    file_permissions: int,
+    uid: int,
+    gid: int,
+    creation_time: int,
+    last_modification_time: int,
+) -> None:
+    """Write an empty file to given domain-path"""
+    asyncio.run(
+        core_device_propose_empty_file_task(
+            service_provider,
+            domain,
+            path,
+            identifier,
+            file_permissions,
+            uid,
+            gid,
+            creation_time,
+            last_modification_time,
+        )
+    )
 
 
 async def core_device_list_launch_application_task(
-        service_provider: RemoteServiceDiscoveryService, bundle_identifier: str, argument: list[str],
-        kill_existing: bool, suspended: bool, env: list[tuple[str, str]]) -> None:
+    service_provider: RemoteServiceDiscoveryService,
+    bundle_identifier: str,
+    argument: list[str],
+    kill_existing: bool,
+    suspended: bool,
+    env: list[tuple[str, str]],
+) -> None:
     async with AppServiceService(service_provider) as app_service:
-        print_json(await app_service.launch_application(bundle_identifier, argument, kill_existing,
-                                                        suspended, dict(env)))
-
-
-@core_device.command('launch-application', cls=RSDCommand)
-@click.argument('bundle_identifier')
-@click.argument('argument', nargs=-1)
-@click.option('--kill-existing/--no-kill-existing', default=True,
-              help='Whether to kill an existing instance of this process')
-@click.option('--suspended', is_flag=True, help='Same as WaitForDebugger')
-@click.option('--env', multiple=True, type=click.Tuple((str, str)),
-              help='Environment variables to pass to process given as a list of key value')
+        print_json(
+            await app_service.launch_application(bundle_identifier, argument, kill_existing, suspended, dict(env))
+        )
+
+
+@core_device.command("launch-application", cls=RSDCommand)
+@click.argument("bundle_identifier")
+@click.argument("argument", nargs=-1)
+@click.option(
+    "--kill-existing/--no-kill-existing", default=True, help="Whether to kill an existing instance of this process"
+)
+@click.option("--suspended", is_flag=True, help="Same as WaitForDebugger")
+@click.option(
+    "--env",
+    multiple=True,
+    type=click.Tuple((str, str)),
+    help="Environment variables to pass to process given as a list of key value",
+)
 def core_device_launch_application(
-        service_provider: RemoteServiceDiscoveryService, bundle_identifier: str, argument: tuple[str],
-        kill_existing: bool, suspended: bool, env: list[tuple[str, str]]) -> None:
-    """ Launch application """
+    service_provider: RemoteServiceDiscoveryService,
+    bundle_identifier: str,
+    argument: tuple[str],
+    kill_existing: bool,
+    suspended: bool,
+    env: list[tuple[str, str]],
+) -> None:
+    """Launch application"""
     asyncio.run(
         core_device_list_launch_application_task(
-            service_provider, bundle_identifier, list(argument), kill_existing, suspended, env))
+            service_provider, bundle_identifier, list(argument), kill_existing, suspended, env
+        )
+    )
 
 
 async def core_device_list_processes_task(service_provider: RemoteServiceDiscoveryService) -> None:
@@ -1344,36 +1423,38 @@ async def core_device_list_processes_task(service_provider: RemoteServiceDiscove
         print_json(await app_service.list_processes())
 
 
-@core_device.command('list-processes', cls=RSDCommand)
+@core_device.command("list-processes", cls=RSDCommand)
 def core_device_list_processes(service_provider: RemoteServiceDiscoveryService) -> None:
-    """ Get process list """
+    """Get process list"""
     asyncio.run(core_device_list_processes_task(service_provider))
 
 
-async def core_device_uninstall_app_task(service_provider: RemoteServiceDiscoveryService,
-                                         bundle_identifier: str) -> None:
+async def core_device_uninstall_app_task(
+    service_provider: RemoteServiceDiscoveryService, bundle_identifier: str
+) -> None:
     async with AppServiceService(service_provider) as app_service:
         await app_service.uninstall_app(bundle_identifier)
 
 
-@core_device.command('uninstall', cls=RSDCommand)
-@click.argument('bundle_identifier')
+@core_device.command("uninstall", cls=RSDCommand)
+@click.argument("bundle_identifier")
 def core_device_uninstall_app(service_provider: RemoteServiceDiscoveryService, bundle_identifier: str) -> None:
-    """ Uninstall application """
+    """Uninstall application"""
     asyncio.run(core_device_uninstall_app_task(service_provider, bundle_identifier))
 
 
 async def core_device_send_signal_to_process_task(
-        service_provider: RemoteServiceDiscoveryService, pid: int, signal: int) -> None:
+    service_provider: RemoteServiceDiscoveryService, pid: int, signal: int
+) -> None:
     async with AppServiceService(service_provider) as app_service:
         print_json(await app_service.send_signal_to_process(pid, signal))
 
 
-@core_device.command('send-signal-to-process', cls=RSDCommand)
-@click.argument('pid', type=click.INT)
-@click.argument('signal', type=click.INT)
+@core_device.command("send-signal-to-process", cls=RSDCommand)
+@click.argument("pid", type=click.INT)
+@click.argument("signal", type=click.INT)
 def core_device_send_signal_to_process(service_provider: RemoteServiceDiscoveryService, pid: int, signal: int) -> None:
-    """ Send signal to process """
+    """Send signal to process"""
     asyncio.run(core_device_send_signal_to_process_task(service_provider, pid, signal))
 
 
@@ -1382,9 +1463,9 @@ async def core_device_get_device_info_task(service_provider: RemoteServiceDiscov
         print_json(await app_service.get_device_info())
 
 
-@core_device.command('get-device-info', cls=RSDCommand)
+@core_device.command("get-device-info", cls=RSDCommand)
 def core_device_get_device_info(service_provider: RemoteServiceDiscoveryService) -> None:
-    """ Get device information """
+    """Get device information"""
     asyncio.run(core_device_get_device_info_task(service_provider))
 
 
@@ -1393,22 +1474,22 @@ async def core_device_get_display_info_task(service_provider: RemoteServiceDisco
         print_json(await app_service.get_display_info())
 
 
-@core_device.command('get-display-info', cls=RSDCommand)
+@core_device.command("get-display-info", cls=RSDCommand)
 def core_device_get_display_info(service_provider: RemoteServiceDiscoveryService) -> None:
-    """ Get display information """
+    """Get display information"""
     asyncio.run(core_device_get_display_info_task(service_provider))
 
 
 async def core_device_query_mobilegestalt_task(service_provider: RemoteServiceDiscoveryService, key: list[str]) -> None:
-    """ Query MobileGestalt """
+    """Query MobileGestalt"""
     async with DeviceInfoService(service_provider) as app_service:
         print_json(await app_service.query_mobilegestalt(key))
 
 
-@core_device.command('query-mobilegestalt', cls=RSDCommand)
-@click.argument('key', nargs=-1, type=click.STRING)
+@core_device.command("query-mobilegestalt", cls=RSDCommand)
+@click.argument("key", nargs=-1, type=click.STRING)
 def core_device_query_mobilegestalt(service_provider: RemoteServiceDiscoveryService, key: tuple[str]) -> None:
-    """ Query MobileGestalt """
+    """Query MobileGestalt"""
     asyncio.run(core_device_query_mobilegestalt_task(service_provider, list(key)))
 
 
@@ -1417,9 +1498,9 @@ async def core_device_get_lockstate_task(service_provider: RemoteServiceDiscover
         print_json(await app_service.get_lockstate())
 
 
-@core_device.command('get-lockstate', cls=RSDCommand)
+@core_device.command("get-lockstate", cls=RSDCommand)
 def core_device_get_lockstate(service_provider: RemoteServiceDiscoveryService) -> None:
-    """ Get lockstate """
+    """Get lockstate"""
     asyncio.run(core_device_get_lockstate_task(service_provider))
 
 
@@ -1428,9 +1509,9 @@ async def core_device_list_apps_task(service_provider: RemoteServiceDiscoverySer
         print_json(await app_service.list_apps())
 
 
-@core_device.command('list-apps', cls=RSDCommand)
+@core_device.command("list-apps", cls=RSDCommand)
 def core_device_list_apps(service_provider: RemoteServiceDiscoveryService) -> None:
-    """ Get application list """
+    """Get application list"""
     asyncio.run(core_device_list_apps_task(service_provider))
 
 
@@ -1438,20 +1519,21 @@ async def core_device_sysdiagnose_task(service_provider: RemoteServiceDiscoveryS
     output = Path(output)
     async with DiagnosticsServiceService(service_provider) as service:
         response = await service.capture_sysdiagnose(False)
-        logger.info(f'Operation response: {response}')
+        logger.info(f"Operation response: {response}")
         if output.is_dir():
             output /= response.preferred_filename
-        logger.info(f'Downloading sysdiagnose to: {output}')
+        logger.info(f"Downloading sysdiagnose to: {output}")
 
         # get the file over lockdownd which is WAYYY faster
         lockdown = create_using_usbmux(service_provider.udid)
         with CrashReportsManager(lockdown) as crash_reports_manager:
-            crash_reports_manager.afc.pull(posixpath.join(f'/DiagnosticLogs/sysdiagnose/{response.preferred_filename}'),
-                                           output)
+            crash_reports_manager.afc.pull(
+                posixpath.join(f"/DiagnosticLogs/sysdiagnose/{response.preferred_filename}"), output
+            )
 
 
-@core_device.command('sysdiagnose', cls=RSDCommand)
-@click.argument('output', type=click.Path(dir_okay=True, file_okay=True, exists=True))
+@core_device.command("sysdiagnose", cls=RSDCommand)
+@click.argument("output", type=click.Path(dir_okay=True, file_okay=True, exists=True))
 def core_device_sysdiagnose(service_provider: RemoteServiceDiscoveryService, output: str) -> None:
-    """ Execute sysdiagnose and fetch the output file """
+    """Execute sysdiagnose and fetch the output file"""
     asyncio.run(core_device_sysdiagnose_task(service_provider, output))