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

pre-commit-ci[bot] · pre-commit-ci[bot] · commit 759d42092331 · 2025-06-15T14:04:55.000Z
for more information, see https://pre-commit.ci
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,7 +10,7 @@ All notable changes to this project will be documented in this file.
 
 ### Enhancements made
 
-- If ServerApp.ip is ipv6 use [::1] as local_url [#1495](https://github.com/jupyter-server/jupyter_server/pull/1495) ([@manics](https://github.com/manics))
+- If ServerApp.ip is ipv6 use \[::1\] as local_url [#1495](https://github.com/jupyter-server/jupyter_server/pull/1495) ([@manics](https://github.com/manics))
 - Don't hide .so,.dylib files by default [#1457](https://github.com/jupyter-server/jupyter_server/pull/1457) ([@nokados](https://github.com/nokados))
 - Add async start hook to ExtensionApp API [#1417](https://github.com/jupyter-server/jupyter_server/pull/1417) ([@Zsailer](https://github.com/Zsailer))
 
diff --git a/jupyter_server/prometheus/__init__.py b/jupyter_server/prometheus/__init__.py
@@ -5,21 +5,20 @@
 """
 
 from .metrics import (
+    ACTIVE_DURATION,
     HTTP_REQUEST_DURATION_SECONDS,
     KERNEL_CURRENTLY_RUNNING_TOTAL,
-    TERMINAL_CURRENTLY_RUNNING_TOTAL,
-    SERVER_INFO,
-    SERVER_EXTENSION_INFO,
     LAST_ACTIVITY,
+    SERVER_EXTENSION_INFO,
+    SERVER_INFO,
     SERVER_STARTED,
-    ACTIVE_DURATION,
+    TERMINAL_CURRENTLY_RUNNING_TOTAL,
 )
-
 from .server import PrometheusMetricsServer, start_metrics_server
 
 __all__ = [
     "HTTP_REQUEST_DURATION_SECONDS",
-    "KERNEL_CURRENTLY_RUNNING_TOTAL", 
+    "KERNEL_CURRENTLY_RUNNING_TOTAL",
     "TERMINAL_CURRENTLY_RUNNING_TOTAL",
     "SERVER_INFO",
     "SERVER_EXTENSION_INFO",
diff --git a/jupyter_server/prometheus/server.py b/jupyter_server/prometheus/server.py
@@ -21,32 +21,33 @@
 """
 
 import threading
-import tornado.web
+from typing import Optional
+
+import prometheus_client
 import tornado.httpserver
 import tornado.ioloop
-import prometheus_client
-from typing import Optional
+import tornado.web
 
 from jupyter_server._version import __version__
 from jupyter_server.base.handlers import PrometheusMetricsHandler
 from jupyter_server.prometheus.metrics import (
-    SERVER_INFO,
-    SERVER_EXTENSION_INFO,
-    LAST_ACTIVITY,
-    SERVER_STARTED,
     ACTIVE_DURATION,
     HTTP_REQUEST_DURATION_SECONDS,
     KERNEL_CURRENTLY_RUNNING_TOTAL,
+    LAST_ACTIVITY,
+    SERVER_EXTENSION_INFO,
+    SERVER_INFO,
+    SERVER_STARTED,
     TERMINAL_CURRENTLY_RUNNING_TOTAL,
 )
 
 
 class PrometheusMetricsServer:
     """A separate server for exposing Prometheus metrics."""
-    
+
     def __init__(self, server_app):
         """Initialize the metrics server.
-        
+
         Parameters
         ----------
         server_app : ServerApp
@@ -56,172 +57,181 @@ def __init__(self, server_app):
         self.port = None
         self.http_server = None
         self.thread = None
-        
+
     def initialize_metrics(self):
         """Initialize Jupyter-specific metrics for this server instance."""
         # Set server version info
         SERVER_INFO.info({"version": __version__})
-        
+
         # Set up extension info
         for ext in self.server_app.extension_manager.extensions.values():
             SERVER_EXTENSION_INFO.labels(
                 name=ext.name, version=ext.version, enabled=str(ext.enabled).lower()
             ).info({})
-        
+
         # Set server start time
         started = self.server_app.web_app.settings["started"]
         SERVER_STARTED.set(started.timestamp())
-        
+
         # Set up activity tracking
         LAST_ACTIVITY.set_function(lambda: self.server_app.web_app.last_activity().timestamp())
         ACTIVE_DURATION.set_function(
             lambda: (
-                self.server_app.web_app.last_activity() - self.server_app.web_app.settings["started"]
+                self.server_app.web_app.last_activity()
+                - self.server_app.web_app.settings["started"]
             ).total_seconds()
         )
-        
+
         # Set up kernel and terminal metrics
         self._setup_runtime_metrics()
-        
+
         # Note: HTTP request metrics are recorded by the main server's logging system
         # via the log_request function when record_http_request_metrics=True.
         # The separate metrics server uses the same prometheus registry, so those
         # metrics will be available here as well.
-    
+
     def _setup_runtime_metrics(self):
         """Set up metrics that track runtime state."""
+
         # Set up kernel count tracking
         def update_kernel_metrics():
             try:
                 kernel_manager = self.server_app.kernel_manager
-                if hasattr(kernel_manager, 'list_kernel_ids'):
+                if hasattr(kernel_manager, "list_kernel_ids"):
                     kernel_ids = kernel_manager.list_kernel_ids()
                     # Reset all kernel type metrics to 0
                     for kernel_type in set(KERNEL_CURRENTLY_RUNNING_TOTAL._metrics.keys()):
                         KERNEL_CURRENTLY_RUNNING_TOTAL.labels(type=kernel_type).set(0)
-                    
+
                     # Count kernels by type
                     kernel_types = {}
                     for kid in kernel_ids:
                         try:
                             kernel = kernel_manager.get_kernel(kid)
-                            if hasattr(kernel, 'kernel_name'):
+                            if hasattr(kernel, "kernel_name"):
                                 kernel_type = kernel.kernel_name
                             else:
-                                kernel_type = 'unknown'
+                                kernel_type = "unknown"
                             kernel_types[kernel_type] = kernel_types.get(kernel_type, 0) + 1
                         except Exception:
-                            kernel_types['unknown'] = kernel_types.get('unknown', 0) + 1
-                    
+                            kernel_types["unknown"] = kernel_types.get("unknown", 0) + 1
+
                     # Update metrics
                     for kernel_type, count in kernel_types.items():
                         KERNEL_CURRENTLY_RUNNING_TOTAL.labels(type=kernel_type).set(count)
             except Exception as e:
                 self.server_app.log.debug(f"Error updating kernel metrics: {e}")
-        
+
         # Set up terminal count tracking
         def update_terminal_metrics():
             try:
-                terminal_manager = getattr(self.server_app, 'terminal_manager', None)
-                if terminal_manager and hasattr(terminal_manager, 'list'):
+                terminal_manager = getattr(self.server_app, "terminal_manager", None)
+                if terminal_manager and hasattr(terminal_manager, "list"):
                     terminal_count = len(terminal_manager.list())
                     TERMINAL_CURRENTLY_RUNNING_TOTAL.set(terminal_count)
                 else:
                     TERMINAL_CURRENTLY_RUNNING_TOTAL.set(0)
             except Exception as e:
                 self.server_app.log.debug(f"Error updating terminal metrics: {e}")
-        
+
         # Set up periodic updates
         def periodic_update():
             update_kernel_metrics()
             update_terminal_metrics()
-        
+
         # Run initial update
         periodic_update()
-        
+
         # Set up periodic updates every 30 seconds
         def start_periodic_updates():
             loop = tornado.ioloop.IOLoop.current()
+
             def update():
                 periodic_update()
                 loop.call_later(30, update)
+
             loop.call_later(30, update)
-        
+
         # Start periodic updates in the main server's IOLoop
-        if hasattr(self.server_app, 'io_loop') and self.server_app.io_loop:
+        if hasattr(self.server_app, "io_loop") and self.server_app.io_loop:
             self.server_app.io_loop.add_callback(start_periodic_updates)
-    
+
     def start(self, port: int) -> None:
         """Start the metrics server on the specified port.
-        
+
         Parameters
         ----------
         port : int
             The port to listen on for metrics requests
         """
         self.port = port
-        
+
         # Initialize Jupyter metrics
         self.initialize_metrics()
-        
+
         # Reuse the main server's web application and settings
         # This ensures identical behavior and eliminates duplication
         main_app = self.server_app.web_app
-        
+
         # Create a new application that shares the same settings and handlers
         # but only serves the metrics endpoint
-        metrics_app = tornado.web.Application([
-            (r"/metrics", PrometheusMetricsHandler),
-        ], **main_app.settings)
-        
+        metrics_app = tornado.web.Application(
+            [
+                (r"/metrics", PrometheusMetricsHandler),
+            ],
+            **main_app.settings,
+        )
+
         # Determine authentication status for logging
         authenticate_metrics = main_app.settings.get("authenticate_prometheus", True)
         auth_info = "with authentication" if authenticate_metrics else "without authentication"
-        
+
         # Create and start the HTTP server
         self.http_server = tornado.httpserver.HTTPServer(metrics_app)
         self.http_server.listen(port)
-        
+
         # Start the IOLoop in a separate thread
         def start_metrics_loop():
             loop = tornado.ioloop.IOLoop()
             loop.make_current()
             loop.start()
-        
+
         self.thread = threading.Thread(target=start_metrics_loop, daemon=True)
         self.thread.start()
-        
-        self.server_app.log.info(f"Metrics server started on port {port} {auth_info} (using Jupyter Prometheus integration)")
-    
+
+        self.server_app.log.info(
+            f"Metrics server started on port {port} {auth_info} (using Jupyter Prometheus integration)"
+        )
+
     def stop(self) -> None:
         """Stop the metrics server."""
         if self.http_server:
             self.http_server.stop()
             self.http_server = None
-        
+
         if self.thread and self.thread.is_alive():
             # Note: Tornado IOLoop doesn't have a clean stop method
             # The thread will exit when the process ends
             pass
-        
+
         self.server_app.log.info(f"Metrics server stopped on port {self.port}")
 
 
 def start_metrics_server(server_app, port: int) -> PrometheusMetricsServer:
     """Start a Prometheus metrics server for the given Jupyter server.
-    
+
     Parameters
     ----------
     server_app : ServerApp
         The main Jupyter server application instance
     port : int
         The port to listen on for metrics requests
-        
+
     Returns
     -------
     PrometheusMetricsServer
         The metrics server instance
     """
     metrics_server = PrometheusMetricsServer(server_app)
     metrics_server.start(port)
-    return metrics_server 
+    return metrics_server
diff --git a/jupyter_server/serverapp.py b/jupyter_server/serverapp.py
@@ -113,12 +113,12 @@
 from jupyter_server.log import log_request
 from jupyter_server.prometheus.metrics import (
     ACTIVE_DURATION,
+    HTTP_REQUEST_DURATION_SECONDS,
+    KERNEL_CURRENTLY_RUNNING_TOTAL,
     LAST_ACTIVITY,
     SERVER_EXTENSION_INFO,
     SERVER_INFO,
     SERVER_STARTED,
-    HTTP_REQUEST_DURATION_SECONDS,
-    KERNEL_CURRENTLY_RUNNING_TOTAL,
     TERMINAL_CURRENTLY_RUNNING_TOTAL,
 )
 from jupyter_server.services.config import ConfigManager
@@ -415,7 +415,8 @@ def init_settings(
         settings = {
             # basics
             "log_function": partial(
-                log_request, record_prometheus_metrics=jupyter_app.record_http_request_metrics),
+                log_request, record_prometheus_metrics=jupyter_app.record_http_request_metrics
+            ),
             "base_url": base_url,
             "default_url": default_url,
             "template_path": template_path,
@@ -514,11 +515,11 @@ def init_handlers(self, default_services, settings, jupyter_app):
 
         # register base handlers last
         base_handlers = load_handlers("jupyter_server.base.handlers")
-        
+
         # If a separate metrics server is running, exclude the /metrics handler from main server
         if jupyter_app.metrics_port:
             base_handlers = [h for h in base_handlers if h[0] != r"/metrics"]
-        
+
         handlers.extend(base_handlers)
 
         if settings["default_url"] != settings["base_url"]:
@@ -3045,11 +3046,11 @@ def _prepare_browser_open(self) -> tuple[str, t.Optional[str]]:
             assembled_url = url_path_join(self.connection_url, uri)
 
         return assembled_url, open_file
-    
+
     def _start_metrics_server(self, port):
         """Start a separate metrics server on the specified port using Jupyter's Prometheus integration."""
         from jupyter_server.prometheus.server import start_metrics_server
-        
+
         self.metrics_server = start_metrics_server(self, port)
 
     def launch_browser(self) -> None:
