pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/cli/crash.py

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

pymobiledevice3/cli/developer/__init__.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+from textwrap import dedent
+from typing import Annotated
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
+from pymobiledevice3.cli.developer import (
+    accessibility,
+    arbitration,
+    condition,
+    core_device,
+    debugserver,
+    dvt,
+    fetch_symbols,
+    simulate_location,
+)
+from pymobiledevice3.services.remote_server import RemoteServer
+from pymobiledevice3.services.screenshot import ScreenshotService
+
+cli = InjectingTyper(
+    name="developer",
+    help=dedent("""\
+        Developer tooling for iOS devices (requires Developer Mode + mounted DeveloperDiskImage).
+
+        These commands require the DeveloperDiskImage.dmg to be mounted on the device prior
+        to execution. You can achieve this using:
+
+        pymobiledevice3 mounter mount
+
+        Also, starting at iOS 17.0, a tunnel must be created to the device for the services
+        to be accessible. Therefore, every CLI command is retried with a `--tunnel` option
+        for implicitly accessing tunneld when necessary
+    """),
+    no_args_is_help=True,
+)
+cli.add_typer(dvt.cli)
+cli.add_typer(fetch_symbols.cli)
+cli.add_typer(simulate_location.cli)
+cli.add_typer(accessibility.cli)
+cli.add_typer(condition.cli)
+cli.add_typer(debugserver.cli)
+cli.add_typer(arbitration.cli)
+cli.add_typer(core_device.cli)
+
+
+@cli.command("shell")
+def developer_shell(
+    service_provider: ServiceProviderDep,
+    service: str,
+    remove_ssl_context: Annotated[bool, typer.Option("--remove-ssl-context", "-r")] = False,
+) -> None:
+    """Open an IPython shell connected to a developer service (for exploration/R&D)."""
+    with RemoteServer(service_provider, service, remove_ssl_context) as service:
+        service.shell()
+
+
+@cli.command()
+def screenshot(service_provider: ServiceProviderDep, out: Path) -> None:
+    """Capture a PNG screenshot (Depcrecated API)."""
+    out.write_bytes(ScreenshotService(lockdown=service_provider).take_screenshot())

pymobiledevice3/cli/developer/accessibility/__init__.py

@@ -0,0 +1,65 @@
+import logging
+
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.cli.developer.accessibility import settings
+from pymobiledevice3.services.accessibilityaudit import AccessibilityAudit
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="accessibility",
+    help="Interact with accessibility-related features",
+    no_args_is_help=True,
+)
+cli.add_typer(settings.cli)
+
+
+@cli.command("run-audit")
+def accessibility_run_audit(service_provider: ServiceProviderDep, test_types: list[str]) -> None:
+    """runs accessibility audit tests"""
+    audit_issues = AccessibilityAudit(service_provider).run_audit(test_types)
+    print_json([audit_issue.json() for audit_issue in audit_issues], False)
+
+
+@cli.command("supported-audit-types")
+def accessibility_supported_audit_types(service_provider: ServiceProviderDep) -> None:
+    """lists supported accessibility audit test types"""
+    print_json(AccessibilityAudit(service_provider).supported_audits_types())
+
+
+@cli.command("capabilities")
+def accessibility_capabilities(service_provider: ServiceProviderDep) -> None:
+    """display accessibility capabilities"""
+    print_json(AccessibilityAudit(service_provider).capabilities)
+
+
+@cli.command("shell")
+def accessibility_shell(service_provider: ServiceProviderDep) -> None:
+    """start and ipython accessibility shell"""
+    AccessibilityAudit(service_provider).shell()
+
+
+@cli.command("notifications")
+def accessibility_notifications(service_provider: ServiceProviderDep) -> None:
+    """show notifications"""
+    service = AccessibilityAudit(service_provider)
+    for event in service.iter_events():
+        if event.name in (
+            "hostAppStateChanged:",
+            "hostInspectorCurrentElementChanged:",
+        ):
+            for focus_item in event.data:
+                logger.info(focus_item)
+
+
+@cli.command("list-items")
+def accessibility_list_items(service_provider: ServiceProviderDep) -> None:
+    """List elements available in the currently shown menu."""
+    elements = []
+    with AccessibilityAudit(service_provider) as service:
+        for element in service.iter_elements():
+            elements.append(element.to_dict())
+    print_json(elements)

