pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/cli/syslog.py

@@ -2,45 +2,48 @@ import logging
 import os
 import posixpath
 import re
-from typing import Optional, TextIO
-
-import click
-
-from pymobiledevice3.cli.cli_common import Command, get_last_used_terminal_formatting, user_requested_colored_output
-from pymobiledevice3.lockdown import LockdownClient
+from contextlib import nullcontext
+from pathlib import Path
+from typing import Annotated, Optional, TextIO
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import (
+    ServiceProviderDep,
+    get_last_used_terminal_formatting,
+    user_requested_colored_output,
+)
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
-from pymobiledevice3.services.os_trace import OsTraceService, SyslogLogLevel
+from pymobiledevice3.services.os_trace import OsTraceService, SyslogEntry, SyslogLogLevel
 from pymobiledevice3.services.syslog import SyslogService
 
 logger = logging.getLogger(__name__)
 
+cli = InjectingTyper(
+    name="syslog",
+    help="Watch syslog messages",
+    no_args_is_help=True,
+)
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group()
-def syslog() -> None:
-    """ Watch syslog messages """
-    pass
 
-
-@syslog.command('live-old', cls=Command)
-def syslog_live_old(service_provider: LockdownClient):
-    """ view live syslog lines in raw bytes form from old relay """
+@cli.command("live-old")
+def syslog_live_old(service_provider: ServiceProviderDep) -> None:
+    """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):
+def format_line(
+    color: bool, pid: int, syslog_entry: SyslogEntry, include_label: bool, image_offset: bool = False
+) -> Optional[str]:
     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,55 +53,75 @@ 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 = ''
+    image_offset_str = f"+0x{syslog_entry.image_offset:x}" if image_offset and image_name else ""
+    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 = typer.style(str(timestamp), "green")
+        process_name = typer.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 = typer.style(image_name, "magenta")
+        if image_offset:
+            image_offset_str = typer.style(image_offset_str, "blue")
+        syslog_pid = typer.style(syslog_pid, "cyan")
         log_level_color = log_level_colors[level]
-        level = click.style(level, log_level_color)
-        label = click.style(label, 'cyan')
-        message = click.style(message, log_level_color)
+        level = typer.style(level, log_level_color)
+        label = typer.style(label, "cyan")
+        message = typer.style(message, log_level_color)
 
-    line_format = '{timestamp} {process_name}{{{image_name}}}[{pid}] <{level}>: {message}'
+    line_format = "{timestamp} {process_name}{{{image_name}{image_offset_str}}}[{pid}] <{level}>: {message}"
 
     if include_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_format += f" {label}"
+
+    line = line_format.format(
+        timestamp=timestamp,
+        process_name=process_name,
+        image_name=image_name,
+        pid=syslog_pid,
+        level=level,
+        message=message,
+        image_offset_str=image_offset_str,
+    )
 
     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: int,
+    process_name: Optional[str],
+    match: list[str],
+    match_insensitive: list[str],
+    include_label: bool,
+    regex: list[str],
+    insensitive_regex: list[str],
+    image_offset: bool = False,
+) -> 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()):
-            return line.replace(m.group(1), click.style(m.group(1), bold=True, underline=True))
-        return None
+        if len(m.groups()) and line:
+            return line.replace(m.group(1), typer.style(m.group(1), bold=True, underline=True))
+        return ""
 
     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, image_offset)
+        line = format_line(user_requested_colored_output(), pid, syslog_entry, include_label, image_offset)
 
-        line_no_style = format_line(False, pid, syslog_entry, include_label)
-        line = format_line(user_requested_colored_output(), pid, syslog_entry, include_label)
+        if line_no_style is None or line is None:
+            continue
 
         skip = False
 
@@ -110,7 +133,7 @@ def syslog_live(
                     break
                 else:
                     if user_requested_colored_output():
-                        match_line = match_line.replace(m, click.style(m, bold=True, underline=True))
+                        match_line = match_line.replace(m, typer.style(m, bold=True, underline=True))
                         line = match_line
 
         if match_insensitive is not None:
@@ -124,8 +147,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]
+                            + typer.style(line[start:end], bold=True, underline=True)
+                            + last_color_formatting
+                            + line[end:]
+                        )
 
         if match_regex:
             skip = True
@@ -147,31 +174,108 @@ 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)')
+@cli.command("live")
 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)
-def syslog_collect(service_provider: LockdownClient, out, size_limit, age_limit, start_time):
+    service_provider: ServiceProviderDep,
+    out: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--out",
+            "-o",
+            help="log file",
+        ),
+    ] = None,
+    pid: Annotated[
+        int,
+        typer.Option(help="pid to filter. -1 for all"),
+    ] = -1,
+    process_name: Annotated[
+        Optional[str],
+        typer.Option(
+            "--process-name",
+            "-pn",
+            help="process name to filter",
+        ),
+    ] = None,
+    match: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--match",
+            "-m",
+            help="match expression",
+        ),
+    ] = None,
+    match_insensitive: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--match-insensitive",
+            "-mi",
+            help="case-insensitive match expression",
+        ),
+    ] = None,
+    include_label: Annotated[
+        bool,
+        typer.Option(
+            "--label",
+            help="should include label",
+        ),
+    ] = False,
+    regex: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--regex",
+            "-e",
+            help="filter only lines matching given regex",
+        ),
+    ] = None,
+    insensitive_regex: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--insensitive-regex",
+            "-ei",
+            help="filter only lines matching given regex (insensitive)",
+        ),
+    ] = None,
+    image_offset: Annotated[
+        bool,
+        typer.Option(
+            "--image-offset",
+            "-io",
+            help="Include image offset in log line",
+        ),
+    ] = False,
+) -> None:
+    """view live syslog lines"""
+
+    with out.open("wt") if out else nullcontext() as out_file:
+        syslog_live(
+            service_provider,
+            out_file,
+            pid,
+            process_name,
+            match or [],
+            match_insensitive or [],
+            include_label,
+            regex or [],
+            insensitive_regex or [],
+        )
+
+
+@cli.command("collect")
+def syslog_collect(
+    service_provider: ServiceProviderDep,
+    out: Annotated[
+        Path,
+        typer.Argument(
+            exists=False,
+            dir_okay=True,
+            file_okay=False,
+        ),
+    ],
+    size_limit: int,
+    age_limit: int,
+    start_time: int,
+) -> None:
     """
     Collect the system logs into a .logarchive that can be viewed later with tools such as log or Console.
     If the filename doesn't exist, system_logs.logarchive will be created in the given directory.
