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

pymobiledevice3/cli/springboard.py

@@ -8,9 +8,9 @@ from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.springboard import SpringBoardServicesService
 
-SHELL_USAGE = '''
+SHELL_USAGE = """
 Use `service` to access the service features
-'''
+"""
 
 
 @click.group()
@@ -20,69 +20,71 @@ def cli():
 
 @cli.group()
 def springboard():
-    """ Access device UI """
+    """Access device UI"""
     pass
 
 
 @springboard.group()
 def state():
-    """ icons state options """
+    """icons state options"""
     pass
 
 
-@state.command('get', cls=Command)
+@state.command("get", cls=Command)
 def state_get(service_provider: LockdownClient):
-    """ get icon state """
+    """get icon state"""
     print_json(SpringBoardServicesService(lockdown=service_provider).get_icon_state())
 
 
-@springboard.command('shell', cls=Command)
+@springboard.command("shell", cls=Command)
 def springboard_shell(service_provider: LockdownClient):
-    """ open a shell to communicate with SpringBoardServicesService """
+    """open a shell to communicate with SpringBoardServicesService"""
     service = SpringBoardServicesService(lockdown=service_provider)
     IPython.embed(
         header=SHELL_USAGE,
         user_ns={
-            'service': service,
-        })
+            "service": service,
+        },
+    )
 
 
-@springboard.command('icon', cls=Command)
-@click.argument('bundle_id')
-@click.argument('out', type=click.File('wb'))
+@springboard.command("icon", cls=Command)
+@click.argument("bundle_id")
+@click.argument("out", type=click.File("wb"))
 def springboard_icon(service_provider: LockdownClient, bundle_id, out):
-    """ get application's icon """
+    """get application's icon"""
     out.write(SpringBoardServicesService(lockdown=service_provider).get_icon_pngdata(bundle_id))
 
 
-@springboard.command('orientation', cls=Command)
+@springboard.command("orientation", cls=Command)
 def springboard_orientation(service_provider: LockdownClient):
-    """ get screen orientation """
+    """get screen orientation"""
     print(SpringBoardServicesService(lockdown=service_provider).get_interface_orientation())
 
 
-@springboard.command('wallpaper-home-screen', cls=Command)
-@click.argument('out', type=click.File('wb'))
+@springboard.command("wallpaper-home-screen", cls=Command)
+@click.argument("out", type=click.File("wb"))
 def springboard_wallpaper_home_screen(service_provider: LockdownClient, out: IO) -> None:
-    """ get homescreen wallpaper """
+    """get homescreen wallpaper"""
     out.write(SpringBoardServicesService(lockdown=service_provider).get_wallpaper_pngdata())
 
 
-@springboard.command('wallpaper-preview-image', cls=Command)
-@click.argument('wallpaper-name', type=click.Choice(['homescreen', 'lockscreen']))
-@click.argument('out', type=click.File('wb'))
-@click.option('-r', '--reload', is_flag=True, help='reload icon state before fetching image')
-def springboard_wallpaper_preview_image(service_provider: LockdownClient, wallpaper_name: str, out: IO,
-                                        reload: bool) -> None:
-    """ get the preview image of either the homescreen or the lockscreen """
+@springboard.command("wallpaper-preview-image", cls=Command)
+@click.argument("wallpaper-name", type=click.Choice(["homescreen", "lockscreen"]))
+@click.argument("out", type=click.File("wb"))
+@click.option("-r", "--reload", is_flag=True, help="reload icon state before fetching image")
+def springboard_wallpaper_preview_image(
+    service_provider: LockdownClient, wallpaper_name: str, out: IO, reload: bool
+) -> None:
+    """get the preview image of either the homescreen or the lockscreen"""
     with SpringBoardServicesService(lockdown=service_provider) as springboard_service:
         if reload:
             springboard_service.reload_icon_state()
         out.write(springboard_service.get_wallpaper_preview_image(wallpaper_name))
 
 
-@springboard.command('homescreen-icon-metrics', cls=Command)
+@springboard.command("homescreen-icon-metrics", cls=Command)
 def springboard_homescreen_icon_metrics(service_provider: LockdownServiceProvider) -> None:
-    """ Get homescreen icon metrics """
+    """Get homescreen icon metrics"""
     with SpringBoardServicesService(lockdown=service_provider) as springboard_service:
         print_json(springboard_service.get_homescreen_icon_metrics())

pymobiledevice3/cli/syslog.py

@@ -22,25 +22,25 @@ def cli() -> None:
 
 @cli.group()
 def syslog() -> None:
-    """ Watch syslog messages """
+    """Watch syslog messages"""
     pass
 
 
-@syslog.command('live-old', cls=Command)
+@syslog.command("live-old", cls=Command)
 def syslog_live_old(service_provider: LockdownClient):
-    """ view live syslog lines in raw bytes form from old relay """
+    """view live syslog lines in raw bytes form from old relay"""
     for line in SyslogService(service_provider=service_provider).watch():
         print(line)
 
 
 def format_line(color, pid, syslog_entry, include_label):
     log_level_colors = {
-        SyslogLogLevel.NOTICE.name: 'white',
-        SyslogLogLevel.INFO.name: 'white',
-        SyslogLogLevel.DEBUG.name: 'green',
-        SyslogLogLevel.ERROR.name: 'red',
-        SyslogLogLevel.FAULT.name: 'red',
-        SyslogLogLevel.USER_ACTION.name: 'white',
+        SyslogLogLevel.NOTICE.name: "white",
+        SyslogLogLevel.INFO.name: "white",
+        SyslogLogLevel.DEBUG.name: "green",
+        SyslogLogLevel.ERROR.name: "red",
+        SyslogLogLevel.FAULT.name: "red",
+        SyslogLogLevel.USER_ACTION.name: "white",
     }
 
     syslog_pid = syslog_entry.pid
@@ -50,42 +50,55 @@ def format_line(color, pid, syslog_entry, include_label):
     image_name = posixpath.basename(syslog_entry.image_name)
     message = syslog_entry.message
     process_name = posixpath.basename(filename)
-    label = ''
+    label = ""
 
     if (pid != -1) and (syslog_pid != pid):
         return None
 
     if syslog_entry.label is not None:
-        label = f'[{syslog_entry.label.subsystem}][{syslog_entry.label.category}]'
+        label = f"[{syslog_entry.label.subsystem}][{syslog_entry.label.category}]"
 
     if color:
-        timestamp = click.style(str(timestamp), 'green')
-        process_name = click.style(process_name, 'magenta')
+        timestamp = click.style(str(timestamp), "green")
+        process_name = click.style(process_name, "magenta")
         if len(image_name) > 0:
-            image_name = click.style(image_name, 'magenta')
-        syslog_pid = click.style(syslog_pid, 'cyan')
+            image_name = click.style(image_name, "magenta")
+        syslog_pid = click.style(syslog_pid, "cyan")
         log_level_color = log_level_colors[level]
         level = click.style(level, log_level_color)
-        label = click.style(label, 'cyan')
+        label = click.style(label, "cyan")
         message = click.style(message, log_level_color)
 
-    line_format = '{timestamp} {process_name}{{{image_name}}}[{pid}] <{level}>: {message}'
+    line_format = "{timestamp} {process_name}{{{image_name}}}[{pid}] <{level}>: {message}"
 
     if include_label:
-        line_format += f' {label}'
+        line_format += f" {label}"
 
-    line = line_format.format(timestamp=timestamp, process_name=process_name, image_name=image_name, pid=syslog_pid,
-                              level=level, message=message)
+    line = line_format.format(
+        timestamp=timestamp,
+        process_name=process_name,
+        image_name=image_name,
+        pid=syslog_pid,
+        level=level,
+        message=message,
+    )
 
     return line
 
 
 def syslog_live(
-        service_provider: LockdownServiceProvider, out: Optional[TextIO], pid: Optional[int],
-        process_name: Optional[str], match: list[str], match_insensitive: list[str], include_label: bool,
-        regex: list[str], insensitive_regex: list[str]) -> None:
-    match_regex = [re.compile(f'.*({r}).*', re.DOTALL) for r in regex]
-    match_regex += [re.compile(f'.*({r}).*', re.IGNORECASE | re.DOTALL) for r in insensitive_regex]
+    service_provider: LockdownServiceProvider,
+    out: Optional[TextIO],
+    pid: Optional[int],
+    process_name: Optional[str],
+    match: list[str],
+    match_insensitive: list[str],
+    include_label: bool,
+    regex: list[str],
+    insensitive_regex: list[str],
+) -> None:
+    match_regex = [re.compile(f".*({r}).*", re.DOTALL) for r in regex]
+    match_regex += [re.compile(f".*({r}).*", re.IGNORECASE | re.DOTALL) for r in insensitive_regex]
 
     def replace(m):
         if len(m.groups()):
