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

pymobiledevice3/cli/notification.py

@@ -17,25 +17,25 @@ def cli() -> None:
 
 @cli.group()
 def notification() -> None:
-    """ Post/Observe notifications """
+    """Post/Observe notifications"""
     pass
 
 
 @notification.command(cls=Command)
-@click.argument('names', nargs=-1)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
+@click.argument("names", nargs=-1)
+@click.option("--insecure", is_flag=True, help="use the insecure relay meant for untrusted clients instead")
 def post(service_provider: LockdownClient, names, insecure):
-    """ API for notify_post(). """
+    """API for notify_post()."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for name in names:
         service.notify_post(name)
 
 
 @notification.command(cls=Command)
-@click.argument('names', nargs=-1)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
+@click.argument("names", nargs=-1)
+@click.option("--insecure", is_flag=True, help="use the insecure relay meant for untrusted clients instead")
 def observe(service_provider: LockdownClient, names, insecure):
-    """ API for notify_register_dispatch(). """
+    """API for notify_register_dispatch()."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for name in names:
         service.notify_register_dispatch(name)
@@ -44,10 +44,10 @@ def observe(service_provider: LockdownClient, names, insecure):
         logger.info(event)
 
 
-@notification.command('observe-all', cls=Command)
-@click.option('--insecure', is_flag=True, help='use the insecure relay meant for untrusted clients instead')
+@notification.command("observe-all", cls=Command)
+@click.option("--insecure", is_flag=True, help="use the insecure relay meant for untrusted clients instead")
 def observe_all(service_provider: LockdownClient, insecure):
-    """ attempt to observe all builtin firmware notifications. """
+    """attempt to observe all builtin firmware notifications."""
     service = NotificationProxyService(lockdown=service_provider, insecure=insecure)
     for notification in get_notifications():
         service.notify_register_dispatch(notification)

pymobiledevice3/cli/pcap.py

@@ -17,19 +17,19 @@ def cli() -> None:
 def print_packet_header(packet, color: bool) -> None:
     date = datetime.fromtimestamp(packet.seconds + (packet.microseconds / 1000000))
     data = (
-        f'{date}: '
-        f'Process {packet.comm} ({packet.pid}), '
-        f'Interface: {packet.interface_name} ({packet.interface_type.name}), '
-        f'Family: {packet.protocol_family.name}'
+        f"{date}: "
+        f"Process {packet.comm} ({packet.pid}), "
+        f"Interface: {packet.interface_name} ({packet.interface_type.name}), "
+        f"Family: {packet.protocol_family.name}"
     )
     if not color:
         print(data)
     else:
-        print(highlight(data, lexers.HspecLexer(), formatters.Terminal256Formatter(style='native')), end='')
+        print(highlight(data, lexers.HspecLexer(), formatters.Terminal256Formatter(style="native")), end="")
 
 
 def print_packet(packet, color: Optional[bool] = None):
-    """ Return the packet, so it can be chained in a generator """
+    """Return the packet, so it can be chained in a generator"""
     if color is None:
         color = user_requested_colored_output()
     print_packet_header(packet, color)
@@ -38,18 +38,23 @@ def print_packet(packet, color: Optional[bool] = None):
 
 
 @cli.command(cls=Command)
-@click.argument('out', type=click.File('wb'), required=False)
-@click.option('-c', '--count', type=click.INT, default=-1, help='Number of packets to sniff. Omit to endless sniff.')
-@click.option('--process', default=None, help='Process to filter. Omit for all.')
-@click.option('-i', '--interface', default=None, help='Interface name to filter. Omit for all.')
-def pcap(service_provider: LockdownServiceProvider, out: Optional[IO], count: int, process: Optional[str],
-         interface: Optional[str]) -> None:
-    """ Sniff device traffic """
+@click.argument("out", type=click.File("wb"), required=False)
+@click.option("-c", "--count", type=click.INT, default=-1, help="Number of packets to sniff. Omit to endless sniff.")
+@click.option("--process", default=None, help="Process to filter. Omit for all.")
+@click.option("-i", "--interface", default=None, help="Interface name to filter. Omit for all.")
+def pcap(
+    service_provider: LockdownServiceProvider,
+    out: Optional[IO],
+    count: int,
+    process: Optional[str],
+    interface: Optional[str],
+) -> None:
+    """Sniff device traffic"""
     service = PcapdService(lockdown=service_provider)
     packets_generator = service.watch(packets_count=count, process=process, interface_name=interface)
 
     if out is not None:
-        packets_generator_with_print = map(lambda p: print_packet(p), packets_generator)
+        packets_generator_with_print = (print_packet(p) for p in packets_generator)
         service.write_to_pcap(out, packets_generator_with_print)
         return
 

pymobiledevice3/cli/power_assertion.py

@@ -12,14 +12,16 @@ def cli() -> None:
     pass
 
 
-@cli.command('power-assertion', cls=Command)
-@click.argument('type', type=click.Choice(
-    ['AMDPowerAssertionTypeWirelessSync', 'PreventUserIdleSystemSleep', 'PreventSystemSleep']))
-@click.argument('name')
-@click.argument('timeout', type=click.INT)
-@click.argument('details', required=False)
-def power_assertion(service_provider: LockdownServiceProvider, type, name, timeout, details) -> None:
-    """ Create a power assertion """
-    with PowerAssertionService(service_provider).create_power_assertion(type, name, timeout, details):
-        print('> Hit Ctrl+C to exit')
+@cli.command("power-assertion", cls=Command)
+@click.argument(
+    "assertion_type",
+    type=click.Choice(["AMDPowerAssertionTypeWirelessSync", "PreventUserIdleSystemSleep", "PreventSystemSleep"]),
+)
+@click.argument("name")
+@click.argument("timeout", type=click.INT)
+@click.argument("details", required=False)
+def power_assertion(service_provider: LockdownServiceProvider, assertion_type, name, timeout, details) -> None:
+    """Create a power assertion"""
+    with PowerAssertionService(service_provider).create_power_assertion(assertion_type, name, timeout, details):
+        print("> Hit Ctrl+C to exit")
         time.sleep(timeout)

pymobiledevice3/cli/processes.py

@@ -16,22 +16,22 @@ def cli() -> None:
 
 @cli.group()
 def processes() -> None:
-    """ View process list using diagnosticsd API """
+    """View process list using diagnosticsd API"""
     pass
 
 
-@processes.command('ps', cls=Command)
+@processes.command("ps", cls=Command)
 def processes_ps(service_provider: LockdownClient):
-    """ show process list """
-    print_json(OsTraceService(lockdown=service_provider).get_pid_list().get('Payload'))
+    """show process list"""
+    print_json(OsTraceService(lockdown=service_provider).get_pid_list().get("Payload"))
 
 
-@processes.command('pgrep', cls=Command)
-@click.argument('expression')
+@processes.command("pgrep", cls=Command)
+@click.argument("expression")
 def processes_pgrep(service_provider: LockdownClient, expression):
-    """ try to match processes pid by given expression (like pgrep) """
-    processes_list = OsTraceService(lockdown=service_provider).get_pid_list().get('Payload')
+    """try to match processes pid by given expression (like pgrep)"""
+    processes_list = OsTraceService(lockdown=service_provider).get_pid_list().get("Payload")
     for pid, process_info in processes_list.items():
-        process_name = process_info.get('ProcessName')
+        process_name = process_info.get("ProcessName")
         if expression in process_name:
-            logger.info(f'{pid} {process_name}')
+            logger.info(f"{pid} {process_name}")

pymobiledevice3/cli/profile.py

@@ -21,21 +21,21 @@ def cli() -> None:
     pass
 
 
-@cli.group('profile')
+@cli.group("profile")
 def profile_group() -> None:
-    """ Managed installed profiles or install SSL certificates """
+    """Managed installed profiles or install SSL certificates"""
     pass
 
 
-@profile_group.command('list', cls=Command)
+@profile_group.command("list", cls=Command)
 def profile_list(service_provider: LockdownClient):
-    """ List installed profiles """
+    """List installed profiles"""
     print_json(MobileConfigService(lockdown=service_provider).get_profile_list())
 
 