@@ -179,9 +283,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 out.suffix != ".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(
+        str(out), size_limit=size_limit, age_limit=age_limit, start_time=start_time
+    )

pymobiledevice3/cli/usbmux.py

@@ -1,56 +1,95 @@
 import logging
 import tempfile
+from typing import Annotated, Optional
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
 from pymobiledevice3 import usbmux
-from pymobiledevice3.cli.cli_common import USBMUX_OPTION_HELP, BaseCommand, print_json
+from pymobiledevice3.cli.cli_common import USBMUX_OPTION_HELP, print_json
 from pymobiledevice3.lockdown import create_using_usbmux
 from pymobiledevice3.tcp_forwarder import UsbmuxTcpForwarder
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group('usbmux')
-def usbmux_cli() -> None:
-    """ List devices or forward a TCP port """
-    pass
-
-
-@usbmux_cli.command('forward')
-@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 """
+cli = InjectingTyper(
+    name="usbmux",
+    help="Inspect usbmuxd-connected devices and forward TCP ports to them.",
+    no_args_is_help=True,
+)
+
+
+@cli.command("forward")
+def usbmux_forward(
+    src_port: Annotated[
+        int,
+        typer.Argument(min=1, max=0xFFFF),
+    ],
+    dst_port: Annotated[
+        int,
+        typer.Argument(min=1, max=0xFFFF),
+    ],
+    *,
+    usbmux_address: Annotated[
+        Optional[str],
+        typer.Option(
+            "--usbmux",
+            help=USBMUX_OPTION_HELP,
+        ),
+    ] = None,
+    serial: Annotated[
+        str,
+        typer.Option(help="Device serial/UDID to forward traffic to."),
+    ],
+    daemonize: Annotated[
+        bool,
+        typer.Option("--daemonize", "-d", help="Run the forwarder in the background."),
+    ] = False,
+) -> None:
+    """Forward a local TCP port to the device via usbmuxd."""
     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')
-def usbmux_list(usbmux_address: str, usb: bool, network: bool) -> None:
-    """ list connected devices """
+@cli.command("list")
+def usbmux_list(
+    usbmux_address: Annotated[
+        Optional[str],
+        typer.Option(
+            "--usbmux",
+            help=USBMUX_OPTION_HELP,
+        ),
+    ] = None,
+    usb: Annotated[
+        bool,
+        typer.Option(
+            "--usb",
+            "-u",
+            help="show only USB devices",
+        ),
+    ] = False,
+    network: Annotated[
+        bool,
+        typer.Option(
+            "--network",
+            "-n",
+            help="show only network devices",
+        ),
+    ] = False,
+) -> None:
+    """List devices known to usbmuxd (USB and Wi-Fi)."""
     connected_devices = []
     for device in usbmux.list_devices(usbmux_address=usbmux_address):
         udid = device.serial
@@ -61,8 +100,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

@@ -1,16 +1,14 @@
-import click
+from typer import Typer
 
-
-@click.group()
-def cli() -> None:
-    pass
+cli = Typer()
 
 
 @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")