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

pymobiledevice3/services/webinspector.py

@@ -1,15 +1,20 @@
 import asyncio
+import contextlib
 import json
 import logging
 import uuid
+from collections.abc import Coroutine
 from dataclasses import dataclass, fields
 from enum import Enum
-from typing import Optional, Union
+from typing import Any, 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 +22,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 +79,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 +92,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 +115,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,32 +147,30 @@ 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:
-            self._handle_recv(self.await_(asyncio.wait_for(self._recv_message(), timeout)))
+            self._handle_recv(self._await_with_timeout(self._recv_message(), timeout))
         except asyncio.TimeoutError as e:
             raise WebInspectorNotEnabledError from e
         self._recv_task = self.loop.create_task(self._receiving_task())
 
     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 +185,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 +199,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 = {}
@@ -225,9 +230,9 @@ class WebinspectorService:
         self.await_(self._request_application_launch(bundle))
         self.get_open_pages()
         try:
-            return self.await_(asyncio.wait_for(self._wait_for_application(bundle), timeout=timeout))
-        except TimeoutError:
-            raise LaunchingApplicationError()
+            return self._await_with_timeout(self._wait_for_application(bundle), timeout)
+        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)
@@ -244,18 +249,30 @@ class WebinspectorService:
     def flush_input(self, duration: Union[float, int] = 0):
         return self.await_(asyncio.sleep(duration))
 
-    def await_(self, awaitable):
-        return self.loop.run_until_complete(asyncio.ensure_future(awaitable, loop=self.loop))
+    def await_(self, awaitable: Coroutine) -> Any:
+        return self.loop.run_until_complete(awaitable)
+
+    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))
+        if not done:
+            task.cancel()
+            # Give the task a chance to cancel cleanly
+            with contextlib.suppress(asyncio.CancelledError):
+                self.loop.run_until_complete(task)
+            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
@@ -265,19 +282,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)
@@ -288,72 +305,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:
@@ -369,7 +395,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)
@@ -51,40 +51,41 @@ class TcpForwarderBase:
         if self.listening_event:
             self.listening_event.set()
 
-        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)
-            if self.stopped.is_set():
-                self.logger.debug("Closing since stopped is set")
-                break
-
-            closed_sockets = set()
-            for current_sock in readable:
-                self.logger.debug("Processing %r", current_sock)
-                if current_sock is self.server_socket:
-                    self._handle_server_connection()
-                else:
-                    if current_sock not in closed_sockets:
-                        try:
-                            self._handle_data(current_sock, closed_sockets)
-                        except ConnectionResetError:
-                            self.logger.exception("Error when handling data")
-                            self._handle_close_or_error(current_sock)
+        try:
+            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)
+                if self.stopped.is_set():
+                    self.logger.debug("Closing since stopped is set")
+                    break
+
+                closed_sockets = set()
+                for current_sock in readable:
+                    self.logger.debug("Processing %r", current_sock)
+                    if current_sock is self.server_socket:
+                        self._handle_server_connection()
                     else:
-                        self.logger.debug("Is closed")
-
-            for current_sock in exceptional:
-                self.logger.error("Sock failed: %r", current_sock)
-                self._handle_close_or_error(current_sock)
-
-        self.logger.info("Closing everything")
-        # on stop, close all currently opened sockets
-        for current_sock in self.inputs:
-            current_sock.close()
+                        if current_sock not in closed_sockets:
+                            try:
+                                self._handle_data(current_sock, closed_sockets)
+                            except ConnectionResetError:
+                                self.logger.error("Error when handling data")
+                                self._handle_close_or_error(current_sock)
+                        else:
+                            self.logger.debug("Is closed")
+
+                for current_sock in exceptional:
+                    self.logger.error("Sock failed: %r", current_sock)
+                    self._handle_close_or_error(current_sock)
+        finally:
+            self.logger.info("Closing everything")
+            # on stop, close all currently opened sockets
+            for current_sock in self.inputs:
+                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()
@@ -92,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}")
@@ -103,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.error(f"Error reading from socket {from_sock}")
             self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
             return
@@ -126,8 +127,8 @@ class TcpForwarderBase:
                 except BrokenPipeError:
                     self.logger.error(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.error("Unhandled error while forwarding data")
             self._handle_close_or_error(from_sock)
             closed_sockets.add(from_sock)
             closed_sockets.add(other_sock)
@@ -137,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.error(f"failed to connect to port: {self.dst_port}")
             local_connection.close()
             return
 
@@ -158,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()
 
 
@@ -170,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
 
@@ -190,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()
@@ -203,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