pymobiledevice3 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymobiledevice3/cli/remote.py

@@ -9,16 +9,25 @@ from typing import Optional, TextIO
 import click
 
 from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remotepairing_manual_pairing
-from pymobiledevice3.cli.cli_common import BaseCommand, RSDCommand, print_json, prompt_device_list, sudo_required, \
-    user_requested_colored_output
+from pymobiledevice3.cli.cli_common import (
+    BaseCommand,
+    RSDCommand,
+    print_json,
+    prompt_device_list,
+    sudo_required,
+    user_requested_colored_output,
+)
 from pymobiledevice3.common import get_home_folder
 from pymobiledevice3.exceptions import NoDeviceConnectedError
 from pymobiledevice3.pair_records import PAIRING_RECORD_EXT, get_remote_pairing_record_filename
 from pymobiledevice3.remote.common import ConnectionType, TunnelProtocol
 from pymobiledevice3.remote.module_imports import MAX_IDLE_TIMEOUT, start_tunnel, verify_tunnel_imports
 from pymobiledevice3.remote.remote_service_discovery import RSD_PORT, RemoteServiceDiscoveryService
-from pymobiledevice3.remote.tunnel_service import RemotePairingManualPairingService, get_core_device_tunnel_services, \
-    get_remote_pairing_tunnel_services
+from pymobiledevice3.remote.tunnel_service import (
+    RemotePairingManualPairingService,
+    get_core_device_tunnel_services,
+    get_remote_pairing_tunnel_services,
+)
 from pymobiledevice3.remote.utils import get_rsds
 from pymobiledevice3.tunneld.api import TUNNELD_DEFAULT_ADDRESS
 from pymobiledevice3.tunneld.server import TunneldRunner
