pymobiledevice3 4.27.4__py3-none-any.whl → 5.1.2__py3-none-any.whl

misc/plist_sniffer.py

@@ -7,8 +7,8 @@ import click
 from scapy.packet import Packet, Raw
 from scapy.sendrecv import sniff
 
-BPLIST_MAGIC = b'bplist'
-PLIST_MAGIC = b'<plist'
+BPLIST_MAGIC = b"bplist"
+PLIST_MAGIC = b"<plist"
 
 
 class PcapSniffer:
@@ -20,13 +20,13 @@ class PcapSniffer:
 
         if BPLIST_MAGIC in packet:
             try:
-                plist = plistlib.loads(packet[packet.find(BPLIST_MAGIC):])
+                plist = plistlib.loads(packet[packet.find(BPLIST_MAGIC) :])
                 self.report(plist)
             except plistlib.InvalidFileException:
                 pass
         if PLIST_MAGIC in packet:
             try:
-                plist = plistlib.loads(packet[packet.find(PLIST_MAGIC):])
+                plist = plistlib.loads(packet[packet.find(PLIST_MAGIC) :])
                 self.report(plist)
             except xml.parsers.expat.ExpatError:
                 pass
@@ -35,37 +35,37 @@ class PcapSniffer:
         try:
             print(plist)
             if self.file is not None:
-                self.file.write('---\n')
+                self.file.write("---\n")
                 self.file.write(pprint.pformat(plist))
-                self.file.write('\n---\n')
+                self.file.write("\n---\n")
         except ValueError:
-            print('failed to print plist')
+            print("failed to print plist")
 
 
 @click.group()
 def cli():
-    """ Parse RemoteXPC traffic """
+    """Parse RemoteXPC traffic"""
     pass
 
 
 @cli.command()
-@click.argument('pcap', type=click.Path(exists=True, file_okay=True, dir_okay=False))
-@click.option('-o', '--out', type=click.File('wt'))
+@click.argument("pcap", type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.option("-o", "--out", type=click.File("wt"))
 def offline(pcap: str, out: IO):
-    """ Parse plists traffic from a .pcap file """
+    """Parse plists traffic from a .pcap file"""
     sniffer = PcapSniffer(out)
     for p in sniff(offline=pcap):
         sniffer.process_packet(p)
 
 
 @cli.command()
-@click.argument('iface')
-@click.option('-o', '--out', type=click.File('wt'))
+@click.argument("iface")
+@click.option("-o", "--out", type=click.File("wt"))
 def live(iface: str, out: IO):
-    """ Parse plists live from a given network interface """
+    """Parse plists live from a given network interface"""
     sniffer = PcapSniffer(out)
     sniff(iface=iface, prn=sniffer.process_packet)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     cli()

misc/remotexpc_sniffer.py

@@ -22,7 +22,7 @@ FRAME_HEADER_SIZE = 9
 
 
 def create_stream_key(src: str, sport: int, dst: str, dport: int) -> str:
-    return f'{src}/{sport}//{dst}/{dport}'
+    return f"{src}/{sport}//{dst}/{dport}"
 
 
 class TCPStream:
@@ -37,7 +37,7 @@ class TCPStream:
         self.segments = {}  # data segments to add later
 
     def __repr__(self) -> str:
-        return f'Stream<{self.key}>'
+        return f"Stream<{self.key}>"
 
     def __len__(self) -> int:
         return len(self.data)
@@ -58,12 +58,12 @@ class TCPStream:
             return False
         else:
             # if this data is in order (has a place to be inserted)
-            self.data[seq_offset:seq_offset + data_len] = data
+            self.data[seq_offset : seq_offset + data_len] = data
             # check if there are any waiting data segments to add
             for seq_offset in sorted(self.segments.keys()):
                 if seq_offset <= len(self.data):  # if we can add this segment to the stream
                     segment_payload = self.segments[seq_offset]
-                    self.data[seq_offset:seq_offset + len(segment_payload)] = segment_payload
+                    self.data[seq_offset : seq_offset + len(segment_payload)] = segment_payload
                     self.segments.pop(seq_offset)
                 else:
                     break  # short circuit because list is sorted
@@ -72,12 +72,12 @@ class TCPStream:
 
 class H2Stream(TCPStream):
     def pop_frames(self) -> list[Frame]:
-        """ Pop all available H2Frames """
+        """Pop all available H2Frames"""
 
         # If self.data starts with the http/2 magic bytes, pop them off
         if self.data.startswith(HTTP2_MAGIC):
-            logger.debug('HTTP/2 magic bytes')
-            self.data = self.data[len(HTTP2_MAGIC):]
+            logger.debug("HTTP/2 magic bytes")
+            self.data = self.data[len(HTTP2_MAGIC) :]
             self.seq += len(HTTP2_MAGIC)
 
         frames = []
@@ -120,13 +120,14 @@ class RemoteXPCSniffer:
         tcp_pkt = pkt[TCP]
         stream_key = create_stream_key(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport)
         stream = self._h2_streams.setdefault(
-            stream_key, H2Stream(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport))
+            stream_key, H2Stream(net_pkt.src, tcp_pkt.sport, net_pkt.dst, tcp_pkt.dport)
+        )
         stream_finished_assembling = stream.add(tcp_pkt)
         if stream_finished_assembling:  # if we just added something in order
             self._process_stream(stream)
 
     def _handle_data_frame(self, stream: H2Stream, frame: DataFrame) -> None:
-        previous_frame_data = self._previous_frame_data.get(stream.key, b'')
+        previous_frame_data = self._previous_frame_data.get(stream.key, b"")
         try:
             payload = XpcWrapper.parse(previous_frame_data + frame.data).message.payload
             if payload is None:
@@ -134,10 +135,11 @@ class RemoteXPCSniffer:
             xpc_message = decode_xpc_object(payload.obj)
         except ConstError:  # if we don't know what this payload is
             logger.debug(
-                f'New Data frame {stream.src}->{stream.dst} on HTTP/2 stream {frame.stream_id} TCP port {stream.dport}')
+                f"New Data frame {stream.src}->{stream.dst} on HTTP/2 stream {frame.stream_id} TCP port {stream.dport}"
+            )
             hexdump(frame.data[:64])
             if len(frame.data) > 64:
-                logger.debug(f'... {len(frame.data)} bytes')
+                logger.debug(f"... {len(frame.data)} bytes")
             return
         except StreamError:
             self._previous_frame_data[stream.key] = previous_frame_data + frame.data
@@ -149,27 +151,26 @@ class RemoteXPCSniffer:
         if xpc_message is None:
             return
 
-        logger.info(f'As Python Object (#{frame.stream_id}): {pformat(xpc_message)}')
+        logger.info(f"As Python Object (#{frame.stream_id}): {pformat(xpc_message)}")
 
         # print `pairingData` if exists, since it contains an inner struct
-        if 'value' not in xpc_message:
+        if "value" not in xpc_message:
             return
-        message = xpc_message['value']['message']
-        if 'plain' not in message:
+        message = xpc_message["value"]["message"]
+        if "plain" not in message:
             return
-        plain = message['plain']['_0']
-        if 'event' not in plain:
+        plain = message["plain"]["_0"]
+        if "event" not in plain:
             return
-        pairing_data = plain['event']['_0']['pairingData']['_0']['data']
+        pairing_data = plain["event"]["_0"]["pairingData"]["_0"]["data"]
         logger.info(PairingDataComponentTLVBuf.parse(pairing_data))
 
     def _handle_single_frame(self, stream: H2Stream, frame: Frame) -> None:
-        logger.debug(f'New HTTP/2 frame: {stream.key} ({frame})')
+        logger.debug(f"New HTTP/2 frame: {stream.key} ({frame})")
         if isinstance(frame, HeadersFrame):
-            logger.debug(
-                f'{stream.src} opening stream {frame.stream_id} for communication on port {stream.dport}')
+            logger.debug(f"{stream.src} opening stream {frame.stream_id} for communication on port {stream.dport}")
         elif isinstance(frame, GoAwayFrame):
-            logger.debug(f'{stream.src} closing stream {frame.stream_id} on port {stream.sport}')
+            logger.debug(f"{stream.src} closing stream {frame.stream_id} on port {stream.sport}")
         elif isinstance(frame, DataFrame):
             self._handle_data_frame(stream, frame)
 
@@ -180,27 +181,27 @@ class RemoteXPCSniffer:
 
 @click.group()
 def cli():
