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

pymobiledevice3/cli/developer/dvt/simulate_location.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import OSUTILS, ServiceProviderDep
+from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
+from pymobiledevice3.services.dvt.instruments.location_simulation import LocationSimulation
+
+cli = InjectingTyper(
+    name="simulate-location",
+    help="Simulate device location by given input",
+    no_args_is_help=True,
+)
+
+
+@cli.command("clear")
+def dvt_simulate_location_clear(service_provider: ServiceProviderDep) -> None:
+    """Clear currently simulated location"""
+    with DvtSecureSocketProxyService(service_provider) as dvt:
+        LocationSimulation(dvt).clear()
+
+
+@cli.command("set")
+def dvt_simulate_location_set(service_provider: ServiceProviderDep, latitude: float, longitude: float) -> None:
+    """
+    Set a simulated location.
+
+    \b
+    For example:
+    \b    ... set -- 40.690008 -74.045843 for liberty island
+    """
+    with DvtSecureSocketProxyService(service_provider) as dvt:
+        LocationSimulation(dvt).set(latitude, longitude)
+        OSUTILS.wait_return()
+
+
+@cli.command("play")
+def dvt_simulate_location_play(
+    service_provider: ServiceProviderDep,
+    filename: Annotated[
+        Path,
+        typer.Argument(exists=True, file_okay=True, dir_okay=False),
+    ],
+    timing_randomness_range: int = 0,
+    disable_sleep: Annotated[bool, typer.Option()] = False,
+) -> None:
+    """Simulate inputs from a given .gpx file"""
+    with DvtSecureSocketProxyService(service_provider) as dvt:
+        LocationSimulation(dvt).play_gpx_file(
+            str(filename),
+            disable_sleep=disable_sleep,
+            timing_randomness_range=timing_randomness_range,
+        )
+        OSUTILS.wait_return()

pymobiledevice3/cli/developer/dvt/sysmon/__init__.py

@@ -0,0 +1,69 @@
+import logging
+from dataclasses import asdict
+from typing import Annotated, Optional
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
+from pymobiledevice3.cli.developer.dvt.sysmon import process
+from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
+from pymobiledevice3.services.dvt.instruments.sysmontap import Sysmontap
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="sysmon",
+    help="System monitor options.",
+    no_args_is_help=True,
+)
+cli.add_typer(process.cli)
+
+
+@cli.command("system")
+def sysmon_system(
+    service_provider: ServiceProviderDep,
+    fields: Annotated[
+        Optional[str],
+        typer.Option(
+            "--fields",
+            "-f",
+            help='field names separated by ",".',
+        ),
+    ] = None,
+) -> None:
+    """show current system stats."""
+
+    split_fields = fields.split(",") if fields is not None else None
+
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        sysmontap = Sysmontap(dvt)
+        with sysmontap as sysmon:
+            system = None
+            system_usage = None
+            system_usage_seen = False  # Tracks if the first occurrence of SystemCPUUsage
+
+            for row in sysmon:
+                if "System" in row and system is None:
+                    system = sysmon.system_attributes_cls(*row["System"])
+
+                if "SystemCPUUsage" in row:
+                    if system_usage_seen:
+                        system_usage = {
+                            **row["SystemCPUUsage"],
+                            "CPUCount": row["CPUCount"],
+                            "EnabledCPUs": row["EnabledCPUs"],
+                        }
+                    else:  # Ignore the first occurrence because first occurrence always gives a incorrect value - 100 or 0
+                        system_usage_seen = True
+
+                if system and system_usage:
+                    break
+
+    assert system is not None and system_usage is not None  # for type checker
+
+    attrs_dict = {**asdict(system), **system_usage}
+    for name, value in attrs_dict.items():
+        if (split_fields is None) or (name in fields):
+            print(f"{name}: {value}")

pymobiledevice3/cli/developer/dvt/sysmon/process.py

