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

pymobiledevice3/remote/core_device/diagnostics_service.py

@@ -17,16 +17,18 @@ class DiagnosticsServiceService(CoreDeviceService):
     Obtain device diagnostics
     """
 
-    SERVICE_NAME = 'com.apple.coredevice.diagnosticsservice'
+    SERVICE_NAME = "com.apple.coredevice.diagnosticsservice"
 
     def __init__(self, rsd: RemoteServiceDiscoveryService):
         super().__init__(rsd, self.SERVICE_NAME)
 
     async def capture_sysdiagnose(self, is_dry_run: bool) -> SysDiagnoseResponse:
-        response = await self.invoke('com.apple.coredevice.feature.capturesysdiagnose', {
-            'options': {
-                'collectFullLogs': True
-            }, 'isDryRun': is_dry_run})
-        return SysDiagnoseResponse(file_size=response['fileTransfer']['expectedLength'],
-                                   preferred_filename=response['preferredFilename'],
-                                   generator=self.service.iter_file_chunks(response['fileTransfer']['expectedLength']))
+        response = await self.invoke(
+            "com.apple.coredevice.feature.capturesysdiagnose",
+            {"options": {"collectFullLogs": True}, "isDryRun": is_dry_run},
+        )
+        return SysDiagnoseResponse(
+            file_size=response["fileTransfer"]["expectedLength"],
+            preferred_filename=response["preferredFilename"],
+            generator=self.service.iter_file_chunks(response["fileTransfer"]["expectedLength"]),
+        )

pymobiledevice3/remote/core_device/file_service.py

@@ -20,10 +20,10 @@ class Domain(IntEnum):
 
 
 APPLE_DOMAIN_DICT = {
-    'appDataContainer': Domain.APP_DATA_CONTAINER,
-    'appGroupDataContainer': Domain.APP_GROUP_DATA_CONTAINER,
-    'temporary': Domain.TEMPORARY,
-    'systemCrashLogs': Domain.SYSTEM_CRASH_LOGS
+    "appDataContainer": Domain.APP_DATA_CONTAINER,
+    "appGroupDataContainer": Domain.APP_GROUP_DATA_CONTAINER,
+    "temporary": Domain.TEMPORARY,
+    "systemCrashLogs": Domain.SYSTEM_CRASH_LOGS,
 }
 
 
@@ -32,9 +32,9 @@ class FileServiceService(CoreDeviceService):
     Filesystem control
     """
 
-    CTRL_SERVICE_NAME = 'com.apple.coredevice.fileservice.control'
+    CTRL_SERVICE_NAME = "com.apple.coredevice.fileservice.control"
 
-    def __init__(self, rsd: RemoteServiceDiscoveryService, domain: Domain, identifier: str = '') -> None:
+    def __init__(self, rsd: RemoteServiceDiscoveryService, domain: Domain, identifier: str = "") -> None:
         super().__init__(rsd, self.CTRL_SERVICE_NAME)
         self.domain: Domain = domain
         self.session: Optional[str] = None
@@ -43,45 +43,59 @@ class FileServiceService(CoreDeviceService):
     async def connect(self) -> None:
         await super().connect()
         response = await self.send_receive_request({
-            'Cmd': 'CreateSession', 'Domain': XpcUInt64Type(self.domain), 'Identifier': self.identifier, 'Session': '',
-            'User': 'mobile'})
-        self.session = response['NewSessionID']
+            "Cmd": "CreateSession",
+            "Domain": XpcUInt64Type(self.domain),
+            "Identifier": self.identifier,
+            "Session": "",
+            "User": "mobile",
+        })
+        self.session = response["NewSessionID"]
 
-    async def retrieve_directory_list(self, path: str = '.') -> AsyncGenerator[list[str], None]:
-        return (await self.send_receive_request({
-            'Cmd': 'RetrieveDirectoryList', 'MessageUUID': str(uuid.uuid4()), 'Path': path, 'SessionID': self.session}
-        ))['FileList']
+    async def retrieve_directory_list(self, path: str = ".") -> AsyncGenerator[list[str], None]:
+        return (
+            await self.send_receive_request({
+                "Cmd": "RetrieveDirectoryList",
+                "MessageUUID": str(uuid.uuid4()),
+                "Path": path,
+                "SessionID": self.session,
+            })
+        )["FileList"]
 