pymobiledevice3/cli/developer/accessibility/settings.py

@@ -0,0 +1,43 @@
+import logging
+
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import OSUTILS, ServiceProviderDep
+from pymobiledevice3.services.accessibilityaudit import AccessibilityAudit
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="settings",
+    help="accessibility settings",
+    no_args_is_help=True,
+)
+
+
+@cli.command("show")
+def accessibility_settings_show(service_provider: ServiceProviderDep) -> None:
+    """show current settings"""
+    for setting in AccessibilityAudit(service_provider).settings:
+        print(setting)
+
+
+@cli.command("set")
+def accessibility_settings_set(service_provider: ServiceProviderDep, setting: str, value: str) -> None:
+    """
+    change current settings
+
+    in order to list all available use the "show" command
+    """
+    service = AccessibilityAudit(service_provider)
+    service.set_setting(setting, eval(value))
+    OSUTILS.wait_return()
+
+
+@cli.command("reset")
+def accessibility_settings_reset(service_provider: ServiceProviderDep) -> None:
+    """
+    reset accessibility settings to default
+    """
+    service = AccessibilityAudit(service_provider)
+    service.reset_settings()

pymobiledevice3/cli/developer/arbitration.py

@@ -0,0 +1,50 @@
+import logging
+from typing import Annotated
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import OSUTILS, ServiceProviderDep, print_json
+from pymobiledevice3.exceptions import DeviceAlreadyInUseError
+from pymobiledevice3.services.device_arbitration import DtDeviceArbitration
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="arbitration",
+    help='Mark/unmark a device as "in-use" to avoid conflicts with other tools.',
+    no_args_is_help=True,
+)
+
+
+@cli.command("version")
+def version(service_provider: ServiceProviderDep) -> None:
+    """Show arbitration protocol version."""
+    with DtDeviceArbitration(service_provider) as device_arbitration:
+        print_json(device_arbitration.version)
+
+
+@cli.command("check-in")
+def check_in(
+    service_provider: ServiceProviderDep,
+    hostname: str,
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f"),
+    ] = False,
+) -> None:
+    """Check-in as owner (marks device as in-use; use --force to override)."""
+    with DtDeviceArbitration(service_provider) as device_arbitration:
+        try:
+            device_arbitration.check_in(hostname, force=force)
+            OSUTILS.wait_return()
+        except DeviceAlreadyInUseError as e:
+            logger.error(e.message)
+
+
+@cli.command("check-out")
+def check_out(service_provider: ServiceProviderDep) -> None:
+    """Release ownership and allow other tools to use the device."""
+    with DtDeviceArbitration(service_provider) as device_arbitration:
+        device_arbitration.check_out()

pymobiledevice3/cli/developer/condition.py

@@ -0,0 +1,33 @@
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import OSUTILS, ServiceProviderDep, print_json
+from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
+from pymobiledevice3.services.dvt.instruments.condition_inducer import ConditionInducer
+
+cli = InjectingTyper(
+    name="developer",
+    help="Force predefined device conditions (network, thermal, battery) via DVT.",
+    no_args_is_help=True,
+)
+
+
+@cli.command("list")
+def condition_list(service_provider: ServiceProviderDep) -> None:
+    """List available condition profiles."""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        print_json(ConditionInducer(dvt).list())
+
+
+@cli.command("clear")
+def condition_clear(service_provider: ServiceProviderDep) -> None:
+    """Clear any active induced condition."""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        ConditionInducer(dvt).clear()
+
+
+@cli.command("set")
+def condition_set(service_provider: ServiceProviderDep, profile_identifier: str) -> None:
+    """Apply a specific condition profile by identifier."""
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        ConditionInducer(dvt).set(profile_identifier)
+        OSUTILS.wait_return()