@scrypted/server 0.123.33 → 0.123.35

package/python/cluster_labels.py

@@ -47,5 +47,8 @@ def needs_cluster_fork_worker(options: ClusterForkOptions) -> bool:
     return (
         os.environ.get("SCRYPTED_CLUSTER_ADDRESS")
         and options
-        and (not matches_cluster_labels(options, get_cluster_labels()) or options.get("clusterWorkerId", None))
+        and (
+            not matches_cluster_labels(options, get_cluster_labels())
+            or options.get("clusterWorkerId", None)
+        )
     )

package/python/cluster_setup.py

@@ -12,6 +12,7 @@ import rpc
 import rpc_reader
 from typing import TypedDict
 
+
 class ClusterObject(TypedDict):
     id: str
     address: str
@@ -20,12 +21,16 @@ class ClusterObject(TypedDict):
     sourceKey: str
     sha256: str
 
+
 def isClusterAddress(address: str):
     return not address or address == os.environ.get("SCRYPTED_CLUSTER_ADDRESS", None)
 
+
 def getClusterPeerKey(address: str, port: int):
     return f"{address}:{port}"
-class ClusterSetup():
+
+
+class ClusterSetup:
     def __init__(self, loop: AbstractEventLoop, peer: rpc.RpcPeer):
         self.loop = loop
         self.peer = peer
@@ -50,9 +55,13 @@ class ClusterSetup():
         sha256 = self.computeClusterObjectHash(o)
         if sha256 != o["sha256"]:
             raise Exception("secret incorrect")
-        return await self.resolveObject(o.get('proxyId', None), o.get('sourceKey', None))
+        return await self.resolveObject(
+            o.get("proxyId", None), o.get("sourceKey", None)
+        )
 
-    def onProxySerialization(self, peer: rpc.RpcPeer, value: Any, sourceKey: str = None):
+    def onProxySerialization(
+        self, peer: rpc.RpcPeer, value: Any, sourceKey: str = None
+    ):
         properties: dict = rpc.RpcPeer.prepareProxyProperties(value) or {}
         clusterEntry = properties.get("__cluster", None)
         proxyId: str
@@ -126,7 +135,9 @@ class ClusterSetup():
             handleClusterClient, listenAddress, 0
         )
         self.clusterPort = clusterRpcServer.sockets[0].getsockname()[1]
-        self.peer.onProxySerialization = lambda value: self.onProxySerialization(self.peer, value, None)
+        self.peer.onProxySerialization = lambda value: self.onProxySerialization(
+            self.peer, value, None
+        )
         del self.peer.params["initializeCluster"]
 
     def computeClusterObjectHash(self, o: ClusterObject) -> str:
@@ -215,9 +226,7 @@ class ClusterSetup():
 
             peerConnectRPCObject = clusterPeer.tags.get("connectRPCObject")
             if not peerConnectRPCObject:
-                peerConnectRPCObject = await clusterPeer.getParam(
-                    "connectRPCObject"
-                )
+                peerConnectRPCObject = await clusterPeer.getParam("connectRPCObject")
                 clusterPeer.tags["connectRPCObject"] = peerConnectRPCObject
             newValue = await peerConnectRPCObject(clusterObject)
             if not newValue:

package/python/plugin_console.py

@@ -1,5 +1,6 @@
 import typing
 
+
 async def writeWorkerGenerator(gen, out: typing.TextIO):
     try:
         async for item in gen:

package/python/plugin_pip.py

@@ -4,22 +4,25 @@ import sys
 from typing import Any
 import shutil
 
+
 def get_requirements_files(requirements: str):
-    want_requirements = requirements + '.txt'
-    installed_requirementstxt = requirements + '.installed.txt'
+    want_requirements = requirements + ".txt"
+    installed_requirementstxt = requirements + ".installed.txt"
     return want_requirements, installed_requirementstxt
 
+
 def need_requirements(requirements_basename: str, requirements_str: str):
     _, installed_requirementstxt = get_requirements_files(requirements_basename)
     if not os.path.exists(installed_requirementstxt):
         return True
     try:
         f = open(installed_requirementstxt, "rb")
-        installed_requirements = f.read().decode('utf8')
+        installed_requirements = f.read().decode("utf8")
         return requirements_str != installed_requirements
     except:
         return True
 
