[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/gateway/v3/managers.py

@@ -1,11 +1,12 @@
 """Gateway kernel manager that integrates with our kernel monitoring system."""
 
 import asyncio
-from jupyter_server.gateway.managers import GatewayMappingKernelManager
-from jupyter_server.gateway.managers import GatewayKernelManager as _GatewayKernelManager
-from jupyter_server.gateway.managers import GatewayKernelClient as _GatewayKernelClient
-from traitlets import default, Instance, Type
 
+from traitlets import Instance, Type, default
+
+from jupyter_server.gateway.managers import GatewayKernelClient as _GatewayKernelClient
+from jupyter_server.gateway.managers import GatewayKernelManager as _GatewayKernelManager
+from jupyter_server.gateway.managers import GatewayMappingKernelManager
 from jupyter_server.services.kernels.v3.client import JupyterServerKernelClientMixin
 
 
@@ -38,22 +39,22 @@ def _send_message(self, channel_name: str, msg: list[bytes]):
         # Send to gateway channel
         try:
             channel = getattr(self, f"{channel_name}_channel", None)
-            if channel and hasattr(channel, 'send'):
+            if channel and hasattr(channel, "send"):
                 # Convert raw message to gateway format
                 header = self.session.unpack(msg[0])
                 parent_header = self.session.unpack(msg[1])
                 metadata = self.session.unpack(msg[2])
                 content = self.session.unpack(msg[3])
 
                 full_msg = {
-                    'header': header,
-                    'parent_header': parent_header,
-                    'metadata': metadata,
-                    'content': content,
-                    'buffers': msg[4:] if len(msg) > 4 else [],
-                    'channel': channel_name,
-                    'msg_id': header.get('msg_id'),
-                    'msg_type': header.get('msg_type')
+                    "header": header,
+                    "parent_header": parent_header,
+                    "metadata": metadata,
+                    "content": content,
+                    "buffers": msg[4:] if len(msg) > 4 else [],
+                    "channel": channel_name,
+                    "msg_id": header.get("msg_id"),
+                    "msg_type": header.get("msg_type"),
                 }
 
                 channel.send(full_msg)
@@ -74,7 +75,7 @@ async def _monitor_channel_messages(self, channel_name: str, channel):
                         channel_name,
                         message,
                         parent_msg_id=message.get("parent_header", {}).get("msg_id"),
-                        execution_state=message.get("content", {}).get("execution_state")
+                        execution_state=message.get("content", {}).get("execution_state"),
                     )
 
                     # Serialize message to standard format for listeners
@@ -83,10 +84,14 @@ async def _monitor_channel_messages(self, channel_name: str, channel):
                     serialized = self.session.serialize(message)
 
                     # Skip delimiter (index 0) and signature (index 1) to get [header, parent_header, metadata, content, ...]
-                    if serialized and len(serialized) >= 6:  # Need delimiter + signature + 4 message parts
+                    if (
+                        serialized and len(serialized) >= 6
+                    ):  # Need delimiter + signature + 4 message parts
                         msg_list = serialized[2:]
                     else:
-                        self.log.warning(f"Gateway message too short: {len(serialized) if serialized else 0} parts")
+                        self.log.warning(
+                            f"Gateway message too short: {len(serialized) if serialized else 0} parts"
+                        )
                         continue
 
                     # Route to listeners