-    async def retrieve_file(self, path: str = '.') -> bytes:
-        response = await self.send_receive_request({
-            'Cmd': 'RetrieveFile', 'Path': path, 'SessionID': self.session}
-        )
-        data_service = self.rsd.get_service_port('com.apple.coredevice.fileservice.data')
+    async def retrieve_file(self, path: str = ".") -> bytes:
+        response = await self.send_receive_request({"Cmd": "RetrieveFile", "Path": path, "SessionID": self.session})
+        data_service = self.rsd.get_service_port("com.apple.coredevice.fileservice.data")
         reader, writer = await asyncio.open_connection(self.service.address[0], data_service)
-        writer.write(b'rwb!FILE' + struct.pack('>QQQQ', response['Response'], 0, response['NewFileID'], 0))
+        writer.write(b"rwb!FILE" + struct.pack(">QQQQ", response["Response"], 0, response["NewFileID"], 0))
         await writer.drain()
         await reader.readexactly(0x24)
-        return await reader.readexactly(struct.unpack('>I', await reader.readexactly(4))[0])
+        return await reader.readexactly(struct.unpack(">I", await reader.readexactly(4))[0])
 
-    async def propose_empty_file(self, path: str = '.', file_permissions: int = 0o644, uid: int = 501, gid: int = 501,
-                                 creation_time: int = time.time(), last_modification_time: int = time.time()) -> None:
-        """ Request to write an empty file at given path. """
+    async def propose_empty_file(
+        self,
+        path: str = ".",
+        file_permissions: int = 0o644,
+        uid: int = 501,
+        gid: int = 501,
+        creation_time: int = time.time(),
+        last_modification_time: int = time.time(),
+    ) -> None:
+        """Request to write an empty file at given path."""
         await self.send_receive_request({
-            'Cmd': 'ProposeEmptyFile',
-            'FileCreationTime': XpcInt64Type(creation_time),
-            'FileLastModificationTime': XpcInt64Type(last_modification_time),
-            'FilePermissions': XpcInt64Type(file_permissions),
-            'FileOwnerUserID': XpcInt64Type(uid),
-            'FileOwnerGroupID': XpcInt64Type(gid),
-            'Path': path,
-            'SessionID': self.session
+            "Cmd": "ProposeEmptyFile",
+            "FileCreationTime": XpcInt64Type(creation_time),
+            "FileLastModificationTime": XpcInt64Type(last_modification_time),
+            "FilePermissions": XpcInt64Type(file_permissions),
+            "FileOwnerUserID": XpcInt64Type(uid),
+            "FileOwnerGroupID": XpcInt64Type(gid),
+            "Path": path,
+            "SessionID": self.session,
         })
 
     async def send_receive_request(self, request: dict) -> dict:
         response = await self.service.send_receive_request(request)
-        encoded_error = response.get('EncodedError')
+        encoded_error = response.get("EncodedError")
         if encoded_error is not None:
-            localized_description = response.get('LocalizedDescription')
+            localized_description = response.get("LocalizedDescription")
             if localized_description is not None:
                 raise CoreDeviceError(localized_description)
             raise CoreDeviceError(encoded_error)

pymobiledevice3/remote/remote_service_discovery.py

@@ -6,8 +6,12 @@ from typing import Any, Optional, Union
 
 from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remoted
 from pymobiledevice3.common import get_home_folder
-from pymobiledevice3.exceptions import InvalidServiceError, NoDeviceConnectedError, PyMobileDevice3Exception, \
-    StartServiceError
+from pymobiledevice3.exceptions import (
+    InvalidServiceError,
+    NoDeviceConnectedError,
+    PyMobileDevice3Exception,
+    StartServiceError,
+)
 from pymobiledevice3.lockdown import LockdownClient, create_using_remote
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.pair_records import get_local_pairing_record, get_remote_pairing_record_filename
@@ -38,11 +42,11 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
     @property
     def product_version(self) -> str:
-        return self.peer_info['Properties']['OSVersion']
+        return self.peer_info["Properties"]["OSVersion"]
 
     @property
     def ecid(self) -> int:
-        return self.peer_info['Properties']['UniqueChipID']
+        return self.peer_info["Properties"]["UniqueChipID"]
 
     @property
     def developer_mode_status(self) -> bool:
@@ -59,15 +63,18 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         await self.service.connect()
         try:
             self.peer_info = await self.service.receive_response()
-            self.udid = self.peer_info['Properties']['UniqueDeviceID']
-            self.product_type = self.peer_info['Properties']['ProductType']
+            self.udid = self.peer_info["Properties"]["UniqueDeviceID"]
+            self.product_type = self.peer_info["Properties"]["ProductType"]
             try:
-                self.lockdown = create_using_remote(self.start_lockdown_service('com.apple.mobile.lockdown.remote.trusted'))
+                self.lockdown = create_using_remote(
+                    self.start_lockdown_service("com.apple.mobile.lockdown.remote.trusted")
+                )
             except InvalidServiceError:
                 self.lockdown = create_using_remote(
-                    self.start_lockdown_service('com.apple.mobile.lockdown.remote.untrusted'))
+                    self.start_lockdown_service("com.apple.mobile.lockdown.remote.untrusted")
+                )
             self.all_values = self.lockdown.all_values
-        except Exception:  # noqa: E722
+        except Exception:
             await self.close()
             raise
 
@@ -80,23 +87,26 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
     def start_lockdown_service(self, name: str, include_escrow_bag: bool = False) -> ServiceConnection:
         service = self.start_lockdown_service_without_checkin(name)
         try:
-            checkin = {'Label': 'pymobiledevice3', 'ProtocolVersion': '2', 'Request': 'RSDCheckin'}
+            checkin = {"Label": "pymobiledevice3", "ProtocolVersion": "2", "Request": "RSDCheckin"}
             if include_escrow_bag:
-                pairing_record = get_local_pairing_record(get_remote_pairing_record_filename(self.udid), get_home_folder())
-                checkin['EscrowBag'] = base64.b64decode(pairing_record['remote_unlock_host_key'])
+                pairing_record = get_local_pairing_record(
+                    get_remote_pairing_record_filename(self.udid), get_home_folder()
+                )
+                checkin["EscrowBag"] = base64.b64decode(pairing_record["remote_unlock_host_key"])
             response = service.send_recv_plist(checkin)
-            if response['Request'] != 'RSDCheckin':
+            if response["Request"] != "RSDCheckin":
                 raise PyMobileDevice3Exception(f'Invalid response for RSDCheckIn: {response}. Expected "RSDCheckIn"')
             response = service.recv_plist()
-            if response['Request'] != 'StartService':
-                raise PyMobileDevice3Exception(f'Invalid response for RSDCheckIn: {response}. Expected "ServiceService"')
-        except Exception:  # noqa: E722
+            if response["Request"] != "StartService":
+                raise PyMobileDevice3Exception(
+                    f'Invalid response for RSDCheckIn: {response}. Expected "ServiceService"'
+                )
+        except Exception:
             service.close()
             raise
         return service
 
-    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:
         service = self.start_lockdown_service(name, include_escrow_bag=include_escrow_bag)
         await service.aio_start()
         return service
@@ -105,9 +115,9 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         try:
             return self.start_lockdown_service_without_checkin(name)
         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
 
@@ -116,24 +126,24 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         return service
 
     def start_service(self, name: str) -> Union[RemoteXPCConnection, ServiceConnection]:
-        service = self.peer_info['Services'][name]
-        service_properties = service.get('Properties', {})
-        use_remote_xpc = service_properties.get('UsesRemoteXPC', False)
+        service = self.peer_info["Services"][name]
+        service_properties = service.get("Properties", {})
+        use_remote_xpc = service_properties.get("UsesRemoteXPC", False)
         return self.start_remote_service(name) if use_remote_xpc else self.start_lockdown_service(name)
 
     def get_service_port(self, name: str) -> int:
         """takes a service name and returns the port that service is running on if the service exists"""
-        service = self.peer_info['Services'].get(name)
+        service = self.peer_info["Services"].get(name)
         if service is None:
-            raise InvalidServiceError(f'No such service: {name}')
-        return int(service['Port'])
+            raise InvalidServiceError(f"No such service: {name}")
+        return int(service["Port"])
 
     async def close(self) -> None:
         if self.lockdown is not None:
             self.lockdown.close()
         await self.service.close()
 
-    async def __aenter__(self) -> 'RemoteServiceDiscoveryService':
+    async def __aenter__(self) -> "RemoteServiceDiscoveryService":
         await self.connect()
         return self
 
@@ -141,20 +151,28 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
         await self.close()
 
     def __repr__(self) -> str:
-        name_str = ''
+        name_str = ""
         if self.name:
-            name_str = f' NAME:{self.name}'
-        return (f'<{self.__class__.__name__} PRODUCT:{self.product_type} VERSION:{self.product_version} '
-                f'UDID:{self.udid}{name_str}>')
+            name_str = f" NAME:{self.name}"
+        return (
+            f"<{self.__class__.__name__} PRODUCT:{self.product_type} VERSION:{self.product_version} "
+            f"UDID:{self.udid}{name_str}>"
+        )
 
 
 async def get_remoted_devices(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[RSDDevice]:
     result = []
     for hostname in await browse_remoted(timeout):
         with RemoteServiceDiscoveryService((hostname, RSD_PORT)) as rsd:
-            properties = rsd.peer_info['Properties']
-            result.append(RSDDevice(hostname=hostname, udid=properties['UniqueDeviceID'],
-                                    product_type=properties['ProductType'], os_version=properties['OSVersion']))
+            properties = rsd.peer_info["Properties"]
+            result.append(
+                RSDDevice(
+                    hostname=hostname,
+                    udid=properties["UniqueDeviceID"],
+                    product_type=properties["ProductType"],
+                    os_version=properties["OSVersion"],
+                )
+            )
     return result
 
 

pymobiledevice3/remote/remotexpc.py

@@ -1,19 +1,34 @@
 import asyncio
+import contextlib
 import sys
 from asyncio import IncompleteReadError
-from typing import AsyncIterable, Optional
+from collections.abc import AsyncIterable
+from typing import Optional
 
 import IPython
 import nest_asyncio
 from construct import StreamError
-from hyperframe.frame import DataFrame, Frame, GoAwayFrame, HeadersFrame, RstStreamFrame, SettingsFrame, \
-    WindowUpdateFrame
+from hyperframe.frame import (
+    DataFrame,
+    Frame,
+    GoAwayFrame,
+    HeadersFrame,
+    RstStreamFrame,
+    SettingsFrame,
+    WindowUpdateFrame,
+)
 from pygments import formatters, highlight, lexers
 from traitlets.config import Config
 
 from pymobiledevice3.exceptions import ProtocolError, StreamClosedError
-from pymobiledevice3.remote.xpc_message import XpcFlags, XpcInt64Type, XpcUInt64Type, XpcWrapper, create_xpc_wrapper, \
-    decode_xpc_object
+from pymobiledevice3.remote.xpc_message import (
+    XpcFlags,
+    XpcInt64Type,
+    XpcUInt64Type,
+    XpcWrapper,
+    create_xpc_wrapper,
+    decode_xpc_object,
+)
 
 # Extracted by sniffing `remoted` traffic via Wireshark
 DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS = 100
@@ -21,7 +36,7 @@ DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE = 1048576
 DEFAULT_WIN_SIZE_INCR = 983041
 
 FRAME_HEADER_SIZE = 9
-HTTP2_MAGIC = b'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'
+HTTP2_MAGIC = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 
 ROOT_CHANNEL = 1
 REPLY_CHANNEL = 3
@@ -38,14 +53,14 @@ resp = await client.send_receive_request({"Command": "DoSomething"})
 
 class RemoteXPCConnection:
     def __init__(self, address: tuple[str, int]):
-        self._previous_frame_data = b''
+        self._previous_frame_data = b""
         self.address = address
         self.next_message_id: dict[int, int] = {ROOT_CHANNEL: 0, REPLY_CHANNEL: 0}
         self.peer_info = None
         self._reader: Optional[asyncio.StreamReader] = None
         self._writer: Optional[asyncio.StreamWriter] = None
 
-    async def __aenter__(self) -> 'RemoteXPCConnection':
+    async def __aenter__(self) -> "RemoteXPCConnection":
         await self.connect()
         return self
 
@@ -56,7 +71,7 @@ class RemoteXPCConnection:
         self._reader, self._writer = await asyncio.open_connection(self.address[0], self.address[1])
         try:
             await self._do_handshake()
-        except Exception:  # noqa: E722
+        except Exception:
             await self.close()
             raise
 
@@ -64,16 +79,15 @@ class RemoteXPCConnection:
         if self._writer is None:
             return
         self._writer.close()
-        try:
+        with contextlib.suppress(ConnectionResetError):
             await self._writer.wait_closed()
-        except ConnectionResetError:
-            pass
         self._writer = None
         self._reader = None
 
     async def send_request(self, data: dict, wanting_reply: bool = False) -> None:
         xpc_wrapper = create_xpc_wrapper(
-            data, message_id=self.next_message_id[ROOT_CHANNEL], wanting_reply=wanting_reply)
+            data, message_id=self.next_message_id[ROOT_CHANNEL], wanting_reply=wanting_reply
+        )
         self._writer.write(DataFrame(stream_id=ROOT_CHANNEL, data=xpc_wrapper).serialize())
         await self._writer.drain()
 
@@ -84,7 +98,7 @@ class RemoteXPCConnection:
         while size < total_size:
             frame = await self._receive_next_data_frame()
 
-            if 'END_STREAM' in frame.flags:
+            if "END_STREAM" in frame.flags:
                 continue
 
             if frame.stream_id != stream_id:
@@ -92,12 +106,12 @@ class RemoteXPCConnection:
                 if xpc_wrapper.flags.FILE_TX_STREAM_REQUEST:
                     continue
 
-            assert frame.stream_id == stream_id, f'got {frame.stream_id} instead of {stream_id}'
+            assert frame.stream_id == stream_id, f"got {frame.stream_id} instead of {stream_id}"
             size += len(frame.data)
             yield frame.data
 
     async def receive_file(self, total_size: int) -> bytes:
-        buf = b''
+        buf = b""
         async for chunk in self.iter_file_chunks(total_size):
             buf += chunk
         return buf
@@ -107,7 +121,7 @@ class RemoteXPCConnection:
             frame = await self._receive_next_data_frame()
             try:
                 xpc_message = XpcWrapper.parse(self._previous_frame_data + frame.data).message
-                self._previous_frame_data = b''
+                self._previous_frame_data = b""
             except StreamError:
                 self._previous_frame_data += frame.data
                 continue
@@ -124,48 +138,56 @@ class RemoteXPCConnection:
 
     def shell(self) -> None:
         nest_asyncio.apply(asyncio.get_running_loop())
-        sys.argv = ['a']
+        sys.argv = ["a"]
         config = Config()
