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

pymobiledevice3/services/webinspector.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import json
 import logging
 import uuid
@@ -8,8 +9,11 @@ from typing import Any, Coroutine, Optional, Union
 
 import nest_asyncio
 
-from pymobiledevice3.exceptions import LaunchingApplicationError, RemoteAutomationNotEnabledError, \
-    WebInspectorNotEnabledError
+from pymobiledevice3.exceptions import (
+    LaunchingApplicationError,
+    RemoteAutomationNotEnabledError,
+    WebInspectorNotEnabledError,
+)
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.service_connection import ServiceConnection
@@ -17,55 +21,55 @@ from pymobiledevice3.services.web_protocol.automation_session import AutomationS
 from pymobiledevice3.services.web_protocol.inspector_session import InspectorSession
 from pymobiledevice3.services.web_protocol.session_protocol import SessionProtocol
 
-SAFARI = 'com.apple.mobilesafari'
+SAFARI = "com.apple.mobilesafari"
 
 
 def key_to_pid(key: str) -> int:
-    return int(key.split(':')[1])
+    return int(key.split(":")[1])
 
 
 class WirTypes(Enum):
-    AUTOMATION = 'WIRTypeAutomation'
-    ITML = 'WIRTypeITML'
-    JAVASCRIPT = 'WIRTypeJavaScript'
-    PAGE = 'WIRTypePage'
-    SERVICE_WORKER = 'WIRTypeServiceWorker'
-    WEB = 'WIRTypeWeb'
-    WEB_PAGE = 'WIRTypeWebPage'
-    AUTOMATICALLY_PAUSE = 'WIRAutomaticallyPause'
+    AUTOMATION = "WIRTypeAutomation"
+    ITML = "WIRTypeITML"
+    JAVASCRIPT = "WIRTypeJavaScript"
+    PAGE = "WIRTypePage"
+    SERVICE_WORKER = "WIRTypeServiceWorker"
+    WEB = "WIRTypeWeb"
+    WEB_PAGE = "WIRTypeWebPage"
+    AUTOMATICALLY_PAUSE = "WIRAutomaticallyPause"
 
 
 class AutomationAvailability(Enum):
-    NOT_AVAILABLE = 'WIRAutomationAvailabilityNotAvailable'
-    AVAILABLE = 'WIRAutomationAvailabilityAvailable'
-    UNKNOWN = 'WIRAutomationAvailabilityUnknown'
+    NOT_AVAILABLE = "WIRAutomationAvailabilityNotAvailable"
+    AVAILABLE = "WIRAutomationAvailabilityAvailable"
+    UNKNOWN = "WIRAutomationAvailabilityUnknown"
 
 
 @dataclass
 class Page:
     id_: int
     type_: WirTypes
-    web_url: str = ''
-    web_title: str = ''
+    web_url: str = ""
+    web_title: str = ""
     automation_is_paired_key: bool = False
-    automation_name: str = ''
-    automation_version: str = ''
-    automation_session_id: str = ''
-    automation_connection_id: str = ''
+    automation_name: str = ""
+    automation_version: str = ""
+    automation_session_id: str = ""
+    automation_connection_id: str = ""
 
     @classmethod
-    def from_page_dictionary(cls, page_dict: dict) -> 'Page':
-        p = cls(page_dict['WIRPageIdentifierKey'], WirTypes(page_dict['WIRTypeKey']))
+    def from_page_dictionary(cls, page_dict: dict) -> "Page":
+        p = cls(page_dict["WIRPageIdentifierKey"], WirTypes(page_dict["WIRTypeKey"]))
         if p.type_ in (WirTypes.WEB, WirTypes.WEB_PAGE):
-            p.web_title = page_dict['WIRTitleKey']
-            p.web_url = page_dict['WIRURLKey']
+            p.web_title = page_dict["WIRTitleKey"]
+            p.web_url = page_dict["WIRURLKey"]
         if p.type_ == WirTypes.AUTOMATION:
-            p.automation_is_paired_key = page_dict['WIRAutomationTargetIsPairedKey']
-            p.automation_name = page_dict['WIRAutomationTargetNameKey']
-            p.automation_version = page_dict['WIRAutomationTargetVersionKey']
-            p.automation_session_id = page_dict['WIRSessionIdentifierKey']
-            if 'WIRConnectionIdentifierKey' in page_dict:
-                p.automation_connection_id = page_dict['WIRConnectionIdentifierKey']
+            p.automation_is_paired_key = page_dict["WIRAutomationTargetIsPairedKey"]
+            p.automation_name = page_dict["WIRAutomationTargetNameKey"]
+            p.automation_version = page_dict["WIRAutomationTargetVersionKey"]
+            p.automation_session_id = page_dict["WIRSessionIdentifierKey"]
+            if "WIRConnectionIdentifierKey" in page_dict:
+                p.automation_connection_id = page_dict["WIRConnectionIdentifierKey"]
         return p
 
     def update(self, page_dict: dict):
@@ -74,7 +78,7 @@ class Page:
             setattr(self, field.name, getattr(new_p, field.name))
 
     def __str__(self):
-        return f'id: {self.id_}, title: {self.web_title}, url: {self.web_url}'
+        return f"id: {self.id_}, title: {self.web_title}, url: {self.web_url}"
 
 
 @dataclass
@@ -87,20 +91,20 @@ class Application:
     active: int
     proxy: bool
     ready: bool
-    host: str = ''
+    host: str = ""
 
     @classmethod
-    def from_application_dictionary(cls, app_dict) -> 'Application':
+    def from_application_dictionary(cls, app_dict) -> "Application":
         return cls(
-            app_dict['WIRApplicationIdentifierKey'],
-            app_dict['WIRApplicationBundleIdentifierKey'],
-            key_to_pid(app_dict['WIRApplicationIdentifierKey']),
-            app_dict['WIRApplicationNameKey'],
-            AutomationAvailability(app_dict['WIRAutomationAvailabilityKey']),
-            app_dict['WIRIsApplicationActiveKey'],
-            app_dict['WIRIsApplicationProxyKey'],
-            app_dict['WIRIsApplicationReadyKey'],
-            app_dict.get('WIRHostApplicationIdentifierKey', ''),
+            app_dict["WIRApplicationIdentifierKey"],
+            app_dict["WIRApplicationBundleIdentifierKey"],
+            key_to_pid(app_dict["WIRApplicationIdentifierKey"]),
+            app_dict["WIRApplicationNameKey"],
+            AutomationAvailability(app_dict["WIRAutomationAvailabilityKey"]),
+            app_dict["WIRIsApplicationActiveKey"],
+            app_dict["WIRIsApplicationProxyKey"],
+            app_dict["WIRIsApplicationReadyKey"],
+            app_dict.get("WIRHostApplicationIdentifierKey", ""),
         )
 
 
@@ -110,12 +114,12 @@ class ApplicationPage:
     page: Page
 
     def __str__(self) -> str:
-        return f'<{self.application.name}({self.application.pid}) TYPE:{self.page.type_.value} URL:{self.page.web_url}>'
+        return f"<{self.application.name}({self.application.pid}) TYPE:{self.page.type_.value} URL:{self.page.web_url}>"
 
 
 class WebinspectorService:
-    SERVICE_NAME = 'com.apple.webinspector'
-    RSD_SERVICE_NAME = 'com.apple.webinspector.shim.remote'
+    SERVICE_NAME = "com.apple.webinspector"
+    RSD_SERVICE_NAME = "com.apple.webinspector.shim.remote"
 
     def __init__(self, lockdown: LockdownServiceProvider, loop=None):
         if loop is None:
@@ -142,18 +146,18 @@ class WebinspectorService:
         self.wir_message_results = {}
         self.wir_events = []
         self.receive_handlers = {
-            '_rpc_reportCurrentState:': self._handle_report_current_state,
-            '_rpc_reportConnectedApplicationList:': self._handle_report_connected_application_list,
-            '_rpc_reportConnectedDriverList:': self._handle_report_connected_driver_list,
-            '_rpc_applicationSentListing:': self._handle_application_sent_listing,
-            '_rpc_applicationUpdated:': self._handle_application_updated,
-            '_rpc_applicationConnected:': self._handle_application_connected,
-            '_rpc_applicationSentData:': self._handle_application_sent_data,
-            '_rpc_applicationDisconnected:': self._handle_application_disconnected,
+            "_rpc_reportCurrentState:": self._handle_report_current_state,
+            "_rpc_reportConnectedApplicationList:": self._handle_report_connected_application_list,
+            "_rpc_reportConnectedDriverList:": self._handle_report_connected_driver_list,
+            "_rpc_applicationSentListing:": self._handle_application_sent_listing,
+            "_rpc_applicationUpdated:": self._handle_application_updated,
+            "_rpc_applicationConnected:": self._handle_application_connected,
+            "_rpc_applicationSentData:": self._handle_application_sent_data,
+            "_rpc_applicationDisconnected:": self._handle_application_disconnected,
         }
         self._recv_task: Optional[asyncio.Task] = None
 
