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

pymobiledevice3/services/device_link.py

@@ -3,9 +3,12 @@ import datetime
 import shutil
 import struct
 import warnings
+from collections.abc import Iterable, Mapping, Sequence
 from pathlib import Path
+from typing import Any, Callable, Optional, cast
 
 from pymobiledevice3.exceptions import NotEnoughDiskSpaceError, PyMobileDevice3Exception
+from pymobiledevice3.service_connection import ServiceConnection
 
 SIZE_FORMAT = ">I"
 CODE_FORMAT = ">B"
@@ -26,12 +29,16 @@ ERRNO_TO_DEVICE_ERROR = {
     28: -15,
 }
 
+DLMessage = Sequence[Any]
+ProgressCallback = Callable[[Any], None]
+DLHandler = Callable[[DLMessage], None]
+
 
 class DeviceLink:
-    def __init__(self, service, root_path: Path):
-        self.service = service
-        self.root_path = root_path
-        self._dl_handlers = {
+    def __init__(self, service: ServiceConnection, root_path: Path) -> None:
+        self.service: ServiceConnection = service
+        self.root_path: Path = root_path
+        self._dl_handlers: dict[str, DLHandler] = {
             "DLMessageCreateDirectory": self.create_directory,
             "DLMessageUploadFiles": self.upload_files,
             "DLMessageGetFreeDiskSpace": self.get_free_disk_space,
@@ -43,7 +50,12 @@ class DeviceLink:
             "DLMessagePurgeDiskSpace": self.purge_disk_space,
         }
 
-    def dl_loop(self, progress_callback=lambda x: None):
+    def dl_loop(self, progress_callback: Optional[ProgressCallback] = None) -> Any:
+        def _noop(_: Any) -> None:
+            return None
+
+        callback: ProgressCallback = progress_callback if progress_callback is not None else _noop
+
         while True:
             message = self.receive_message()
             command = message[0]
@@ -55,9 +67,9 @@ class DeviceLink:
                 "DLMessageRemoveFiles",
                 "DLMessageRemoveItems",
             ):
-                progress_callback(message[3])
+                callback(message[3])
             elif command == "DLMessageUploadFiles":
-                progress_callback(message[2])
+                callback(message[2])
 
             if command == "DLMessageProcessMessage":
                 if not message[1]["ErrorCode"]:
@@ -66,7 +78,7 @@ class DeviceLink:
                     raise PyMobileDevice3Exception(f"Device link error: {message[1]}")
             self._dl_handlers[command](message)
 
-    def version_exchange(self):
+    def version_exchange(self) -> None:
         dl_message_version_exchange = self.receive_message()
         version_major = dl_message_version_exchange[1]
         self.service.send_plist(["DLMessageVersionExchange", "DLVersionsOk", version_major])
@@ -74,12 +86,13 @@ class DeviceLink:
         if dl_message_device_ready[0] != "DLMessageDeviceReady":
             raise PyMobileDevice3Exception("Device link didn't return ready state")
 
-    def send_process_message(self, message):
+    def send_process_message(self, message: Mapping[str, Any]) -> None:
         self.service.send_plist(["DLMessageProcessMessage", message])
 
-    def download_files(self, message):
-        status = {}
-        for file in message[1]:
+    def download_files(self, message: DLMessage) -> None:
+        status: dict[str, dict[str, Any]] = {}
+        files = cast(Iterable[str], message[1])
+        for file in files:
             self.service.sendall(struct.pack(SIZE_FORMAT, len(file)))
             self.service.sendall(file.encode())
 
@@ -114,9 +127,9 @@ class DeviceLink:
         else:
             self.status_response(0)
 
-    def contents_of_directory(self, message):
+    def contents_of_directory(self, message: DLMessage) -> None:
         data = {}
-        path = self.root_path / message[1]
+        path = self.root_path / cast(str, message[1])
         for file in path.iterdir():
             ftype = "DLFileTypeUnknown"
             if file.is_dir():
@@ -132,7 +145,7 @@ class DeviceLink:
             }
         self.status_response(0, status_dict=data)
 
-    def upload_files(self, message):
+    def upload_files(self, _message: DLMessage) -> None:
         while True:
             device_name = self._prefixed_recv()
             if not device_name:
@@ -158,20 +171,21 @@ class DeviceLink:
             assert code == CODE_SUCCESS
         self.status_response(0)
 
-    def get_free_disk_space(self, message):
+    def get_free_disk_space(self, _message: DLMessage) -> None:
         freespace = shutil.disk_usage(self.root_path).free
         self.status_response(0, status_dict=freespace)
 
-    def move_items(self, message):
-        for src, dst in message[1].items():
+    def move_items(self, message: DLMessage) -> None:
+        items = cast(Mapping[str, str], message[1])
+        for src, dst in items.items():
             dest = self.root_path / dst
             dest.parent.mkdir(parents=True, exist_ok=True)
             shutil.move(self.root_path / src, dest)
         self.status_response(0)
 
-    def copy_item(self, message):
-        src = self.root_path / message[1]
-        dest = self.root_path / message[2]
+    def copy_item(self, message: DLMessage) -> None:
+        src = self.root_path / cast(str, message[1])
+        dest = self.root_path / cast(str, message[2])
         dest.parent.mkdir(parents=True, exist_ok=True)
         if src.is_dir():
             shutil.copytree(src, dest)
@@ -179,11 +193,11 @@ class DeviceLink:
             shutil.copy(src, dest)
         self.status_response(0)
 
-    def purge_disk_space(self, message) -> None:
+    def purge_disk_space(self, _message: DLMessage) -> None:
         raise NotEnoughDiskSpaceError()
 
-    def remove_items(self, message):
-        for path in message[1]:
+    def remove_items(self, message: DLMessage) -> None:
+        for path in cast(Iterable[str], message[1]):
             rm_path = self.root_path / path
             if rm_path.is_dir():
                 shutil.rmtree(rm_path)
@@ -191,12 +205,12 @@ class DeviceLink:
                 rm_path.unlink(missing_ok=True)
         self.status_response(0)
 
-    def create_directory(self, message):
-        path = message[1]
+    def create_directory(self, message: DLMessage) -> None:
+        path = cast(str, message[1])
         (self.root_path / path).mkdir(parents=True, exist_ok=True)
         self.status_response(0)
 
-    def status_response(self, status_code, status_str="", status_dict=None):
+    def status_response(self, status_code: int, status_str: str = "", status_dict: Any = None) -> None:
         self.service.send_plist([
             "DLMessageStatusResponse",
             ctypes.c_uint64(status_code).value,
@@ -204,12 +218,12 @@ class DeviceLink:
             status_dict if status_dict is not None else {},
         ])
 
-    def receive_message(self):
-        return self.service.recv_plist()
+    def receive_message(self) -> DLMessage:
+        return cast(DLMessage, self.service.recv_plist())
 
-    def disconnect(self):
+    def disconnect(self) -> None:
         self.service.send_plist(["DLMessageDisconnect", "___EmptyParameterString___"])
 
-    def _prefixed_recv(self):
+    def _prefixed_recv(self) -> str:
         (size,) = struct.unpack(SIZE_FORMAT, self.service.recvall(struct.calcsize(SIZE_FORMAT)))
         return self.service.recvall(size).decode()

pymobiledevice3/services/idam.py

@@ -0,0 +1,20 @@
+from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
+from pymobiledevice3.services.lockdown_service import LockdownService
+
+
+class IDAMService(LockdownService):
+    RSD_SERVICE_NAME = "com.apple.idamd.shim.remote"
+    SERVICE_NAME = "com.apple.idamd"
+
+    def __init__(self, lockdown: LockdownServiceProvider) -> None:
+        if isinstance(lockdown, LockdownClient):
+            super().__init__(lockdown, self.SERVICE_NAME)
+        else:
+            super().__init__(lockdown, self.RSD_SERVICE_NAME)
+
+    def configuration_inquiry(self) -> dict:
+        return self.service.send_recv_plist({"Configuration Inquiry": True})
+
+    def set_idam_configuration(self, value: bool) -> None:
+        self.service.send_recv_plist({"Set IDAM Configuration": value})

