Remove nbextensions

e2xgrader/__init__.py

@@ -2,10 +2,6 @@
 A system for creating assignments.
 """
 
-import glob
-import os
-from os.path import join as pjoin
-
 from .server_extensions.student import (
     _load_jupyter_server_extension as load_student_extension,
 )
@@ -37,27 +33,6 @@ def _jupyter_labextension_paths():
     ]
 
 
-def _jupyter_nbextension_paths():
-    root = os.path.dirname(__file__)
-    base_path = pjoin(root, "static", "nbextensions")
-
-    paths = []
-
-    for section in ["notebook", "tree"]:
-        for notebook_extension in glob.glob(pjoin(base_path, section, "*")):
-            name = f"{os.path.split(notebook_extension)[-1]}_{section}"
-            paths.append(
-                dict(
-                    section=section,
-                    src=notebook_extension,
-                    dest=name,
-                    require=pjoin(name, "main"),
-                )
-            )
-
-    return paths
-
-
 def _jupyter_server_extension_paths():
     paths = [
         dict(module="e2xgrader.server_extensions.teacher"),

e2xgrader/extensions/manager.py

@@ -1,12 +1,11 @@
 from .base import BaseExtensionManager
-from .nbextensions import NbExtensionManager
 from .serverextensions import ServerExtensionManager
 
 
 class E2xExtensionManager(BaseExtensionManager):
     def __init__(self):
         super().__init__()
-        self.managers = [NbExtensionManager(), ServerExtensionManager()]
+        self.managers = [ServerExtensionManager()]
 
     def deactivate(self, sys_prefix: bool = True, user: bool = False) -> None:
         for manager in self.managers:

e2xgrader/extensions/utils.py

@@ -1,60 +1,15 @@
 from importlib import import_module
 from types import ModuleType
-from typing import Dict, List, Optional
-
-from .. import _jupyter_nbextension_paths
-
-
-def is_installed(package: str) -> bool:
-    try:
-        import_module(package)
-        return True
-    except ModuleNotFoundError:
-        return False
-
-
-def get_notebook_major_version() -> int:
-    from notebook import __version__
-
-    return int(__version__.split(".")[0])
-
-
-def get_nbextension_utils() -> Optional[ModuleType]:
-    if is_installed("notebook") and get_notebook_major_version() < 7:
-        return import_module("notebook.nbextensions")
-    if is_installed("nbclassic"):
-        return import_module("nbclassic.nbextensions")
-    return None
+from typing import Optional
 
 
 def get_notebook_config_manager() -> Optional[ModuleType]:
-    if is_installed("jupyter_server"):
-        return import_module("jupyter_server.config_manager").BaseJSONConfigManager
-    if is_installed("notebook") and get_notebook_major_version() < 7:
-        return import_module("notebook.services.config.manager").BaseJSONConfigManager
-    return None
-
-
-def discover_nbextensions(mode: str) -> List[Dict[str, str]]:
-    extensions = list()
-    for nbextension in _jupyter_nbextension_paths():
-        if (
-            f"{mode}_notebook" in nbextension["dest"]
-            or f"{mode}_tree" in nbextension["dest"]
-        ):
-            extensions.append(
-                dict(require=nbextension["require"], section=nbextension["section"])
-            )
-    return extensions
+    return import_module("jupyter_server.config_manager").BaseJSONConfigManager
 
 
 def get_serverextension_toggle() -> Optional[ModuleType]:
     def toggle_server_extension_python(**kwargs):
-        if is_installed("notebook") and get_notebook_major_version() < 7:
-            module = import_module("notebook.serverextensions")
-            module.toggle_serverextension_python(**kwargs)
-        if is_installed("jupyter_server"):
-            module = import_module("jupyter_server.extension.serverextension")
-            module.toggle_server_extension_python(**kwargs)
+        module = import_module("jupyter_server.extension.serverextension")
+        module.toggle_server_extension_python(**kwargs)
 
     return toggle_server_extension_python

e2xgrader/utils/mode.py

@@ -1,11 +1,10 @@
-import os
 from enum import Enum
 from typing import Dict
 
 from jupyter_core.paths import jupyter_config_path
 
 from .. import _jupyter_server_extension_paths
-from ..extensions.utils import discover_nbextensions, get_notebook_config_manager
+from ..extensions.utils import get_notebook_config_manager
 
 
 class E2xGraderMode(Enum):
@@ -16,33 +15,6 @@ class E2xGraderMode(Enum):
     INACTIVE = "inactive"
 
 
-def get_nbextension_config() -> Dict[str, Dict[str, bool]]:
-    """
-    Get the configuration for nbextensions.
-
-    Returns:
-        A dictionary containing the configuration for nbextensions.
-        The dictionary has the following structure:
-        {
-            'tree': {
-                'nbextension_name': True/False,
-                ...
-            },
-            'notebook': {
-                'nbextension_name': True/False,
-                ...
-            }
-        }
-    """
-    config = dict(tree=dict(), notebook=dict())
-    for path in jupyter_config_path():
-        config_path = os.path.join(path, "nbconfig")
-        contextmanager = get_notebook_config_manager()(config_dir=config_path)
-        for key in config:
-            config[key].update(contextmanager.get(key))
-    return config
-
-
 def get_serverextension_config() -> Dict[str, bool]:
     """
     Retrieves the server extension configuration from the Jupyter notebook configuration files.
@@ -59,43 +31,6 @@ def get_serverextension_config() -> Dict[str, bool]:
     return config.get("NotebookApp", dict()).get("nbserver_extensions", dict())
 
 
-def infer_nbextension_mode() -> str:
-    """
-    Infer the active mode for the nbextension based on the current configuration.
-
-    Returns:
-        str: The active mode for the nbextension.
-
-    Raises:
-        ValueError: If more than one mode is active or if tree and notebook extensions don't match.
-    """
-    config = get_nbextension_config()
-    modes = [
-        E2xGraderMode.TEACHER.value,
-        E2xGraderMode.STUDENT_EXAM.value,
-        E2xGraderMode.STUDENT.value,
-    ]
-    is_active = dict(tree=[], notebook=[])
-    for mode in modes:
-        for extension in discover_nbextensions(mode):
-            if (
-                config[extension["section"]]
-                .get("load_extensions", dict())
-                .get(extension["require"], False)
-            ):
-                is_active[extension["section"]].append(mode)
-
-    if set(is_active["tree"]) == set(is_active["notebook"]):
-        if len(is_active["tree"]) == 1:
-            return is_active["tree"][0]
-        elif len(is_active["tree"]) == 0:
-            return E2xGraderMode.INACTIVE.value
-    raise ValueError(
-        "More than one mode is active or tree and notebook extensions don't match\n"
-        f"The current config is {config}"
-    )
-
-
 def infer_serverextension_mode() -> str:
     """
     Infer the server extension mode based on the configuration.
@@ -128,14 +63,5 @@ def infer_e2xgrader_mode() -> str:
     Returns:
         str: The mode of e2xgrader.
 
-    Raises:
-        ValueError: If the nbextension mode and serverextension mode do not match.
     """
-    nbextension_mode = infer_nbextension_mode()
-    serverextension_mode = infer_serverextension_mode()
-    if nbextension_mode == serverextension_mode:
-        return nbextension_mode
-    raise ValueError(
-        "The nbextension and serverextension mode does not match"
-        f"nbextension mode is {nbextension_mode}, serverextension_mode is {serverextension_mode}"
-    )
+    return infer_serverextension_mode()