rename legacy backend, cleanup tests and comments

Author: andrii-i

conftest.py

@@ -1,16 +1,33 @@
 from pathlib import Path
+from unittest.mock import patch
 
 import pytest
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
 from jupyter_scheduler.orm import Base
 from jupyter_scheduler.scheduler import Scheduler
-from jupyter_scheduler.tests.mocks import MockEnvironmentManager
+from jupyter_scheduler.tests.mocks import MockEnvironmentManager, MockTestBackend
 
 pytest_plugins = ("jupyter_server.pytest_plugin", "pytest_jupyter.jupyter_server")
 
 
+def _mock_discover_backends(*args, **kwargs):
+    """Return test backends for testing - includes high-priority test backend."""
+    from jupyter_scheduler.backends import JupyterServerNotebookBackend
+
+    return {"jupyter_server_nb": JupyterServerNotebookBackend, "test": MockTestBackend}
+
+
+@pytest.fixture(autouse=True)
+def mock_backend_discovery():
+    """Patch backend discovery to include test backend for all tests."""
+    with patch(
+        "jupyter_scheduler.extension.discover_backends", side_effect=_mock_discover_backends
+    ):
+        yield
+
+
 @pytest.fixture(scope="session")
 def static_test_files_dir() -> Path:
     return Path(__file__).parent.resolve() / "jupyter_scheduler" / "tests" / "static"
@@ -51,6 +68,7 @@ def jp_scheduler_db(jp_scheduler_db_url):
     session = Session()
     yield session
     session.close()
+    engine.dispose()
 
 
 @pytest.fixture

jupyter_scheduler/backend_registry.py

@@ -1,10 +1,3 @@
-"""Backend registry for managing multiple backend configurations.
-
-This module provides a registry for managing multiple scheduler backends.
-Each backend is a complete execution environment with its own scheduler,
-execution manager, and optionally database manager.
-"""
-
 import logging
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type
@@ -18,54 +11,22 @@
 
 
 def import_class(class_path: str) -> Type:
-    """Import a class from a fully qualified class path.
-
-    Parameters
-    ----------
-    class_path : str
-        Fully qualified class path (e.g., "jupyter_scheduler.scheduler.Scheduler")
-
-    Returns
-    -------
-    Type
-        The imported class
-    """
+    """Import a class from a fully qualified path like 'module.submodule.ClassName'."""
     module_path, class_name = class_path.rsplit(".", 1)
     module = __import__(module_path, fromlist=[class_name])
     return getattr(module, class_name)
 
 
 @dataclass
 class BackendInstance:
-    """A running instance of a backend with initialized scheduler.
-
-    Attributes
-    ----------
-    config : BackendConfig
-        The configuration used to create this backend
-    scheduler : BaseScheduler
-        The initialized scheduler instance for this backend
-    """
+    """A running backend with its configuration and initialized scheduler."""
 
     config: BackendConfig
     scheduler: BaseScheduler
 
 
 class BackendRegistry:
-    """Registry managing multiple backend configurations.
-
-    This class is responsible for:
-    - Storing and managing multiple backend configurations
-    - Creating and initializing backend instances (schedulers)
-    - Routing requests to the appropriate backend based on ID or file extension
-
-    Parameters
-    ----------
-    configs : List[BackendConfig]
-        List of backend configurations to register
-    default_backend : str
-        The ID of the default backend to use when none is specified
-    """
+    """Registry for storing, initializing, and routing to scheduler backends."""
 
     def __init__(self, configs: List[BackendConfig], default_backend: str):
         self._configs = configs
@@ -80,19 +41,7 @@ def initialize(
         db_url: str,
         config: Optional[Any] = None,
     ):
-        """Instantiate all backends from configs.
-
-        Parameters
-        ----------
-        root_dir : str
-            The Jupyter server root directory
-        environments_manager : EnvironmentManager
-            The environment manager instance to use
-        db_url : str
-            Default database URL (used if backend doesn't specify its own)
-        config : Any, optional
-            Traitlets config object
-        """
+        """Instantiate all backends from configs."""
         for cfg in self._configs:
             try:
                 instance = self._create_backend(cfg, root_dir, environments_manager, db_url, config)