+
 def remove_pip_dirs(plugin_volume: str):
     try:
         for de in os.listdir(plugin_volume):
@@ -48,7 +51,9 @@ def install_with_pip(
     ignore_error: bool = False,
     site_packages: str = None,
 ):
-    requirementstxt, installed_requirementstxt = get_requirements_files(requirements_basename)
+    requirementstxt, installed_requirementstxt = get_requirements_files(
+        requirements_basename
+    )
 
     os.makedirs(python_prefix, exist_ok=True)
 
@@ -81,15 +86,16 @@ def install_with_pip(
         # force reinstall even if it exists in system packages.
         pipArgs.append("--force-reinstall")
 
-
     env = None
     if site_packages:
         env = dict(os.environ)
-        PYTHONPATH = env['PYTHONPATH'] or ''
-        PYTHONPATH += ':' + site_packages
+        PYTHONPATH = env["PYTHONPATH"] or ""
+        PYTHONPATH += ":" + site_packages
         env["PYTHONPATH"] = PYTHONPATH
         print("PYTHONPATH", env["PYTHONPATH"])
-    p = subprocess.Popen(pipArgs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
+    p = subprocess.Popen(
+        pipArgs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env
+    )
 
     while True:
         line = p.stdout.readline()

package/python/plugin_remote.py

@@ -27,18 +27,22 @@ from cluster_setup import ClusterSetup
 import cluster_labels
 from plugin_pip import install_with_pip, need_requirements, remove_pip_dirs
 from scrypted_python.scrypted_sdk import PluginFork, ScryptedStatic
-from scrypted_python.scrypted_sdk.types import (Device, DeviceManifest,
-                                                EventDetails,
-                                                ScryptedInterface,
-                                                ScryptedInterfaceMethods,
-                                                ScryptedInterfaceProperty,
-                                                Storage)
+from scrypted_python.scrypted_sdk.types import (
+    Device,
+    DeviceManifest,
+    EventDetails,
+    ScryptedInterface,
+    ScryptedInterfaceMethods,
+    ScryptedInterfaceProperty,
+    Storage,
+)
 
 SCRYPTED_REQUIREMENTS = """
 ptpython
 wheel
 """.strip()
 
+
 class SystemDeviceState(TypedDict):
     lastEventTime: int
     stateTime: int
@@ -47,8 +51,10 @@ class SystemDeviceState(TypedDict):
 
 def ensure_not_coroutine(fn: Callable | Coroutine) -> Callable:
     if inspect.iscoroutinefunction(fn):
+
         def wrapper(*args, **kwargs):
             return asyncio.create_task(fn(*args, **kwargs))
+
         return wrapper
     return fn
 
@@ -96,25 +102,29 @@ class DeviceProxy(object):
 class EventListenerRegisterImpl(scrypted_python.scrypted_sdk.EventListenerRegister):
     removeListener: Callable[[], None]
 
-    def __init__(self, removeListener: Callable[[], None] | Coroutine[Any, None, None]) -> None:
+    def __init__(
+        self, removeListener: Callable[[], None] | Coroutine[Any, None, None]
+    ) -> None:
         self.removeListener = ensure_not_coroutine(removeListener)
 
 
 class EventRegistry(object):
     systemListeners: Set[scrypted_python.scrypted_sdk.EventListener]
-    listeners: Mapping[str, Set[Callable[[scrypted_python.scrypted_sdk.EventDetails, Any], None]]]
+    listeners: Mapping[
+        str, Set[Callable[[scrypted_python.scrypted_sdk.EventDetails, Any], None]]
+    ]
 
-    __allowedEventInterfaces = set([
-        ScryptedInterface.ScryptedDevice.value,
-        'Logger',
-        'Storage'
-    ])
+    __allowedEventInterfaces = set(
+        [ScryptedInterface.ScryptedDevice.value, "Logger", "Storage"]
+    )
 
     def __init__(self) -> None:
         self.systemListeners = set()
         self.listeners = {}
 
-    def __getMixinEventName(self, options: str | scrypted_python.scrypted_sdk.EventListenerOptions) -> str:
+    def __getMixinEventName(
+        self, options: str | scrypted_python.scrypted_sdk.EventListenerOptions
+    ) -> str:
         mixinId = None
         if type(options) == str:
             event = options
@@ -155,7 +165,15 @@ class EventRegistry(object):
         self.listeners[id].add(callback)
         return EventListenerRegisterImpl(lambda: self.listeners[id].remove(callback))
 
-    def notify(self, id: str, eventTime: int, eventInterface: str, property: str, value: Any, options: dict = None):
+    def notify(
+        self,
+        id: str,
+        eventTime: int,
+        eventInterface: str,
+        property: str,
+        value: Any,
+        options: dict = None,
+    ):
         options = options or {}
         changed = options.get("changed")
         mixinId = options.get("mixinId")
@@ -174,7 +192,13 @@ class EventRegistry(object):
 
         return self.notifyEventDetails(id, eventDetails, value)
 
-    def notifyEventDetails(self, id: str, eventDetails: scrypted_python.scrypted_sdk.EventDetails, value: Any, eventInterface: str = None):
+    def notifyEventDetails(
+        self,
+        id: str,
+        eventDetails: scrypted_python.scrypted_sdk.EventDetails,
+        value: Any,
+        eventInterface: str = None,
+    ):
         if not eventDetails.get("eventId"):
             eventDetails["eventId"] = self.__generateBase36Str()
         if not eventInterface:
@@ -183,8 +207,9 @@ class EventRegistry(object):
         # system listeners only get state changes.
         # there are many potentially noisy stateless events, like
         # object detection and settings changes
-        if (eventDetails.get("property") and not eventDetails.get("mixinId")) or \
-            (eventInterface in EventRegistry.__allowedEventInterfaces):
+        if (eventDetails.get("property") and not eventDetails.get("mixinId")) or (
+            eventInterface in EventRegistry.__allowedEventInterfaces
+        ):
             for listener in self.systemListeners:
                 listener(id, eventDetails, value)
 
@@ -202,6 +227,7 @@ class EventRegistry(object):
 
         return True
 
+
 class ClusterManager(scrypted_python.scrypted_sdk.types.ClusterManager):
     def __init__(self, api: Any):
         self.api = api
@@ -213,11 +239,16 @@ class ClusterManager(scrypted_python.scrypted_sdk.types.ClusterManager):
     def getClusterWorkerId(self) -> str:
         return os.getenv("SCRYPTED_CLUSTER_WORKER_ID", None)
 
-    async def getClusterWorkers(self) -> Mapping[str, scrypted_python.scrypted_sdk.types.ClusterWorker]:
-        self.clusterService = self.clusterService or asyncio.ensure_future(self.api.getComponent("cluster-fork"))
+    async def getClusterWorkers(
+        self,
+    ) -> Mapping[str, scrypted_python.scrypted_sdk.types.ClusterWorker]:
+        self.clusterService = self.clusterService or asyncio.ensure_future(
+            self.api.getComponent("cluster-fork")
+        )
         cs = await self.clusterService
         return await cs.getClusterWorkers()
 
+
 class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
     def __init__(
         self, api: Any, systemState: Mapping[str, Mapping[str, SystemDeviceState]]
@@ -306,19 +337,27 @@ class SystemManager(scrypted_python.scrypted_sdk.types.SystemManager):
         callback = ensure_not_coroutine(callback)
         if type(options) != str and options.get("watch"):
             return self.events.listenDevice(
-                id, options,
-                lambda eventDetails, eventData: callback(self.getDeviceById(id), eventDetails, eventData)
+                id,
+                options,
+                lambda eventDetails, eventData: callback(
+                    self.getDeviceById(id), eventDetails, eventData
+                ),
             )
 
         register_fut = asyncio.ensure_future(
             self.api.listenDevice(
-                id, options,
-                lambda eventDetails, eventData: callback(self.getDeviceById(id), eventDetails, eventData)
+                id,
+                options,
+                lambda eventDetails, eventData: callback(
+                    self.getDeviceById(id), eventDetails, eventData
+                ),
             )
         )
+
         async def unregister():
             register = await register_fut
             await register.removeListener()
+
         return EventListenerRegisterImpl(lambda: asyncio.ensure_future(unregister()))
 
     async def removeDevice(self, id: str) -> None:
@@ -555,6 +594,7 @@ class DeviceManager(scrypted_python.scrypted_sdk.types.DeviceManager):
     def getDeviceStorage(self, nativeId: str = None) -> Storage:
         return self.nativeIds.get(nativeId, None)
 
+
 class PeerLiveness:
     def __init__(self, loop: AbstractEventLoop):
         self.killed = Future(loop=loop)
@@ -562,15 +602,22 @@ class PeerLiveness:
     async def waitKilled(self):
         await self.killed
 
+
 def safe_set_result(fut: Future, result: Any):
     try:
         fut.set_result(result)
     except:
         pass
 
+
 class PluginRemote:
     def __init__(
-        self, clusterSetup: ClusterSetup, api, pluginId: str, hostInfo, loop: AbstractEventLoop
+        self,
+        clusterSetup: ClusterSetup,
+        api,
+        pluginId: str,
+        hostInfo,
+        loop: AbstractEventLoop,
     ):
         self.systemState: Mapping[str, Mapping[str, SystemDeviceState]] = {}
         self.nativeIds: Mapping[str, DeviceStorage] = {}
@@ -606,7 +653,9 @@ class PluginRemote:
             consoleFuture = Future()
             self.consoles[nativeId] = consoleFuture
             plugins = await self.api.getComponent("plugins")
-            port, hostname = await plugins.getRemoteServicePort(self.pluginId, "console-writer")
+            port, hostname = await plugins.getRemoteServicePort(
+                self.pluginId, "console-writer"
+            )
             connection = await asyncio.open_connection(host=hostname, port=port)
             _, writer = connection
             if not nativeId:
@@ -682,7 +731,7 @@ class PluginRemote:
 
         if not forkMain:
             multiprocessing.set_start_method("spawn")
-        
+
         # forkMain may be set to true, but the environment may not be initialized
         # if the plugin is loaded in another cluster worker.
         # instead rely on a environemnt variable that will be passed to
@@ -819,10 +868,13 @@ class PluginRemote:
                         async def getZip(self):
                             return await zipAPI.getZip()
 
-                    return await remote.loadZip(packageJson, PluginZipAPI(), forkOptions)
+                    return await remote.loadZip(
+                        packageJson, PluginZipAPI(), forkOptions
+                    )
 
                 if cluster_labels.needs_cluster_fork_worker(options):
                     peerLiveness = PeerLiveness(self.loop)
+
                     async def getClusterFork():
                         runtimeWorkerOptions = {
                             "packageJson": packageJson,
@@ -835,14 +887,17 @@ class PluginRemote:
 
                         forkComponent = await self.api.getComponent("cluster-fork")
                         sanitizedOptions = options.copy()
-                        sanitizedOptions["runtime"] = sanitizedOptions.get("runtime", "python")
+                        sanitizedOptions["runtime"] = sanitizedOptions.get(
+                            "runtime", "python"
+                        )
                         sanitizedOptions["zipHash"] = zipHash
                         clusterForkResult = await forkComponent.fork(
                             runtimeWorkerOptions,
                             sanitizedOptions,
-                            peerLiveness, lambda: zipAPI.getZip()
+                            peerLiveness,
+                            lambda: zipAPI.getZip(),
                         )
-                        
+
                         async def waitPeerLiveness():
                             try:
                                 await peerLiveness.waitKilled()
@@ -851,6 +906,7 @@ class PluginRemote:
                                     await clusterForkResult.kill()
                                 except:
                                     pass
+
                         asyncio.ensure_future(waitPeerLiveness(), loop=self.loop)
 
                         async def waitClusterForkKilled():
@@ -859,30 +915,48 @@ class PluginRemote:
                             except:
                                 pass
                             safe_set_result(peerLiveness.killed, None)
+
                         asyncio.ensure_future(waitClusterForkKilled(), loop=self.loop)
 
-                        clusterGetRemote = await self.clusterSetup.connectRPCObject(await clusterForkResult.getResult())
+                        clusterGetRemote = await self.clusterSetup.connectRPCObject(
+                            await clusterForkResult.getResult()
+                        )
                         remoteDict = await clusterGetRemote()
-                        asyncio.ensure_future(plugin_console.writeWorkerGenerator(remoteDict["stdout"], sys.stdout))
-                        asyncio.ensure_future(plugin_console.writeWorkerGenerator(remoteDict["stderr"], sys.stderr))
+                        asyncio.ensure_future(
+                            plugin_console.writeWorkerGenerator(
+                                remoteDict["stdout"], sys.stdout
+                            )
+                        )
+                        asyncio.ensure_future(
+                            plugin_console.writeWorkerGenerator(
+                                remoteDict["stderr"], sys.stderr
+                            )
+                        )
 
                         getRemote = remoteDict["getRemote"]
-                        directGetRemote = await self.clusterSetup.connectRPCObject(getRemote)
+                        directGetRemote = await self.clusterSetup.connectRPCObject(
+                            getRemote
+                        )
                         if directGetRemote is getRemote:
                             raise Exception("cluster fork peer not direct connected")
 
-                        forkPeer = getattr(directGetRemote, rpc.RpcPeer.PROPERTY_PROXY_PEER)
+                        forkPeer = getattr(
+                            directGetRemote, rpc.RpcPeer.PROPERTY_PROXY_PEER
+                        )
                         return await finishFork(forkPeer)
 
-
                     pluginFork = PluginFork()
                     pluginFork.result = asyncio.create_task(getClusterFork())
+
                     async def waitKilled():
                         await peerLiveness.killed
+
                     pluginFork.exit = asyncio.create_task(waitKilled())
+
                     def terminate():
                         safe_set_result(peerLiveness.killed, None)
                         pluginFork.worker.terminate()
+
                     pluginFork.terminate = terminate
 
                     pluginFork.worker = None
@@ -902,12 +976,16 @@ class PluginRemote:
 
                 pluginFork = PluginFork()
                 killed = Future(loop=self.loop)
+
                 async def waitKilled():
                     await killed
+
                 pluginFork.exit = asyncio.create_task(waitKilled())
+
                 def terminate():
                     safe_set_result(killed, None)
                     pluginFork.worker.kill()
+
                 pluginFork.terminate = terminate
 
                 pluginFork.worker = multiprocessing.Process(
@@ -956,6 +1034,7 @@ class PluginRemote:
             # sdk.
 
             from scrypted_sdk import sdk_init2  # type: ignore
+
             sdk_init2(sdk)
         except:
             from scrypted_sdk import sdk_init  # type: ignore
@@ -1048,7 +1127,9 @@ async def plugin_async_main(
     peer.params["print"] = print
 
     clusterSetup = ClusterSetup(loop, peer)
-    peer.params["initializeCluster"] = lambda options: clusterSetup.initializeCluster(options)
+    peer.params["initializeCluster"] = lambda options: clusterSetup.initializeCluster(
+        options
+    )
 
     async def ping(time: int):
         return time
@@ -1077,6 +1158,7 @@ def main(rpcTransport: rpc_reader.RpcTransport):
     loop.run_until_complete(plugin_async_main(loop, rpcTransport))
     loop.close()
 
+
 def plugin_fork(conn: multiprocessing.connection.Connection):
     main(rpc_reader.RpcConnectionTransport(conn))
 

package/python/plugin_repl.py

@@ -39,6 +39,8 @@ ColorDepth.default = lambda *args, **kwargs: ColorDepth.DEPTH_4_BIT
 # the library. The patches here allow us to scope a particular call stack
 # to a particular REPL, and to get the current Application from the stack.
 default_get_app = prompt_toolkit.application.current.get_app
+
+
 def get_app_patched() -> Application[Any]:
     stack = inspect.stack()
     for frame in stack:
@@ -46,6 +48,8 @@ def get_app_patched() -> Application[Any]:
         if self_var is not None and isinstance(self_var, Application):
             return self_var
     return default_get_app()
+
+
 prompt_toolkit.application.current.get_app = get_app_patched
 prompt_toolkit.key_binding.key_processor.get_app = get_app_patched
 prompt_toolkit.contrib.telnet.server.get_app = get_app_patched
@@ -141,7 +145,9 @@ async def eval_async_patched(self: PythonRepl, line: str) -> object:
 
     def eval_across_loops(code, *args, **kwargs):
         future = concurrent.futures.Future()
-        scrypted_loop.call_soon_threadsafe(partial(eval_in_scrypted, future), code, *args, **kwargs)
+        scrypted_loop.call_soon_threadsafe(
+            partial(eval_in_scrypted, future), code, *args, **kwargs
+        )
         return future.result()
 
     # WORKAROUND: Due to a bug in Jedi, the current directory is removed
@@ -192,7 +198,7 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     sock.settimeout(None)
-    sock.bind(('localhost', 0))
+    sock.bind(("localhost", 0))
     sock.listen()
 
     scrypted_loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()
@@ -222,7 +228,7 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
 
         # Select a free port for the telnet server
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        s.bind(('localhost', 0))
+        s.bind(("localhost", 0))
         telnet_port = s.getsockname()[1]
         s.close()
 
@@ -230,14 +236,19 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
             # repl_loop owns the print capabilities, but the prints will
             # be executed in scrypted_loop. We need to bridge the two here
             repl_print = partial(print_formatted_text, output=connection.vt100_output)
+
             def print_across_loops(*args, **kwargs):
                 repl_loop.call_soon_threadsafe(repl_print, *args, **kwargs)
 
             global_dict = {
                 **globals(),
                 "print": print_across_loops,
-                "help": lambda *args, **kwargs: print_across_loops("Help is not available in this environment"),
-                "input": lambda *args, **kwargs: print_across_loops("Input is not available in this environment"),
+                "help": lambda *args, **kwargs: print_across_loops(
+                    "Help is not available in this environment"
+                ),
+                "input": lambda *args, **kwargs: print_across_loops(
+                    "Input is not available in this environment"
+                ),
             }
             locals_dict = {
                 "device": device,
@@ -245,19 +256,32 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
                 "deviceManager": deviceManager,
                 "mediaManager": mediaManager,
                 "sdk": sdk,
-                "realDevice": realDevice
+                "realDevice": realDevice,
             }
-            vars_prompt = '\n'.join([f"  {k}" for k in locals_dict.keys()])
+            vars_prompt = "\n".join([f"  {k}" for k in locals_dict.keys()])
             banner = f"Python REPL variables:\n{vars_prompt}"
             print_formatted_text(banner)
-            await embed(return_asyncio_coroutine=True, globals=global_dict, locals=locals_dict, configure=partial(configure, scrypted_loop))
+            await embed(
+                return_asyncio_coroutine=True,
+                globals=global_dict,
+                locals=locals_dict,
+                configure=partial(configure, scrypted_loop),
+            )
 
         server_task: asyncio.Task = None
+
         def ready_cb():
-            future.set_result((telnet_port, lambda: repl_loop.call_soon_threadsafe(server_task.cancel)))
+            future.set_result(
+                (
+                    telnet_port,
+                    lambda: repl_loop.call_soon_threadsafe(server_task.cancel),
+                )
+            )
 
         # Start the REPL server
-        telnet_server = TelnetServer(interact=interact, port=telnet_port, enable_cpr=False)
+        telnet_server = TelnetServer(
+            interact=interact, port=telnet_port, enable_cpr=False
+        )
         server_task = asyncio.create_task(telnet_server.run(ready_cb=ready_cb))
         try:
             await server_task
@@ -277,16 +301,19 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
         def finish_setup():
             telnet_port, exit_server = server_started_future.result()
 
-            telnet_client = telnetlib.Telnet('localhost', telnet_port, timeout=None)
+            telnet_client = telnetlib.Telnet("localhost", telnet_port, timeout=None)
 
             def telnet_negotiation_cb(telnet_socket, command, option):
                 pass  # ignore telnet negotiation
+
             telnet_client.set_option_negotiation_callback(telnet_negotiation_cb)
 
             # initialize telnet terminal
             # this tells the telnet server we are a vt100 terminal
-            telnet_client.get_socket().sendall(b'\xff\xfb\x18\xff\xfa\x18\x00\x61\x6e\x73\x69\xff\xf0')
-            telnet_client.get_socket().sendall(b'\r\n')
+            telnet_client.get_socket().sendall(
+                b"\xff\xfb\x18\xff\xfa\x18\x00\x61\x6e\x73\x69\xff\xf0"
+            )
+            telnet_client.get_socket().sendall(b"\r\n")
 
             # Bridge the connection to the telnet server, two way
             def forward_to_telnet():
@@ -303,7 +330,7 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
                 while True:
                     data = telnet_client.read_some()
                     if not data:
-                        conn.sendall('REPL exited'.encode())
+                        conn.sendall("REPL exited".encode())
                         break
                     if b">>>" in data:
                         # This is an ugly hack - somewhere in ptpython, the
@@ -333,4 +360,4 @@ async def createREPLServer(sdk: ScryptedStatic, plugin: ScryptedDevice) -> int:
     threading.Thread(target=accept_connection).start()
 
     proxy_port = sock.getsockname()[1]
-    return proxy_port
+    return proxy_port