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

pymobiledevice3/remote/core_device/core_device_service.py

@@ -7,13 +7,15 @@ from pymobiledevice3.remote.xpc_message import XpcInt64Type, XpcUInt64Type
 
 
 def _generate_core_device_version_dict(version: str) -> dict:
-    version_components = version.split('.')
-    return {'components': [XpcUInt64Type(component) for component in version_components],
-            'originalComponentsCount': XpcInt64Type(len(version_components)),
-            'stringValue': version}
+    version_components = version.split(".")
+    return {
+        "components": [XpcUInt64Type(component) for component in version_components],
+        "originalComponentsCount": XpcInt64Type(len(version_components)),
+        "stringValue": version,
+    }
 
 
-CORE_DEVICE_VERSION = _generate_core_device_version_dict('325.3')
+CORE_DEVICE_VERSION = _generate_core_device_version_dict("325.3")
 
 
 class CoreDeviceService(RemoteService):
@@ -21,14 +23,15 @@ class CoreDeviceService(RemoteService):
         if input_ is None:
             input_ = {}
         response = await self.service.send_receive_request({
-            'CoreDevice.CoreDeviceDDIProtocolVersion': XpcInt64Type(0),
-            'CoreDevice.action': {},
-            'CoreDevice.coreDeviceVersion': CORE_DEVICE_VERSION,
-            'CoreDevice.deviceIdentifier': str(uuid.uuid4()),
-            'CoreDevice.featureIdentifier': feature_identifier,
-            'CoreDevice.input': input_,
-            'CoreDevice.invocationIdentifier': str(uuid.uuid4())})
-        output = response.get('CoreDevice.output')
+            "CoreDevice.CoreDeviceDDIProtocolVersion": XpcInt64Type(0),
+            "CoreDevice.action": {},
+            "CoreDevice.coreDeviceVersion": CORE_DEVICE_VERSION,
+            "CoreDevice.deviceIdentifier": str(uuid.uuid4()),
+            "CoreDevice.featureIdentifier": feature_identifier,
+            "CoreDevice.input": input_,
+            "CoreDevice.invocationIdentifier": str(uuid.uuid4()),
+        })
+        output = response.get("CoreDevice.output")
         if output is None:
-            raise CoreDeviceError(f'Failed to invoke: {feature_identifier}. Got error: {response}')
+            raise CoreDeviceError(f"Failed to invoke: {feature_identifier}. Got error: {response}")
         return output

pymobiledevice3/remote/core_device/device_info.py

@@ -7,7 +7,7 @@ class DeviceInfoService(CoreDeviceService):
     Query device information
     """
 
-    SERVICE_NAME = 'com.apple.coredevice.deviceinfo'
+    SERVICE_NAME = "com.apple.coredevice.deviceinfo"
 
     def __init__(self, rsd: RemoteServiceDiscoveryService):
         super().__init__(rsd, self.SERVICE_NAME)
@@ -16,13 +16,13 @@ class DeviceInfoService(CoreDeviceService):
         """
         Get device information
         """
-        return await self.invoke('com.apple.coredevice.feature.getdeviceinfo', {})
+        return await self.invoke("com.apple.coredevice.feature.getdeviceinfo", {})
 
     async def get_display_info(self) -> dict:
         """
         Get display information
         """
-        return await self.invoke('com.apple.coredevice.feature.getdisplayinfo', {})
+        return await self.invoke("com.apple.coredevice.feature.getdisplayinfo", {})
 
     async def query_mobilegestalt(self, keys: list[str]) -> dict:
         """
