pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/services/dvt/instruments/device_info.py

@@ -7,7 +7,7 @@ from pymobiledevice3.services.remote_server import MessageAux
 
 
 class DeviceInfo:
-    IDENTIFIER = 'com.apple.instruments.server.services.deviceinfo'
+    IDENTIFIER = "com.apple.instruments.server.services.deviceinfo"
 
     def __init__(self, dvt):
         self._channel = dvt.make_channel(self.IDENTIFIER)
@@ -41,33 +41,42 @@ class DeviceInfo:
         result = self._channel.receive_plist()
         assert isinstance(result, list)
         for process in result:
-            if 'startDate' in process:
-                process['startDate'] = datetime.fromtimestamp(process['startDate'])
+            if "startDate" in process:
+                process["startDate"] = datetime.fromtimestamp(process["startDate"])
         return result
 
+    def is_running_pid(self, pid: int) -> bool:
+        """
+        check if pid is running
+        :param pid: process identifier
+        :return: whether if it is running or not
+        """
+        self._channel.isRunningPid_(MessageAux().append_obj(pid))
+        return self._channel.receive_plist()
+
     def system_information(self):
-        return self.request_information('systemInformation')
+        return self.request_information("systemInformation")
 
     def hardware_information(self):
-        return self.request_information('hardwareInformation')
+        return self.request_information("hardwareInformation")
 
     def network_information(self):
-        return self.request_information('networkInformation')
+        return self.request_information("networkInformation")
 
     def mach_time_info(self):
-        return self.request_information('machTimeInfo')
+        return self.request_information("machTimeInfo")
 
     def mach_kernel_name(self) -> str:
-        return self.request_information('machKernelName')
+        return self.request_information("machKernelName")
 
     def kpep_database(self) -> typing.Optional[dict]:
-        kpep_database = self.request_information('kpepDatabase')
+        kpep_database = self.request_information("kpepDatabase")
         if kpep_database is not None:
             return plistlib.loads(kpep_database)
 
     def trace_codes(self):
-        codes_file = self.request_information('traceCodesFile')
-        return {int(k, 16): v for k, v in map(lambda line: line.split(), codes_file.splitlines())}
+        codes_file = self.request_information("traceCodesFile")
+        return {int(k, 16): v for k, v in (line.split() for line in codes_file.splitlines())}
 
     def request_information(self, selector_name):
         self._channel[selector_name]()

pymobiledevice3/services/dvt/instruments/energy_monitor.py

@@ -2,7 +2,7 @@ from pymobiledevice3.services.remote_server import MessageAux
 
 
 class EnergyMonitor:
-    IDENTIFIER = 'com.apple.xcode.debug-gauge-data-providers.Energy'
+    IDENTIFIER = "com.apple.xcode.debug-gauge-data-providers.Energy"
 
     def __init__(self, dvt, pid_list: list):
         self._channel = dvt.make_channel(self.IDENTIFIER)

pymobiledevice3/services/dvt/instruments/graphics.py

@@ -2,7 +2,7 @@ from pymobiledevice3.services.remote_server import MessageAux
 
 
 class Graphics:
-    IDENTIFIER = 'com.apple.instruments.server.services.graphics.opengl'
+    IDENTIFIER = "com.apple.instruments.server.services.graphics.opengl"
 
     def __init__(self, dvt):
         self._channel = dvt.make_channel(self.IDENTIFIER)

pymobiledevice3/services/dvt/instruments/location_simulation.py

@@ -3,7 +3,7 @@ from pymobiledevice3.services.remote_server import MessageAux
 
 
 class LocationSimulation(LocationSimulationBase):
-    IDENTIFIER = 'com.apple.instruments.server.services.LocationSimulation'
+    IDENTIFIER = "com.apple.instruments.server.services.LocationSimulation"
 
     def __init__(self, dvt):
         super().__init__()

pymobiledevice3/services/dvt/instruments/location_simulation_base.py

@@ -29,15 +29,15 @@ class LocationSimulationBase:
                 for point in segment.points:
                     if last_time is not None:
                         duration = (point.time - last_time).total_seconds()
-                        if duration >= 0:
-                            if not disable_sleep:
-
-                                if timing_randomness_range:
-                                    gpx_timing_noise = random.randint(-timing_randomness_range, timing_randomness_range) / 1000
-                                    duration += gpx_timing_noise
-
-                                self.logger.info(f'waiting for {duration:.3f}s')
-                                time.sleep(duration)
+                        if duration >= 0 and not disable_sleep:
+                            if timing_randomness_range:
+                                gpx_timing_noise = (
+                                    random.randint(-timing_randomness_range, timing_randomness_range) / 1000
+                                )
+                                duration += gpx_timing_noise
+
+                            self.logger.info(f"waiting for {duration:.3f}s")
+                            time.sleep(duration)
                     last_time = point.time
-                    self.logger.info(f'set location to {point.latitude} {point.longitude}')
+                    self.logger.info(f"set location to {point.latitude} {point.longitude}")
                     self.set(point.latitude, point.longitude)

pymobiledevice3/services/dvt/instruments/network_monitor.py

@@ -11,21 +11,21 @@ class IpAddressAdapter(Adapter):
 
 
 address_t = Struct(
-    'len' / Int8ul,
-    'family' / Int8ul,
-    'port' / Int16ub,
-    'data' / Switch(this.len, {
-        0x1c: Struct(
-            'flow_info' / Int32ul,
-            'address' / IpAddressAdapter(Bytes(16)),
-            'scope_id' / Int32ul,
-        ),
-        0x10: Struct(
-            'address' / IpAddressAdapter(Bytes(4)),
-            '_zero' / Bytes(8)
-        )
-    })
-
+    "len" / Int8ul,
+    "family" / Int8ul,
+    "port" / Int16ub,
+    "data"
+    / Switch(
+        this.len,
+        {
+            0x1C: Struct(
+                "flow_info" / Int32ul,
+                "address" / IpAddressAdapter(Bytes(16)),
+                "scope_id" / Int32ul,
+            ),
+            0x10: Struct("address" / IpAddressAdapter(Bytes(4)), "_zero" / Bytes(8)),
+        },
+    ),
 )
 
 MESSAGE_TYPE_INTERFACE_DETECTION = 0
@@ -67,7 +67,7 @@ class ConnectionUpdateEvent:
 
 
 class NetworkMonitor:
-    IDENTIFIER = 'com.apple.instruments.server.services.networking'
+    IDENTIFIER = "com.apple.instruments.server.services.networking"
 
     def __init__(self, dvt):
         self.logger = logging.getLogger(__name__)
@@ -98,5 +98,5 @@ class NetworkMonitor:
             elif message[0] == MESSAGE_TYPE_CONNECTION_UPDATE:
                 event = ConnectionUpdateEvent(*message[1])
             else:
-                self.logger.warning(f'unsupported event type: {message[0]}')
+                self.logger.warning(f"unsupported event type: {message[0]}")
             yield event

pymobiledevice3/services/dvt/instruments/notifications.py

@@ -2,7 +2,7 @@ from pymobiledevice3.services.remote_server import MessageAux
 
 
 class Notifications:
-    IDENTIFIER = 'com.apple.instruments.server.services.mobilenotifications'
+    IDENTIFIER = "com.apple.instruments.server.services.mobilenotifications"
 
     def __init__(self, dvt):
         self._dvt = dvt

pymobiledevice3/services/dvt/instruments/process_control.py

@@ -2,6 +2,7 @@ import dataclasses
 import typing
 from typing import Optional
 
+from pymobiledevice3.exceptions import DisableMemoryLimitError
 from pymobiledevice3.osu.os_utils import get_os_utils
 from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocketProxyService
 from pymobiledevice3.services.remote_server import MessageAux
@@ -16,7 +17,7 @@ class OutputReceivedEvent:
     message: str
 
     @classmethod
-    def create(cls, message) -> 'OutputReceivedEvent':
+    def create(cls, message) -> "OutputReceivedEvent":
         try:
             date = OSUTIL.parse_timestamp(message[2].value)
         except (ValueError, OSError):
@@ -26,7 +27,7 @@ class OutputReceivedEvent:
 
 
 class ProcessControl:
-    IDENTIFIER = 'com.apple.instruments.server.services.processcontrol'
+    IDENTIFIER = "com.apple.instruments.server.services.processcontrol"
 
     def __init__(self, dvt: DvtSecureSocketProxyService):
         self._channel = dvt.make_channel(self.IDENTIFIER)
@@ -40,6 +41,15 @@ class ProcessControl:
         self._channel.sendSignal_toPid_(MessageAux().append_obj(sig).append_obj(pid), expects_reply=True)
         return self._channel.receive_plist()
 
+    def disable_memory_limit_for_pid(self, pid: int) -> None:
+        """
+        Waive memory limit for a given pid
+        :param pid: process id.
+        """
+        self._channel.requestDisableMemoryLimitsForPid_(MessageAux().append_int(pid), expects_reply=True)
+        if not self._channel.receive_plist():
+            raise DisableMemoryLimitError()
+
     def kill(self, pid: int):
         """
         Kill a process.
@@ -48,11 +58,20 @@ class ProcessControl:
         self._channel.killPid_(MessageAux().append_obj(pid), expects_reply=False)
 
     def process_identifier_for_bundle_identifier(self, app_bundle_identifier: str) -> int:
-        self._channel.processIdentifierForBundleIdentifier_(MessageAux().append_obj(app_bundle_identifier), expects_reply=True)
+        self._channel.processIdentifierForBundleIdentifier_(
+            MessageAux().append_obj(app_bundle_identifier), expects_reply=True
+        )
         return self._channel.receive_plist()
 
-    def launch(self, bundle_id: str, arguments=None, kill_existing: bool = True, start_suspended: bool = False,
-               environment: Optional[dict] = None, extra_options: Optional[dict] = None) -> int:
+    def launch(
+        self,
+        bundle_id: str,
+        arguments=None,
+        kill_existing: bool = True,
+        start_suspended: bool = False,
+        environment: Optional[dict] = None,
+        extra_options: Optional[dict] = None,
+    ) -> int:
         """
         Launch a process.
         :param bundle_id: Bundle id of the process.
@@ -66,13 +85,19 @@ class ProcessControl:
         arguments = [] if arguments is None else arguments
         environment = {} if environment is None else environment
         options = {
-            'StartSuspendedKey': start_suspended,
-            'KillExisting': kill_existing,
+            "StartSuspendedKey": start_suspended,
+            "KillExisting": kill_existing,
         }
         if extra_options:
             options.update(extra_options)
-        args = MessageAux().append_obj('').append_obj(bundle_id).append_obj(environment).append_obj(
-            arguments).append_obj(options)
+        args = (
+            MessageAux()
+            .append_obj("")
+            .append_obj(bundle_id)
+            .append_obj(environment)
+            .append_obj(arguments)
+            .append_obj(options)
+        )
         self._channel.launchSuspendedProcessWithDevicePath_bundleIdentifier_environment_arguments_options_(args)
         result = self._channel.receive_plist()
         assert result
@@ -80,5 +105,5 @@ class ProcessControl:
 
     def __iter__(self) -> typing.Generator[OutputReceivedEvent, None, None]:
         key, value = self._channel.receive_key_value()
-        if key == 'outputReceived:fromProcess:atTime:':
+        if key == "outputReceived:fromProcess:atTime:":
             yield OutputReceivedEvent.create(value)

pymobiledevice3/services/dvt/instruments/screenshot.py

@@ -2,12 +2,12 @@ from pymobiledevice3.services.dvt.dvt_secure_socket_proxy import DvtSecureSocket
 
 
 class Screenshot:
-    IDENTIFIER = 'com.apple.instruments.server.services.screenshot'
+    IDENTIFIER = "com.apple.instruments.server.services.screenshot"
 
     def __init__(self, dvt: DvtSecureSocketProxyService):
         self._channel = dvt.make_channel(self.IDENTIFIER)
 
     def get_screenshot(self) -> bytes:
-        """ get device screenshot """
+        """get device screenshot"""
         self._channel.takeScreenshot(expects_reply=True)
         return self._channel.receive_plist()

pymobiledevice3/services/dvt/instruments/sysmontap.py

@@ -5,25 +5,25 @@ from pymobiledevice3.services.remote_server import Tap
 
 
 class Sysmontap(Tap):
-    IDENTIFIER = 'com.apple.instruments.server.services.sysmontap'
+    IDENTIFIER = "com.apple.instruments.server.services.sysmontap"
 
     def __init__(self, dvt):
         self._device_info = DeviceInfo(dvt)
 
