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

pymobiledevice3/cli/mounter.py

@@ -2,18 +2,19 @@ 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.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.exceptions import (
     AlreadyMountedError,
     DeveloperDiskImageNotFoundError,
     NotMountedError,
     UnsupportedCommandError,
 )
-from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.mobile_image_mounter import (
     DeveloperDiskImageMounter,
@@ -37,19 +38,15 @@ def catch_errors(func):
     return update_wrapper(catch_function, func)
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group()
-def mounter() -> None:
-    """Mount/Umount DeveloperDiskImage or query related info"""
-    pass
+cli = InjectingTyper(
+    name="mounter",
+    help="Mount/Umount DeveloperDiskImage or query related info",
+    no_args_is_help=True,
+)
 
 
-@mounter.command("list", cls=Command)
-def mounter_list(service_provider: LockdownClient):
+@cli.command("list")
+def mounter_list(service_provider: ServiceProviderDep) -> None:
     """list all mounted images"""
     output = []
 
@@ -63,9 +60,8 @@ def mounter_list(service_provider: LockdownClient):
     print_json(output)
 
 
-@mounter.command("lookup", cls=Command)
-@click.argument("image_type")
-def mounter_lookup(service_provider: LockdownClient, 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)
@@ -74,9 +70,9 @@ def mounter_lookup(service_provider: LockdownClient, image_type):
         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):
+def mounter_umount_developer(service_provider: ServiceProviderDep) -> None:
     """unmount Developer image"""
     try:
         DeveloperDiskImageMounter(lockdown=service_provider).umount()
@@ -85,9 +81,9 @@ def mounter_umount_developer(service_provider: LockdownClient):
         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):
+def mounter_umount_personalized(service_provider: ServiceProviderDep) -> None:
     """unmount Personalized image"""
     try:
         PersonalizedImageMounter(lockdown=service_provider).umount()
@@ -96,13 +92,29 @@ def mounter_umount_personalized(service_provider: LockdownClient):
         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:
+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(Path(image), Path(signature))
+    DeveloperDiskImageMounter(lockdown=service_provider).mount(image, signature)
     logger.info("Developer image mounted successfully")
 
 
@@ -115,16 +127,39 @@ async def mounter_mount_personalized_task(
     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))
+@cli.command("mount-personalized")
 @catch_errors
 def mounter_mount_personalized(
-    service_provider: LockdownServiceProvider, image: str, trust_cache: str, build_manifest: str
+    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, image, trust_cache, build_manifest), debug=True)
+    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:
@@ -144,42 +179,49 @@ async def mounter_auto_mount_task(service_provider: LockdownServiceProvider, xco
         )
 
 
-@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(
-    "--version", help="use a different DeveloperDiskImage version from the one retrieved by lockdownconnection"
-)
-def mounter_auto_mount(service_provider: LockdownServiceProvider, xcode: str, version: str) -> None:
+@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, xcode, version), debug=True)
+    asyncio.run(mounter_auto_mount_task(service_provider, str(xcode), version), debug=True)
 
 
-@mounter.command("query-developer-mode-status", cls=Command)
-def mounter_query_developer_mode_status(service_provider: LockdownClient):
+@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):
+@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):
+@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):
+@cli.command("query-personalization-manifest")
+def mounter_query_personalization_manifest(service_provider: ServiceProviderDep) -> None:
     """Query personalization manifest"""
     result = []
     mounter = MobileImageMounterService(lockdown=service_provider)
@@ -188,12 +230,12 @@ def mounter_query_personalization_manifest(service_provider: LockdownClient):
     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):
+@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,17 +1,19 @@
 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:
@@ -37,25 +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.")
+@cli.command()
 def pcap(
-    service_provider: LockdownServiceProvider,
-    out: Optional[IO],
-    count: int,
-    process: Optional[str],
-    interface: Optional[str],
+    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"""
+    """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 = (print_packet(p) for p in packets_generator)
-        service.write_to_pcap(out, packets_generator_with_print)
+        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,26 +1,25 @@
 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
 
-
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="power-assertion",
+    no_args_is_help=True,
+)
 
 
-@cli.command("power-assertion", cls=Command)
-@click.argument(
-    "assertion_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, assertion_type, name, timeout, details) -> None:
+@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")

pymobiledevice3/cli/processes.py

@@ -1,34 +1,28 @@
 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
-
-
-@processes.command("ps", cls=Command)
-def processes_ps(service_provider: LockdownClient):
+@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("pgrep", cls=Command)
-@click.argument("expression")
-def processes_pgrep(service_provider: LockdownClient, expression):
+@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():