[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

jupyter_server_proxy/__init__.py

@@ -1,12 +1,13 @@
 from jupyter_server.utils import url_path_join as ujoin
 
 from .api import (
-    IconHandler, ServersInfoHandler, ServersAPIHandler, ListServersAPIHandler
+    IconHandler,
+    ListServersAPIHandler,
+    ServersAPIHandler,
+    ServersInfoHandler,
 )
 from .config import ServerProxy as ServerProxyConfig
-from .config import (
-    get_entrypoint_server_processes, make_handlers, make_server_process
-)
+from .config import get_entrypoint_server_processes, make_handlers, make_server_process
 from .handlers import setup_handlers
 
 
@@ -62,10 +63,10 @@ def _load_jupyter_server_extension(nbapp):
     for sp in server_processes:
         if sp.launcher_entry.enabled and sp.launcher_entry.icon_path:
             icon_handlers.append(
-               (
+                (
                     ujoin(base_url, f"server-proxy/icon/{sp.name}"),
                     IconHandler,
-                    {"path": sp.launcher_entry.icon_path}
+                    {"path": sp.launcher_entry.icon_path},
                 )
             )
 
@@ -77,15 +78,10 @@ def _load_jupyter_server_extension(nbapp):
                 ServersInfoHandler,
                 {"server_processes": server_processes},
             ),
-            (
-                ujoin(base_url, r"api/server-proxy"),
-                ListServersAPIHandler
-            ),
-            (
-                ujoin(base_url, r"api/server-proxy/(?P<name>.*)"),
-                ServersAPIHandler
-            ),
-        ] + icon_handlers,
+            (ujoin(base_url, r"api/server-proxy"), ListServersAPIHandler),
+            (ujoin(base_url, r"api/server-proxy/(?P<name>.*)"), ServersAPIHandler),
+        ]
+        + icon_handlers,
     )
 
 

jupyter_server_proxy/api.py

@@ -41,12 +41,13 @@ class IconHandler(web.StaticFileHandler):
     """A singular handler for serving the icon."""
 
     def get(self):
-        return super().get('')
+        return super().get("")
 
     @classmethod
     def get_absolute_path(cls, root, path):
         """We only serve one file, ignore relative path"""
         import os
+
         return os.path.abspath(root)
 
 

jupyter_server_proxy/handlers.py

@@ -20,10 +20,10 @@
 from traitlets import Bytes, Dict, Instance, Integer, Unicode, Union, default, observe
 from traitlets.traitlets import HasTraits
 
+from .manager import manager
 from .unixsock import UnixResolver
 from .utils import call_with_asked_args
 from .websocket import WebSocketHandlerMixin, pingable_ws_connect
-from .manager import manager
 
 
 class RewritableResponse(HasTraits):
@@ -801,7 +801,6 @@ async def ensure_process(self):
         # Invariant here should be: when lock isn't being held, either 'proc' is in state &
         # running, or not.
         async with self.state["proc_lock"]:
-
             # If the server process is terminated via Runningsessions or killed
             # outside of jsp, we should be able to restart the process. If
             # process is not in running stated, remove proc object and restart
@@ -848,7 +847,9 @@ async def ensure_process(self):
 
                     # If process started succesfully, add it to manager
                     # Add the server proxy app to manager
-                    await manager.add_server_proxy_app(self.name, self.base_url, cmd, self.port, proc)
+                    await manager.add_server_proxy_app(
+                        self.name, self.base_url, cmd, self.port, proc
+                    )
                 except:
                     # Make sure we remove proc from state in any error condition
                     del self.state["proc"]

jupyter_server_proxy/manager.py

@@ -1,18 +1,14 @@
 """Manager for jupyter server proxy"""
 
 from collections import namedtuple
-from tornado.ioloop import PeriodicCallback
+
 from jupyter_server.utils import url_path_join as ujoin
+from tornado.ioloop import PeriodicCallback
 
 from .utils import check_pid
 
-
-ServerProxy = namedtuple('ServerProxy', [
-    'name', 'url', 'cmd', 'port', 'managed'
-])
-ServerProxyProc = namedtuple('ServerProxyProc', [
-    'name', 'proc'
-])
+ServerProxy = namedtuple("ServerProxy", ["name", "url", "cmd", "port", "managed"])
+ServerProxyProc = namedtuple("ServerProxyProc", ["name", "proc"])
 
 
 async def monitor_server_proxy_procs():
@@ -53,25 +49,31 @@ async def add_server_proxy_app(self, name, base_url, cmd, port, proc):
         # Add proxy server metadata
         self.server_proxy_apps.append(
             ServerProxy(
-            name=name,
-            url=ujoin(base_url, name),
-            cmd=' '.join(cmd),
-            port=port,
-            managed=True if proc else False,
-        ))
+                name=name,
+                url=ujoin(base_url, name),
+                cmd=" ".join(cmd),
+                port=port,
+                managed=True if proc else False,
+            )
+        )
 
         # Add proxy server proc object so that we can send SIGTERM
         # when user chooses to shut it down
         self._server_proxy_procs.append(
             ServerProxyProc(
-            name=name,
-            proc=proc,
-        ))
+                name=name,
+                proc=proc,
+            )
+        )
 
     async def del_server_proxy_app(self, name):
         """Remove a launched proxy server from list"""