@@ -29,27 +38,31 @@ logger = logging.getLogger(__name__)
 async def browse_rsd(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[dict]:
     devices = []
     for rsd in await get_rsds(timeout):
-        devices.append({'address': rsd.service.address[0],
-                        'port': RSD_PORT,
-                        'UniqueDeviceID': rsd.peer_info['Properties']['UniqueDeviceID'],
-                        'ProductType': rsd.peer_info['Properties']['ProductType'],
-                        'OSVersion': rsd.peer_info['Properties']['OSVersion']})
+        devices.append({
+            "address": rsd.service.address[0],
+            "port": RSD_PORT,
+            "UniqueDeviceID": rsd.peer_info["Properties"]["UniqueDeviceID"],
+            "ProductType": rsd.peer_info["Properties"]["ProductType"],
+            "OSVersion": rsd.peer_info["Properties"]["OSVersion"],
+        })
     return devices
 
 
 async def browse_remotepairing(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[dict]:
     devices = []
     for remotepairing in await get_remote_pairing_tunnel_services(timeout):
-        devices.append({'address': remotepairing.hostname,
-                        'port': remotepairing.port,
-                        'identifier': remotepairing.remote_identifier})
+        devices.append({
+            "address": remotepairing.hostname,
+            "port": remotepairing.port,
+            "identifier": remotepairing.remote_identifier,
+        })
     return devices
 
 
 async def cli_browse(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> None:
     print_json({
-        'usb': await browse_rsd(timeout),
-        'wifi': await browse_remotepairing(timeout),
+        "usb": await browse_rsd(timeout),
+        "wifi": await browse_remotepairing(timeout),
     })
 
 
@@ -58,105 +71,139 @@ def cli() -> None:
     pass
 
 
-@cli.group('remote')
+@cli.group("remote")
 def remote_cli() -> None:
-    """ Create RemoteXPC tunnels """
+    """Create RemoteXPC tunnels"""
     pass
 
 
-@remote_cli.command('tunneld', cls=BaseCommand)
-@click.option('--host', default=TUNNELD_DEFAULT_ADDRESS[0])
-@click.option('--port', type=click.INT, default=TUNNELD_DEFAULT_ADDRESS[1])
-@click.option('-d', '--daemonize', is_flag=True)
-@click.option('-p', '--protocol', type=click.Choice([e.value for e in TunnelProtocol]),
-              help='Transport protocol. If python version >= 3.13 will default to TCP. Otherwise will default to QUIC',
-              default=TunnelProtocol.DEFAULT.value)
-@click.option('--usb/--no-usb', default=True, help='Enable usb monitoring')
-@click.option('--wifi/--no-wifi', default=True, help='Enable wifi monitoring')
-@click.option('--usbmux/--no-usbmux', default=True, help='Enable usbmux monitoring')
-@click.option('--mobdev2/--no-mobdev2', default=True, help='Enable mobdev2 monitoring')
+@remote_cli.command("tunneld", cls=BaseCommand)
+@click.option("--host", default=TUNNELD_DEFAULT_ADDRESS[0])
+@click.option("--port", type=click.INT, default=TUNNELD_DEFAULT_ADDRESS[1])
+@click.option("-d", "--daemonize", is_flag=True)
+@click.option(
+    "-p",
+    "--protocol",
+    type=click.Choice([e.value for e in TunnelProtocol]),
+    help="Transport protocol. If python version >= 3.13 will default to TCP. Otherwise will default to QUIC",
+    default=TunnelProtocol.DEFAULT.value,
+)
+@click.option("--usb/--no-usb", default=True, help="Enable usb monitoring")
+@click.option("--wifi/--no-wifi", default=True, help="Enable wifi monitoring")
+@click.option("--usbmux/--no-usbmux", default=True, help="Enable usbmux monitoring")
+@click.option("--mobdev2/--no-mobdev2", default=True, help="Enable mobdev2 monitoring")
 @sudo_required
 def cli_tunneld(
-        host: str, port: int, daemonize: bool, protocol: str, usb: bool, wifi: bool, usbmux: bool,
-        mobdev2: bool) -> None:
-    """ Start Tunneld service for remote tunneling """
+    host: str, port: int, daemonize: bool, protocol: str, usb: bool, wifi: bool, usbmux: bool, mobdev2: bool
+) -> None:
+    """Start Tunneld service for remote tunneling"""
     if not verify_tunnel_imports():
         return
     protocol = TunnelProtocol(protocol)
-    tunneld_runner = partial(TunneldRunner.create, host, port, protocol=protocol, usb_monitor=usb, wifi_monitor=wifi,
-                             usbmux_monitor=usbmux, mobdev2_monitor=mobdev2)
+    tunneld_runner = partial(
+        TunneldRunner.create,
+        host,
+        port,
+        protocol=protocol,
+        usb_monitor=usb,
+        wifi_monitor=wifi,
+        usbmux_monitor=usbmux,
+        mobdev2_monitor=mobdev2,
+    )
     if daemonize:
         try:
             from daemonize import Daemonize
-        except ImportError:
-            raise NotImplementedError('daemonizing is only supported on unix platforms')
-        with tempfile.NamedTemporaryFile('wt') as pid_file:
-            daemon = Daemonize(app=f'Tunneld {host}:{port}', pid=pid_file.name,
-                               action=tunneld_runner)
-            logger.info(f'starting Tunneld {host}:{port}')
+        except ImportError as e:
+            raise NotImplementedError("daemonizing is only supported on unix platforms") from e
+        with tempfile.NamedTemporaryFile("wt") as pid_file:
+            daemon = Daemonize(app=f"Tunneld {host}:{port}", pid=pid_file.name, action=tunneld_runner)
+            logger.info(f"starting Tunneld {host}:{port}")
             daemon.start()
     else:
         tunneld_runner()
 
 
-@remote_cli.command('browse', cls=BaseCommand)
-@click.option('--timeout', type=click.FLOAT, default=DEFAULT_BONJOUR_TIMEOUT, help='Bonjour timeout (in seconds)')
+@remote_cli.command("browse", cls=BaseCommand)
+@click.option("--timeout", type=click.FLOAT, default=DEFAULT_BONJOUR_TIMEOUT, help="Bonjour timeout (in seconds)")
 def browse(timeout: float) -> None:
-    """ browse RemoteXPC devices using bonjour """
+    """browse RemoteXPC devices using bonjour"""
     asyncio.run(cli_browse(timeout), debug=True)
 
 
-@remote_cli.command('rsd-info', cls=RSDCommand)
+@remote_cli.command("rsd-info", cls=RSDCommand)
 def rsd_info(service_provider: RemoteServiceDiscoveryService):
-    """ show info extracted from RSD peer """
+    """show info extracted from RSD peer"""
     print_json(service_provider.peer_info)
 
 
 async def tunnel_task(
-        service, secrets: Optional[TextIO] = None, script_mode: bool = False,
-        max_idle_timeout: float = MAX_IDLE_TIMEOUT, protocol: TunnelProtocol = TunnelProtocol.DEFAULT) -> None:
+    service,
+    secrets: Optional[TextIO] = None,
+    script_mode: bool = False,
+    max_idle_timeout: float = MAX_IDLE_TIMEOUT,
+    protocol: TunnelProtocol = TunnelProtocol.DEFAULT,
+) -> None:
     async with start_tunnel(
-            service, secrets=secrets, max_idle_timeout=max_idle_timeout, protocol=protocol) as tunnel_result:
-        logger.info('tunnel created')
+        service, secrets=secrets, max_idle_timeout=max_idle_timeout, protocol=protocol
+    ) as tunnel_result:
+        logger.info("tunnel created")
         if script_mode:
-            print(f'{tunnel_result.address} {tunnel_result.port}')
+            print(f"{tunnel_result.address} {tunnel_result.port}")
         else:
             if user_requested_colored_output():
                 if secrets is not None:
-                    print(click.style('Secrets: ', bold=True, fg='magenta') +
-                          click.style(secrets.name, bold=True, fg='white'))
-                print(click.style('Identifier: ', bold=True, fg='yellow') +
-                      click.style(service.remote_identifier, bold=True, fg='white'))
-                print(click.style('Interface: ', bold=True, fg='yellow') +
-                      click.style(tunnel_result.interface, bold=True, fg='white'))
-                print(click.style('Protocol: ', bold=True, fg='yellow') +
-                      click.style(tunnel_result.protocol, bold=True, fg='white'))
-                print(click.style('RSD Address: ', bold=True, fg='yellow') +
-                      click.style(tunnel_result.address, bold=True, fg='white'))
-                print(click.style('RSD Port: ', bold=True, fg='yellow') +
-                      click.style(tunnel_result.port, bold=True, fg='white'))
-                print(click.style('Use the follow connection option:\n', bold=True, fg='yellow') +
-                      click.style(f'--rsd {tunnel_result.address} {tunnel_result.port}', bold=True, fg='cyan'))
+                    print(
+                        click.style("Secrets: ", bold=True, fg="magenta")
+                        + click.style(secrets.name, bold=True, fg="white")
+                    )
+                print(
+                    click.style("Identifier: ", bold=True, fg="yellow")
+                    + click.style(service.remote_identifier, bold=True, fg="white")
+                )
+                print(
+                    click.style("Interface: ", bold=True, fg="yellow")
+                    + click.style(tunnel_result.interface, bold=True, fg="white")
+                )
+                print(
+                    click.style("Protocol: ", bold=True, fg="yellow")
+                    + click.style(tunnel_result.protocol, bold=True, fg="white")
+                )
+                print(
+                    click.style("RSD Address: ", bold=True, fg="yellow")
+                    + click.style(tunnel_result.address, bold=True, fg="white")
+                )
+                print(
+                    click.style("RSD Port: ", bold=True, fg="yellow")
+                    + click.style(tunnel_result.port, bold=True, fg="white")
+                )
+                print(
+                    click.style("Use the follow connection option:\n", bold=True, fg="yellow")
+                    + click.style(f"--rsd {tunnel_result.address} {tunnel_result.port}", bold=True, fg="cyan")
+                )
             else:
                 if secrets is not None:
-                    print(f'Secrets: {secrets.name}')
-                print(f'Identifier: {service.remote_identifier}')
-                print(f'Interface: {tunnel_result.interface}')
-                print(f'Protocol: {tunnel_result.protocol}')
-                print(f'RSD Address: {tunnel_result.address}')
-                print(f'RSD Port: {tunnel_result.port}')
-                print(f'Use the follow connection option:\n'
-                      f'--rsd {tunnel_result.address} {tunnel_result.port}')
+                    print(f"Secrets: {secrets.name}")
+                print(f"Identifier: {service.remote_identifier}")
+                print(f"Interface: {tunnel_result.interface}")
+                print(f"Protocol: {tunnel_result.protocol}")
+                print(f"RSD Address: {tunnel_result.address}")
+                print(f"RSD Port: {tunnel_result.port}")
+                print(f"Use the follow connection option:\n--rsd {tunnel_result.address} {tunnel_result.port}")
         sys.stdout.flush()
         await tunnel_result.client.wait_closed()
-        logger.info('tunnel was closed')
+        logger.info("tunnel was closed")
 
 
 async def start_tunnel_task(
-        connection_type: ConnectionType, secrets: TextIO, udid: Optional[str] = None, script_mode: bool = False,
-        max_idle_timeout: float = MAX_IDLE_TIMEOUT, protocol: TunnelProtocol = TunnelProtocol.DEFAULT) -> None:
+    connection_type: ConnectionType,
+    secrets: TextIO,
+    udid: Optional[str] = None,
+    script_mode: bool = False,
+    max_idle_timeout: float = MAX_IDLE_TIMEOUT,
+    protocol: TunnelProtocol = TunnelProtocol.DEFAULT,
+) -> None:
     if start_tunnel is None:
-        raise NotImplementedError('failed to start the tunnel on your platform')
+        raise NotImplementedError("failed to start the tunnel on your platform")
     get_tunnel_services = {
         connection_type.USB: get_core_device_tunnel_services,
         connection_type.WIFI: get_remote_pairing_tunnel_services,
@@ -172,33 +219,57 @@ async def start_tunnel_task(
         # several devices were found, show prompt if none explicitly selected
         service = prompt_device_list(tunnel_services)
 
-    await tunnel_task(service, secrets=secrets, script_mode=script_mode, max_idle_timeout=max_idle_timeout,
-                      protocol=protocol)
-
-
-@remote_cli.command('start-tunnel', cls=BaseCommand)
-@click.option('-t', '--connection-type', type=click.Choice([e.value for e in ConnectionType], case_sensitive=False),
-              default=ConnectionType.USB.value)
-@click.option('--udid', help='UDID for a specific device to look for')
-@click.option('--secrets', type=click.File('wt'), help='TLS keyfile for decrypting with Wireshark')
-@click.option('--script-mode', is_flag=True,
-              help='Show only HOST and port number to allow easy parsing from external shell scripts')
-@click.option('--max-idle-timeout', type=click.FLOAT, default=MAX_IDLE_TIMEOUT,
-              help='Maximum QUIC idle time (ping interval)')
-@click.option('-p', '--protocol',
-              type=click.Choice([e.value for e in TunnelProtocol], case_sensitive=False),
-              default=TunnelProtocol.DEFAULT.value)
+    await tunnel_task(
+        service, secrets=secrets, script_mode=script_mode, max_idle_timeout=max_idle_timeout, protocol=protocol
+    )
+
+
+@remote_cli.command("start-tunnel", cls=BaseCommand)
+@click.option(
+    "-t",
+    "--connection-type",
+    type=click.Choice([e.value for e in ConnectionType], case_sensitive=False),
+    default=ConnectionType.USB.value,
+)
+@click.option("--udid", help="UDID for a specific device to look for")
+@click.option("--secrets", type=click.File("wt"), help="TLS keyfile for decrypting with Wireshark")
+@click.option(
+    "--script-mode",
+    is_flag=True,
+    help="Show only HOST and port number to allow easy parsing from external shell scripts",
+)
+@click.option(
+    "--max-idle-timeout", type=click.FLOAT, default=MAX_IDLE_TIMEOUT, help="Maximum QUIC idle time (ping interval)"
+)
+@click.option(
+    "-p",
+    "--protocol",
+    type=click.Choice([e.value for e in TunnelProtocol], case_sensitive=False),
+    default=TunnelProtocol.DEFAULT.value,
+)
 @sudo_required
 def cli_start_tunnel(
-        connection_type: ConnectionType, udid: Optional[str], secrets: TextIO, script_mode: bool,
-        max_idle_timeout: float, protocol: str) -> None:
-    """ start tunnel """
+    connection_type: ConnectionType,
+    udid: Optional[str],
+    secrets: TextIO,
+    script_mode: bool,
+    max_idle_timeout: float,
+    protocol: str,
+) -> None:
+    """start tunnel"""
     if not verify_tunnel_imports():
         return
     asyncio.run(
         start_tunnel_task(
-            ConnectionType(connection_type), secrets, udid, script_mode, max_idle_timeout=max_idle_timeout,
-            protocol=TunnelProtocol(protocol)), debug=True)
+            ConnectionType(connection_type),
+            secrets,
+            udid,
+            script_mode,
+            max_idle_timeout=max_idle_timeout,
+            protocol=TunnelProtocol(protocol),
+        ),
+        debug=True,
+    )
 
 
 @dataclasses.dataclass
