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

pymobiledevice3/services/power_assertion.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import contextlib
+from typing import Optional
 
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
@@ -7,8 +8,8 @@ from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class PowerAssertionService(LockdownService):
-    RSD_SERVICE_NAME = 'com.apple.mobile.assertion_agent.shim.remote'
-    SERVICE_NAME = 'com.apple.mobile.assertion_agent'
+    RSD_SERVICE_NAME = "com.apple.mobile.assertion_agent.shim.remote"
+    SERVICE_NAME = "com.apple.mobile.assertion_agent"
 
     def __init__(self, lockdown: LockdownServiceProvider):
         if isinstance(lockdown, LockdownClient):
@@ -17,17 +18,17 @@ class PowerAssertionService(LockdownService):
             super().__init__(lockdown, self.RSD_SERVICE_NAME)
 
     @contextlib.contextmanager
-    def create_power_assertion(self, type_: str, name: str, timeout: float, details: str = None):
-        """ Trigger IOPMAssertionCreateWithName """
+    def create_power_assertion(self, type_: str, name: str, timeout: float, details: Optional[str] = None):
+        """Trigger IOPMAssertionCreateWithName"""
         msg = {
-            'CommandKey': 'CommandCreateAssertion',
-            'AssertionTypeKey': type_,
-            'AssertionNameKey': name,
-            'AssertionTimeoutKey': timeout,
+            "CommandKey": "CommandCreateAssertion",
+            "AssertionTypeKey": type_,
+            "AssertionNameKey": name,
+            "AssertionTimeoutKey": timeout,
         }
 
         if details is not None:
-            msg['AssertionDetailKey'] = details
+            msg["AssertionDetailKey"] = details
 
         self.service.send_recv_plist(msg)
         yield

pymobiledevice3/services/preboard.py

@@ -6,8 +6,8 @@ from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class PreboardService(LockdownService):
-    RSD_SERVICE_NAME = 'com.apple.preboardservice_v2.shim.remote'
-    SERVICE_NAME = 'com.apple.preboardservice_v2'
+    RSD_SERVICE_NAME = "com.apple.preboardservice_v2.shim.remote"
+    SERVICE_NAME = "com.apple.preboardservice_v2"
 
     def __init__(self, lockdown: LockdownServiceProvider):
         if isinstance(lockdown, LockdownClient):
@@ -16,7 +16,7 @@ class PreboardService(LockdownService):
             super().__init__(lockdown, self.RSD_SERVICE_NAME)
 
     def create_stashbag(self, manifest):
-        return self.service.send_recv_plist({'Command': 'CreateStashbag', 'Manifest': manifest})
+        return self.service.send_recv_plist({"Command": "CreateStashbag", "Manifest": manifest})
 
     def commit(self, manifest):
-        return self.service.send_recv_plist({'Command': 'CommitStashbag', 'Manifest': manifest})
+        return self.service.send_recv_plist({"Command": "CommitStashbag", "Manifest": manifest})

pymobiledevice3/services/remote_fetch_symbols.py

@@ -15,32 +15,34 @@ class DSCFile:
 
 
 class RemoteFetchSymbolsService(RemoteService):
-    SERVICE_NAME = 'com.apple.dt.remoteFetchSymbols'
+    SERVICE_NAME = "com.apple.dt.remoteFetchSymbols"
 
     def __init__(self, rsd: RemoteServiceDiscoveryService):
         super().__init__(rsd, self.SERVICE_NAME)
 
     async def get_dsc_file_list(self) -> list[DSCFile]:
         files: list[DSCFile] = []
-        response = await self.service.send_receive_request({'XPCDictionary_sideChannel': uuid.uuid4(), 'DSCFilePaths': []})
-        file_count = response['DSCFilePaths']
-        for i in range(file_count):
+        response = await self.service.send_receive_request({
+            "XPCDictionary_sideChannel": uuid.uuid4(),
+            "DSCFilePaths": [],
+        })
+        file_count = response["DSCFilePaths"]
+        for _i in range(file_count):
             response = await self.service.receive_response()
