Set JPY_SESSION_NAME to full notebook path.

This also add some typing here and there, and extend one of the console
warning to log an exception when there is an error.

My main concern is that get_kernel_env need to become async.

cleanup

Author: Carreau

jupyter_server/base/handlers.py

@@ -725,7 +725,7 @@ def write_error(self, status_code, **kwargs):
                 reply["message"] = "Unhandled error"
                 reply["reason"] = None
                 reply["traceback"] = "".join(traceback.format_exception(*exc_info))
-        self.log.warning("wrote error: %r", reply["message"])
+        self.log.warning("wrote error: %r", reply["message"], exc_info=True)
         self.finish(json.dumps(reply))
 
     def get_login_url(self):

jupyter_server/services/contents/fileio.py

@@ -16,7 +16,7 @@
 from traitlets import Bool
 from traitlets.config import Configurable
 
-from jupyter_server.utils import to_api_path, to_os_path
+from jupyter_server.utils import ApiPath, to_api_path, to_os_path
 
 
 def replace_file(src, dst):
@@ -254,7 +254,7 @@ def _get_os_path(self, path):
         404: if path is outside root
         """
         root = os.path.abspath(self.root_dir)
-        os_path = to_os_path(path, root)
+        os_path = to_os_path(ApiPath(path), root)
         if not (os.path.abspath(os_path) + os.path.sep).startswith(root):
             raise HTTPError(404, "%s is outside root contents directory" % path)
         return os_path

jupyter_server/services/kernels/kernelmanager.py

@@ -11,6 +11,8 @@
 from collections import defaultdict
 from datetime import datetime, timedelta
 from functools import partial
+from typing import Dict as DictType
+from typing import Optional
 
 from jupyter_client.ioloop.manager import AsyncIOLoopKernelManager
 from jupyter_client.multikernelmanager import (
@@ -38,7 +40,7 @@
 
 from jupyter_server._tz import isoformat, utcnow
 from jupyter_server.prometheus.metrics import KERNEL_CURRENTLY_RUNNING_TOTAL
-from jupyter_server.utils import ensure_async, import_item, to_os_path
+from jupyter_server.utils import ensure_async, import_item, to_os_path, ApiPath
 
 
 class MappingKernelManager(MultiKernelManager):
@@ -58,7 +60,7 @@ def _default_kernel_manager_class(self):
 
     _kernel_connections = Dict()
 
-    _kernel_ports = Dict()
+    _kernel_ports: DictType[str, str] = Dict()
 
     _culler_callback = None
 
@@ -196,12 +198,14 @@ async def _remove_kernel_when_ready(self, kernel_id, kernel_awaitable):
         self._kernel_connections.pop(kernel_id, None)
         self._kernel_ports.pop(kernel_id, None)
 
-    async def _async_start_kernel(self, kernel_id=None, path=None, **kwargs):
+    async def _async_start_kernel(
+        self, kernel_id: Optional[str] = None, path: Optional[ApiPath] = None, **kwargs: str
+    ) -> str:
         """Start a kernel for a session and return its kernel_id.
 
         Parameters
         ----------
-        kernel_id : uuid
+        kernel_id : uuid (str)
             The uuid to associate the new kernel with. If this
             is not None, this kernel will be persistent whenever it is
             requested.
@@ -216,6 +220,7 @@ async def _async_start_kernel(self, kernel_id=None, path=None, **kwargs):
             if path is not None:
                 kwargs["cwd"] = self.cwd_for_path(path, env=kwargs.get("env", {}))
             if kernel_id is not None:
+                assert kernel_id is not None
                 kwargs["kernel_id"] = kernel_id
             kernel_id = await self.pinned_superclass._async_start_kernel(self, **kwargs)
             self._kernel_connections[kernel_id] = 0
@@ -242,7 +247,7 @@ async def _async_start_kernel(self, kernel_id=None, path=None, **kwargs):
         # Initialize culling if not already
         if not self._initialized_culler:
             self.initialize_culler()
-
+        assert kernel_id is not None
         return kernel_id
 
     start_kernel = _async_start_kernel

jupyter_server/services/sessions/handlers.py

@@ -6,6 +6,7 @@
 # Distributed under the terms of the Modified BSD License.
 import asyncio
 import json
+import os.path
 
 try:
     from jupyter_client.jsonutil import json_default
@@ -49,10 +50,12 @@ async def post(self):
 
         if "notebook" in model and "path" in model["notebook"]:
             self.log.warning("Sessions API changed, see updated swagger docs")
-            model["path"] = model["notebook"]["path"]
+            model["path"] = model["notebook"]["name"]
             model["type"] = "notebook"
 
         try:
+            # There is a high chance here that `path` is not a path but
+            # a unique sesion id
             path = model["path"]
         except KeyError as e:
             raise web.HTTPError(400, "Missing field in JSON data: path") from e

jupyter_server/services/sessions/sessionmanager.py

@@ -4,6 +4,7 @@
 import os
 import pathlib
 import uuid
+from typing import Dict
 
 try:
     import sqlite3
