jupyterlab 4.2.7__py3-none-any.whl → 4.3.0a0__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, 2, 7, "final", 0)
+version_info = VersionInfo(4, 3, 0, "alpha", 0)
 
 _specifier_ = {"alpha": "a", "beta": "b", "candidate": "rc", "final": ""}
 

jupyterlab/commands.py

@@ -265,7 +265,7 @@ def ensure_app(app_dir):
         return
 
     msgs = [
-        'JupyterLab application assets not found in "%s"' % app_dir,
+        f'JupyterLab application assets not found in "{app_dir}"',
         "Please run `jupyter lab build` or use a different app directory",
     ]
     return msgs
@@ -467,7 +467,7 @@ def clean(app_options=None):
     logger = app_options.logger
     app_dir = app_options.app_dir
 
-    logger.info("Cleaning %s...", app_dir)
+    logger.info(f"Cleaning {app_dir}...")
     if app_dir == pjoin(HERE, "dev"):
         msg = "Cannot clean the dev app"
         raise ValueError(msg)
@@ -476,7 +476,7 @@ def clean(app_options=None):
         raise ValueError(msg)
 
     if getattr(app_options, "all", False):
-        logger.info("Removing everything in %s...", app_dir)
+        logger.info(f"Removing everything in {app_dir}...")
         _rmtree_star(app_dir, logger)
     else:
         possible_targets = ["extensions", "settings", "staging", "static"]
@@ -485,10 +485,10 @@ def clean(app_options=None):
         for name in targets:
             target = pjoin(app_dir, name)
             if osp.exists(target):
-                logger.info("Removing %s...", name)
+                logger.info(f"Removing {name}...")
                 _rmtree(target, logger)
             else:
-                logger.info("%s not present, skipping...", name)
+                logger.info(f"{name} not present, skipping...")
 
     logger.info("Success!")
     if getattr(app_options, "all", False) or getattr(app_options, "extensions", False):
@@ -671,7 +671,7 @@ class _AppHandler:
             config = self._read_build_config()
             uninstalled = config.get("uninstalled_core_extensions", [])
             if extension in uninstalled:
-                self.logger.info("Installing core extension %s" % extension)
+                self.logger.info(f"Installing core extension {extension}")
                 uninstalled.remove(extension)
                 config["uninstalled_core_extensions"] = uninstalled
                 self._write_build_config(config)
@@ -778,8 +778,8 @@ class _AppHandler:
         self._ensure_disabled_info()
         logger = self.logger
         info = self.info
-
-        logger.info("JupyterLab v%s" % info["version"])
+        version = info["version"]
+        logger.info(f"JupyterLab v{version}")
 
         if info["federated_extensions"] or info["extensions"]:
             info["compat_errors"] = self._get_extension_compat()
@@ -808,7 +808,7 @@ class _AppHandler:
         uninstalled_core = info["uninstalled_core"]
         if uninstalled_core:
             logger.info("\nUninstalled core extensions:")
