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

pymobiledevice3/services/amfi.py

@@ -1,32 +1,33 @@
 #!/usr/bin/env python3
 import logging
 
-import construct
-
-from pymobiledevice3.exceptions import AmfiError, BadDevError, ConnectionFailedError, DeveloperModeError, \
-    DeviceHasPasscodeSetError, DeviceNotFoundError, NoDeviceConnectedError, PyMobileDevice3Exception
-from pymobiledevice3.lockdown import LockdownClient, create_using_usbmux
+from pymobiledevice3.exceptions import (
+    AmfiError,
+    DeveloperModeError,
+    DeviceHasPasscodeSetError,
+    PyMobileDevice3Exception,
+)
+from pymobiledevice3.lockdown import LockdownClient, retry_create_using_usbmux
 from pymobiledevice3.services.heartbeat import HeartbeatService
 
 
 class AmfiService:
-
     DEVELOPER_MODE_REVEAL = 0
     DEVELOPER_MODE_ENABLE = 1
     DEVELOPER_MODE_ACCEPT = 2
 
-    SERVICE_NAME = 'com.apple.amfi.lockdown'
+    SERVICE_NAME = "com.apple.amfi.lockdown"
 
     def __init__(self, lockdown: LockdownClient):
         self._lockdown = lockdown
         self._logger = logging.getLogger(self.__module__)
 
     def reveal_developer_mode_option_in_ui(self):
-        """ create an empty file at AMFIShowOverridePath """
+        """create an empty file at AMFIShowOverridePath"""
         service = self._lockdown.start_lockdown_service(self.SERVICE_NAME)
-        resp = service.send_recv_plist({'action': self.DEVELOPER_MODE_REVEAL})
-        if not resp.get('success'):
-            raise PyMobileDevice3Exception(f'create_AMFIShowOverridePath() failed with: {resp}')
+        resp = service.send_recv_plist({"action": self.DEVELOPER_MODE_REVEAL})
+        if not resp.get("success"):
+            raise PyMobileDevice3Exception(f"create_AMFIShowOverridePath() failed with: {resp}")
 
     def enable_developer_mode(self, enable_post_restart=True):
         """
@@ -35,38 +36,31 @@ class AmfiService:
         with "yes"
         """
         service = self._lockdown.start_lockdown_service(self.SERVICE_NAME)
-        resp = service.send_recv_plist({'action': self.DEVELOPER_MODE_ENABLE})
-        error = resp.get('Error')
+        resp = service.send_recv_plist({"action": self.DEVELOPER_MODE_ENABLE})
+        error = resp.get("Error")
 
         if error is not None:
-            if error == 'Device has a passcode set':
+            if error == "Device has a passcode set":
                 raise DeviceHasPasscodeSetError()
             raise AmfiError(error)
 
-        if not resp.get('success'):
-            raise DeveloperModeError(f'enable_developer_mode(): {resp}')
+        if not resp.get("success"):
+            raise DeveloperModeError(f"enable_developer_mode(): {resp}")
 
         if not enable_post_restart:
             return
 
         try:
             HeartbeatService(self._lockdown).start()
-        except ConnectionAbortedError:
-            self._logger.debug('device disconnected, awaiting reconnect')
-
-        while True:
-            try:
-                self._lockdown = create_using_usbmux(self._lockdown.udid)
-                break
-            except (NoDeviceConnectedError, ConnectionFailedError, BadDevError, OSError, construct.core.StreamError,
-                    DeviceNotFoundError):
-                pass
+        except (ConnectionAbortedError, BrokenPipeError):
+            self._logger.debug("device disconnected, awaiting reconnect")
 
+        self._lockdown = retry_create_using_usbmux(None, serial=self._lockdown.udid)
         self.enable_developer_mode_post_restart()
 
     def enable_developer_mode_post_restart(self):