@@ -211,43 +282,48 @@ class RemotePairingManualPairingDevice:
 
 async def start_remote_pair_task(device_name: str) -> None:
     if start_tunnel is None:
-        raise NotImplementedError('failed to start the tunnel on your platform')
+        raise NotImplementedError("failed to start the tunnel on your platform")
 
     devices: list[RemotePairingManualPairingDevice] = []
     for answer in await browse_remotepairing_manual_pairing():
-        current_device_name = answer.properties[b'name'].decode()
+        current_device_name = answer.properties[b"name"].decode()
 
         if device_name is not None and current_device_name != device_name:
             continue
 
         for address in answer.addresses:
             devices.append(
-                RemotePairingManualPairingDevice(ip=address.full_ip, port=answer.port, device_name=current_device_name,
-                                                 identifier=answer.properties[b'identifier'].decode()))
+                RemotePairingManualPairingDevice(
+                    ip=address.full_ip,
+                    port=answer.port,
+                    device_name=current_device_name,
+                    identifier=answer.properties[b"identifier"].decode(),
+                )
+            )
 
     if len(devices) > 0:
         device = prompt_device_list(devices)
     else:
-        logger.error('No devices were found during bonjour browse')
+        logger.error("No devices were found during bonjour browse")
         return
 
     async with RemotePairingManualPairingService(device.identifier, device.ip, device.port) as service:
         await service.connect(autopair=True)
 
 
-@remote_cli.command('pair', cls=BaseCommand)
-@click.option('--name', help='Device name for a specific device to look for')
+@remote_cli.command("pair", cls=BaseCommand)
+@click.option("--name", help="Device name for a specific device to look for")
 def cli_pair(name: Optional[str]) -> None:
-    """ start remote pairing for devices which allow """
+    """start remote pairing for devices which allow"""
     asyncio.run(start_remote_pair_task(name), debug=True)
 
 
-@remote_cli.command('delete-pair', cls=BaseCommand)
-@click.argument('udid')
+@remote_cli.command("delete-pair", cls=BaseCommand)
+@click.argument("udid")
 @sudo_required
 def cli_delete_pair(udid: str):
-    """ delete a pairing record """
-    pair_record_path = get_home_folder() / f'{get_remote_pairing_record_filename(udid)}.{PAIRING_RECORD_EXT}'
+    """delete a pairing record"""
+    pair_record_path = get_home_folder() / f"{get_remote_pairing_record_filename(udid)}.{PAIRING_RECORD_EXT}"
     pair_record_path.unlink()
 
 