@@ -30,10 +30,10 @@ class DeviceInfoService(CoreDeviceService):
 
         Can only be performed to specific devices
         """
-        return await self.invoke('com.apple.coredevice.feature.querymobilegestalt', {'keys': keys})
+        return await self.invoke("com.apple.coredevice.feature.querymobilegestalt", {"keys": keys})
 
     async def get_lockstate(self) -> dict:
         """
         Get lockstate
         """
-        return await self.invoke('com.apple.coredevice.feature.getlockstate', {})
+        return await self.invoke("com.apple.coredevice.feature.getlockstate", {})

pymobiledevice3/remote/core_device/diagnostics_service.py

@@ -1,19 +1,34 @@
+import dataclasses
 from collections.abc import AsyncGenerator
 
 from pymobiledevice3.remote.core_device.core_device_service import CoreDeviceService
 from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
 
 
+@dataclasses.dataclass
+class SysDiagnoseResponse:
+    preferred_filename: str
+    file_size: int
+    generator: AsyncGenerator[bytes, None]
+
+
 class DiagnosticsServiceService(CoreDeviceService):
     """
     Obtain device diagnostics
     """
 
-    SERVICE_NAME = 'com.apple.coredevice.diagnosticsservice'
+    SERVICE_NAME = "com.apple.coredevice.diagnosticsservice"
 
     def __init__(self, rsd: RemoteServiceDiscoveryService):
         super().__init__(rsd, self.SERVICE_NAME)
 
-    async def capture_sysdiagnose(self, is_dry_run: bool) -> AsyncGenerator[bytes, None]:
-        response = await self.invoke('com.apple.coredevice.feature.capturesysdiagnose', {'isDryRun': is_dry_run})
-        return self.service.iter_file_chunks(response['fileTransfer']['expectedLength'])
+    async def capture_sysdiagnose(self, is_dry_run: bool) -> SysDiagnoseResponse:
+        response = await self.invoke(
+            "com.apple.coredevice.feature.capturesysdiagnose",
+            {"options": {"collectFullLogs": True}, "isDryRun": is_dry_run},
+        )
+        return SysDiagnoseResponse(
+            file_size=response["fileTransfer"]["expectedLength"],
+            preferred_filename=response["preferredFilename"],
+            generator=self.service.iter_file_chunks(response["fileTransfer"]["expectedLength"]),
+        )

pymobiledevice3/remote/core_device/file_service.py

@@ -1,5 +1,6 @@
 import asyncio
 import struct
+import time
 import uuid
 from collections.abc import AsyncGenerator
 from enum import IntEnum
@@ -8,7 +9,7 @@ from typing import Optional
 from pymobiledevice3.exceptions import CoreDeviceError
 from pymobiledevice3.remote.core_device.core_device_service import CoreDeviceService
 from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
-from pymobiledevice3.remote.xpc_message import XpcUInt64Type
+from pymobiledevice3.remote.xpc_message import XpcInt64Type, XpcUInt64Type
 
 
 class Domain(IntEnum):
@@ -19,10 +20,10 @@ class Domain(IntEnum):
 
 
 APPLE_DOMAIN_DICT = {
-    'appDataContainer': Domain.APP_DATA_CONTAINER,
-    'appGroupDataContainer': Domain.APP_GROUP_DATA_CONTAINER,
-    'temporary': Domain.TEMPORARY,
-    'systemCrashLogs': Domain.SYSTEM_CRASH_LOGS
+    "appDataContainer": Domain.APP_DATA_CONTAINER,
+    "appGroupDataContainer": Domain.APP_GROUP_DATA_CONTAINER,
+    "temporary": Domain.TEMPORARY,
+    "systemCrashLogs": Domain.SYSTEM_CRASH_LOGS,
 }
 
 
@@ -31,41 +32,70 @@ class FileServiceService(CoreDeviceService):
     Filesystem control
     """
 
-    CTRL_SERVICE_NAME = 'com.apple.coredevice.fileservice.control'
+    CTRL_SERVICE_NAME = "com.apple.coredevice.fileservice.control"
 
-    def __init__(self, rsd: RemoteServiceDiscoveryService, domain: Domain) -> None:
+    def __init__(self, rsd: RemoteServiceDiscoveryService, domain: Domain, identifier: str = "") -> None:
         super().__init__(rsd, self.CTRL_SERVICE_NAME)
         self.domain: Domain = domain
         self.session: Optional[str] = None