-        self.server_proxy_apps = [app for app in self.server_proxy_apps if app.name != name]
-        self._server_proxy_procs = [app for app in self._server_proxy_procs if app.name != name]
+        self.server_proxy_apps = [
+            app for app in self.server_proxy_apps if app.name != name
+        ]
+        self._server_proxy_procs = [
+            app for app in self._server_proxy_procs if app.name != name
+        ]
         self.num_active_server_proxy_apps -= 1
 
     def get_server_proxy_app(self, name):
@@ -121,5 +123,5 @@ async def terminate_all(self):
 manager = ServerProxyAppManager()
 
 # Create a Periodic call back function to check the status of processes
-pc = PeriodicCallback(monitor_server_proxy_procs,  1e4)
+pc = PeriodicCallback(monitor_server_proxy_procs, 1e4)
 pc.start()

jupyter_server_proxy/utils.py

@@ -1,4 +1,5 @@
 import os
+
 from traitlets import TraitType
 
 
@@ -53,7 +54,7 @@ def validate(self, obj, value):
 
 
 def check_pid(pid):
-    """ Check For the existence of a unix pid"""
+    """Check For the existence of a unix pid"""
     try:
         os.kill(pid, 0)
     except OSError:

labextension/src/index.ts

@@ -5,20 +5,20 @@ import {
 } from "@jupyterlab/application";
 import { ILauncher } from "@jupyterlab/launcher";
 import { PageConfig } from "@jupyterlab/coreutils";
-import { IRunningSessionManagers, IRunningSessions } from '@jupyterlab/running';
+import { IRunningSessionManagers, IRunningSessions } from "@jupyterlab/running";
 import { IFrame, MainAreaWidget, WidgetTracker } from "@jupyterlab/apputils";
-import { LabIcon } from '@jupyterlab/ui-components';
-import { ServerProxyManager } from './manager';
-import { IModel as IServerProxyModel } from './serverproxy';
-import serverProxyAppSvgstr from '../style/icons/proxy.svg';
+import { LabIcon } from "@jupyterlab/ui-components";
+import { ServerProxyManager } from "./manager";
+import { IModel as IServerProxyModel } from "./serverproxy";
+import serverProxyAppSvgstr from "../style/icons/proxy.svg";
 
 export const ServerProxyAppIcon = new LabIcon({
-  name: 'server-proxy:proxyAppIcon',
-  svgstr: serverProxyAppSvgstr
+  name: "server-proxy:proxyAppIcon",
+  svgstr: serverProxyAppSvgstr,
 });
 
 namespace CommandIDs {
-  export const open = 'running-server-proxy:open';
+  export const open = "running-server-proxy:open";
 }
 
 function newServerProxyWidget(
@@ -52,21 +52,22 @@ function newServerProxyWidget(
  * User can shut down the applications as well to restart them in future
  *
  */
- function addRunningSessionManager(
+function addRunningSessionManager(
   managers: IRunningSessionManagers,
   app: JupyterFrontEnd,
-  manager: ServerProxyManager
+  manager: ServerProxyManager,
 ): void {
   managers.add({
-    name: 'Server Proxy Apps',
+    name: "Server Proxy Apps",
     running: () =>
       Array.from(manager.running()).map(
-        model => new RunningServerProxyApp(model)
+        (model) => new RunningServerProxyApp(model),
       ),
     shutdownAll: () => manager.shutdownAll(),
     refreshRunning: () => manager.refreshRunning(),
     runningChanged: manager.runningChanged,
-    shutdownAllConfirmationText: 'Are you sure you want to close all server proxy applications?'
+    shutdownAllConfirmationText:
+      "Are you sure you want to close all server proxy applications?",
   });
 
   class RunningServerProxyApp implements IRunningSessions.IRunningItem {
@@ -103,7 +104,7 @@ async function activate(
   app: JupyterFrontEnd,
   launcher: ILauncher,
   restorer: ILayoutRestorer,
-  sessions: IRunningSessionManagers | null
+  sessions: IRunningSessionManagers | null,
 ): Promise<void> {
   // Fetch configured server processes from {base_url}/server-proxy/servers-info
   const response = await fetch(
@@ -175,12 +176,12 @@ async function activate(
   });
 
   commands.addCommand(CommandIDs.open, {
-    execute: args => {
-      const model = args['sp'] as IServerProxyModel;
+    execute: (args) => {
+      const model = args["sp"] as IServerProxyModel;
       const url = PageConfig.getBaseUrl() + model.url;
-      window.open(url, '_blank');
+      window.open(url, "_blank");
       return;
-    }
+    },
   });
 
   for (let server_process of data.server_processes) {
@@ -222,7 +223,7 @@ const extension: JupyterFrontEndPlugin<void> = {
   autoStart: true,
   requires: [ILauncher, ILayoutRestorer],
   optional: [IRunningSessionManagers],
-  activate: activate
+  activate: activate,
 };
 
 export default extension;