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

pymobiledevice3/cli/diagnostics.py

@@ -18,88 +18,93 @@ def cli() -> None:
 
 @cli.group()
 def diagnostics() -> None:
-    """ Reboot/Shutdown device or access other diagnostics services """
+    """Reboot/Shutdown device or access other diagnostics services"""
     pass
 
 
-@diagnostics.command('restart', cls=Command)
-@click.option('-r', '--reconnect', is_flag=True, default=False,
-              help='Wait until the device reconnects before finishing the operation.')
+@diagnostics.command("restart", cls=Command)
+@click.option(
+    "-r",
+    "--reconnect",
+    is_flag=True,
+    default=False,
+    help="Wait until the device reconnects before finishing the operation.",
+)
 def diagnostics_restart(service_provider: LockdownClient, reconnect):
-    """ Restart device """
+    """Restart device"""
     DiagnosticsService(lockdown=service_provider).restart()
     if reconnect:
         # Wait for the device to be available again
         with retry_create_using_usbmux(None, serial=service_provider.udid):
-            print(f'Device Reconnected ({service_provider.udid}).')
+            print(f"Device Reconnected ({service_provider.udid}).")
 
 
-@diagnostics.command('shutdown', cls=Command)
+@diagnostics.command("shutdown", cls=Command)
 def diagnostics_shutdown(service_provider: LockdownClient):
-    """ Shutdown device """
+    """Shutdown device"""
     DiagnosticsService(lockdown=service_provider).shutdown()
 
 
-@diagnostics.command('sleep', cls=Command)
+@diagnostics.command("sleep", cls=Command)
 def diagnostics_sleep(service_provider: LockdownClient):
-    """ Put device into sleep """
+    """Put device into sleep"""
     DiagnosticsService(lockdown=service_provider).sleep()
 
 
-@diagnostics.command('info', cls=Command)
+@diagnostics.command("info", cls=Command)
 def diagnostics_info(service_provider: LockdownClient):
-    """ Get diagnostics info """
+    """Get diagnostics info"""
     print_json(DiagnosticsService(lockdown=service_provider).info())
 
 
-@diagnostics.command('ioregistry', cls=Command)
-@click.option('--plane')
-@click.option('--name')
-@click.option('--ioclass')
+@diagnostics.command("ioregistry", cls=Command)
+@click.option("--plane")
+@click.option("--name")
+@click.option("--ioclass")
 def diagnostics_ioregistry(service_provider: LockdownClient, plane, name, ioclass):
-    """ Get ioregistry info """
+    """Get ioregistry info"""
     print_json(DiagnosticsService(lockdown=service_provider).ioregistry(plane=plane, name=name, ioclass=ioclass))
 
 
-@diagnostics.command('mg', cls=Command)
-@click.argument('keys', nargs=-1, default=None)
+@diagnostics.command("mg", cls=Command)
+@click.argument("keys", nargs=-1, default=None)
 def diagnostics_mg(service_provider: LockdownClient, keys):
-    """ Get MobileGestalt key values from given list. If empty, return all known. """
+    """Get MobileGestalt key values from given list. If empty, return all known."""
     print_json(DiagnosticsService(lockdown=service_provider).mobilegestalt(keys=keys))
 
 
-@diagnostics.group('battery')
+@diagnostics.group("battery")
 def diagnostics_battery():
-    """ Battery options """
+    """Battery options"""
     pass
 
 
-@diagnostics_battery.command('single', cls=Command)
+@diagnostics_battery.command("single", cls=Command)
 def diagnostics_battery_single(service_provider: LockdownClient):
-    """ get single snapshot of battery data """
+    """get single snapshot of battery data"""
     raw_info = DiagnosticsService(lockdown=service_provider).get_battery()
     print_json(raw_info)
 
 
-@diagnostics_battery.command('monitor', cls=Command)
+@diagnostics_battery.command("monitor", cls=Command)
 def diagnostics_battery_monitor(service_provider: LockdownClient):
