pymobiledevice3 5.0.1__py3-none-any.whl → 5.0.3__py3-none-any.whl

pymobiledevice3/bonjour.py

@@ -3,22 +3,23 @@
 # - Uses ifaddr (optional) to map IPs -> local interfaces; otherwise iface will be None.
 
 import asyncio
+import contextlib
 import ipaddress
 import socket
 import struct
 import sys
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 import ifaddr  # pip install ifaddr
 
 from pymobiledevice3.osu.os_utils import get_os_utils
 
-REMOTEPAIRING_SERVICE_NAME = '_remotepairing._tcp.local.'
-REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAME = '_remotepairing-manual-pairing._tcp.local.'
-MOBDEV2_SERVICE_NAME = '_apple-mobdev2._tcp.local.'
-REMOTED_SERVICE_NAME = '_remoted._tcp.local.'
+REMOTEPAIRING_SERVICE_NAME = "_remotepairing._tcp.local."
+REMOTEPAIRING_MANUAL_PAIRING_SERVICE_NAME = "_remotepairing-manual-pairing._tcp.local."
+MOBDEV2_SERVICE_NAME = "_apple-mobdev2._tcp.local."
+REMOTED_SERVICE_NAME = "_remoted._tcp.local."
 OSUTILS = get_os_utils()
 DEFAULT_BONJOUR_TIMEOUT = OSUTILS.bonjour_timeout
 
@@ -38,6 +39,7 @@ CLASS_QU = 0x8000  # unicast-response bit (we use multicast queries)
 
 # ---------------- Dataclasses ----------------
 
+
 # --- Dataclass decorator shim (adds slots only on 3.10+)
 def dataclass_compat(*d_args, **d_kwargs):
     if sys.version_info < (3, 10):
@@ -62,8 +64,8 @@ class ServiceInstance:
     instance: str  # "<Instance Name>._type._proto.local."
     host: Optional[str]  # "host.local" (without trailing dot), or None if unresolved
     port: Optional[int]  # SRV port
-    addresses: List[Address] = field(default_factory=list)  # IPs with interface names
-    properties: Dict[str, str] = field(default_factory=dict)  # TXT key/values
+    addresses: list[Address] = field(default_factory=list)  # IPs with interface names
+    properties: dict[str, str] = field(default_factory=dict)  # TXT key/values
 
 
 # ---------------- DNS helpers ----------------
@@ -82,7 +84,7 @@ def encode_name(name: str) -> bytes:
     return bytes(out)
 
 
-def decode_name(data: bytes, off: int) -> Tuple[str, int]:
+def decode_name(data: bytes, off: int) -> tuple[str, int]:
     labels = []
     jumped = False
     orig_end = off
@@ -123,9 +125,9 @@ def parse_rr(data: bytes, off: int):
     name, off = decode_name(data, off)
     if off + 10 > len(data):
         raise ValueError("truncated RR header")
-    rtype, rclass, ttl, rdlen = struct.unpack("!HHIH", data[off: off + 10])
+    rtype, rclass, ttl, rdlen = struct.unpack("!HHIH", data[off : off + 10])
     off += 10
-    rdata = data[off: off + rdlen]
+    rdata = data[off : off + rdlen]
     off += rdlen
 
     rr = {"name": name, "type": rtype, "class": rclass & 0x7FFF, "ttl": ttl}
@@ -135,16 +137,14 @@ def parse_rr(data: bytes, off: int):
     elif rtype == QTYPE_SRV and rdlen >= 6:
         priority, weight, port = struct.unpack("!HHH", rdata[:6])
         target, _ = decode_name(data, off - rdlen + 6)
-        rr.update(
-            {"priority": priority, "weight": weight, "port": port, "target": target}
-        )
+        rr.update({"priority": priority, "weight": weight, "port": port, "target": target})
     elif rtype == QTYPE_TXT:
         kv = {}
         i = 0
         while i < rdlen:
             b = rdata[i]
             i += 1
-            seg = rdata[i: i + b]
+            seg = rdata[i : i + b]
             i += b
             if not seg:
                 continue
@@ -185,16 +185,13 @@ class _Adapters:
     def __init__(self):
         self.adapters = ifaddr.get_adapters() if ifaddr is not None else []
 
-    def pick_iface_for_ip(
-            self, ip_str: str, family: int, v6_scopeid: Optional[int]
-    ) -> Optional[str]:
+    def pick_iface_for_ip(self, ip_str: str, family: int, v6_scopeid: Optional[int]) -> Optional[str]:
         # Prefer scope id for IPv6 link-local
