jupyterlab 4.0.12__py3-none-any.whl → 4.1.0__py3-none-any.whl

jupyterlab/_version.py

@@ -6,7 +6,7 @@ from collections import namedtuple
 VersionInfo = namedtuple("VersionInfo", ["major", "minor", "micro", "releaselevel", "serial"])
 
 # DO NOT EDIT THIS DIRECTLY!  It is managed by bumpversion
-version_info = VersionInfo(4, 0, 12, "final", 0)
+version_info = VersionInfo(4, 1, 0, "final", 0)
 
 _specifier_ = {"alpha": "a", "beta": "b", "candidate": "rc", "final": ""}
 

jupyterlab/browser_check.py

@@ -43,7 +43,7 @@ class LogErrorHandler(logging.Handler):
         super().__init__(level=logging.ERROR)
         self.errored = False
 
-    def filter(self, record):  # noqa
+    def filter(self, record):
         # Handle known StreamClosedError from Tornado
         # These occur when we forcibly close Websockets or
         # browser connections during the test.

jupyterlab/commands.py

@@ -18,10 +18,12 @@ import subprocess
 import sys
 import tarfile
 from copy import deepcopy
+from dataclasses import dataclass
 from glob import glob
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from threading import Event
+from typing import FrozenSet, Optional
 from urllib.error import URLError
 from urllib.request import Request, quote, urljoin, urlopen
 
@@ -522,7 +524,7 @@ def get_app_info(app_options=None):
 
 
 def enable_extension(extension, app_options=None, level="sys_prefix"):
-    """Enable a JupyterLab extension.
+    """Enable a JupyterLab extension/plugin.
 
     Returns `True` if a rebuild is recommended, `False` otherwise.
     """
@@ -531,7 +533,7 @@ def enable_extension(extension, app_options=None, level="sys_prefix"):
 
 
 def disable_extension(extension, app_options=None, level="sys_prefix"):
-    """Disable a JupyterLab package.
+    """Disable a JupyterLab extension/plugin.
 
     Returns `True` if a rebuild is recommended, `False` otherwise.
     """
@@ -545,6 +547,18 @@ def check_extension(extension, installed=False, app_options=None):
     return handler.check_extension(extension, installed)
 
 
+def lock_extension(extension, app_options=None, level="sys_prefix"):
+    """Lock a JupyterLab extension/plugin."""
+    handler = _AppHandler(app_options)
+    return handler.toggle_extension_lock(extension, True, level=level)
+
+
+def unlock_extension(extension, app_options=None, level="sys_prefix"):
+    """Unlock a JupyterLab extension/plugin."""
+    handler = _AppHandler(app_options)
+    return handler.toggle_extension_lock(extension, False, level=level)
+
+
 def build_check(app_options=None):
     """Determine whether JupyterLab should be built.
 
@@ -624,6 +638,19 @@ class _AppHandler:
 
         # Do this last since it relies on other attributes
         self.info = self._get_app_info()
+        # Migrate from 4.0 which did not have "locked" status
+        try:
+            self._maybe_mirror_disabled_in_locked(level="sys_prefix")
+        except PermissionError:
+            try:
+                self.logger.info(
+                    "`sys_prefix` level settings are read-only, using `user` level for migration to `lockedExtensions`"
+                )
+                self._maybe_mirror_disabled_in_locked(level="user")
+            except PermissionError:
+                self.logger.warning(
+                    "Both `sys_prefix` and `user` level settings are read-only, cannot auto-migrate `disabledExtensions` to `lockedExtensions`"
+                )
 
     def install_extension(self, extension, existing=None, pin=None):
         """Install an extension package into JupyterLab.
@@ -1100,6 +1127,44 @@ class _AppHandler:
             write_page_config(page_config, level=level)
         return did_something
 