-        """ answer the prompt that appears after the restart with "yes" """
+        """answer the prompt that appears after the restart with "yes" """
         service = self._lockdown.start_lockdown_service(self.SERVICE_NAME)
-        resp = service.send_recv_plist({'action': self.DEVELOPER_MODE_ACCEPT})
-        if not resp.get('success'):
-            raise DeveloperModeError(f'enable_developer_mode_post_restart() failed: {resp}')
+        resp = service.send_recv_plist({"action": self.DEVELOPER_MODE_ACCEPT})
+        if not resp.get("success"):
+            raise DeveloperModeError(f"enable_developer_mode_post_restart() failed: {resp}")

pymobiledevice3/services/companion.py

@@ -8,8 +8,8 @@ from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class CompanionProxyService(LockdownService):
-    SERVICE_NAME = 'com.apple.companion_proxy'
-    RSD_SERVICE_NAME = 'com.apple.companion_proxy.shim.remote'
+    SERVICE_NAME = "com.apple.companion_proxy"
+    RSD_SERVICE_NAME = "com.apple.companion_proxy.shim.remote"
 
     def __init__(self, lockdown: LockdownServiceProvider):
         if isinstance(lockdown, LockdownClient):
@@ -19,48 +19,52 @@ class CompanionProxyService(LockdownService):
 
     def list(self):
         service = self.lockdown.start_lockdown_service(self.service_name)
-        return service.send_recv_plist({'Command': 'GetDeviceRegistry'}).get('PairedDevicesArray', [])
+        return service.send_recv_plist({"Command": "GetDeviceRegistry"}).get("PairedDevicesArray", [])
 
     def listen_for_devices(self):
         service = self.lockdown.start_lockdown_service(self.service_name)
-        service.send_plist({'Command': 'StartListeningForDevices'})
+        service.send_plist({"Command": "StartListeningForDevices"})
         while True:
             yield service.recv_plist()
 
     def get_value(self, udid: str, key: str):
         service = self.lockdown.start_lockdown_service(self.service_name)
-        response = service.send_recv_plist({'Command': 'GetValueFromRegistry',
-                                            'GetValueGizmoUDIDKey': udid,
-                                            'GetValueKeyKey': key})
+        response = service.send_recv_plist({
+            "Command": "GetValueFromRegistry",
+            "GetValueGizmoUDIDKey": udid,
+            "GetValueKeyKey": key,
+        })
 
-        value = response.get('RetrievedValueDictionary')
+        value = response.get("RetrievedValueDictionary")
         if value is not None:
             return value
 
-        error = response.get('Error')
+        error = response.get("Error")
         raise PyMobileDevice3Exception(error)
 
-    def start_forwarding_service_port(self, remote_port: int, service_name: Optional[str] = None,
-                                      options: Optional[dict] = None):
+    def start_forwarding_service_port(
+        self, remote_port: int, service_name: Optional[str] = None, options: Optional[dict] = None
+    ):
         service = self.lockdown.start_lockdown_service(self.service_name)
 
-        request = {'Command': 'StartForwardingServicePort',
-                   'GizmoRemotePortNumber': remote_port,
-                   'IsServiceLowPriority': False,
-                   'PreferWifi': False}
+        request = {
+            "Command": "StartForwardingServicePort",
+            "GizmoRemotePortNumber": remote_port,
+            "IsServiceLowPriority": False,
+            "PreferWifi": False,
+        }
 
         if service_name is not None:
-            request['ForwardedServiceName'] = service_name
+            request["ForwardedServiceName"] = service_name
 
         if options is not None:
             request.update(options)
 
-        return service.send_recv_plist(request).get('CompanionProxyServicePort')
+        return service.send_recv_plist(request).get("CompanionProxyServicePort")
 
     def stop_forwarding_service_port(self, remote_port: int):
         service = self.lockdown.start_lockdown_service(self.service_name)
 
