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

pymobiledevice3/cli/cli_common.py

@@ -24,51 +24,50 @@ from pymobiledevice3.tunneld.api import TUNNELD_DEFAULT_ADDRESS, async_get_tunne
 from pymobiledevice3.usbmux import select_devices_by_connection_type
 
 COLORED_OUTPUT = True
-UDID_ENV_VAR = 'PYMOBILEDEVICE3_UDID'
-TUNNEL_ENV_VAR = 'PYMOBILEDEVICE3_TUNNEL'
-USBMUX_ENV_VAR = 'PYMOBILEDEVICE3_USBMUX'
+UDID_ENV_VAR = "PYMOBILEDEVICE3_UDID"
+TUNNEL_ENV_VAR = "PYMOBILEDEVICE3_TUNNEL"
+USBMUX_ENV_VAR = "PYMOBILEDEVICE3_USBMUX"
 OSUTILS = get_os_utils()
 
-USBMUX_OPTION_HELP = (f'usbmuxd listener address (in the form of either /path/to/unix/socket OR HOST:PORT). '
-                      f'Can be specified via {USBMUX_ENV_VAR} envvar')
+USBMUX_OPTION_HELP = (
+    f"usbmuxd listener address (in the form of either /path/to/unix/socket OR HOST:PORT). "
+    f"Can be specified via {USBMUX_ENV_VAR} envvar"
+)
 
 
 class RSDOption(Option):
     def __init__(self, *args, **kwargs):
-        self.mutually_exclusive = set(kwargs.pop('mutually_exclusive', []))
-        help = kwargs.get('help', '')
+        self.mutually_exclusive = set(kwargs.pop("mutually_exclusive", []))
+        help_option = kwargs.get("help", "")
         if self.mutually_exclusive:
-            ex_str = ', '.join(self.mutually_exclusive)
-            kwargs['help'] = help + (
-                    '\nNOTE: This argument is mutually exclusive with '
-                    ' arguments: [' + ex_str + '].'
+            ex_str = ", ".join(self.mutually_exclusive)
+            kwargs["help"] = help_option + (
+                "\nNOTE: This argument is mutually exclusive with  arguments: [" + ex_str + "]."
             )
         super().__init__(*args, **kwargs)
 
     def handle_parse_result(self, ctx, opts, args):
-        if (isinstance(ctx.command, RSDCommand) and not (isinstance(ctx.command, Command)) and
-                ('rsd_service_provider_using_tunneld' not in opts) and ('rsd_service_provider_manually' not in opts)):
+        if (
+            isinstance(ctx.command, RSDCommand)
+            and not (isinstance(ctx.command, Command))
+            and ("rsd_service_provider_using_tunneld" not in opts)
+            and ("rsd_service_provider_manually" not in opts)
+        ):
             # defaulting to `--tunnel ''` if no remote option was specified
-            opts['rsd_service_provider_using_tunneld'] = ''
+            opts["rsd_service_provider_using_tunneld"] = ""
         if self.mutually_exclusive.intersection(opts) and self.name in opts:
             raise UsageError(
-                'Illegal usage: `{}` is mutually exclusive with '
-                'arguments `{}`.'.format(
-                    self.name,
-                    ', '.join(self.mutually_exclusive)
+                "Illegal usage: `{}` is mutually exclusive with arguments `{}`.".format(
+                    self.name, ", ".join(self.mutually_exclusive)
                 )
             )
 
-        return super().handle_parse_result(
-            ctx,
-            opts,
-            args
-        )
+        return super().handle_parse_result(ctx, opts, args)
 
 
 def default_json_encoder(obj):
     if isinstance(obj, bytes):
-        return f'<{obj.hex()}>'
+        return f"<{obj.hex()}>"
     if isinstance(obj, datetime.datetime):
         return str(obj)
     if isinstance(obj, uuid.UUID):
@@ -81,8 +80,9 @@ def print_json(buf, colored: Optional[bool] = None, default=default_json_encoder
         colored = user_requested_colored_output()
     formatted_json = json.dumps(buf, sort_keys=True, indent=4, default=default)
     if colored and os.isatty(sys.stdout.fileno()):
-        colorful_json = highlight(formatted_json, lexers.JsonLexer(),
-                                  formatters.Terminal256Formatter(style='stata-dark'))
+        colorful_json = highlight(
+            formatted_json, lexers.JsonLexer(), formatters.Terminal256Formatter(style="stata-dark")
+        )
         print(colorful_json)
         return colorful_json
     else:
@@ -91,11 +91,11 @@ def print_json(buf, colored: Optional[bool] = None, default=default_json_encoder
 
 
 def print_hex(data, colored=True):
-    hex_dump = hexdump.hexdump(data, result='return')
+    hex_dump = hexdump.hexdump(data, result="return")
     if colored:
-        print(highlight(hex_dump, lexers.HexdumpLexer(), formatters.Terminal256Formatter(style='native')))
+        print(highlight(hex_dump, lexers.HexdumpLexer(), formatters.Terminal256Formatter(style="native")))
     else:
-        print(hex_dump, end='\n\n')
+        print(hex_dump, end="\n\n")
 
 
 def set_verbosity(ctx, param, value):
@@ -116,7 +116,7 @@ def user_requested_colored_output() -> bool:
 
 
 def get_last_used_terminal_formatting(buf: str) -> str:
-    return '\x1b' + buf.rsplit('\x1b', 1)[1].split('m')[0] + 'm'
+    return "\x1b" + buf.rsplit("\x1b", 1)[1].split("m")[0] + "m"
 
 
 def sudo_required(func):
@@ -131,24 +131,24 @@ def sudo_required(func):
 
 
 def prompt_selection(choices: list[Any], message: str, idx: bool = False) -> Any:
-    question = [inquirer3.List('selection', message=message, choices=choices, carousel=True)]
+    question = [inquirer3.List("selection", message=message, choices=choices, carousel=True)]
     try:
         result = inquirer3.prompt(question, theme=GreenPassion(), raise_keyboard_interrupt=True)
-    except KeyboardInterrupt:
-        raise click.ClickException('No selection was made')
-    return result['selection'] if not idx else choices.index(result['selection'])
+    except KeyboardInterrupt as e:
+        raise click.ClickException("No selection was made") from e
+    return result["selection"] if not idx else choices.index(result["selection"])
 
 
 def prompt_device_list(device_list: list):
-    return prompt_selection(device_list, 'Choose device')
+    return prompt_selection(device_list, "Choose device")
 
 
 def choose_service_provider(callback: Callable):
     def wrap_callback_calling(**kwargs: dict) -> None:
         service_provider = None
-        lockdown_service_provider = kwargs.pop('lockdown_service_provider', None)
-        rsd_service_provider_manually = kwargs.pop('rsd_service_provider_manually', None)
-        rsd_service_provider_using_tunneld = kwargs.pop('rsd_service_provider_using_tunneld', None)
+        lockdown_service_provider = kwargs.pop("lockdown_service_provider", None)
+        rsd_service_provider_manually = kwargs.pop("rsd_service_provider_manually", None)
+        rsd_service_provider_using_tunneld = kwargs.pop("rsd_service_provider_using_tunneld", None)
         if lockdown_service_provider is not None:
             service_provider = lockdown_service_provider
         if rsd_service_provider_manually is not None:
@@ -161,20 +161,23 @@ def choose_service_provider(callback: Callable):
 
 
 def is_invoked_for_completion() -> bool:
-    """ Returns True if the command is ivoked for autocompletion. """
-    for env in os.environ.keys():
-        if env.startswith('_') and env.endswith('_COMPLETE'):
-            return True
-    return False
+    """Returns True if the command is ivoked for autocompletion."""
+    return any(env.startswith("_") and env.endswith("_COMPLETE") for env in os.environ)
 
 
 class BaseCommand(click.Command):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.params[:0] = [
-            click.Option(('verbosity', '-v', '--verbose'), count=True, callback=set_verbosity, expose_value=False),
-            click.Option(('color', '--color/--no-color'), default=True, callback=set_color_flag, is_flag=True,
-                         expose_value=False, help='colorize output'),
+            click.Option(("verbosity", "-v", "--verbose"), count=True, callback=set_verbosity, expose_value=False),
+            click.Option(
+                ("color", "--color/--no-color"),
+                default=True,
+                callback=set_color_flag,
+                is_flag=True,
+                expose_value=False,
+                help="colorize output",
+            ),
         ]
 
 
@@ -191,20 +194,35 @@ class LockdownCommand(BaseServiceProviderCommand):
         self.usbmux_address = None
         self.mobdev2_option = None
         self.params[:0] = [
-            click.Option(('mobdev2', '--mobdev2'), callback=self.mobdev2, expose_value=False, default=None,
-                         help='Use bonjour browse for mobdev2 devices. Expected value IP address of the interface to '
-                              'use. Leave empty to browse through all interfaces'),
-            click.Option(('usbmux', '--usbmux'), callback=self.usbmux, expose_value=False,
-                         envvar=USBMUX_ENV_VAR, help=USBMUX_OPTION_HELP),
-            click.Option(('lockdown_service_provider', '--udid'), envvar=UDID_ENV_VAR, callback=self.udid,
-                         help=f'Device unique identifier. You may pass {UDID_ENV_VAR} environment variable to pass this'
-                              f' option as well'),
+            click.Option(
+                ("mobdev2", "--mobdev2"),
+                callback=self.mobdev2,
+                expose_value=False,
+                default=None,
+                help="Use bonjour browse for mobdev2 devices. Expected value IP address of the interface to "
+                "use. Leave empty to browse through all interfaces",
+            ),
+            click.Option(
+                ("usbmux", "--usbmux"),
+                callback=self.usbmux,
+                expose_value=False,
+                envvar=USBMUX_ENV_VAR,
+                help=USBMUX_OPTION_HELP,
+            ),
+            click.Option(
+                ("lockdown_service_provider", "--udid"),
+                envvar=UDID_ENV_VAR,
+                callback=self.udid,
+                help=f"Device unique identifier. You may pass {UDID_ENV_VAR} environment variable to pass this"
+                f" option as well",
+            ),
         ]
 
-    async def get_mobdev2_devices(self, udid: Optional[str] = None, ips: Optional[list[str]] = None) \
-            -> list[TcpLockdownClient]:
+    async def get_mobdev2_devices(
+        self, udid: Optional[str] = None, ips: Optional[list[str]] = None
+    ) -> list[TcpLockdownClient]:
         result = []
-        async for ip, lockdown in get_mobdev2_lockdowns(udid=udid, ips=ips):
+        async for _ip, lockdown in get_mobdev2_lockdowns(udid=udid, ips=ips):
             result.append(lockdown)
         return result
 
@@ -225,8 +243,11 @@ class LockdownCommand(BaseServiceProviderCommand):
             return self.service_provider
 
         if self.mobdev2_option is not None:
-            devices = asyncio.run(self.get_mobdev2_devices(
-                udid=value if value else None, ips=[self.mobdev2_option] if self.mobdev2_option else None))
+            devices = asyncio.run(
+                self.get_mobdev2_devices(
+                    udid=value if value else None, ips=[self.mobdev2_option] if self.mobdev2_option else None
+                )
+            )
             if not devices:
                 raise NoDeviceConnectedError()
 
@@ -240,29 +261,37 @@ class LockdownCommand(BaseServiceProviderCommand):
         if value is not None:
             return create_using_usbmux(serial=value)
 
-        devices = select_devices_by_connection_type(connection_type='USB', usbmux_address=self.usbmux_address)
+        devices = select_devices_by_connection_type(connection_type="USB", usbmux_address=self.usbmux_address)
         if len(devices) <= 1:
             return create_using_usbmux(usbmux_address=self.usbmux_address)
 
-        return prompt_device_list(
-            [create_using_usbmux(serial=device.serial, usbmux_address=self.usbmux_address) for device in devices])
+        return prompt_device_list([
+            create_using_usbmux(serial=device.serial, usbmux_address=self.usbmux_address) for device in devices
+        ])
 
 
 class RSDCommand(BaseServiceProviderCommand):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.params[:0] = [
-            RSDOption(('rsd_service_provider_manually', '--rsd'), type=(str, int), callback=self.rsd,
-                      mutually_exclusive=['rsd_service_provider_using_tunneld'],
-                      help='\b\n'
-                           'RSD hostname and port number (as provided by a `start-tunnel` subcommand).'),
-            RSDOption(('rsd_service_provider_using_tunneld', '--tunnel'), callback=self.tunneld,
-                      mutually_exclusive=['rsd_service_provider_manually'], envvar=TUNNEL_ENV_VAR,
-                      help='\b\n'
-                           'Either an empty string to force tunneld device selection, or a UDID of a tunneld '
-                           'discovered device.\n'
-                           'The string may be suffixed with :PORT in case tunneld is not serving at the default port.\n'
-                           f'This option may also be transferred as an environment variable: {TUNNEL_ENV_VAR}')
+            RSDOption(
+                ("rsd_service_provider_manually", "--rsd"),
+                type=(str, int),
+                callback=self.rsd,
+                mutually_exclusive=["rsd_service_provider_using_tunneld"],
+                help="\b\nRSD hostname and port number (as provided by a `start-tunnel` subcommand).",
+            ),
+            RSDOption(
+                ("rsd_service_provider_using_tunneld", "--tunnel"),
+                callback=self.tunneld,
+                mutually_exclusive=["rsd_service_provider_manually"],
+                envvar=TUNNEL_ENV_VAR,
+                help="\b\n"
+                "Either an empty string to force tunneld device selection, or a UDID of a tunneld "
+                "discovered device.\n"
+                "The string may be suffixed with :PORT in case tunneld is not serving at the default port.\n"
+                f"This option may also be transferred as an environment variable: {TUNNEL_ENV_VAR}",
+            ),
         ]
 
     def rsd(self, ctx, param: str, value: Optional[tuple[str, int]]) -> Optional[RemoteServiceDiscoveryService]:
@@ -278,19 +307,21 @@ class RSDCommand(BaseServiceProviderCommand):
 
         udid = udid.strip()
         port = TUNNELD_DEFAULT_ADDRESS[1]
-        if ':' in udid:
-            udid, port = udid.split(':')
+        if ":" in udid:
+            udid, port = udid.split(":")
 
         rsds = await async_get_tunneld_devices((TUNNELD_DEFAULT_ADDRESS[0], port))
         if len(rsds) == 0:
             raise NoDeviceConnectedError()
 
-        if udid != '':
+        if udid != "":
             try:
                 # Connect to the specified device
-                self.service_provider = [rsd for rsd in rsds if rsd.udid == udid or rsd.udid.replace('-', '') == udid][0]
-            except IndexError:
-                raise DeviceNotFoundError(udid)
+                self.service_provider = next(
+                    rsd for rsd in rsds if rsd.udid == udid or rsd.udid.replace("-", "") == udid
+                )
+            except IndexError as e:
+                raise DeviceNotFoundError(udid) from e
         else:
             if len(rsds) == 1:
                 self.service_provider = rsds[0]
@@ -323,13 +354,13 @@ class CommandWithoutAutopair(Command):
 
 
 class BasedIntParamType(click.ParamType):
-    name = 'based int'
+    name = "based int"
 
     def convert(self, value, param, ctx):
         try:
             return int(value, 0)
         except ValueError:
-            self.fail(f'{value!r} is not a valid int.', param, ctx)
+            self.fail(f"{value!r} is not a valid int.", param, ctx)
 
 
 BASED_INT = BasedIntParamType()

pymobiledevice3/cli/companion_proxy.py

@@ -12,11 +12,11 @@ def cli() -> None:
 
 @cli.group()
 def companion() -> None:
-    """ List paired "companion" devices """
+    """List paired "companion" devices"""
     pass
 
 
-@companion.command('list', cls=Command)
+@companion.command("list", cls=Command)
 def companion_list(service_provider: LockdownClient):
-    """ list all paired companion devices """
-    print_json(CompanionProxyService(service_provider).list(), default=lambda x: '<non-serializable>')
+    """list all paired companion devices"""
+    print_json(CompanionProxyService(service_provider).list(), default=lambda x: "<non-serializable>")

pymobiledevice3/cli/completions.py

@@ -7,12 +7,12 @@ from plumbum import CommandNotFound, local
 
 logger = logging.getLogger(__name__)
 
-ShellCompletion = namedtuple('ShellCompletion', ['source', 'rc', 'path'])
+ShellCompletion = namedtuple("ShellCompletion", ["source", "rc", "path"])
 
 COMPLETIONS = [
-    ShellCompletion('zsh_source', Path('~/.zshrc').expanduser(), Path('~/.pymobiledevice3.zsh').expanduser()),
-    ShellCompletion('bash_source', Path('~/.bashrc').expanduser(), Path('~/.pymobiledevice3.bash').expanduser()),
-    ShellCompletion('fish_source', None, Path('~/.config/fish/completions/pymobiledevice3.fish').expanduser()),
+    ShellCompletion("zsh_source", Path("~/.zshrc").expanduser(), Path("~/.pymobiledevice3.zsh").expanduser()),
+    ShellCompletion("bash_source", Path("~/.bashrc").expanduser(), Path("~/.pymobiledevice3.bash").expanduser()),
+    ShellCompletion("fish_source", None, Path("~/.config/fish/completions/pymobiledevice3.fish").expanduser()),
 ]
 
 
@@ -29,9 +29,9 @@ def install_completions() -> None:
     If supplying an explicit shell script to write, install it there, otherwise install globally.
     """
     try:
-        pymobiledevice3 = local['pymobiledevice3']
+        pymobiledevice3 = local["pymobiledevice3"]
     except CommandNotFound:
-        logger.error('pymobiledevice3 main binary could not be found in your path.')
+        logger.error("pymobiledevice3 main binary could not be found in your path.")
         return
 
     for completion in COMPLETIONS:
@@ -39,12 +39,12 @@ def install_completions() -> None:
             if not completion.path.parent.exists():
                 # fish is not installed, skip
                 continue
-            logger.info(f'Writing shell completions to: {completion.path}')
+            logger.info(f"Writing shell completions to: {completion.path}")
             completion.path.write_text(pymobiledevice3())
-            line = f'source {completion.path}'
+            line = f"source {completion.path}"
 
             if not completion.rc.exists() or line in completion.rc.read_text():
                 continue
 
-            logger.info(f'Adding source line to {completion.rc}')
-            completion.rc.write_text(f'{completion.rc.read_text()}\n{line}')
+            logger.info(f"Adding source line to {completion.rc}")
+            completion.rc.write_text(f"{completion.rc.read_text()}\n{line}")

pymobiledevice3/cli/crash.py

@@ -13,70 +13,76 @@ def cli() -> None:
 
 @cli.group()
 def crash() -> None:
-    """ Manage crash reports """
+    """Manage crash reports"""
     pass
 
 
-@crash.command('clear', cls=Command)
-@click.option('-f', '--flush', is_flag=True, default=False, help='flush before clear')
+@crash.command("clear", cls=Command)
+@click.option("-f", "--flush", is_flag=True, default=False, help="flush before clear")
 def crash_clear(service_provider: LockdownClient, flush):
-    """ clear(/remove) all crash reports """
+    """clear(/remove) all crash reports"""
     crash_manager = CrashReportsManager(service_provider)
     if flush:
         crash_manager.flush()
     crash_manager.clear()
 
 
-@crash.command('pull', cls=Command)
-@click.argument('out', type=click.Path(file_okay=False))
-@click.argument('remote_file', type=click.Path(), required=False)
-@click.option('-e', '--erase', is_flag=True)
-@click.option('-m', '--match', help='Match given regex over enumerated basenames')
+@crash.command("pull", cls=Command)
+@click.argument("out", type=click.Path(file_okay=False))
+@click.argument("remote_file", type=click.Path(), required=False)
+@click.option("-e", "--erase", is_flag=True)
+@click.option("-m", "--match", help="Match given regex over enumerated basenames")
 def crash_pull(service_provider: LockdownServiceProvider, out, remote_file, erase, match) -> None:
-    """ pull all crash reports """
+    """pull all crash reports"""
     if remote_file is None:
-        remote_file = '/'
+        remote_file = "/"
     CrashReportsManager(service_provider).pull(out, remote_file, erase, match)
 
 
-@crash.command('shell', cls=Command)
+@crash.command("shell", cls=Command)
 def crash_shell(service_provider: LockdownClient):
-    """ start an afc shell """
+    """start an afc shell"""
     CrashReportsShell.create(service_provider)
 
 
-@crash.command('ls', cls=Command)
-@click.argument('remote_file', type=click.Path(), required=False)
-@click.option('-d', '--depth', type=click.INT, default=1)
+@crash.command("ls", cls=Command)
+@click.argument("remote_file", type=click.Path(), required=False)
+@click.option("-d", "--depth", type=click.INT, default=1)
 def crash_ls(service_provider: LockdownClient, remote_file, depth):
-    """ List  """
+    """List"""
     if remote_file is None:
-        remote_file = '/'
+        remote_file = "/"
     for path in CrashReportsManager(service_provider).ls(remote_file, depth):
         print(path)
 
 
-@crash.command('flush', cls=Command)
+@crash.command("flush", cls=Command)
 def crash_mover_flush(service_provider: LockdownClient):
-    """ trigger com.apple.crashreportmover to flush all products into CrashReports directory """
+    """trigger com.apple.crashreportmover to flush all products into CrashReports directory"""
     CrashReportsManager(service_provider).flush()
 
 
-@crash.command('watch', cls=Command)
-@click.argument('name', required=False)
-@click.option('-r', '--raw', is_flag=True)
+@crash.command("watch", cls=Command)
+@click.argument("name", required=False)
+@click.option("-r", "--raw", is_flag=True)
 def crash_mover_watch(service_provider: LockdownClient, name, raw):
-    """ watch for crash report generation """
+    """watch for crash report generation"""
     for crash_report in CrashReportsManager(service_provider).watch(name=name, raw=raw):
         print(crash_report)
 
 
-@crash.command('sysdiagnose', cls=Command)
-@click.argument('out', type=click.Path(exists=False, dir_okay=True, file_okay=True))
-@click.option('-e', '--erase', is_flag=True, help='erase file after pulling')
-@click.option('-t', '--timeout', default=None, show_default=True, type=click.FLOAT,
-              help='Maximum time in seconds to wait for the completion of sysdiagnose archive')
+@crash.command("sysdiagnose", cls=Command)
+@click.argument("out", type=click.Path(exists=False, dir_okay=True, file_okay=True))
+@click.option("-e", "--erase", is_flag=True, help="erase file after pulling")
+@click.option(
+    "-t",
+    "--timeout",
+    default=None,
+    show_default=True,
+    type=click.FLOAT,
+    help="Maximum time in seconds to wait for the completion of sysdiagnose archive",
+)
 def crash_sysdiagnose(service_provider: LockdownClient, out, erase, timeout):
-    """ get a sysdiagnose archive from device (requires user interaction) """
-    print('Press Power+VolUp+VolDown for 0.215 seconds')
+    """get a sysdiagnose archive from device (requires user interaction)"""
+    print("Press Power+VolUp+VolDown for 0.215 seconds")
     CrashReportsManager(service_provider).get_new_sysdiagnose(out, erase=erase, timeout=timeout)