Verified python labextension install, enable, disable

jupyterlab/__init__.py

@@ -39,7 +39,7 @@ with open(os.path.join(HERE, '..', 'package.json')) as f:
 __version__ = packagejson['version']
 
 
-def get_lab_extension_manifest_data_by_folder(folder):
+def get_labextension_manifest_data_by_folder(folder):
     """Get the manifest data for a given lab extension folder
     """
     manifest_files = glob.glob(os.path.join(folder, '*.manifest'))
@@ -51,14 +51,14 @@ def get_lab_extension_manifest_data_by_folder(folder):
     return manifests
 
 
-def get_lab_extension_manifest_data_by_name(name):
+def get_labextension_manifest_data_by_name(name):
     """Get the manifest data for a given lab extension folder
     """
-    from .labextensions import _lab_extension_dirs
-    for exts in _lab_extension_dirs():
+    from .labextensions import _labextension_dirs
+    for exts in _labextension_dirs():
         full_dest = os.path.join(exts, name)
         if os.path.exists(full_dest):
-            return get_lab_extension_manifest_data_by_folder(full_dest)
+            return get_labextension_manifest_data_by_folder(full_dest)
 
 
 class LabHandler(IPythonHandler):
@@ -67,9 +67,9 @@ class LabHandler(IPythonHandler):
     @web.authenticated
     def get(self):
         static_prefix = ujoin(self.application.settings['base_url'], PREFIX)
-        lab_extensions = self.application.lab_extensions
+        labextensions = self.application.labextensions
 
-        data = get_lab_extension_manifest_data_by_folder(BUILT_FILES)
+        data = get_labextension_manifest_data_by_folder(BUILT_FILES)
         css_files = [ujoin(static_prefix, 'main.css'),
                      ujoin(static_prefix, 'extensions.css')]
         main = data['main']['entry']
@@ -78,20 +78,19 @@ class LabHandler(IPythonHandler):
         entries = [data['extensions']['entry']]
 
         # Gather the lab extension files and entry points.