-    """ Parse RemoteXPC traffic """
+    """Parse RemoteXPC traffic"""
     pass
 
 
 @cli.command()
-@click.argument('file', type=click.Path(exists=True, file_okay=True, dir_okay=False))
+@click.argument("file", type=click.Path(exists=True, file_okay=True, dir_okay=False))
 def offline(file: str):
-    """ Parse RemoteXPC traffic from a .pcap file """
+    """Parse RemoteXPC traffic from a .pcap file"""
     sniffer = RemoteXPCSniffer()
     for p in sniff(offline=file):
         sniffer.process_packet(p)
 
 
 @cli.command()
-@click.argument('iface')
+@click.argument("iface")
 def live(iface: str):
-    """ Parse RemoteXPC live from a given network interface """
+    """Parse RemoteXPC live from a given network interface"""
     sniffer = RemoteXPCSniffer()
     sniff(iface=iface, prn=sniffer.process_packet)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     coloredlogs.install(level=logging.DEBUG)
     cli()

pymobiledevice3/__main__.py

@@ -13,34 +13,53 @@ import click
 import coloredlogs
 
 from pymobiledevice3.cli.cli_common import TUNNEL_ENV_VAR, isatty
-from pymobiledevice3.exceptions import AccessDeniedError, CloudConfigurationAlreadyPresentError, \
-    ConnectionFailedError, ConnectionFailedToUsbmuxdError, DeprecationError, DeveloperModeError, \
-    DeveloperModeIsNotEnabledError, DeviceHasPasscodeSetError, DeviceNotFoundError, FeatureNotSupportedError, \
-    InternalError, InvalidServiceError, MessageNotSupportedError, MissingValueError, NoDeviceConnectedError, \
-    NotEnoughDiskSpaceError, NotPairedError, OSNotSupportedError, PairingDialogResponsePendingError, \
-    PasswordRequiredError, QuicProtocolNotSupportedError, RSDRequiredError, SetProhibitedError, \
-    TunneldConnectionError, UserDeniedPairingError
+from pymobiledevice3.exceptions import (
+    AccessDeniedError,
+    CloudConfigurationAlreadyPresentError,
+    ConnectionFailedError,
+    ConnectionFailedToUsbmuxdError,
+    DeprecationError,
+    DeveloperModeError,
+    DeveloperModeIsNotEnabledError,
+    DeviceHasPasscodeSetError,
+    DeviceNotFoundError,
+    FeatureNotSupportedError,
+    InternalError,
+    InvalidServiceError,
+    MessageNotSupportedError,
+    MissingValueError,
+    NoDeviceConnectedError,
+    NotEnoughDiskSpaceError,
+    NotPairedError,
+    OSNotSupportedError,
+    PairingDialogResponsePendingError,
+    PasswordRequiredError,
+    QuicProtocolNotSupportedError,
+    RSDRequiredError,
+    SetProhibitedError,
+    TunneldConnectionError,
+    UserDeniedPairingError,
+)
 from pymobiledevice3.lockdown import retry_create_using_usbmux
 from pymobiledevice3.osu.os_utils import get_os_utils
 
 coloredlogs.install(level=logging.INFO)
 
-logging.getLogger('quic').disabled = True
-logging.getLogger('asyncio').disabled = True
-logging.getLogger('zeroconf').disabled = True
-logging.getLogger('parso.cache').disabled = True
-logging.getLogger('parso.cache.pickle').disabled = True
-logging.getLogger('parso.python.diff').disabled = True
-logging.getLogger('humanfriendly.prompts').disabled = True
-logging.getLogger('blib2to3.pgen2.driver').disabled = True
-logging.getLogger('urllib3.connectionpool').disabled = True
+logging.getLogger("quic").disabled = True
+logging.getLogger("asyncio").disabled = True
+logging.getLogger("parso.cache").disabled = True
+logging.getLogger("parso.cache.pickle").disabled = True
+logging.getLogger("parso.python.diff").disabled = True
+logging.getLogger("humanfriendly.prompts").disabled = True
+logging.getLogger("blib2to3.pgen2.driver").disabled = True
+logging.getLogger("urllib3.connectionpool").disabled = True
 
 logger = logging.getLogger(__name__)
 
 # For issue https://github.com/doronz88/pymobiledevice3/issues/1217, details: https://bugs.python.org/issue37373
