pymobiledevice3 6.2.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

pymobiledevice3/cli/pcap.py

@@ -1,17 +1,19 @@
 from datetime import datetime
-from typing import IO, Optional
+from pathlib import Path
+from typing import Annotated, Optional
 
-import click
+import typer
 from pygments import formatters, highlight, lexers
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_hex, user_requested_colored_output
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_hex, user_requested_colored_output
 from pymobiledevice3.services.pcapd import PcapdService
 
-
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="pcap",
+    help="Sniff device traffic via pcapd and optionally save to a .pcap file.",
+    no_args_is_help=True,
+)
 
 
 def print_packet_header(packet, color: bool) -> None:
@@ -37,25 +39,39 @@ def print_packet(packet, color: Optional[bool] = None):
     return packet
 
 
-@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.")
+@cli.command()
 def pcap(
-    service_provider: LockdownServiceProvider,
-    out: Optional[IO],
-    count: int,
-    process: Optional[str],
-    interface: Optional[str],
+    service_provider: ServiceProviderDep,
+    out: Optional[Path] = None,
+    count: Annotated[
+        int,
+        typer.Option(
+            "--count",
+            "-c",
+            help="Number of packets to sniff. Omit to endless sniff.",
+        ),
+    ] = -1,
+    process: Annotated[
+        Optional[str],
+        typer.Option(help="Process to filter. Omit for all."),
+    ] = None,
+    interface: Annotated[
+        Optional[str],
+        typer.Option(
+            "--interface",
+            "-i",
+            help="Interface name to filter. Omit for all.",
+        ),
+    ] = None,
 ) -> None:
-    """Sniff device traffic"""
+    """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 = (print_packet(p) for p in packets_generator)
-        service.write_to_pcap(out, packets_generator_with_print)
+        with out.open("wb") as out_file:
+            service.write_to_pcap(out_file, packets_generator_with_print)
         return
 
     for packet in packets_generator:

pymobiledevice3/cli/power_assertion.py

@@ -1,26 +1,25 @@
 import time
+from typing import Literal, Optional
 
-import click
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
 from pymobiledevice3.services.power_assertion import PowerAssertionService
 
-
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="power-assertion",
+    no_args_is_help=True,
+)
 
 
-@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:
+@cli.command("power-assertion")
+def power_assertion(
+    service_provider: ServiceProviderDep,
+    assertion_type: Literal["AMDPowerAssertionTypeWirelessSync", "PreventUserIdleSystemSleep", "PreventSystemSleep"],
+    name: str,
+    timeout: int,
+    details: Optional[str] = None,
+) -> None:
     """Create a power assertion"""
     with PowerAssertionService(service_provider).create_power_assertion(assertion_type, name, timeout, details):
         print("> Hit Ctrl+C to exit")

pymobiledevice3/cli/processes.py

@@ -1,34 +1,28 @@
 import logging
 
-import click
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.os_trace import OsTraceService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="processes",
+    help="View process list using diagnosticsd API",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def processes() -> None:
-    """View process list using diagnosticsd API"""
-    pass
-
-
-@processes.command("ps", cls=Command)
-def processes_ps(service_provider: LockdownClient):
+@cli.command("ps")
+def processes_ps(service_provider: ServiceProviderDep) -> None:
     """show process list"""
     print_json(OsTraceService(lockdown=service_provider).get_pid_list().get("Payload"))
 
 
-@processes.command("pgrep", cls=Command)
-@click.argument("expression")
-def processes_pgrep(service_provider: LockdownClient, expression):
+@cli.command("pgrep")
+def processes_pgrep(service_provider: ServiceProviderDep, expression: str) -> None:
     """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():

pymobiledevice3/cli/profile.py

@@ -2,41 +2,45 @@ import logging
 import plistlib
 import tempfile
 from pathlib import Path
-from typing import IO, Optional
+from typing import Annotated, Literal, Optional
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
 from pymobiledevice3.ca import create_keybag_file
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown import LockdownClient
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.mobile_activation import MobileActivationService
 from pymobiledevice3.services.mobile_config import MobileConfigService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