-    """ monitor battery usage """
+    """monitor battery usage"""
     diagnostics = DiagnosticsService(lockdown=service_provider)
     while True:
         raw_info = diagnostics.get_battery()
         info = {
-            'InstantAmperage': raw_info.get('InstantAmperage'),
-            'Temperature': raw_info.get('Temperature'),
-            'Voltage': raw_info.get('Voltage'),
-            'IsCharging': raw_info.get('IsCharging'),
-            'CurrentCapacity': raw_info.get('CurrentCapacity'),
+            "InstantAmperage": raw_info.get("InstantAmperage"),
+            "Temperature": raw_info.get("Temperature"),
+            "Voltage": raw_info.get("Voltage"),
+            "IsCharging": raw_info.get("IsCharging"),
+            "CurrentCapacity": raw_info.get("CurrentCapacity"),
         }
         logger.info(info)
         time.sleep(1)
 
 
-@diagnostics.command('wifi', cls=Command)
+@diagnostics.command("wifi", cls=Command)
 def diagnostics_wifi(service_provider: LockdownServiceProvider) -> None:
-    """ Query WiFi info from IORegistry """
+    """Query WiFi info from IORegistry"""
     raw_info = DiagnosticsService(lockdown=service_provider).get_wifi()
     print_json(raw_info)

pymobiledevice3/cli/lockdown.py

@@ -22,169 +22,174 @@ def cli() -> None:
     pass
 
 
-@cli.group('lockdown')
+@cli.group("lockdown")
 def lockdown_group() -> None:
-    """ Pair/Unpair device or access other lockdown services """
+    """Pair/Unpair device or access other lockdown services"""
     pass
 
 
-@lockdown_group.command('recovery', cls=Command)
+@lockdown_group.command("recovery", cls=Command)
 def lockdown_recovery(service_provider: LockdownClient):
-    """ enter recovery """
+    """enter recovery"""
     print_json(service_provider.enter_recovery())
 
 
-@lockdown_group.command('service', cls=Command)
-@click.argument('service_name')
+@lockdown_group.command("service", cls=Command)
+@click.argument("service_name")
 def lockdown_service(service_provider: LockdownServiceProvider, service_name):
-    """ send-receive raw service messages with a given service name"""
+    """send-receive raw service messages with a given service name"""
     service_provider.start_lockdown_service(service_name).shell()
 
 
-@lockdown_group.command('developer-service', cls=Command)
-@click.argument('service_name')
+@lockdown_group.command("developer-service", cls=Command)
+@click.argument("service_name")
 def lockdown_developer_service(service_provider: LockdownServiceProvider, service_name):
-    """ send-receive raw service messages with a given developer service name """
+    """send-receive raw service messages with a given developer service name"""
     service_provider.start_lockdown_developer_service(service_name).shell()
 
 
-@lockdown_group.command('info', cls=Command)
+@lockdown_group.command("info", cls=Command)
 def lockdown_info(service_provider: LockdownServiceProvider):
-    """ query all lockdown values """
+    """query all lockdown values"""
     print_json(service_provider.all_values)
 
 
-@lockdown_group.command('get', cls=Command)
-@click.argument('domain', required=False)
-@click.argument('key', required=False)
+@lockdown_group.command("get", cls=Command)
+@click.argument("domain", required=False)
+@click.argument("key", required=False)
 def lockdown_get(service_provider: LockdownClient, domain, key):
-    """ query lockdown values by their domain and key names """
+    """query lockdown values by their domain and key names"""
     print_json(service_provider.get_value(domain=domain, key=key))
 
 
-@lockdown_group.command('set', cls=Command)
-@click.argument('value')
-@click.argument('domain', required=False)
-@click.argument('key', required=False)
+@lockdown_group.command("set", cls=Command)
+@click.argument("value")
+@click.argument("domain", required=False)
+@click.argument("key", required=False)
 def lockdown_set(service_provider: LockdownClient, value, domain, key):
-    """ set a lockdown value using python's eval() """
+    """set a lockdown value using python's eval()"""
     print_json(service_provider.set_value(value=eval(value), domain=domain, key=key))
 
 
-@lockdown_group.command('remove', cls=Command)
-@click.argument('domain')
-@click.argument('key')
+@lockdown_group.command("remove", cls=Command)
+@click.argument("domain")
+@click.argument("key")
 def lockdown_remove(service_provider: LockdownClient, domain, key):
-    """ remove a domain/key pair """
+    """remove a domain/key pair"""
     print_json(service_provider.remove_value(domain=domain, key=key))
 
 
-@lockdown_group.command('unpair', cls=CommandWithoutAutopair)
-@click.argument('host_id', required=False)
-def lockdown_unpair(service_provider: LockdownClient, host_id: str = None):
-    """ unpair from connected device """
+@lockdown_group.command("unpair", cls=CommandWithoutAutopair)
+@click.argument("host_id", required=False)
+def lockdown_unpair(service_provider: LockdownClient, host_id: Optional[str] = None):
+    """unpair from connected device"""
     service_provider.unpair(host_id=host_id)
 
 