pymobiledevice3/services/lockdown_service.py

@@ -1,4 +1,7 @@
 import logging
+from typing import Optional
+
+from typing_extensions import Self
 
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.service_connection import ServiceConnection
@@ -9,10 +12,10 @@ class LockdownService:
         self,
         lockdown: LockdownServiceProvider,
         service_name: str,
-        is_developer_service=False,
-        service: ServiceConnection = None,
+        is_developer_service: bool = False,
+        service: Optional[ServiceConnection] = None,
         include_escrow_bag: bool = False,
-    ):
+    ) -> None:
         """
         :param lockdown: server provider
         :param service_name: wrapped service name - will attempt
@@ -26,15 +29,15 @@ class LockdownService:
             )
             service = start_service(service_name, include_escrow_bag=include_escrow_bag)
 
-        self.service_name = service_name
-        self.lockdown = lockdown
-        self.service = service
-        self.logger = logging.getLogger(self.__module__)
+        self.service_name: str = service_name
+        self.lockdown: LockdownServiceProvider = lockdown
+        self.service: ServiceConnection = service
+        self.logger: logging.Logger = logging.getLogger(self.__module__)
 
-    def __enter__(self):
+    def __enter__(self) -> Self:
         return self
 
-    async def __aenter__(self) -> "LockdownService":
+    async def __aenter__(self) -> Self:
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

pymobiledevice3/services/mobile_config.py

@@ -279,6 +279,7 @@ class MobileConfigService(LockdownService):
                 "OSShowcase",
                 "SafetyAndHandling",
                 "Tips",
+                "AgeBasedSafetySettings",
             ],
             "SupervisorHostCertificates": [public_key],
         })

pymobiledevice3/services/mobilebackup2.py

@@ -5,6 +5,7 @@ import uuid
 from contextlib import contextmanager, suppress
 from datetime import datetime
 from pathlib import Path
+from typing import Union
 
 from pymobiledevice3.exceptions import (
     AfcException,
@@ -16,7 +17,7 @@ from pymobiledevice3.exceptions import (
 )
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
-from pymobiledevice3.services.afc import AFC_LOCK_EX, AFC_LOCK_UN, AfcService, afc_error_t
+from pymobiledevice3.services.afc import AFC_LOCK_EX, AFC_LOCK_UN, AfcError, AfcService
 from pymobiledevice3.services.device_link import DeviceLink
 from pymobiledevice3.services.installation_proxy import InstallationProxyService
 from pymobiledevice3.services.lockdown_service import LockdownService
@@ -60,7 +61,9 @@ class Mobilebackup2Service(LockdownService):
         except LockdownError:
             return False
 
-    def backup(self, full: bool = True, backup_directory: str = ".", progress_callback=lambda x: None) -> None:
+    def backup(
+        self, full: bool = True, backup_directory: Union[str, Path] = ".", progress_callback=lambda x: None
+    ) -> None:
         """
         Backup a device.
         :param full: Whether to do a full backup. If full is True, any previous backup attempts will be discarded.
@@ -386,7 +389,7 @@ class Mobilebackup2Service(LockdownService):
                 try:
                     afc.lock(lockfile, AFC_LOCK_EX)
                 except AfcException as e:
-                    if e.status == afc_error_t.OP_WOULD_BLOCK:
+                    if e.status == AfcError.OP_WOULD_BLOCK:
                         time.sleep(0.2)
                     else:
                         afc.fclose(lockfile)

pymobiledevice3/services/os_trace.py

@@ -9,8 +9,6 @@ from enum import IntEnum
 from pathlib import Path
 from tarfile import TarFile
 
-from construct import Adapter, Byte, Bytes, Computed, Enum, Int16ul, Int32ul, Optional, RepeatUntil, Struct, this
-
 from pymobiledevice3.exceptions import PyMobileDevice3Exception
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
@@ -45,51 +43,107 @@ class SyslogEntry:
     timestamp: datetime
     level: SyslogLogLevel
     image_name: str
+    image_offset: int
     filename: str
     message: str
     label: typing.Optional[SyslogLabel] = None
 
 
