pymobiledevice3 4.27.0__py3-none-any.whl → 5.1.2__py3-none-any.whl

pymobiledevice3/cli/afc.py

@@ -13,44 +13,44 @@ def cli() -> None:
 
 @cli.group()
 def afc() -> None:
-    """ Manage device multimedia files """
+    """Manage device multimedia files"""
     pass
 
 
-@afc.command('shell', cls=Command)
+@afc.command("shell", cls=Command)
 def afc_shell(service_provider: LockdownClient):
-    """ open an AFC shell rooted at /var/mobile/Media """
+    """open an AFC shell rooted at /var/mobile/Media"""
     AfcShell.create(service_provider)
 
 
-@afc.command('pull', cls=Command)
-@click.option('-i', '--ignore-errors', is_flag=True, help='Ignore AFC pull errors')
-@click.argument('remote_file', type=click.Path(exists=False))
-@click.argument('local_file', type=click.Path(exists=False))
+@afc.command("pull", cls=Command)
+@click.option("-i", "--ignore-errors", is_flag=True, help="Ignore AFC pull errors")
+@click.argument("remote_file", type=click.Path(exists=False))
+@click.argument("local_file", type=click.Path(exists=False))
 def afc_pull(service_provider: LockdownServiceProvider, remote_file: str, local_file: str, ignore_errors: bool) -> None:
-    """ pull remote file from /var/mobile/Media """
+    """pull remote file from /var/mobile/Media"""
     AfcService(lockdown=service_provider).pull(remote_file, local_file, ignore_errors=ignore_errors)
 
 
-@afc.command('push', cls=Command)
-@click.argument('local_file', type=click.Path(exists=False))
-@click.argument('remote_file', type=click.Path(exists=False))
+@afc.command("push", cls=Command)
+@click.argument("local_file", type=click.Path(exists=False))
+@click.argument("remote_file", type=click.Path(exists=False))
 def afc_push(service_provider: LockdownServiceProvider, local_file: str, remote_file: str) -> None:
-    """ push local file into /var/mobile/Media """
+    """push local file into /var/mobile/Media"""
     AfcService(lockdown=service_provider).push(local_file, remote_file)
 
 
-@afc.command('ls', cls=Command)
-@click.argument('remote_file', type=click.Path(exists=False))
-@click.option('-r', '--recursive', is_flag=True)
+@afc.command("ls", cls=Command)
+@click.argument("remote_file", type=click.Path(exists=False))
+@click.option("-r", "--recursive", is_flag=True)
 def afc_ls(service_provider: LockdownClient, remote_file, recursive):
-    """ perform a dirlist rooted at /var/mobile/Media """
+    """perform a dirlist rooted at /var/mobile/Media"""
     for path in AfcService(lockdown=service_provider).dirlist(remote_file, -1 if recursive else 1):
         print(path)
 
 
-@afc.command('rm', cls=Command)
-@click.argument('remote_file', type=click.Path(exists=False))
+@afc.command("rm", cls=Command)
+@click.argument("remote_file", type=click.Path(exists=False))
 def afc_rm(service_provider: LockdownClient, remote_file):
-    """ remove a file rooted at /var/mobile/Media """
+    """remove a file rooted at /var/mobile/Media"""
     AfcService(lockdown=service_provider).rm(remote_file)

pymobiledevice3/cli/amfi.py

@@ -16,23 +16,23 @@ def cli() -> None:
 
 @cli.group()
 def amfi() -> None:
-    """ Enable developer-mode or query its state """
+    """Enable developer-mode or query its state"""
     pass
 
 
 @amfi.command(cls=Command)
 def reveal_developer_mode(service_provider: LockdownClient):
-    """ reveal developer mode option in device's UI """
+    """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):
-    """ enable developer mode """
+    """enable developer mode"""
     AmfiService(service_provider).enable_developer_mode()
 
 
 @amfi.command(cls=Command)
 def developer_mode_status(service_provider: LockdownClient):
-    """ query developer mode status """
+    """query developer mode status"""
     print_json(service_provider.developer_mode_status)

pymobiledevice3/cli/apps.py

@@ -14,73 +14,85 @@ def cli() -> None:
 
 @cli.group()
 def apps() -> None:
-    """ Manage installed applications """
+    """Manage installed applications"""
     pass
 
 
-@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)
+@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))
+    """list installed apps"""
+    print_json(
+        InstallationProxyService(lockdown=service_provider).get_apps(
+            application_type=app_type, calculate_sizes=calculate_sizes
+        )
+    )
 
 
-@apps.command('query', cls=Command)
-@click.argument('bundle_identifiers', nargs=-1)
-@click.option('--calculate-sizes/--no-calculate-size', default=False)
+@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))
+    """query installed apps"""
+    print_json(
+        InstallationProxyService(lockdown=service_provider).get_apps(
+            calculate_sizes=calculate_sizes, bundle_identifiers=bundle_identifiers
+        )
+    )
 
 
-@apps.command('uninstall', cls=Command)
-@click.argument('bundle_id')
+@apps.command("uninstall", cls=Command)
+@click.argument("bundle_id")
 def uninstall(service_provider: LockdownClient, bundle_id):
-    """ uninstall app by given bundle_id """
+    """uninstall app by given bundle_id"""
     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))
+@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 """
+    """install given .ipa/.app/.ipcc"""
     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')