-@lockdown_group.command('pair', cls=CommandWithoutAutopair)
+@lockdown_group.command("pair", cls=CommandWithoutAutopair)
 def lockdown_pair(service_provider: LockdownClient):
-    """ pair device """
+    """pair device"""
     service_provider.pair()
 
 
-@lockdown_group.command('pair-supervised', cls=CommandWithoutAutopair)
-@click.argument('keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
+@lockdown_group.command("pair-supervised", cls=CommandWithoutAutopair)
+@click.argument("keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
 def lockdown_pair_supervised(service_provider: LockdownClient, keybag: str) -> None:
-    """ pair supervised device """
+    """pair supervised device"""
     service_provider.pair_supervised(Path(keybag))
 
 
-@lockdown_group.command('save-pair-record', cls=CommandWithoutAutopair)
-@click.argument('output', type=click.File('wb'))
+@lockdown_group.command("save-pair-record", cls=CommandWithoutAutopair)
+@click.argument("output", type=click.File("wb"))
 def lockdown_save_pair_record(service_provider: LockdownClient, output):
-    """ save pair record to specified location """
+    """save pair record to specified location"""
     if service_provider.pair_record is None:
-        logger.error('no pairing record was found')
+        logger.error("no pairing record was found")
         return
     plistlib.dump(service_provider.pair_record, output)
 
 
-@lockdown_group.command('date', cls=Command)
+@lockdown_group.command("date", cls=Command)
 def lockdown_date(service_provider: LockdownClient):
-    """ get device date """
+    """get device date"""
     print(service_provider.date)
 
 
-@lockdown_group.command('heartbeat', cls=Command)
+@lockdown_group.command("heartbeat", cls=Command)
 def lockdown_heartbeat(service_provider: LockdownClient):
-    """ start heartbeat service """
+    """start heartbeat service"""
     HeartbeatService(service_provider).start()
 
 
-@lockdown_group.command('language', cls=Command)
-@click.argument('language', required=False)
+@lockdown_group.command("language", cls=Command)
+@click.argument("language", required=False)
 def lockdown_language(service_provider: LockdownClient, language: Optional[str]) -> None:
-    """ Get/Set current language settings """
+    """Get/Set current language settings"""
     if language is not None:
         service_provider.set_language(language)
     print_json(service_provider.language)
 
 
-@lockdown_group.command('locale', cls=Command)
-@click.argument('locale', required=False)
+@lockdown_group.command("locale", cls=Command)
+@click.argument("locale", required=False)
 def lockdown_locale(service_provider: LockdownClient, locale: Optional[str]) -> None:
-    """ Get/Set current language settings """
+    """Get/Set current language settings"""
     if locale is not None:
         service_provider.set_locale(locale)
     print_json(service_provider.locale)
 
 
-@lockdown_group.command('device-name', cls=Command)
-@click.argument('new_name', required=False)
+@lockdown_group.command("device-name", cls=Command)
+@click.argument("new_name", required=False)
 def lockdown_device_name(service_provider: LockdownClient, new_name):
-    """ get/set current device name """
+    """get/set current device name"""
     if new_name:
-        service_provider.set_value(new_name, key='DeviceName')
+        service_provider.set_value(new_name, key="DeviceName")
     else:
-        print(f'{service_provider.get_value(key="DeviceName")}')
+        print(f"{service_provider.get_value(key='DeviceName')}")
 
 
-@lockdown_group.command('wifi-connections', cls=Command)
-@click.argument('state', type=click.Choice(['on', 'off']), required=False)
+@lockdown_group.command("wifi-connections", cls=Command)
+@click.argument("state", type=click.Choice(["on", "off"]), required=False)
 def lockdown_wifi_connections(service_provider: LockdownClient, state):
-    """ get/set wifi connections state """
+    """get/set wifi connections state"""
     if not state:
         # show current state
-        print_json(service_provider.get_value(domain='com.apple.mobile.wireless_lockdown'))
+        print_json(service_provider.get_value(domain="com.apple.mobile.wireless_lockdown"))
     else:
         # enable/disable
-        service_provider.enable_wifi_connections = state == 'on'
+        service_provider.enable_wifi_connections = state == "on"
 
 
-async def async_cli_start_tunnel(
-        service_provider: LockdownServiceProvider, script_mode: bool) -> None:
-    await tunnel_task(await CoreDeviceTunnelProxy.create(service_provider),
-                      script_mode=script_mode, secrets=None, protocol=TunnelProtocol.TCP)
+async def async_cli_start_tunnel(service_provider: LockdownServiceProvider, script_mode: bool) -> None:
+    await tunnel_task(
+        await CoreDeviceTunnelProxy.create(service_provider),
+        script_mode=script_mode,
+        secrets=None,
+        protocol=TunnelProtocol.TCP,
+    )
 
 
-@lockdown_group.command('start-tunnel', cls=Command)
-@click.option('--script-mode', is_flag=True,
-              help='Show only HOST and port number to allow easy parsing from external shell scripts')
+@lockdown_group.command("start-tunnel", cls=Command)
+@click.option(
+    "--script-mode",
+    is_flag=True,
+    help="Show only HOST and port number to allow easy parsing from external shell scripts",
+)
 @sudo_required
-def cli_start_tunnel(
-        service_provider: LockdownServiceProvider, script_mode: bool) -> None:
-    """ start tunnel """
+def cli_start_tunnel(service_provider: LockdownServiceProvider, script_mode: bool) -> None:
+    """start tunnel"""
     asyncio.run(async_cli_start_tunnel(service_provider, script_mode), debug=True)
 
 
-@lockdown_group.command('assistive-touch', cls=Command)
-@click.argument('state', type=click.Choice(['on', 'off']), required=False)
+@lockdown_group.command("assistive-touch", cls=Command)
+@click.argument("state", type=click.Choice(["on", "off"]), required=False)
 def lockdown_assistive_touch(service_provider: LockdownClient, state: str) -> None:
-    """ get/set assistive touch icon state (visibility) """
+    """get/set assistive touch icon state (visibility)"""
     if not state:
-        key = 'AssistiveTouchEnabledByiTunes'
-        accessibility_values = service_provider.get_value('com.apple.Accessibility')
+        key = "AssistiveTouchEnabledByiTunes"
+        accessibility_values = service_provider.get_value("com.apple.Accessibility")
         print_json({key: bool(accessibility_values[key])})
     else:
         # enable/disable
-        service_provider.assistive_touch = state == 'on'
+        service_provider.assistive_touch = state == "on"

pymobiledevice3/cli/mounter.py

@@ -7,12 +7,20 @@ from urllib.error import URLError
 import click
 
 from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.exceptions import AlreadyMountedError, DeveloperDiskImageNotFoundError, NotMountedError, \
-    UnsupportedCommandError
+from pymobiledevice3.exceptions import (
+    AlreadyMountedError,
+    DeveloperDiskImageNotFoundError,
+    NotMountedError,
+    UnsupportedCommandError,
+)
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
-from pymobiledevice3.services.mobile_image_mounter import DeveloperDiskImageMounter, MobileImageMounterService, \
-    PersonalizedImageMounter, auto_mount
+from pymobiledevice3.services.mobile_image_mounter import (
+    DeveloperDiskImageMounter,
+    MobileImageMounterService,
+    PersonalizedImageMounter,
+    auto_mount,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -22,9 +30,9 @@ def catch_errors(func):
         try:
             return func(*args, **kwargs)
         except AlreadyMountedError:
-            logger.error('Given image was already mounted')
+            logger.exception("Given image was already mounted")
         except UnsupportedCommandError:
-            logger.error('Your iOS version doesn\'t support this command')
+            logger.exception("Your iOS version doesn't support this command")
 
     return update_wrapper(catch_function, func)
 
@@ -36,147 +44,156 @@ def cli() -> None:
 
 @cli.group()
 def mounter() -> None:
-    """ Mount/Umount DeveloperDiskImage or query related info """
+    """Mount/Umount DeveloperDiskImage or query related info"""
     pass
 
 
-@mounter.command('list', cls=Command)
+@mounter.command("list", cls=Command)
 def mounter_list(service_provider: LockdownClient):
-    """ list all mounted images """
+    """list all mounted images"""
     output = []
 
     images = MobileImageMounterService(lockdown=service_provider).copy_devices()
     for image in images:
-        image_signature = image.get('ImageSignature')
+        image_signature = image.get("ImageSignature")
         if image_signature is not None:
-            image['ImageSignature'] = image_signature.hex()
+            image["ImageSignature"] = image_signature.hex()
         output.append(image)
 
     print_json(output)
 
 
-@mounter.command('lookup', cls=Command)
-@click.argument('image_type')
+@mounter.command("lookup", cls=Command)
+@click.argument("image_type")
 def mounter_lookup(service_provider: LockdownClient, image_type):
-    """ lookup mounter image type """
+    """lookup mounter image type"""
     try:
         signature = MobileImageMounterService(lockdown=service_provider).lookup_image(image_type)
         print_json(signature)
     except NotMountedError:
-        logger.error(f'Disk image of type: {image_type} is not mounted')
+        logger.exception(f"Disk image of type: {image_type} is not mounted")
 
 
-@mounter.command('umount-developer', cls=Command)
+@mounter.command("umount-developer", cls=Command)
 @catch_errors
 def mounter_umount_developer(service_provider: LockdownClient):
-    """ unmount Developer image """
+    """unmount Developer image"""
     try:
         DeveloperDiskImageMounter(lockdown=service_provider).umount()
-        logger.info('Developer image unmounted successfully')
+        logger.info("Developer image unmounted successfully")
     except NotMountedError:
-        logger.error('Developer image isn\'t currently mounted')
+        logger.exception("Developer image isn't currently mounted")
 
 
-@mounter.command('umount-personalized', cls=Command)
+@mounter.command("umount-personalized", cls=Command)
 @catch_errors
 def mounter_umount_personalized(service_provider: LockdownClient):
-    """ unmount Personalized image """
+    """unmount Personalized image"""
     try:
         PersonalizedImageMounter(lockdown=service_provider).umount()
-        logger.info('Personalized image unmounted successfully')
+        logger.info("Personalized image unmounted successfully")
     except NotMountedError:
-        logger.error('Personalized image isn\'t currently mounted')
+        logger.exception("Personalized image isn't currently mounted")
 
 
-@mounter.command('mount-developer', cls=Command)
-@click.argument('image', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('signature', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@mounter.command("mount-developer", cls=Command)
+@click.argument("image", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("signature", type=click.Path(exists=True, file_okay=True, dir_okay=False))
 @catch_errors
 def mounter_mount_developer(service_provider: LockdownServiceProvider, image: str, signature: str) -> None:
-    """ mount developer image """
+    """mount developer image"""
     DeveloperDiskImageMounter(lockdown=service_provider).mount(Path(image), Path(signature))
-    logger.info('Developer image mounted successfully')
+    logger.info("Developer image mounted successfully")
 
 
-async def mounter_mount_personalized_task(service_provider: LockdownServiceProvider, image: str, trust_cache: str,
-                                          build_manifest: str) -> None:
-    await PersonalizedImageMounter(lockdown=service_provider).mount(Path(image), Path(build_manifest),
-                                                                    Path(trust_cache))
-    logger.info('Personalized image mounted successfully')
+async def mounter_mount_personalized_task(
+    service_provider: LockdownServiceProvider, image: str, trust_cache: str, build_manifest: str
+) -> None:
+    await PersonalizedImageMounter(lockdown=service_provider).mount(
+        Path(image), Path(build_manifest), Path(trust_cache)
+    )
+    logger.info("Personalized image mounted successfully")
 
 
-@mounter.command('mount-personalized', cls=Command)
-@click.argument('image', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('trust-cache', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.argument('build-manifest', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@mounter.command("mount-personalized", cls=Command)
+@click.argument("image", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("trust-cache", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("build-manifest", type=click.Path(exists=True, file_okay=True, dir_okay=False))
 @catch_errors
-def mounter_mount_personalized(service_provider: LockdownServiceProvider, image: str, trust_cache: str,
-                               build_manifest: str) -> None:
-    """ mount personalized image """
+def mounter_mount_personalized(
+    service_provider: LockdownServiceProvider, image: str, trust_cache: str, build_manifest: str
+) -> None:
+    """mount personalized image"""
     asyncio.run(mounter_mount_personalized_task(service_provider, image, trust_cache, build_manifest), debug=True)
 
 
 async def mounter_auto_mount_task(service_provider: LockdownServiceProvider, xcode: str, version: str) -> None:
     try:
         await auto_mount(service_provider, xcode=xcode, version=version)
-        logger.info('DeveloperDiskImage mounted successfully')
+        logger.info("DeveloperDiskImage mounted successfully")
     except URLError:
-        logger.warning('failed to query DeveloperDiskImage versions')
+        logger.warning("failed to query DeveloperDiskImage versions")
     except DeveloperDiskImageNotFoundError:
-        logger.error('Unable to find the correct DeveloperDiskImage')
+        logger.exception("Unable to find the correct DeveloperDiskImage")
     except AlreadyMountedError:
-        logger.error('DeveloperDiskImage already mounted')
+        logger.exception("DeveloperDiskImage already mounted")
     except PermissionError as e:
-        logger.error(
-            f'DeveloperDiskImage could not be saved to Xcode default path ({e.filename}). '
-            f'Please make sure your user has the necessary permissions')
-
-
-@mounter.command('auto-mount', cls=Command)
-@click.option('-x', '--xcode', type=click.Path(exists=True, dir_okay=True, file_okay=False),
-              help='Xcode application path used to figure out automatically the DeveloperDiskImage path')
-@click.option('--version', help='use a different DeveloperDiskImage version from the one retrieved by lockdown'
-                                'connection')
+        logger.exception(
+            f"DeveloperDiskImage could not be saved to Xcode default path ({e.filename}). "
+            f"Please make sure your user has the necessary permissions"
+        )
+
+
+@mounter.command("auto-mount", cls=Command)
+@click.option(
+    "-x",
+    "--xcode",
+    type=click.Path(exists=True, dir_okay=True, file_okay=False),
+    help="Xcode application path used to figure out automatically the DeveloperDiskImage path",
+)
+@click.option(
+    "--version", help="use a different DeveloperDiskImage version from the one retrieved by lockdownconnection"
+)
 def mounter_auto_mount(service_provider: LockdownServiceProvider, xcode: str, version: str) -> None:
-    """ auto-detect correct DeveloperDiskImage and mount it """
+    """auto-detect correct DeveloperDiskImage and mount it"""
     asyncio.run(mounter_auto_mount_task(service_provider, xcode, version), debug=True)
 
 
-@mounter.command('query-developer-mode-status', cls=Command)
+@mounter.command("query-developer-mode-status", cls=Command)
 def mounter_query_developer_mode_status(service_provider: LockdownClient):
-    """ Query developer mode status """
+    """Query developer mode status"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_developer_mode_status())
 
 
-@mounter.command('query-nonce', cls=Command)
-@click.option('--image-type')
+@mounter.command("query-nonce", cls=Command)
+@click.option("--image-type")
 def mounter_query_nonce(service_provider: LockdownClient, image_type: str):
-    """ Query nonce """
+    """Query nonce"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_nonce(image_type))
 
 
-@mounter.command('query-personalization-identifiers', cls=Command)
+@mounter.command("query-personalization-identifiers", cls=Command)
 def mounter_query_personalization_identifiers(service_provider: LockdownClient):
-    """ Query personalization identifiers """
+    """Query personalization identifiers"""
     print_json(MobileImageMounterService(lockdown=service_provider).query_personalization_identifiers())
 
 
-@mounter.command('query-personalization-manifest', cls=Command)
+@mounter.command("query-personalization-manifest", cls=Command)
 def mounter_query_personalization_manifest(service_provider: LockdownClient):
-    """ Query personalization manifest """
+    """Query personalization manifest"""
     result = []
     mounter = MobileImageMounterService(lockdown=service_provider)
     for device in mounter.copy_devices():
-        result.append(mounter.query_personalization_manifest(device['PersonalizedImageType'], device['ImageSignature']))
+        result.append(mounter.query_personalization_manifest(device["PersonalizedImageType"], device["ImageSignature"]))
     print_json(result)
 
 
-@mounter.command('roll-personalization-nonce', cls=Command)
+@mounter.command("roll-personalization-nonce", cls=Command)
 def mounter_roll_personalization_nonce(service_provider: LockdownClient):
     MobileImageMounterService(lockdown=service_provider).roll_personalization_nonce()
 
 
-@mounter.command('roll-cryptex-nonce', cls=Command)
+@mounter.command("roll-cryptex-nonce", cls=Command)
 def mounter_roll_cryptex_nonce(service_provider: LockdownClient):
-    """ Roll cryptex nonce (will reboot) """
+    """Roll cryptex nonce (will reboot)"""
     MobileImageMounterService(lockdown=service_provider).roll_cryptex_nonce()