pymobiledevice3 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymobiledevice3/lockdown_service_provider.py

@@ -41,21 +41,19 @@ class LockdownServiceProvider:
         pass
 
     @abstractmethod
-    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:
         pass
 
     @abstractmethod
     def get_value(self, domain: Optional[str] = None, key: Optional[str] = None) -> Any:
         pass
 
-    def start_lockdown_developer_service(
-            self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
+    def start_lockdown_developer_service(self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
         try:
             return self.start_lockdown_service(name, include_escrow_bag=include_escrow_bag)
         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

pymobiledevice3/osu/os_utils.py

@@ -13,9 +13,9 @@ DEFAULT_MAX_FAILS = 3
 
 def is_wsl() -> bool:
     try:
-        with open('/proc/version', 'r') as f:
+        with open("/proc/version", "r") as f:
             version_info = f.read()
-            return 'Microsoft' in version_info or 'WSL' in version_info
+            return "Microsoft" in version_info or "WSL" in version_info
     except FileNotFoundError:
         return False
 
@@ -25,20 +25,24 @@ class OsUtils:
     _os_name = None
 
     @classmethod
-    def create(cls) -> 'OsUtils':
+    def create(cls) -> "OsUtils":
         if cls._instance is None:
             cls._os_name = sys.platform
-            if cls._os_name == 'win32':
+            if cls._os_name == "win32":
                 from pymobiledevice3.osu.win_util import Win32
+
                 cls._instance = Win32()
-            elif cls._os_name == 'darwin':
+            elif cls._os_name == "darwin":
                 from pymobiledevice3.osu.posix_util import Darwin
+
                 cls._instance = Darwin()
-            elif cls._os_name == 'linux':
+            elif cls._os_name == "linux":
                 from pymobiledevice3.osu.posix_util import Linux, Wsl
+
                 cls._instance = Wsl() if is_wsl() else Linux()
-            elif cls._os_name == 'cygwin':
+            elif cls._os_name == "cygwin":
                 from pymobiledevice3.osu.posix_util import Cygwin
+
                 cls._instance = Cygwin()
             else:
                 raise OSNotSupportedError(cls._os_name)
@@ -71,8 +75,13 @@ class OsUtils:
     def get_ipv6_ips(self) -> list[str]:
         raise FeatureNotSupportedError(self._os_name, inspect.currentframe().f_code.co_name)
 
-    def set_keepalive(self, sock: socket.socket, after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
-                      interval_sec: int = DEFAULT_INTERVAL_SEC, max_fails: int = DEFAULT_MAX_FAILS) -> None:
+    def set_keepalive(
+        self,
+        sock: socket.socket,
+        after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
+        interval_sec: int = DEFAULT_INTERVAL_SEC,
+        max_fails: int = DEFAULT_MAX_FAILS,
+    ) -> None:
         raise FeatureNotSupportedError(self._os_name, inspect.currentframe().f_code.co_name)
 
     def parse_timestamp(self, time_stamp) -> datetime:

pymobiledevice3/osu/posix_util.py

@@ -33,13 +33,16 @@ class Posix(OsUtils):
         return 'This command requires root privileges. Consider retrying with "sudo".'
 
     def get_ipv6_ips(self) -> list[str]:
-        return [f'{adapter.ips[0].ip[0]}%{adapter.nice_name}' for adapter in get_adapters() if
-                adapter.ips[0].is_IPv6 and not adapter.nice_name.startswith('tun')]
+        return [
+            f"{adapter.ips[0].ip[0]}%{adapter.nice_name}"
+            for adapter in get_adapters()
+            if adapter.ips[0].is_IPv6 and not adapter.nice_name.startswith("tun")
+        ]
 
     def chown_to_non_sudo_if_needed(self, path: Path) -> None:
-        if os.getenv('SUDO_UID') is None:
+        if os.getenv("SUDO_UID") is None:
             return
-        os.chown(path, int(os.getenv('SUDO_UID')), int(os.getenv('SUDO_GID')))
+        os.chown(path, int(os.getenv("SUDO_UID")), int(os.getenv("SUDO_GID")))
 
     def parse_timestamp(self, time_stamp) -> datetime:
         return datetime.datetime.fromtimestamp(time_stamp)
@@ -52,14 +55,19 @@ class Posix(OsUtils):
 class Darwin(Posix):
     @property
     def pair_record_path(self) -> Path:
-        return Path('/var/db/lockdown/')
+        return Path("/var/db/lockdown/")
 
     @property
     def loopback_header(self) -> bytes:
-        return struct.pack('>I', socket.AF_INET6)
-
-    def set_keepalive(self, sock: socket.socket, after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
-                      interval_sec: int = DEFAULT_INTERVAL_SEC, max_fails: int = DEFAULT_MAX_FAILS) -> None:
+        return struct.pack(">I", socket.AF_INET6)
+
+    def set_keepalive(
+        self,
+        sock: socket.socket,
+        after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
+        interval_sec: int = DEFAULT_INTERVAL_SEC,
+        max_fails: int = DEFAULT_MAX_FAILS,
+    ) -> None:
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
         sock.setsockopt(socket.IPPROTO_TCP, _DARWIN_TCP_KEEPALIVE, after_idle_sec)
         sock.setsockopt(socket.IPPROTO_TCP, _DARWIN_TCP_KEEPINTVL, interval_sec)
@@ -69,21 +77,26 @@ class Darwin(Posix):
 class Linux(Posix):
     @property
     def pair_record_path(self) -> Path:
-        return Path('/var/lib/lockdown/')
+        return Path("/var/lib/lockdown/")
 
     @property
     def loopback_header(self) -> bytes:
-        return b'\x00\x00\x86\xdd'
-
-    def set_keepalive(self, sock: socket.socket, after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
-                      interval_sec: int = DEFAULT_INTERVAL_SEC, max_fails: int = DEFAULT_MAX_FAILS) -> None:
+        return b"\x00\x00\x86\xdd"
+
+    def set_keepalive(
+        self,
+        sock: socket.socket,
+        after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
+        interval_sec: int = DEFAULT_INTERVAL_SEC,
+        max_fails: int = DEFAULT_MAX_FAILS,
+    ) -> None:
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, after_idle_sec)
         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, interval_sec)
         sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, max_fails)
 
     def get_homedir(self) -> Path:
-        return Path('~' + os.environ.get('SUDO_USER', '')).expanduser()
+        return Path("~" + os.environ.get("SUDO_USER", "")).expanduser()
 
 
 class Cygwin(Posix):

pymobiledevice3/osu/win_util.py

@@ -13,7 +13,7 @@ from pymobiledevice3.usbmux import MuxConnection
 class Win32(OsUtils):
     @property
     def is_admin(self) -> bool:
-        """ Check if the current OS user is an Administrator or root.
+        """Check if the current OS user is an Administrator or root.
         See: https://github.com/Preston-Landers/pyuac/blob/master/pyuac/admin.py
         :return: True if the current user is an 'Administrator', otherwise False.
         """
@@ -33,7 +33,7 @@ class Win32(OsUtils):
 
     @property
     def loopback_header(self) -> bytes:
-        return b'\x00\x00\x86\xdd'
+        return b"\x00\x00\x86\xdd"
 
     @property
     def access_denied_error(self) -> str:
@@ -41,14 +41,20 @@ class Win32(OsUtils):
 
     @property
     def pair_record_path(self) -> Path:
-        return Path(os.environ.get('ALLUSERSPROFILE', ''), 'Apple', 'Lockdown')
+        return Path(os.environ.get("ALLUSERSPROFILE", ""), "Apple", "Lockdown")
 
     def get_ipv6_ips(self) -> list[str]:
-        return [f'{adapter.ips[0].ip[0]}%{adapter.ips[0].ip[2]}' for adapter in get_adapters() if
-                adapter.ips[0].is_IPv6]
+        return [
+            f"{adapter.ips[0].ip[0]}%{adapter.ips[0].ip[2]}" for adapter in get_adapters() if adapter.ips[0].is_IPv6
+        ]
 
-    def set_keepalive(self, sock: socket.socket, after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
-                      interval_sec: int = DEFAULT_INTERVAL_SEC, **kwargs) -> None:
+    def set_keepalive(
+        self,
+        sock: socket.socket,
+        after_idle_sec: int = DEFAULT_AFTER_IDLE_SEC,
+        interval_sec: int = DEFAULT_INTERVAL_SEC,
+        **kwargs,
+    ) -> None:
         sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, after_idle_sec * 1000, interval_sec * 1000))
 
     def parse_timestamp(self, time_stamp) -> datetime:
@@ -58,4 +64,4 @@ class Win32(OsUtils):
         return
 
     def wait_return(self):
-        input('Press ENTER to exit>')
+        input("Press ENTER to exit>")

pymobiledevice3/pair_records.py

@@ -15,10 +15,10 @@ from pymobiledevice3.usbmux import PlistMuxConnection
 
 logger = logging.getLogger(__name__)
 OSUTILS = get_os_utils()
-PAIRING_RECORD_EXT = 'plist'
+PAIRING_RECORD_EXT = "plist"
 
 
-def generate_host_id(hostname: str = None) -> str:
+def generate_host_id(hostname: Optional[str] = None) -> str:
     """
     Generate a unique host ID based on the hostname.
 