-        process_attributes = list(self._device_info.request_information('sysmonProcessAttributes'))
-        system_attributes = list(self._device_info.request_information('sysmonSystemAttributes'))
+        process_attributes = list(self._device_info.request_information("sysmonProcessAttributes"))
+        system_attributes = list(self._device_info.request_information("sysmonSystemAttributes"))
 
-        self.process_attributes_cls = dataclasses.make_dataclass('SysmonProcessAttributes', process_attributes)
-        self.system_attributes_cls = dataclasses.make_dataclass('SysmonSystemAttributes', system_attributes)
+        self.process_attributes_cls = dataclasses.make_dataclass("SysmonProcessAttributes", process_attributes)
+        self.system_attributes_cls = dataclasses.make_dataclass("SysmonSystemAttributes", system_attributes)
 
         config = {
-            'ur': 500,  # Output frequency ms
-            'bm': 0,
-            'procAttrs': process_attributes,
-            'sysAttrs': system_attributes,
-            'cpuUsage': True,
-            'physFootprint': True,  # memory value
-            'sampleInterval': 500000000
+            "ur": 500,  # Output frequency ms
+            "bm": 0,
+            "procAttrs": process_attributes,
+            "sysAttrs": system_attributes,
+            "cpuUsage": True,
+            "physFootprint": True,  # memory value
+            "sampleInterval": 500000000,
         }
 
         super().__init__(dvt, self.IDENTIFIER, config)
@@ -34,13 +34,13 @@ class Sysmontap(Tap):
 
     def iter_processes(self):
         for row in self:
-            if 'Processes' not in row:
+            if "Processes" not in row:
                 continue
 
             entries = []
 
-            processes = row['Processes'].items()
-            for pid, process_info in processes:
+            processes = row["Processes"].items()
+            for _pid, process_info in processes:
                 entry = dataclasses.asdict(self.process_attributes_cls(*process_info))
                 entries.append(entry)
 

pymobiledevice3/services/dvt/testmanaged/xcuitest.py

@@ -13,8 +13,16 @@ from pymobiledevice3.services.dvt.dvt_testmanaged_proxy import DvtTestmanagedPro
 from pymobiledevice3.services.dvt.instruments.process_control import ProcessControl
 from pymobiledevice3.services.house_arrest import HouseArrestService
 from pymobiledevice3.services.installation_proxy import InstallationProxyService
-from pymobiledevice3.services.remote_server import NSURL, NSUUID, Channel, ChannelFragmenter, MessageAux, \
-    XCTestConfiguration, dtx_message_header_struct, dtx_message_payload_header_struct
+from pymobiledevice3.services.remote_server import (
+    NSURL,
+    NSUUID,
+    Channel,
+    ChannelFragmenter,
+    MessageAux,
+    XCTestConfiguration,
+    dtx_message_header_struct,
+    dtx_message_payload_header_struct,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -52,9 +60,7 @@ class XCUITestService:
         self.setup_xcuitest(bundle_id, xctest_path, xctest_configuration)
         dvt1, chan1, dvt2, chan2 = self.init_ide_channels(session_identifier)
 
-        pid = self.launch_test_app(
-            app_info, bundle_id, xctest_path, test_runner_env, test_runner_args
-        )
+        pid = self.launch_test_app(app_info, bundle_id, xctest_path, test_runner_env, test_runner_args)
         logger.info("Runner started with pid:%d, waiting for testBundleReady", pid)
 
         time.sleep(1)
@@ -95,24 +101,18 @@ class XCUITestService:
             # - _XCT_didFinishExecutingTestPlan
             logger.info("unhandled %s %r", key, value)
 
-    def send_response_capabilities(
-        self, dvt: DvtTestmanagedProxyService, chan: Channel, cur_message: int
-    ):
-        pheader = dtx_message_payload_header_struct.build(
-            dict(flags=3, auxiliaryLength=0, totalLength=0)
-        )
-        mheader = dtx_message_header_struct.build(
-            dict(
-                cb=dtx_message_header_struct.sizeof(),
-                fragmentId=0,
-                fragmentCount=1,
-                length=dtx_message_payload_header_struct.sizeof(),
-                identifier=cur_message,
-                conversationIndex=1,
-                channelCode=chan,
-                expectsReply=int(0),
-            )
-        )
+    def send_response_capabilities(self, dvt: DvtTestmanagedProxyService, chan: Channel, cur_message: int):
+        pheader = dtx_message_payload_header_struct.build({"flags": 3, "auxiliaryLength": 0, "totalLength": 0})
+        mheader = dtx_message_header_struct.build({
+            "cb": dtx_message_header_struct.sizeof(),
+            "fragmentId": 0,
+            "fragmentCount": 1,
+            "length": dtx_message_payload_header_struct.sizeof(),
+            "identifier": cur_message,
+            "conversationIndex": 1,
+            "channelCode": chan,
+            "expectsReply": (0),
+        })
         msg = mheader + pheader
         dvt.service.sendall(msg)
 
@@ -160,9 +160,7 @@ class XCUITestService:
         xctest_configuration: XCTestConfiguration,
     ):
         """push xctestconfiguration to app VendDocuments"""
