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

pymobiledevice3/cli/apps.py

@@ -1,59 +1,104 @@
-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
 
+cli = InjectingTyper(
+    name="apps",
+    help="List, query, install, uninstall, and inspect apps on the device.",
+    no_args_is_help=True,
+)
+
 
-@click.group()
-def cli() -> None:
-    pass
+@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
+        )
+    )
 
 
-@cli.group()
-def apps() -> None:
-    """ Manage installed applications """
-    pass
+@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
+        )
+    )
 
 
-@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 """
-    print_json(InstallationProxyService(lockdown=service_provider).get_apps(application_type=app_type,
-                                                                            calculate_sizes=calculate_sizes))
+@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('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 """
-    print_json(InstallationProxyService(lockdown=service_provider)
-               .get_apps(calculate_sizes=calculate_sizes, bundle_identifiers=bundle_identifiers))
+@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('uninstall', cls=Command)
-@click.argument('bundle_id')
-def uninstall(service_provider: LockdownClient, bundle_id):
-    """ uninstall app by given bundle_id """
-    InstallationProxyService(lockdown=service_provider).uninstall(bundle_id)
+@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('install', cls=Command)
-@click.argument('package', type=click.Path(exists=True))
-def install(service_provider: LockdownServiceProvider, package: str) -> None:
-    """ install given .ipa/.app/.ipcc """
-    InstallationProxyService(lockdown=service_provider).install_from_local(package)
+@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('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 """
-    HouseArrestService(lockdown=service_provider, bundle_id=bundle_id, documents_only=documents).shell()
+@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))
+
+
+@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,37 +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.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
-
-
-@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: LockdownClient, backup_directory, full):
+cli = InjectingTyper(
+    name="backup2",
+    help="Create, inspect, and restore MobileBackup2 backups.",
+    no_args_is_help=True,
+)
+
+
+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.
 
@@ -39,23 +67,45 @@ def backup(service_provider: LockdownClient, backup_directory, full):
     """
     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)
-
-
-@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=True, 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.')
-@password_option
-@source_option
-def restore(service_provider: LockdownClient, backup_directory, system, reboot, copy, settings, remove, password, source):
+        backup_client.backup(full=full, backup_directory=str(backup_directory), progress_callback=update_bar)
+
+
+@cli.command()
+def restore(
+    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.
 
@@ -63,56 +113,68 @@ def restore(service_provider: LockdownClient, backup_directory, system, reboot,
     """
     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, progress_callback=update_bar, system=system,
-                              reboot=reboot, copy=copy, settings=settings, remove=remove, password=password,
-                              source=source)
+        backup_client.restore(
+            backup_directory=str(backup_directory),
+            progress_callback=update_bar,
+            system=system,
+            reboot=reboot,
+            copy=copy,
+            settings=settings,
+            remove=remove,
+            password=password,
+            source=source,
+            skip_apps=skip_apps,
+        )
 
 
-@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.
 
@@ -120,15 +182,22 @@ def extract(service_provider: LockdownClient, domain_name, relative_path, backup
     will be extracted to the BACKUP_DIRECTORY.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    backup_client.extract(domain_name, relative_path, backup_directory=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):
+    backup_client.extract(
+        domain_name, relative_path, backup_directory=str(backup_directory), password=password, source=source
+    )
+
+
+@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.
 
@@ -136,36 +205,37 @@ def encryption(service_provider: LockdownClient, backup_directory, mode, passwor
     When off, PASSWORD is the current backup password.
     """
     backup_client = Mobilebackup2Service(service_provider)
-    should_encrypt = mode.lower() == 'on'
+    should_encrypt = mode.lower() == "on"
     if should_encrypt == backup_client.will_encrypt:
-        logger.error('Encryption already ' + ('on!' if should_encrypt else 'off!'))
+        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.
     """
     backup_client = Mobilebackup2Service(service_provider)
     if not backup_client.will_encrypt:
-        logger.error('Encryption is not turned on!')
+        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,75 +1,79 @@
 import asyncio
-import plistlib
 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
 
+cli = InjectingTyper(
+    name="bonjour",
+    help="Browse devices over bonjour",
+    no_args_is_help=True,
+)
 
-@click.group()
-def cli() -> None:
-    pass
 
-
-@cli.group('bonjour')
-def bonjour_cli() -> None:
-    """ Browse devices over bonjour """
-    pass
-
-
-async def cli_mobdev2_task(timeout: float, pair_records: str) -> None:
-    records = []
-    if pair_records is not None:
-        for record in Path(pair_records).glob('*.plist'):
-            records.append(plistlib.loads(record.read_bytes()))
+async def cli_mobdev2_task(timeout: float, pair_records: Optional[Path]) -> None:
     output = []
-    async for ip, lockdown in get_mobdev2_lockdowns(timeout=timeout):
+    async for ip, lockdown in get_mobdev2_lockdowns(timeout=timeout, pair_records=pair_records):
         short_info = lockdown.short_info
-        short_info['ip'] = ip
+        short_info["ip"] = ip
         output.append(short_info)
     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: str) -> None:
-    """ browse for mobdev2 devices over bonjour """
+@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))
 
 
 async def cli_remotepairing_task(timeout: float) -> None:
     output = []
     for answer in await browse_remotepairing(timeout=timeout):
-        for ip in answer.ips:
-            output.append({'hostname': ip, 'port': answer.port})
+        for address in answer.addresses:
+            output.append({"hostname": address.full_ip, "port": answer.port})
     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:
-    """ browse for remotepairing devices over bonjour (without attempting pair verification) """
+@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))
 
 
 async def cli_remotepairing_manual_pairing_task(timeout: float) -> None:
     output = []
     for answer in await browse_remotepairing_manual_pairing(timeout=timeout):
-        for ip in answer.ips:
-            output.append({'hostname': ip, 'port': answer.port, 'name': answer.properties[b'name'].decode()})
+        for address in answer.addresses:
+            output.append({
+                "hostname": address.full_ip,
+                "port": answer.port,
+                "name": answer.properties[b"name"].decode(),
+            })
     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:
-    """ browse for remotepairing-manual-pairing devices over bonjour """
+@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))
 
 
@@ -77,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 """
+    """browse RemoteXPC devices using bonjour"""
     asyncio.run(cli_browse_rsd(), debug=True)