-        request = {'Command': 'StopForwardingServicePort',
-                   'GizmoRemotePortNumber': remote_port}
+        request = {"Command": "StopForwardingServicePort", "GizmoRemotePortNumber": remote_port}
 
         return service.send_recv_plist(request)

pymobiledevice3/services/crash_reports.py

@@ -3,21 +3,27 @@ import posixpath
 import re
 import time
 from collections.abc import Generator
-from typing import Callable, Optional
+from json import JSONDecodeError
+from typing import Callable, ClassVar, Optional
 
 from pycrashreport.crash_report import get_crash_report_from_buf
 from xonsh.built_ins import XSH
 from xonsh.cli_utils import Annotated, Arg
 
-from pymobiledevice3.exceptions import AfcException, NotificationTimeoutError, SysdiagnoseTimeoutError
+from pymobiledevice3.exceptions import (
+    AfcException,
+    AfcFileNotFoundError,
+    NotificationTimeoutError,
+    SysdiagnoseTimeoutError,
+)
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.afc import AfcService, AfcShell, path_completer
 from pymobiledevice3.services.notification_proxy import NotificationProxyService
 from pymobiledevice3.services.os_trace import OsTraceService
 
-SYSDIAGNOSE_PROCESS_NAMES = ('sysdiagnose', 'sysdiagnosed')
-SYSDIAGNOSE_DIR = 'DiagnosticLogs/sysdiagnose'
+SYSDIAGNOSE_PROCESS_NAMES = ("sysdiagnose", "sysdiagnosed")
+SYSDIAGNOSE_DIR = "DiagnosticLogs/sysdiagnose"
 SYSDIAGNOSE_IN_PROGRESS_MAX_TTL_SECS = 600
 
 # on iOS17, we need to wait for a moment before trying to fetch the sysdiagnose archive
@@ -25,14 +31,14 @@ IOS17_SYSDIAGNOSE_DELAY = 3
 
 
 class CrashReportsManager:
-    COPY_MOBILE_NAME = 'com.apple.crashreportcopymobile'
-    RSD_COPY_MOBILE_NAME = 'com.apple.crashreportcopymobile.shim.remote'
+    COPY_MOBILE_NAME = "com.apple.crashreportcopymobile"
+    RSD_COPY_MOBILE_NAME = "com.apple.crashreportcopymobile.shim.remote"
 
-    CRASH_MOVER_NAME = 'com.apple.crashreportmover'
-    RSD_CRASH_MOVER_NAME = 'com.apple.crashreportmover.shim.remote'
+    CRASH_MOVER_NAME = "com.apple.crashreportmover"
+    RSD_CRASH_MOVER_NAME = "com.apple.crashreportmover.shim.remote"
 
-    APPSTORED_PATH = '/com.apple.appstored'
-    IN_PROGRESS_SYSDIAGNOSE_EXTENSIONS = ['.tmp', '.tar.gz']
+    APPSTORED_PATH = "/com.apple.appstored"
+    IN_PROGRESS_SYSDIAGNOSE_EXTENSIONS: ClassVar = [".tmp", ".tar.gz"]
 
     def __init__(self, lockdown: LockdownServiceProvider):
         self.logger = logging.getLogger(__name__)
@@ -61,16 +67,16 @@ class CrashReportsManager:
         Clear all crash reports.
         """
         undeleted_items = []
-        for filename in self.ls('/'):
+        for filename in self.ls("/"):
             undeleted_items.extend(self.afc.rm(filename, force=True))
 
         for item in undeleted_items:
             # special case of file that sometimes created automatically right after delete,
             # and then we can't delete the folder because it's not empty
             if item != self.APPSTORED_PATH:
-                raise AfcException(f'failed to clear crash reports directory, undeleted items: {undeleted_items}', None)
+                raise AfcException(f"failed to clear crash reports directory, undeleted items: {undeleted_items}", None)
 
-    def ls(self, path: str = '/', depth: int = 1) -> list[str]:
+    def ls(self, path: str = "/", depth: int = 1) -> list[str]:
         """
         List file and folder in the crash report's directory.
         :param path: Path to list, relative to the crash report's directory.