-class TimestampAdapter(Adapter):
-    def _decode(self, obj, context, path):
-        return datetime.fromtimestamp(obj.seconds + (obj.microseconds / 1000000))
-
-    def _encode(self, obj, context, path):
-        return list(map(int, obj.split(".")))
-
-
-timestamp_t = Struct("seconds" / Int32ul, Bytes(4), "microseconds" / Int32ul)
-
-syslog_t = Struct(
-    Bytes(9),
-    "pid" / Int32ul,
-    Bytes(42),
-    "timestamp" / TimestampAdapter(timestamp_t),
-    Bytes(1),
-    "level" / Enum(Byte, Notice=0, Info=0x01, Debug=0x02, Error=0x10, Fault=0x11),
-    Bytes(38),
-    "image_name_size" / Int16ul,
-    "message_size" / Int16ul,
-    Bytes(6),
-    "_subsystem_size" / Int32ul,
-    "_category_size" / Int32ul,
-    Bytes(4),
-    "_filename" / RepeatUntil(lambda x, lst, ctx: lst[-1] == 0, Byte),
-    "filename" / Computed(lambda ctx: try_decode(bytearray(ctx._filename[:-1]))),
-    "_image_name" / Bytes(this.image_name_size),
-    "image_name" / Computed(lambda ctx: try_decode(ctx._image_name[:-1])),
-    "_message" / Bytes(this.message_size),
-    "message" / Computed(lambda ctx: try_decode(ctx._message[:-1])),
-    "label"
-    / Optional(
-        Struct(
-            "_subsystem" / Bytes(this._._subsystem_size),
-            "subsystem" / Computed(lambda ctx: try_decode(ctx._subsystem[:-1])),
-            "_category" / Bytes(this._._category_size),
-            "category" / Computed(lambda ctx: try_decode(ctx._category[:-1])),
-        )
-    ),
-)
+def parse_syslog_entry(data: bytes) -> SyslogEntry:
+    """
+    Parse a syslog entry from binary data.
+
+    :param data: Raw binary data
+    :return: SyslogEntry
+    """
+    offset = 0
+
+    # Skip first 9 bytes
+    offset += 9
+
+    # Parse pid (4 bytes, little-endian unsigned int)
+    pid = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+
+    # Skip 42 bytes
+    offset += 42
+
+    # Parse timestamp
+    seconds = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    offset += 4  # Skip 4 bytes
+    microseconds = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+    timestamp = datetime.fromtimestamp(seconds + (microseconds / 1000000))
+
+    # Skip 1 byte
+    offset += 1
+
+    # Parse level (1 byte)
+    level = data[offset]
+    offset += 1
+
+    # Skip 38 bytes
+    offset += 38
+
+    # Parse image_name_size (2 bytes, little-endian unsigned short)
+    image_name_size = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+
+    # Parse message_size (2 bytes, little-endian unsigned short)
+    message_size = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+
+    # Skip 2 bytes
+    offset += 2
+
+    # Parse sender_image_offset (4 bytes, little-endian unsigned int)
+    sender_image_offset = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+
+    # Parse subsystem_size (4 bytes, little-endian unsigned int)
+    subsystem_size = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+
+    # Parse category_size (4 bytes, little-endian unsigned int)
+    category_size = struct.unpack("<I", data[offset : offset + 4])[0]
+    offset += 4
+
+    # Skip 4 bytes
+    offset += 4
+
+    # Parse filename (null-terminated)
+    filename_end = data.find(b"\x00", offset)
+    filename = try_decode(data[offset:filename_end])
+    offset = filename_end + 1
+
+    # Parse image_name
+    image_name = try_decode(data[offset : offset + image_name_size - 1])
+    offset += image_name_size
+
+    # Parse message
+    message = try_decode(data[offset : offset + message_size - 1])
+    offset += message_size
+
+    # Parse label (optional)
+    label = None
+    if subsystem_size > 0 and category_size > 0:
+        subsystem = try_decode(data[offset : offset + subsystem_size - 1])
+        offset += subsystem_size
+        category = try_decode(data[offset : offset + category_size - 1])
+        offset += category_size
+        label = SyslogLabel(subsystem=subsystem, category=category)
+
+    return SyslogEntry(
+        pid=pid,
+        timestamp=timestamp,
+        level=SyslogLogLevel(level),
+        image_name=image_name,
+        image_offset=sender_image_offset,
+        filename=filename,
+        message=message,
+        label=label,
+    )
 
 
 class OsTraceService(LockdownService):
