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

pymobiledevice3/lockdown_service_provider.py

@@ -1,7 +1,7 @@
 import datetime
 import logging
 from abc import abstractmethod
-from typing import Optional
+from typing import Any, Optional
 
 from pymobiledevice3.exceptions import StartServiceError
 from pymobiledevice3.service_connection import ServiceConnection
@@ -17,6 +17,11 @@ class LockdownServiceProvider:
     def product_version(self) -> str:
         pass
 
+    @property
+    @abstractmethod
+    def product_build_version(self) -> str:
+        pass
+
     @property
     @abstractmethod
     def ecid(self) -> int:
@@ -41,17 +46,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

@@ -11,25 +11,38 @@ DEFAULT_INTERVAL_SEC = 3
 DEFAULT_MAX_FAILS = 3
 
 
+def is_wsl() -> bool:
+    try:
+        with open("/proc/version") as f:
+            version_info = f.read()
+            return "Microsoft" in version_info or "WSL" in version_info
+    except FileNotFoundError:
+        return False
+
+
 class OsUtils:
     _instance = None
     _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':
-                from pymobiledevice3.osu.posix_util import Linux
-                cls._instance = Linux()
-            elif cls._os_name == 'cygwin':
+            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":
                 from pymobiledevice3.osu.posix_util import Cygwin
+
                 cls._instance = Cygwin()
             else:
                 raise OSNotSupportedError(cls._os_name)
@@ -62,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,24 +77,35 @@ 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):
     @property
     def usbmux_address(self) -> tuple[str, int]:
         return MuxConnection.ITUNES_HOST, socket.AF_INET
+
+
+class Wsl(Linux):
+    @property
+    def usbmux_address(self) -> tuple[str, int]:
+        return MuxConnection.ITUNES_HOST, socket.AF_INET

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,19 +15,55 @@ 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.
+
+    :param hostname: The hostname to use for generating the host ID.
+                     If None, the current hostname is used.
+    :type hostname: str, optional
+    :return: The generated host ID.
+    :rtype: str
+    """
     hostname = platform.node() if hostname is None else hostname
     host_id = uuid.uuid3(uuid.NAMESPACE_DNS, hostname)
     return str(host_id).upper()
 
 
+def get_usbmux_pairing_record(identifier: str, usbmux_address: Optional[str] = None):
+    """
+    Retrieve the pairing record from usbmuxd.
+
+    :param identifier: The identifier of the device.
+    :type identifier: str
+    :param usbmux_address: The address of the usbmuxd server.
+    :type usbmux_address: Optional[str], optional
+    :return: The pairing record if found, otherwise None.
+    :rtype: dict or None
+    """
+    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
+
+
 def get_itunes_pairing_record(identifier: str) -> Optional[dict]:
-    filename = OSUTILS.pair_record_path / f'{identifier}.plist'
+    """
+    Retrieve the pairing record from iTunes.
+
+    :param identifier: The identifier of the device.
+    :type identifier: str
+    :return: The pairing record if found, otherwise None.
+    :rtype: Optional[dict]
+    """
+    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
@@ -35,30 +71,46 @@ def get_itunes_pairing_record(identifier: str) -> Optional[dict]:
 
 
 def get_local_pairing_record(identifier: str, pairing_records_cache_folder: Path) -> Optional[dict]:
-    logger.debug('Looking for pymobiledevice3 pairing record')
-    path = pairing_records_cache_folder / f'{identifier}.{PAIRING_RECORD_EXT}'
+    """
+    Retrieve the pairing record from local storage.
+
+    :param identifier: The identifier of the device.
+    :type identifier: str
+    :param pairing_records_cache_folder: The path to the local pairing records cache folder.
+    :type 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}"
     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 to connected device by following order:
+    Look for an existing pair record for the connected device in the following order:
     - usbmuxd
     - iTunes
     - local storage
-    """
 
+    :param identifier: The identifier of the device.
+    :type identifier: str
+    :param pairing_records_cache_folder: The path to the local pairing records cache folder.
+    :type pairing_records_cache_folder: Path
+    :param usbmux_address: The address of the usbmuxd server.
+    :type usbmux_address: Optional[str], optional
+    :return: The preferred pairing record.
+    :rtype: dict
+    """
     # usbmuxd
-    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
+    pair_record = get_usbmux_pairing_record(identifier=identifier, usbmux_address=usbmux_address)
+    if pair_record is not None:
+        return pair_record
 
     # iTunes
     pair_record = get_itunes_pairing_record(identifier)
@@ -69,7 +121,16 @@ 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.
+
+    :param pairing_records_cache_folder: The path to the local pairing records cache folder.
+                                         If None, the home folder is used.
+    :type pairing_records_cache_folder: Path, optional
+    :return: The path to the pairing records cache folder.
+    :rtype: Path
+    """
     if pairing_records_cache_folder is None:
         pairing_records_cache_folder = get_home_folder()
     else:
@@ -79,13 +140,33 @@ def create_pairing_records_cache_folder(pairing_records_cache_folder: Path = Non
 
 
 def get_remote_pairing_record_filename(identifier: str) -> str:
-    return f'remote_{identifier}'
+    """
+    Generate the filename for the remote pairing record.
+
+    :param identifier: The identifier of the device.
+    :type identifier: str
+    :return: The filename for the remote pairing record.
+    :rtype: str
+    """
+    return f"remote_{identifier}"
 
 
 def iter_remote_pair_records() -> Generator[Path, None, None]:
-    return get_home_folder().glob('remote_*')
+    """
+    Iterate over the remote pairing records in the home folder.
+
+    :return: A generator yielding paths to the remote pairing records.
+    :rtype: Generator[Path, None, None]
+    """
+    return get_home_folder().glob("remote_*")
 
 
 def iter_remote_paired_identifiers() -> Generator[str, None, None]:
+    """
+    Iterate over the identifiers of the remote paired devices.
+
+    :return: A generator yielding the identifiers of the remote paired devices.
+    :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

@@ -1,11 +1,15 @@
+import sys
 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,
+            },
+        )