-    def connect(self, timeout: Union[float, int] = None):
+    def connect(self, timeout: Optional[Union[float, int]] = None):
         self.service = self.await_(self.lockdown.aio_start_lockdown_service(self.service_name))
         self.await_(self._report_identifier())
         try:
@@ -164,10 +168,8 @@ class WebinspectorService:
 
     def close(self):
         self._recv_task.cancel()
-        try:
+        with contextlib.suppress(asyncio.CancelledError):
             self.await_(self._recv_task)
-        except asyncio.CancelledError:
-            pass
         self.await_(self.service.aio_close())
 
     async def _recv_message(self):
@@ -182,7 +184,7 @@ class WebinspectorService:
             self._handle_recv(await self._recv_message())
 
     def automation_session(self, app: Application) -> AutomationSession:
-        if self.state == 'WIRAutomationAvailabilityNotAvailable':
+        if self.state == "WIRAutomationAvailabilityNotAvailable":
             raise RemoteAutomationNotEnabledError()
         session_id = str(uuid.uuid4()).upper()
         self.await_(self._forward_automation_session_request(session_id, app.id_))
@@ -196,8 +198,10 @@ class WebinspectorService:
 
     async def inspector_session(self, app: Application, page: Page) -> InspectorSession:
         session_id = str(uuid.uuid4()).upper()
-        return await InspectorSession.create(SessionProtocol(self, session_id, app, page, method_prefix=''),
-                                             wait_target=page.type_ != WirTypes.JAVASCRIPT)
+        return await InspectorSession.create(
+            SessionProtocol(self, session_id, app, page, method_prefix=""),
+            wait_target=page.type_ != WirTypes.JAVASCRIPT,
+        )
 
     def get_open_pages(self) -> dict:
         apps = {}
@@ -226,8 +230,8 @@ class WebinspectorService:
         self.get_open_pages()
         try:
             return self._await_with_timeout(self._wait_for_application(bundle), timeout)
-        except TimeoutError:
-            raise LaunchingApplicationError()
+        except TimeoutError as e:
+            raise LaunchingApplicationError() from e
 
     async def send_socket_data(self, session_id: str, app_id: str, page_id: int, data: dict):
         await self._forward_socket_data(session_id, app_id, page_id, data)
@@ -247,29 +251,27 @@ class WebinspectorService:
     def await_(self, awaitable: Coroutine) -> Any:
         return self.loop.run_until_complete(awaitable)
 
-    def _await_with_timeout(self, coro: Coroutine, timeout: float = None) -> Any:
+    def _await_with_timeout(self, coro: Coroutine, timeout: Optional[float] = None) -> Any:
         # Create a task explicitly so we're definitely inside a Task
         task = self.loop.create_task(coro)
-        done, pending = self.loop.run_until_complete(asyncio.wait({task}, timeout=timeout))
+        done, _pending = self.loop.run_until_complete(asyncio.wait({task}, timeout=timeout))
         if not done:
             task.cancel()
             # Give the task a chance to cancel cleanly
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 self.loop.run_until_complete(task)
-            except asyncio.CancelledError:
-                pass
             raise WebInspectorNotEnabledError()
         return task.result()
 
     def _handle_recv(self, plist):
-        self.receive_handlers[plist['__selector']](plist['__argument'])
+        self.receive_handlers[plist["__selector"]](plist["__argument"])
 
     def _handle_report_current_state(self, arg):
-        self.state = arg['WIRAutomationAvailabilityKey']
+        self.state = arg["WIRAutomationAvailabilityKey"]
 
     def _handle_report_connected_application_list(self, arg):
         self.connected_application = {}