+    def _maybe_mirror_disabled_in_locked(self, level="sys_prefix"):
+        """Lock all extensions that were previously disabled.
+
+        This exists to facilitate migration from 4.0 (which did not include lock
+        function) to 4.1 which exposes the plugin management to users in UI.
+
+        Returns `True` if migration happened, `False` otherwise.
+        """
+        app_settings_dir = osp.join(self.app_dir, "settings")
+
+        page_config = get_static_page_config(
+            app_settings_dir=app_settings_dir, logger=self.logger, level=level
+        )
+        if "lockedExtensions" in page_config:
+            # short-circuit if migration already happened
+            return False
+
+        # copy disabled onto lockedExtensions, ensuring the mapping format
+        disabled = page_config.get("disabledExtensions", {})
+        if isinstance(disabled, list):
+            disabled = {extension: True for extension in disabled}
+        page_config["lockedExtensions"] = disabled
+        write_page_config(page_config, level=level)
+        return True
+
+    def toggle_extension_lock(self, extension, value, level="sys_prefix"):
+        """Lock or unlock a lab extension (/plugin)."""
+        app_settings_dir = osp.join(self.app_dir, "settings")
+
+        page_config = get_static_page_config(
+            app_settings_dir=app_settings_dir, logger=self.logger, level=level
+        )
+
+        locked = page_config.get("lockedExtensions", {})
+        locked[extension] = value
+
+        write_page_config(page_config, level=level)
+
     def check_extension(self, extension, check_installed_only=False):
         """Check if a lab extension is enabled or disabled"""
         self._ensure_disabled_info()
@@ -1206,6 +1271,11 @@ class _AppHandler:
 
         info["disabled"] = disabled
 
+        locked = page_config.get("lockedExtensions", {})
+        if isinstance(locked, list):
+            locked = {extension: True for extension in locked}
+        info["locked"] = locked
+
         disabled_core = []
         for key in info["core_extensions"]:
             if key in info["disabled"]:
@@ -1601,17 +1671,8 @@ class _AppHandler:
             data = info["extensions"][name]
             version = data["version"]
             errors = info["compat_errors"][name]
-            extra = ""
-            if _is_disabled(name, info["disabled"]):
-                extra += " %s" % RED_DISABLED
-            else:
-                extra += " %s" % GREEN_ENABLED
-            if errors:
-                extra += " %s" % RED_X
-            else:
-                extra += " %s" % GREEN_OK
-            if data["is_local"]:
-                extra += "*"
+            extra = self._compose_extra_status(name, info, data, errors)
+
             # If we have the package name in the data, this means this extension's name is the alias name
             alias_package_source = data["alias_package_source"]
             if alias_package_source:
@@ -1648,17 +1709,7 @@ class _AppHandler:
                     continue
                 version = data["version"]
                 errors = info["compat_errors"][name]
-                extra = ""
-                if _is_disabled(name, info["disabled"]):
-                    extra += " %s" % RED_DISABLED
-                else:
-                    extra += " %s" % GREEN_ENABLED
-                if errors:
-                    extra += " %s" % RED_X
-                else:
-                    extra += " %s" % GREEN_OK
-                if data["is_local"]:
-                    extra += "*"
+                extra = self._compose_extra_status(name, info, data, errors)
 
                 install = data.get("install")
                 if install:
@@ -1672,6 +1723,26 @@ class _AppHandler:
         # Write all errors at end:
         _log_multiple_compat_errors(logger, error_accumulator)
 
+    def _compose_extra_status(self, name: str, info: dict, data: dict, errors) -> str:
+        extra = ""
+        if _is_disabled(name, info["disabled"]):
+            extra += " %s" % RED_DISABLED
+        else:
+            extra += " %s" % GREEN_ENABLED
+        if errors:
+            extra += " %s" % RED_X
+        else:
+            extra += " %s" % GREEN_OK
+        if data["is_local"]:
+            extra += "*"
+        lock_status = _is_locked(name, info["locked"])
+        if lock_status.entire_extension_locked:
+            extra += " 🔒 (all plugins locked)"
+        elif lock_status.locked_plugins:
+            plugin_list = ", ".join(sorted(lock_status.locked_plugins))
+            extra += " 🔒 (plugins: %s locked)" % plugin_list
+        return extra
+
     def _read_build_config(self):
         """Get the build config data for the app dir."""
         target = pjoin(self.app_dir, "settings", "build_config.json")
@@ -2285,6 +2356,33 @@ def _is_disabled(name, disabled=None):
     return False
 
 