-        if family == socket.AF_INET6 and ip_str.lower().startswith("fe80:"):
-            if v6_scopeid:
-                try:
-                    return socket.if_indextoname(v6_scopeid)
-                except OSError:
-                    pass
+        if family == socket.AF_INET6 and ip_str.lower().startswith("fe80:") and v6_scopeid:
+            try:
+                return socket.if_indextoname(v6_scopeid)
+            except OSError:
+                pass
 
         # Otherwise, try to match destination ip to local subnet via ifaddr
         if not self.adapters:
@@ -213,9 +210,7 @@ class _Adapters:
                     ipn_ip = ipn.ip[0]
                 if fam != family:
                     continue
-                net = ipaddress.ip_network(
-                    f"{ipn_ip}/{ipn.network_prefix}", strict=False
-                )
+                net = ipaddress.ip_network(f"{ipn_ip}/{ipn.network_prefix}", strict=False)
                 if ip in net and ipn.network_prefix > best[1]:
                     best = (ad.nice_name or ad.name, ipn.network_prefix)
         return best[0]
@@ -237,21 +232,15 @@ async def _bind_ipv4(queue: asyncio.Queue):
     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     if hasattr(socket, "SO_REUSEPORT"):
-        try:
+        with contextlib.suppress(OSError):
             s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-        except OSError:
-            pass
     s.bind(("0.0.0.0", MDNS_PORT))
     try:
-        mreq = struct.pack(
-            "=4s4s", socket.inet_aton(MDNS_MCAST_V4), socket.inet_aton("0.0.0.0")
-        )
+        mreq = struct.pack("=4s4s", socket.inet_aton(MDNS_MCAST_V4), socket.inet_aton("0.0.0.0"))
         s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
     except OSError:
         pass
-    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(
-        lambda: _DatagramProtocol(queue), sock=s
-    )
+    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(lambda: _DatagramProtocol(queue), sock=s)
     return transport, s
 
 
@@ -259,10 +248,8 @@ async def _bind_ipv6_all_ifaces(queue: asyncio.Queue):
     s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
     s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     if hasattr(socket, "SO_REUSEPORT"):
-        try:
+        with contextlib.suppress(OSError):
             s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-        except OSError:
-            pass
     s.bind(("::", MDNS_PORT))
     grp = socket.inet_pton(socket.AF_INET6, MDNS_MCAST_V6)
     for ifindex, _ in socket.if_nameindex():
@@ -271,15 +258,13 @@ async def _bind_ipv6_all_ifaces(queue: asyncio.Queue):
             s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq6)
         except OSError:
             continue
-    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(
-        lambda: _DatagramProtocol(queue), sock=s
-    )
+    transport, _ = await asyncio.get_running_loop().create_datagram_endpoint(lambda: _DatagramProtocol(queue), sock=s)
     return transport, s
 
 
 async def _open_mdns_sockets():
     queue = asyncio.Queue()
-    transports: List[Tuple[asyncio.BaseTransport, socket.socket]] = []
+    transports: list[tuple[asyncio.BaseTransport, socket.socket]] = []
     t4, s4 = await _bind_ipv4(queue)
     transports.append((t4, s4))
     t6, s6 = await _bind_ipv6_all_ifaces(queue)
@@ -302,9 +287,7 @@ async def _send_query_all(transports, pkt: bytes):
 # ---------------- Public API ----------------
 
 