@@ -79,30 +85,32 @@ class CrashReportsManager:
         """
         return list(self.afc.dirlist(path, depth))[1:]  # skip the root path '/'
 
-    def pull(self, out: str, entry: str = '/', erase: bool = False, match: Optional[str] = None) -> None:
+    def pull(
+        self, out: str, entry: str = "/", erase: bool = False, match: Optional[str] = None, progress_bar: bool = True
+    ) -> None:
         """
         Pull crash reports from the device.
         :param out: Directory to pull crash reports to.
         :param entry: File or Folder to pull.
         :param erase: Whether to erase the original file from the CrashReports directory.
         :param match: Regex to match against file and directory names to pull.
+        :param progress_bar: Whether to show a progress bar when pulling large files.
         """
 
         def log(src: str, dst: str) -> None:
-            self.logger.info(f'{src} --> {dst}')
-            if erase:
-                if not self.afc.isdir(src):
-                    self.afc.rm_single(src, force=True)
+            self.logger.info(f"{src} --> {dst}")
+            if erase and not self.afc.isdir(src):
+                self.afc.rm_single(src, force=True)
 
         match = None if match is None else re.compile(match)
-        self.afc.pull(entry, out, match, callback=log)
+        self.afc.pull(entry, out, match, callback=log, progress_bar=progress_bar, ignore_errors=True)
 
     def flush(self) -> None:
-        """ Trigger com.apple.crashreportmover to flush all products into CrashReports directory """
-        ack = b'ping\x00'
+        """Trigger com.apple.crashreportmover to flush all products into CrashReports directory"""
+        ack = b"ping\x00"
         assert ack == self.lockdown.start_lockdown_service(self.crash_mover_service_name).recvall(len(ack))
 
-    def watch(self, name: str = None, raw: bool = False) -> Generator[str, None, None]:
+    def watch(self, name: Optional[str] = None, raw: bool = False) -> Generator[str, None, None]:
         """
         Monitor creation of new crash reports for a given process name.
 
@@ -110,20 +118,28 @@ class CrashReportsManager:
         representation for the crash.
         """
         for syslog_entry in OsTraceService(lockdown=self.lockdown).syslog():
-            if (posixpath.basename(syslog_entry.filename) != 'osanalyticshelper') or \
-                    (posixpath.basename(syslog_entry.image_name) != 'OSAnalytics') or \
-                    not syslog_entry.message.startswith('Saved type '):
+            if (
+                (posixpath.basename(syslog_entry.filename) != "osanalyticshelper")
+                or (posixpath.basename(syslog_entry.image_name) != "OSAnalytics")
+                or not syslog_entry.message.startswith("Saved type ")
+            ):
                 # skip non-ips creation syslog lines
                 continue
 
             filename = posixpath.basename(syslog_entry.message.split()[-1])
-            self.logger.debug(f'crash report: {filename}')
+            self.logger.debug(f"crash report: {filename}")
 
-            if posixpath.splitext(filename)[-1] not in ('.ips', '.panic'):
+            if posixpath.splitext(filename)[-1] not in (".ips", ".panic"):
                 continue
 
-            crash_report_raw = self.afc.get_file_contents(filename).decode()
-            crash_report = get_crash_report_from_buf(crash_report_raw, filename=filename)
+            while True:
+                try:
+                    crash_report_raw = self.afc.get_file_contents(filename).decode()
+                    crash_report = get_crash_report_from_buf(crash_report_raw, filename=filename)
+                    break
+                except (AfcFileNotFoundError, JSONDecodeError):
+                    # Sometimes we have to wait for the file to be readable
+                    pass
 
             if name is None or crash_report.name == name:
                 if raw:
@@ -131,8 +147,14 @@ class CrashReportsManager:
                 else:
                     yield crash_report
 
-    def get_new_sysdiagnose(self, out: str, erase: bool = True, *, timeout: Optional[float] = None,
-                            callback: Optional[Callable[[float], None]] = None) -> None:
+    def get_new_sysdiagnose(
+        self,
+        out: str,
+        erase: bool = True,
+        *,
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[float], None]] = None,
+    ) -> None:
         """
         Monitor the creation of a newly created sysdiagnose archive and pull it
         :param out: filename
