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

pymobiledevice3/services/installation_proxy.py

@@ -14,16 +14,16 @@ from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.afc import AfcService
 from pymobiledevice3.services.lockdown_service import LockdownService
 
-GET_APPS_ADDITIONAL_INFO = {'ReturnAttributes': ['CFBundleIdentifier', 'StaticDiskUsage', 'DynamicDiskUsage']}
+GET_APPS_ADDITIONAL_INFO = {"ReturnAttributes": ["CFBundleIdentifier", "StaticDiskUsage", "DynamicDiskUsage"]}
 
-TEMP_REMOTE_BASEDIR = '/PublicStaging'
-TEMP_REMOTE_IPA_FILE = f'{TEMP_REMOTE_BASEDIR}/pymobiledevice3.ipa'
-TEMP_REMOTE_IPCC_FOLDER = f'{TEMP_REMOTE_BASEDIR}/pymobiledevice3.ipcc'
+TEMP_REMOTE_BASEDIR = "/PublicStaging"
+TEMP_REMOTE_IPA_FILE = f"{TEMP_REMOTE_BASEDIR}/pymobiledevice3.ipa"
+TEMP_REMOTE_IPCC_FOLDER = f"{TEMP_REMOTE_BASEDIR}/pymobiledevice3.ipcc"
 
 
 class ZipFileType(Enum):
-    IPCC = 'ipcc'
-    IPA = 'ipa'
+    IPCC = "ipcc"
+    IPA = "ipa"
 
     def is_ipcc(self) -> bool:
         return self == ZipFileType.IPCC
@@ -33,42 +33,41 @@ class ZipFileType(Enum):
 
 
 def create_ipa_contents_from_directory(directory: str) -> bytes:
-    payload_prefix = 'Payload/' + os.path.basename(directory)
+    payload_prefix = "Payload/" + os.path.basename(directory)
     with TemporaryDirectory() as temp_dir:
-        zip_path = Path(temp_dir) / 'ipa'
-        with ZipFile(zip_path, 'w', ZIP_DEFLATED) as zip_file:
-            for root, dirs, files in os.walk(directory):
+        zip_path = Path(temp_dir) / "ipa"
+        with ZipFile(zip_path, "w", ZIP_DEFLATED) as zip_file:
+            for root, _dirs, files in os.walk(directory):
                 for file in files:
                     full_path = Path(root) / file
                     full_path.touch()
-                    zip_file.write(full_path,
-                                   arcname=f'{payload_prefix}/{os.path.relpath(full_path, directory)}')
+                    zip_file.write(full_path, arcname=f"{payload_prefix}/{os.path.relpath(full_path, directory)}")
         return zip_path.read_bytes()
 
 
 def classify_zip_file(zip_bytes: bytes) -> ZipFileType:
-    """ checks the zipped bytes if it's a .ipcc or .ipa """
+    """checks the zipped bytes if it's a .ipcc or .ipa"""
     try:
-        with ZipFile(BytesIO(zip_bytes), 'r') as zip_file:
+        with ZipFile(BytesIO(zip_bytes), "r") as zip_file:
             # sometimes packages at first index don't have enough infos to check
-            dirs = zip_file.namelist()[1].split('/')
+            dirs = zip_file.namelist()[1].split("/")
 
-            if dirs[0] != 'Payload':
-                raise AppInstallError('package does not have a payload')
-            if dirs[1].endswith('.app'):
+            if dirs[0] != "Payload":
+                raise AppInstallError("package does not have a payload")
+            if dirs[1].endswith(".app"):
                 return ZipFileType.IPA
-            elif dirs[1].endswith('.bundle'):
+            elif dirs[1].endswith(".bundle"):
                 return ZipFileType.IPCC
             else:
-                raise AppInstallError('package does not have the appropriate folders structure')
+                raise AppInstallError("package does not have the appropriate folders structure")
 
-    except BadZipFile:
-        raise AppInstallError('invalid bytes package')
+    except BadZipFile as e:
+        raise AppInstallError("Invalid bytes package") from e
 
 
 class InstallationProxyService(LockdownService):
