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

pymobiledevice3/cli/amfi.py

@@ -1,38 +1,33 @@
 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.amfi import AmfiService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="amfi",
+    help="Enable developer-mode or query its state",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def amfi() -> None:
-    """Enable developer-mode or query its state"""
-    pass
-
-
-@amfi.command(cls=Command)
-def reveal_developer_mode(service_provider: LockdownClient):
+@cli.command()
+def reveal_developer_mode(service_provider: ServiceProviderDep) -> None:
     """reveal developer mode option in device's UI"""
     AmfiService(service_provider).reveal_developer_mode_option_in_ui()
 
 
-@amfi.command(cls=Command)
-def enable_developer_mode(service_provider: LockdownClient):
+@cli.command()
+def enable_developer_mode(service_provider: ServiceProviderDep) -> None:
     """enable developer mode"""
     AmfiService(service_provider).enable_developer_mode()
 
 
-@amfi.command(cls=Command)
-def developer_mode_status(service_provider: LockdownClient):
+@cli.command()
+def developer_mode_status(service_provider: ServiceProviderDep) -> None:
     """query developer mode status"""
     print_json(service_provider.developer_mode_status)

pymobiledevice3/cli/apps.py

@@ -1,35 +1,37 @@
-import click
+from pathlib import Path
+from typing import Annotated, Literal
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown import LockdownClient
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.house_arrest import HouseArrestService
 from pymobiledevice3.services.installation_proxy import InstallationProxyService
 