+@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 """
+    """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()
 
 
-@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))
+@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 """
+    """pull remote file from specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).pull(remote_file, 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))
+@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 """
+    """push local file into specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).push(local_file, remote_file)
 
 
-@apps.command('rm', cls=Command)
-@click.argument('bundle_id')
-@click.argument('remote_file', type=click.Path(exists=False))
+@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 """
+    """remove remote file from specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).rm(remote_file)

pymobiledevice3/cli/backup.py

@@ -8,11 +8,12 @@ from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 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='.')
+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__)
 
@@ -24,14 +25,17 @@ def cli() -> None:
 
 @cli.group()
 def backup2() -> None:
-    """ Backup/Restore options """
+    """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.'))
+@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:
     """
     Backup device.
@@ -40,6 +44,7 @@ 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):
             pbar.n = percentage
             pbar.refresh()
@@ -49,16 +54,26 @@ def backup(service_provider: LockdownServiceProvider, backup_directory: str, ful
 
 @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')
+@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
-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) -> None:
+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,
+) -> None:
     """
     Restore a backup to a device.
 
@@ -66,13 +81,23 @@ def restore(service_provider: LockdownServiceProvider, backup_directory: str, sy
     """
     backup_client = Mobilebackup2Service(service_provider)
     with tqdm(total=100, dynamic_ncols=True) as pbar:
+
         def update_bar(percentage):
             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, skip_apps=skip_apps)
+        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,
+            skip_apps=skip_apps,
+        )
 
 
 @backup2.command(cls=Command)
@@ -86,7 +111,7 @@ def info(service_provider: LockdownClient, backup_directory, source):
     print(backup_client.info(backup_directory=backup_directory, source=source))
 
 
-@backup2.command('list', cls=Command)
+@backup2.command("list", cls=Command)
 @backup_directory_arg
 @source_option
 def list_(service_provider: LockdownClient, backup_directory, source):
@@ -110,8 +135,8 @@ def unback(service_provider: LockdownClient, backup_directory, password, source)
 
 
 @backup2.command(cls=Command)
-@click.argument('domain-name')
-@click.argument('relative-path')
+@click.argument("domain-name")
+@click.argument("relative-path")
 @backup_directory_arg
 @password_option
 @source_option
@@ -123,13 +148,14 @@ 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)
+    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')
+@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):
     """
@@ -139,9 +165,9 @@ 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)
@@ -150,8 +176,8 @@ def encryption(service_provider: LockdownClient, backup_directory, mode, passwor
 
 
 @backup2.command(cls=Command)
-@click.argument('old-password')
-@click.argument('new-password')
+@click.argument("old-password")
+@click.argument("new-password")
 @backup_directory_option
 def change_password(service_provider: LockdownClient, old_password, new_password, backup_directory):
     """
@@ -159,7 +185,7 @@ def change_password(service_provider: LockdownClient, old_password, new_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)
 

pymobiledevice3/cli/bonjour.py

@@ -14,9 +14,9 @@ def cli() -> None:
     pass
 
 
-@cli.group('bonjour')
+@cli.group("bonjour")
 def bonjour_cli() -> None:
-    """ Browse devices over bonjour """
+    """Browse devices over bonjour"""
     pass
 
 
@@ -24,47 +24,54 @@ async def cli_mobdev2_task(timeout: float, pair_records: Optional[str]) -> None:
     output = []
     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')
+@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:
-    """ browse for mobdev2 devices over bonjour """
+    """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)
+@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) """
+    """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)
+@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 """
+    """browse for remotepairing-manual-pairing devices over bonjour"""
     asyncio.run(cli_remotepairing_manual_pairing_task(timeout=timeout))
 
 
@@ -72,7 +79,7 @@ async def cli_browse_rsd() -> None:
     print_json(await browse_rsd())
 
 
-@bonjour_cli.command('rsd', cls=BaseCommand)
+@bonjour_cli.command("rsd", cls=BaseCommand)
 def cli_rsd() -> None:
-    """ browse RemoteXPC devices using bonjour """
+    """browse RemoteXPC devices using bonjour"""
     asyncio.run(cli_browse_rsd(), debug=True)