-
-
-@cli.group("profile")
-def profile_group() -> None:
-    """Managed installed profiles or install SSL certificates"""
-    pass
+cli = InjectingTyper(
+    name="profile",
+    help="Manage installed profiles or install SSL certificates",
+    no_args_is_help=True,
+)
 
 
-@profile_group.command("list", cls=Command)
-def profile_list(service_provider: LockdownClient):
+@cli.command("list")
+def profile_list(service_provider: ServiceProviderDep) -> None:
     """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"))
-def profile_install(service_provider: LockdownServiceProvider, keybag: Optional[str], profiles: list[IO]) -> None:
+@cli.command("install")
+def profile_install(
+    service_provider: ServiceProviderDep,
+    profiles: list[Path],
+    keybag: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
+) -> None:
     """
     Install given profiles
 
@@ -44,61 +48,58 @@ 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}")
         if keybag is not None:
-            service.install_profile_silent(Path(keybag), profile.read())
+            service.install_profile_silent(Path(keybag), profile.read_bytes())
         else:
-            service.install_profile(profile.read())
+            service.install_profile(profile.read_bytes())
 
 
-@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:
+@cli.command("cloud-configuration")
+def profile_cloud_configuration(service_provider: ServiceProviderDep, config: Optional[Path] = None) -> None:
     """Get/Set cloud configuration"""
     if not config:
         print_json(MobileConfigService(lockdown=service_provider).get_cloud_configuration())
     else:
-        config_json = plistlib.load(config)
+        with config.open("rb") as config_file:
+            config_json = plistlib.load(config_file)
         logger.info(f"applying cloud configuration {config_json}")
         MobileConfigService(lockdown=service_provider).set_cloud_configuration(config_json)
         logger.info("applied cloud configuration")
 
 
-@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:
+@cli.command("store")
+def profile_store(service_provider: ServiceProviderDep, profiles: list[Path]) -> None:
     """Store a profile"""
     service = MobileConfigService(lockdown=service_provider)
     for profile in profiles:
         logger.info(f"storing {profile.name}")
-        service.store_profile(profile.read())
+        service.store_profile(profile.read_bytes())
 
 
-@profile_group.command("remove", cls=Command)
-@click.argument("name")
-def profile_remove(service_provider: LockdownServiceProvider, name: str) -> None:
+@cli.command("remove")
+def profile_remove(service_provider: ServiceProviderDep, name: str) -> None:
     """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)
-def profile_set_wifi_power(service_provider: LockdownServiceProvider, state: str) -> None:
+@cli.command("set-wifi-power")
+def profile_set_wifi_power(service_provider: ServiceProviderDep, state: Literal["on", "off"] = "off") -> 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",
-)
+@cli.command("erase-device")
 def profile_erase_device(
-    service_provider: LockdownServiceProvider, preserve_data_plan: bool, disallow_proximity_setup: bool
+    service_provider: ServiceProviderDep,
+    preserve_data_plan: Annotated[
+        bool,
+        typer.Option(help="Preserves eSIM / data plan after erase"),
+    ] = True,
+    disallow_proximity_setup: Annotated[
+        bool,
+        typer.Option(help="Disallows setup of the erased device from nearby devices"),
+    ] = False,
 ) -> None:
     """Erase device"""
     logger.info(
@@ -109,18 +110,35 @@ def profile_erase_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")
-def profile_create_keybag(keybag: str, organization: str) -> None:
+@cli.command("create-keybag")
+def profile_create_keybag(
+    keybag: Annotated[
+        Path,
+        typer.Argument(
+            exists=False,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ],
+    organization: str,
+) -> None:
     """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))
-def profile_supervise(service_provider: LockdownServiceProvider, organization: str, keybag: Optional[str]) -> None:
+    create_keybag_file(keybag, organization)
+
+
+@cli.command("supervise")
+def profile_supervise(
+    service_provider: ServiceProviderDep,
+    organization: str,
+    keybag: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
+) -> None:
     """Supervise device"""
     if MobileActivationService(service_provider).state == "Unactivated":
         logger.info("Activating device")
@@ -138,13 +156,20 @@ def profile_supervise(service_provider: LockdownServiceProvider, organization: s
     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))