@@ -0,0 +1,188 @@
+import contextlib
+import json
+import logging
+import time
+from collections import namedtuple
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, default_json_encoder, print_json
+from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
+from pymobiledevice3.services.dvt.instruments.device_info import DeviceInfo
+from pymobiledevice3.services.dvt.instruments.sysmontap import Sysmontap
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="process",
+    help="Process monitor options.",
+    no_args_is_help=True,
+)
+
+
+@cli.command("monitor")
+def sysmon_process_monitor(service_provider: ServiceProviderDep, threshold: float) -> None:
+    """monitor all most consuming processes by given cpuUsage threshold."""
+
+    Process = namedtuple("process", "pid name cpuUsage physFootprint")
+
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt, Sysmontap(dvt) as sysmon:
+        for process_snapshot in sysmon.iter_processes():
+            entries = []
+            for process in process_snapshot:
+                if (process["cpuUsage"] is not None) and (process["cpuUsage"] >= threshold):
+                    entries.append(
+                        Process(
+                            pid=process["pid"],
+                            name=process["name"],
+                            cpuUsage=process["cpuUsage"],
+                            physFootprint=process["physFootprint"],
+                        )
+                    )
+
+            logger.info(entries)
+
+
+@cli.command("single")
+def sysmon_process_single(
+    service_provider: ServiceProviderDep,
+    attributes: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--attributes",
+            "-a",
+            help="filter processes by given attribute value given as key=value. Can be specified multiple times.",
+        ),
+    ] = None,
+) -> None:
+    """show a single snapshot of currently running processes."""
+
+    count = 0
+
+    result = []
+    with DvtSecureSocketProxyService(lockdown=service_provider) as dvt:
+        device_info = DeviceInfo(dvt)
+
+        with Sysmontap(dvt) as sysmon:
+            for process_snapshot in sysmon.iter_processes():
+                count += 1
+
+                if count < 2:
+                    # first sample doesn't contain an initialized value for cpuUsage
+                    continue
+
+                for process in process_snapshot:
+                    skip = False
+                    if attributes is not None:
+                        for filter_attr in attributes:
+                            filter_attr, filter_value = filter_attr.split("=", 1)
+                            if str(process[filter_attr]) != filter_value:
+                                skip = True
+                                break
+
+                    if skip:
+                        continue
+
+                    # adding "artificially" the execName field
+                    process["execName"] = device_info.execname_for_pid(process["pid"])
+                    result.append(process)
+
+                # exit after single snapshot
+                break
+
+    print_json(result)
+
+
+@cli.command("monitor-single")
+def sysmon_process_monitor_single(
+    service_provider: ServiceProviderDep,
+    attributes: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--attributes",
+            "-a",
+            help="filter processes by attribute (key=value). Multiple filters on same attribute use OR logic, different attributes use AND.",
+        ),
+    ] = None,
+    output: Annotated[
+        Optional[Path],
+        typer.Option(
+            "--output",
+            "-o",
+            help="output file path for JSONL format (optional, defaults to stdout)",
+        ),
+    ] = None,
+    interval: Annotated[
+        Optional[int],
+        typer.Option(
+            "--interval",
+            "-i",
+            help="minimum interval in milliseconds between outputs (optional)",
+        ),
+    ] = None,
+    duration: Annotated[
+        Optional[int],
+        typer.Option(
+            "--duration",
+            "-d",
+            help="maximum duration in milliseconds to run monitoring (optional)",
+        ),
+    ] = None,
+) -> None:
+    """Continuously monitor a single process with comprehensive metrics."""
+    count = 0
+    start_time = None
+
+    # Parse attributes into grouped filters: same attribute uses OR, different attributes use AND
+    parsed_filters: dict[str, list[str]] = {}
+    if attributes:
+        for raw in attributes:
+            key, value = raw.split("=", 1)
+            parsed_filters.setdefault(key, []).append(value)
+
+    def matches_filters(proc: dict) -> bool:
+        """Check if process matches all filter criteria."""
+        if not parsed_filters:
+            return True
+        return all(str(proc.get(key)) in values for key, values in parsed_filters.items())
+
+    with contextlib.ExitStack() as stack:
+        output_file = stack.enter_context(open(output, "w")) if output else None
+
+        dvt = stack.enter_context(DvtSecureSocketProxyService(lockdown=service_provider))
+        sysmon = stack.enter_context(Sysmontap(dvt))
+
+        for process_snapshot in sysmon.iter_processes():
+            count += 1
+
+            if count < 2:
+                continue
+
+            if start_time is None:
+                start_time = time.time()
+
+            if duration is not None:
+                elapsed_ms = (time.time() - start_time) * 1000
+                if elapsed_ms >= duration:
+                    break
+
+            for process in process_snapshot:
+                if not matches_filters(process):
+                    continue
+
+                process["timestamp"] = datetime.now(timezone.utc).isoformat()
+
+                if output_file:
+                    json_output = json.dumps(process, default=default_json_encoder)
+                    output_file.write(json_output + "\n")
+                    output_file.flush()
+                else:
+                    print_json(process)
+
+            if interval:
+                time.sleep(interval / 1000.0)

