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

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

@@ -0,0 +1,42 @@
+import logging
+from textwrap import dedent
+
+from typer_injector import InjectingTyper
+
+from pymobiledevice3.cli.cli_common import ServiceProviderDep, print_json
+from pymobiledevice3.services.idam import IDAMService
+
+logger = logging.getLogger(__name__)
+
+
+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.command()
+def configuration_inquiry(service_provider: ServiceProviderDep) -> None:
+    """Inquiry IDAM configuration"""
+    with IDAMService(service_provider) as idam:
+        print_json(idam.configuration_inquiry())
+
+
+@cli.command()
+def enable(service_provider: ServiceProviderDep) -> None:
+    """Enable IDAM"""
+    with IDAMService(service_provider) as idam:
+        idam.set_idam_configuration(True)
+
+
+@cli.command()
+def disable(service_provider: ServiceProviderDep) -> None:
+    """Disable IDAM"""
+    with IDAMService(service_provider) as idam:
+        idam.set_idam_configuration(False)

pymobiledevice3/cli/lockdown.py

@@ -2,13 +2,13 @@ import asyncio
 import logging
 import plistlib
 from pathlib import Path
-from typing import Optional
+from typing import Annotated, Literal, Optional
 
-import click
+import typer
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command, CommandWithoutAutopair, print_json, sudo_required
+from pymobiledevice3.cli.cli_common import NoAutoPairServiceProviderDep, ServiceProviderDep, print_json, sudo_required
 from pymobiledevice3.cli.remote import tunnel_task
-from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.remote.common import TunnelProtocol
 from pymobiledevice3.remote.tunnel_service import CoreDeviceTunnelProxy
@@ -17,169 +17,174 @@ from pymobiledevice3.services.heartbeat import HeartbeatService
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="lockdown",
+    help="Pair/Unpair device or access other lockdown services",
+    no_args_is_help=True,
+)
 
 
-@cli.group('lockdown')
-def lockdown_group() -> None:
-    """ Pair/Unpair device or access other lockdown services """
-    pass
-
-
-@lockdown_group.command('recovery', cls=Command)
-def lockdown_recovery(service_provider: LockdownClient):
-    """ enter recovery """
+@cli.command("recovery")
+def lockdown_recovery(service_provider: ServiceProviderDep) -> None:
+    """enter recovery"""
     print_json(service_provider.enter_recovery())
 
 