-            response = response['DSCFilePaths']
-            file_transfer = response['fileTransfer']
-            expected_length = file_transfer['expectedLength']
-            file_path = response['filePath']
+            response = response["DSCFilePaths"]
+            file_transfer = response["fileTransfer"]
+            expected_length = file_transfer["expectedLength"]
+            file_path = response["filePath"]
             files.append(DSCFile(file_path=file_path, file_size=expected_length))
         return files
 
     async def download(self, out: Path) -> None:
         files = await self.get_dsc_file_list()
         for i, file in enumerate(files):
-            self.logger.info(f'Downloading {file}')
+            self.logger.info(f"Downloading {file}")
             out_file = out / file.file_path[1:]  # trim the "/" prefix
             out_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(out_file, 'wb') as f:
-                with tqdm(total=files[i].file_size, dynamic_ncols=True) as pb:
-                    async for chunk in self.service.iter_file_chunks(files[i].file_size, file_idx=i):
-                        f.write(chunk)
-                        pb.update(len(chunk))
+            with open(out_file, "wb") as f, tqdm(total=files[i].file_size, dynamic_ncols=True) as pb:
+                async for chunk in self.service.iter_file_chunks(files[i].file_size, file_idx=i):
+                    f.write(chunk)
+                    pb.update(len(chunk))

pymobiledevice3/services/remote_server.py

@@ -1,3 +1,4 @@
+import contextlib
 import copy
 import io
 import os
@@ -6,18 +7,33 @@ import uuid
 from functools import partial
 from pprint import pprint
 from queue import Empty, Queue
+from typing import ClassVar, Optional
 
 import IPython
 from bpylist2 import archiver
-from construct import Adapter, Const, Default, GreedyBytes, GreedyRange, Int16ul, Int32sl, Int32ul, Int64ul, Prefixed, \
-    Select, Struct, Switch, this
+from construct import (
+    Adapter,
+    Const,
+    Default,
+    GreedyBytes,
+    GreedyRange,
+    Int16ul,
+    Int32sl,
+    Int32ul,
+    Int64ul,
+    Prefixed,
+    Select,
+    Struct,
+    Switch,
+    this,
+)
 from pygments import formatters, highlight, lexers
 
 from pymobiledevice3.exceptions import DvtException, UnrecognizedSelectorError
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.lockdown_service import LockdownService
 
-SHELL_USAGE = '''
+SHELL_USAGE = """
 # This shell allows you to send messages to the DVTSecureSocketProxy and receive answers easily.
 # Generally speaking, each channel represents a group of actions.
 # Calling actions is done using a selector and auxiliary (parameters).
@@ -45,7 +61,7 @@ channel.killPid_(args, expects_reply=False) # Killing a process doesn't require
 # In some rare cases, you might want to receive the auxiliary and the selector return value.
 # For that cases you can use the recv_plist method.
 return_value, auxiliary = developer.recv_plist()
-'''
+"""
 
 
 class BplitAdapter(Adapter):
@@ -57,29 +73,39 @@ class BplitAdapter(Adapter):
 
 
 message_aux_t_struct = Struct(
-    'magic' / Default(Int64ul, 0x1f0),
-    'aux' / Prefixed(Int64ul, GreedyRange(Struct(
-        '_empty_dictionary' / Select(Const(0xa, Int32ul), Int32ul),
-        'type' / Int32ul,
-        'value' / Switch(this.type, {2: BplitAdapter(Prefixed(Int32ul, GreedyBytes)), 3: Int32ul, 6: Int64ul},
-                         default=GreedyBytes),
-    )))
+    "magic" / Default(Int64ul, 0x1F0),
+    "aux"
+    / Prefixed(
+        Int64ul,
+        GreedyRange(
+            Struct(
+                "_empty_dictionary" / Select(Const(0xA, Int32ul), Int32ul),
+                "type" / Int32ul,
+                "value"
+                / Switch(
+                    this.type,
+                    {2: BplitAdapter(Prefixed(Int32ul, GreedyBytes)), 3: Int32ul, 6: Int64ul},
+                    default=GreedyBytes,
+                ),
+            )
+        ),
+    ),
 )
 dtx_message_header_struct = Struct(
-    'magic' / Const(0x1F3D5B79, Int32ul),
-    'cb' / Int32ul,
-    'fragmentId' / Int16ul,
-    'fragmentCount' / Int16ul,
-    'length' / Int32ul,
-    'identifier' / Int32ul,
-    'conversationIndex' / Int32ul,
-    'channelCode' / Int32sl,
-    'expectsReply' / Int32ul,
+    "magic" / Const(0x1F3D5B79, Int32ul),
+    "cb" / Int32ul,
+    "fragmentId" / Int16ul,
+    "fragmentCount" / Int16ul,
+    "length" / Int32ul,
+    "identifier" / Int32ul,
+    "conversationIndex" / Int32ul,
+    "channelCode" / Int32sl,
+    "expectsReply" / Int32ul,
 )
 dtx_message_payload_header_struct = Struct(
-    'flags' / Int32ul,
-    'auxiliaryLength' / Int32ul,
-    'totalLength' / Int64ul,
+    "flags" / Int32ul,
+    "auxiliaryLength" / Int32ul,
+    "totalLength" / Int64ul,
 )
 
 
@@ -88,25 +114,25 @@ class MessageAux:
         self.values = []
 
     def append_int(self, value: int):
-        self.values.append({'type': 3, 'value': value})
+        self.values.append({"type": 3, "value": value})
         return self
 
     def append_long(self, value: int):
-        self.values.append({'type': 6, 'value': value})
+        self.values.append({"type": 6, "value": value})
         return self
 
     def append_obj(self, value):
-        self.values.append({'type': 2, 'value': value})
+        self.values.append({"type": 2, "value": value})
         return self
 
     def __bytes__(self):
-        return message_aux_t_struct.build(dict(aux=self.values))
+        return message_aux_t_struct.build({"aux": self.values})
 
 
 class DTTapMessage:
     @staticmethod
     def decode_archive(archive_obj):
-        return archive_obj.decode('DTTapMessagePlist')
+        return archive_obj.decode("DTTapMessagePlist")
 
 
 class NSNull:
@@ -122,10 +148,10 @@ class NSError:
 
     @staticmethod
     def decode_archive(archive_obj):
-        user_info = archive_obj.decode('NSUserInfo')
-        if user_info.get('NSLocalizedDescription', '').endswith(' - it does not respond to the selector'):
+        user_info = archive_obj.decode("NSUserInfo")
+        if user_info.get("NSLocalizedDescription", "").endswith(" - it does not respond to the selector"):
             raise UnrecognizedSelectorError(user_info)
-        raise DvtException(archive_obj.decode('NSUserInfo'))
+        raise DvtException(archive_obj.decode("NSUserInfo"))
 
 
 class NSUUID(uuid.UUID):
@@ -135,11 +161,11 @@ class NSUUID(uuid.UUID):
         return NSUUID(bytes=os.urandom(16))
 
     def encode_archive(self, archive_obj: archiver.ArchivingObject):
-        archive_obj.encode('NS.uuidbytes', self.bytes)
+        archive_obj.encode("NS.uuidbytes", self.bytes)
 
     @staticmethod
     def decode_archive(archive_obj: archiver.ArchivedObject):
-        return NSUUID(bytes=archive_obj.decode('NS.uuidbytes'))
+        return NSUUID(bytes=archive_obj.decode("NS.uuidbytes"))
 
 
 class NSURL:
@@ -148,74 +174,72 @@ class NSURL:
         self.relative = relative
 
     def encode_archive(self, archive_obj: archiver.ArchivingObject):
-        archive_obj.encode('NS.base', self.base)
-        archive_obj.encode('NS.relative', self.relative)
+        archive_obj.encode("NS.base", self.base)
+        archive_obj.encode("NS.relative", self.relative)
 
     @staticmethod
     def decode_archive(archive_obj: archiver.ArchivedObject):
-        return NSURL(archive_obj.decode('NS.base'), archive_obj.decode('NS.relative'))
+        return NSURL(archive_obj.decode("NS.base"), archive_obj.decode("NS.relative"))
 
 
 class NSValue:
     @staticmethod
     def decode_archive(archive_obj: archiver.ArchivedObject):
-        return archive_obj.decode('NS.rectval')
+        return archive_obj.decode("NS.rectval")
 
 
 class NSMutableData:
     @staticmethod
     def decode_archive(archive_obj: archiver.ArchivedObject):
-        return archive_obj.decode('NS.data')
+        return archive_obj.decode("NS.data")
 
 
 class NSMutableString:
     @staticmethod
     def decode_archive(archive_obj: archiver.ArchivedObject):
-        return archive_obj.decode('NS.string')
+        return archive_obj.decode("NS.string")
 
 
 class XCTestConfiguration:
-    _default = {
+    _default: ClassVar = {
         # 'testBundleURL': UID(3),
         # 'sessionIdentifier': UID(8), # UUID
-        'aggregateStatisticsBeforeCrash': {
-            'XCSuiteRecordsKey': {}
-        },
-        'automationFrameworkPath': '/Developer/Library/PrivateFrameworks/XCTAutomationSupport.framework',
-        'baselineFileRelativePath': None,
-        'baselineFileURL': None,
-        'defaultTestExecutionTimeAllowance': None,
-        'disablePerformanceMetrics': False,
-        'emitOSLogs': False,
-        'formatVersion': plistlib.UID(2),  # store in UID
-        'gatherLocalizableStringsData': False,
-        'initializeForUITesting': True,
-        'maximumTestExecutionTimeAllowance': None,
-        'productModuleName': 'WebDriverAgentRunner',  # set to other value is also OK
-        'randomExecutionOrderingSeed': None,
-        'reportActivities': True,
-        'reportResultsToIDE': True,
-        'systemAttachmentLifetime': 2,
-        'targetApplicationArguments': [],  # maybe useless
-        'targetApplicationBundleID': None,
-        'targetApplicationEnvironment': None,
-        'targetApplicationPath': '/whatever-it-does-not-matter/but-should-not-be-empty',
-        'testApplicationDependencies': {},
-        'testApplicationUserOverrides': None,
-        'testBundleRelativePath': None,
-        'testExecutionOrdering': 0,
-        'testTimeoutsEnabled': False,
-        'testsDrivenByIDE': False,
-        'testsMustRunOnMainThread': True,
-        'testsToRun': None,
-        'testsToSkip': None,
-        'treatMissingBaselinesAsFailures': False,
-        'userAttachmentLifetime': 1
+        "aggregateStatisticsBeforeCrash": {"XCSuiteRecordsKey": {}},
+        "automationFrameworkPath": "/Developer/Library/PrivateFrameworks/XCTAutomationSupport.framework",
+        "baselineFileRelativePath": None,
+        "baselineFileURL": None,
+        "defaultTestExecutionTimeAllowance": None,
+        "disablePerformanceMetrics": False,
+        "emitOSLogs": False,
+        "formatVersion": plistlib.UID(2),  # store in UID
+        "gatherLocalizableStringsData": False,
+        "initializeForUITesting": True,
+        "maximumTestExecutionTimeAllowance": None,
+        "productModuleName": "WebDriverAgentRunner",  # set to other value is also OK
+        "randomExecutionOrderingSeed": None,
+        "reportActivities": True,
+        "reportResultsToIDE": True,
+        "systemAttachmentLifetime": 2,
+        "targetApplicationArguments": [],  # maybe useless
+        "targetApplicationBundleID": None,
+        "targetApplicationEnvironment": None,
+        "targetApplicationPath": "/whatever-it-does-not-matter/but-should-not-be-empty",
+        "testApplicationDependencies": {},
+        "testApplicationUserOverrides": None,
+        "testBundleRelativePath": None,
+        "testExecutionOrdering": 0,
+        "testTimeoutsEnabled": False,
+        "testsDrivenByIDE": False,
+        "testsMustRunOnMainThread": True,
+        "testsToRun": None,
+        "testsToSkip": None,
+        "treatMissingBaselinesAsFailures": False,
+        "userAttachmentLifetime": 1,
     }
 
     def __init__(self, kv: dict):
-        assert 'testBundleURL' in kv
-        assert 'sessionIdentifier' in kv
+        assert "testBundleURL" in kv
+        assert "sessionIdentifier" in kv
         self._config = copy.deepcopy(self._default)
         self._config.update(kv)
 
@@ -228,27 +252,29 @@ class XCTestConfiguration:
         return archive_obj.object
 
 
-archiver.update_class_map({'DTSysmonTapMessage': DTTapMessage,
-                           'DTTapHeartbeatMessage': DTTapMessage,
-                           'DTTapStatusMessage': DTTapMessage,
-                           'DTKTraceTapMessage': DTTapMessage,
-                           'DTActivityTraceTapMessage': DTTapMessage,
-                           'DTTapMessage': DTTapMessage,
-                           'NSNull': NSNull,
-                           'NSError': NSError,
-                           'NSUUID': NSUUID,
-                           'NSURL': NSURL,
-                           'NSValue': NSValue,
-                           'NSMutableData': NSMutableData,
-                           'NSMutableString': NSMutableString,
-                           'XCTestConfiguration': XCTestConfiguration})
+archiver.update_class_map({
+    "DTSysmonTapMessage": DTTapMessage,
+    "DTTapHeartbeatMessage": DTTapMessage,
+    "DTTapStatusMessage": DTTapMessage,
+    "DTKTraceTapMessage": DTTapMessage,
+    "DTActivityTraceTapMessage": DTTapMessage,
+    "DTTapMessage": DTTapMessage,
+    "NSNull": NSNull,
+    "NSError": NSError,
+    "NSUUID": NSUUID,
+    "NSURL": NSURL,
+    "NSValue": NSValue,
+    "NSMutableData": NSMutableData,
+    "NSMutableString": NSMutableString,
+    "XCTestConfiguration": XCTestConfiguration,
+})
 
-archiver.Archive.inline_types = list(set(archiver.Archive.inline_types + [bytes]))
+archiver.Archive.inline_types = list({*archiver.Archive.inline_types, bytes})
 
 
 class Channel(int):
     @classmethod
-    def create(cls, value: int, service: 'RemoteServer'):
+    def create(cls, value: int, service: "RemoteServer"):
         channel = cls(value)
         channel._service = service
         return channel
@@ -270,10 +296,7 @@ class Channel(int):
         """
         Sanitize python name to ObjectiveC name.
         """
-        if name.startswith('_'):
-            name = '_' + name[1:].replace('_', ':')
-        else:
-            name = name.replace('_', ':')
+        name = "_" + name[1:].replace("_", ":") if name.startswith("_") else name.replace("_", ":")
         return name
 
     def __getitem__(self, item):
@@ -286,8 +309,8 @@ class Channel(int):
 class ChannelFragmenter:
     def __init__(self):
         self._messages = Queue()
-        self._packet_data = b''
-        self._stream_packet_data = b''
+        self._packet_data = b""
+        self._stream_packet_data = b""
 
     def get(self):
         return self._messages.get_nowait()
@@ -298,13 +321,13 @@ class ChannelFragmenter:
             if mheader.fragmentId == mheader.fragmentCount - 1:
                 # last message
                 self._messages.put(self._packet_data)
-                self._packet_data = b''
+                self._packet_data = b""
         else:
             self._stream_packet_data += chunk
             if mheader.fragmentId == mheader.fragmentCount - 1:
                 # last message
                 self._messages.put(self._stream_packet_data)
-                self._stream_packet_data = b''
+                self._stream_packet_data = b""
 
 
 class RemoteServer(LockdownService):
@@ -351,16 +374,22 @@ class RemoteServer(LockdownService):
         }
     }
     ```
-    """  # noqa: E501
+    """
+
     BROADCAST_CHANNEL = 0
     INSTRUMENTS_MESSAGE_TYPE = 2
     EXPECTS_REPLY_MASK = 0x1000
 
-    def __init__(self, lockdown: LockdownServiceProvider, service_name, remove_ssl_context: bool = True,
-                 is_developer_service: bool = True):
+    def __init__(
+        self,
+        lockdown: LockdownServiceProvider,
+        service_name,
+        remove_ssl_context: bool = True,
+        is_developer_service: bool = True,
+    ):
         super().__init__(lockdown, service_name, is_developer_service=is_developer_service)
 
-        if remove_ssl_context and hasattr(self.service.socket, '_sslobj'):
+        if remove_ssl_context and hasattr(self.service.socket, "_sslobj"):
             self.service.socket._sslobj = None
 
         self.supported_identifiers = {}
@@ -372,22 +401,23 @@ class RemoteServer(LockdownService):
 
     def shell(self):
         IPython.embed(
-            header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style='native')),
+            header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")),
             user_ns={
-                'developer': self,
-                'broadcast': self.broadcast,
-                'MessageAux': MessageAux,
-            })
+                "developer": self,
+                "broadcast": self.broadcast,
+                "MessageAux": MessageAux,
+            },
+        )
 
     def perform_handshake(self):
         args = MessageAux()
-        args.append_obj({'com.apple.private.DTXBlockCompression': 0, 'com.apple.private.DTXConnection': 1})
-        self.send_message(0, '_notifyOfPublishedCapabilities:', args, expects_reply=False)
+        args.append_obj({"com.apple.private.DTXBlockCompression": 0, "com.apple.private.DTXConnection": 1})
+        self.send_message(0, "_notifyOfPublishedCapabilities:", args, expects_reply=False)
         ret, aux = self.recv_plist()
-        if ret != '_notifyOfPublishedCapabilities:':
-            raise ValueError('Invalid answer')
+        if ret != "_notifyOfPublishedCapabilities:":
+            raise ValueError("Invalid answer")
         if not len(aux[0]):
-            raise ValueError('Invalid answer')
+            raise ValueError("Invalid answer")
         self.supported_identifiers = aux[0].value
 
     def make_channel(self, identifier) -> Channel:
@@ -399,34 +429,39 @@ class RemoteServer(LockdownService):
         self.last_channel_code += 1
         code = self.last_channel_code
         args = MessageAux().append_int(code).append_obj(identifier)
-        self.send_message(0, '_requestChannelWithCode:identifier:', args)
-        ret, aux = self.recv_plist()
+        self.send_message(0, "_requestChannelWithCode:identifier:", args)
+        ret, _aux = self.recv_plist()
         assert ret is None
         channel = Channel.create(code, self)
         self.channel_cache[identifier] = channel
         self.channel_messages[code] = ChannelFragmenter()
         return channel
 
-    def send_message(self, channel: int, selector: str = None, args: MessageAux = None, expects_reply: bool = True):
+    def send_message(
+        self, channel: int, selector: Optional[str] = None, args: MessageAux = None, expects_reply: bool = True
+    ):
         self.cur_message += 1
 
-        aux = bytes(args) if args is not None else b''
-        sel = archiver.archive(selector) if selector is not None else b''
+        aux = bytes(args) if args is not None else b""
+        sel = archiver.archive(selector) if selector is not None else b""
         flags = self.INSTRUMENTS_MESSAGE_TYPE
         if expects_reply:
             flags |= self.EXPECTS_REPLY_MASK
-        pheader = dtx_message_payload_header_struct.build(dict(flags=flags, auxiliaryLength=len(aux),
-                                                               totalLength=len(aux) + len(sel)))
-        mheader = dtx_message_header_struct.build(dict(
-            cb=dtx_message_header_struct.sizeof(),
-            fragmentId=0,
-            fragmentCount=1,
-            length=dtx_message_payload_header_struct.sizeof() + len(aux) + len(sel),
-            identifier=self.cur_message,
-            conversationIndex=0,
-            channelCode=channel,
-            expectsReply=int(expects_reply)
-        ))
+        pheader = dtx_message_payload_header_struct.build({
+            "flags": flags,
+            "auxiliaryLength": len(aux),
+            "totalLength": len(aux) + len(sel),
+        })
+        mheader = dtx_message_header_struct.build({
+            "cb": dtx_message_header_struct.sizeof(),
+            "fragmentId": 0,
+            "fragmentCount": 1,
+            "length": dtx_message_payload_header_struct.sizeof() + len(aux) + len(sel),
+            "identifier": self.cur_message,
+            "conversationIndex": 0,
+            "channelCode": channel,
+            "expectsReply": int(expects_reply),
+        })
         msg = mheader + pheader + aux + sel
         self.service.sendall(msg)
 
@@ -435,11 +470,11 @@ class RemoteServer(LockdownService):
         if data is not None:
             try:
                 data = archiver.unarchive(data)
-            except archiver.MissingClassMapping as e:
+            except archiver.MissingClassMapping:
                 pprint(plistlib.loads(data))
-                raise e
+                raise
             except plistlib.InvalidFileException:
-                self.logger.warning(f'got an invalid plist: {data[:40]}')
+                self.logger.warning(f"got an invalid plist: {data[:40]}")
         return data, aux
 
     def recv_message(self, channel: int = BROADCAST_CHANNEL):
@@ -448,12 +483,9 @@ class RemoteServer(LockdownService):
 
         compression = (pheader.flags & 0xFF000) >> 12
         if compression:
-            raise NotImplementedError('Compressed')
+            raise NotImplementedError("Compressed")
 
-        if pheader.auxiliaryLength:
-            aux = message_aux_t_struct.parse_stream(packet_stream).aux
-        else:
-            aux = None
+        aux = message_aux_t_struct.parse_stream(packet_stream).aux if pheader.auxiliaryLength else None
         obj_size = pheader.totalLength - pheader.auxiliaryLength
         data = packet_stream.read(obj_size) if obj_size else None
         return data, aux
@@ -477,9 +509,8 @@ class RemoteServer(LockdownService):
                 if received_channel_code not in self.channel_messages:
                     self.channel_messages[received_channel_code] = ChannelFragmenter()
 
-                if not mheader.conversationIndex:
-                    if mheader.identifier > self.cur_message:
-                        self.cur_message = mheader.identifier
+                if not mheader.conversationIndex and mheader.identifier > self.cur_message:
+                    self.cur_message = mheader.identifier
 
                 if mheader.fragmentCount > 1 and mheader.fragmentId == 0:
                     # when reading multiple message fragments, the first fragment contains only a message header
@@ -493,15 +524,14 @@ class RemoteServer(LockdownService):
 
     def close(self):
         aux = MessageAux()
-        codes = [code for code in self.channel_messages.keys() if code > 0]
+        codes = [code for code in self.channel_messages if code > 0]
         if codes:
             for code in codes:
                 aux.append_int(code)
-            try:
-                self.send_message(self.BROADCAST_CHANNEL, '_channelCanceled:', aux, expects_reply=False)
-            except OSError:
+
+            with contextlib.suppress(OSError):
                 # ignore: OSError: [Errno 9] Bad file descriptor
-                pass
+                self.send_message(self.BROADCAST_CHANNEL, "_channelCanceled:", aux, expects_reply=False)
         super().close()