-if sys.platform == 'win32':
+if sys.platform == "win32":
     with warnings.catch_warnings():
-        warnings.simplefilter('ignore', category=DeprecationWarning)
+        warnings.simplefilter("ignore", category=DeprecationWarning)
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 INVALID_SERVICE_MESSAGE = """Failed to start service. Possible reasons are:
@@ -62,36 +81,36 @@ INVALID_SERVICE_MESSAGE = """Failed to start service. Possible reasons are:
   https://github.com/doronz88/pymobiledevice3/issues/new?assignees=&labels=&projects=&template=bug_report.md&title=
 """
 
-CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'], max_content_width=400)
+CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"], "max_content_width": 400}
 
 # Mapping of index options to import file names
 CLI_GROUPS = {
-    'activation': 'activation',
-    'afc': 'afc',
-    'amfi': 'amfi',
-    'apps': 'apps',
-    'backup2': 'backup',
-    'bonjour': 'bonjour',
-    'companion': 'companion_proxy',
-    'crash': 'crash',
-    'developer': 'developer',
-    'diagnostics': 'diagnostics',
-    'lockdown': 'lockdown',
-    'mounter': 'mounter',
-    'notification': 'notification',
-    'pcap': 'pcap',
-    'power-assertion': 'power_assertion',
-    'processes': 'processes',
-    'profile': 'profile',
-    'provision': 'provision',
-    'remote': 'remote',
-    'restore': 'restore',
-    'springboard': 'springboard',
-    'syslog': 'syslog',
-    'usbmux': 'usbmux',
-    'webinspector': 'webinspector',
-    'version': 'version',
-    'install-completions': 'completions',
+    "activation": "activation",
+    "afc": "afc",
+    "amfi": "amfi",
+    "apps": "apps",
+    "backup2": "backup",
+    "bonjour": "bonjour",
+    "companion": "companion_proxy",
+    "crash": "crash",
+    "developer": "developer",
+    "diagnostics": "diagnostics",
+    "lockdown": "lockdown",
+    "mounter": "mounter",
+    "notification": "notification",
+    "pcap": "pcap",
+    "power-assertion": "power_assertion",
+    "processes": "processes",
+    "profile": "profile",
+    "provision": "provision",
+    "remote": "remote",
+    "restore": "restore",
+    "springboard": "springboard",
+    "syslog": "syslog",
+    "usbmux": "usbmux",
+    "webinspector": "webinspector",
+    "version": "version",
+    "install-completions": "completions",
 }
 
 # Set if used the `--reconnect` option
@@ -103,26 +122,26 @@ class Pmd3Cli(click.Group):
         return CLI_GROUPS.keys()
 
     def get_command(self, ctx: click.Context, name: str) -> click.Command:
-        if name not in CLI_GROUPS.keys():
+        if name not in CLI_GROUPS:
             self.handle_invalid_command(ctx, name)
         return self.import_and_get_command(ctx, name)
 
     def handle_invalid_command(self, ctx: click.Context, name: str) -> None:
         suggested_commands = self.search_commands(name)
         suggestion = self.format_suggestions(suggested_commands)
-        ctx.fail(f'No such command {name!r}{suggestion}')
+        ctx.fail(f"No such command {name!r}{suggestion}")
 
     @staticmethod
     def format_suggestions(suggestions: list[str]) -> str:
         if not suggestions:
-            return ''
-        cmds = textwrap.indent('\n'.join(suggestions), ' ' * 4)
-        return f'\nDid you mean this?\n{cmds}'
+            return ""
+        cmds = textwrap.indent("\n".join(suggestions), " " * 4)
+        return f"\nDid you mean this?\n{cmds}"
 
     @staticmethod
     def import_and_get_command(ctx: click.Context, name: str) -> click.Command:
-        module_name = f'pymobiledevice3.cli.{CLI_GROUPS[name]}'
-        mod = __import__(module_name, None, None, ['cli'])
+        module_name = f"pymobiledevice3.cli.{CLI_GROUPS[name]}"
+        mod = __import__(module_name, None, None, ["cli"])
         command = mod.cli.get_command(ctx, name)
         if not command:
             command_name = mod.cli.list_commands(ctx)[0]
@@ -131,20 +150,20 @@ class Pmd3Cli(click.Group):
 
     @staticmethod
     def highlight_keyword(text: str, keyword: str) -> str:
-        return re.sub(f'({keyword})', click.style('\\1', bold=True), text, flags=re.IGNORECASE)
+        return re.sub(f"({keyword})", click.style("\\1", bold=True), text, flags=re.IGNORECASE)
 
     @staticmethod
     def collect_commands(command: click.Command) -> Union[str, list[str]]:
         commands = []
         if isinstance(command, click.Group):
-            for k, v in command.commands.items():
+            for _k, v in command.commands.items():
                 cmd = Pmd3Cli.collect_commands(v)
                 if isinstance(cmd, list):
-                    commands.extend([f'{command.name} {c}' for c in cmd])
+                    commands.extend([f"{command.name} {c}" for c in cmd])
                 else:
-                    commands.append(f'{command.name} {cmd}')
+                    commands.append(f"{command.name} {cmd}")
             return commands
-        return f'{command.name}'
+        return f"{command.name}"
 
     @staticmethod
     def search_commands(pattern: str) -> list[str]:
@@ -159,9 +178,9 @@ class Pmd3Cli(click.Group):
     @staticmethod
     def load_all_commands() -> list[str]:
         all_commands = []
-        for key in CLI_GROUPS.keys():
-            module_name = f'pymobiledevice3.cli.{CLI_GROUPS[key]}'
-            mod = __import__(module_name, None, None, ['cli'])
+        for key in CLI_GROUPS:
+            module_name = f"pymobiledevice3.cli.{CLI_GROUPS[key]}"
+            mod = __import__(module_name, None, None, ["cli"])
             cmd = Pmd3Cli.collect_commands(mod.cli.commands[key])
             if isinstance(cmd, list):
                 all_commands.extend(cmd)
@@ -171,7 +190,7 @@ class Pmd3Cli(click.Group):
 
 
 @click.command(cls=Pmd3Cli, context_settings=CONTEXT_SETTINGS)
-@click.option('--reconnect', is_flag=True, default=False, help='Reconnect to device when disconnected.')
+@click.option("--reconnect", is_flag=True, default=False, help="Reconnect to device when disconnected.")
 def cli(reconnect: bool) -> None:
     """
     \b