@@ -150,7 +172,7 @@ class CrashReportsManager:
         if callback is not None:
             callback(time.monotonic() - start_time)
 
-        self.logger.info('sysdiagnose tarball creation has been started')
+        self.logger.info("sysdiagnose tarball creation has been started")
         self._wait_for_sysdiagnose_to_finish(timeout)
 
         if callback is not None:
@@ -163,17 +185,17 @@ class CrashReportsManager:
 
     def _wait_for_sysdiagnose_to_finish(self, end_time: Optional[float] = None) -> None:
         with NotificationProxyService(self.lockdown, timeout=end_time) as service:
-            stop_notification = 'com.apple.sysdiagnose.sysdiagnoseStopped'
+            stop_notification = "com.apple.sysdiagnose.sysdiagnoseStopped"
             service.notify_register_dispatch(stop_notification)
             try:
                 for event in service.receive_notification():
-                    if event['Name'] != stop_notification:
+                    if event["Name"] != stop_notification:
                         continue
-                    self.logger.debug(f'Received {event}')
+                    self.logger.debug(f"Received {event}")
                     time.sleep(IOS17_SYSDIAGNOSE_DELAY)
                     break
             except NotificationTimeoutError as e:
-                raise SysdiagnoseTimeoutError('Timeout waiting for sysdiagnose completion') from e
+                raise SysdiagnoseTimeoutError("Timeout waiting for sysdiagnose completion") from e
 
     def _get_new_sysdiagnose_filename(self, end_time: Optional[float] = None) -> str:
         sysdiagnose_filename = None
@@ -183,17 +205,19 @@ class CrashReportsManager:
             try:
                 for filename in self.afc.listdir(SYSDIAGNOSE_DIR):
                     # search for an IN_PROGRESS archive
-                    if filename not in excluded_temp_files and 'IN_PROGRESS_' in filename:
+                    if filename not in excluded_temp_files and "IN_PROGRESS_" in filename:
                         for ext in self.IN_PROGRESS_SYSDIAGNOSE_EXTENSIONS:
                             if filename.endswith(ext):
-                                delta = self.lockdown.date - \
-                                        self.afc.stat(posixpath.join(SYSDIAGNOSE_DIR, filename))['st_mtime']
+                                delta = (
+                                    self.lockdown.date
+                                    - self.afc.stat(posixpath.join(SYSDIAGNOSE_DIR, filename))["st_mtime"]
+                                )
                                 # Ignores IN_PROGRESS sysdiagnose files older than the defined time to live
                                 if delta.total_seconds() < SYSDIAGNOSE_IN_PROGRESS_MAX_TTL_SECS:
-                                    self.logger.debug(f'Detected in progress sysdiagnose {filename}')
+                                    self.logger.debug(f"Detected in progress sysdiagnose {filename}")
                                     sysdiagnose_filename = filename.rsplit(ext)[0]
-                                    sysdiagnose_filename = sysdiagnose_filename.replace('IN_PROGRESS_', '')
-                                    sysdiagnose_filename = f'{sysdiagnose_filename}.tar.gz'
+                                    sysdiagnose_filename = sysdiagnose_filename.replace("IN_PROGRESS_", "")
+                                    sysdiagnose_filename = f"{sysdiagnose_filename}.tar.gz"
                                     return posixpath.join(SYSDIAGNOSE_DIR, sysdiagnose_filename)
                                 else:
                                     self.logger.warning(f"Old sysdiagnose temp file ignored {filename}")