@@ -256,8 +332,8 @@ async def cli_service_task(service_provider: RemoteServiceDiscoveryService, serv
         service.shell()
 
 
-@remote_cli.command('service', cls=RSDCommand)
-@click.argument('service_name')
+@remote_cli.command("service", cls=RSDCommand)
+@click.argument("service_name")
 def cli_service(service_provider: RemoteServiceDiscoveryService, service_name: str) -> None:
-    """ start an ipython shell for interacting with given service """
+    """start an ipython shell for interacting with given service"""
     asyncio.run(cli_service_task(service_provider, service_name), debug=True)

pymobiledevice3/cli/restore.py

@@ -32,15 +32,15 @@ print(irecv.getenv('build-version'))
 """
 
 logger = logging.getLogger(__name__)
-IPSWME_API = 'https://api.ipsw.me/v4/device/'
+IPSWME_API = "https://api.ipsw.me/v4/device/"
 
 
 class Command(click.Command):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.params[:0] = [
-            click.Option(('device', '--ecid'), type=click.INT, callback=self.device),
-            click.Option(('verbosity', '-v', '--verbose'), count=True, callback=set_verbosity, expose_value=False),
+            click.Option(("device", "--ecid"), type=click.INT, callback=self.device),
+            click.Option(("verbosity", "-v", "--verbose"), count=True, callback=set_verbosity, expose_value=False),
         ]
 
     @staticmethod
@@ -50,32 +50,32 @@ class Command(click.Command):
             return
 
         ecid = value
-        logger.debug('searching among connected devices via lockdownd')
-        devices = [dev for dev in usbmux.list_devices() if dev.connection_type == 'USB']
+        logger.debug("searching among connected devices via lockdownd")
+        devices = [dev for dev in usbmux.list_devices() if dev.connection_type == "USB"]
         if len(devices) > 1:
-            raise click.ClickException('Multiple device detected')
+            raise click.ClickException("Multiple device detected")
         try:
             for device in devices:
                 try:
-                    lockdown = create_using_usbmux(serial=device.serial, connection_type='USB')
+                    lockdown = create_using_usbmux(serial=device.serial, connection_type="USB")
                 except (ConnectionFailedError, IncorrectModeError):
                     continue
                 if (ecid is None) or (lockdown.ecid == value):
-                    logger.debug('found device')
+                    logger.debug("found device")
                     return lockdown
                 else:
                     continue
         except ConnectionFailedToUsbmuxdError:
             pass
 
-        logger.debug('waiting for device to be available in Recovery mode')
+        logger.debug("waiting for device to be available in Recovery mode")
         return IRecv(ecid=ecid)
 
 
 @contextlib.contextmanager
 def tempzip_download_ctx(url: str) -> Generator[ZipFile, None, None]:
     with tempfile.TemporaryDirectory() as tmpdir:
-        tmpzip = Path(tmpdir) / url.split('/')[-1]
+        tmpzip = Path(tmpdir) / url.split("/")[-1]
         file_download(url, tmpzip)
         yield ZipFile(tmpzip)
 
@@ -88,18 +88,19 @@ def zipfile_ctx(path: str) -> Generator[ZipFile, None, None]:
 class IPSWCommand(Command):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.params.extend([click.Option(('ipsw_ctx', '-i', '--ipsw'), required=False,
-                                         callback=self.ipsw_ctx, help='local IPSW file'),
-                            click.Option(('tss', '--tss'), type=click.File('rb'), callback=self.tss)])
+        self.params.extend([
+            click.Option(("ipsw_ctx", "-i", "--ipsw"), required=False, callback=self.ipsw_ctx, help="local IPSW file"),
+            click.Option(("tss", "--tss"), type=click.File("rb"), callback=self.tss),
+        ])
 
     @staticmethod
     def ipsw_ctx(ctx, param, value) -> Generator[ZipFile, None, None]:
-        if value and not value.startswith(('http://', 'https://')):
+        if value and not value.startswith(("http://", "https://")):
             return zipfile_ctx(value)
 
         url = value
         if url is None:
-            url = query_ipswme(ctx.params['device'].product_type)
+            url = query_ipswme(ctx.params["device"].product_type)
         return tempzip_download_ctx(url)
 
     @staticmethod
@@ -110,11 +111,11 @@ class IPSWCommand(Command):
 
 
 def query_ipswme(identifier: str) -> str:
-    resp = requests.get(IPSWME_API + identifier, headers={'Accept': 'application/json'})
-    firmwares = resp.json()['firmwares']
-    display_list = [f'{entry["version"]}: {entry["buildid"]}' for entry in firmwares if entry['signed']]
-    idx = prompt_selection(display_list, 'Choose version', idx=True)
-    return firmwares[idx]['url']
+    resp = requests.get(IPSWME_API + identifier, headers={"Accept": "application/json"})
+    firmwares = resp.json()["firmwares"]
+    display_list = [f"{entry['version']}: {entry['buildid']}" for entry in firmwares if entry["signed"]]
+    idx = prompt_selection(display_list, "Choose version", idx=True)
+    return firmwares[idx]["url"]
 
 
 async def restore_update_task(device: Device, ipsw: ZipFile, tss: Optional[IO], erase: bool, ignore_fdr: bool) -> None:
@@ -145,38 +146,39 @@ def cli() -> None:
 
 @cli.group()
 def restore() -> None:
-    """ Restore an IPSW or access device in recovery mode """
+    """Restore an IPSW or access device in recovery mode"""
     pass
 
 
-@restore.command('shell', cls=Command)
+@restore.command("shell", cls=Command)
 def restore_shell(device):
-    """ create an IPython shell for interacting with iBoot """
+    """create an IPython shell for interacting with iBoot"""
     IPython.embed(
-        header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style='native')),
+        header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")),
         user_ns={
-            'irecv': device,
-        })
+            "irecv": device,
+        },
+    )
 
 
-@restore.command('enter', cls=Command)
+@restore.command("enter", cls=Command)
 def restore_enter(device):
-    """ enter Recovery mode """
+    """enter Recovery mode"""
     if isinstance(device, LockdownClient):
         device.enter_recovery()
 
 
-@restore.command('exit')
+@restore.command("exit")
 def restore_exit():
-    """ exit Recovery mode """
+    """exit Recovery mode"""
     irecv = IRecv()
     irecv.set_autoboot(True)
     irecv.reboot()
 
 
-@restore.command('restart', cls=Command)
+@restore.command("restart", cls=Command)
 def restore_restart(device):
-    """ restarts device """
+    """restarts device"""
     if isinstance(device, LockdownClient):
         with DiagnosticsService(device) as diagnostics:
             diagnostics.restart()
@@ -200,10 +202,10 @@ async def restore_tss_task(device: Device, ipsw_ctx: Generator, tss: IO, out: Op
     print_json(tss)
 
 
-@restore.command('tss', cls=IPSWCommand)
-@click.argument('out', type=click.File('wb'), required=False)
+@restore.command("tss", cls=IPSWCommand)
+@click.argument("out", type=click.File("wb"), required=False)
 def restore_tss(device: Device, ipsw_ctx: Generator, tss: IO, out: Optional[IO]) -> None:
-    """ query SHSH blobs """
+    """query SHSH blobs"""
     asyncio.run(restore_tss_task(device, ipsw_ctx, tss, out), debug=True)
 
 
@@ -220,7 +222,7 @@ async def restore_ramdisk_task(device: Device, ipsw_ctx: Generator) -> None:
         await Recovery(ipsw, device).boot_ramdisk()
 
 
-@restore.command('ramdisk', cls=IPSWCommand)
+@restore.command("ramdisk", cls=IPSWCommand)
 def restore_ramdisk(device: Device, ipsw_ctx: Generator, tss: IO) -> None:
     """
     don't perform an actual restore. just enter the update ramdisk
@@ -230,10 +232,11 @@ def restore_ramdisk(device: Device, ipsw_ctx: Generator, tss: IO) -> None:
     asyncio.run(restore_ramdisk_task(device, ipsw_ctx), debug=True)
 
 
-@restore.command('update', cls=IPSWCommand)
-@click.option('--erase', is_flag=True, help='use the Erase BuildIdentity (full factory-reset)')
-@click.option('--ignore-fdr', is_flag=True, help='only establish an FDR service connection, but don\'t proxy any '
-                                                 'traffic')
+@restore.command("update", cls=IPSWCommand)
+@click.option("--erase", is_flag=True, help="use the Erase BuildIdentity (full factory-reset)")
+@click.option(
+    "--ignore-fdr", is_flag=True, help="only establish an FDR service connection, but don't proxy any traffic"
+)
 def restore_update(device: Device, ipsw_ctx: Generator, tss: IO, erase: bool, ignore_fdr: bool) -> None:
     """
     perform an update