pymobiledevice3 6.2.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

pymobiledevice3/cli/lockdown.py

@@ -2,13 +2,13 @@ import asyncio
 import logging
 import plistlib
 from pathlib import Path
-from typing import Optional
+from typing import Annotated, Literal, Optional
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, CommandWithoutAutopair, print_json, sudo_required
+from pymobiledevice3.cli.cli_common import NoAutoPairServiceProviderDep, ServiceProviderDep, print_json, sudo_required
 from pymobiledevice3.cli.remote import tunnel_task
-from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.remote.common import TunnelProtocol
 from pymobiledevice3.remote.tunnel_service import CoreDeviceTunnelProxy
@@ -17,131 +17,123 @@ from pymobiledevice3.services.heartbeat import HeartbeatService
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group("lockdown")
-def lockdown_group() -> None:
-    """Pair/Unpair device or access other lockdown services"""
-    pass
+cli = InjectingTyper(
+    name="lockdown",
+    help="Pair/Unpair device or access other lockdown services",
+    no_args_is_help=True,
+)
 
 
-@lockdown_group.command("recovery", cls=Command)
-def lockdown_recovery(service_provider: LockdownClient):
+@cli.command("recovery")
+def lockdown_recovery(service_provider: ServiceProviderDep) -> None:
     """enter recovery"""
     print_json(service_provider.enter_recovery())
 
 
-@lockdown_group.command("service", cls=Command)
-@click.argument("service_name")
-def lockdown_service(service_provider: LockdownServiceProvider, service_name):
+@cli.command("service")
+def lockdown_service(service_provider: ServiceProviderDep, service_name: str) -> None:
     """send-receive raw service messages with a given service name"""
     service_provider.start_lockdown_service(service_name).shell()
 
 
-@lockdown_group.command("developer-service", cls=Command)
-@click.argument("service_name")
-def lockdown_developer_service(service_provider: LockdownServiceProvider, service_name):
+@cli.command("developer-service")
+def lockdown_developer_service(service_provider: ServiceProviderDep, service_name: str) -> None:
     """send-receive raw service messages with a given developer service name"""
     service_provider.start_lockdown_developer_service(service_name).shell()
 
 
-@lockdown_group.command("info", cls=Command)
-def lockdown_info(service_provider: LockdownServiceProvider):
+@cli.command("info")
+def lockdown_info(service_provider: ServiceProviderDep) -> None:
     """query all lockdown values"""
     print_json(service_provider.all_values)
 
 
-@lockdown_group.command("get", cls=Command)
-@click.argument("domain", required=False)
-@click.argument("key", required=False)
-def lockdown_get(service_provider: LockdownClient, domain, key):
+@cli.command("get")
+def lockdown_get(service_provider: ServiceProviderDep, domain: Optional[str] = None, key: Optional[str] = None) -> None:
     """query lockdown values by their domain and key names"""
     print_json(service_provider.get_value(domain=domain, key=key))
 
 
-@lockdown_group.command("set", cls=Command)
-@click.argument("value")
-@click.argument("domain", required=False)
-@click.argument("key", required=False)
-def lockdown_set(service_provider: LockdownClient, value, domain, key):
+@cli.command("set")
+def lockdown_set(
+    service_provider: ServiceProviderDep,
+    value: str,
+    domain: Optional[str] = None,
+    key: Optional[str] = None,
+) -> None:
     """set a lockdown value using python's eval()"""
     print_json(service_provider.set_value(value=eval(value), domain=domain, key=key))
 
 
-@lockdown_group.command("remove", cls=Command)
-@click.argument("domain")
-@click.argument("key")
-def lockdown_remove(service_provider: LockdownClient, domain, key):
+@cli.command("remove")
+def lockdown_remove(service_provider: ServiceProviderDep, domain: str, key: str) -> None:
     """remove a domain/key pair"""
     print_json(service_provider.remove_value(domain=domain, key=key))
 
 
-@lockdown_group.command("unpair", cls=CommandWithoutAutopair)
-@click.argument("host_id", required=False)
-def lockdown_unpair(service_provider: LockdownClient, host_id: Optional[str] = None):
+@cli.command("unpair")
+def lockdown_unpair(service_provider: NoAutoPairServiceProviderDep, host_id: Optional[str] = None) -> None:
     """unpair from connected device"""
     service_provider.unpair(host_id=host_id)
 
 
-@lockdown_group.command("pair", cls=CommandWithoutAutopair)
-def lockdown_pair(service_provider: LockdownClient):
+@cli.command("pair")
+def lockdown_pair(service_provider: NoAutoPairServiceProviderDep) -> None:
     """pair device"""
     service_provider.pair()
 
 