-            [logger.info("    %s" % item) for item in sorted(uninstalled_core)]
+            [logger.info(f"    {item}") for item in sorted(uninstalled_core)]
 
         all_exts = (
             list(info["federated_extensions"])
@@ -823,7 +823,7 @@ class _AppHandler:
                 # Show that all plugins will be disabled if the whole extension matches
                 if item in all_exts:
                     item += " (all plugins)"  # noqa PLW2901
-                logger.info("    %s" % item)
+                logger.info(f"    {item}")
 
         # Here check if modules are improperly shadowed
         improper_shadowed = []
@@ -837,12 +837,12 @@ class _AppHandler:
             logger.info(
                 "\nThe following source extensions are overshadowed by older prebuilt extensions:"
             )
-            [logger.info("    %s" % name) for name in sorted(improper_shadowed)]
+            [logger.info(f"    {name}") for name in sorted(improper_shadowed)]
 
         messages = self.build_check(fast=True)
         if messages:
             logger.info("\nBuild recommended, please run `jupyter lab build`:")
-            [logger.info("    %s" % item) for item in messages]
+            [logger.info(f"    {item}") for item in messages]
 
     def build_check(self, fast=None):  # noqa
         """Determine whether JupyterLab should be built.
@@ -870,8 +870,8 @@ class _AppHandler:
         if not static_version.endswith("-spliced"):
             core_version = old_jlab["version"]
             if Version(static_version) != Version(core_version):
-                msg = "Version mismatch: %s (built), %s (current)"
-                return [msg % (static_version, core_version)]
+                msg = f"Version mismatch: {static_version} (built), {core_version} (current)"
+                return [msg]
 
         shadowed_exts = self.info["shadowed_exts"]
 
@@ -886,14 +886,14 @@ class _AppHandler:
                 if ext in shadowed_exts:
                     continue
                 if ext not in old_jlab[ext_type]:
-                    messages.append("%s needs to be included in build" % ext)
+                    messages.append(f"{ext} needs to be included in build")
 
             # Extensions that were removed.
             for ext in old_jlab[ext_type]:
                 if ext in shadowed_exts:
                     continue
                 if ext not in new_jlab[ext_type]:
-                    messages.append("%s needs to be removed from build" % ext)
+                    messages.append(f"{ext} needs to be removed from build")
 
         # Look for mismatched dependencies
         src_pkg_dir = pjoin(REPO_ROOT, "packages")
@@ -906,8 +906,8 @@ class _AppHandler:
             if pkg in local or pkg in linked:
                 continue
             if old_deps[pkg] != dep:
-                msg = "%s changed from %s to %s"
-                messages.append(msg % (pkg, old_deps[pkg], new_deps[pkg]))
+                msg = f"{pkg} changed from {old_deps[pkg]} to {new_deps[pkg]}"
+                messages.append(msg)
 
         # Look for updated local extensions.
         for name, source in local.items():
@@ -915,7 +915,7 @@ class _AppHandler:
                 continue
             dname = pjoin(app_dir, "extensions")
             if self._check_local(name, source, dname):
-                messages.append("%s content changed" % name)
+                messages.append(f"{name} content changed")
 
         # Look for updated linked packages.
         for name, item in linked.items():
@@ -923,7 +923,7 @@ class _AppHandler:
                 continue
             dname = pjoin(app_dir, "staging", "linked_packages")
             if self._check_local(name, item["source"], dname):
-                messages.append("%s content changed" % name)
+                messages.append(f"{name} content changed")
 
         return messages
 
@@ -941,14 +941,13 @@ class _AppHandler:
                 .get("install", {})
                 .get("uninstallInstructions", None)
             ):
-                logger.error(
-                    "JupyterLab cannot uninstall this extension. %s"
-                    % info["federated_extensions"][name]["install"]["uninstallInstructions"]
-                )
+                instructions = info["federated_extensions"][name]["install"][
+                    "uninstallInstructions"
+                ]
+                logger.error(f"JupyterLab cannot uninstall this extension. {instructions}")
             else:
                 logger.error(
-                    "JupyterLab cannot uninstall %s since it was installed outside of JupyterLab. Use the same method used to install this extension to uninstall this extension."
-                    % name
+                    f"JupyterLab cannot uninstall {name} since it was installed outside of JupyterLab. Use the same method used to install this extension to uninstall this extension."
                 )
             return False
 
@@ -957,7 +956,7 @@ class _AppHandler:
             config = self._read_build_config()
             uninstalled = config.get("uninstalled_core_extensions", [])
             if name not in uninstalled:
-                logger.info("Uninstalling core extension %s" % name)
+                logger.info(f"Uninstalling core extension {name}")
                 uninstalled.append(name)
                 config["uninstalled_core_extensions"] = uninstalled
                 self._write_build_config(config)
@@ -980,7 +979,7 @@ class _AppHandler:
                     self._write_build_config(config)
                 return True
 
-        logger.warning('No labextension named "%s" installed' % name)
+        logger.warning(f'No labextension named "{name}" installed')
         return False
 
     def uninstall_all_extensions(self):
@@ -1014,7 +1013,7 @@ class _AppHandler:
         Returns `True` if a rebuild is recommended, `False` otherwise.
         """
         if name not in self.info["extensions"]:
-            self.logger.warning('No labextension named "%s" installed' % name)
+            self.logger.warning(f'No labextension named "{name}" installed')
             return False
         return self._update_extension(name)
 
@@ -1025,7 +1024,7 @@ class _AppHandler:
         """
         data = self.info["extensions"][name]
         if data["alias_package_source"]:
-            self.logger.warning("Skipping updating pinned extension '%s'." % name)
+            self.logger.warning(f"Skipping updating pinned extension '{name}'.")
             return False
         try:
             latest = self._latest_compatible_package_version(name)
@@ -1035,7 +1034,7 @@ class _AppHandler:
             self.logger.warning(f"No compatible version found for {name}!")
             return False
         if latest == data["version"]:
-            self.logger.info("Extension %r already up to date" % name)
+            self.logger.info(f"Extension {name!r} already up to date")
             return False
         self.logger.info(f"Updating {name} to version {latest}")
         return self.install_extension(f"{name}@{latest}")
@@ -1047,8 +1046,8 @@ class _AppHandler:
         """
         path = _normalize_path(path)
         if not osp.exists(path) or not osp.isdir(path):
-            msg = 'Cannot install "%s" only link local directories'
-            raise ValueError(msg % path)
+            msg = f'Cannot install "{path}" only link local directories'
+            raise ValueError(msg)
 
         with TemporaryDirectory() as tempdir:
             info = self._extract_package(path, tempdir)
@@ -1059,9 +1058,9 @@ class _AppHandler:
 
         # Warn that it is a linked package.
         self.logger.warning(
-            "Installing %s as a linked package because it does not have extension metadata:", path
+            f"Installing {path} as a linked package because it does not have extension metadata:"
         )
-        [self.logger.warning("   %s" % m) for m in messages]
+        [self.logger.warning(f"   {m}") for m in messages]
 
         # Add to metadata.
         config = self._read_build_config()
@@ -1100,7 +1099,8 @@ class _AppHandler:
                 os.remove(path)
 
         if not found:
-            raise ValueError("No linked package for %s" % path)
+            msg = f"No linked package for {path}"
+            raise ValueError(msg)
 
         self._write_build_config(config)
         return True
@@ -1331,7 +1331,7 @@ class _AppHandler:
         app_dir = self.app_dir
         staging = pjoin(app_dir, "staging")
         if clean and osp.exists(staging):
-            self.logger.info("Cleaning %s", staging)
+            self.logger.info(f"Cleaning {staging}")
             _rmtree(staging, self.logger)
 
         self._ensure_app_dirs()
@@ -1668,7 +1668,7 @@ class _AppHandler:
             data = read_package(path)
             name = data["name"]
             if name not in info:
-                self.logger.warning("Removing orphaned linked package %s" % name)
+                self.logger.warning(f"Removing orphaned linked package {name}")
                 os.remove(path)
                 continue
             item = info[name]
@@ -1699,11 +1699,11 @@ class _AppHandler:
         """List the extensions of a given type."""
         self._ensure_disabled_info()
         logger = self.logger
-        names = info["%s_extensions" % ext_type]
+        names = info[f"{ext_type}_extensions"]
         if not names:
             return
 
-        dname = info["%s_dir" % ext_type]
+        dname = info[f"{ext_type}_dir"]
 
         error_accumulator = {}
 
@@ -1769,13 +1769,13 @@ class _AppHandler:
     def _compose_extra_status(self, name: str, info: dict, data: dict, errors) -> str:
         extra = ""
         if _is_disabled(name, info["disabled"]):
-            extra += " %s" % RED_DISABLED
+            extra += f" {RED_DISABLED}"
         else:
-            extra += " %s" % GREEN_ENABLED
+            extra += f" {GREEN_ENABLED}"
         if errors:
-            extra += " %s" % RED_X
+            extra += f" {RED_X}"
         else:
-            extra += " %s" % GREEN_OK
+            extra += f" {GREEN_OK}"
         if data["is_local"]:
             extra += "*"
         lock_status = _is_locked(name, info["locked"])
@@ -1783,7 +1783,7 @@ class _AppHandler:
             extra += " 🔒 (all plugins locked)"
         elif lock_status.locked_plugins:
             plugin_list = ", ".join(sorted(lock_status.locked_plugins))
-            extra += " 🔒 (plugins: %s locked)" % plugin_list
+            extra += f" 🔒 (plugins: {plugin_list} locked)"
         return extra
 
     def _read_build_config(self):
@@ -1838,8 +1838,8 @@ class _AppHandler:
         # Verify that the package is an extension.
         messages = _validate_extension(data)
         if messages:
-            msg = '"%s" is not a valid extension:\n%s'
-            msg = msg % (extension, "\n".join(messages))
+            all_messages = "\n".join(messages)
+            msg = f'"{extension}" is not a valid extension:\n{all_messages}'
             if allow_fallback:
                 try:
                     version = self._latest_compatible_package_version(name)
@@ -1861,8 +1861,8 @@ class _AppHandler:
                     raise ValueError(msg) from None
 
                 if version and name:
-                    self.logger.debug("Incompatible extension:\n%s", name)
-                    self.logger.debug("Found compatible version: %s", version)
+                    self.logger.debug(f"Incompatible extension:\n{name}")
+                    self.logger.debug(f"Found compatible version: {version}")
                     with TemporaryDirectory() as tempdir2:
                         return self._install_extension(f"{name}@{version}", tempdir2)
 
@@ -1897,14 +1897,14 @@ class _AppHandler:
 
         ret = self._run([which("npm"), "pack", source], cwd=tempdir)
         if ret != 0:
-            msg = '"%s" is not a valid npm package'
-            raise ValueError(msg % source)
+            msg = f'"{source}" is not a valid npm package'
+            raise ValueError(msg)
 
         path = glob(pjoin(tempdir, "*.tgz"))[0]
         info["data"] = read_package(path)
         if is_dir:
             info["sha"] = sha = _tarsum(path)
-            target = path.replace(".tgz", "-%s.tgz" % sha)
+            target = path.replace(".tgz", f"-{sha}.tgz")
             shutil.move(path, target)
             info["path"] = target
         else:
@@ -1992,8 +1992,8 @@ class _AppHandler:
         with TemporaryDirectory() as tempdir:
             ret = self._run([which("npm"), "pack", *keys], cwd=tempdir)
             if ret != 0:
-                msg = '"%s" is not a valid npm package'
-                raise ValueError(msg % keys)
+                msg = f'"{keys}" is not a valid npm package'
+                raise ValueError(msg)
 
             for key in keys:
                 fname = (
@@ -2043,12 +2043,12 @@ class _AppHandler:
             # All singleton deps in current version of lab are newer than those
             # in the latest version of the extension
             return (
-                'The extension "%s" does not yet support the current version of '
-                "JupyterLab.\n" % name
+                f'The extension "{name}" does not yet support the current version of '
+                "JupyterLab.\n"
             )
 
         parts = [
-            "No version of {extension} could be found that is compatible with "
+            f"No version of {name} could be found that is compatible with "
             "the current version of JupyterLab."
         ]
         if latest_newer_than_lab:
@@ -2059,7 +2059,7 @@ class _AppHandler:
                 )
             )
 