-async def browse_service(
-        service_type: str, timeout: float = 4.0
-) -> List[ServiceInstance]:
+async def browse_service(service_type: str, timeout: float = 4.0) -> list[ServiceInstance]:
     """
     Discover a DNS-SD/mDNS service type (e.g. "_remoted._tcp.local.") on the local network.
 
@@ -316,11 +299,11 @@ async def browse_service(
     transports, queue = await _open_mdns_sockets()
     adapters = _Adapters()
 
-    ptr_targets: Set[str] = set()
-    srv_map: Dict[str, Dict] = {}
-    txt_map: Dict[str, Dict] = {}
+    ptr_targets: set[str] = set()
+    srv_map: dict[str, dict] = {}
+    txt_map: dict[str, dict] = {}
     # host -> list[(ip, iface)]
-    host_addrs: Dict[str, List[Address]] = defaultdict(list)
+    host_addrs: dict[str, list[Address]] = defaultdict(list)
 
     def _record_addr(rr_name: str, ip_str: str, pkt_addr):
         # Determine family and possible scopeid from the packet that delivered this RR
@@ -335,16 +318,12 @@ async def browse_service(
             existing.append(Address(ip=ip_str, iface=iface))
 
     try:
-        await _send_query_all(
-            transports, build_query(service_type, QTYPE_PTR, unicast=False)
-        )
+        await _send_query_all(transports, build_query(service_type, QTYPE_PTR, unicast=False))
         loop = asyncio.get_running_loop()
         end = loop.time() + timeout
         while loop.time() < end:
             try:
-                data, pkt_addr = await asyncio.wait_for(
-                    queue.get(), timeout=end - loop.time()
-                )
+                data, pkt_addr = await asyncio.wait_for(queue.get(), timeout=end - loop.time())
             except asyncio.TimeoutError:
                 break
             for rr in parse_mdns_message(data):
@@ -358,16 +337,14 @@ async def browse_service(
                     }
                 elif t == QTYPE_TXT:
                     txt_map[rr["name"]] = rr.get("txt", {})
-                elif t == QTYPE_A and rr.get("address"):
-                    _record_addr(rr["name"], rr["address"], pkt_addr)
-                elif t == QTYPE_AAAA and rr.get("address"):
+                elif (t == QTYPE_A and rr.get("address")) or (t == QTYPE_AAAA and rr.get("address")):
                     _record_addr(rr["name"], rr["address"], pkt_addr)
     finally:
         for transport, _ in transports:
             transport.close()
 
     # Assemble dataclasses
-    results: List[ServiceInstance] = []
+    results: list[ServiceInstance] = []
     for inst in sorted(ptr_targets):
         srv = srv_map.get(inst, {})
         target = srv.get("target")

pymobiledevice3/ca.py

@@ -23,10 +23,7 @@ def select_hash_algorithm(device_version: Union[tuple[int, int, int], str, None]
     """
     if device_version is None:
         return hashes.SHA256()
-    if isinstance(device_version, str):
-        parts = tuple(int(x) for x in device_version.split("."))
-    else:
-        parts = device_version
+    parts = tuple(int(x) for x in device_version.split(".")) if isinstance(device_version, str) else device_version
     return hashes.SHA1() if parts < (4, 0, 0) else hashes.SHA256()
 
 
@@ -65,6 +62,7 @@ def serialize_private_key_pkcs8_pem(key: RSAPrivateKey) -> bytes:
 # Certificate builders (empty DN, v3, KU)
 # =======================================
 
+
 def build_root_certificate(root_key: RSAPrivateKey, alg: hashes.HashAlgorithm) -> Certificate:
     """
     Build a self-signed root (CA) certificate:
@@ -93,10 +91,10 @@ def build_root_certificate(root_key: RSAPrivateKey, alg: hashes.HashAlgorithm) -
 
 
 def build_host_certificate(
-        host_key: RSAPrivateKey,
-        root_cert: Certificate,
-        root_key: RSAPrivateKey,
-        alg: hashes.HashAlgorithm,
+    host_key: RSAPrivateKey,
+    root_cert: Certificate,
+    root_key: RSAPrivateKey,
+    alg: hashes.HashAlgorithm,
 ) -> Certificate:
     """
     Build the host (leaf) certificate signed by the root:
@@ -127,9 +125,13 @@ def build_host_certificate(
             x509.KeyUsage(
                 digital_signature=True,
                 key_encipherment=True,
-                key_cert_sign=False, crl_sign=False,
-                content_commitment=False, data_encipherment=False,
-                key_agreement=False, encipher_only=False, decipher_only=False,
+                key_cert_sign=False,
+                crl_sign=False,
+                content_commitment=False,
+                data_encipherment=False,
+                key_agreement=False,
+                encipher_only=False,
+                decipher_only=False,
             ),
             critical=True,
         )