-
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group()
-def apps() -> None:
-    """Manage installed applications"""
-    pass
+cli = InjectingTyper(
+    name="apps",
+    help="List, query, install, uninstall, and inspect apps on the device.",
+    no_args_is_help=True,
+)
 
 
-@apps.command("list", cls=Command)
-@click.option(
-    "app_type",
-    "-t",
-    "--type",
-    type=click.Choice(["System", "User", "Hidden", "Any"]),
-    default="Any",
-    help="include only applications of given type",
-)
-@click.option("--calculate-sizes/--no-calculate-size", default=False)
-def apps_list(service_provider: LockdownServiceProvider, app_type: str, calculate_sizes: bool) -> None:
-    """list installed apps"""
+@cli.command("list")
+def apps_list(
+    service_provider: ServiceProviderDep,
+    app_type: Annotated[
+        Literal["System", "User", "Hidden", "Any"],
+        typer.Option(
+            "--type",
+            "-t",
+            help="Filter by application type (System/User/Hidden/Any).",
+        ),
+    ] = "Any",
+    calculate_sizes: Annotated[
+        bool,
+        typer.Option(help="Include app size information (slower)."),
+    ] = False,
+) -> None:
+    """List installed apps."""
     print_json(
         InstallationProxyService(lockdown=service_provider).get_apps(
             application_type=app_type, calculate_sizes=calculate_sizes
@@ -37,11 +39,16 @@ def apps_list(service_provider: LockdownServiceProvider, app_type: str, calculat
     )
 
 
-@apps.command("query", cls=Command)
-@click.argument("bundle_identifiers", nargs=-1)
-@click.option("--calculate-sizes/--no-calculate-size", default=False)
-def apps_query(service_provider: LockdownServiceProvider, bundle_identifiers: list[str], calculate_sizes: bool) -> None:
-    """query installed apps"""
+@cli.command("query")
+def apps_query(
+    service_provider: ServiceProviderDep,
+    bundle_identifiers: list[str],
+    calculate_sizes: Annotated[
+        bool,
+        typer.Option(help="Include app size information (slower)."),
+    ] = False,
+) -> None:
+    """Return metadata for specific bundle identifiers."""
     print_json(
         InstallationProxyService(lockdown=service_provider).get_apps(
             calculate_sizes=calculate_sizes, bundle_identifiers=bundle_identifiers
@@ -49,50 +56,49 @@ def apps_query(service_provider: LockdownServiceProvider, bundle_identifiers: li
     )
 
 
-@apps.command("uninstall", cls=Command)
-@click.argument("bundle_id")
-def uninstall(service_provider: LockdownClient, bundle_id):
-    """uninstall app by given bundle_id"""
+@cli.command("uninstall")
+def uninstall(service_provider: ServiceProviderDep, bundle_id: str) -> None:
+    """Uninstall an app by bundle identifier."""
     InstallationProxyService(lockdown=service_provider).uninstall(bundle_id)
 
 
-@apps.command("install", cls=Command)
-@click.option("--developer", is_flag=True, help="Install developer package")
-@click.argument("package", type=click.Path(exists=True))
-def install(service_provider: LockdownServiceProvider, package: str, developer: bool) -> None:
-    """install given .ipa/.app/.ipcc"""
+@cli.command("install")
+def install(
+    service_provider: ServiceProviderDep,
+    package: Annotated[
+        Path,
+        typer.Argument(exists=True),
+    ],
+    developer: Annotated[
+        bool,
+        typer.Option(help="Install developer package"),
+    ] = False,
+) -> None:
+    """Install a local .ipa/.app/.ipcc package."""
     InstallationProxyService(lockdown=service_provider).install_from_local(package, developer=developer)
 
 
-@apps.command("afc", cls=Command)
-@click.option("--documents", is_flag=True)
-@click.argument("bundle_id")
-def afc(service_provider: LockdownClient, bundle_id: str, documents: bool):
-    """open an AFC shell for given bundle_id, assuming its profile is installed"""
+@cli.command("afc")
+def afc(
+    service_provider: ServiceProviderDep, bundle_id: str, documents: Annotated[bool, typer.Option()] = False
+) -> None:
+    """Open an AFC shell into the app container; pass --documents for Documents-only."""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id, documents_only=documents).shell()
 
 
-@apps.command("pull", cls=Command)
-@click.argument("bundle_id")
-@click.argument("remote_file", type=click.Path(exists=False))
-@click.argument("local_file", type=click.Path(exists=False))
-def pull(service_provider: LockdownClient, bundle_id: str, remote_file: str, local_file: str):
-    """pull remote file from specified bundle_id"""
-    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).pull(remote_file, local_file)
+@cli.command("pull")
+def pull(service_provider: ServiceProviderDep, bundle_id: str, remote_file: Path, local_file: Path) -> None:
+    """Pull a file from an app container to a local path."""
+    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).pull(str(remote_file), str(local_file))
 
 
-@apps.command("push", cls=Command)
-@click.argument("bundle_id")
-@click.argument("local_file", type=click.Path(exists=False))
-@click.argument("remote_file", type=click.Path(exists=False))
-def push(service_provider: LockdownClient, bundle_id: str, local_file: str, remote_file: str):
-    """push local file into specified bundle_id"""
-    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).push(local_file, remote_file)
+@cli.command("push")
+def push(service_provider: ServiceProviderDep, bundle_id: str, local_file: Path, remote_file: Path) -> None:
+    """Push a local file into an app container."""
+    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).push(str(local_file), str(remote_file))
 
 
-@apps.command("rm", cls=Command)
-@click.argument("bundle_id")
-@click.argument("remote_file", type=click.Path(exists=False))
-def rm(service_provider: LockdownClient, bundle_id: str, remote_file: str):
-    """remove remote file from specified bundle_id"""
-    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).rm(remote_file)
+@cli.command("rm")
+def rm(service_provider: ServiceProviderDep, bundle_id: str, remote_file: Path) -> None:
+    """Delete a file from an app container."""
+    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).rm(str(remote_file))

pymobiledevice3/cli/backup.py

@@ -1,42 +1,65 @@
 import logging
+from pathlib import Path
+from typing import Annotated, Literal
 
-import click
+import typer
 from tqdm import tqdm
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command
-from pymobiledevice3.lockdown import LockdownClient
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
 from pymobiledevice3.services.mobilebackup2 import Mobilebackup2Service
 