pymobiledevice3/cli/developer/fetch_symbols.py

@@ -0,0 +1,108 @@
+import asyncio
+import logging
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from ipsw_parser.dsc import create_device_support_layout, get_device_support_path
+from packaging.version import Version
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.exceptions import RSDRequiredError
+from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
+from pymobiledevice3.services.dtfetchsymbols import DtFetchSymbols
+from pymobiledevice3.services.remote_fetch_symbols import RemoteFetchSymbolsService
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="fetch-symbols",
+    help="Download the DSC (and dyld) from the device",
+    no_args_is_help=True,
+)
+
+
+async def fetch_symbols_list_task(service_provider: LockdownServiceProvider) -> None:
+    if Version(service_provider.product_version) < Version("17.0"):
+        print_json(DtFetchSymbols(service_provider).list_files())
+    else:
+        if not isinstance(service_provider, RemoteServiceDiscoveryService):
+            raise RSDRequiredError(service_provider.identifier)
+
+        async with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
+            print_json([f.file_path for f in await fetch_symbols.get_dsc_file_list()])
+
+
+@cli.command("list")
+def fetch_symbols_list(service_provider: ServiceProviderDep) -> None:
+    """list of files to be downloaded"""
+    asyncio.run(fetch_symbols_list_task(service_provider), debug=True)
+
+
+async def fetch_symbols_download_task(service_provider: LockdownServiceProvider, out: Optional[Path] = None) -> None:
+    should_create_device_support_layout = False
+    if out is None:
+        assert service_provider.product_type is not None  # for type checker
+        out = get_device_support_path(
+            service_provider.product_type, service_provider.product_version, service_provider.product_build_version
+        )
+        should_create_device_support_layout = True
+
+    logger.info(f"Downloading DSC into: {out}")
+
+    out.mkdir(parents=True, exist_ok=True)
+
+    if Version(service_provider.product_version) < Version("17.0"):
+        fetch_symbols = DtFetchSymbols(service_provider)
+        files = fetch_symbols.list_files()
+
+        downloaded_files = set()
+
+        for i, file in enumerate(files):
+            if file.startswith("/"):
+                # trim root to allow relative download
+                file = file[1:]
+            file = out / file
+
+            if file not in downloaded_files:
+                # first time the file was seen in list, means we can safely remove any old copy if any
+                file.unlink(missing_ok=True)
+
+            downloaded_files.add(file)
+            file.parent.mkdir(parents=True, exist_ok=True)
+            with open(file, "ab") as f:
+                # same file may appear twice, so we'll need to append data into it
+                logger.info(f"writing to: {file}")
+                fetch_symbols.get_file(i, f)
+    else:
+        if not isinstance(service_provider, RemoteServiceDiscoveryService):
+            raise RSDRequiredError(service_provider.identifier)
+        async with RemoteFetchSymbolsService(service_provider) as fetch_symbols:
+            await fetch_symbols.download(out)
+
+    if should_create_device_support_layout:
+        assert service_provider.product_type is not None  # for type checker
+        create_device_support_layout(
+            service_provider.product_type, service_provider.product_version, service_provider.product_build_version, out
+        )
+
+
+@cli.command("download")
+def fetch_symbols_download(
+    service_provider: ServiceProviderDep,
+    out: Annotated[
+        Optional[Path],
+        typer.Argument(dir_okay=True, file_okay=False),
+    ] = None,
+) -> None:
+    """
+    Fetches symbols from the given device and saves them into Xcode DeviceSupport directory.
+
+    This command downloads symbol data. Optionally, the user can specify an output directory where the data will
+    be stored. If no output directory is provided, the symbols will be downloaded into the Xcode directory directly
+    (DeviceSupport).
+    """
+    asyncio.run(fetch_symbols_download_task(service_provider, out), debug=True)