@@ -185,16 +239,4 @@ class OsTraceService(LockdownService):
             assert self.service.recvall(1) == b"\x02"
             (length,) = struct.unpack("<I", self.service.recvall(4))
             line = self.service.recvall(length)
-            entry = syslog_t.parse(line)
-            label = None
-            if entry.label is not None:
-                label = SyslogLabel(subsystem=entry.label.subsystem, category=entry.label.category)
-            yield SyslogEntry(
-                pid=entry.pid,
-                timestamp=entry.timestamp,
-                level=SyslogLogLevel(int(entry.level)),
-                image_name=entry.image_name,
-                filename=entry.filename,
-                message=entry.message,
-                label=label,
-            )
+            yield parse_syslog_entry(line)

pymobiledevice3/services/remote_fetch_symbols.py

@@ -38,11 +38,16 @@ class RemoteFetchSymbolsService(RemoteService):
 
     async def download(self, out: Path) -> None:
         files = await self.get_dsc_file_list()
-        for i, file in enumerate(files):
-            self.logger.info(f"Downloading {file}")
-            out_file = out / file.file_path[1:]  # trim the "/" prefix
-            out_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(out_file, "wb") as f, tqdm(total=files[i].file_size, dynamic_ncols=True) as pb:
-                async for chunk in self.service.iter_file_chunks(files[i].file_size, file_idx=i):
-                    f.write(chunk)
-                    pb.update(len(chunk))
+        with tqdm(total=len(files), dynamic_ncols=True, desc="Downloading DSC") as total_pb:
+            for i, file in enumerate(files):
+                total_pb.set_description("Downloading DSC")
+                out_file = out / file.file_path[1:]  # trim the "/" prefix
+                out_file.parent.mkdir(parents=True, exist_ok=True)
+                with (
+                    open(out_file, "wb") as f,
+                    tqdm(total=files[i].file_size, dynamic_ncols=True, desc=file.file_path.rsplit("/", 1)[-1]) as pb,
+                ):
+                    async for chunk in self.service.iter_file_chunks(files[i].file_size, file_idx=i):
+                        f.write(chunk)
+                        pb.update(len(chunk))
+                total_pb.update(1)

pymobiledevice3/services/screenshot.py

@@ -1,12 +1,12 @@
 from pymobiledevice3.exceptions import PyMobileDevice3Exception
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class ScreenshotService(LockdownService):
     SERVICE_NAME = "com.apple.mobile.screenshotr"
 
-    def __init__(self, lockdown: LockdownClient):
+    def __init__(self, lockdown: LockdownServiceProvider) -> None:
         super().__init__(lockdown, self.SERVICE_NAME, is_developer_service=True)
 
         dl_message_version_exchange = self.service.recv_plist()

pymobiledevice3/services/web_protocol/alert.py

@@ -5,22 +5,22 @@ class Alert:
         """
         self.session = session
 
-    def accept(self):
+    async def accept(self):
         """Accepts the alert available."""
-        self.session.accept_current_javascript_dialog()
+        await self.session.accept_current_javascript_dialog()
 
-    def dismiss(self):
+    async def dismiss(self):
         """Dismisses the alert available."""
-        self.session.dismiss_current_javascript_dialog()
+        await self.session.dismiss_current_javascript_dialog()
 
-    def send_keys(self, text: str):
+    async def send_keys(self, text: str):
         """
         Send Keys to the Alert.
         :param text: Text to send to prompts.
         """
-        self.session.set_user_input_for_current_javascript_prompt(text)
+        await self.session.set_user_input_for_current_javascript_prompt(text)
 
     @property
-    def text(self) -> str:
+    async def text(self) -> str:
         """Gets the text of the Alert."""
-        return self.session.message_of_current_javascript_dialog()
+        return await self.session.message_of_current_javascript_dialog()