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

pymobiledevice3/cli/mounter.py

@@ -2,17 +2,26 @@ import asyncio
 import logging
 from functools import update_wrapper
 from pathlib import Path
+from typing import Annotated, Optional
 from urllib.error import URLError
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.exceptions import AlreadyMountedError, DeveloperDiskImageNotFoundError, NotMountedError, \
-    UnsupportedCommandError
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.exceptions import (
+    AlreadyMountedError,
+    DeveloperDiskImageNotFoundError,
+    NotMountedError,
+    UnsupportedCommandError,
+)
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
-from pymobiledevice3.services.mobile_image_mounter import DeveloperDiskImageMounter, MobileImageMounterService, \
-    PersonalizedImageMounter, auto_mount
+from pymobiledevice3.services.mobile_image_mounter import (
+    DeveloperDiskImageMounter,
+    MobileImageMounterService,
+    PersonalizedImageMounter,
+    auto_mount,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -22,161 +31,211 @@ def catch_errors(func):
         try:
             return func(*args, **kwargs)
         except AlreadyMountedError:
-            logger.error('Given image was already mounted')
+            logger.error("Given image was already mounted")
         except UnsupportedCommandError:
-            logger.error('Your iOS version doesn\'t support this command')
+            logger.error("Your iOS version doesn't support this command")
 
     return update_wrapper(catch_function, func)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="mounter",
+    help="Mount/Umount DeveloperDiskImage or query related info",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def mounter() -> None:
-    """ Mount/Umount DeveloperDiskImage or query related info """
-    pass
-
-
-@mounter.command('list', cls=Command)
-def mounter_list(service_provider: LockdownClient):
-    """ list all mounted images """
+@cli.command("list")
+def mounter_list(service_provider: ServiceProviderDep) -> None:
+    """list all mounted images"""
     output = []
 
     images = MobileImageMounterService(lockdown=service_provider).copy_devices()
     for image in images:
-        image_signature = image.get('ImageSignature')
+        image_signature = image.get("ImageSignature")
         if image_signature is not None:
-            image['ImageSignature'] = image_signature.hex()
+            image["ImageSignature"] = image_signature.hex()
         output.append(image)
 
     print_json(output)
 
 
-@mounter.command('lookup', cls=Command)
-@click.argument('image_type')
-def mounter_lookup(service_provider: LockdownClient, image_type):
-    """ lookup mounter image type """
+@cli.command("lookup")
+def mounter_lookup(service_provider: ServiceProviderDep, image_type: str) -> None:
+    """lookup mounter image type"""
     try:
         signature = MobileImageMounterService(lockdown=service_provider).lookup_image(image_type)
         print_json(signature)
     except NotMountedError:
-        logger.error(f'Disk image of type: {image_type} is not mounted')
+        logger.error(f"Disk image of type: {image_type} is not mounted")
 
 
-@mounter.command('umount-developer', cls=Command)
+@cli.command("umount-developer")
 @catch_errors
-def mounter_umount_developer(service_provider: LockdownClient):
-    """ unmount Developer image """
+def mounter_umount_developer(service_provider: ServiceProviderDep) -> None:
+    """unmount Developer image"""
     try:
         DeveloperDiskImageMounter(lockdown=service_provider).umount()
-        logger.info('Developer image unmounted successfully')
+        logger.info("Developer image unmounted successfully")
     except NotMountedError:
-        logger.error('Developer image isn\'t currently mounted')
+        logger.error("Developer image isn't currently mounted")
 
 
-@mounter.command('umount-personalized', cls=Command)
+@cli.command("umount-personalized")
 @catch_errors
-def mounter_umount_personalized(service_provider: LockdownClient):
-    """ unmount Personalized image """
+def mounter_umount_personalized(service_provider: ServiceProviderDep) -> None:
+    """unmount Personalized image"""
     try:
         PersonalizedImageMounter(lockdown=service_provider).umount()
-        logger.info('Personalized image unmounted successfully')
+        logger.info("Personalized image unmounted successfully")
     except NotMountedError:
-        logger.error('Personalized image isn\'t currently mounted')
+        logger.error("Personalized image isn't currently mounted")
 
 
-@mounter.command('mount-developer', cls=Command)
-@click.argument('image', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('signature', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@cli.command("mount-developer")
 @catch_errors
-def mounter_mount_developer(service_provider: LockdownServiceProvider, image: str, signature: str) -> None:
-    """ mount developer image """
-    DeveloperDiskImageMounter(lockdown=service_provider).mount(Path(image), Path(signature))
-    logger.info('Developer image mounted successfully')
-
-
-async def mounter_mount_personalized_task(service_provider: LockdownServiceProvider, image: str, trust_cache: str,
-                                          build_manifest: str) -> None:
-    await PersonalizedImageMounter(lockdown=service_provider).mount(Path(image), Path(build_manifest),
-                                                                    Path(trust_cache))
-    logger.info('Personalized image mounted successfully')
-
-
-@mounter.command('mount-personalized', cls=Command)
-@click.argument('image', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('trust-cache', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('build-manifest', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+def mounter_mount_developer(
+    service_provider: ServiceProviderDep,
+    image: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+    signature: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+) -> None:
+    """mount developer image"""
+    DeveloperDiskImageMounter(lockdown=service_provider).mount(image, signature)
+    logger.info("Developer image mounted successfully")
+
+
+async def mounter_mount_personalized_task(
+    service_provider: LockdownServiceProvider, image: str, trust_cache: str, build_manifest: str
+) -> None:
+    await PersonalizedImageMounter(lockdown=service_provider).mount(
+        Path(image), Path(build_manifest), Path(trust_cache)
+    )
+    logger.info("Personalized image mounted successfully")
+
+
+@cli.command("mount-personalized")
 @catch_errors
-def mounter_mount_personalized(service_provider: LockdownServiceProvider, image: str, trust_cache: str,
-                               build_manifest: str) -> None:
-    """ mount personalized image """
-    asyncio.run(mounter_mount_personalized_task(service_provider, image, trust_cache, build_manifest), debug=True)
+def mounter_mount_personalized(
+    service_provider: ServiceProviderDep,
+    image: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+    trust_cache: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+    build_manifest: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+) -> None:
+    """mount personalized image"""
+    asyncio.run(
+        mounter_mount_personalized_task(service_provider, str(image), str(trust_cache), str(build_manifest)), debug=True
+    )
 
 
 async def mounter_auto_mount_task(service_provider: LockdownServiceProvider, xcode: str, version: str) -> None:
     try:
         await auto_mount(service_provider, xcode=xcode, version=version)
-        logger.info('DeveloperDiskImage mounted successfully')
+        logger.info("DeveloperDiskImage mounted successfully")
     except URLError:
-        logger.warning('failed to query DeveloperDiskImage versions')
+        logger.warning("failed to query DeveloperDiskImage versions")
     except DeveloperDiskImageNotFoundError:
-        logger.error('Unable to find the correct DeveloperDiskImage')
+        logger.error("Unable to find the correct DeveloperDiskImage")
     except AlreadyMountedError:
-        logger.error('DeveloperDiskImage already mounted')
+        logger.error("DeveloperDiskImage already mounted")
     except PermissionError as e:
         logger.error(
-            f'DeveloperDiskImage could not be saved to Xcode default path ({e.filename}). '
-            f'Please make sure your user has the necessary permissions')
-
-
-@mounter.command('auto-mount', cls=Command)
-@click.option('-x', '--xcode', type=click.Path(exists=True, dir_okay=True, file_okay=False),
-              help='Xcode application path used to figure out automatically the DeveloperDiskImage path')
-@click.option('-v', '--version', help='use a different DeveloperDiskImage version from the one retrieved by lockdown'
-                                      'connection')
-def mounter_auto_mount(service_provider: LockdownServiceProvider, xcode: str, version: str) -> None:
-    """ auto-detect correct DeveloperDiskImage and mount it """
-    asyncio.run(mounter_auto_mount_task(service_provider, xcode, version), debug=True)
-
-
-@mounter.command('query-developer-mode-status', cls=Command)
-def mounter_query_developer_mode_status(service_provider: LockdownClient):
-    """ Query developer mode status """
+            f"DeveloperDiskImage could not be saved to Xcode default path ({e.filename}). "
+            f"Please make sure your user has the necessary permissions"
+        )
+
+
+@cli.command("auto-mount")
+def mounter_auto_mount(
+    service_provider: ServiceProviderDep,
+    xcode: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--xcode",
+            "-x",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            help="Xcode application path used to figure out automatically the DeveloperDiskImage path",
+        ),
+    ] = None,
+    version: Annotated[
+        Optional[str],
+        typer.Option(help="Use a different DeveloperDiskImage version from the one retrieved by lockdownconnection"),
+    ] = None,
+) -> None:
+    """auto-detect correct DeveloperDiskImage and mount it"""
+    asyncio.run(mounter_auto_mount_task(service_provider, str(xcode), version), debug=True)
+
+
+@cli.command("query-developer-mode-status")
+def mounter_query_developer_mode_status(service_provider: ServiceProviderDep) -> None:
+    """Query developer mode status"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_developer_mode_status())
 
 
-@mounter.command('query-nonce', cls=Command)
-@click.option('--image-type')
-def mounter_query_nonce(service_provider: LockdownClient, image_type: str):
-    """ Query nonce """
+@cli.command("query-nonce")
+def mounter_query_nonce(service_provider: ServiceProviderDep, image_type: Annotated[str, typer.Option()]) -> None:
+    """Query nonce"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_nonce(image_type))
 
 
-@mounter.command('query-personalization-identifiers', cls=Command)
-def mounter_query_personalization_identifiers(service_provider: LockdownClient):
-    """ Query personalization identifiers """
+@cli.command("query-personalization-identifiers")
+def mounter_query_personalization_identifiers(service_provider: ServiceProviderDep) -> None:
+    """Query personalization identifiers"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_personalization_identifiers())
 
 
-@mounter.command('query-personalization-manifest', cls=Command)
-def mounter_query_personalization_manifest(service_provider: LockdownClient):
-    """ Query personalization manifest """
+@cli.command("query-personalization-manifest")
+def mounter_query_personalization_manifest(service_provider: ServiceProviderDep) -> None:
+    """Query personalization manifest"""
     result = []
     mounter = MobileImageMounterService(lockdown=service_provider)
     for device in mounter.copy_devices():
-        result.append(mounter.query_personalization_manifest(device['PersonalizedImageType'], device['ImageSignature']))
+        result.append(mounter.query_personalization_manifest(device["PersonalizedImageType"], device["ImageSignature"]))
     print_json(result)
 
 
-@mounter.command('roll-personalization-nonce', cls=Command)
-def mounter_roll_personalization_nonce(service_provider: LockdownClient):
+@cli.command("roll-personalization-nonce")
+def mounter_roll_personalization_nonce(service_provider: ServiceProviderDep) -> None:
     MobileImageMounterService(lockdown=service_provider).roll_personalization_nonce()
 
 
-@mounter.command('roll-cryptex-nonce', cls=Command)
-def mounter_roll_cryptex_nonce(service_provider: LockdownClient):
-    """ Roll cryptex nonce (will reboot) """
+@cli.command("roll-cryptex-nonce")
+def mounter_roll_cryptex_nonce(service_provider: ServiceProviderDep) -> None:
+    """Roll cryptex nonce (will reboot)"""
     MobileImageMounterService(lockdown=service_provider).roll_cryptex_nonce()

pymobiledevice3/cli/notification.py

@@ -1,41 +1,48 @@
 import logging
+from typing import Annotated
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
 from pymobiledevice3.resources.firmware_notifications import get_notifications
 from pymobiledevice3.services.notification_proxy import NotificationProxyService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="notifications",
+    help="Post or observe Darwin notifications via notification_proxy.",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def notification() -> None:
-    """ Post/Observe notifications """
-    pass
-
-
-@notification.command(cls=Command)
-@click.argument('names', nargs=-1)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
-def post(service_provider: LockdownClient, names, insecure):
-    """ API for notify_post(). """
+@cli.command()
+def post(
+    service_provider: ServiceProviderDep,
+    names: list[str],
+    insecure: Annotated[
+        bool,
+        typer.Option(help="Use the insecure relay meant for untrusted clients instead of the trusted channel."),
+    ],
+) -> None:
+    """Post one or more Darwin notifications (notify_post)."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for name in names:
         service.notify_post(name)
 
 
-@notification.command(cls=Command)
-@click.argument('names', nargs=-1)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
-def observe(service_provider: LockdownClient, names, insecure):
-    """ API for notify_register_dispatch(). """
+@cli.command()
+def observe(
+    service_provider: ServiceProviderDep,
+    names: list[str],
+    insecure: Annotated[
+        bool,
+        typer.Option(help="Use the insecure relay meant for untrusted clients instead of the trusted channel."),
+    ],
+) -> None:
+    """Subscribe and stream notifications (notify_register_dispatch)."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for name in names:
         service.notify_register_dispatch(name)
@@ -44,10 +51,15 @@ def observe(service_provider: LockdownClient, names, insecure):
         logger.info(event)
 
 
-@notification.command('observe-all', cls=Command)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
-def observe_all(service_provider: LockdownClient, insecure):
-    """ attempt to observe all builtin firmware notifications. """
+@cli.command("observe-all")
+def observe_all(
+    service_provider: ServiceProviderDep,
+    insecure: Annotated[
+        bool,
+        typer.Option(help="Use the insecure relay meant for untrusted clients instead of the trusted channel."),
+    ],
+) -> None:
+    """Subscribe to all known firmware notifications and stream events."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for notification in get_notifications():
         service.notify_register_dispatch(notification)

pymobiledevice3/cli/pcap.py

@@ -1,35 +1,37 @@
 from datetime import datetime
-from typing import IO, Optional
+from pathlib import Path
+from typing import Annotated, Optional
 
-import click
+import typer
 from pygments import formatters, highlight, lexers
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_hex, user_requested_colored_output
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_hex, user_requested_colored_output
 from pymobiledevice3.services.pcapd import PcapdService
 
-
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="pcap",
+    help="Sniff device traffic via pcapd and optionally save to a .pcap file.",
+    no_args_is_help=True,
+)
 
 
 def print_packet_header(packet, color: bool) -> None:
     date = datetime.fromtimestamp(packet.seconds + (packet.microseconds / 1000000))
     data = (
-        f'{date}: '
-        f'Process {packet.comm} ({packet.pid}), '
-        f'Interface: {packet.interface_name} ({packet.interface_type.name}), '
-        f'Family: {packet.protocol_family.name}'
+        f"{date}: "
+        f"Process {packet.comm} ({packet.pid}), "
+        f"Interface: {packet.interface_name} ({packet.interface_type.name}), "
+        f"Family: {packet.protocol_family.name}"
     )
     if not color:
         print(data)
     else:
-        print(highlight(data, lexers.HspecLexer(), formatters.Terminal256Formatter(style='native')), end='')
+        print(highlight(data, lexers.HspecLexer(), formatters.Terminal256Formatter(style="native")), end="")
 
 
 def print_packet(packet, color: Optional[bool] = None):
-    """ Return the packet, so it can be chained in a generator """
+    """Return the packet, so it can be chained in a generator"""
     if color is None:
         color = user_requested_colored_output()
     print_packet_header(packet, color)
@@ -37,20 +39,39 @@ def print_packet(packet, color: Optional[bool] = None):
     return packet
 
 
-@cli.command(cls=Command)
-@click.argument('out', type=click.File('wb'), required=False)
-@click.option('-c', '--count', type=click.INT, default=-1, help='Number of packets to sniff. Omit to endless sniff.')
-@click.option('--process', default=None, help='Process to filter. Omit for all.')
-@click.option('-i', '--interface', default=None, help='Interface name to filter. Omit for all.')
-def pcap(service_provider: LockdownServiceProvider, out: Optional[IO], count: int, process: Optional[str],
-         interface: Optional[str]) -> None:
-    """ Sniff device traffic """
+@cli.command()
+def pcap(
+    service_provider: ServiceProviderDep,
+    out: Optional[Path] = None,
+    count: Annotated[
+        int,
+        typer.Option(
+            "--count",
+            "-c",
+            help="Number of packets to sniff. Omit to endless sniff.",
+        ),
+    ] = -1,
+    process: Annotated[
+        Optional[str],
+        typer.Option(help="Process to filter. Omit for all."),
+    ] = None,
+    interface: Annotated[
+        Optional[str],
+        typer.Option(
+            "--interface",
+            "-i",
+            help="Interface name to filter. Omit for all.",
+        ),
+    ] = None,
+) -> None:
+    """Sniff device traffic."""
     service = PcapdService(lockdown=service_provider)
     packets_generator = service.watch(packets_count=count, process=process, interface_name=interface)
 
     if out is not None:
-        packets_generator_with_print = map(lambda p: print_packet(p), packets_generator)
-        service.write_to_pcap(out, packets_generator_with_print)
+        packets_generator_with_print = (print_packet(p) for p in packets_generator)
+        with out.open("wb") as out_file:
+            service.write_to_pcap(out_file, packets_generator_with_print)
         return
 
     for packet in packets_generator:

pymobiledevice3/cli/power_assertion.py

@@ -1,25 +1,26 @@
 import time
+from typing import Literal, Optional
 
-import click
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
 from pymobiledevice3.services.power_assertion import PowerAssertionService
 
+cli = InjectingTyper(
+    name="power-assertion",
+    no_args_is_help=True,
+)
 
-@click.group()
-def cli() -> None:
-    pass
 
-
-@cli.command('power-assertion', cls=Command)
-@click.argument('type', type=click.Choice(
-    ['AMDPowerAssertionTypeWirelessSync', 'PreventUserIdleSystemSleep', 'PreventSystemSleep']))
-@click.argument('name')
-@click.argument('timeout', type=click.INT)
-@click.argument('details', required=False)
-def power_assertion(service_provider: LockdownServiceProvider, type, name, timeout, details) -> None:
-    """ Create a power assertion """
-    with PowerAssertionService(service_provider).create_power_assertion(type, name, timeout, details):
-        print('> Hit Ctrl+C to exit')
+@cli.command("power-assertion")
+def power_assertion(
+    service_provider: ServiceProviderDep,
+    assertion_type: Literal["AMDPowerAssertionTypeWirelessSync", "PreventUserIdleSystemSleep", "PreventSystemSleep"],
+    name: str,
+    timeout: int,
+    details: Optional[str] = None,
+) -> None:
+    """Create a power assertion"""
+    with PowerAssertionService(service_provider).create_power_assertion(assertion_type, name, timeout, details):
+        print("> Hit Ctrl+C to exit")
         time.sleep(timeout)

pymobiledevice3/cli/processes.py

@@ -1,37 +1,31 @@
 import logging
 
-import click
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.os_trace import OsTraceService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="processes",
+    help="View process list using diagnosticsd API",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def processes() -> None:
-    """ View process list using diagnosticsd API """
-    pass
+@cli.command("ps")
+def processes_ps(service_provider: ServiceProviderDep) -> None:
+    """show process list"""
+    print_json(OsTraceService(lockdown=service_provider).get_pid_list().get("Payload"))
 
 
-@processes.command('ps', cls=Command)
-def processes_ps(service_provider: LockdownClient):
-    """ show process list """
-    print_json(OsTraceService(lockdown=service_provider).get_pid_list().get('Payload'))
-
-
-@processes.command('pgrep', cls=Command)
-@click.argument('expression')
-def processes_pgrep(service_provider: LockdownClient, expression):
-    """ try to match processes pid by given expression (like pgrep) """
-    processes_list = OsTraceService(lockdown=service_provider).get_pid_list().get('Payload')
+@cli.command("pgrep")
+def processes_pgrep(service_provider: ServiceProviderDep, expression: str) -> None:
+    """try to match processes pid by given expression (like pgrep)"""
+    processes_list = OsTraceService(lockdown=service_provider).get_pid_list().get("Payload")
     for pid, process_info in processes_list.items():
-        process_name = process_info.get('ProcessName')
+        process_name = process_info.get("ProcessName")
         if expression in process_name:
-            logger.info(f'{pid} {process_name}')
+            logger.info(f"{pid} {process_name}")