-        for key, application in arg['WIRApplicationDictionaryKey'].items():
+        for key, application in arg["WIRApplicationDictionaryKey"].items():
             self.connected_application[key] = Application.from_application_dictionary(application)
 
             # Immediately also query the application pages
@@ -279,19 +281,19 @@ class WebinspectorService:
         pass
 
     def _handle_application_sent_listing(self, arg):
-        if arg['WIRApplicationIdentifierKey'] in self.application_pages:
+        if arg["WIRApplicationIdentifierKey"] in self.application_pages:
             # Update existing application pages
-            for id_, page in arg['WIRListingKey'].items():
-                if id_ in self.application_pages[arg['WIRApplicationIdentifierKey']]:
-                    self.application_pages[arg['WIRApplicationIdentifierKey']][id_].update(page)
+            for id_, page in arg["WIRListingKey"].items():
+                if id_ in self.application_pages[arg["WIRApplicationIdentifierKey"]]:
+                    self.application_pages[arg["WIRApplicationIdentifierKey"]][id_].update(page)
                 else:
-                    self.application_pages[arg['WIRApplicationIdentifierKey']][id_] = Page.from_page_dictionary(page)
+                    self.application_pages[arg["WIRApplicationIdentifierKey"]][id_] = Page.from_page_dictionary(page)
         else:
             # Add new application pages
             pages = {}
-            for id_, page in arg['WIRListingKey'].items():
+            for id_, page in arg["WIRListingKey"].items():
                 pages[id_] = Page.from_page_dictionary(page)
-            self.application_pages[arg['WIRApplicationIdentifierKey']] = pages
+            self.application_pages[arg["WIRApplicationIdentifierKey"]] = pages
 
     def _handle_application_updated(self, arg):
         app = Application.from_application_dictionary(arg)
@@ -302,72 +304,81 @@ class WebinspectorService:
         self.connected_application[app.id_] = app
 
     def _handle_application_sent_data(self, arg):
-        response = json.loads(arg['WIRMessageDataKey'])
+        response = json.loads(arg["WIRMessageDataKey"])
 
-        if 'id' in response:
-            self.wir_message_results[response['id']] = response
+        if "id" in response:
+            self.wir_message_results[response["id"]] = response
         else:
             self.wir_events.append(response)
 
     def _handle_application_disconnected(self, arg):
-        self.connected_application.pop(arg['WIRApplicationIdentifierKey'], None)
-        self.application_pages.pop(arg['WIRApplicationIdentifierKey'], None)
+        self.connected_application.pop(arg["WIRApplicationIdentifierKey"], None)
+        self.application_pages.pop(arg["WIRApplicationIdentifierKey"], None)
 
     async def _report_identifier(self):
-        await self._send_message('_rpc_reportIdentifier:')
+        await self._send_message("_rpc_reportIdentifier:")
 
     async def _forward_get_listing(self, app_id):
-        self.logger.debug(f'Listing app with id {app_id}')
-        await self._send_message('_rpc_forwardGetListing:', {'WIRApplicationIdentifierKey': app_id})
+        self.logger.debug(f"Listing app with id {app_id}")
+        await self._send_message("_rpc_forwardGetListing:", {"WIRApplicationIdentifierKey": app_id})
 
     async def _request_application_launch(self, bundle: str):
-        await self._send_message('_rpc_requestApplicationLaunch:', {'WIRApplicationBundleIdentifierKey': bundle})
+        await self._send_message("_rpc_requestApplicationLaunch:", {"WIRApplicationBundleIdentifierKey": bundle})
 
     async def _get_connected_applications(self) -> None:
-        await self._send_message('_rpc_getConnectedApplications:', {})
+        await self._send_message("_rpc_getConnectedApplications:", {})
 
     async def _forward_automation_session_request(self, session_id: str, app_id: str):