-        with HouseArrestService(
-            lockdown=self.service_provider, bundle_id=bundle_id, documents_only=False
-        ) as afc:
+        with HouseArrestService(lockdown=self.service_provider, bundle_id=bundle_id, documents_only=False) as afc:
             for name in afc.listdir("/tmp"):
                 if name.endswith(".xctestconfiguration"):
                     logger.debug("remove /tmp/%s", name)
@@ -197,7 +195,7 @@ class XCUITestService:
         if isinstance(reply, bool) and reply is True:
             logger.info("authorizing test session for pid %d successful %r", pid, reply)
         else:
-            raise RuntimeError("Failed to authorize test process id: %s" % reply)
+            raise RuntimeError(f"Failed to authorize test process id: {reply}")
 
     def launch_test_app(
         self,
@@ -212,9 +210,7 @@ class XCUITestService:
         exec_name = app_info["CFBundleExecutable"]
         # # logger.info('CFBundleExecutable: %s', exec_name)
         # # CFBundleName always endswith -Runner
-        assert exec_name.endswith("-Runner"), (
-            "Invalid CFBundleExecutable: %s" % exec_name
-        )
+        assert exec_name.endswith("-Runner"), f"Invalid CFBundleExecutable: {exec_name}"
         target_name = exec_name[: -len("-Runner")]
 
         app_env = {
@@ -226,7 +222,7 @@ class XCUITestService:
             "NSUnbufferedIO": "YES",
             "SQLITE_ENABLE_THREAD_ASSERTIONS": "1",
             "WDA_PRODUCT_BUNDLE_IDENTIFIER": "",
-            "XCTestBundlePath": f'{app_info["Path"]}/PlugIns/{target_name}.xctest',
+            "XCTestBundlePath": f"{app_info['Path']}/PlugIns/{target_name}.xctest",
             "XCTestConfigurationFilePath": app_container + xctest_path,
             "XCODE_DBG_XPC_EXCLUSIONS": "com.apple.dt.xctestSymbolicator",
             # the following maybe no needed
@@ -238,9 +234,7 @@ class XCUITestService:
             app_env.update(test_runner_env)
 
         if self.product_major_version >= 11:
-            app_env[
-                "DYLD_INSERT_LIBRARIES"
-            ] = "/Developer/usr/lib/libMainThreadChecker.dylib"
+            app_env["DYLD_INSERT_LIBRARIES"] = "/Developer/usr/lib/libMainThreadChecker.dylib"
             app_env["OS_ACTIVITY_DT_MODE"] = "YES"
 
         app_args = [
@@ -276,28 +270,24 @@ def get_app_info(service_provider: LockdownClient, bundle_id: str) -> dict[str,
 def generate_xctestconfiguration(
     app_info: dict,
     session_identifier: NSUUID,
-    target_app_bundle_id: str = None,
+    target_app_bundle_id: Optional[str] = None,
     target_app_env: Optional[dict] = None,
     target_app_args: Optional[list] = None,
     tests_to_run: Optional[list] = None,
 ) -> XCTestConfiguration:
     exec_name: str = app_info["CFBundleExecutable"]
-    assert exec_name.endswith("-Runner"), "Invalid CFBundleExecutable: %s" % exec_name
+    assert exec_name.endswith("-Runner"), f"Invalid CFBundleExecutable: {exec_name}"
     config_name = exec_name[: -len("-Runner")]
 
-    return XCTestConfiguration(
-        {
-            "testBundleURL": NSURL(
-                None, f'file://{app_info["Path"]}/PlugIns/{config_name}.xctest'
-            ),
-            "sessionIdentifier": session_identifier,
-            "targetApplicationBundleID": target_app_bundle_id,
-            "targetApplicationEnvironment": target_app_env or {},
-            "targetApplicationArguments": target_app_args or [],
-            "testsToRun": tests_to_run or set(),
-            "testsMustRunOnMainThread": True,
-            "reportResultsToIDE": True,
-            "reportActivities": True,
-            "automationFrameworkPath": "/Developer/Library/PrivateFrameworks/XCTAutomationSupport.framework",
-        }
-    )
+    return XCTestConfiguration({
+        "testBundleURL": NSURL(None, f"file://{app_info['Path']}/PlugIns/{config_name}.xctest"),
+        "sessionIdentifier": session_identifier,
+        "targetApplicationBundleID": target_app_bundle_id,
+        "targetApplicationEnvironment": target_app_env or {},
+        "targetApplicationArguments": target_app_args or [],
+        "testsToRun": tests_to_run or set(),
+        "testsMustRunOnMainThread": True,
+        "reportResultsToIDE": True,
+        "reportActivities": True,
+        "automationFrameworkPath": "/Developer/Library/PrivateFrameworks/XCTAutomationSupport.framework",
+    })

pymobiledevice3/services/file_relay.py

@@ -1,7 +1,7 @@
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.services.lockdown_service import LockdownService
 
-SRCFILES = '''Baseband
+SRCFILES = """Baseband
 CrashReporter
 MobileAsset
 VARFS
@@ -19,30 +19,30 @@ NANDDebugInfo
 SystemConfiguration
 Ubiquity
 tmp
-WirelessAutomation'''
+WirelessAutomation"""
 
 
 class FileRelayService(LockdownService):
-    SERVICE_NAME = 'com.apple.mobile.file_relay'
+    SERVICE_NAME = "com.apple.mobile.file_relay"
 
     def __init__(self, lockdown: LockdownClient):
         super().__init__(lockdown, self.SERVICE_NAME)
         self.packet_num = 0
 
     def stop_session(self):
-        self.logger.info('Disconecting...')
+        self.logger.info("Disconecting...")
         self.service.close()
 
     def request_sources(self, sources=None):
         if sources is None:
-            sources = ['UserDatabases']
-        self.service.send_plist({'Sources': sources})
+            sources = ["UserDatabases"]
+        self.service.send_plist({"Sources": sources})
         while 1:
             res = self.service.recv_plist()
             if res:
-                s = res.get('Status')
-                if s == 'Acknowledged':
-                    z = ''
+                s = res.get("Status")
+                if s == "Acknowledged":
+                    z = ""
                     while True:
                         x = self.service.recv()
                         if not x:
@@ -50,6 +50,6 @@ class FileRelayService(LockdownService):
                         z += x
                     return z
                 else:
-                    print(res.get('Error'))
+                    print(res.get("Error"))
                     break
         return None

pymobiledevice3/services/heartbeat.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import logging
 import time
+from typing import Optional
 
 from pymobiledevice3.lockdown import LockdownClient
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
@@ -8,10 +9,11 @@ from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 
 class HeartbeatService:
     """
-    Use to keep an active connection with lockdowd
+    Use to keep an active connection with lockdownd
     """
-    SERVICE_NAME = 'com.apple.mobile.heartbeat'
-    RSD_SERVICE_NAME = 'com.apple.mobile.heartbeat.shim.remote'
+
+    SERVICE_NAME = "com.apple.mobile.heartbeat"
+    RSD_SERVICE_NAME = "com.apple.mobile.heartbeat.shim.remote"
 
     def __init__(self, lockdown: LockdownServiceProvider):
         self.logger = logging.getLogger(__name__)
@@ -22,7 +24,7 @@ class HeartbeatService:
         else:
             self.service_name = self.RSD_SERVICE_NAME
 
-    def start(self, interval: float = None) -> None:
+    def start(self, interval: Optional[float] = None) -> None:
         start = time.time()
         service = self.lockdown.start_lockdown_service(self.service_name)
 
@@ -30,8 +32,7 @@ class HeartbeatService:
             response = service.recv_plist()
             self.logger.debug(response)
 
-            if interval is not None:
-                if time.time() >= start + interval:
-                    break
+            if interval is not None and time.time() >= start + interval:
+                break
 
-            service.send_plist({'Command': 'Polo'})
+            service.send_plist({"Command": "Polo"})