@@ -124,14 +129,15 @@ class GatewayKernelManager(_GatewayKernelManager):
     When jupyter_server is configured to use a gateway, this manager ensures that
     remote kernels receive the same level of monitoring as local kernels.
     """
+
     # Configure the manager to use our enhanced gateway client
     client_class = GatewayKernelClient
     client_factory = GatewayKernelClient
 
     kernel_client = Instance(
-        'jupyter_client.client.KernelClient',
+        "jupyter_client.client.KernelClient",
         allow_none=True,
-        help="""Pre-created kernel client instance. Created on initialization."""
+        help="""Pre-created kernel client instance. Created on initialization.""",
     )
 
     def __init__(self, **kwargs):
@@ -184,7 +190,9 @@ async def cleanup_resources(self, restart=False):
             if restart:
                 # On restart, clear client state but keep connection
                 # The connection will be refreshed in post_start_kernel after restart
-                self.log.debug(f"Clearing kernel client state for restart of kernel {self.kernel_id}")
+                self.log.debug(
+                    f"Clearing kernel client state for restart of kernel {self.kernel_id}"
+                )
                 self.kernel_client.last_shell_status_time = None
                 self.kernel_client.last_control_status_time = None
                 # Disconnect before restart - will reconnect after
@@ -208,7 +216,6 @@ def _default_kernel_manager_class(self):
 
     def start_watching_activity(self, kernel_id):
         pass
-    
+
     def stop_buffering(self, kernel_id):
         pass
-

jupyter_server/serverapp.py

@@ -1652,11 +1652,15 @@ def template_file_path(self) -> list[str]:
     @default("kernel_manager_class")
     def _default_kernel_manager_class(self) -> t.Union[str, type[AsyncMappingKernelManager]]:
         if self.kernels_api_version == 3:
-            gateway_enabled = getattr(self, 'gateway_config', None) and getattr(self.gateway_config, 'gateway_enabled', False)
+            gateway_enabled = getattr(self, "gateway_config", None) and getattr(
+                self.gateway_config, "gateway_enabled", False
+            )
             if gateway_enabled:
                 return "jupyter_server.gateway.v3.managers.GatewayMultiKernelManager"
             return "jupyter_server.services.kernels.v3.kernelmanager.AsyncMappingKernelManager"
-        gateway_enabled = getattr(self, 'gateway_config', None) and getattr(self.gateway_config, 'gateway_enabled', False)
+        gateway_enabled = getattr(self, "gateway_config", None) and getattr(
+            self.gateway_config, "gateway_enabled", False
+        )
         if gateway_enabled:
             return "jupyter_server.gateway.managers.GatewayMappingKernelManager"
         return AsyncMappingKernelManager
@@ -1685,7 +1689,9 @@ def _default_kernel_websocket_connection_class(
         if self.kernels_api_version == 3:
             # V3 uses shared kernel client connection for both local and gateway
             return "jupyter_server.services.kernels.v3.connection.client_connection.KernelClientWebsocketConnection"
-        gateway_enabled = getattr(self, 'gateway_config', None) and getattr(self.gateway_config, 'gateway_enabled', False)
+        gateway_enabled = getattr(self, "gateway_config", None) and getattr(
+            self.gateway_config, "gateway_enabled", False
+        )
         if gateway_enabled:
             return "jupyter_server.gateway.connections.GatewayWebSocketConnection"
         return ZMQChannelsWebsocketConnection

jupyter_server/services/kernels/v3/connection/client_connection.py

@@ -1,10 +1,14 @@
+from jupyter_client.session import Session
 from tornado.websocket import WebSocketClosedError
-from traitlets import List as TraitletsList, Tuple as TraitletsTuple
+from traitlets import List as TraitletsList
+from traitlets import Tuple as TraitletsTuple
+
 from jupyter_server.services.kernels.connection.base import (
     BaseKernelWebsocketConnection,
+    deserialize_msg_from_ws_v1,
+    serialize_msg_to_ws_v1,
 )
-from jupyter_server.services.kernels.connection.base import deserialize_msg_from_ws_v1, serialize_msg_to_ws_v1
-from jupyter_client.session import Session
+
 from ..message_utils import encode_cell_id_in_message, strip_encoding_from_message
 
 
@@ -54,7 +58,7 @@ class KernelClientWebsocketConnection(BaseKernelWebsocketConnection):
         these (msg_type, channel) pairs will be sent to the websocket.
 
         Example: [("status", "iopub"), ("execute_reply", "shell")]
-        """
+        """,
     )
 
     exclude_msg_types = TraitletsList(
@@ -71,7 +75,7 @@ class KernelClientWebsocketConnection(BaseKernelWebsocketConnection):
 
         Note: Cannot be used together with msg_types. If both are specified,
         msg_types takes precedence.
-        """
+        """,
     )
 
     def _get_kernel_client(self):
@@ -90,7 +94,7 @@ def _get_kernel_client(self):
                 raise RuntimeError(f"No kernel manager found for kernel {self.kernel_id}")
 
             # Get the pre-created kernel client from the kernel manager
-            if not hasattr(km, 'kernel_client') or km.kernel_client is None:
+            if not hasattr(km, "kernel_client") or km.kernel_client is None:
                 raise RuntimeError(f"Kernel manager for {self.kernel_id} has no kernel_client")
 
             return km.kernel_client
@@ -115,8 +119,12 @@ async def connect(self):
             client.add_listener(self.handle_outgoing_message, msg_types=msg_types_list)
         elif self.exclude_msg_types is not None:
             # Convert list of tuples to list for the API
-            exclude_msg_types_list = [tuple(item) for item in self.exclude_msg_types] if self.exclude_msg_types else None
-            client.add_listener(self.handle_outgoing_message, exclude_msg_types=exclude_msg_types_list)
+            exclude_msg_types_list = (
+                [tuple(item) for item in self.exclude_msg_types] if self.exclude_msg_types else None
+            )
+            client.add_listener(
+                self.handle_outgoing_message, exclude_msg_types=exclude_msg_types_list
+            )
         else:
             # No filtering - listen to all messages (default)
             client.add_listener(self.handle_outgoing_message)
@@ -170,7 +178,9 @@ def handle_outgoing_message(self, channel_name, msg):
         try:
             # Validate message has minimum required parts
             if not msg or len(msg) < 4:
-                self.log.warning(f"Message on {channel_name} has insufficient parts: {len(msg) if msg else 0}")
+                self.log.warning(
+                    f"Message on {channel_name} has insufficient parts: {len(msg) if msg else 0}"
+                )
                 return
 
             # Validate parts are bytes
@@ -192,4 +202,6 @@ def handle_outgoing_message(self, channel_name, msg):
         except WebSocketClosedError:
             self.log.warning("A Kernel Socket message arrived on a closed websocket channel.")
         except Exception as err:
-            self.log.error(f"Error handling outgoing message on {channel_name}: {err}", exc_info=True)
+            self.log.error(
+                f"Error handling outgoing message on {channel_name}: {err}", exc_info=True
+            )

jupyter_server/services/kernels/v3/kernelmanager.py

@@ -1,10 +1,12 @@
 """Kernel manager for the Apple JupyterLab Kernel Monitor Extension."""
 
 from jupyter_client.multikernelmanager import AsyncMultiKernelManager
-from traitlets import Type, observe, Instance, default
+from traitlets import Instance, Type, default, observe
 
 from jupyter_server.services.kernels.kernelmanager import (
     MappingKernelManager,
+)
+from jupyter_server.services.kernels.kernelmanager import (
     ServerKernelManager as _ServerKernelManager,
 )
 
@@ -24,22 +26,22 @@ class ServerKernelManager(_ServerKernelManager):
 
     client_class = Type(
         default_value=JupyterServerKernelClient,
-        klass='jupyter_client.client.KernelClient',
+        klass="jupyter_client.client.KernelClient",
         config=True,
-        help="""The kernel client class to use for creating kernel clients."""
+        help="""The kernel client class to use for creating kernel clients.""",
     )
 
     client_factory = Type(
         default_value=JupyterServerKernelClient,
-        klass='jupyter_client.client.KernelClient',
+        klass="jupyter_client.client.KernelClient",
         config=True,
-        help="""The kernel client factory class to use."""
+        help="""The kernel client factory class to use.""",
     )
 
     kernel_client = Instance(
-        'jupyter_client.client.KernelClient',
+        "jupyter_client.client.KernelClient",
         allow_none=True,
-        help="""Pre-created kernel client instance. Created on initialization."""
+        help="""Pre-created kernel client instance. Created on initialization.""",
     )
 
     def __init__(self, **kwargs):
@@ -49,11 +51,11 @@ def __init__(self, **kwargs):
         # Create a kernel client instance immediately
         self.kernel_client = self.client(session=self.session)
 
-    @observe('client_class')
+    @observe("client_class")
     def _client_class_changed(self, change):
         """Override parent's _client_class_changed to handle Type trait instead of DottedObjectName."""
         # Set client_factory to the same class