-@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"""
+@cli.command("service")
+def lockdown_service(service_provider: ServiceProviderDep, service_name: str) -> None:
+    """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')
-def lockdown_developer_service(service_provider: LockdownServiceProvider, service_name):
-    """ send-receive raw service messages with a given developer service name """
+@cli.command("developer-service")
+def lockdown_developer_service(service_provider: ServiceProviderDep, service_name: str) -> None:
+    """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)
-def lockdown_info(service_provider: LockdownServiceProvider):
-    """ query all lockdown values """
+@cli.command("info")
+def lockdown_info(service_provider: ServiceProviderDep) -> None:
+    """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)
-def lockdown_get(service_provider: LockdownClient, domain, key):
-    """ query lockdown values by their domain and key names """
+@cli.command("get")
+def lockdown_get(service_provider: ServiceProviderDep, domain: Optional[str] = None, key: Optional[str] = None) -> None:
+    """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)
-def lockdown_set(service_provider: LockdownClient, value, domain, key):
-    """ set a lockdown value using python's eval() """
+@cli.command("set")
+def lockdown_set(
+    service_provider: ServiceProviderDep,
+    value: str,
+    domain: Optional[str] = None,
+    key: Optional[str] = None,
+) -> None:
+    """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')
-def lockdown_remove(service_provider: LockdownClient, domain, key):
-    """ remove a domain/key pair """
+@cli.command("remove")
+def lockdown_remove(service_provider: ServiceProviderDep, domain: str, key: str) -> None:
+    """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 """
+@cli.command("unpair")
+def lockdown_unpair(service_provider: NoAutoPairServiceProviderDep, host_id: Optional[str] = None) -> None:
+    """unpair from connected device"""
     service_provider.unpair(host_id=host_id)
 
 
-@lockdown_group.command('pair', cls=CommandWithoutAutopair)
-def lockdown_pair(service_provider: LockdownClient):
-    """ pair device """
+@cli.command("pair")
+def lockdown_pair(service_provider: NoAutoPairServiceProviderDep) -> None:
+    """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))
-def lockdown_pair_supervised(service_provider: LockdownClient, keybag: str) -> None:
-    """ pair supervised device """
-    service_provider.pair_supervised(Path(keybag))
+@cli.command("pair-supervised")
+def lockdown_pair_supervised(
+    service_provider: NoAutoPairServiceProviderDep,
+    keybag: Annotated[
+        Path,
+        typer.Argument(file_okay=True, dir_okay=False, exists=True),
+    ],
+) -> None:
+    """pair supervised device"""
+    service_provider.pair_supervised(keybag)
 
 
-@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 """
+@cli.command("save-pair-record")
+def lockdown_save_pair_record(service_provider: NoAutoPairServiceProviderDep, output: Path) -> None:
+    """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)
+    output.write_bytes(plistlib.dumps(service_provider.pair_record))
 
 
-@lockdown_group.command('date', cls=Command)
-def lockdown_date(service_provider: LockdownClient):
-    """ get device date """
+@cli.command("date")
+def lockdown_date(service_provider: ServiceProviderDep) -> None:
+    """get device date"""
     print(service_provider.date)
 
 
-@lockdown_group.command('heartbeat', cls=Command)
-def lockdown_heartbeat(service_provider: LockdownClient):
-    """ start heartbeat service """
+@cli.command("heartbeat")
+def lockdown_heartbeat(service_provider: ServiceProviderDep) -> None:
+    """start heartbeat service"""
     HeartbeatService(service_provider).start()
 
 
-@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 """
+@cli.command("language")
+def lockdown_language(service_provider: ServiceProviderDep, language: Optional[str] = None) -> None:
+    """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)
-def lockdown_locale(service_provider: LockdownClient, locale: Optional[str]) -> None:
-    """ Get/Set current language settings """
+@cli.command("locale")
+def lockdown_locale(service_provider: ServiceProviderDep, locale: Optional[str] = None) -> None:
+    """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)
-def lockdown_device_name(service_provider: LockdownClient, new_name):
-    """ get/set current device name """
+@cli.command("device-name")
+def lockdown_device_name(service_provider: ServiceProviderDep, new_name: Optional[str] = None) -> None:
+    """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)
-def lockdown_wifi_connections(service_provider: LockdownClient, state):
-    """ get/set wifi connections state """
+@cli.command("wifi-connections")
+def lockdown_wifi_connections(
+    service_provider: ServiceProviderDep, state: Optional[Literal["on", "off"]] = None
+) -> None:
+    """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"
 
 
-@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 """
-    service = CoreDeviceTunnelProxy(service_provider)
-    asyncio.run(tunnel_task(service, script_mode=script_mode, secrets=None, protocol=TunnelProtocol.TCP), debug=True)
+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('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) """
+@cli.command("start-tunnel")
+@sudo_required
+def cli_start_tunnel(
+    service_provider: ServiceProviderDep,
+    script_mode: Annotated[
+        bool,
+        typer.Option(help="Show only HOST and port number to allow easy parsing from external shell scripts"),
+    ] = False,
+) -> None:
+    """start tunnel"""
+    asyncio.run(async_cli_start_tunnel(service_provider, script_mode), debug=True)
+
+
+@cli.command("assistive-touch")
+def lockdown_assistive_touch(
+    service_provider: ServiceProviderDep, state: Optional[Literal["on", "off"]] = None
+) -> None:
+    """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"