-    SERVICE_NAME = 'com.apple.mobile.installation_proxy'
-    RSD_SERVICE_NAME = 'com.apple.mobile.installation_proxy.shim.remote'
+    SERVICE_NAME = "com.apple.mobile.installation_proxy"
+    RSD_SERVICE_NAME = "com.apple.mobile.installation_proxy.shim.remote"
 
     def __init__(self, lockdown: LockdownServiceProvider):
         if isinstance(lockdown, LockdownClient):
@@ -76,69 +75,84 @@ class InstallationProxyService(LockdownService):
         else:
             super().__init__(lockdown, self.RSD_SERVICE_NAME)
 
-    def _watch_completion(self, handler: Callable = None, ipcc: bool = False, *args) -> None:
+    def _watch_completion(self, handler: Optional[Callable] = None, ipcc: bool = False, *args) -> None:
         while True:
             response = self.service.recv_plist()
             if not response:
                 break
-            error = response.get('Error')
+            error = response.get("Error")
             if error:
-                raise AppInstallError(f'{error}: {response.get("ErrorDescription")}')
-            completion = response.get('PercentComplete')
+                raise AppInstallError(f"{error}: {response.get('ErrorDescription')}")
+            completion = response.get("PercentComplete")
             if completion:
                 if handler:
-                    self.logger.debug('calling handler')
+                    self.logger.debug("calling handler")
                     handler(completion, *args)
-                self.logger.info(f'{response.get("PercentComplete")}% Complete')
-            if response.get('Status') == 'Complete':
+                self.logger.info(f"{response.get('PercentComplete')}% Complete")
+            if response.get("Status") == "Complete":
                 if ipcc:
                     # there is no progress when installing a .ipcc file,
                     # so we just put a simple message indicating it's done
-                    self.logger.info('Installation succeed.')
+                    self.logger.info("Installation succeed.")
                 return
         raise AppInstallError()
 
-    def send_cmd_for_bundle_identifier(self, bundle_identifier: str, cmd: str = 'Archive',
-                                       options: Optional[dict] = None,
-                                       handler: Optional[dict] = None, *args) -> None:
-        """ send a low-level command to installation relay """
-        cmd = {'Command': cmd,
-               'ApplicationIdentifier': bundle_identifier}
+    def send_cmd_for_bundle_identifier(
+        self,
+        bundle_identifier: str,
+        cmd: str = "Archive",
+        options: Optional[dict] = None,
+        handler: Optional[dict] = None,
+        *args,
+    ) -> None:
+        """send a low-level command to installation relay"""
+        cmd = {"Command": cmd, "ApplicationIdentifier": bundle_identifier}
 
         if options is None:
             options = {}
 
-        cmd.update({'ClientOptions': options})
+        cmd.update({"ClientOptions": options})
         self.service.send_plist(cmd)
         self._watch_completion(handler, *args)
 
-    def install(self, package_path: str, options: Optional[dict] = None, handler: Callable = None, *args) -> None:
-        """ install given ipa/ipcc from device path """
-        self.install_from_local(package_path, 'Install', options, handler, args)
-
-    def upgrade(self, ipa_path: str, options: Optional[dict] = None, handler: Callable = None, *args) -> None:
-        """ upgrade given ipa from device path """
-        self.install_from_local(ipa_path, 'Upgrade', options, handler, args)
-
-    def restore(self, bundle_identifier: str, options: Optional[dict] = None, handler: Callable = None, *args) -> None:
-        """ no longer supported on newer iOS versions """
-        self.send_cmd_for_bundle_identifier(bundle_identifier, 'Restore', options, handler, args)
-
-    def uninstall(self, bundle_identifier: str, options: Optional[dict] = None, handler: Callable = None,
-                  *args) -> None:
-        """ uninstall given bundle_identifier """
-        self.send_cmd_for_bundle_identifier(bundle_identifier, 'Uninstall', options, handler, args)
-
-    def install_from_bytes(self, package_bytes: bytes, cmd: str = 'Install', options: Optional[dict] = None,
-                           handler: Callable = None, *args) -> None:
-        """ upload given ipa/ipcc bytes object onto device and install it """
+    def install(
+        self, package_path: str, options: Optional[dict] = None, handler: Optional[Callable] = None, *args
+    ) -> None:
+        """install given ipa/ipcc from device path"""
+        self.install_from_local(package_path, "Install", options, handler, args)
+
+    def upgrade(self, ipa_path: str, options: Optional[dict] = None, handler: Optional[Callable] = None, *args) -> None:
+        """upgrade given ipa from device path"""
+        self.install_from_local(ipa_path, "Upgrade", options, handler, args)
+
+    def restore(
+        self, bundle_identifier: str, options: Optional[dict] = None, handler: Optional[Callable] = None, *args
+    ) -> None:
+        """no longer supported on newer iOS versions"""
+        self.send_cmd_for_bundle_identifier(bundle_identifier, "Restore", options, handler, args)
+
+    def uninstall(
+        self, bundle_identifier: str, options: Optional[dict] = None, handler: Optional[Callable] = None, *args
+    ) -> None:
+        """uninstall given bundle_identifier"""
+        self.send_cmd_for_bundle_identifier(bundle_identifier, "Uninstall", options, handler, args)
+
+    def install_from_bytes(
+        self,
+        package_bytes: bytes,
+        cmd: str = "Install",
+        options: Optional[dict] = None,
+        handler: Optional[Callable] = None,
+        *args,
+    ) -> None:
+        """upload given ipa/ipcc bytes object onto device and install it"""
         ipcc_mode = classify_zip_file(package_bytes).is_ipcc()
 
         if options is None:
             options = {}
 
         if ipcc_mode:
-            options['PackageType'] = 'CarrierBundle'
+            options["PackageType"] = "CarrierBundle"
 
         with AfcService(self.lockdown) as afc:
             if not ipcc_mode:
@@ -148,17 +162,24 @@ class InstallationProxyService(LockdownService):
 
         self.send_package(cmd, options, handler, ipcc_mode, *args)
 
-    @str_to_path('package_path')
-    def install_from_local(self, package_path: Path, cmd: str = 'Install', options: Optional[dict] = None,
-                           handler: Callable = None, developer: bool = False, *args) -> None:
-        """ upload given ipa/ipcc onto device and install it """
-        ipcc_mode = package_path.suffix == '.ipcc'
+    @str_to_path("package_path")
+    def install_from_local(
+        self,
+        package_path: Path,
+        cmd: str = "Install",
+        options: Optional[dict] = None,
+        handler: Optional[Callable] = None,
+        developer: bool = False,
+        *args,
+    ) -> None:
+        """upload given ipa/ipcc onto device and install it"""
+        ipcc_mode = package_path.suffix == ".ipcc"
 
         if options is None:
             options = {}
 
         if ipcc_mode:
-            options['PackageType'] = 'CarrierBundle'
+            options["PackageType"] = "CarrierBundle"
         else:
             if package_path.is_dir():
                 # treat as app, convert into an ipa
@@ -168,7 +189,7 @@ class InstallationProxyService(LockdownService):
                 ipa_contents = package_path.read_bytes()
 
         if developer:
-            options['PackageType'] = 'Developer'
+            options["PackageType"] = "Developer"
 
         with AfcService(self.lockdown) as afc:
             if not ipcc_mode:
@@ -182,19 +203,16 @@ class InstallationProxyService(LockdownService):
 
     def send_package(self, cmd: str, options: Optional[dict], handler: Callable, ipcc_mode: bool = False, *args):
         self.service.send_plist({
-            'Command': cmd,
-            'ClientOptions': options,
-            'PackagePath': (
-                TEMP_REMOTE_IPCC_FOLDER if ipcc_mode
-                else TEMP_REMOTE_IPA_FILE
-            )
+            "Command": cmd,
+            "ClientOptions": options,
+            "PackagePath": (TEMP_REMOTE_IPCC_FOLDER if ipcc_mode else TEMP_REMOTE_IPA_FILE),
         })
 
         self._watch_completion(handler, ipcc_mode, args)
 
     def upload_ipcc_from_path(self, file: Path, afc_client: AfcService) -> None:
         """Used to upload a .ipcc file to an iPhone as a folder"""
-        with file.open('rb') as fb:
+        with file.open("rb") as fb:
             file_name = file.name
             file_stream = BytesIO(fb.read())
             self._upload_ipcc(file_stream, afc_client, file_name)
@@ -206,44 +224,41 @@ class InstallationProxyService(LockdownService):
         self._upload_ipcc(file_stream, afc_client, file_name)
 
     def _upload_ipcc(self, file_stream: BytesIO, afc_client: AfcService, file_name: str) -> None:
-        self.logger.info(f'Uploading {file_name} contents..')
+        self.logger.info(f"Uploading {file_name} contents..")
 
         afc_client.makedirs(TEMP_REMOTE_IPCC_FOLDER)
 
         # we unpack it and upload it directly instead of saving it in a temp folder
-        with ZipFile(file_stream, 'r') as file_zip:
+        with ZipFile(file_stream, "r") as file_zip:
             for file_name in file_zip.namelist():
-
-                if file_name.endswith(('/', '\\')):
-                    afc_client.makedirs(f'{TEMP_REMOTE_IPCC_FOLDER}/{file_name}')
+                if file_name.endswith(("/", "\\")):
+                    afc_client.makedirs(f"{TEMP_REMOTE_IPCC_FOLDER}/{file_name}")
                     continue
 
                 with file_zip.open(file_name) as inside_file_zip:
                     file_data = inside_file_zip.read()
                     afc_client.makedirs(TEMP_REMOTE_BASEDIR)
-                    afc_client.set_file_contents(f'{TEMP_REMOTE_IPCC_FOLDER}/{file_name}', file_data)
+                    afc_client.set_file_contents(f"{TEMP_REMOTE_IPCC_FOLDER}/{file_name}", file_data)
 
-        self.logger.info('Upload complete.')
+        self.logger.info("Upload complete.")
 
     def check_capabilities_match(self, capabilities: Optional[dict] = None, options: Optional[dict] = None) -> dict:
         if options is None:
             options = {}
-        cmd = {'Command': 'CheckCapabilitiesMatch',
-               'ClientOptions': options}
+        cmd = {"Command": "CheckCapabilitiesMatch", "ClientOptions": options}
 
         if capabilities:
-            cmd['Capabilities'] = capabilities
+            cmd["Capabilities"] = capabilities
 
-        return self.service.send_recv_plist(cmd).get('LookupResult')
+        return self.service.send_recv_plist(cmd).get("LookupResult")
 
-    def browse(self, options: Optional[dict] = None, attributes: list[str] = None) -> list[dict]:
+    def browse(self, options: Optional[dict] = None, attributes: Optional[list[str]] = None) -> list[dict]:
         if options is None:
             options = {}
         if attributes:
-            options['ReturnAttributes'] = attributes
+            options["ReturnAttributes"] = attributes
 
-        cmd = {'Command': 'Browse',
-               'ClientOptions': options}
+        cmd = {"Command": "Browse", "ClientOptions": options}
 
         self.service.send_plist(cmd)
 
@@ -253,30 +268,34 @@ class InstallationProxyService(LockdownService):
             if not response:
                 break
 
-            data = response.get('CurrentList')
+            data = response.get("CurrentList")
             if data is not None:
                 result += data
 
-            if response.get('Status') == 'Complete':
+            if response.get("Status") == "Complete":
                 break
 
         return result
 
     def lookup(self, options: Optional[dict] = None) -> dict:
-        """ search installation database """
+        """search installation database"""
         if options is None:
             options = {}
-        cmd = {'Command': 'Lookup', 'ClientOptions': options}
-        return self.service.send_recv_plist(cmd).get('LookupResult')
-
-    def get_apps(self, application_type: str = 'Any', calculate_sizes: bool = False,
-                 bundle_identifiers: Optional[list[str]] = None) -> dict[str, dict]:
-        """ get applications according to given criteria """
+        cmd = {"Command": "Lookup", "ClientOptions": options}
+        return self.service.send_recv_plist(cmd).get("LookupResult")
+
+    def get_apps(
+        self,
+        application_type: str = "Any",
+        calculate_sizes: bool = False,
+        bundle_identifiers: Optional[list[str]] = None,
+    ) -> dict[str, dict]:
+        """get applications according to given criteria"""
         options = {}
         if bundle_identifiers is not None:
-            options['BundleIDs'] = bundle_identifiers
+            options["BundleIDs"] = bundle_identifiers
 
-        options['ApplicationType'] = application_type
+        options["ApplicationType"] = application_type
         result = self.lookup(options)
         if calculate_sizes:
             options.update(GET_APPS_ADDITIONAL_INFO)

pymobiledevice3/services/lockdown_service.py

@@ -5,8 +5,14 @@ from pymobiledevice3.service_connection import ServiceConnection
 
 
 class LockdownService:
-    def __init__(self, lockdown: LockdownServiceProvider, service_name: str, is_developer_service=False,
-                 service: ServiceConnection = None, include_escrow_bag: bool = False):
+    def __init__(
+        self,
+        lockdown: LockdownServiceProvider,
+        service_name: str,
+        is_developer_service=False,
+        service: ServiceConnection = None,
+        include_escrow_bag: bool = False,
+    ):
         """
         :param lockdown: server provider
         :param service_name: wrapped service name - will attempt
@@ -15,8 +21,9 @@ class LockdownService:
         """
 
         if service is None:
-            start_service = lockdown.start_lockdown_developer_service if is_developer_service else \
-                lockdown.start_lockdown_service
+            start_service = (
+                lockdown.start_lockdown_developer_service if is_developer_service else lockdown.start_lockdown_service
+            )
             service = start_service(service_name, include_escrow_bag=include_escrow_bag)
 
         self.service_name = service_name
@@ -27,7 +34,7 @@ class LockdownService:
     def __enter__(self):
         return self
 
-    async def __aenter__(self) -> 'LockdownService':
+    async def __aenter__(self) -> "LockdownService":
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):

pymobiledevice3/services/misagent.py

@@ -10,8 +10,8 @@ class ProvisioningProfile:
     def __init__(self, buf: bytes):
         self.buf = buf
 
-        xml = b'<?xml' + buf.split(b'<?xml', 1)[1]
-        xml = xml.split(b'</plist>')[0] + b'</plist>'
+        xml = b"<?xml" + buf.split(b"<?xml", 1)[1]
+        xml = xml.split(b"</plist>")[0] + b"</plist>"
         self.plist = plistlib.loads(xml)
 
     def __str__(self):
@@ -19,8 +19,8 @@ class ProvisioningProfile:
 
 
 class MisagentService(LockdownService):
-    SERVICE_NAME = 'com.apple.misagent'
-    RSD_SERVICE_NAME = 'com.apple.misagent.shim.remote'
+    SERVICE_NAME = "com.apple.misagent"
+    RSD_SERVICE_NAME = "com.apple.misagent.shim.remote"
 
     def __init__(self, lockdown: LockdownClient):
         if isinstance(lockdown, LockdownClient):
@@ -29,27 +29,30 @@ class MisagentService(LockdownService):
             super().__init__(lockdown, self.RSD_SERVICE_NAME)
 
     def install(self, plist: BytesIO) -> dict:
-        response = self.service.send_recv_plist({'MessageType': 'Install',
-                                                 'Profile': plist.read(),
-                                                 'ProfileType': 'Provisioning'})
-        if response['Status']:
-            raise PyMobileDevice3Exception(f'invalid status: {response}')
+        response = self.service.send_recv_plist({
+            "MessageType": "Install",
+            "Profile": plist.read(),
+            "ProfileType": "Provisioning",
+        })
+        if response["Status"]:
+            raise PyMobileDevice3Exception(f"invalid status: {response}")
 
         return response
 
     def remove(self, profile_id: str) -> dict:
-        response = self.service.send_recv_plist({'MessageType': 'Remove',
-                                                 'ProfileID': profile_id,
-                                                 'ProfileType': 'Provisioning'})
-        if response['Status']:
-            raise PyMobileDevice3Exception(f'invalid status: {response}')
+        response = self.service.send_recv_plist({
+            "MessageType": "Remove",
+            "ProfileID": profile_id,
+            "ProfileType": "Provisioning",
+        })
+        if response["Status"]:
+            raise PyMobileDevice3Exception(f"invalid status: {response}")
 
         return response
 
     def copy_all(self) -> list[ProvisioningProfile]:
-        response = self.service.send_recv_plist({'MessageType': 'CopyAll',
-                                                 'ProfileType': 'Provisioning'})
-        if response['Status']:
-            raise PyMobileDevice3Exception(f'invalid status: {response}')
+        response = self.service.send_recv_plist({"MessageType": "CopyAll", "ProfileType": "Provisioning"})
+        if response["Status"]:
+            raise PyMobileDevice3Exception(f"invalid status: {response}")
 
-        return [ProvisioningProfile(p) for p in response['Payload']]
+        return [ProvisioningProfile(p) for p in response["Payload"]]