-        config.InteractiveShellApp.exec_lines = ['%autoawait asyncio']
-        print(highlight(SHELL_USAGE, lexers.PythonLexer(),
-                        formatters.Terminal256Formatter(style='native')))
-        IPython.start_ipython(config=config, user_ns={
-            'client': self,
-            'XpcInt64Type': XpcInt64Type,
-            'XpcUInt64Type': XpcUInt64Type,
-        })
+        config.InteractiveShellApp.exec_lines = ["%autoawait asyncio"]
+        print(highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")))
+        IPython.start_ipython(
+            config=config,
+            user_ns={
+                "client": self,
+                "XpcInt64Type": XpcInt64Type,
+                "XpcUInt64Type": XpcUInt64Type,
+            },
+        )
 
     async def _do_handshake(self) -> None:
         self._writer.write(HTTP2_MAGIC)
         await self._writer.drain()
 
         # send h2 headers
-        await self._send_frame(SettingsFrame(settings={
-            SettingsFrame.MAX_CONCURRENT_STREAMS: DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS,
-            SettingsFrame.INITIAL_WINDOW_SIZE: DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE,
-        }))
+        await self._send_frame(
+            SettingsFrame(
+                settings={
+                    SettingsFrame.MAX_CONCURRENT_STREAMS: DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS,
+                    SettingsFrame.INITIAL_WINDOW_SIZE: DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE,
+                }
+            )
+        )
         await self._send_frame(WindowUpdateFrame(stream_id=0, window_increment=DEFAULT_WIN_SIZE_INCR))
-        await self._send_frame(HeadersFrame(stream_id=ROOT_CHANNEL, flags=['END_HEADERS']))
+        await self._send_frame(HeadersFrame(stream_id=ROOT_CHANNEL, flags=["END_HEADERS"]))
 
         # send first actual requests
         await self.send_request({})
-        await self._send_frame(DataFrame(stream_id=ROOT_CHANNEL,
-                                         data=XpcWrapper.build({'size': 0, 'flags': 0x0201, 'payload': None})))
+        await self._send_frame(
+            DataFrame(stream_id=ROOT_CHANNEL, data=XpcWrapper.build({"size": 0, "flags": 0x0201, "payload": None}))
+        )
         self.next_message_id[ROOT_CHANNEL] += 1
         await self._open_channel(REPLY_CHANNEL, XpcFlags.INIT_HANDSHAKE)
         self.next_message_id[REPLY_CHANNEL] += 1
 
         settings_frame = await asyncio.wait_for(self._receive_frame(), FIRST_REPLY_TIMEOUT)
         if not isinstance(settings_frame, SettingsFrame):
-            raise ProtocolError(f'Got unexpected frame: {settings_frame} instead of a SettingsFrame')
+            raise ProtocolError(f"Got unexpected frame: {settings_frame} instead of a SettingsFrame")
 
-        await self._send_frame(SettingsFrame(flags=['ACK']))
+        await self._send_frame(SettingsFrame(flags=["ACK"]))
 
     async def _open_channel(self, stream_id: int, flags: int) -> None:
         flags |= XpcFlags.ALWAYS_SET
-        await self._send_frame(HeadersFrame(stream_id=stream_id, flags=['END_HEADERS']))
+        await self._send_frame(HeadersFrame(stream_id=stream_id, flags=["END_HEADERS"]))
         await self._send_frame(
-            DataFrame(stream_id=stream_id, data=XpcWrapper.build({'size': 0, 'flags': flags, 'payload': None})))
+            DataFrame(stream_id=stream_id, data=XpcWrapper.build({"size": 0, "flags": flags, "payload": None}))
+        )
 
     async def _send_frame(self, frame: Frame) -> None:
         self._writer.write(frame.serialize())
@@ -176,9 +198,9 @@ class RemoteXPCConnection:
             frame = await self._receive_frame()
 
             if isinstance(frame, GoAwayFrame):
-                raise StreamClosedError(f'Got {frame}')
+                raise StreamClosedError(f"Got {frame}")
             if isinstance(frame, RstStreamFrame):
-                raise StreamClosedError(f'Got {frame}')
+                raise StreamClosedError(f"Got {frame}")
             if not isinstance(frame, DataFrame):
                 continue
 
@@ -195,11 +217,11 @@ class RemoteXPCConnection:
         return frame
 
     async def _recvall(self, size: int) -> bytes:
-        data = b''
+        data = b""
         while len(data) < size:
             try:
                 chunk = await self._reader.readexactly(size - len(data))
-            except IncompleteReadError:
-                raise ConnectionAbortedError()
+            except IncompleteReadError as e:
+                raise ConnectionAbortedError() from e
             data += chunk
         return data