+        self.identifier = identifier
 
     async def connect(self) -> None:
         await super().connect()
         response = await self.send_receive_request({
-            'Cmd': 'CreateSession', 'Domain': XpcUInt64Type(self.domain), 'Identifier': '', 'Session': '',
-            'User': 'mobile'})
-        self.session = response['NewSessionID']
+            "Cmd": "CreateSession",
+            "Domain": XpcUInt64Type(self.domain),
+            "Identifier": self.identifier,
+            "Session": "",
+            "User": "mobile",
+        })
+        self.session = response["NewSessionID"]
 
-    async def retrieve_directory_list(self, path: str = '.') -> AsyncGenerator[list[str], None]:
-        return (await self.send_receive_request({
-            'Cmd': 'RetrieveDirectoryList', 'MessageUUID': str(uuid.uuid4()), 'Path': path, 'SessionID': self.session}
-        ))['FileList']
+    async def retrieve_directory_list(self, path: str = ".") -> AsyncGenerator[list[str], None]:
+        return (
+            await self.send_receive_request({
+                "Cmd": "RetrieveDirectoryList",
+                "MessageUUID": str(uuid.uuid4()),
+                "Path": path,
+                "SessionID": self.session,
+            })
+        )["FileList"]
 
-    async def retrieve_file(self, path: str = '.') -> bytes:
-        response = await self.send_receive_request({
-            'Cmd': 'RetrieveFile', 'Path': path, 'SessionID': self.session}
-        )
-        data_service = self.rsd.get_service_port('com.apple.coredevice.fileservice.data')
+    async def retrieve_file(self, path: str = ".") -> bytes:
+        response = await self.send_receive_request({"Cmd": "RetrieveFile", "Path": path, "SessionID": self.session})
+        data_service = self.rsd.get_service_port("com.apple.coredevice.fileservice.data")
         reader, writer = await asyncio.open_connection(self.service.address[0], data_service)
-        writer.write(b'rwb!FILE' + struct.pack('>QQQQ', response['Response'], 0, response['NewFileID'], 0))
+        writer.write(b"rwb!FILE" + struct.pack(">QQQQ", response["Response"], 0, response["NewFileID"], 0))
         await writer.drain()
         await reader.readexactly(0x24)
-        return await reader.readexactly(struct.unpack('>I', await reader.readexactly(4))[0])
+        return await reader.readexactly(struct.unpack(">I", await reader.readexactly(4))[0])
+
+    async def propose_empty_file(
+        self,
+        path: str = ".",
+        file_permissions: int = 0o644,
+        uid: int = 501,
+        gid: int = 501,
+        creation_time: int = time.time(),
+        last_modification_time: int = time.time(),
+    ) -> None:
+        """Request to write an empty file at given path."""
+        await self.send_receive_request({
+            "Cmd": "ProposeEmptyFile",
+            "FileCreationTime": XpcInt64Type(creation_time),
+            "FileLastModificationTime": XpcInt64Type(last_modification_time),
+            "FilePermissions": XpcInt64Type(file_permissions),
+            "FileOwnerUserID": XpcInt64Type(uid),
+            "FileOwnerGroupID": XpcInt64Type(gid),
+            "Path": path,
+            "SessionID": self.session,
+        })
 
     async def send_receive_request(self, request: dict) -> dict:
         response = await self.service.send_receive_request(request)
-        encoded_error = response.get('EncodedError')
+        encoded_error = response.get("EncodedError")
         if encoded_error is not None:
-            localized_description = response.get('LocalizedDescription')
+            localized_description = response.get("LocalizedDescription")
             if localized_description is not None:
                 raise CoreDeviceError(localized_description)
             raise CoreDeviceError(encoded_error)

pymobiledevice3/remote/remote_service_discovery.py

@@ -2,12 +2,16 @@ import base64
 import logging
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remoted
 from pymobiledevice3.common import get_home_folder