-        await self._send_message('_rpc_forwardAutomationSessionRequest:', {
-            'WIRApplicationIdentifierKey': app_id,
-            'WIRSessionCapabilitiesKey': {
-                'org.webkit.webdriver.webrtc.allow-insecure-media-capture': True,
-                'org.webkit.webdriver.webrtc.suppress-ice-candidate-filtering': False,
+        await self._send_message(
+            "_rpc_forwardAutomationSessionRequest:",
+            {
+                "WIRApplicationIdentifierKey": app_id,
+                "WIRSessionCapabilitiesKey": {
+                    "org.webkit.webdriver.webrtc.allow-insecure-media-capture": True,
+                    "org.webkit.webdriver.webrtc.suppress-ice-candidate-filtering": False,
+                },
+                "WIRSessionIdentifierKey": session_id,
             },
-            'WIRSessionIdentifierKey': session_id
-        })
+        )
 
     async def _forward_socket_setup(self, session_id: str, app_id: str, page_id: int, pause: bool = True):
         message = {
-            'WIRApplicationIdentifierKey': app_id,
-            'WIRPageIdentifierKey': page_id,
-            'WIRSenderKey': session_id,
-            'WIRMessageDataTypeChunkSupportedKey': 0,
+            "WIRApplicationIdentifierKey": app_id,
+            "WIRPageIdentifierKey": page_id,
+            "WIRSenderKey": session_id,
+            "WIRMessageDataTypeChunkSupportedKey": 0,
         }
         if not pause:
-            message['WIRAutomaticallyPause'] = False
-        await self._send_message('_rpc_forwardSocketSetup:', message)
+            message["WIRAutomaticallyPause"] = False
+        await self._send_message("_rpc_forwardSocketSetup:", message)
 
     async def _forward_socket_data(self, session_id: str, app_id: str, page_id: int, data: dict):
-        await self._send_message('_rpc_forwardSocketData:', {
-            'WIRApplicationIdentifierKey': app_id,
-            'WIRPageIdentifierKey': page_id,
-            'WIRSessionIdentifierKey': session_id,
-            'WIRSenderKey': session_id,
-            'WIRSocketDataKey': json.dumps(data).encode(),
-        })
+        await self._send_message(
+            "_rpc_forwardSocketData:",
+            {
+                "WIRApplicationIdentifierKey": app_id,
+                "WIRPageIdentifierKey": page_id,
+                "WIRSessionIdentifierKey": session_id,
+                "WIRSenderKey": session_id,
+                "WIRSocketDataKey": json.dumps(data).encode(),
+            },
+        )
 
     async def _forward_indicate_web_view(self, app_id: str, page_id: int, enable: bool):
-        await self._send_message('_rpc_forwardIndicateWebView'), {
-            'WIRApplicationIdentifierKey': app_id,
-            'WIRPageIdentifierKey': page_id,
-            'WIRIndicateEnabledKey': enable,
-        }
+        (
+            await self._send_message("_rpc_forwardIndicateWebView"),
+            {
+                "WIRApplicationIdentifierKey": app_id,
+                "WIRPageIdentifierKey": page_id,
+                "WIRIndicateEnabledKey": enable,
+            },
+        )
 
     async def _send_message(self, selector: str, args=None):
         if args is None:
             args = {}
-        args['WIRConnectionIdentifierKey'] = self.connection_id
-        await self.service.aio_send_plist({'__selector': selector, '__argument': args})
+        args["WIRConnectionIdentifierKey"] = self.connection_id
+        await self.service.aio_send_plist({"__selector": selector, "__argument": args})
 
     def _page_by_automation_session(self, session_id: str) -> Page:
         for app_id in self.application_pages:
@@ -383,7 +394,7 @@ class WebinspectorService:
                         return page
             await asyncio.sleep(0)
 
-    async def _wait_for_application(self, bundle: str = '', app_id: str = '') -> Application:
+    async def _wait_for_application(self, bundle: str = "", app_id: str = "") -> Application:
         while True:
             for app in self.connected_application.values():
                 if bundle and app.bundle == bundle:

pymobiledevice3/tcp_forwarder.py

@@ -19,7 +19,7 @@ class TcpForwarderBase:
     MAX_FORWARDED_CONNECTIONS = 200
     TIMEOUT = 1
 
-    def __init__(self, src_port: int, listening_event: threading.Event = None):
+    def __init__(self, src_port: int, listening_event: Optional[threading.Event] = None):
         """
         Initialize a new tcp forwarder
 
@@ -38,8 +38,8 @@ class TcpForwarderBase:
         # socket to its remote socket and vice versa
         self.connections = {}
 
-    def start(self, address='0.0.0.0'):
-        """ forward each connection from given local machine port to remote device port """
+    def start(self, address="0.0.0.0"):
+        """forward each connection from given local machine port to remote device port"""
         # create local tcp server socket
         self.server_socket = socket.socket()
         self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -55,7 +55,7 @@ class TcpForwarderBase:
             while self.inputs:
                 # will only perform the socket select on the inputs. the outputs will handled
                 # as synchronous blocking
-                readable, writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
+                readable, _writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
                 if self.stopped.is_set():
                     self.logger.debug("Closing since stopped is set")
                     break
@@ -85,7 +85,7 @@ class TcpForwarderBase:
                 current_sock.close()
 
     def _handle_close_or_error(self, from_sock):
-        """ if an error occurred its time to close the two sockets """
+        """if an error occurred its time to close the two sockets"""
         other_sock = self.connections[from_sock]
 
         other_sock.close()
@@ -93,7 +93,7 @@ class TcpForwarderBase:
         self.inputs.remove(other_sock)
         self.inputs.remove(from_sock)
 
-        self.logger.info(f'connection {other_sock} was closed')
+        self.logger.info(f"connection {other_sock} was closed")
 
     def _handle_data(self, from_sock, closed_sockets):
         self.logger.debug(f"Handling data from {from_sock}")
@@ -104,8 +104,8 @@ class TcpForwarderBase:
         except BlockingIOError:
             self.logger.warning(f"Non-blocking read failed on {from_sock}, retrying later.")
             return
-        except OSError as e:
-            self.logger.error(f"Error reading from socket {from_sock}: {e}")
+        except OSError:
+            self.logger.exception(f"Error reading from socket {from_sock}")
             self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
             return
@@ -125,10 +125,10 @@ class TcpForwarderBase:
                     self.logger.warning(f"Socket buffer full for {other_sock}, retrying in 100ms.")
                     time.sleep(0.1)  # Introduce a small delay
                 except BrokenPipeError:
-                    self.logger.error(f"Broken pipe error on {other_sock}.")
+                    self.logger.exception(f"Broken pipe error on {other_sock}.")
                     raise
-        except OSError as e:
-            self.logger.error(f"Unhandled error while forwarding data: {e}")
+        except OSError:
+            self.logger.exception("Unhandled error while forwarding data")
             self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
             closed_sockets.add(other_sock)
@@ -138,14 +138,14 @@ class TcpForwarderBase:
         pass
 
     def _handle_server_connection(self):
-        """ accept the connection from local machine and attempt to connect at remote """
-        local_connection, client_address = self.server_socket.accept()
+        """accept the connection from local machine and attempt to connect at remote"""
+        local_connection, _client_address = self.server_socket.accept()
         local_connection.setblocking(False)
 
         try:
             remote_connection = self._establish_remote_connection()
         except ConnectionFailedError:
-            self.logger.error(f'failed to connect to port: {self.dst_port}')
+            self.logger.exception(f"failed to connect to port: {self.dst_port}")
             local_connection.close()
             return
 
@@ -159,10 +159,10 @@ class TcpForwarderBase:
         self.connections[remote_connection] = local_connection
         self.connections[local_connection] = remote_connection
 
-        self.logger.info('connection established from local to remote')
+        self.logger.info("connection established from local to remote")
 
     def stop(self):
-        """ stop forwarding """
+        """stop forwarding"""
         self.stopped.set()
 
 
@@ -171,8 +171,15 @@ class UsbmuxTcpForwarder(TcpForwarderBase):
     Allows forwarding local tcp connection into the device via a given lockdown connection
     """
 
-    def __init__(self, serial: str, dst_port: int, src_port: int, listening_event: threading.Event = None,
-                 usbmux_connection_type: str = None, usbmux_address: Optional[str] = None):
+    def __init__(
+        self,
+        serial: str,
+        dst_port: int,
+        src_port: int,
+        listening_event: Optional[threading.Event] = None,
+        usbmux_connection_type: Optional[str] = None,
+        usbmux_address: Optional[str] = None,
+    ):
         """
         Initialize a new tcp forwarder
 
@@ -191,8 +198,9 @@ class UsbmuxTcpForwarder(TcpForwarderBase):
 
     def _establish_remote_connection(self) -> socket.socket:
         # connect directly using usbmuxd
-        mux_device = usbmux.select_device(self.serial, connection_type=self.usbmux_connection_type,
-                                          usbmux_address=self.usbmux_address)
+        mux_device = usbmux.select_device(
+            self.serial, connection_type=self.usbmux_connection_type, usbmux_address=self.usbmux_address
+        )
         self.logger.debug("Selected device: %r", mux_device)
         if mux_device is None:
             raise ConnectionFailedError()
@@ -204,8 +212,13 @@ class LockdownTcpForwarder(TcpForwarderBase):
     Allows forwarding local tcp connection into the device via a given lockdown connection
     """
 
-    def __init__(self, service_provider: LockdownServiceProvider, src_port: int, service_name: str,
-                 listening_event: threading.Event = None):
+    def __init__(
+        self,
+        service_provider: LockdownServiceProvider,
+        src_port: int,
+        service_name: str,
+        listening_event: Optional[threading.Event] = None,
+    ):
         """
         Initialize a new tcp forwarder
 

pymobiledevice3/tunneld/api.py

@@ -6,22 +6,25 @@ from pymobiledevice3.exceptions import TunneldConnectionError
 from pymobiledevice3.remote.remote_service_discovery import RemoteServiceDiscoveryService
 from pymobiledevice3.utils import get_asyncio_loop
 
-TUNNELD_DEFAULT_ADDRESS = ('127.0.0.1', 49151)
+TUNNELD_DEFAULT_ADDRESS = ("127.0.0.1", 49151)
 
 
-async def async_get_tunneld_devices(tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) \
-        -> list[RemoteServiceDiscoveryService]:
+async def async_get_tunneld_devices(
+    tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS,
+) -> list[RemoteServiceDiscoveryService]:
     tunnels = _list_tunnels(tunneld_address)
     return await _create_rsds_from_tunnels(tunnels)
 
 
-def get_tunneld_devices(tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) \
-        -> list[RemoteServiceDiscoveryService]:
+def get_tunneld_devices(
+    tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS,
+) -> list[RemoteServiceDiscoveryService]:
     return get_asyncio_loop().run_until_complete(async_get_tunneld_devices(tunneld_address))
 
 
-async def async_get_tunneld_device_by_udid(udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) \
-        -> Optional[RemoteServiceDiscoveryService]:
+async def async_get_tunneld_device_by_udid(
+    udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS
+) -> Optional[RemoteServiceDiscoveryService]:
     tunnels = _list_tunnels(tunneld_address)
     if udid not in tunnels:
         return None
@@ -29,27 +32,29 @@ async def async_get_tunneld_device_by_udid(udid: str, tunneld_address: tuple[str
     return rsds[0]
 
 
-def get_tunneld_device_by_udid(udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) \
-        -> Optional[RemoteServiceDiscoveryService]:
+def get_tunneld_device_by_udid(
+    udid: str, tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS
+) -> Optional[RemoteServiceDiscoveryService]:
     return get_asyncio_loop().run_until_complete(async_get_tunneld_device_by_udid(udid, tunneld_address))
 
 
 def _list_tunnels(tunneld_address: tuple[str, int] = TUNNELD_DEFAULT_ADDRESS) -> dict[str, list[dict]]:
     try:
         # Get the list of tunnels from the specified address
-        resp = requests.get(f'http://{tunneld_address[0]}:{tunneld_address[1]}')
+        resp = requests.get(f"http://{tunneld_address[0]}:{tunneld_address[1]}")
         tunnels = resp.json()
-    except requests.exceptions.ConnectionError:
-        raise TunneldConnectionError()
+    except requests.exceptions.ConnectionError as e:
+        raise TunneldConnectionError() from e
     return tunnels
 
 
 async def _create_rsds_from_tunnels(tunnels: dict[str, list[dict]]) -> list[RemoteServiceDiscoveryService]:
     rsds = []
-    for udid, details in tunnels.items():
+    for _udid, details in tunnels.items():
         for tunnel_details in details:
-            rsd = RemoteServiceDiscoveryService((tunnel_details['tunnel-address'], tunnel_details['tunnel-port']),
-                                                name=tunnel_details['interface'])
+            rsd = RemoteServiceDiscoveryService(
+                (tunnel_details["tunnel-address"], tunnel_details["tunnel-port"]), name=tunnel_details["interface"]
+            )
             try:
                 await rsd.connect()
                 rsds.append(rsd)