@@ -44,12 +44,11 @@ def get_usbmux_pairing_record(identifier: str, usbmux_address: Optional[str] = N
     :return: The pairing record if found, otherwise None.
     :rtype: dict or None
     """
-    with suppress(NotPairedError, MuxException):
-        with usbmux.create_mux(usbmux_address=usbmux_address) as mux:
-            if isinstance(mux, PlistMuxConnection):
-                pair_record = mux.get_pair_record(identifier)
-                if pair_record is not None:
-                    return pair_record
+    with suppress(NotPairedError, MuxException), usbmux.create_mux(usbmux_address=usbmux_address) as mux:
+        if isinstance(mux, PlistMuxConnection):
+            pair_record = mux.get_pair_record(identifier)
+            if pair_record is not None:
+                return pair_record
     return None
 
 
@@ -62,9 +61,9 @@ def get_itunes_pairing_record(identifier: str) -> Optional[dict]:
     :return: The pairing record if found, otherwise None.
     :rtype: Optional[dict]
     """
-    filename = OSUTILS.pair_record_path / f'{identifier}.plist'
+    filename = OSUTILS.pair_record_path / f"{identifier}.plist"
     try:
-        with open(filename, 'rb') as f:
+        with open(filename, "rb") as f:
             pair_record = plistlib.load(f)
     except (PermissionError, FileNotFoundError, plistlib.InvalidFileException):
         return None
@@ -82,16 +81,17 @@ def get_local_pairing_record(identifier: str, pairing_records_cache_folder: Path
     :return: The pairing record if found, otherwise None.
     :rtype: Optional[dict]
     """
-    logger.debug('Looking for pymobiledevice3 pairing record')
-    path = pairing_records_cache_folder / f'{identifier}.{PAIRING_RECORD_EXT}'
+    logger.debug("Looking for pymobiledevice3 pairing record")
+    path = pairing_records_cache_folder / f"{identifier}.{PAIRING_RECORD_EXT}"
     if not path.exists():
-        logger.debug(f'No pymobiledevice3 pairing record found for device {identifier}')
+        logger.debug(f"No pymobiledevice3 pairing record found for device {identifier}")
         return None
     return plistlib.loads(path.read_bytes())
 
 
-def get_preferred_pair_record(identifier: str, pairing_records_cache_folder: Path,
-                              usbmux_address: Optional[str] = None) -> dict:
+def get_preferred_pair_record(
+    identifier: str, pairing_records_cache_folder: Path, usbmux_address: Optional[str] = None
+) -> dict:
     """
     Look for an existing pair record for the connected device in the following order:
     - usbmuxd
@@ -121,7 +121,7 @@ def get_preferred_pair_record(identifier: str, pairing_records_cache_folder: Pat
     return get_local_pairing_record(identifier, pairing_records_cache_folder)
 
 
-def create_pairing_records_cache_folder(pairing_records_cache_folder: Path = None) -> Path:
+def create_pairing_records_cache_folder(pairing_records_cache_folder: Optional[Path] = None) -> Path:
     """
     Create the pairing records cache folder if it does not exist.
 
@@ -148,7 +148,7 @@ def get_remote_pairing_record_filename(identifier: str) -> str:
     :return: The filename for the remote pairing record.
     :rtype: str
     """
-    return f'remote_{identifier}'
+    return f"remote_{identifier}"
 
 
 def iter_remote_pair_records() -> Generator[Path, None, None]:
@@ -158,7 +158,7 @@ def iter_remote_pair_records() -> Generator[Path, None, None]:
     :return: A generator yielding paths to the remote pairing records.
     :rtype: Generator[Path, None, None]
     """
-    return get_home_folder().glob('remote_*')
+    return get_home_folder().glob("remote_*")
 
 
 def iter_remote_paired_identifiers() -> Generator[str, None, None]:
@@ -169,4 +169,4 @@ def iter_remote_paired_identifiers() -> Generator[str, None, None]:
     :rtype: Generator[str, None, None]
     """
     for file in iter_remote_pair_records():
-        yield file.parts[-1].split('remote_', 1)[1].split('.', 1)[0]
+        yield file.parts[-1].split("remote_", 1)[1].split(".", 1)[0]

pymobiledevice3/remote/common.py

@@ -3,13 +3,13 @@ from enum import Enum
 
 
 class ConnectionType(Enum):
-    USB = 'usb'
-    WIFI = 'wifi'
+    USB = "usb"
+    WIFI = "wifi"
 
 
 class TunnelProtocol(Enum):
-    TCP = 'tcp'
-    QUIC = 'quic'
+    TCP = "tcp"
+    QUIC = "quic"
 
     # TODO: make only TCP the default once 3.12 becomes deprecated
     DEFAULT = TCP if sys.version_info >= (3, 13) else QUIC

pymobiledevice3/remote/core_device/app_service.py

@@ -11,45 +11,63 @@ class AppServiceService(CoreDeviceService):
     Manage applications
     """
 
-    SERVICE_NAME = 'com.apple.coredevice.appservice'
+    SERVICE_NAME = "com.apple.coredevice.appservice"
 
     def __init__(self, rsd: RemoteServiceDiscoveryService):
         super().__init__(rsd, self.SERVICE_NAME)
 
-    async def list_apps(self, include_app_clips: bool = True, include_removable_apps: bool = True,
-                        include_hidden_apps: bool = True, include_internal_apps: bool = True,
-                        include_default_apps: bool = True) -> list[dict]:
-        """ List applications """
-        return await self.invoke('com.apple.coredevice.feature.listapps', {
-            'includeAppClips': include_app_clips, 'includeRemovableApps': include_removable_apps,
-            'includeHiddenApps': include_hidden_apps, 'includeInternalApps': include_internal_apps,
-            'includeDefaultApps': include_default_apps})
+    async def list_apps(
+        self,
+        include_app_clips: bool = True,
+        include_removable_apps: bool = True,
+        include_hidden_apps: bool = True,
+        include_internal_apps: bool = True,
+        include_default_apps: bool = True,
+    ) -> list[dict]:
+        """List applications"""
+        return await self.invoke(
+            "com.apple.coredevice.feature.listapps",
+            {
+                "includeAppClips": include_app_clips,
+                "includeRemovableApps": include_removable_apps,
+                "includeHiddenApps": include_hidden_apps,
+                "includeInternalApps": include_internal_apps,
+                "includeDefaultApps": include_default_apps,
+            },
+        )
 
     async def launch_application(
-            self, bundle_id: str, arguments: Optional[list[str]] = None, kill_existing: bool = True,
-            start_suspended: bool = False, environment: Optional[dict] = None, extra_options: Optional[dict] = None) \
-            -> list[dict]:
-        """ launch application """
-        return await self.invoke('com.apple.coredevice.feature.launchapplication', {
-            'applicationSpecifier': {
-                'bundleIdentifier': {'_0': bundle_id},
-            },
-            'options': {
-                'arguments': arguments if arguments is not None else [],
-                'environmentVariables': environment if environment is not None else {},
-                'standardIOUsesPseudoterminals': True,
-                'startStopped': start_suspended,
-                'terminateExisting': kill_existing,
-                'user': {'shortName': 'mobile'},
-                'platformSpecificOptions': plistlib.dumps(extra_options if extra_options is not None else {}),
-            },
-            'standardIOIdentifiers': {
+        self,
+        bundle_id: str,
+        arguments: Optional[list[str]] = None,
+        kill_existing: bool = True,
+        start_suspended: bool = False,
+        environment: Optional[dict] = None,
+        extra_options: Optional[dict] = None,
+    ) -> list[dict]:
+        """launch application"""
+        return await self.invoke(
+            "com.apple.coredevice.feature.launchapplication",
+            {
+                "applicationSpecifier": {
+                    "bundleIdentifier": {"_0": bundle_id},
+                },
+                "options": {
+                    "arguments": arguments if arguments is not None else [],
+                    "environmentVariables": environment if environment is not None else {},
+                    "standardIOUsesPseudoterminals": True,
+                    "startStopped": start_suspended,
+                    "terminateExisting": kill_existing,
+                    "user": {"shortName": "mobile"},
+                    "platformSpecificOptions": plistlib.dumps(extra_options if extra_options is not None else {}),
+                },
+                "standardIOIdentifiers": {},
             },
-        })
+        )
 
     async def list_processes(self) -> list[dict]:
-        """ List processes """
-        return (await self.invoke('com.apple.coredevice.feature.listprocesses'))['processTokens']
+        """List processes"""
+        return (await self.invoke("com.apple.coredevice.feature.listprocesses"))["processTokens"]
 
     async def list_roots(self) -> dict:
         """
@@ -57,10 +75,7 @@ class AppServiceService(CoreDeviceService):
 
         Can only be performed on certain devices
         """
-        return await self.invoke('com.apple.coredevice.feature.listroots', {
-            'rootPoint': {
-                'relative': '/'
-            }})
+        return await self.invoke("com.apple.coredevice.feature.listroots", {"rootPoint": {"relative": "/"}})
 
     async def spawn_executable(self, executable: str, arguments: list[str]) -> dict:
         """
@@ -68,26 +83,29 @@ class AppServiceService(CoreDeviceService):
 
         Can only be performed on certain devices
         """
-        return await self.invoke('com.apple.coredevice.feature.spawnexecutable', {
-            'executableItem': {
-                'url': {
-                    '_0': {
-                        'relative': executable,
+        return await self.invoke(
+            "com.apple.coredevice.feature.spawnexecutable",
+            {
+                "executableItem": {
+                    "url": {
+                        "_0": {
+                            "relative": executable,
+                        },
+                    }
+                },
+                "standardIOIdentifiers": {},
+                "options": {
+                    "arguments": arguments,
+                    "environmentVariables": {},
+                    "standardIOUsesPseudoterminals": True,
+                    "startStopped": False,
+                    "user": {
+                        "active": True,
                     },
-                }
-            },
-            'standardIOIdentifiers': {},
-            'options': {
-                'arguments': arguments,
-                'environmentVariables': {},
-                'standardIOUsesPseudoterminals': True,
-                'startStopped': False,
-                'user': {
-                    'active': True,
+                    "platformSpecificOptions": plistlib.dumps({}),
                 },
-                'platformSpecificOptions': plistlib.dumps({}),
             },
-        })
+        )
 
     async def monitor_process_termination(self, pid: int) -> dict:
         """
@@ -95,33 +113,42 @@ class AppServiceService(CoreDeviceService):
 
         Can only be performed on certain devices
         """
-        return await self.invoke('com.apple.coredevice.feature.monitorprocesstermination', {
-            'processToken': {'processIdentifier': XpcInt64Type(pid)}})
+        return await self.invoke(
+            "com.apple.coredevice.feature.monitorprocesstermination",
+            {"processToken": {"processIdentifier": XpcInt64Type(pid)}},
+        )
 
     async def uninstall_app(self, bundle_identifier: str) -> None:
         """
         Uninstall given application by its bundle identifier
         """
-        await self.invoke('com.apple.coredevice.feature.uninstallapp', {'bundleIdentifier': bundle_identifier})
+        await self.invoke("com.apple.coredevice.feature.uninstallapp", {"bundleIdentifier": bundle_identifier})
 
     async def send_signal_to_process(self, pid: int, signal: int) -> dict:
         """
         Send signal to given process by its pid
         """
-        return await self.invoke('com.apple.coredevice.feature.sendsignaltoprocess', {
-            'process': {'processIdentifier': XpcInt64Type(pid)},
-            'signal': XpcInt64Type(signal),
-        })
+        return await self.invoke(
+            "com.apple.coredevice.feature.sendsignaltoprocess",
+            {
+                "process": {"processIdentifier": XpcInt64Type(pid)},
+                "signal": XpcInt64Type(signal),
+            },
+        )
 
-    async def fetch_icons(self, bundle_identifier: str, width: float, height: float, scale: float,
-                          allow_placeholder: bool) -> dict:
+    async def fetch_icons(
+        self, bundle_identifier: str, width: float, height: float, scale: float, allow_placeholder: bool
+    ) -> dict:
         """
         Fetch given application's icons
         """
-        return await self.invoke('com.apple.coredevice.feature.fetchappicons', {
-            'width': width,
-            'height': height,
-            'scale': scale,
-            'allowPlaceholder': allow_placeholder,
-            'bundleIdentifier': bundle_identifier
-        })
+        return await self.invoke(
+            "com.apple.coredevice.feature.fetchappicons",
+            {
+                "width": width,
+                "height": height,
+                "scale": scale,
+                "allowPlaceholder": allow_placeholder,
+                "bundleIdentifier": bundle_identifier,
+            },
+        )

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", {})