-@profile_group.command('install', cls=Command)
-@click.option('--keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
-@click.argument('profiles', nargs=-1, type=click.File('rb'))
+@profile_group.command("install", cls=Command)
+@click.option("--keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
+@click.argument("profiles", nargs=-1, type=click.File("rb"))
 def profile_install(service_provider: LockdownServiceProvider, keybag: Optional[str], profiles: list[IO]) -> None:
     """
     Install given profiles
@@ -44,101 +44,108 @@ def profile_install(service_provider: LockdownServiceProvider, keybag: Optional[
     """
     service = MobileConfigService(lockdown=service_provider)
     for profile in profiles:
-        logger.info(f'installing {profile.name}')
+        logger.info(f"installing {profile.name}")
         if keybag is not None:
             service.install_profile_silent(Path(keybag), profile.read())
         else:
             service.install_profile(profile.read())
 
 
-@profile_group.command('cloud-configuration', cls=Command)
-@click.argument('config', type=click.File('rb'), required=False)
+@profile_group.command("cloud-configuration", cls=Command)
+@click.argument("config", type=click.File("rb"), required=False)
 def profile_cloud_configuration(service_provider: LockdownServiceProvider, config: Optional[IO]) -> None:
-    """ Get/Set cloud configuration """
+    """Get/Set cloud configuration"""
     if not config:
         print_json(MobileConfigService(lockdown=service_provider).get_cloud_configuration())
     else:
         config_json = plistlib.load(config)
-        logger.info(f'applying cloud configuration {config_json}')
+        logger.info(f"applying cloud configuration {config_json}")
         MobileConfigService(lockdown=service_provider).set_cloud_configuration(config_json)
-        logger.info('applied cloud configuration')
+        logger.info("applied cloud configuration")
 
 
-@profile_group.command('store', cls=Command)
-@click.argument('profiles', nargs=-1, type=click.File('rb'))
+@profile_group.command("store", cls=Command)
+@click.argument("profiles", nargs=-1, type=click.File("rb"))
 def profile_store(service_provider: LockdownServiceProvider, profiles: list[IO]) -> None:
-    """ Store a profile """
+    """Store a profile"""
     service = MobileConfigService(lockdown=service_provider)
     for profile in profiles:
-        logger.info(f'storing {profile.name}')
+        logger.info(f"storing {profile.name}")
         service.store_profile(profile.read())
 
 
-@profile_group.command('remove', cls=Command)
-@click.argument('name')
+@profile_group.command("remove", cls=Command)
+@click.argument("name")
 def profile_remove(service_provider: LockdownServiceProvider, name: str) -> None:
-    """ Remove a profile by its name """
+    """Remove a profile by its name"""
     MobileConfigService(lockdown=service_provider).remove_profile(name)
 
 
-@profile_group.command('set-wifi-power', cls=Command)
-@click.argument('state', type=click.Choice(['on', 'off']), required=False)
+@profile_group.command("set-wifi-power", cls=Command)
+@click.argument("state", type=click.Choice(["on", "off"]), required=False)
 def profile_set_wifi_power(service_provider: LockdownServiceProvider, state: str) -> None:
-    """ change Wi-Fi power state """
-    MobileConfigService(lockdown=service_provider).set_wifi_power_state(state == 'on')
-
-
-@profile_group.command('erase-device', cls=Command)
-@click.option('--preserve-data-plan/--no-preserve-data-plan', default=True,
-              help='Preserves eSIM / data plan after erase')
-@click.option('--disallow-proximity-setup/--no-disallow-proximity-setup', default=False,
-              help='Disallows to setup the erased device from nearby devices')
-def profile_erase_device(service_provider: LockdownServiceProvider, preserve_data_plan: bool,
-                         disallow_proximity_setup: bool) -> None:
-    """ Erase device """
-    logger.info(f'Erasing device with preserve_data_plan: {preserve_data_plan}, '
-                f'disallow_proximity_setup: {disallow_proximity_setup}')
+    """change Wi-Fi power state"""
+    MobileConfigService(lockdown=service_provider).set_wifi_power_state(state == "on")
+
+
+@profile_group.command("erase-device", cls=Command)
+@click.option(
+    "--preserve-data-plan/--no-preserve-data-plan", default=True, help="Preserves eSIM / data plan after erase"
+)
+@click.option(
+    "--disallow-proximity-setup/--no-disallow-proximity-setup",
+    default=False,
+    help="Disallows to setup the erased device from nearby devices",
+)
+def profile_erase_device(
+    service_provider: LockdownServiceProvider, preserve_data_plan: bool, disallow_proximity_setup: bool
+) -> None:
+    """Erase device"""
+    logger.info(
+        f"Erasing device with preserve_data_plan: {preserve_data_plan}, "
+        f"disallow_proximity_setup: {disallow_proximity_setup}"
+    )
     MobileConfigService(lockdown=service_provider).erase_device(preserve_data_plan, disallow_proximity_setup)
-    logger.info('Erased device')
+    logger.info("Erased device")
 
 
-@profile_group.command('create-keybag')
-@click.argument('keybag', type=click.Path(file_okay=True, dir_okay=False, exists=False))
-@click.argument('organization')
+@profile_group.command("create-keybag")
+@click.argument("keybag", type=click.Path(file_okay=True, dir_okay=False, exists=False))
+@click.argument("organization")
 def profile_create_keybag(keybag: str, organization: str) -> None:
-    """ Create keybag storing certificate and private key """
+    """Create keybag storing certificate and private key"""
     create_keybag_file(Path(keybag), organization)
 
 
-@profile_group.command('supervise', cls=Command)
-@click.argument('organization')
-@click.option('--keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
+@profile_group.command("supervise", cls=Command)
+@click.argument("organization")
+@click.option("--keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
 def profile_supervise(service_provider: LockdownServiceProvider, organization: str, keybag: Optional[str]) -> None:
-    """ Supervise device """
-    if MobileActivationService(service_provider).state == 'Unactivated':
-        logger.info('Activating device')
+    """Supervise device"""
+    if MobileActivationService(service_provider).state == "Unactivated":
+        logger.info("Activating device")
         MobileActivationService(service_provider).activate()
-        logger.info('Device has been successfully activated')
-    logger.info('Supervising device')
+        logger.info("Device has been successfully activated")
+    logger.info("Supervising device")
     if keybag is None:
         with tempfile.TemporaryDirectory() as temp_dir:
-            keybag = Path(temp_dir) / 'keybag'
+            keybag = Path(temp_dir) / "keybag"
             create_keybag_file(keybag, organization)
             MobileConfigService(lockdown=service_provider).supervise(organization, keybag)
     else:
         MobileConfigService(lockdown=service_provider).supervise(organization, Path(keybag))
 
-    logger.info('Device has been successfully supervised')
+    logger.info("Device has been successfully supervised")
 
 
-@profile_group.command('install-wifi-profile', cls=Command)
-@click.argument('encryption_type')
-@click.argument('ssid')
-@click.argument('password')
-@click.option('--keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
-def profile_install_wifi_profile(service_provider: LockdownServiceProvider, encryption_type: str, ssid: str,
-                                 password: str,
-                                 keybag: Optional[str]) -> None:
+@profile_group.command("install-wifi-profile", cls=Command)
+@click.argument("encryption_type")
+@click.argument("ssid")
+@click.argument("password")
+@click.option("--keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
+def profile_install_wifi_profile(
+    service_provider: LockdownServiceProvider, encryption_type: str, ssid: str, password: str, keybag: Optional[str]
+) -> None:
     """
     Install Wi-Fi profile
 
@@ -147,34 +154,38 @@ def profile_install_wifi_profile(service_provider: LockdownServiceProvider, encr
     if keybag is not None:
         keybag = Path(keybag)
     MobileConfigService(lockdown=service_provider).install_wifi_profile(
-        encryption_type=encryption_type, ssid=ssid, password=password, keybag_file=keybag)
-
-
-@profile_group.command('install-http-proxy', cls=Command)
-@click.argument('server')
-@click.argument('port', type=click.IntRange(1, 65535))
-@click.option('--keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
-def profile_install_http_proxy(service_provider: LockdownServiceProvider, server: str, port: int,
-                               keybag: Optional[str]) -> None:
-    """ Install HTTP Proxy profile """
+        encryption_type=encryption_type, ssid=ssid, password=password, keybag_file=keybag
+    )
+
+
+@profile_group.command("install-http-proxy", cls=Command)
+@click.argument("server")
+@click.argument("port", type=click.IntRange(1, 65535))
+@click.option("--keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
+def profile_install_http_proxy(
+    service_provider: LockdownServiceProvider, server: str, port: int, keybag: Optional[str]
+) -> None:
+    """Install HTTP Proxy profile"""
     if keybag is not None:
         keybag = Path(keybag)
     MobileConfigService(lockdown=service_provider).install_http_proxy(server, port, keybag_file=keybag)
 
 
-@profile_group.command('remove-http-proxy', cls=Command)
+@profile_group.command("remove-http-proxy", cls=Command)
 def profile_remove_http_proxy(service_provider: LockdownServiceProvider) -> None:
-    """ Remove HTTP Proxy profile that was previously installed using pymobiledevice3 """
+    """Remove HTTP Proxy profile that was previously installed using pymobiledevice3"""
     MobileConfigService(lockdown=service_provider).remove_http_proxy()
 
 
-@profile_group.command('install-restrictions-profile', cls=Command)
-@click.option('--keybag', type=click.Path(file_okay=True, dir_okay=False, exists=True))
-@click.option('--enforced-software-update-delay', type=click.IntRange(0, 90), default=0)
+@profile_group.command("install-restrictions-profile", cls=Command)
+@click.option("--keybag", type=click.Path(file_okay=True, dir_okay=False, exists=True))
+@click.option("--enforced-software-update-delay", type=click.IntRange(0, 90), default=0)
 def profile_install_restrictions_profile(
-        service_provider: LockdownServiceProvider, keybag: Optional[str], enforced_software_update_delay: int) -> None:
-    """ Install restrictions profile (can be used for delayed OTA) """
+    service_provider: LockdownServiceProvider, keybag: Optional[str], enforced_software_update_delay: int
+) -> None:
+    """Install restrictions profile (can be used for delayed OTA)"""
     if keybag is not None:
         keybag = Path(keybag)
     MobileConfigService(lockdown=service_provider).install_restrictions_profile(
-        enforced_software_update_delay=enforced_software_update_delay, keybag_file=keybag)
+        enforced_software_update_delay=enforced_software_update_delay, keybag_file=keybag
+    )

pymobiledevice3/cli/provision.py

@@ -17,42 +17,42 @@ def cli() -> None:
 
 @cli.group()
 def provision() -> None:
-    """ Manage installed provision profiles """
+    """Manage installed provision profiles"""
     pass
 
 
-@provision.command('install', cls=Command)
-@click.argument('profile', type=click.File('rb'))
+@provision.command("install", cls=Command)
+@click.argument("profile", type=click.File("rb"))
 def provision_install(service_provider: LockdownClient, profile):
-    """ install a provision profile (.mobileprovision file) """
+    """install a provision profile (.mobileprovision file)"""
     MisagentService(lockdown=service_provider).install(profile)
 
 
-@provision.command('remove', cls=Command)
-@click.argument('profile_id')
+@provision.command("remove", cls=Command)
+@click.argument("profile_id")
 def provision_remove(service_provider: LockdownClient, profile_id):
-    """ remove a provision profile """
+    """remove a provision profile"""
     MisagentService(lockdown=service_provider).remove(profile_id)
 
 
-@provision.command('clear', cls=Command)
+@provision.command("clear", cls=Command)
 def provision_clear(service_provider: LockdownClient):
-    """ remove all provision profiles """
+    """remove all provision profiles"""
     for profile in MisagentService(lockdown=service_provider).copy_all():
-        MisagentService(lockdown=service_provider).remove(profile.plist['UUID'])
+        MisagentService(lockdown=service_provider).remove(profile.plist["UUID"])
 
 
-@provision.command('list', cls=Command)
+@provision.command("list", cls=Command)
 def provision_list(service_provider: LockdownClient):
-    """ list installed provision profiles """
+    """list installed provision profiles"""
     print_json([p.plist for p in MisagentService(lockdown=service_provider).copy_all()])
 
 
-@provision.command('dump', cls=Command)
-@click.argument('out', type=click.Path(file_okay=False, dir_okay=True, exists=True))
+@provision.command("dump", cls=Command)
+@click.argument("out", type=click.Path(file_okay=False, dir_okay=True, exists=True))
 def provision_dump(service_provider: LockdownClient, out):
-    """ dump installed provision profiles to specified location """
+    """dump installed provision profiles to specified location"""
     for profile in MisagentService(lockdown=service_provider).copy_all():
-        filename = f'{profile.plist["UUID"]}.mobileprovision'
-        logger.info(f'downloading {filename}')
+        filename = f"{profile.plist['UUID']}.mobileprovision"
+        logger.info(f"downloading {filename}")
         (Path(out) / filename).write_bytes(profile.buf)