-        self.client_factory = change['new']
+        self.client_factory = change["new"]
 
     async def _async_post_start_kernel(self, **kwargs):
         """After kernel starts, connect the kernel client.
@@ -97,7 +99,9 @@ async def cleanup_resources(self, restart=False):
             if restart:
                 # On restart, clear client state but keep connection
                 # The connection will be refreshed in post_start_kernel after restart
-                self.log.debug(f"Clearing kernel client state for restart of kernel {self.kernel_id}")
+                self.log.debug(
+                    f"Clearing kernel client state for restart of kernel {self.kernel_id}"
+                )
                 self.kernel_client.last_shell_status_time = None
                 self.kernel_client.last_control_status_time = None
                 # Disconnect before restart - will reconnect after
@@ -110,11 +114,11 @@ async def cleanup_resources(self, restart=False):
                 self.kernel_client.stop_channels()
 
         await super().cleanup_resources(restart=restart)
-    
+
 
 class AsyncMappingKernelManager(MappingKernelManager, AsyncMultiKernelManager):  # type:ignore[misc]
     """Custom kernel manager that uses enhanced monitoring kernel manager with v3 API."""
-    
+
     @default("kernel_manager_class")
     def _default_kernel_manager_class(self):
-        return "jupyter_server.services.kernels.v3.kernelmanager.ServerKernelManager"
+        return "jupyter_server.services.kernels.v3.kernelmanager.ServerKernelManager"