@@ -138,10 +140,10 @@ def build_host_certificate(
 
 
 def build_device_certificate(
-        device_public_key: RSAPublicKey,
-        root_cert: Certificate,
-        root_key: RSAPrivateKey,
-        alg: hashes.HashAlgorithm,
+    device_public_key: RSAPublicKey,
+    root_cert: Certificate,
+    root_key: RSAPrivateKey,
+    alg: hashes.HashAlgorithm,
 ) -> Certificate:
     """
     Build the device certificate (leaf) signed by the root:
@@ -173,9 +175,13 @@ def build_device_certificate(
             x509.KeyUsage(
                 digital_signature=True,
                 key_encipherment=True,
-                key_cert_sign=False, crl_sign=False,
-                content_commitment=False, data_encipherment=False,
-                key_agreement=False, encipher_only=False, decipher_only=False,
+                key_cert_sign=False,
+                crl_sign=False,
+                content_commitment=False,
+                data_encipherment=False,
+                key_agreement=False,
+                encipher_only=False,
+                decipher_only=False,
             ),
             critical=True,
         )
@@ -188,10 +194,11 @@ def build_device_certificate(
 # Public API for your pairing flow (renamed)
 # ==========================================
 
+
 def generate_pairing_cert_chain(
-        device_public_key_pem: bytes,
-        private_key: Optional[RSAPrivateKey] = None,
-        device_version: Union[tuple[int, int, int], str, None] = (4, 0, 0),
+    device_public_key_pem: bytes,
+    private_key: Optional[RSAPrivateKey] = None,
+    device_version: Union[tuple[int, int, int], str, None] = (4, 0, 0),
 ) -> tuple[bytes, bytes, bytes, bytes, bytes]:
     """
     Generate a root→host certificate chain and a device certificate that mirror the
@@ -215,7 +222,7 @@ def generate_pairing_cert_chain(
     # Device leaf (public key provided by the device)
     dev_pub = load_pem_public_key(device_public_key_pem)
     if not isinstance(dev_pub, RSAPublicKey):
-        raise ValueError("device_public_key_pem must be an RSA PUBLIC KEY in PEM format")
+        raise TypeError("device_public_key_pem must be an RSA PUBLIC KEY in PEM format")
     device_cert = build_device_certificate(dev_pub, root_cert, root_key, alg)
 
     return (
@@ -277,6 +284,7 @@ def create_keybag_file(file: Path, common_name: str) -> None:
         private_key.private_bytes(
             encoding=serialization.Encoding.PEM,
             format=PrivateFormat.TraditionalOpenSSL,
-            encryption_algorithm=serialization.NoEncryption()
-        ) + cer.public_bytes(encoding=serialization.Encoding.PEM)
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        + cer.public_bytes(encoding=serialization.Encoding.PEM)
     )

pymobiledevice3/cli/activation.py

@@ -12,20 +12,20 @@ def cli() -> None:
 
 @cli.group()
 def activation() -> None:
-    """ Perform iCloud activation/deactivation or query the current state """
+    """Perform iCloud activation/deactivation or query the current state"""
     pass
 
 
 @activation.command(cls=Command)
 def state(service_provider: LockdownClient):
-    """ Get current activation state """
+    """Get current activation state"""
     print(MobileActivationService(service_provider).state)
 
 
 @activation.command(cls=Command)
-@click.option('--now', is_flag=True, help='do not wait for next nonce cycle')
+@click.option("--now", is_flag=True, help="do not wait for next nonce cycle")
 def activate(service_provider: LockdownClient, now):
-    """ Activate device """
+    """Activate device"""
     activation_service = MobileActivationService(service_provider)
     if not now:
         activation_service.wait_for_activation_session()
@@ -34,11 +34,11 @@ def activate(service_provider: LockdownClient, now):
 
 @activation.command(cls=Command)
 def deactivate(service_provider: LockdownClient):
-    """ Deactivate device """
+    """Deactivate device"""
     MobileActivationService(service_provider).deactivate()
 
 
 @activation.command(cls=Command)
 def itunes(service_provider: LockdownClient):
-    """ Tell the device that it has been connected to iTunes (useful for < iOS 4) """
-    service_provider.set_value(True, key='iTunesHasConnected')
+    """Tell the device that it has been connected to iTunes (useful for < iOS 4)"""
+    service_provider.set_value(True, key="iTunesHasConnected")

pymobiledevice3/cli/afc.py

@@ -13,44 +13,44 @@ def cli() -> None:
 
 @cli.group()
 def afc() -> None:
-    """ Manage device multimedia files """
+    """Manage device multimedia files"""
     pass
 
 
-@afc.command('shell', cls=Command)
+@afc.command("shell", cls=Command)
 def afc_shell(service_provider: LockdownClient):
-    """ open an AFC shell rooted at /var/mobile/Media """
+    """open an AFC shell rooted at /var/mobile/Media"""
     AfcShell.create(service_provider)
 
 
-@afc.command('pull', cls=Command)
-@click.option('-i', '--ignore-errors', is_flag=True, help='Ignore AFC pull errors')
-@click.argument('remote_file', type=click.Path(exists=False))
-@click.argument('local_file', type=click.Path(exists=False))
+@afc.command("pull", cls=Command)
+@click.option("-i", "--ignore-errors", is_flag=True, help="Ignore AFC pull errors")
+@click.argument("remote_file", type=click.Path(exists=False))
+@click.argument("local_file", type=click.Path(exists=False))
 def afc_pull(service_provider: LockdownServiceProvider, remote_file: str, local_file: str, ignore_errors: bool) -> None:
-    """ pull remote file from /var/mobile/Media """
+    """pull remote file from /var/mobile/Media"""
     AfcService(lockdown=service_provider).pull(remote_file, local_file, ignore_errors=ignore_errors)
 
 
-@afc.command('push', cls=Command)
-@click.argument('local_file', type=click.Path(exists=False))
-@click.argument('remote_file', type=click.Path(exists=False))
+@afc.command("push", cls=Command)
+@click.argument("local_file", type=click.Path(exists=False))
+@click.argument("remote_file", type=click.Path(exists=False))
 def afc_push(service_provider: LockdownServiceProvider, local_file: str, remote_file: str) -> None:
-    """ push local file into /var/mobile/Media """
+    """push local file into /var/mobile/Media"""
     AfcService(lockdown=service_provider).push(local_file, remote_file)
 
 
-@afc.command('ls', cls=Command)
-@click.argument('remote_file', type=click.Path(exists=False))
-@click.option('-r', '--recursive', is_flag=True)
+@afc.command("ls", cls=Command)
+@click.argument("remote_file", type=click.Path(exists=False))
+@click.option("-r", "--recursive", is_flag=True)
 def afc_ls(service_provider: LockdownClient, remote_file, recursive):
-    """ perform a dirlist rooted at /var/mobile/Media """
+    """perform a dirlist rooted at /var/mobile/Media"""
     for path in AfcService(lockdown=service_provider).dirlist(remote_file, -1 if recursive else 1):
         print(path)
 
 
-@afc.command('rm', cls=Command)
-@click.argument('remote_file', type=click.Path(exists=False))
+@afc.command("rm", cls=Command)
+@click.argument("remote_file", type=click.Path(exists=False))
 def afc_rm(service_provider: LockdownClient, remote_file):
-    """ remove a file rooted at /var/mobile/Media """
+    """remove a file rooted at /var/mobile/Media"""
     AfcService(lockdown=service_provider).rm(remote_file)

pymobiledevice3/cli/amfi.py

@@ -16,23 +16,23 @@ def cli() -> None:
 
 @cli.group()
 def amfi() -> None:
-    """ Enable developer-mode or query its state """
+    """Enable developer-mode or query its state"""
     pass
 
 
 @amfi.command(cls=Command)
 def reveal_developer_mode(service_provider: LockdownClient):
-    """ reveal developer mode option in device's UI """
+    """reveal developer mode option in device's UI"""
     AmfiService(service_provider).reveal_developer_mode_option_in_ui()
 
 
 @amfi.command(cls=Command)
 def enable_developer_mode(service_provider: LockdownClient):
-    """ enable developer mode """
+    """enable developer mode"""
     AmfiService(service_provider).enable_developer_mode()
 
 
 @amfi.command(cls=Command)
 def developer_mode_status(service_provider: LockdownClient):
-    """ query developer mode status """
+    """query developer mode status"""
     print_json(service_provider.developer_mode_status)

pymobiledevice3/cli/apps.py

@@ -14,73 +14,85 @@ def cli() -> None:
 
 @cli.group()
 def apps() -> None:
-    """ Manage installed applications """
+    """Manage installed applications"""
     pass
 
 
-@apps.command('list', cls=Command)
-@click.option('app_type', '-t', '--type', type=click.Choice(['System', 'User', 'Hidden', 'Any']), default='Any',
-              help='include only applications of given type')
-@click.option('--calculate-sizes/--no-calculate-size', default=False)
+@apps.command("list", cls=Command)
+@click.option(
+    "app_type",
+    "-t",
+    "--type",
+    type=click.Choice(["System", "User", "Hidden", "Any"]),
+    default="Any",
+    help="include only applications of given type",
+)
+@click.option("--calculate-sizes/--no-calculate-size", default=False)
 def apps_list(service_provider: LockdownServiceProvider, app_type: str, calculate_sizes: bool) -> None:
-    """ list installed apps """
-    print_json(InstallationProxyService(lockdown=service_provider).get_apps(application_type=app_type,
-                                                                            calculate_sizes=calculate_sizes))
+    """list installed apps"""
+    print_json(
+        InstallationProxyService(lockdown=service_provider).get_apps(
+            application_type=app_type, calculate_sizes=calculate_sizes
+        )
+    )
 
 
-@apps.command('query', cls=Command)
-@click.argument('bundle_identifiers', nargs=-1)
-@click.option('--calculate-sizes/--no-calculate-size', default=False)
+@apps.command("query", cls=Command)
+@click.argument("bundle_identifiers", nargs=-1)
+@click.option("--calculate-sizes/--no-calculate-size", default=False)
 def apps_query(service_provider: LockdownServiceProvider, bundle_identifiers: list[str], calculate_sizes: bool) -> None:
-    """ query installed apps """
-    print_json(InstallationProxyService(lockdown=service_provider)
-               .get_apps(calculate_sizes=calculate_sizes, bundle_identifiers=bundle_identifiers))
+    """query installed apps"""
+    print_json(
+        InstallationProxyService(lockdown=service_provider).get_apps(
+            calculate_sizes=calculate_sizes, bundle_identifiers=bundle_identifiers
+        )
+    )
 
 
-@apps.command('uninstall', cls=Command)
-@click.argument('bundle_id')
+@apps.command("uninstall", cls=Command)
+@click.argument("bundle_id")
 def uninstall(service_provider: LockdownClient, bundle_id):
-    """ uninstall app by given bundle_id """
+    """uninstall app by given bundle_id"""
     InstallationProxyService(lockdown=service_provider).uninstall(bundle_id)
 
 
-@apps.command('install', cls=Command)
-@click.option('--developer', is_flag=True, help='Install developer package')
-@click.argument('package', type=click.Path(exists=True))
+@apps.command("install", cls=Command)
+@click.option("--developer", is_flag=True, help="Install developer package")
+@click.argument("package", type=click.Path(exists=True))
 def install(service_provider: LockdownServiceProvider, package: str, developer: bool) -> None:
-    """ install given .ipa/.app/.ipcc """
+    """install given .ipa/.app/.ipcc"""
     InstallationProxyService(lockdown=service_provider).install_from_local(package, developer=developer)
 
 
-@apps.command('afc', cls=Command)
-@click.option('--documents', is_flag=True)
-@click.argument('bundle_id')
+@apps.command("afc", cls=Command)
+@click.option("--documents", is_flag=True)
+@click.argument("bundle_id")
 def afc(service_provider: LockdownClient, bundle_id: str, documents: bool):
-    """ open an AFC shell for given bundle_id, assuming its profile is installed """
+    """open an AFC shell for given bundle_id, assuming its profile is installed"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id, documents_only=documents).shell()
 
 
-@apps.command('pull', cls=Command)
-@click.argument('bundle_id')
-@click.argument('remote_file', type=click.Path(exists=False))
-@click.argument('local_file', type=click.Path(exists=False))
+@apps.command("pull", cls=Command)
+@click.argument("bundle_id")
+@click.argument("remote_file", type=click.Path(exists=False))
+@click.argument("local_file", type=click.Path(exists=False))
 def pull(service_provider: LockdownClient, bundle_id: str, remote_file: str, local_file: str):
-    """ pull remote file from specified bundle_id """
+    """pull remote file from specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).pull(remote_file, local_file)
 
 
-@apps.command('push', cls=Command)
-@click.argument('bundle_id')
-@click.argument('local_file', type=click.Path(exists=False))
-@click.argument('remote_file', type=click.Path(exists=False))
+@apps.command("push", cls=Command)
+@click.argument("bundle_id")
+@click.argument("local_file", type=click.Path(exists=False))
+@click.argument("remote_file", type=click.Path(exists=False))
 def push(service_provider: LockdownClient, bundle_id: str, local_file: str, remote_file: str):
-    """ push local file into specified bundle_id """
+    """push local file into specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).push(local_file, remote_file)
 
 
-@apps.command('rm', cls=Command)
-@click.argument('bundle_id')
-@click.argument('remote_file', type=click.Path(exists=False))
+@apps.command("rm", cls=Command)
+@click.argument("bundle_id")
+@click.argument("remote_file", type=click.Path(exists=False))
 def rm(service_provider: LockdownClient, bundle_id: str, remote_file: str):
-    """ remove remote file from specified bundle_id """
+    """remove remote file from specified bundle_id"""
     HouseArrestService(lockdown=service_provider, bundle_id=bundle_id).rm(remote_file)