@@ -93,9 +106,8 @@ def syslog_live(
         return None
 
     for syslog_entry in OsTraceService(lockdown=service_provider).syslog(pid=pid):
-        if process_name:
-            if posixpath.basename(syslog_entry.filename) != process_name:
-                continue
+        if process_name and posixpath.basename(syslog_entry.filename) != process_name:
+            continue
 
         line_no_style = format_line(False, pid, syslog_entry, include_label)
         line = format_line(user_requested_colored_output(), pid, syslog_entry, include_label)
@@ -124,8 +136,12 @@ def syslog_live(
                         start = line.lower().index(m)
                         end = start + len(m)
                         last_color_formatting = get_last_used_terminal_formatting(line[:start])
-                        line = line[:start] + click.style(line[start:end], bold=True,
-                                                          underline=True) + last_color_formatting + line[end:]
+                        line = (
+                            line[:start]
+                            + click.style(line[start:end], bold=True, underline=True)
+                            + last_color_formatting
+                            + line[end:]
+                        )
 
         if match_regex:
             skip = True
@@ -147,30 +163,38 @@ def syslog_live(
                 print(line_no_style, file=out, flush=True)
 
 
-@syslog.command('live', cls=Command)
-@click.option('-o', '--out', type=click.File('wt'), help='log file')
-@click.option('--pid', type=click.INT, default=-1, help='pid to filter. -1 for all')
-@click.option('-pn', '--process-name', help='process name to filter')
-@click.option('-m', '--match', multiple=True, help='match expression')
-@click.option('-mi', '--match-insensitive', multiple=True, help='insensitive match expression')
-@click.option('include_label', '--label', is_flag=True, help='should include label')
-@click.option('-e', '--regex', multiple=True, help='filter only lines matching given regex')
-@click.option('-ei', '--insensitive-regex', multiple=True, help='filter only lines matching given regex (insensitive)')
+@syslog.command("live", cls=Command)
+@click.option("-o", "--out", type=click.File("wt"), help="log file")
+@click.option("--pid", type=click.INT, default=-1, help="pid to filter. -1 for all")
+@click.option("-pn", "--process-name", help="process name to filter")
+@click.option("-m", "--match", multiple=True, help="match expression")
+@click.option("-mi", "--match-insensitive", multiple=True, help="insensitive match expression")
+@click.option("include_label", "--label", is_flag=True, help="should include label")
+@click.option("-e", "--regex", multiple=True, help="filter only lines matching given regex")
+@click.option("-ei", "--insensitive-regex", multiple=True, help="filter only lines matching given regex (insensitive)")
 def cli_syslog_live(
-        service_provider: LockdownServiceProvider, out: Optional[TextIO], pid: Optional[int],
-        process_name: Optional[str], match: list[str], match_insensitive: list[str], include_label: bool,
-        regex: list[str], insensitive_regex: list[str]) -> None:
-    """ view live syslog lines """
-
-    syslog_live(service_provider, out, pid, process_name, match, match_insensitive, include_label, regex,
-                insensitive_regex)
-
-
-@syslog.command('collect', cls=Command)
-@click.argument('out', type=click.Path(exists=False, dir_okay=True, file_okay=False))
-@click.option('--size-limit', type=click.INT)
-@click.option('--age-limit', type=click.INT)
-@click.option('--start-time', type=click.INT)
+    service_provider: LockdownServiceProvider,
+    out: Optional[TextIO],
+    pid: Optional[int],
+    process_name: Optional[str],
+    match: list[str],
+    match_insensitive: list[str],
+    include_label: bool,
+    regex: list[str],
+    insensitive_regex: list[str],
+) -> None:
+    """view live syslog lines"""
+
+    syslog_live(
+        service_provider, out, pid, process_name, match, match_insensitive, include_label, regex, insensitive_regex
+    )
+
+
+@syslog.command("collect", cls=Command)
+@click.argument("out", type=click.Path(exists=False, dir_okay=True, file_okay=False))
+@click.option("--size-limit", type=click.INT)
+@click.option("--age-limit", type=click.INT)
+@click.option("--start-time", type=click.INT)
 def syslog_collect(service_provider: LockdownClient, out, size_limit, age_limit, start_time):
     """
     Collect the system logs into a .logarchive that can be viewed later with tools such as log or Console.
@@ -179,9 +203,12 @@ def syslog_collect(service_provider: LockdownClient, out, size_limit, age_limit,
     if not os.path.exists(out):
         os.makedirs(out)
 
-    if not out.endswith('.logarchive'):
-        logger.warning('given out path doesn\'t end with a .logarchive - consider renaming to be able to view '
-                       'the file with the likes of the Console.app and the `log show` utilities')
+    if not out.endswith(".logarchive"):
+        logger.warning(
+            "given out path doesn't end with a .logarchive - consider renaming to be able to view "
+            "the file with the likes of the Console.app and the `log show` utilities"
+        )
 
-    OsTraceService(lockdown=service_provider).collect(out, size_limit=size_limit, age_limit=age_limit,
-                                                      start_time=start_time)
+    OsTraceService(lockdown=service_provider).collect(
+        out, size_limit=size_limit, age_limit=age_limit, start_time=start_time
+    )

pymobiledevice3/cli/usbmux.py

@@ -16,41 +16,41 @@ def cli() -> None:
     pass
 
 
-@cli.group('usbmux')
+@cli.group("usbmux")
 def usbmux_cli() -> None:
-    """ List devices or forward a TCP port """
+    """List devices or forward a TCP port"""
     pass
 
 
-@usbmux_cli.command('forward', cls=BaseCommand)
-@click.option('usbmux_address', '--usbmux', help=USBMUX_OPTION_HELP)
-@click.argument('src_port', type=click.IntRange(1, 0xffff))
-@click.argument('dst_port', type=click.IntRange(1, 0xffff))
-@click.option('--serial', help='device serial number')
-@click.option('-d', '--daemonize', is_flag=True)
+@usbmux_cli.command("forward", cls=BaseCommand)
+@click.option("usbmux_address", "--usbmux", help=USBMUX_OPTION_HELP)
+@click.argument("src_port", type=click.IntRange(1, 0xFFFF))
+@click.argument("dst_port", type=click.IntRange(1, 0xFFFF))
+@click.option("--serial", help="device serial number")
+@click.option("-d", "--daemonize", is_flag=True)
 def usbmux_forward(usbmux_address: str, src_port: int, dst_port: int, serial: str, daemonize: bool):
-    """ forward tcp port """
+    """forward tcp port"""
     forwarder = UsbmuxTcpForwarder(serial, dst_port, src_port, usbmux_address=usbmux_address)
 
     if daemonize:
         try:
             from daemonize import Daemonize
-        except ImportError:
-            raise NotImplementedError('daemonizing is only supported on unix platforms')
+        except ImportError as e:
+            raise NotImplementedError("daemonizing is only supported on unix platforms") from e
 
-        with tempfile.NamedTemporaryFile('wt') as pid_file:
-            daemon = Daemonize(app=f'forwarder {src_port}->{dst_port}', pid=pid_file.name, action=forwarder.start)
+        with tempfile.NamedTemporaryFile("wt") as pid_file:
+            daemon = Daemonize(app=f"forwarder {src_port}->{dst_port}", pid=pid_file.name, action=forwarder.start)
             daemon.start()
     else:
         forwarder.start()
 
 
-@usbmux_cli.command('list', cls=BaseCommand)
-@click.option('usbmux_address', '--usbmux', help=USBMUX_OPTION_HELP)
-@click.option('-u', '--usb', is_flag=True, help='show only usb devices')
-@click.option('-n', '--network', is_flag=True, help='show only network devices')
+@usbmux_cli.command("list", cls=BaseCommand)
+@click.option("usbmux_address", "--usbmux", help=USBMUX_OPTION_HELP)
+@click.option("-u", "--usb", is_flag=True, help="show only usb devices")
+@click.option("-n", "--network", is_flag=True, help="show only network devices")
 def usbmux_list(usbmux_address: str, usb: bool, network: bool) -> None:
-    """ list connected devices """
+    """list connected devices"""
     connected_devices = []
     for device in usbmux.list_devices(usbmux_address=usbmux_address):
         udid = device.serial
@@ -61,8 +61,9 @@ def usbmux_list(usbmux_address: str, usb: bool, network: bool) -> None:
         if network and not device.is_network:
             continue
 
-        lockdown = create_using_usbmux(udid, autopair=False, connection_type=device.connection_type,
-                                       usbmux_address=usbmux_address)
+        lockdown = create_using_usbmux(
+            udid, autopair=False, connection_type=device.connection_type, usbmux_address=usbmux_address
+        )
         connected_devices.append(lockdown.short_info)
 
     print_json(connected_devices)

pymobiledevice3/cli/version.py

@@ -8,9 +8,10 @@ def cli() -> None:
 
 @cli.command()
 def version() -> None:
-    """ Query pymobiledevice3 version """
+    """Query pymobiledevice3 version"""
     try:
         from pymobiledevice3._version import __version__
+
         print(__version__)
     except ImportError:
-        print('version could not be determined. please first install/build the package')
+        print("version could not be determined. please first install/build the package")