-@lockdown_group.command("pair-supervised", cls=CommandWithoutAutopair)
-@click.argument("keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
-def lockdown_pair_supervised(service_provider: LockdownClient, keybag: str) -> None:
+@cli.command("pair-supervised")
+def lockdown_pair_supervised(
+    service_provider: NoAutoPairServiceProviderDep,
+    keybag: Annotated[
+        Path,
+        typer.Argument(file_okay=True, dir_okay=False, exists=True),
+    ],
+) -> None:
     """pair supervised device"""
-    service_provider.pair_supervised(Path(keybag))
+    service_provider.pair_supervised(keybag)
 
 
-@lockdown_group.command("save-pair-record", cls=CommandWithoutAutopair)
-@click.argument("output", type=click.File("wb"))
-def lockdown_save_pair_record(service_provider: LockdownClient, output):
+@cli.command("save-pair-record")
+def lockdown_save_pair_record(service_provider: NoAutoPairServiceProviderDep, output: Path) -> None:
     """save pair record to specified location"""
     if service_provider.pair_record is None:
         logger.error("no pairing record was found")
         return
-    plistlib.dump(service_provider.pair_record, output)
+    output.write_bytes(plistlib.dumps(service_provider.pair_record))
 
 
-@lockdown_group.command("date", cls=Command)
-def lockdown_date(service_provider: LockdownClient):
+@cli.command("date")
+def lockdown_date(service_provider: ServiceProviderDep) -> None:
     """get device date"""
     print(service_provider.date)
 
 
-@lockdown_group.command("heartbeat", cls=Command)
-def lockdown_heartbeat(service_provider: LockdownClient):
+@cli.command("heartbeat")
+def lockdown_heartbeat(service_provider: ServiceProviderDep) -> None:
     """start heartbeat service"""
     HeartbeatService(service_provider).start()
 
 
-@lockdown_group.command("language", cls=Command)
-@click.argument("language", required=False)
-def lockdown_language(service_provider: LockdownClient, language: Optional[str]) -> None:
+@cli.command("language")
+def lockdown_language(service_provider: ServiceProviderDep, language: Optional[str] = None) -> None:
     """Get/Set current language settings"""
     if language is not None:
         service_provider.set_language(language)
     print_json(service_provider.language)
 
 
-@lockdown_group.command("locale", cls=Command)
-@click.argument("locale", required=False)
-def lockdown_locale(service_provider: LockdownClient, locale: Optional[str]) -> None:
+@cli.command("locale")
+def lockdown_locale(service_provider: ServiceProviderDep, locale: Optional[str] = None) -> None:
     """Get/Set current language settings"""
     if locale is not None:
         service_provider.set_locale(locale)
     print_json(service_provider.locale)
 
 
-@lockdown_group.command("device-name", cls=Command)
-@click.argument("new_name", required=False)
-def lockdown_device_name(service_provider: LockdownClient, new_name):
+@cli.command("device-name")
+def lockdown_device_name(service_provider: ServiceProviderDep, new_name: Optional[str] = None) -> None:
     """get/set current device name"""
     if new_name:
         service_provider.set_value(new_name, key="DeviceName")
@@ -149,9 +141,10 @@ def lockdown_device_name(service_provider: LockdownClient, new_name):
         print(f"{service_provider.get_value(key='DeviceName')}")
 
 
-@lockdown_group.command("wifi-connections", cls=Command)
-@click.argument("state", type=click.Choice(["on", "off"]), required=False)
-def lockdown_wifi_connections(service_provider: LockdownClient, state):
+@cli.command("wifi-connections")
+def lockdown_wifi_connections(
+    service_provider: ServiceProviderDep, state: Optional[Literal["on", "off"]] = None
+) -> None:
     """get/set wifi connections state"""
     if not state:
         # show current state
@@ -170,21 +163,23 @@ async def async_cli_start_tunnel(service_provider: LockdownServiceProvider, scri
     )
 
 
-@lockdown_group.command("start-tunnel", cls=Command)
-@click.option(
-    "--script-mode",
-    is_flag=True,
-    help="Show only HOST and port number to allow easy parsing from external shell scripts",
-)
+@cli.command("start-tunnel")
 @sudo_required
-def cli_start_tunnel(service_provider: LockdownServiceProvider, script_mode: bool) -> None:
+def cli_start_tunnel(
+    service_provider: ServiceProviderDep,
+    script_mode: Annotated[
+        bool,
+        typer.Option(help="Show only HOST and port number to allow easy parsing from external shell scripts"),
+    ] = False,
+) -> None:
     """start tunnel"""
     asyncio.run(async_cli_start_tunnel(service_provider, script_mode), debug=True)
 
 
-@lockdown_group.command("assistive-touch", cls=Command)
-@click.argument("state", type=click.Choice(["on", "off"]), required=False)
-def lockdown_assistive_touch(service_provider: LockdownClient, state: str) -> None:
+@cli.command("assistive-touch")
+def lockdown_assistive_touch(
+    service_provider: ServiceProviderDep, state: Optional[Literal["on", "off"]] = None
+) -> None:
     """get/set assistive touch icon state (visibility)"""
     if not state:
         key = "AssistiveTouchEnabledByiTunes"

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)