@@ -118,26 +67,7 @@ def _create_backend(
         global_db_url: str,
         config: Optional[Any] = None,
     ) -> BackendInstance:
-        """Create a backend instance from configuration.
-
-        Parameters
-        ----------
-        cfg : BackendConfig
-            The backend configuration
-        root_dir : str
-            The Jupyter server root directory
-        environments_manager : EnvironmentManager
-            The environment manager instance
-        global_db_url : str
-            Default database URL (used if backend doesn't specify its own)
-        config : Any, optional
-            Traitlets config object
-
-        Returns
-        -------
-        BackendInstance
-            The initialized backend instance
-        """
+        """Create a backend instance from configuration."""
         scheduler_class = import_class(cfg.scheduler_class)
 
         # Use backend-specific db_url if provided, otherwise use global
@@ -163,75 +93,30 @@ def _create_backend(
         return BackendInstance(config=cfg, scheduler=scheduler)
 
     def get_backend(self, backend_id: str) -> Optional[BackendInstance]:
-        """Get a backend by its ID.
-
-        Parameters
-        ----------
-        backend_id : str
-            The backend ID to look up
-
-        Returns
-        -------
-        BackendInstance or None
-            The backend instance if found, None otherwise
-        """
+        """Get a backend by ID, or None if not found."""
         return self._backends.get(backend_id)
 
     def get_default(self) -> BackendInstance:
-        """Get the default backend.
-
-        Returns
-        -------
-        BackendInstance
-            The default backend instance
-
-        Raises
-        ------
-        KeyError
-            If the default backend is not found
-        """
+        """Get the default backend."""
         if self._default not in self._backends:
             raise KeyError(f"Default backend '{self._default}' not found in registry")
         return self._backends[self._default]
 
     def get_for_file(self, input_uri: str) -> BackendInstance:
-        """Auto-select backend based on file extension.
-
-        If multiple backends support the file type, returns the one with
-        highest priority. If no backend matches the extension, returns
-        the default backend.
-
-        Parameters
-        ----------
-        input_uri : str
-            The input file URI/path
-
-        Returns
-        -------
-        BackendInstance
-            The selected backend instance
-        """
-        # Extract file extension
+        """Auto-select backend by file extension (highest priority wins), or return default."""
         ext = ""
         if "." in input_uri:
             ext = input_uri.rsplit(".", 1)[-1].lower()
 
         candidates = self._extension_map.get(ext, [])
         if candidates:
-            # Return highest priority backend
             candidate_instances = [self._backends[bid] for bid in candidates]
             return max(candidate_instances, key=lambda b: b.config.priority)
 
         return self.get_default()
 
     def list_backends(self) -> List[DescribeBackend]:
-        """Return list of backends for API/UI.
-
-        Returns
-        -------
-        List[DescribeBackend]
-            List of backend descriptions for frontend consumption
-        """
+        """Return backend descriptions for API/UI consumption."""
         return [
             DescribeBackend(
                 id=b.config.id,
@@ -244,19 +129,11 @@ def list_backends(self) -> List[DescribeBackend]:
         ]
 
     def list_backend_instances(self) -> List[BackendInstance]:
-        """Return list of all backend instances.
-
-        Returns
-        -------
-        List[BackendInstance]
-            List of all backend instances
-        """
+        """Return all backend instances."""
         return list(self._backends.values())
 
     def __len__(self) -> int:
-        """Return the number of registered backends."""
         return len(self._backends)
 
     def __contains__(self, backend_id: str) -> bool:
-        """Check if a backend ID is registered."""
         return backend_id in self._backends

jupyter_scheduler/backend_utils.py

@@ -1,15 +1,3 @@
-"""Backend discovery utilities.
-
-This module provides functions for discovering scheduler backends registered
-via Python entry points. The entry point group "jupyter_scheduler.backends"
-is scanned at startup to find all available backend implementations.
-
-The discovery system supports:
-- Automatic registration of pip-installed backend packages
-- Allow/block lists for filtering available backends
-- Graceful handling of missing dependencies
-"""
-
 import logging
 from importlib.metadata import entry_points
 from typing import Dict, List, Optional, Type
@@ -26,53 +14,16 @@ def discover_backends(
     allowed_backends: Optional[List[str]] = None,
     blocked_backends: Optional[List[str]] = None,
 ) -> Dict[str, Type[BaseBackend]]:
-    """Discover all registered backends via entry points.
-
-    Scans the "jupyter_scheduler.backends" entry point group for registered
-    backend classes. Each entry point should reference a class that inherits
-    from BaseBackend.
-
-    Parameters
-    ----------
-    log : logging.Logger, optional
-        Logger for status messages. If None, uses module logger.
-    allowed_backends : list of str, optional
-        If provided, only backends with IDs in this list are included.
-        Takes precedence over blocked_backends for the same ID.
-    blocked_backends : list of str, optional
-        If provided, backends with IDs in this list are excluded.
-
-    Returns
-    -------
-    dict
-        Mapping of backend_id -> backend class for all discovered backends.
-
-    Notes
-    -----
-    Backends are filtered in this order:
-    1. Entry point is loaded (skip on ImportError with warning)
-    2. Backend ID is checked against blocked_backends (skip if blocked)
-    3. Backend ID is checked against allowed_backends (skip if not allowed)
-
-    Example entry point registration in pyproject.toml:
-
-        [project.entry-points."jupyter_scheduler.backends"]
-        local = "jupyter_scheduler.backends:LocalBackend"
-        k8s = "jupyter_scheduler_k8s:K8sBackend"
-    """
+    """Discover backends registered in the 'jupyter_scheduler.backends' entry point group."""
     if log is None:
         log = logger
 
     backends: Dict[str, Type[BaseBackend]] = {}
 
-    # Get entry points for the backends group
-    # Compatible with Python 3.9+ importlib.metadata
     eps = entry_points()
     if hasattr(eps, "select"):
-        # Python 3.10+ / importlib_metadata style
         backend_eps = eps.select(group=ENTRY_POINT_GROUP)
     else:
-        # Python 3.9 style (returns dict)
         backend_eps = eps.get(ENTRY_POINT_GROUP, [])
 
     for ep in backend_eps:
@@ -118,49 +69,20 @@ def get_default_backend_id(
     available_backends: Dict[str, Type[BaseBackend]],
     configured_default: Optional[str] = None,
 ) -> str:
-    """Determine the default backend ID.
-
-    Selection priority:
-    1. Explicitly configured default (if available)
-    2. "local" backend (if available)
-    3. First available backend (sorted by ID for determinism)
-
-    Parameters
-    ----------
-    available_backends : dict
-        Mapping of backend_id -> backend class from discover_backends().
-    configured_default : str, optional
-        Administrator-configured default backend ID.
-
-    Returns
-    -------
-    str
-        The backend ID to use as default.
-
-    Raises
-    ------
-    ValueError
-        If no backends are available.
-    """
+    """Select default backend: configured > 'jupyter_server_nb' > first alphabetically."""
     if not available_backends:
-        raise ValueError(
-            "No scheduler backends available. " "Ensure at least one backend package is installed."
-        )
+        raise ValueError("No scheduler backends available.")
 
-    # Explicit configuration takes precedence
     if configured_default and configured_default in available_backends:
         return configured_default
 
-    # Warn if configured default is not available
     if configured_default and configured_default not in available_backends:
         logger.warning(
             f"Configured default_backend '{configured_default}' not found. "
-            f"Available backends: {list(available_backends.keys())}"
+            f"Available: {list(available_backends.keys())}"
         )
 
-    # Fall back to "local" if available
-    if "local" in available_backends:
-        return "local"
+    if "jupyter_server_nb" in available_backends:
+        return "jupyter_server_nb"
 
-    # Last resort: first available (sorted for determinism)
     return sorted(available_backends.keys())[0]