-from pymobiledevice3.exceptions import InvalidServiceError, NoDeviceConnectedError, PyMobileDevice3Exception, \
-    StartServiceError
+from pymobiledevice3.exceptions import (
+    InvalidServiceError,
+    NoDeviceConnectedError,
+    PyMobileDevice3Exception,
+    StartServiceError,
+)
 from pymobiledevice3.lockdown import LockdownClient, create_using_remote
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.pair_records import get_local_pairing_record, get_remote_pairing_record_filename
@@ -38,11 +42,15 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
     @property
     def product_version(self) -> str:
-        return self.peer_info['Properties']['OSVersion']
+        return self.peer_info["Properties"]["OSVersion"]
+
+    @property
+    def product_build_version(self) -> str:
+        return self.peer_info["Properties"]["BuildVersion"]
 
     @property
     def ecid(self) -> int:
-        return self.peer_info['Properties']['UniqueChipID']
+        return self.peer_info["Properties"]["UniqueChipID"]
 
     @property
     def developer_mode_status(self) -> bool:
@@ -57,17 +65,24 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
     async def connect(self) -> None:
         await self.service.connect()
-        self.peer_info = await self.service.receive_response()
-        self.udid = self.peer_info['Properties']['UniqueDeviceID']
-        self.product_type = self.peer_info['Properties']['ProductType']
         try:
-            self.lockdown = create_using_remote(self.start_lockdown_service('com.apple.mobile.lockdown.remote.trusted'))
-        except InvalidServiceError:
-            self.lockdown = create_using_remote(
-                self.start_lockdown_service('com.apple.mobile.lockdown.remote.untrusted'))
-        self.all_values = self.lockdown.all_values
+            self.peer_info = await self.service.receive_response()
+            self.udid = self.peer_info["Properties"]["UniqueDeviceID"]
+            self.product_type = self.peer_info["Properties"]["ProductType"]
+            try:
+                self.lockdown = create_using_remote(
+                    self.start_lockdown_service("com.apple.mobile.lockdown.remote.trusted")
+                )
+            except InvalidServiceError:
+                self.lockdown = create_using_remote(
+                    self.start_lockdown_service("com.apple.mobile.lockdown.remote.untrusted")
+                )
+            self.all_values = self.lockdown.all_values
+        except Exception:
+            await self.close()
+            raise
 
-    def get_value(self, domain: str = None, key: str = None):
+    def get_value(self, domain: Optional[str] = None, key: Optional[str] = None) -> Any:
         return self.lockdown.get_value(domain, key)
 
     def start_lockdown_service_without_checkin(self, name: str) -> ServiceConnection:
@@ -75,20 +90,30 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
     def start_lockdown_service(self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
         service = self.start_lockdown_service_without_checkin(name)
-        checkin = {'Label': 'pymobiledevice3', 'ProtocolVersion': '2', 'Request': 'RSDCheckin'}
-        if include_escrow_bag:
-            pairing_record = get_local_pairing_record(get_remote_pairing_record_filename(self.udid), get_home_folder())
-            checkin['EscrowBag'] = base64.b64decode(pairing_record['remote_unlock_host_key'])
-        response = service.send_recv_plist(checkin)
-        if response['Request'] != 'RSDCheckin':
-            raise PyMobileDevice3Exception(f'Invalid response for RSDCheckIn: {response}. Expected "RSDCheckIn"')
-        response = service.recv_plist()
-        if response['Request'] != 'StartService':
-            raise PyMobileDevice3Exception(f'Invalid response for RSDCheckIn: {response}. Expected "ServiceService"')
+        try:
+            checkin = {"Label": "pymobiledevice3", "ProtocolVersion": "2", "Request": "RSDCheckin"}
+            if include_escrow_bag:
+                pairing_record = get_local_pairing_record(
+                    get_remote_pairing_record_filename(self.udid), get_home_folder()
+                )
+                checkin["EscrowBag"] = base64.b64decode(pairing_record["remote_unlock_host_key"])
+            response = service.send_recv_plist(checkin)
+            if response["Request"] != "RSDCheckin":
+                raise PyMobileDevice3Exception(f'Invalid response for RSDCheckIn: {response}. Expected "RSDCheckIn"')
+            response = service.recv_plist()
+            if response["Request"] != "StartService":
+                raise PyMobileDevice3Exception(
+                    f'Invalid response for RSDCheckIn: {response}. Expected "ServiceService"'
+                )
+            error = response.get("Error")
+            if error is not None:
+                raise StartServiceError(name, error)
+        except Exception:
+            service.close()
+            raise
         return service
 
-    async def aio_start_lockdown_service(
-            self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
+    async def aio_start_lockdown_service(self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
         service = self.start_lockdown_service(name, include_escrow_bag=include_escrow_bag)
         await service.aio_start()
         return service
@@ -97,9 +122,9 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         try:
             return self.start_lockdown_service_without_checkin(name)
         except StartServiceError:
-            logging.getLogger(self.__module__).error(
-                'Failed to connect to required service. Make sure DeveloperDiskImage.dmg has been mounted. '
-                'You can do so using: pymobiledevice3 mounter mount'
+            logging.getLogger(self.__module__).exception(
+                "Failed to connect to required service. Make sure DeveloperDiskImage.dmg has been mounted. "
+                "You can do so using: pymobiledevice3 mounter mount"
             )
             raise
 
@@ -108,24 +133,24 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         return service
 
     def start_service(self, name: str) -> Union[RemoteXPCConnection, ServiceConnection]:
-        service = self.peer_info['Services'][name]
-        service_properties = service.get('Properties', {})
-        use_remote_xpc = service_properties.get('UsesRemoteXPC', False)
+        service = self.peer_info["Services"][name]
+        service_properties = service.get("Properties", {})
+        use_remote_xpc = service_properties.get("UsesRemoteXPC", False)
         return self.start_remote_service(name) if use_remote_xpc else self.start_lockdown_service(name)
 
     def get_service_port(self, name: str) -> int:
         """takes a service name and returns the port that service is running on if the service exists"""
-        service = self.peer_info['Services'].get(name)
+        service = self.peer_info["Services"].get(name)
         if service is None:
-            raise InvalidServiceError(f'No such service: {name}')
-        return int(service['Port'])
+            raise InvalidServiceError(f"No such service: {name}")
+        return int(service["Port"])
 
     async def close(self) -> None:
         if self.lockdown is not None:
             self.lockdown.close()
         await self.service.close()
 
-    async def __aenter__(self) -> 'RemoteServiceDiscoveryService':
+    async def __aenter__(self) -> "RemoteServiceDiscoveryService":
         await self.connect()
         return self
 
@@ -133,20 +158,29 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         await self.close()
 
     def __repr__(self) -> str:
-        name_str = ''
+        name_str = ""
         if self.name:
-            name_str = f' NAME:{self.name}'
-        return (f'<{self.__class__.__name__} PRODUCT:{self.product_type} VERSION:{self.product_version} '
-                f'UDID:{self.udid}{name_str}>')
+            name_str = f" NAME:{self.name}"
+        return (
+            f"<{self.__class__.__name__} PRODUCT:{self.product_type} VERSION:{self.product_version} "
+            f"UDID:{self.udid}{name_str}>"
+        )
 
 
 async def get_remoted_devices(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[RSDDevice]:
     result = []
-    for hostname in await browse_remoted(timeout):
-        with RemoteServiceDiscoveryService((hostname, RSD_PORT)) as rsd:
-            properties = rsd.peer_info['Properties']
-            result.append(RSDDevice(hostname=hostname, udid=properties['UniqueDeviceID'],
-                                    product_type=properties['ProductType'], os_version=properties['OSVersion']))
+    for instance in await browse_remoted(timeout):
+        for address in instance.addresses:
+            with RemoteServiceDiscoveryService((address.full_ip, RSD_PORT)) as rsd:
+                properties = rsd.peer_info["Properties"]
+                result.append(
+                    RSDDevice(
+                        hostname=address.full_ip,
+                        udid=properties["UniqueDeviceID"],
+                        product_type=properties["ProductType"],
+                        os_version=properties["OSVersion"],
+                    )
+                )
     return result