-        for name in lab_extensions:
-            if lab_extensions[name]:
-                data = get_lab_extension_manifest_data_by_name(name)
-                for value in data.values():
-                    if value.get('entry', None):
-                        entries.append(value['entry'])
-                        bundles.append('%s/%s/%s' % (
-                            EXTENSION_PREFIX, name, value['files'][0]
+        for name in labextensions:
+            data = get_labextension_manifest_data_by_name(name)
+            for value in data.values():
+                if value.get('entry', None):
+                    entries.append(value['entry'])
+                    bundles.append('%s/%s/%s' % (
+                        EXTENSION_PREFIX, name, value['files'][0]
+                    ))
+                for fname in value['files']:
+                    if os.path.splitext(fname)[1] == '.css':
+                        css_files.append('%s/%s/%s' % (
+                            EXTENSION_PREFIX, name, fname
                         ))
-                    for fname in value['files']:
-                        if os.path.splitext(fname)[1] == '.css':
-                            css_files.append('%s/%s/%s' % (
-                                EXTENSION_PREFIX, name, fname
-                            ))
 
         self.write(self.render_template('lab.html',
             static_prefix=static_prefix,
@@ -136,10 +135,10 @@ def load_jupyter_server_extension(nbapp):
     base_url = webapp.settings['base_url']
     webapp.add_handlers(".*$",
         [(ujoin(base_url, h[0]),) + h[1:] for h in default_handlers])
-    lab_extension_handler = (
+    labextension_handler = (
         r"%s/(.*)" % EXTENSION_PREFIX, FileFindHandler, {
-            'path': nbapp.lab_extensions_path,
+            'path': nbapp.labextensions_path,
             'no_cache_paths': ['/'],  # don't cache anything in labbextensions
         }
     )
-    webapp.add_handlers(".*$", [lab_extension_handler])
+    webapp.add_handlers(".*$", [labextension_handler])

jupyterlab/labapp.py

@@ -5,9 +5,11 @@
 # Distributed under the terms of the Modified BSD License.
 
 # TODO: import base server app
-from jupyter_core.paths import jupyter_path
+import os
+from jupyter_core.paths import jupyter_config_path, jupyter_path
 from notebook.notebookapp import NotebookApp
-from traitlets import Dict, List, Unicode
+from traitlets import List, Unicode
+from traitlets.config.manager import BaseJSONConfigManager
 
 
 class LabApp(NotebookApp):
@@ -16,24 +18,35 @@ class LabApp(NotebookApp):
         help="The default URL to redirect to from `/`"
     )
 
-    extra_lab_extensions_path = List(Unicode(), config=True,
+    extra_labextensions_path = List(Unicode(), config=True,
         help="""extra paths to look for JupyterLab extensions"""
     )
 
-    lab_extensions = Dict({}, config=True,
-        help=("Dict of Python modules to load as notebook server extensions."
-              "Entry values can be used to enable and disable the loading of"
-              "the extensions.")
-    )
+    @property
+    def labextensions(self):
+        extensions = []
+        config_dirs = [os.path.join(p, 'labconfig') for p in 
+                       jupyter_config_path()]
+        for config_dir in config_dirs:
+            cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
+            data = cm.get("jupyterlab_config")
+            labextensions = (
+                data.setdefault("LabApp", {})
+                .setdefault("labextensions", {})
+            )
+            for name, enabled in labextensions.items():
+                if enabled:
+                    extensions.append(name)
+        return extensions
 
     @property
-    def lab_extensions_path(self):
+    def labextensions_path(self):
         """The path to look for JupyterLab extensions"""
-        return self.extra_lab_extensions_path + jupyter_path('lab_extensions')
+        return self.extra_labextensions_path + jupyter_path('labextensions')
 
     def init_webapp(self):
         super(LabApp, self).init_webapp()
-        self.web_app.lab_extensions = self.lab_extensions
+        self.web_app.labextensions = self.labextensions
 
 #-----------------------------------------------------------------------------
 # Main entry point

jupyterlab/labextensions.py

@@ -37,8 +37,8 @@ from traitlets.utils.importstring import import_item
 from tornado.log import LogFormatter
 
 from . import (
-    get_lab_extension_manifest_data_by_folder,
-    get_lab_extension_manifest_data_by_name
+    get_labextension_manifest_data_by_folder,
+    get_labextension_manifest_data_by_name
 )
 
 # Constants for pretty print extension listing function.
@@ -58,70 +58,70 @@ class ArgumentConflict(ValueError):
     pass
 
 
-def check_lab_extension(files, user=False, prefix=None, lab_extensions_dir=None, sys_prefix=False):
-    """Check whether lab_extension files have been installed
+def check_labextension(files, user=False, prefix=None, labextensions_dir=None, sys_prefix=False):
+    """Check whether labextension files have been installed
     
     Returns True if all files are found, False if any are missing.
 
     Parameters
     ----------
     files : list(paths)
-        a list of relative paths within lab_extensions.
+        a list of relative paths within labextensions.
     user : bool [default: False]
-        Whether to check the user's .jupyter/lab_extensions directory.
-        Otherwise check a system-wide install (e.g. /usr/local/share/jupyter/lab_extensions).
+        Whether to check the user's .jupyter/labextensions directory.
+        Otherwise check a system-wide install (e.g. /usr/local/share/jupyter/labextensions).
     prefix : str [optional]
         Specify install prefix, if it should differ from default (e.g. /usr/local).
-        Will check prefix/share/jupyter/lab_extensions
-    lab_extensions_dir : str [optional]
-        Specify absolute path of lab_extensions directory explicitly.
+        Will check prefix/share/jupyter/labextensions
+    labextensions_dir : str [optional]
+        Specify absolute path of labextensions directory explicitly.
     sys_prefix : bool [default: False]
         Install into the sys.prefix, i.e. environment
     """
-    lab_ext = _get_lab_extension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, lab_extensions_dir=lab_extensions_dir)
-    # make sure lab_extensions dir exists
-    if not os.path.exists(lab_ext):
+    labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir)
+    # make sure labextensions dir exists
+    if not os.path.exists(labext):
         return False
     
     if isinstance(files, string_types):
         # one file given, turn it into a list
         files = [files]
     
-    return all(os.path.exists(pjoin(lab_ext, f)) for f in files)
+    return all(os.path.exists(pjoin(labext, f)) for f in files)
 
 
-def install_lab_extension(path, name, overwrite=False, symlink=False,
-                        user=False, prefix=None, lab_extensions_dir=None,
+def install_labextension(path, name, overwrite=False, symlink=False,
+                        user=False, prefix=None, labextensions_dir=None,
                         logger=None, sys_prefix=False
                         ):
     """Install a Javascript extension for JupyterLab
     
-    Stages files and/or directories into the lab_extensions directory.
+    Stages files and/or directories into the labextensions directory.
     By default, this compares modification time, and only stages files that need updating.
     If `overwrite` is specified, matching files are purged before proceeding.
     
     Parameters
     ----------
     path : path to file, directory, zip or tarball archive, or URL to install
-        Archives (zip or tarballs) will be extracted into the lab_extensions directory.
+        Archives (zip or tarballs) will be extracted into the labextensions directory.
     name : str [optional]
-        name the lab_extension is installed to.  For example, if name is 'foo', then
-        the source file will be installed to 'lab_extensions/foo'.
+        name the labextension is installed to.  For example, if name is 'foo', then
+        the source file will be installed to 'labextensions/foo'.
     overwrite : bool [default: False]
         If True, always install the files, regardless of what may already be installed.
     symlink : bool [default: False]
-        If True, create a symlink in lab_extensions, rather than copying files.
+        If True, create a symlink in labextensions, rather than copying files.
         Not allowed with URLs or archives. Windows support for symlinks requires
         Vista or above, Python 3, and a permission bit which only admin users
         have by default, so don't rely on it.
     user : bool [default: False]
-        Whether to install to the user's lab_extensions directory.
-        Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/lab_extensions).
+        Whether to install to the user's labextensions directory.
+        Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/labextensions).
     prefix : str [optional]
         Specify install prefix, if it should differ from default (e.g. /usr/local).
-        Will install to ``<prefix>/share/jupyter/lab_extensions``
-    lab_extensions_dir : str [optional]
-        Specify absolute path of lab_extensions directory explicitly.
+        Will install to ``<prefix>/share/jupyter/labextensions``
+    labextensions_dir : str [optional]
+        Specify absolute path of labextensions directory explicitly.
     logger : Jupyter logger [optional]
         Logger instance to use
     """
@@ -129,9 +129,9 @@ def install_lab_extension(path, name, overwrite=False, symlink=False,
     # the actual path to which we eventually installed
     full_dest = None
 
-    lab_ext = _get_lab_extension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, lab_extensions_dir=lab_extensions_dir)
-    # make sure lab_extensions dir exists
-    ensure_dir_exists(lab_ext)
+    labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir)
+    # make sure labextensions dir exists
+    ensure_dir_exists(labext)
     
     # forcing symlink parameter to False if os.symlink does not exist (e.g., on Windows machines running python 2)
     if not hasattr(os, 'symlink'):
@@ -143,12 +143,12 @@ def install_lab_extension(path, name, overwrite=False, symlink=False,
     path = cast_unicode_py2(path)
 
     if path.startswith(('https://', 'http://')):
-        raise NotImplementedError('Urls are not yet supported for lab_extensions')
+        raise NotImplementedError('Urls are not yet supported for labextensions')
     elif path.endswith('.zip') or _safe_is_tarfile(path):
-        raise NotImplementedError('Archive files are not yet supported for lab_extensions')
+        raise NotImplementedError('Archive files are not yet supported for labextensions')
     else:
         destination = cast_unicode_py2(name)
-        full_dest = normpath(pjoin(lab_ext, destination))
+        full_dest = normpath(pjoin(labext, destination))
         if overwrite and os.path.lexists(full_dest):
             if logger:
                 logger.info("Removing: %s" % full_dest)
@@ -182,60 +182,60 @@ def install_lab_extension(path, name, overwrite=False, symlink=False,
     return full_dest
 
 
-def install_lab_extension_python(module, overwrite=False, symlink=False,
-                        user=False, sys_prefix=False, prefix=None, lab_extensions_dir=None, logger=None):
-    """Install an lab_extension bundled in a Python package.
+def install_labextension_python(module, overwrite=False, symlink=False,
+                        user=False, sys_prefix=False, prefix=None, labextensions_dir=None, logger=None):
+    """Install a labextension bundled in a Python package.
 
     Returns a list of installed/updated directories.
 
-    See install_lab_extension for parameter information."""
-    m, lab_exts = _get_lab_extension_metadata(module)
+    See install_labextension for parameter information."""
+    m, labexts = _get_labextension_metadata(module)
     base_path = os.path.split(m.__file__)[0]
 
     full_dests = []
 
-    for lab_ext in lab_exts:
-        src = os.path.join(base_path, lab_ext['src'])
-        name = lab_ext['name']
+    for labext in labexts:
+        src = os.path.join(base_path, labext['src'])
+        name = labext['name']
 
         if logger:
             logger.info("Installing %s -> %s" % (src, name))
-        full_dest = install_lab_extension(
+        full_dest = install_labextension(
             src, name, overwrite=overwrite, symlink=symlink,
-            user=user, sys_prefix=sys_prefix, prefix=prefix, lab_extensions_dir=lab_extensions_dir,
+            user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir,
             logger=logger
             )
-        validate_lab_extension_folder(full_dest, logger)
+        validate_labextension_folder(name, full_dest, logger)
         full_dests.append(full_dest)
 
     return full_dests
 
 
-def uninstall_lab_extension(name, user=False, sys_prefix=False, prefix=None, 
-                          lab_extensions_dir=None, logger=None):
+def uninstall_labextension(name, user=False, sys_prefix=False, prefix=None, 
+                          labextensions_dir=None, logger=None):
     """Uninstall a Javascript extension of JupyterLab
     
-    Removes staged files and/or directories in the lab_extensions directory and 
+    Removes staged files and/or directories in the labextensions directory and 
     removes the extension from the frontend config.
     
     Parameters
     ----------
     name: str
-        The name of the lab_extension.
+        The name of the labextension.
     user : bool [default: False]
-        Whether to install to the user's lab_extensions directory.
-        Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/lab_extensions).
+        Whether to install to the user's labextensions directory.
+        Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/labextensions).
     prefix : str [optional]
         Specify install prefix, if it should differ from default (e.g. /usr/local).
-        Will install to ``<prefix>/share/jupyter/lab_extensions``
-    lab_extensions_dir : str [optional]
-        Specify absolute path of lab_extensions directory explicitly.
+        Will install to ``<prefix>/share/jupyter/labextensions``
+    labextensions_dir : str [optional]
+        Specify absolute path of labextensions directory explicitly.
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    lab_ext = _get_lab_extension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, lab_extensions_dir=lab_extensions_dir)
+    labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir)
     dest = cast_unicode_py2(name)
