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

pymobiledevice3/remote/remote_service_discovery.py

@@ -44,6 +44,10 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
     def product_version(self) -> str:
         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"]
@@ -101,6 +105,9 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
                 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
@@ -162,17 +169,18 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
 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
 
 

pymobiledevice3/restore/device.py

@@ -1,6 +1,6 @@
 from contextlib import suppress
 from functools import cached_property
-from typing import Optional
+from typing import Optional, overload
 
 from pymobiledevice3.exceptions import MissingValueError
 from pymobiledevice3.irecv import IRecv
@@ -8,9 +8,15 @@ from pymobiledevice3.lockdown import LockdownClient
 
 
 class Device:
-    def __init__(self, lockdown: LockdownClient = None, irecv: IRecv = None):
-        self.lockdown = lockdown
-        self.irecv = irecv
+    @overload
+    def __init__(self, lockdown: LockdownClient, irecv: None = None) -> None: ...
+
+    @overload
+    def __init__(self, lockdown: None = None, *, irecv: IRecv) -> None: ...
+
+    def __init__(self, lockdown: Optional[LockdownClient] = None, irecv: Optional[IRecv] = None) -> None:
+        self._lockdown: Optional[LockdownClient] = lockdown
+        self._irecv: Optional[IRecv] = irecv
 
     def __repr__(self) -> str:
         return (
@@ -20,6 +26,24 @@ class Device:
             f"image4-support: {self.is_image4_supported}>"
         )
 
+    @cached_property
+    def is_lockdown(self) -> bool:
+        return self._lockdown is not None
+
+    @cached_property
+    def is_irecv(self) -> bool:
+        return self._irecv is not None
+
+    @cached_property
+    def lockdown(self) -> LockdownClient:
+        assert self._lockdown is not None
+        return self._lockdown
+
+    @cached_property
+    def irecv(self) -> IRecv:
+        assert self._irecv is not None
+        return self._irecv
+
     @cached_property
     def ecid(self):
         if self.lockdown:

pymobiledevice3/restore/restore.py

@@ -182,7 +182,7 @@ class Restore(BaseRestore):
         self.logger.info("Sending BuildIdentityDict now...")
         await service.aio_send_plist(req)
 
-    async def extract_global_manifest(self) -> dict:
+    def extract_global_manifest(self) -> dict:
         build_info = self.build_identity.get("Info")
         if build_info is None:
             raise PyMobileDevice3Exception('build identity does not contain an "Info" element')
@@ -881,7 +881,7 @@ class Restore(BaseRestore):
         comp_name = "BMU,FirmwareMap"
 
         if "DeviceGeneratedTags" in arguments:
-            response = self.get_device_generated_firmware_data(updater_name, info, arguments)
+            response = await self.get_device_generated_firmware_data(updater_name, info, arguments)
         else:
             # create Veridian request
             request = TSSRequest()

pymobiledevice3/service_connection.py

@@ -8,7 +8,7 @@ import struct
 import time
 import xml
 from enum import Enum
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 import IPython
 from pygments import formatters, highlight, lexers
@@ -192,7 +192,7 @@ class ServiceConnection:
         except ssl.SSLEOFError as e:
             raise ConnectionTerminatedError from e
 
-    def send_recv_plist(self, data: dict, endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> Any:
+    def send_recv_plist(self, data: Union[dict, list], endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> Any:
         """
         Send a plist to the socket and receive a plist response.
 
@@ -282,29 +282,29 @@ class ServiceConnection:
         msg = b"".join([hdr, data])
         return self.sendall(msg)
 
-    def recv_plist(self, endianity: str = ">") -> dict:
+    def recv_plist(self, endianity: str = ">") -> Union[dict, list]:
         """
-        Receive a plist from the socket and parse it into a dictionary.
+        Receive a plist from the socket and parse it into a native type.
 
         :param endianity: The byte order ('>' for big-endian, '<' for little-endian).
-        :return: The received plist as a dictionary.
+        :return: The received plist as a native type.
         """
         return parse_plist(self.recv_prefixed(endianity=endianity))
 
     async def aio_recv_plist(self, endianity: str = ">") -> dict:
         """
-        Asynchronously receive a plist from the socket and parse it into a dictionary.
+        Asynchronously receive a plist from the socket and parse it into a native type.
 
         :param endianity: The byte order ('>' for big-endian, '<' for little-endian).
-        :return: The received plist as a dictionary.
+        :return: The received plist as a native type.
         """
         return parse_plist(await self.aio_recv_prefixed(endianity))
 
-    def send_plist(self, d: dict, endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> None:
+    def send_plist(self, d: Union[dict, list], endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> None:
         """
-        Send a dictionary as a plist to the socket.
+        Send a native type as a plist to the socket.
 
-        :param d: The dictionary to send.
+        :param d: The native type to send.
         :param endianity: The byte order ('>' for big-endian, '<' for little-endian).
         :param fmt: The plist format (e.g., plistlib.FMT_XML).
         """
@@ -319,7 +319,7 @@ class ServiceConnection:
         self.writer.write(payload)
         await self.writer.drain()
 
-    async def aio_send_plist(self, d: dict, endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> None:
+    async def aio_send_plist(self, d: Union[dict, list], endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> None:
         """
         Asynchronously send a dictionary as a plist to the socket.
 
@@ -357,7 +357,10 @@ class ServiceConnection:
         :param certfile: The path to the certificate file.
         :param keyfile: The path to the key file (optional).
         """
-        self.socket = self.create_ssl_context(certfile, keyfile=keyfile).wrap_socket(self.socket)
+        try:
+            self.socket = self.create_ssl_context(certfile, keyfile=keyfile).wrap_socket(self.socket)
+        except OSError as e:
+            raise ConnectionAbortedError() from e
 
     async def aio_ssl_start(self, certfile: str, keyfile: Optional[str] = None) -> None:
         """