@@ -12,7 +13,7 @@
     from pysqlite2 import dbapi2 as sqlite3  # type:ignore[no-redef]
 
 from dataclasses import dataclass, fields
-from typing import Union
+from typing import Optional, Union
 
 from tornado import web
 from traitlets import Instance, TraitError, Unicode, validate
@@ -39,8 +40,8 @@ class KernelSessionRecord:
     associated with them.
     """
 
-    session_id: Union[None, str] = None
-    kernel_id: Union[None, str] = None
+    session_id: Optional[str] = None
+    kernel_id: Optional[str] = None
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, KernelSessionRecord):
@@ -243,14 +244,21 @@ async def session_exists(self, path):
                 exists = True
         return exists
 
-    def new_session_id(self):
+    def new_session_id(self) -> str:
         "Create a uuid for a new session"
         return str(uuid.uuid4())
 
     async def create_session(
         self, path=None, name=None, type=None, kernel_name=None, kernel_id=None
     ):
-        """Creates a session and returns its model"""
+        """Creates a session and returns its model
+
+        name: str
+            Usually the model name, like the filename associated with current
+            kernel.
+
+
+        """
         session_id = self.new_session_id()
         record = KernelSessionRecord(session_id=session_id)
         self._pending_sessions.update(record)
@@ -268,15 +276,34 @@ async def create_session(
         self._pending_sessions.remove(record)
         return result
 
-    def get_kernel_env(self, path):
-        """Return the environment variables that need to be set in the kernel"""
+    async def get_kernel_env(self, path: str, name: Optional[str] = None) -> Dict[str, str]:
+        """Return the environment variables that need to be set in the kernel
+
+        name: str
+            Here the name is likely to be the name of the associated file
+            with the current kernel at startup time.
+
+
+        """
+        if name is not None:
+            session_dir = await self.contents_manager.get_kernel_path(path=path)
+            cwd = self.kernel_manager.cwd_for_path(path)
+            path = os.path.join(cwd, session_dir, name)
+        assert isinstance(path, str)
         return {**os.environ, "JPY_SESSION_NAME": path}
 
     async def start_kernel_for_session(self, session_id, path, name, type, kernel_name):
-        """Start a new kernel for a given session."""
+        """Start a new kernel for a given session.
+
+        name: str
+            Usually the model name, like the filename associated with current
+            kernel.
+
+        """
         # allow contents manager to specify kernels cwd
         kernel_path = await ensure_async(self.contents_manager.get_kernel_path(path=path))
-        kernel_env = self.get_kernel_env(path)
+
+        kernel_env = await self.get_kernel_env(path, name)
         kernel_id = await self.kernel_manager.start_kernel(
             path=kernel_path,
             kernel_name=kernel_name,

jupyter_server/utils.py

@@ -8,6 +8,7 @@
 import sys
 import warnings
 from contextlib import contextmanager
+from typing import NewType
 from urllib.parse import urljoin  # noqa: F401
 from urllib.parse import SplitResult, quote, unquote, urlparse, urlsplit, urlunsplit
 from urllib.request import pathname2url  # noqa: F401
@@ -18,6 +19,8 @@
 from tornado.httpclient import AsyncHTTPClient, HTTPClient, HTTPRequest
 from tornado.netutil import Resolver
 
+ApiPath = NewType("ApiPath", str)
+
 
 def url_path_join(*pieces):
     """Join components of url into a relative url
@@ -102,19 +105,19 @@ def samefile_simple(path, other_path):
     return path.lower() == other_path.lower() and path_stat == other_path_stat
 
 
-def to_os_path(path, root=""):
+def to_os_path(path: ApiPath, root: str = "") -> str:
     """Convert an API path to a filesystem path
 
     If given, root will be prepended to the path.
     root must be a filesystem path already.
     """
-    parts = path.strip("/").split("/")
+    parts = str(path).strip("/").split("/")
     parts = [p for p in parts if p != ""]  # remove duplicate splits
-    path = os.path.join(root, *parts)
-    return os.path.normpath(path)
+    path_ = os.path.join(root, *parts)
+    return os.path.normpath(path_)
 
 
-def to_api_path(os_path, root=""):
+def to_api_path(os_path: str, root: str = "") -> ApiPath:
     """Convert a filesystem path to an API path
 
     If given, root will be removed from the path.
@@ -125,7 +128,7 @@ def to_api_path(os_path, root=""):
     parts = os_path.strip(os.path.sep).split(os.path.sep)
     parts = [p for p in parts if p != ""]  # remove duplicate splits
     path = "/".join(parts)
-    return path
+    return ApiPath(path)
 
 
 def check_version(v, check):

tests/utils.py

@@ -1,4 +1,5 @@
 import json
+from typing import NewType
 
 from tornado.httpclient import HTTPClientError
 from tornado.web import HTTPError
@@ -10,6 +11,8 @@
     "display_name": "Test kernel",
 }
 
+ApiPath = NewType("ApiPath", str)
+
 
 def mkdir(tmp_path, *parts):
     path = tmp_path.joinpath(*parts)