-source_option = click.option("--source", default="", help="The UDID of the source device.")
-password_option = click.option("-p", "--password", default="", help="Backup password.")
-backup_directory_arg = click.argument("backup-directory", type=click.Path(exists=True, file_okay=False))
-backup_directory_option = click.option(
-    "-b", "--backup-directory", type=click.Path(exists=True, file_okay=False), default="."
-)
-
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group()
-def backup2() -> None:
-    """Backup/Restore options"""
-    pass
+cli = InjectingTyper(
+    name="backup2",
+    help="Create, inspect, and restore MobileBackup2 backups.",
+    no_args_is_help=True,
+)
 
 
-@backup2.command(cls=Command)
-@click.argument("backup-directory", type=click.Path(file_okay=False))
-@click.option(
-    "--full",
-    is_flag=True,
-    help=("Whether to do a full backup. If full is True, any previous backup attempts will be discarded."),
-)
-def backup(service_provider: LockdownServiceProvider, backup_directory: str, full: bool) -> None:
+SourceOption = Annotated[
+    str,
+    typer.Option(help="The UDID of the source device."),
+]
+PasswordOption = Annotated[
+    str,
+    typer.Option(
+        "--password",
+        "-p",
+        help="Backup password.",
+    ),
+]
+BackupDirectoryArg = Annotated[
+    Path,
+    typer.Argument(
+        exists=True,
+        file_okay=False,
+    ),
+]
+BackupDirectoryOption = Annotated[
+    Path,
+    typer.Option(
+        "--backup-directory",
+        "-b",
+        exists=True,
+        file_okay=False,
+    ),
+]
+
+
+@cli.command()
+def backup(
+    service_provider: ServiceProviderDep,
+    backup_directory: BackupDirectoryArg,
+    full: Annotated[
+        bool,
+        typer.Option(
+            help="Whether to do a full backup. If full is True, any previous backup attempts will be discarded.",
+        ),
+    ],
+) -> None:
     """
     Backup device.
 
@@ -45,34 +68,43 @@ def backup(service_provider: LockdownServiceProvider, backup_directory: str, ful
     backup_client = Mobilebackup2Service(service_provider)
     with tqdm(total=100, dynamic_ncols=True) as pbar:
 
-        def update_bar(percentage):
+        def update_bar(percentage) -> None:
             pbar.n = percentage
             pbar.refresh()
 
-        backup_client.backup(full=full, backup_directory=backup_directory, progress_callback=update_bar)
+        backup_client.backup(full=full, backup_directory=str(backup_directory), progress_callback=update_bar)
 
 
-@backup2.command(cls=Command)
-@backup_directory_arg
-@click.option("--system/--no-system", default=False, help="Restore system files.")
-@click.option("--reboot/--no-reboot", default=True, help="Reboot the device when done.")
-@click.option("--copy/--no-copy", default=False, help="Create a copy of backup folder before restoring.")
-@click.option("--settings/--no-settings", default=True, help="Restore device settings.")
-@click.option("--remove/--no-remove", default=False, help="Remove items which aren't being restored.")
-@click.option("--skip-apps", is_flag=True, help="Do not trigger re-installation of apps after restore")
-@password_option
-@source_option
+@cli.command()
 def restore(
-    service_provider: LockdownServiceProvider,
-    backup_directory: str,
-    system: bool,
-    reboot: bool,
-    copy: bool,
-    settings: bool,
-    remove: bool,
-    skip_apps: bool,
-    password: str,
-    source: str,
+    service_provider: ServiceProviderDep,
+    backup_directory: BackupDirectoryArg,
+    system: Annotated[
+        bool,
+        typer.Option(help="Restore system files."),
+    ] = False,
+    reboot: Annotated[
+        bool,
+        typer.Option(help="Reboot the device when done."),
+    ] = True,
+    copy: Annotated[
+        bool,
+        typer.Option(help="Create a copy of backup folder before restoring."),
+    ] = False,
+    settings: Annotated[
+        bool,
+        typer.Option(help="Restore device settings."),
+    ] = True,
+    remove: Annotated[
+        bool,
+        typer.Option(help="Remove items which aren't being restored."),
+    ] = False,
+    skip_apps: Annotated[
+        bool,
+        typer.Option(help="Do not trigger re-installation of apps after restore."),
+    ] = False,
+    password: PasswordOption = "",
+    source: SourceOption = "",
 ) -> None:
     """
     Restore a backup to a device.
@@ -82,12 +114,12 @@ def restore(
     backup_client = Mobilebackup2Service(service_provider)
     with tqdm(total=100, dynamic_ncols=True) as pbar:
 
-        def update_bar(percentage):
+        def update_bar(percentage) -> None:
             pbar.n = percentage
             pbar.refresh()
 
         backup_client.restore(
-            backup_directory=backup_directory,
+            backup_directory=str(backup_directory),
             progress_callback=update_bar,
             system=system,
             reboot=reboot,
@@ -100,47 +132,49 @@ def restore(
         )
 
 
-@backup2.command(cls=Command)
-@backup_directory_arg
-@source_option
-def info(service_provider: LockdownClient, backup_directory, source):
+@cli.command()
+def info(service_provider: ServiceProviderDep, backup_directory: BackupDirectoryArg, source: SourceOption = "") -> None:
     """
     Print information about a backup.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    print(backup_client.info(backup_directory=backup_directory, source=source))
+    print(backup_client.info(backup_directory=str(backup_directory), source=source))
 
 
-@backup2.command("list", cls=Command)
-@backup_directory_arg
-@source_option
-def list_(service_provider: LockdownClient, backup_directory, source):
+@cli.command("list")
+def list_(
+    service_provider: ServiceProviderDep, backup_directory: BackupDirectoryArg, source: SourceOption = ""
+) -> None:
     """
     List all file in the backup in a CSV format.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    print(backup_client.list(backup_directory=backup_directory, source=source))
+    print(backup_client.list(backup_directory=str(backup_directory), source=source))
 
 
-@backup2.command(cls=Command)
-@backup_directory_arg
-@password_option
-@source_option
-def unback(service_provider: LockdownClient, backup_directory, password, source):
+@cli.command()
+def unback(
+    service_provider: ServiceProviderDep,
+    backup_directory: BackupDirectoryArg,
+    password: PasswordOption = "",
+    source: SourceOption = "",
+) -> None:
     """
     Convert all files in the backup to the correct directory hierarchy.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    backup_client.unback(backup_directory=backup_directory, password=password, source=source)
+    backup_client.unback(backup_directory=str(backup_directory), password=password, source=source)
 
 
-@backup2.command(cls=Command)
-@click.argument("domain-name")
-@click.argument("relative-path")
-@backup_directory_arg
-@password_option
-@source_option
-def extract(service_provider: LockdownClient, domain_name, relative_path, backup_directory, password, source):
+@cli.command()
+def extract(
+    service_provider: ServiceProviderDep,
+    domain_name: str,
+    relative_path: str,
+    backup_directory: BackupDirectoryArg,
+    password: PasswordOption = "",
+    source: SourceOption = "",
+) -> None:
     """
     Extract a file from the backup.
 
@@ -149,15 +183,21 @@ def extract(service_provider: LockdownClient, domain_name, relative_path, backup
     """
     backup_client = Mobilebackup2Service(service_provider)
     backup_client.extract(
-        domain_name, relative_path, backup_directory=backup_directory, password=password, source=source
+        domain_name, relative_path, backup_directory=str(backup_directory), password=password, source=source
     )
 
 
-@backup2.command(cls=Command)
-@click.argument("mode", type=click.Choice(["on", "off"], case_sensitive=False))
-@click.argument("password")
-@backup_directory_option
-def encryption(service_provider: LockdownClient, backup_directory, mode, password):
+@cli.command()
+def encryption(
+    service_provider: ServiceProviderDep,
+    *,
+    backup_directory: BackupDirectoryOption = Path("."),
+    mode: Annotated[
+        Literal["on", "off"],
+        typer.Argument(case_sensitive=False),
+    ],
+    password: str,
+) -> None:
     """
     Set backup encryption on / off.
 
@@ -170,16 +210,18 @@ def encryption(service_provider: LockdownClient, backup_directory, mode, passwor
         logger.error("Encryption already " + ("on!" if should_encrypt else "off!"))
         return
     if should_encrypt:
-        backup_client.change_password(backup_directory, new=password)
+        backup_client.change_password(str(backup_directory), new=password)
     else:
-        backup_client.change_password(backup_directory, old=password)
+        backup_client.change_password(str(backup_directory), old=password)
 
 
-@backup2.command(cls=Command)
-@click.argument("old-password")
-@click.argument("new-password")
-@backup_directory_option
-def change_password(service_provider: LockdownClient, old_password, new_password, backup_directory):
+@cli.command()
+def change_password(
+    service_provider: ServiceProviderDep,
+    old_password: str,
+    new_password: str,
+    backup_directory: BackupDirectoryOption = Path("."),
+) -> None:
     """
     Change the backup password.
     """
@@ -187,14 +229,13 @@ def change_password(service_provider: LockdownClient, old_password, new_password
     if not backup_client.will_encrypt:
         logger.error("Encryption is not turned on!")
         return
-    backup_client.change_password(backup_directory, old=old_password, new=new_password)
+    backup_client.change_password(str(backup_directory), old=old_password, new=new_password)
 
 
-@backup2.command(cls=Command)
-@backup_directory_arg
-def erase_device(service_provider: LockdownClient, backup_directory):
+@cli.command()
+def erase_device(service_provider: ServiceProviderDep, backup_directory: BackupDirectoryArg) -> None:
     """
     Erase all data on the device.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    backup_client.erase_device(backup_directory)
+    backup_client.erase_device(str(backup_directory))

pymobiledevice3/cli/bonjour.py

@@ -1,26 +1,23 @@
 import asyncio
-from typing import Optional
+from pathlib import Path
+from typing import Annotated, Optional
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
 from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remotepairing, browse_remotepairing_manual_pairing
-from pymobiledevice3.cli.cli_common import BaseCommand, print_json
+from pymobiledevice3.cli.cli_common import print_json
 from pymobiledevice3.cli.remote import browse_rsd
 from pymobiledevice3.lockdown import get_mobdev2_lockdowns
 
-
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group("bonjour")
-def bonjour_cli() -> None:
-    """Browse devices over bonjour"""
-    pass
+cli = InjectingTyper(
+    name="bonjour",
+    help="Browse devices over bonjour",
+    no_args_is_help=True,
+)
 
 
-async def cli_mobdev2_task(timeout: float, pair_records: Optional[str]) -> None:
+async def cli_mobdev2_task(timeout: float, pair_records: Optional[Path]) -> None:
     output = []
     async for ip, lockdown in get_mobdev2_lockdowns(timeout=timeout, pair_records=pair_records):
         short_info = lockdown.short_info
@@ -29,14 +26,19 @@ async def cli_mobdev2_task(timeout: float, pair_records: Optional[str]) -> None:
     print_json(output)
 
 
-@bonjour_cli.command("mobdev2", cls=BaseCommand)
-@click.option("--timeout", default=DEFAULT_BONJOUR_TIMEOUT, type=click.INT)
-@click.option(
-    "--pair-records",
-    type=click.Path(dir_okay=True, file_okay=False, exists=True),
-    help="pair records to attempt validation with",
-)
-def cli_mobdev2(timeout: float, pair_records: Optional[str]) -> None:
+@cli.command("mobdev2")
+def cli_mobdev2(
+    timeout: Annotated[float, typer.Option()] = DEFAULT_BONJOUR_TIMEOUT,
+    pair_records: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            dir_okay=True,
+            file_okay=True,
+            help="pair records to attempt validation with",
+        ),
+    ] = None,
+) -> None:
     """browse for mobdev2 devices over bonjour"""
     asyncio.run(cli_mobdev2_task(timeout, pair_records))
 
@@ -49,9 +51,8 @@ async def cli_remotepairing_task(timeout: float) -> None:
     print_json(output)
 
 
-@bonjour_cli.command("remotepairing", cls=BaseCommand)
-@click.option("--timeout", default=DEFAULT_BONJOUR_TIMEOUT, type=click.FLOAT)
-def cli_remotepairing(timeout: float) -> None:
+@cli.command("remotepairing")
+def cli_remotepairing(timeout: Annotated[float, typer.Option()] = DEFAULT_BONJOUR_TIMEOUT) -> None:
     """browse for remotepairing devices over bonjour (without attempting pair verification)"""
     asyncio.run(cli_remotepairing_task(timeout=timeout))
 
@@ -68,9 +69,10 @@ async def cli_remotepairing_manual_pairing_task(timeout: float) -> None:
     print_json(output)
 
 
-@bonjour_cli.command("remotepairing-manual-pairing", cls=BaseCommand)
-@click.option("--timeout", default=DEFAULT_BONJOUR_TIMEOUT, type=click.FLOAT)
-def cli_remotepairing_manual_pairing(timeout: float) -> None:
+@cli.command("remotepairing-manual-pairing")
+def cli_remotepairing_manual_pairing(
+    timeout: Annotated[float, typer.Option()] = DEFAULT_BONJOUR_TIMEOUT,
+) -> None:
     """browse for remotepairing-manual-pairing devices over bonjour"""
     asyncio.run(cli_remotepairing_manual_pairing_task(timeout=timeout))
 
@@ -79,7 +81,7 @@ async def cli_browse_rsd() -> None:
     print_json(await browse_rsd())
 
 
-@bonjour_cli.command("rsd", cls=BaseCommand)
+@cli.command("rsd")
 def cli_rsd() -> None:
     """browse RemoteXPC devices using bonjour"""
     asyncio.run(cli_browse_rsd(), debug=True)