@@ -202,7 +226,7 @@ class CrashReportsManager:
                 pass
 
             if self._check_timeout(end_time):
-                raise SysdiagnoseTimeoutError('Timeout finding in-progress sysdiagnose filename')
+                raise SysdiagnoseTimeoutError("Timeout finding in-progress sysdiagnose filename")
 
     def _check_timeout(self, end_time: Optional[float] = None) -> bool:
         return end_time is not None and time.monotonic() > end_time
@@ -212,16 +236,16 @@ class CrashReportsShell(AfcShell):
     @classmethod
     def create(cls, service_provider: LockdownServiceProvider, **kwargs):
         manager = CrashReportsManager(service_provider)
-        XSH.ctx['_manager'] = manager
+        XSH.ctx["_manager"] = manager
         super(CrashReportsShell, CrashReportsShell).create(service_provider, service=manager.afc)
 
     def _setup_shell_commands(self):
         super()._setup_shell_commands()
-        self._register_arg_parse_alias('parse', self._do_parse)
-        self._register_arg_parse_alias('clear', self._do_clear)
+        self._register_arg_parse_alias("parse", self._do_parse)
+        self._register_arg_parse_alias("clear", self._do_clear)
 
     def _do_parse(self, filename: Annotated[str, Arg(completer=path_completer)]) -> None:
         print(get_crash_report_from_buf(self.afc.get_file_contents(filename).decode(), filename=filename))
 
     def _do_clear(self) -> None:
-        XSH.ctx['_manager'].clear()
+        XSH.ctx["_manager"].clear()

pymobiledevice3/services/debugserver_applist.py

@@ -7,14 +7,14 @@ CHUNK_SIZE = 200
 
 
 class DebugServerAppList(LockdownService):
-    SERVICE_NAME = 'com.apple.debugserver.DVTSecureSocketProxy.applist'
+    SERVICE_NAME = "com.apple.debugserver.DVTSecureSocketProxy.applist"
 
     def __init__(self, lockdown: LockdownClient):
         super().__init__(lockdown, self.SERVICE_NAME)
 
     def get(self) -> dict:
-        buf = b''
-        while b'</plist>' not in buf:
+        buf = b""
+        while b"</plist>" not in buf:
             buf += self.service.recv(CHUNK_SIZE)
 
         return plistlib.loads(buf)

pymobiledevice3/services/device_arbitration.py

@@ -4,25 +4,25 @@ from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class DtDeviceArbitration(LockdownService):
-    SERVICE_NAME = 'com.apple.dt.devicearbitration'
+    SERVICE_NAME = "com.apple.dt.devicearbitration"
 
     def __init__(self, lockdown: LockdownClient):
         super().__init__(lockdown, self.SERVICE_NAME, is_developer_service=True)
 
     @property
     def version(self) -> dict:
-        return self.service.send_recv_plist({'command': 'version'})
+        return self.service.send_recv_plist({"command": "version"})
 
     def check_in(self, hostname: str, force: bool = False):
-        request = {'command': 'check-in', 'hostname': hostname}
+        request = {"command": "check-in", "hostname": hostname}
         if force:
-            request['command'] = 'force-check-in'
+            request["command"] = "force-check-in"
         response = self.service.send_recv_plist(request)
-        if response.get('result') != 'success':
+        if response.get("result") != "success":
             raise DeviceAlreadyInUseError(response)
 
     def check_out(self):
-        request = {'command': 'check-out'}
+        request = {"command": "check-out"}
         response = self.service.send_recv_plist(request)
-        if response.get('result') != 'success':
-            raise ArbitrationError(f'failed with: {response}')
+        if response.get("result") != "success":
+            raise ArbitrationError(f"failed with: {response}")