+@cli.command("install-wifi-profile")
 def profile_install_wifi_profile(
-    service_provider: LockdownServiceProvider, encryption_type: str, ssid: str, password: str, keybag: Optional[str]
+    service_provider: ServiceProviderDep,
+    encryption_type: str,
+    ssid: str,
+    password: str,
+    keybag: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
 ) -> None:
     """
     Install Wi-Fi profile
@@ -158,12 +183,22 @@ def profile_install_wifi_profile(
     )
 
 
-@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))
+@cli.command("install-http-proxy")
 def profile_install_http_proxy(
-    service_provider: LockdownServiceProvider, server: str, port: int, keybag: Optional[str]
+    service_provider: ServiceProviderDep,
+    server: str,
+    port: Annotated[
+        int,
+        typer.Argument(min=1, max=0xFFFF),
+    ],
+    keybag: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
 ) -> None:
     """Install HTTP Proxy profile"""
     if keybag is not None:
@@ -171,17 +206,27 @@ def profile_install_http_proxy(
     MobileConfigService(lockdown=service_provider).install_http_proxy(server, port, keybag_file=keybag)
 
 
-@profile_group.command("remove-http-proxy", cls=Command)
-def profile_remove_http_proxy(service_provider: LockdownServiceProvider) -> None:
+@cli.command("remove-http-proxy")
+def profile_remove_http_proxy(service_provider: ServiceProviderDep) -> None:
     """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)
+@cli.command("install-restrictions-profile")
 def profile_install_restrictions_profile(
-    service_provider: LockdownServiceProvider, keybag: Optional[str], enforced_software_update_delay: int
+    service_provider: ServiceProviderDep,
+    keybag: Annotated[
+        Optional[Path],
+        typer.Option(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+        ),
+    ] = None,
+    enforced_software_update_delay: Annotated[
+        int,
+        typer.Option(min=0, max=90),
+    ] = 0,
 ) -> None:
     """Install restrictions profile (can be used for delayed OTA)"""
     if keybag is not None:

pymobiledevice3/cli/provision.py

@@ -1,56 +1,57 @@
 import logging
 from pathlib import Path
+from typing import Annotated
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.misagent import MisagentService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="provision",
+    help="Manage installed provision profiles",
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def provision() -> None:
-    """Manage installed provision profiles"""
-    pass
-
-
-@provision.command("install", cls=Command)
-@click.argument("profile", type=click.File("rb"))
-def provision_install(service_provider: LockdownClient, profile):
+@cli.command("install")
+def provision_install(service_provider: ServiceProviderDep, profile: Path) -> None:
     """install a provision profile (.mobileprovision file)"""
-    MisagentService(lockdown=service_provider).install(profile)
+    with profile.open("rb") as profile_file:
+        MisagentService(lockdown=service_provider).install(profile_file)
 
 
-@provision.command("remove", cls=Command)
-@click.argument("profile_id")
-def provision_remove(service_provider: LockdownClient, profile_id):
+@cli.command("remove")
+def provision_remove(service_provider: ServiceProviderDep, profile_id: str) -> None:
     """remove a provision profile"""
     MisagentService(lockdown=service_provider).remove(profile_id)
 
 
-@provision.command("clear", cls=Command)
-def provision_clear(service_provider: LockdownClient):
+@cli.command("clear")
+def provision_clear(service_provider: ServiceProviderDep) -> None:
     """remove all provision profiles"""
     for profile in MisagentService(lockdown=service_provider).copy_all():
         MisagentService(lockdown=service_provider).remove(profile.plist["UUID"])
 
 
-@provision.command("list", cls=Command)
-def provision_list(service_provider: LockdownClient):
+@cli.command("list")
+def provision_list(service_provider: ServiceProviderDep) -> None:
     """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))
-def provision_dump(service_provider: LockdownClient, out):
+@cli.command("dump")
+def provision_dump(
+    service_provider: ServiceProviderDep,
+    out: Annotated[
+        Path,
+        typer.Argument(file_okay=False, dir_okay=True, exists=True),
+    ],
+) -> None:
     """dump installed provision profiles to specified location"""
     for profile in MisagentService(lockdown=service_provider).copy_all():
         filename = f"{profile.plist['UUID']}.mobileprovision"