+@dataclass(frozen=True)
+class LockStatus:
+    entire_extension_locked: bool
+    # locked plugins are only given if extension is not locked as a whole
+    locked_plugins: Optional[FrozenSet[str]] = None
+
+
+def _is_locked(name, locked=None) -> LockStatus:
+    """Test whether the package is locked.
+
+    If only a subset of extension plugins is locked return them.
+    """
+    locked = locked or {}
+    locked_plugins = set()
+    for lock, value in locked.items():
+        # skip packages explicitly marked as not locked
+        if value is False:
+            continue
+        if name == lock:
+            return LockStatus(entire_extension_locked=True)
+        extension_part = lock.partition(":")[0]
+        if name == extension_part:
+            locked_plugins.add(lock)
+
+    return LockStatus(entire_extension_locked=False, locked_plugins=locked_plugins)
+
+
 def _format_compatibility_errors(name, version, errors):
     """Format a message for compatibility errors."""
     msgs = []

jupyterlab/extensions/manager.py

@@ -5,11 +5,13 @@
 
 import json
 import re
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field, fields, replace
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, FrozenSet, List, Optional, Set, Tuple, Union
 
 import tornado
+from jupyterlab_server.translation_utils import translator
+from traitlets import Enum
 from traitlets.config import Configurable, LoggingConfigurable
 
 from jupyterlab.commands import (
@@ -92,7 +94,7 @@ class ExtensionPackage:
     latest_version: str = ""
     status: str = "ok"
     author: Optional[str] = None
-    license: Optional[str] = None  # noqa
+    license: Optional[str] = None
     bug_tracker_url: Optional[str] = None
     documentation_url: Optional[str] = None
     package_manager_url: Optional[str] = None
@@ -116,8 +118,23 @@ class ActionResult:
     needs_restart: List[str] = field(default_factory=list)
 
 
-@dataclass
-class ExtensionManagerOptions:
+@dataclass(frozen=True)
+class PluginManagerOptions:
+    """Plugin manager options.
+
+    Attributes:
+        lock_all: Whether to lock (prevent enabling/disabling) all plugins.
+        lock_rules: A list of plugins or extensions that cannot be toggled.
+            If extension name is provided, all its plugins will be disabled.
+            The plugin names need to follow colon-separated format of `extension:plugin`.
+    """
+
+    lock_rules: FrozenSet[str] = field(default_factory=frozenset)
+    lock_all: bool = False
+
+
+@dataclass(frozen=True)
+class ExtensionManagerOptions(PluginManagerOptions):
     """Extension manager options.
 
     Attributes:
@@ -161,7 +178,126 @@ class ExtensionsCache:
     last_page: int = 1
 
 
-class ExtensionManager(LoggingConfigurable):
+class PluginManager(LoggingConfigurable):
+    """Plugin manager enables or disables plugins unless locked.
+
+    It can also disable/enable all plugins in an extension.
+
+    Args:
+        app_options: Application options
+        ext_options: Plugin manager (subset of extension manager) options
+        parent: Configurable parent
+
+    Attributes:
+        app_options: Application options
+        options: Plugin manager options
+    """
+
+    level = Enum(
+        values=["sys_prefix", "user", "system"],
+        default_value="sys_prefix",
+        help="Level at which to manage plugins: sys_prefix, user, system",
+    ).tag(config=True)
+
+    def __init__(
+        self,
+        app_options: Optional[dict] = None,
+        ext_options: Optional[dict] = None,
+        parent: Optional[Configurable] = None,
+    ) -> None:
+        super().__init__(parent=parent)
+        self.log.debug(
+            "Plugins in %s will managed on the %s level", self.__class__.__name__, self.level
+        )
+        self.app_options = _ensure_options(app_options)
+        plugin_options_field = {f.name for f in fields(PluginManagerOptions)}
+        plugin_options = {
+            option: value
+            for option, value in (ext_options or {}).items()
+            if option in plugin_options_field
+        }
+        self.options = PluginManagerOptions(**plugin_options)
+
+    async def plugin_locks(self) -> dict:
+        """Get information about locks on plugin enabling/disabling"""
+        return {
+            "lockRules": list(self.options.lock_rules),
+            "allLocked": self.options.lock_all,
+        }
+
+    def _find_locked(self, plugins_or_extensions: List[str]) -> FrozenSet[str]:
+        """Find a subset of plugins (or extensions) which are locked"""
+        if self.options.lock_all:
+            return set(plugins_or_extensions)
+        locked_subset = set()
+        extensions_with_locked_plugins = {
+            plugin.split(":")[0] for plugin in self.options.lock_rules
+        }
+        for plugin in plugins_or_extensions:
+            if ":" in plugin:
+                # check directly if this is a plugin identifier (has colon)
+                if plugin in self.options.lock_rules:
+                    locked_subset.add(plugin)
+            elif plugin in extensions_with_locked_plugins:
+                # this is an extension - we need to check for >any< plugin
+                # belonging to said extension
+                locked_subset.add(plugin)
+        return locked_subset
+
+    async def disable(self, plugins: Union[str, List[str]]) -> ActionResult:
+        """Disable a set of plugins (or an extension).
+
+        Args:
+            plugins: The list of plugins to disable
+        Returns:
+            The action result
+        """
+        plugins = plugins if isinstance(plugins, list) else [plugins]
+        locked = self._find_locked(plugins)
+        trans = translator.load("jupyterlab")
+        if locked:
+            return ActionResult(
+                status="error",
+                message=trans.gettext(
+                    "The following plugins cannot be disabled as they are locked: "
+                )
+                + ", ".join(locked),
+            )
+        try:
+            for plugin in plugins:
+                disable_extension(plugin, app_options=self.app_options, level=self.level)
+            return ActionResult(status="ok", needs_restart=["frontend"])
+        except Exception as err:
+            return ActionResult(status="error", message=repr(err))
+
+    async def enable(self, plugins: Union[str, List[str]]) -> ActionResult:
+        """Enable a set of plugins (or an extension).
+
+        Args:
+            plugins: The list of plugins to enable
+        Returns:
+            The action result
+        """
+        plugins = plugins if isinstance(plugins, list) else [plugins]
+        locked = self._find_locked(plugins)
+        trans = translator.load("jupyterlab")
+        if locked:
+            return ActionResult(
+                status="error",
+                message=trans.gettext(
+                    "The following plugins cannot be enabled as they are locked: "
+                )
+                + ", ".join(locked),
+            )
+        try:
+            for plugin in plugins:
+                enable_extension(plugin, app_options=self.app_options, level=self.level)
+            return ActionResult(status="ok", needs_restart=["frontend"])
+        except Exception as err:
+            return ActionResult(status="error", message=repr(err))
+
+
+class ExtensionManager(PluginManager):
     """Base abstract extension manager.
 
     Note:
@@ -195,12 +331,10 @@ class ExtensionManager(LoggingConfigurable):
         ext_options: Optional[dict] = None,
         parent: Optional[Configurable] = None,
     ) -> None:
-        super().__init__(parent=parent)
-        app_options = _ensure_options(app_options)
-        self.log = app_options.logger
-        self.app_dir = Path(app_options.app_dir)
-        self.core_config = app_options.core_config
-        self.app_options = app_options
+        super().__init__(app_options=app_options, ext_options=ext_options, parent=parent)
+        self.log = self.app_options.logger
+        self.app_dir = Path(self.app_options.app_dir)
+        self.core_config = self.app_options.core_config
         self.options = ExtensionManagerOptions(**(ext_options or {}))
         self._extensions_cache: Dict[Optional[str], ExtensionsCache] = {}
         self._listings_cache: Optional[dict] = None
@@ -286,34 +420,6 @@ class ExtensionManager(LoggingConfigurable):
         """
         raise NotImplementedError()
 
-    async def disable(self, extension: str) -> ActionResult:
-        """Disable an extension.
-
-        Args:
-            extension: The extension name
-        Returns:
-            The action result
-        """
-        try:
-            disable_extension(extension, app_options=self.app_options)
-            return ActionResult(status="ok", needs_restart=["frontend"])
-        except Exception as err:
-            return ActionResult(status="error", message=repr(err))
-
-    async def enable(self, extension: str) -> ActionResult:
-        """Enable an extension.
-
-        Args:
-            extension: The extension name
-        Returns:
-            The action result
-        """
-        try:
-            enable_extension(extension, app_options=self.app_options)
-            return ActionResult(status="ok", needs_restart=["frontend"])
-        except Exception as err:
-            return ActionResult(status="error", message=repr(err))
-
     @staticmethod
     def get_semver_version(version: str) -> str:
         """Convert a Python version to Semver version.