pymobiledevice3/cli/developer/simulate_location.py

@@ -0,0 +1,51 @@
+import logging
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
+from pymobiledevice3.services.simulate_location import DtSimulateLocation
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="simulate-location",
+    help="Simulate GPS location (set, clear, or replay GPX routes).",
+    no_args_is_help=True,
+)
+
+
+@cli.command("clear")
+def simulate_location_clear(service_provider: ServiceProviderDep) -> None:
+    """Stop location simulation and resume real GPS."""
+    DtSimulateLocation(service_provider).clear()
+
+
+@cli.command("set")
+def simulate_location_set(service_provider: ServiceProviderDep, latitude: float, longitude: float) -> None:
+    """
+    Set a fixed simulated location (latitude, longitude).
+    Example: `set 40.690008 -74.045843` (Liberty Island).
+    """
+    DtSimulateLocation(service_provider).set(latitude, longitude)
+
+
+@cli.command("play")
+def simulate_location_play(
+    service_provider: ServiceProviderDep,
+    filename: Annotated[
+        Path,
+        typer.Argument(exists=True, file_okay=True, dir_okay=False),
+    ],
+    timing_randomness_range: int,
+    disable_sleep: Annotated[bool, typer.Option()] = False,
+) -> None:
+    """Replay a GPX route; optionally disable sleeps and add timing jitter."""
+    DtSimulateLocation(service_provider).play_gpx_file(
+        str(filename),
+        disable_sleep=disable_sleep,
+        timing_randomness_range=timing_randomness_range,
+    )

pymobiledevice3/cli/diagnostics/__init__.py

@@ -0,0 +1,75 @@
+import logging
+from typing import Annotated, Optional
+
+import typer
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.cli.diagnostics import battery
+from pymobiledevice3.lockdown import retry_create_using_usbmux
+from pymobiledevice3.services.diagnostics import DiagnosticsService
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="diagnostics",
+    help="Reboot/Shutdown device or access other diagnostics services",
+    no_args_is_help=True,
+)
+cli.add_typer(battery.cli)
+
+
+@cli.command("restart")
+def diagnostics_restart(
+    service_provider: ServiceProviderDep,
+    reconnect: Annotated[
+        bool,
+        typer.Option(
+            "--reconnect",
+            "-r",
+            help="Wait until the device reconnects before finishing the operation.",
+        ),
+    ] = False,
+) -> None:
+    """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}).")
+
+
+@cli.command("shutdown")
+def diagnostics_shutdown(service_provider: ServiceProviderDep) -> None:
+    """Shutdown device"""
+    DiagnosticsService(lockdown=service_provider).shutdown()
+
+
+@cli.command("sleep")
+def diagnostics_sleep(service_provider: ServiceProviderDep) -> None:
+    """Put device into sleep"""
+    DiagnosticsService(lockdown=service_provider).sleep()
+
+
+@cli.command("info")
+def diagnostics_info(service_provider: ServiceProviderDep) -> None:
+    """Get diagnostics info"""
+    print_json(DiagnosticsService(lockdown=service_provider).info())
+
+
+@cli.command("ioregistry")
+def diagnostics_ioregistry(
+    service_provider: ServiceProviderDep,
+    plane: Annotated[Optional[str], typer.Option()] = None,
+    name: Annotated[Optional[str], typer.Option()] = None,
+    ioclass: Annotated[Optional[str], typer.Option()] = None,
+) -> None:
+    """Get ioregistry info"""
+    print_json(DiagnosticsService(lockdown=service_provider).ioregistry(plane=plane, name=name, ioclass=ioclass))
+
+
+@cli.command("mg")
+def diagnostics_mg(service_provider: ServiceProviderDep, keys: Optional[list[str]] = None) -> None:
+    """Get MobileGestalt key values from given list. If empty, return all known."""
+    print_json(DiagnosticsService(lockdown=service_provider).mobilegestalt(keys=keys))

pymobiledevice3/cli/diagnostics/battery.py

@@ -0,0 +1,47 @@
+import logging
+import time
+
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.services.diagnostics import DiagnosticsService
+
+logger = logging.getLogger(__name__)
+
+
+cli = InjectingTyper(
+    name="battery",
+    help="Battery options",
+    no_args_is_help=True,
+)
+
+
+@cli.command("single")
+def diagnostics_battery_single(service_provider: ServiceProviderDep) -> None:
+    """get single snapshot of battery data"""
+    raw_info = DiagnosticsService(lockdown=service_provider).get_battery()
+    print_json(raw_info)
+
+
+@cli.command("monitor")
+def diagnostics_battery_monitor(service_provider: ServiceProviderDep) -> None:
+    """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"),
+        }
+        logger.info(info)
+        time.sleep(1)
+
+
+@cli.command("wifi")
+def diagnostics_wifi(service_provider: ServiceProviderDep) -> None:
+    """Query WiFi info from IORegistry"""
+    raw_info = DiagnosticsService(lockdown=service_provider).get_wifi()
+    print_json(raw_info)

pymobiledevice3/cli/idam.py

@@ -1,46 +1,42 @@
 import logging
+from textwrap import dedent
 
-import click
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, print_json
-from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
 from pymobiledevice3.services.idam import IDAMService
 
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="idam",
+    help=dedent("""\
+        Access IDAM (Inter-Device Audio and MIDI) configuration
 
+        For more info refer to:
+        <https://www.youtube.com/watch?v=IXmP938brnc>
+    """),
+    no_args_is_help=True,
+)
 
-@cli.group("idam")
-def idam() -> None:
-    """
-    Access IDAM (Inter-Device Audio and MIDI) configuration
 
-    For more info refer to:
-    <https://www.youtube.com/watch?v=IXmP938brnc>
-    """
-    pass
-
-
-@idam.command(cls=Command)
-def configuration_inquiry(service_provider: LockdownServiceProvider) -> None:
+@cli.command()
+def configuration_inquiry(service_provider: ServiceProviderDep) -> None:
     """Inquiry IDAM configuration"""
     with IDAMService(service_provider) as idam:
         print_json(idam.configuration_inquiry())
 
 
-@idam.command(cls=Command)
-def enable(service_provider: LockdownServiceProvider) -> None:
+@cli.command()
+def enable(service_provider: ServiceProviderDep) -> None:
     """Enable IDAM"""
     with IDAMService(service_provider) as idam:
         idam.set_idam_configuration(True)
 
 
-@idam.command(cls=Command)
-def disable(service_provider: LockdownServiceProvider) -> None:
+@cli.command()
+def disable(service_provider: ServiceProviderDep) -> None:
     """Disable IDAM"""
     with IDAMService(service_provider) as idam:
         idam.set_idam_configuration(False)