-        return " ".join(parts).format(extension=name)
+        return " ".join(parts)
 
     def _run(self, cmd, **kwargs):
         """Run the command using our logger and abort callback.
@@ -2085,10 +2085,7 @@ def _node_check(logger):
     except Exception:
         data = CoreConfig()._data
         ver = data["engines"]["node"]
-        msg = (
-            "Please install nodejs %s before continuing. nodejs may be installed using conda or directly from the nodejs website."
-            % ver
-        )
+        msg = f"Please install nodejs {ver} before continuing. nodejs may be installed using conda or directly from the nodejs website."
         raise ValueError(msg) from None
 
 
@@ -2216,16 +2213,16 @@ def _validate_extension(data):  # noqa
         mime_extension += ".js"
 
     if extension and extension not in files:
-        messages.append('Missing extension module "%s"' % extension)
+        messages.append(f'Missing extension module "{extension}"')
 
     if mime_extension and mime_extension not in files:
-        messages.append('Missing mimeExtension module "%s"' % mime_extension)
+        messages.append(f'Missing mimeExtension module "{mime_extension}"')
 
     if theme_path and not any(f.startswith(str(Path(theme_path))) for f in files):
-        messages.append('themePath is empty: "%s"' % theme_path)
+        messages.append(f'themePath is empty: "{theme_path}"')
 
     if schema_dir and not any(f.startswith(str(Path(schema_dir))) for f in files):
-        messages.append('schemaDir is empty: "%s"' % schema_dir)
+        messages.append(f'schemaDir is empty: "{schema_dir}"')
 
     return messages
 
@@ -2439,8 +2436,7 @@ def _format_compatibility_errors(name, version, errors):
         l0 = max(l0, len(pkg) + 1)
         l1 = max(l1, len(jlab) + 1)
 
-    msg = '\n"%s@%s" is not compatible with the current JupyterLab'
-    msg = msg % (name, version)
+    msg = f'\n"{name}@{version}" is not compatible with the current JupyterLab'
     msg += "\nConflicting Dependencies:\n"
     msg += "JupyterLab".ljust(l0)
     msg += "Extension".ljust(l1)
@@ -2492,7 +2488,7 @@ def _log_single_compat_errors(logger, name, version, errors):
 
     age = _compat_error_age(errors)
     if age > 0:
-        logger.warning('The extension "%s" is outdated.\n', name)
+        logger.warning(f'The extension "{name}" is outdated.\n')
     else:
         msg = _format_compatibility_errors(name, version, errors)
         logger.warning(f"{msg}\n")
@@ -2588,14 +2584,14 @@ def _fetch_package_metadata(registry, name, logger):
         },
     )
     try:
-        logger.debug("Fetching URL: %s" % (req.full_url))
+        logger.debug(f"Fetching URL: {req.full_url}")
     except AttributeError:
-        logger.debug("Fetching URL: %s" % (req.get_full_url()))
+        logger.debug(f"Fetching URL: {req.get_full_url()}")
     try:
         with contextlib.closing(urlopen(req)) as response:  # noqa S310
             return json.loads(response.read().decode("utf-8"))
     except URLError as exc:
-        logger.warning("Failed to fetch package metadata for %r: %r", name, exc)
+        logger.warning(f"Failed to fetch package metadata for {name!r}: {exc!r}")
         raise
 
 

jupyterlab/extensions/manager.py

@@ -207,7 +207,7 @@ class PluginManager(LoggingConfigurable):
     ) -> None:
         super().__init__(parent=parent)
         self.log.debug(
-            "Plugins in %s will managed on the %s level", self.__class__.__name__, self.level
+            f"Plugins in {self.__class__.__name__} will managed on the {self.level} level"
         )
         self.app_options = _ensure_options(app_options)
         plugin_options_field = {f.name for f in fields(PluginManagerOptions)}

jupyterlab/extensions/pypi.py

@@ -26,7 +26,6 @@ from zipfile import ZipFile
 import httpx
 import tornado
 from async_lru import alru_cache
-from packaging.version import Version
 from traitlets import CFloat, CInt, Unicode, config, observe
 
 from jupyterlab._version import __version__
@@ -50,6 +49,8 @@ class ProxiedTransport(xmlrpc.client.Transport):
         return connection
 
 
+xmlrpc_transport_override = None
+
 all_proxy_url = environ.get("ALL_PROXY")
 # For historical reasons, we also support the lowercase environment variables.
 # Info: https://about.gitlab.com/blog/2021/01/27/we-need-to-talk-no-proxy/
@@ -57,31 +58,16 @@ http_proxy_url = environ.get("http_proxy") or environ.get("HTTP_PROXY") or all_p
 https_proxy_url = (
     environ.get("https_proxy") or environ.get("HTTPS_PROXY") or http_proxy_url or all_proxy_url
 )
-
-# sniff ``httpx`` version for version-sensitive API
-_httpx_version = Version(httpx.__version__)
-_httpx_client_args = {}
-
-xmlrpc_transport_override = None
+proxies = None
 
 if http_proxy_url:
     http_proxy = urlparse(http_proxy_url)
     proxy_host, _, proxy_port = http_proxy.netloc.partition(":")
 
-    if _httpx_version >= Version("0.28.0"):
-        _httpx_client_args = {
-            "mounts": {
-                "http://": httpx.AsyncHTTPTransport(proxy=http_proxy_url),
-                "https://": httpx.AsyncHTTPTransport(proxy=https_proxy_url),
-            }
-        }
-    else:
-        _httpx_client_args = {
-            "proxies": {
-                "http://": http_proxy_url,
-                "https://": https_proxy_url,
-            }
-        }
+    proxies = {
+        "http://": http_proxy_url,
+        "https://": https_proxy_url,
+    }
 
     xmlrpc_transport_override = ProxiedTransport()
     xmlrpc_transport_override.set_proxy(proxy_host, proxy_port)
@@ -145,7 +131,7 @@ class PyPIExtensionManager(ExtensionManager):
         parent: Optional[config.Configurable] = None,
     ) -> None:
         super().__init__(app_options, ext_options, parent)
-        self._httpx_client = httpx.AsyncClient(**_httpx_client_args)
+        self._httpx_client = httpx.AsyncClient(proxies=proxies)
         # Set configurable cache size to fetch function
         self._fetch_package_metadata = partial(_fetch_package_metadata, self._httpx_client)
         self._observe_package_metadata_cache_size({"new": self.package_metadata_cache_size})

jupyterlab/federated_labextensions.py

@@ -102,7 +102,7 @@ def develop_labextension(  # noqa
     full_dest = normpath(pjoin(labext, destination))
     if overwrite and os.path.lexists(full_dest):
         if logger:
-            logger.info("Removing: %s" % full_dest)
+            logger.info(f"Removing: {full_dest}")
         if os.path.isdir(full_dest) and not os.path.islink(full_dest):
             shutil.rmtree(full_dest)
         else:
@@ -129,7 +129,8 @@ def develop_labextension(  # noqa
                 raise
 
         elif not os.path.islink(full_dest):
-            raise ValueError("%s exists and is not a symlink" % full_dest)
+            msg = f"{full_dest} exists and is not a symlink"
+            raise ValueError(msg)
 
     elif os.path.isdir(path):
         path = pjoin(os.path.abspath(path), "")  # end in path separator
@@ -137,7 +138,7 @@ def develop_labextension(  # noqa
             dest_dir = pjoin(full_dest, parent[len(path) :])
             if not os.path.exists(dest_dir):
                 if logger:
-                    logger.info("Making directory: %s" % dest_dir)
+                    logger.info(f"Making directory: {dest_dir}")
                 os.makedirs(dest_dir)
             for file_name in files:
                 src = pjoin(parent, file_name)
@@ -202,7 +203,7 @@ def build_labextension(
     ext_path = str(Path(path).resolve())
 
     if logger:
-        logger.info("Building extension in %s" % path)
+        logger.info(f"Building extension in {path}")
 
     builder = _ensure_builder(ext_path, core_path)
 
@@ -225,7 +226,7 @@ def watch_labextension(
     ext_path = str(Path(path).resolve())
 
     if logger:
-        logger.info("Building extension in %s" % path)
+        logger.info(f"Building extension in {path}")
 
     # Check to see if we need to create a symlink
     federated_extensions = get_federated_extensions(labextensions_path)
@@ -268,9 +269,8 @@ def _ensure_builder(ext_path, core_path):
     dep_version2 = ext_data.get("devDependencies", {}).get("@jupyterlab/builder")
     dep_version2 = dep_version2 or ext_data.get("dependencies", {}).get("@jupyterlab/builder")
     if dep_version2 is None:
-        raise ValueError(
-            "Extensions require a devDependency on @jupyterlab/builder@%s" % dep_version1
-        )
+        msg = f"Extensions require a devDependency on @jupyterlab/builder@{dep_version1}"
+        raise ValueError(msg)
 
     # if we have installed from disk (version is a path), assume we know what
     # we are doing and do not check versions.
@@ -331,10 +331,10 @@ def _should_copy(src, dest, logger=None):
         # we add a fudge factor to work around a bug in python 2.x
         # that was fixed in python 3.x: https://bugs.python.org/issue12904
         if logger:
-            logger.warning("Out of date: %s" % dest)
+            logger.warning(f"Out of date: {dest}")
         return True
     if logger:
-        logger.info("Up to date: %s" % dest)
+        logger.info(f"Up to date: {dest}")
     return False