Parameterized kernel specs

jupyter_server/serverapp.py

@@ -401,6 +401,8 @@ def init_settings(
             # collapse $HOME to ~
             root_dir = "~" + root_dir[len(home) :]
 
+        self.allow_insecure_kernelspec_params = jupyter_app.allow_insecure_kernelspec_params
+
         settings = {
             # basics
             "log_function": log_request,
@@ -460,6 +462,7 @@ def init_settings(
             "server_root_dir": root_dir,
             "jinja2_env": env,
             "serverapp": jupyter_app,
+            "page_config_hook": (self.page_config_hook),
         }
 
         # allow custom overrides for the tornado web app.
@@ -470,6 +473,10 @@ def init_settings(
             settings["xsrf_cookie_kwargs"] = {"path": base_url}
         return settings
 
+    def page_config_hook(self, handler, page_config):
+        page_config["allow_insecure_kernelspec_params"] = self.allow_insecure_kernelspec_params
+        return page_config
+
     def init_handlers(self, default_services, settings):
         """Load the (URL pattern, handler) tuples for each component."""
         # Order matters. The first handler to match the URL will handle the request.
@@ -1426,6 +1433,12 @@ def _default_allow_remote(self) -> bool:
                         """,
     )
 
+    allow_insecure_kernelspec_params = Bool(
+        False,
+        config=True,
+        help="""Allow to use insecure kernelspec parameters""",
+    )
+
     browser = Unicode(
         "",
         config=True,
@@ -2179,6 +2192,7 @@ def init_event_logger(self) -> None:
             self.event_logger.register_event_schema(schema_path)
 
     def init_webapp(self) -> None:
+        #
         """initialize tornado webapp"""
         self.tornado_settings["allow_origin"] = self.allow_origin
         self.tornado_settings["websocket_compression_options"] = self.websocket_compression_options
@@ -2986,7 +3000,7 @@ def target():
     def start_app(self) -> None:
         """Start the Jupyter Server application."""
         super().start()
-
+        #
         if not self.allow_root:
             # check if we are running as root, and abort if it's not allowed
             try:
@@ -3025,6 +3039,12 @@ def start_app(self) -> None:
         # Handle the browser opening.
         if self.open_browser and not self.sock:
             self.launch_browser()
+        if self.allow_insecure_kernelspec_params:
+            print("yesssssssssssssssss")
+            print(self.allow_insecure_kernelspec_params)
+            self.kernel_spec_manager.allow_insecure_kernelspec_params(
+                self.allow_insecure_kernelspec_params
+            )
 
         if self.identity_provider.token and self.identity_provider.token_generated:
             # log full URL with generated token, so there's a copy/pasteable link

jupyter_server/services/sessions/handlers.py

@@ -77,6 +77,7 @@ async def post(self):
         kernel = model.get("kernel", {})
         kernel_name = kernel.get("name", None)
         kernel_id = kernel.get("id", None)
+        custom_kernel_specs = kernel.get("custom_kernel_specs", {})
 
         if not kernel_id and not kernel_name:
             self.log.debug("No kernel specified, using default kernel")
@@ -93,6 +94,7 @@ async def post(self):
                     kernel_id=kernel_id,
                     name=name,
                     type=mtype,
+                    custom_kernel_specs=custom_kernel_specs,
                 )
             except NoSuchKernel:
                 msg = (
@@ -152,6 +154,9 @@ async def patch(self, session_id):
             changes["name"] = model["name"]
         if "type" in model:
             changes["type"] = model["type"]
+        if "custom_kernel_specs" in model:
+            changes["custom_kernel_specs"] = model["custom_kernel_specs"]
+
         if "kernel" in model:
             # Kernel id takes precedence over name.
             if model["kernel"].get("id") is not None:
@@ -160,13 +165,18 @@ async def patch(self, session_id):
                     raise web.HTTPError(400, "No such kernel: %s" % kernel_id)
                 changes["kernel_id"] = kernel_id
             elif model["kernel"].get("name") is not None:
+                if "custom_kernel_specs" in model["kernel"]:
+                    custom_kernel_specs = model["kernel"]["custom_kernel_specs"]
+                else:
+                    custom_kernel_specs = None
                 kernel_name = model["kernel"]["name"]
                 kernel_id = await sm.start_kernel_for_session(
                     session_id,
                     kernel_name=kernel_name,
                     name=before["name"],
                     path=before["path"],
                     type=before["type"],
+                    custom_kernel_specs=custom_kernel_specs,
                 )
                 changes["kernel_id"] = kernel_id
 

jupyter_server/services/sessions/sessionmanager.py

@@ -267,6 +267,7 @@ async def create_session(
         type: Optional[str] = None,
         kernel_name: Optional[KernelName] = None,
         kernel_id: Optional[str] = None,
+        custom_kernel_specs: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         """Creates a session and returns its model
 
@@ -282,8 +283,9 @@ async def create_session(
         if kernel_id is not None and kernel_id in self.kernel_manager:
             pass
         else:
+            #
             kernel_id = await self.start_kernel_for_session(
-                session_id, path, name, type, kernel_name
+                session_id, path, name, type, kernel_name, custom_kernel_specs
             )
         record.kernel_id = kernel_id
         self._pending_sessions.update(record)
@@ -306,6 +308,7 @@ def get_kernel_env(
             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:
             cwd = self.kernel_manager.cwd_for_path(path)
             path = os.path.join(cwd, name)
@@ -319,6 +322,7 @@ async def start_kernel_for_session(
         name: Optional[ModelName],
         type: Optional[str],
         kernel_name: Optional[KernelName],
+        custom_kernel_specs: Optional[Dict[str, Any]] = None,
     ) -> str:
         """Start a new kernel for a given session.
 
@@ -335,6 +339,8 @@ async def start_kernel_for_session(
             the type of the session
         kernel_name : str
             the name of the kernel specification to use.  The default kernel name will be used if not provided.
+        custom_kernel_specs: dict
+            dictionary of kernel custom specifications
         """
         # allow contents manager to specify kernels cwd
         kernel_path = await ensure_async(self.contents_manager.get_kernel_path(path=path))
@@ -344,6 +350,7 @@ async def start_kernel_for_session(
             path=kernel_path,
             kernel_name=kernel_name,
             env=kernel_env,
+            custom_kernel_specs=custom_kernel_specs,
         )
         return cast(str, kernel_id)