@@ -191,81 +210,87 @@ def invoke_cli_with_error_handling() -> bool:
     try:
         cli()
     except NoDeviceConnectedError:
-        logger.error('Device is not connected')
+        logger.error("Device is not connected")
         return True
     except ConnectionAbortedError:
-        logger.error('Device was disconnected')
+        logger.error("Device was disconnected")
         return True
     except NotPairedError:
-        logger.error('Device is not paired')
+        logger.error("Device is not paired")
     except UserDeniedPairingError:
-        logger.error('User refused to trust this computer')
+        logger.error("User refused to trust this computer")
     except PairingDialogResponsePendingError:
-        logger.error('Waiting for user dialog approval')
+        logger.error("Waiting for user dialog approval")
     except SetProhibitedError:
-        logger.error('lockdownd denied the access')
+        logger.error("lockdownd denied the access")
     except MissingValueError:
-        logger.error('No such value')
+        logger.error("No such value")
     except DeviceHasPasscodeSetError:
-        logger.error('Cannot enable developer-mode when passcode is set')
-    except DeveloperModeError as e:
-        logger.error(f'Failed to enable developer-mode. Error: {e}')
+        logger.error("Cannot enable developer-mode when passcode is set")
+    except DeveloperModeError:
+        logger.error("Failed to enable developer-mode.")
     except ConnectionFailedToUsbmuxdError:
-        logger.error('Failed to connect to usbmuxd socket. Make sure it\'s running.')
+        logger.error("Failed to connect to usbmuxd socket. Make sure it's running.")
     except ConnectionFailedError:
-        logger.error('Failed to connect to service port.')
+        logger.error("Failed to connect to service port.")
         return True
     except MessageNotSupportedError:
-        logger.error('Message not supported for this iOS version')
+        logger.error("Message not supported for this iOS version")
         traceback.print_exc()
     except InternalError:
-        logger.error('Internal Error')
+        logger.error("Internal Error")
     except DeveloperModeIsNotEnabledError:
-        logger.error('Developer Mode is disabled. You can try to enable it using: '
-                     'python3 -m pymobiledevice3 amfi enable-developer-mode')
+        logger.error(
+            "Developer Mode is disabled. You can try to enable it using: "
+            "python3 -m pymobiledevice3 amfi enable-developer-mode"
+        )
     except (InvalidServiceError, RSDRequiredError) as e:
         should_retry_over_tunneld = False
         if isinstance(e, RSDRequiredError):
-            logger.warning('Trying again over tunneld since RSD is required for this command')
+            logger.warning("Trying again over tunneld since RSD is required for this command")
             should_retry_over_tunneld = True
-        elif (e.identifier is not None) and ('developer' in sys.argv) and ('--tunnel' not in sys.argv):
-            logger.warning('Got an InvalidServiceError. Trying again over tunneld since it is a developer command')
+        elif (e.identifier is not None) and ("developer" in sys.argv) and ("--tunnel" not in sys.argv):
+            logger.warning("Got an InvalidServiceError. Trying again over tunneld since it is a developer command")
             should_retry_over_tunneld = True
         if should_retry_over_tunneld:
             # use a single space because click will ignore envvars of empty strings
-            os.environ[TUNNEL_ENV_VAR] = e.identifier or ' '
+            os.environ[TUNNEL_ENV_VAR] = e.identifier or " "
             return main()
         logger.error(INVALID_SERVICE_MESSAGE)
     except PasswordRequiredError:
-        logger.error('Device is password protected. Please unlock and retry')
+        logger.error("Device is password protected. Please unlock and retry")
     except AccessDeniedError:
         logger.error(get_os_utils().access_denied_error)
     except BrokenPipeError:
         traceback.print_exc()
     except TunneldConnectionError:
         logger.error(
-            'Unable to connect to Tunneld. You can start one using:\n'
-            'sudo python3 -m pymobiledevice3 remote tunneld')
+            "Unable to connect to Tunneld. You can start one using:\nsudo python3 -m pymobiledevice3 remote tunneld"
+        )
     except DeviceNotFoundError as e:
-        logger.error(f'Device not found: {e.udid}')
+        logger.error(f"Device not found: {e.udid}")
     except NotEnoughDiskSpaceError:
-        logger.error('Not enough disk space')
+        logger.error("Not enough disk space")
     except DeprecationError:
-        logger.error('failed to query MobileGestalt, MobileGestalt deprecated (iOS >= 17.4).')
+        logger.error("failed to query MobileGestalt, MobileGestalt deprecated (iOS >= 17.4).")
     except OSNotSupportedError as e:
         logger.error(
-            f'Unsupported OS - {e.os_name}. To add support, consider contributing at '
-            f'https://github.com/doronz88/pymobiledevice3.')
+            f"Unsupported OS - {e.os_name}. To add support, consider contributing at "
+            f"https://github.com/doronz88/pymobiledevice3."
+        )
     except CloudConfigurationAlreadyPresentError:
-        logger.error('A cloud configuration is already present on device. You must first erase the device in order '
-                     'to install new one:\n'
-                     '> pymobiledevice3 profile erase-device')
+        logger.error(
+            "A cloud configuration is already present on device. You must first erase the device in order "
+            "to install new one:\n"
+            "> pymobiledevice3 profile erase-device"
+        )
     except FeatureNotSupportedError as e:
         logger.error(
-            f'Missing implementation of `{e.feature}` on `{e.os_name}`. To add support, consider contributing at '
-            f'https://github.com/doronz88/pymobiledevice3.')
-    except QuicProtocolNotSupportedError as e:
-        logger.error(str(e))
+            f"Missing implementation of `{e.feature}` on `{e.os_name}`. To add support, consider contributing at "
+            f"https://github.com/doronz88/pymobiledevice3."
+        )
+    except QuicProtocolNotSupportedError:
+        logger.error("Encountered a QUIC protocol error.")
 
     return False
 
@@ -282,9 +307,9 @@ def main() -> None:
             lockdown = retry_create_using_usbmux(None)
             lockdown.close()
         except KeyboardInterrupt:
-            print('Aborted.')
+            print("Aborted.")
             break
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.27.4'
-__version_tuple__ = version_tuple = (4, 27, 4)
+__version__ = version = '5.1.2'
+__version_tuple__ = version_tuple = (5, 1, 2)
 
 __commit_id__ = commit_id = None