-    full_dest = pjoin(lab_ext, dest)
+    full_dest = pjoin(labext, dest)
     if os.path.lexists(full_dest):
         if logger:
             logger.info("Removing: %s" % full_dest)
@@ -243,28 +243,28 @@ def uninstall_lab_extension(name, user=False, sys_prefix=False, prefix=None,
             shutil.rmtree(full_dest)
         else:
             os.remove(full_dest)
-    disable_lab_extension(name)
+    disable_labextension(name)
 
 
-def uninstall_lab_extension_python(module,
-                        user=False, sys_prefix=False, prefix=None, lab_extensions_dir=None,
+def uninstall_labextension_python(module,
+                        user=False, sys_prefix=False, prefix=None, labextensions_dir=None,
                         logger=None):
-    """Uninstall an lab_extension bundled in a Python package.
+    """Uninstall a labextension bundled in a Python package.
     
-    See parameters of `install_lab_extension_python`
+    See parameters of `install_labextension_python`
     """
-    m, lab_exts = _get_lab_extension_metadata(module)
-    for lab_ext in lab_exts:
-        name = lab_ext['name']
+    m, labexts = _get_labextension_metadata(module)
+    for labext in labexts:
+        name = labext['name']
         if logger:
             logger.info("Uninstalling {} {}".format(name))
-        uninstall_lab_extension(name, user=user, sys_prefix=sys_prefix, 
-            prefix=prefix, lab_extensions_dir=lab_extensions_dir, logger=logger)
+        uninstall_labextension(name, user=user, sys_prefix=sys_prefix, 
+            prefix=prefix, labextensions_dir=labextensions_dir, logger=logger)
 
 
-def _set_lab_extension_state(name, state,
+def _set_labextension_state(name, state,
                            user=True, sys_prefix=False, logger=None):
-    """Set whether the JupyterLab frontend should use the named lab_extension
+    """Set whether the JupyterLab frontend should use the named labextension
 
     Returns True if the final state is the one requested.
 
@@ -274,7 +274,7 @@ def _set_lab_extension_state(name, state,
     state : bool
         The state in which to leave the extension
     user : bool [default: True]
-        Whether to update the user's .jupyter/lab_extensions directory
+        Whether to update the user's .jupyter/labextensions directory
     sys_prefix : bool [default: False]
         Whether to update the sys.prefix, i.e. environment. Will override
         `user`.
@@ -283,20 +283,20 @@ def _set_lab_extension_state(name, state,
     """
     user = False if sys_prefix else user
     config_dir = os.path.join(
-        _get_config_dir(user=user, sys_prefix=sys_prefix), 'nbconfig')
+        _get_config_dir(user=user, sys_prefix=sys_prefix), 'labconfig')
     cm = BaseJSONConfigManager(config_dir=config_dir)
     if logger:
         logger.info("{} extension {}...".format(
             "Enabling" if state else "Disabling",
             name
         ))
-    cfg = cm.get("jupyter_notebook_config")
-    lab_extensions = (
+    cfg = cm.get("jupyterlab_config")
+    labextensions = (
         cfg.setdefault("LabApp", {})
-        .setdefault("lab_extensions", {})
+        .setdefault("labextensions", {})
     )
 
-    old_enabled = lab_extensions.get(name, None)
+    old_enabled = labextensions.get(name, None)
     new_enabled = state if state is not None else not old_enabled
 
     if logger:
@@ -305,22 +305,22 @@ def _set_lab_extension_state(name, state,
         else:
             logger.info(u"Disabling: %s" % (name))
 
-    lab_extensions[name] = new_enabled
+    labextensions[name] = new_enabled
 
     if logger:
         logger.info(u"- Writing config: {}".format(config_dir))
 
-    cm.update("jupyter_notebook_config", cfg)
+    cm.update("jupyterlab_config", cfg)
 
     if new_enabled:
-        validate_lab_extension(name, logger=logger)
+        validate_labextension(name, logger=logger)
 
     return old_enabled == state
 
 
-def _set_lab_extension_state_python(state, module, user, sys_prefix,
+def _set_labextension_state_python(state, module, user, sys_prefix,
                                   logger=None):
-    """Enable or disable some lab_extensions stored in a Python package
+    """Enable or disable some labextensions stored in a Python package
 
     Returns a list of whether the state was achieved (i.e. changed, or was
     already right)
@@ -332,25 +332,25 @@ def _set_lab_extension_state_python(state, module, user, sys_prefix,
         Whether the extensions should be enabled
     module : str
         Importable Python module exposing the
-        magic-named `_jupyter_lab_extension_paths` function
+        magic-named `_jupyter_labextension_paths` function
     user : bool
-        Whether to enable in the user's lab_extensions directory.
+        Whether to enable in the user's labextensions directory.
     sys_prefix : bool
         Enable/disable in the sys.prefix, i.e. environment
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    m, lab_exts = _get_lab_extension_metadata(module)
-    return [_set_lab_extension_state(name=lab_ext["name"],
+    m, labexts = _get_labextension_metadata(module)
+    return [_set_labextension_state(name=labext["name"],
                                    state=state,
                                    user=user, sys_prefix=sys_prefix,
                                    logger=logger)
-            for lab_ext in lab_exts]
+            for labext in labexts]
 
 
-def enable_lab_extension(name, user=True, sys_prefix=False,
+def enable_labextension(name, user=True, sys_prefix=False,
                        logger=None):
-    """Enable a named lab_extension
+    """Enable a named labextension
 
     Returns True if the final state is the one requested.
 
@@ -359,22 +359,22 @@ def enable_lab_extension(name, user=True, sys_prefix=False,
     name : string
         The name of the extension.
     user : bool [default: True]
-        Whether to enable in the user's lab_extensions directory.
+        Whether to enable in the user's labextensions directory.
     sys_prefix : bool [default: False]
         Whether to enable in the sys.prefix, i.e. environment. Will override
         `user`
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    return _set_lab_extension_state(name=name,
+    return _set_labextension_state(name=name,
                                   state=True,
                                   user=user, sys_prefix=sys_prefix,
                                   logger=logger)
 
 
-def disable_lab_extension(name, user=True, sys_prefix=False,
+def disable_labextension(name, user=True, sys_prefix=False,
                         logger=None):
-    """Disable a named lab_extension
+    """Disable a named labextension
     
     Returns True if the final state is the one requested.
 
@@ -383,22 +383,22 @@ def disable_lab_extension(name, user=True, sys_prefix=False,
     name : string
         The name of the extension.
     user : bool [default: True]
-        Whether to enable in the user's lab_extensions directory.
+        Whether to enable in the user's labextensions directory.
     sys_prefix : bool [default: False]
         Whether to enable in the sys.prefix, i.e. environment. Will override
         `user`.
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    return _set_lab_extension_state(name=name,
+    return _set_labextension_state(name=name,
                                   state=False,
                                   user=user, sys_prefix=sys_prefix,
                                   logger=logger)
 
 
-def enable_lab_extension_python(module, user=True, sys_prefix=False,
+def enable_labextension_python(module, user=True, sys_prefix=False,
                               logger=None):
-    """Enable some lab_extensions associated with a Python module.
+    """Enable some labextensions associated with a Python module.
 
     Returns a list of whether the state was achieved (i.e. changed, or was
     already right)
@@ -408,22 +408,22 @@ def enable_lab_extension_python(module, user=True, sys_prefix=False,
 
     module : str
         Importable Python module exposing the
-        magic-named `_jupyter_lab_extension_paths` function
+        magic-named `_jupyter_labextension_paths` function
     user : bool [default: True]
-        Whether to enable in the user's lab_extensions directory.
+        Whether to enable in the user's labextensions directory.
     sys_prefix : bool [default: False]
         Whether to enable in the sys.prefix, i.e. environment. Will override
         `user`
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    return _set_lab_extension_state_python(True, module, user, sys_prefix,
+    return _set_labextension_state_python(True, module, user, sys_prefix,
                                          logger=logger)
 
 
-def disable_lab_extension_python(module, user=True, sys_prefix=False,
+def disable_labextension_python(module, user=True, sys_prefix=False,
                                logger=None):
-    """Disable some lab_extensions associated with a Python module.
+    """Disable some labextensions associated with a Python module.
 
     Returns True if the final state is the one requested.
 
@@ -431,22 +431,22 @@ def disable_lab_extension_python(module, user=True, sys_prefix=False,
     ----------
     module : str
         Importable Python module exposing the
-        magic-named `_jupyter_lab_extension_paths` function
+        magic-named `_jupyter_labextension_paths` function
     user : bool [default: True]
-        Whether to enable in the user's lab_extensions directory.
+        Whether to enable in the user's labextensions directory.
     sys_prefix : bool [default: False]
         Whether to enable in the sys.prefix, i.e. environment
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    return _set_lab_extension_state_python(False, module, user, sys_prefix,
+    return _set_labextension_state_python(False, module, user, sys_prefix,
                                          logger=logger)
 
 
-def validate_lab_extension(name, logger=None):
-    """Validate a named lab_extension.
+def validate_labextension(name, logger=None):
+    """Validate a named labextension.
 
-    Looks across all of the lab_extension directories.
+    Looks across all of the labextension directories.
 
     Returns a list of warnings.
 
@@ -457,22 +457,22 @@ def validate_lab_extension(name, logger=None):
     logger : Jupyter logger [optional]
         Logger instance to use
     """
-    for exts in _lab_extension_dirs():
+    for exts in _labextension_dirs():
         full_dest = os.path.join(exts, name)
         if os.path.exists(full_dest):
-            return validate_lab_extension_folder(full_dest)
+            return validate_labextension_folder(name, full_dest, logger)
 
 
-def validate_lab_extension_folder(name, full_dest, logger=None):
-    """Assess the health of an installed lab_extension
+def validate_labextension_folder(name, full_dest, logger=None):
+    """Assess the health of an installed labextension
 
     Returns a list of warnings.
 
     Parameters
     ----------
     full_dest : str
-        The on-disk location of the installed lab_extension: this should end
-        with `lab_extensions/<name>`
+        The on-disk location of the installed labextension: this should end
+        with `labextensions/<name>`
     logger : Jupyter logger [optional]
         Logger instance to use
     """
@@ -484,7 +484,7 @@ def validate_lab_extension_folder(name, full_dest, logger=None):
 
     hasFiles = True
     hasEntry = False
-    data = get_lab_extension_manifest_data(full_dest)
+    data = get_labextension_manifest_data_by_folder(full_dest)
     for manifest in data.values():
         if ('entry' in manifest and 'modules' in manifest):
             if (manifest['entry'] in manifest['modules']):
@@ -546,7 +546,7 @@ _base_flags.update({
     "sys-prefix" : ({
         "BaseLabExtensionApp" : {
             "sys_prefix" : True,
-        }}, "Use sys.prefix as the prefix for installing lab_extensions (for environments, packaging)"
+        }}, "Use sys.prefix as the prefix for installing labextensions (for environments, packaging)"
     ),
     "py" : ({
         "BaseLabExtensionApp" : {
@@ -557,7 +557,7 @@ _base_flags.update({
 _base_flags['python'] = _base_flags['py']
 
 class BaseLabExtensionApp(JupyterApp):
-    """Base lab_extension installer app"""
+    """Base labextension installer app"""
     _log_formatter_cls = LogFormatter
     flags = _base_flags
     version = __version__
@@ -590,7 +590,7 @@ flags['s'] = flags['symlink']
 
 aliases = {
     "prefix" : "InstallLabExtensionApp.prefix",
-    "lab_extensions" : "InstallLabExtensionApp.lab_extensions_dir",
+    "labextensions" : "InstallLabExtensionApp.labextensions_dir",
     "destination" : "InstallLabExtensionApp.destination",
 }
 
@@ -600,17 +600,17 @@ class InstallLabExtensionApp(BaseLabExtensionApp):
     
     Usage
     
-        jupyter lab_extension install path|url [--user|--sys-prefix]
+        jupyter labextension install path|url [--user|--sys-prefix]
     
-    This copies a file or a folder into the Jupyter lab_extensions directory.
+    This copies a file or a folder into the Jupyter labextensions directory.
     If a URL is given, it will be downloaded.
-    If an archive is given, it will be extracted into lab_extensions.
+    If an archive is given, it will be extracted into labextensions.
     If the requested files are already up to date, no action is taken
     unless --overwrite is specified.
     """
     
     examples = """
-    jupyter lab_extension install /path/to/myextension
+    jupyter labextension install /path/to/myextension
     """
     aliases = aliases
     flags = flags
@@ -619,26 +619,26 @@ class InstallLabExtensionApp(BaseLabExtensionApp):
     symlink = Bool(False, config=True, help="Create symlinks instead of copying files")
 
     prefix = Unicode('', config=True, help="Installation prefix")
-    lab_extensions_dir = Unicode('', config=True,
-           help="Full path to lab_extensions dir (probably use prefix or user)")
-    destination = Unicode('', config=True, help="Destination for the copy or symlink")
+    labextensions_dir = Unicode('', config=True,
+           help="Full path to labextensions dir (probably use prefix or user)")
+    name = Unicode('', config=True, help="The name of the extension")
 
     def _config_file_name_default(self):
         """The default config file name."""
-        return 'jupyter_notebook_config'
+        return 'jupyterlab_config'
     
     def install_extensions(self):
-        """Perform the installation of lab_extension(s)"""
+        """Perform the installation of labextension(s)"""
         if len(self.extra_args)>1:
-            raise ValueError("Only one lab_extension allowed at a time. "
+            raise ValueError("Only one labextension allowed at a time. "
                          "Call multiple times to install multiple extensions.")
 
         if self.python:
-            install = install_lab_extension_python
+            install = install_labextension_python
             kwargs = {}
         else:
-            install = install_lab_extension
-            kwargs = {'destination': self.destination}
+            install = install_labextension
+            kwargs = {'name': self.name}
         
         full_dests = install(self.extra_args[0],
                              overwrite=self.overwrite,
@@ -646,17 +646,17 @@ class InstallLabExtensionApp(BaseLabExtensionApp):
                              user=self.user,
                              sys_prefix=self.sys_prefix,
                              prefix=self.prefix,
-                             lab_extensions_dir=self.lab_extensions_dir,
+                             labextensions_dir=self.labextensions_dir,
                              logger=self.log,
                              **kwargs
                             )
 
         if full_dests:
             self.log.info(
-                u"\nTo initialize this lab_extension in the browser every time"
+                u"\nTo enable this labextension in the browser every time"
                 " JupyterLab loads:\n\n"
-                "      jupyter lab_extension enable {}{}{}{}\n".format(
-                    self.extra_args[0] if self.python else "<the entry point>",
+                "      jupyter labextension enable {}{}{}{}\n".format(
+                    self.extra_args[0] if self.python else self.name,
                     " --user" if self.user else "",
                     " --py" if self.python else "",
                     " --sys-prefix" if self.sys_prefix else ""
@@ -666,7 +666,7 @@ class InstallLabExtensionApp(BaseLabExtensionApp):
     def start(self):
         """Perform the App's function as configured"""
         if not self.extra_args:
-            sys.exit('Please specify an lab_extension to install')
+            sys.exit('Please specify a labextension to install')
         else:
             try:
                 self.install_extensions()
@@ -681,57 +681,57 @@ class UninstallLabExtensionApp(BaseLabExtensionApp):
     
     Usage
     
-        jupyter lab_extension uninstall path/url path/url/entrypoint
-        jupyter lab_extension uninstall --py pythonPackageName
+        jupyter labextension uninstall path/url path/url/entrypoint
+        jupyter labextension uninstall --py pythonPackageName
     
-    This uninstalls an lab_extension.
+    This uninstalls a labextension.
     """
     
     examples = """
-    jupyter lab_extension uninstall dest/dir dest/dir/extensionjs
-    jupyter lab_extension uninstall --py extensionPyPackage
+    jupyter labextension uninstall dest/dir dest/dir/extensionjs
+    jupyter labextension uninstall --py extensionPyPackage
     """
     
     aliases = {
         "prefix" : "UninstallLabExtensionApp.prefix",
-        "lab_extensions" : "UninstallLabExtensionApp.lab_extensions_dir",
+        "labextensions" : "UninstallLabExtensionApp.labextensions_dir",
         "require": "UninstallLabExtensionApp.require",
     }
     
     prefix = Unicode('', config=True, help="Installation prefix")
-    lab_extensions_dir = Unicode('', config=True, help="Full path to lab_extensions dir (probably use prefix or user)")
+    labextensions_dir = Unicode('', config=True, help="Full path to labextensions dir (probably use prefix or user)")
     require = Unicode('', config=True, help="require.js module to load.")
     
     def _config_file_name_default(self):
         """The default config file name."""
-        return 'jupyter_notebook_config'
+        return 'jupyterlab_config'
     
     def uninstall_extensions(self):
-        """Uninstall some lab_extensions"""
+        """Uninstall some labextensions"""
         kwargs = {
             'user': self.user,
             'sys_prefix': self.sys_prefix,
             'prefix': self.prefix,
-            'lab_extensions_dir': self.lab_extensions_dir,
+            'labextensions_dir': self.labextensions_dir,
             'logger': self.log
         }
         
         arg_count = 1
         if len(self.extra_args) > arg_count:
-            raise ValueError("only one lab_extension allowed at a time.  Call multiple times to uninstall multiple extensions.")
+            raise ValueError("only one labextension allowed at a time.  Call multiple times to uninstall multiple extensions.")
         if len(self.extra_args) < arg_count:
             raise ValueError("not enough arguments")
         
         if self.python:
-            uninstall_lab_extension_python(self.extra_args[0], **kwargs)
+            uninstall_labextension_python(self.extra_args[0], **kwargs)
         else:
             if self.require:
                 kwargs['require'] = self.require
-            uninstall_lab_extension(self.extra_args[0], **kwargs)
+            uninstall_labextension(self.extra_args[0], **kwargs)
     
     def start(self):
         if not self.extra_args:
-            sys.exit('Please specify an lab_extension to uninstall')
+            sys.exit('Please specify a labextension to uninstall')
         else:
             try:
                 self.uninstall_extensions()
@@ -741,9 +741,9 @@ class UninstallLabExtensionApp(BaseLabExtensionApp):
 
 class ToggleLabExtensionApp(BaseLabExtensionApp):
     """A base class for apps that enable/disable extensions"""
-    name = "jupyter lab_extension enable/disable"
+    name = "jupyter labextension enable/disable"
     version = __version__
-    description = "Enable/disable an lab_extension in configuration."
+    description = "Enable/disable a labextension in configuration."
 
     user = Bool(True, config=True, help="Apply the configuration only for the current user (default)")
     
@@ -751,9 +751,9 @@ class ToggleLabExtensionApp(BaseLabExtensionApp):
 
     def _config_file_name_default(self):
         """The default config file name."""
-        return 'jupyter_notebook_config'
+        return 'jupyterlab_config'
     
-    def toggle_lab_extension_python(self, module):
+    def toggle_labextension_python(self, module):
         """Toggle some extensions in an importable Python module.
 
         Returns a list of booleans indicating whether the state was changed as
@@ -763,119 +763,119 @@ class ToggleLabExtensionApp(BaseLabExtensionApp):
         ----------
         module : str
             Importable Python module exposing the
-            magic-named `_jupyter_lab_extension_paths` function
+            magic-named `_jupyter_labextension_paths` function
         """
-        toggle = (enable_lab_extension_python if self._toggle_value
-                  else disable_lab_extension_python)
+        toggle = (enable_labextension_python if self._toggle_value
+                  else disable_labextension_python)
         return toggle(module,
                       user=self.user,
                       sys_prefix=self.sys_prefix,
                       logger=self.log)
 
-    def toggle_lab_extension(self, name):
-        """Toggle some a named lab_extension by require-able AMD module.
+    def toggle_labextension(self, name):
+        """Toggle some a named labextension by require-able AMD module.
 
         Returns whether the state was changed as requested.
 
         Parameters
         ----------
         require : str
-            require.js path used to load the lab_extension
+            require.js path used to load the labextension
         """
-        toggle = (enable_lab_extension if self._toggle_value
-                  else disable_lab_extension)
+        toggle = (enable_labextension if self._toggle_value
+                  else disable_labextension)
         return toggle(name,
                       user=self.user, sys_prefix=self.sys_prefix,
                       logger=self.log)
         
     def start(self):
         if not self.extra_args:
-            sys.exit('Please specify an lab_extension/package to enable or disable')
+            sys.exit('Please specify a labextension/package to enable or disable')
         elif len(self.extra_args) > 1:
-            sys.exit('Please specify one lab_extension/package at a time')
+            sys.exit('Please specify one labextension/package at a time')
         if self.python:
-            self.toggle_lab_extension_python(self.extra_args[0])
+            self.toggle_labextension_python(self.extra_args[0])
         else:
-            self.toggle_lab_extension(self.extra_args[0])
+            self.toggle_labextension(self.extra_args[0])
 
 
 class EnableLabExtensionApp(ToggleLabExtensionApp):
-    """An App that enables lab_extensions"""
-    name = "jupyter lab_extension enable"
+    """An App that enables labextensions"""
+    name = "jupyter labextension enable"
     description = """
-    Enable an lab_extension in frontend configuration.
+    Enable a labextension in frontend configuration.
     
     Usage
-        jupyter lab_extension enable [--system|--sys-prefix]
+        jupyter labextension enable [--system|--sys-prefix]
     """
     _toggle_value = True
 
 
 class DisableLabExtensionApp(ToggleLabExtensionApp):
-    """An App that disables lab_extensions"""
-    name = "jupyter lab_extension disable"
+    """An App that disables labextensions"""
+    name = "jupyter labextension disable"
     description = """
-    Enable an lab_extension in frontend configuration.
+    Enable a labextension in frontend configuration.
     
     Usage
-        jupyter lab_extension disable [--system|--sys-prefix]
+        jupyter labextension disable [--system|--sys-prefix]
     """
     _toggle_value = None
 
 
 class ListLabExtensionsApp(BaseLabExtensionApp):
-    """An App that lists and validates lab_extensions"""
-    name = "jupyter lab_extension list"
+    """An App that lists and validates labextensions"""
+    name = "jupyter labextension list"
     version = __version__
-    description = "List all lab_extensions known by the configuration system"
+    description = "List all labextensions known by the configuration system"
     
-    def list_lab_extensions(self):
-        """List all the lab_extensions"""
-        config_dirs = [os.path.join(p, 'nbconfig') for p in jupyter_config_path()]
+    def list_labextensions(self):
+        """List all the labextensions"""
+        config_dirs = [os.path.join(p, 'labconfig') for p in jupyter_config_path()]
         
-        print("Known lab_extensions:")
+        print("Known labextensions:")
         
         for config_dir in config_dirs:
             cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
-            data = cm.get("jupyter_notebook_config")
-            lab_extensions = (
+            data = cm.get("jupyterlab_config")
+            labextensions = (
                 data.setdefault("LabApp", {})
-                .setdefault("lab_extensions", {})
+                .setdefault("labextensions", {})
             )
-            if lab_extensions:
+            if labextensions:
                 print(u'config dir: {}'.format(config_dir))
-            for name, enabled in lab_extensions.items():
+            for name, enabled in labextensions.items():
                 print(u'    {} {}'.format(
                               name,
                               GREEN_ENABLED if enabled else RED_DISABLED))
-                validate_lab_extension(name, self.log)
+                validate_labextension(name, self.log)
 
     def start(self):
         """Perform the App's functions as configured"""
-        self.list_lab_extensions()
+        self.list_labextensions()
 
 
 _examples = """
-jupyter lab_extension list                          # list all configured lab_extensions
-jupyter lab_extension install --py <packagename>    # install an lab_extension from a Python package
-jupyter lab_extension enable --py <packagename>     # enable all lab_extensions in a Python package
-jupyter lab_extension disable --py <packagename>    # disable all lab_extensions in a Python package
-jupyter lab_extension uninstall --py <packagename>  # uninstall an lab_extension in a Python package
+jupyter labextension list                          # list all configured labextensions
+jupyter labextension install --py <packagename>    # install a labextension from a Python package
+jupyter labextension enable --py <packagename>     # enable all labextensions in a Python package
+jupyter labextension disable --py <packagename>    # disable all labextensions in a Python package
+jupyter labextension uninstall --py <packagename>  # uninstall a labextension in a Python package
 """
 
 class LabExtensionApp(BaseLabExtensionApp):
-    """Base jupyter lab_extension command entry point"""
-    name = "jupyter lab_extension"
+    """Base jupyter labextension command entry point"""
+    name = "jupyter labextension"
     version = __version__
     description = "Work with JupyterLab extensions"
     examples = _examples
 
     subcommands = dict(
-        install=(InstallLabExtensionApp,"Install an lab_extension"),
-        enable=(EnableLabExtensionApp, "Enable an lab_extension"),
-        disable=(DisableLabExtensionApp, "Disable an lab_extension"),
-        uninstall=(UninstallLabExtensionApp, "Uninstall an lab_extension"),
-        list=(ListLabExtensionsApp, "List lab_extensions")
+        install=(InstallLabExtensionApp, "Install a labextension"),
+        enable=(EnableLabExtensionApp, "Enable a labextension"),
+        disable=(DisableLabExtensionApp, "Disable a labextension"),
+        uninstall=(UninstallLabExtensionApp, "Uninstall a labextension"),
+        list=(ListLabExtensionsApp, "List labextensions")
     )
 
     def start(self):
@@ -958,45 +958,45 @@ def _safe_is_tarfile(path):
         return False
 
 
-def _get_lab_extension_dir(user=False, sys_prefix=False, prefix=None, lab_extensions_dir=None):
-    """Return the lab_extension directory specified
+def _get_labextension_dir(user=False, sys_prefix=False, prefix=None, labextensions_dir=None):
+    """Return the labextension directory specified
 
     Parameters
     ----------
 
     user : bool [default: False]
-        Get the user's .jupyter/lab_extensions directory
+        Get the user's .jupyter/labextensions directory
     sys_prefix : bool [default: False]
-        Get sys.prefix, i.e. ~/.envs/my-env/share/jupyter/lab_extensions
+        Get sys.prefix, i.e. ~/.envs/my-env/share/jupyter/labextensions
     prefix : str [optional]
         Get custom prefix
-    lab_extensions_dir : str [optional]
+    labextensions_dir : str [optional]
         Get what you put in
     """
-    if sum(map(bool, [user, prefix, lab_extensions_dir, sys_prefix])) > 1:
-        raise ArgumentConflict("cannot specify more than one of user, sys_prefix, prefix, or lab_extensions_dir")
+    if sum(map(bool, [user, prefix, labextensions_dir, sys_prefix])) > 1:
+        raise ArgumentConflict("cannot specify more than one of user, sys_prefix, prefix, or labextensions_dir")
     if user:
-        lab_ext = pjoin(jupyter_data_dir(), u'lab_extensions')
+        labext = pjoin(jupyter_data_dir(), u'labextensions')
     elif sys_prefix:
-        lab_ext = pjoin(ENV_JUPYTER_PATH[0], u'lab_extensions')
+        labext = pjoin(ENV_JUPYTER_PATH[0], u'labextensions')
     elif prefix:
-        lab_ext = pjoin(prefix, 'share', 'jupyter', 'lab_extensions')
-    elif lab_extensions_dir:
-        lab_ext = lab_extensions_dir
+        labext = pjoin(prefix, 'share', 'jupyter', 'labextensions')
+    elif labextensions_dir:
+        labext = labextensions_dir
     else:
-        lab_ext = pjoin(SYSTEM_JUPYTER_PATH[0], 'lab_extensions')
-    return lab_ext
+        labext = pjoin(SYSTEM_JUPYTER_PATH[0], 'labextensions')
+    return labext
 
 
-def _lab_extension_dirs():
-    """The possible locations of lab_extensions.
+def _labextension_dirs():
+    """The possible locations of labextensions.
 
     Returns a list of known base extension locations
     """
     return [
-        pjoin(jupyter_data_dir(), u'lab_extensions'),
-        pjoin(ENV_JUPYTER_PATH[0], u'lab_extensions'),
-        pjoin(SYSTEM_JUPYTER_PATH[0], 'lab_extensions')
+        pjoin(jupyter_data_dir(), u'labextensions'),
+        pjoin(ENV_JUPYTER_PATH[0], u'labextensions'),
+        pjoin(SYSTEM_JUPYTER_PATH[0], 'labextensions')
     ]
 
 
@@ -1017,16 +1017,16 @@ def _get_config_dir(user=False, sys_prefix=False):
     if user and sys_prefix:
         raise ArgumentConflict("Cannot specify more than one of user or sys_prefix")
     if user:
-        lab_ext = jupyter_config_dir()
+        labext = jupyter_config_dir()
     elif sys_prefix:
-        lab_ext = ENV_CONFIG_PATH[0]
+        labext = ENV_CONFIG_PATH[0]
     else:
-        lab_ext = SYSTEM_CONFIG_PATH[0]
-    return lab_ext
+        labext = SYSTEM_CONFIG_PATH[0]
+    return labext
 
 
-def _get_lab_extension_metadata(module):
-    """Get the list of lab_extension paths associated with a Python module.
+def _get_labextension_metadata(module):
+    """Get the list of labextension paths associated with a Python module.
 
     Returns a tuple of (the module,             [{
         'name': 'mockextension',
@@ -1038,13 +1038,13 @@ def _get_lab_extension_metadata(module):
 
     module : str
         Importable Python module exposing the
-        magic-named `_jupyter_lab_extension_paths` function
+        magic-named `_jupyter_labextension_paths` function
     """
     m = import_item(module)
-    if not hasattr(m, '_jupyter_lab_extension_paths'):
-        raise KeyError('The Python module {} is not a valid lab_extension'.format(module))
-    lab_exts = m._jupyter_lab_extension_paths()
-    return m, lab_exts
+    if not hasattr(m, '_jupyter_labextension_paths'):
+        raise KeyError('The Python module {} is not a valid labextension'.format(module))
+    labexts = m._jupyter_labextension_paths()
+    return m, labexts
 
 
 def _read_config_data(user=False, sys_prefix=False):
@@ -1062,7 +1062,7 @@ def _read_config_data(user=False, sys_prefix=False):
     """
     config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
     config_man = BaseJSONConfigManager(config_dir=config_dir)
-    return config_man.get('jupyter_notebook_config')
+    return config_man.get('jupyterlab_config')
 
 
 def _write_config_data(data, user=False, sys_prefix=False):
@@ -1079,7 +1079,7 @@ def _write_config_data(data, user=False, sys_prefix=False):
     """
     config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
     config_man = BaseJSONConfigManager(config_dir=config_dir)
-    config_man.update('jupyter_notebook_config', data)
+    config_man.update('jupyterlab_config', data)
 
 
 if __name__ == '__main__':