Allow python config

jupyterlab/__init__.py

@@ -10,7 +10,8 @@ from tornado import web
 from notebook.base.handlers import IPythonHandler, FileFindHandler
 from jinja2 import FileSystemLoader
 from notebook.utils import url_path_join as ujoin
-
+from traitlets.config.manager import BaseJSONConfigManager
+from jupyter_core.paths import jupyter_config_path
 
 try:
     from ._version import __version__
@@ -91,8 +92,23 @@ class LabHandler(IPythonHandler):
             if os.path.isfile(os.path.join(BUILT_FILES, css_file)):
                 css_files.append(ujoin(static_prefix, css_file))
 
+        config = dict(
+            static_prefix=static_prefix,
+            page_title='JupyterLab Alpha Preview',
+            terminals_available=self.settings['terminals_available'],
+            mathjax_url=self.mathjax_url,
+            jupyterlab_main=main,
+            jupyterlab_css=css_files,
+            jupyterlab_bundles=bundles,
+            plugin_entries=entries,
+            mathjax_config='TeX-AMS_HTML-full,Safe',
+            #mathjax_config=self.mathjax_config # for the next release of the notebook
+        )
+
         # Gather the lab extension files and entry points.
-        for name in labextensions:
+        for (name, value) in labextensions.items():
+            if not value['enabled']:
+                continue
             data = get_labextension_manifest_data_by_name(name)
             if data is None:
                 self.log.warn('Could not locate extension: ' + name)
@@ -108,23 +124,21 @@ class LabHandler(IPythonHandler):
                         css_files.append('%s/%s/%s' % (
                             EXTENSION_PREFIX, name, fname
                         ))
+            python_module = value['python_module']
+            from .labextensions import get_labextension_config_python
+            if python_module:
+                try:
+                    value = get_labextension_config_python(python_module)
+                    config.update(value)
+                except Exception as e:
+                    self.log.error(e)
 
-        self.write(self.render_template('lab.html',
-            static_prefix=static_prefix,
-            page_title='JupyterLab Alpha Preview',
-            terminals_available=self.settings['terminals_available'],
-            mathjax_url=self.mathjax_url,
-            jupyterlab_main=main,
-            jupyterlab_css=css_files,
-            jupyterlab_bundles=bundles,
-            plugin_entries=entries,
-            mathjax_config='TeX-AMS_HTML-full,Safe',
-            #mathjax_config=self.mathjax_config # for the next release of the notebook
-        ))
+        self.write(self.render_template('lab.html', **config))
 
     def get_template(self, name):
         return FILE_LOADER.load(self.settings['jinja2_env'], name)
 
+
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
@@ -144,7 +158,14 @@ def _jupyter_server_extension_paths():
 
 def load_jupyter_server_extension(nbapp):
     from jupyter_core.paths import jupyter_path
-    from .labapp import get_labextensions
+    from .labapp import LabApp
+
+    if not isinstance(nbapp, LabApp):
+        labapp = LabApp()
+        labapp.load_config_file()
+        labextensions = labapp.labextensions
+    else:
+        labextensions = nbapp.labextensions
 
     base_dir = os.path.realpath(os.path.join(HERE, '..'))
     dev_mode = os.path.exists(os.path.join(base_dir, '.git'))
@@ -152,7 +173,8 @@ def load_jupyter_server_extension(nbapp):
         nbapp.log.info(DEV_NOTE_NPM)
     nbapp.log.info('JupyterLab alpha preview extension loaded from %s' % HERE)
     webapp = nbapp.web_app
-    webapp.labextensions = get_labextensions(parent=nbapp)
+    webapp.labextensions = labextensions
+
     base_url = webapp.settings['base_url']
     webapp.add_handlers(".*$",
         [(ujoin(base_url, h[0]),) + h[1:] for h in default_handlers])

jupyterlab/labapp.py

@@ -8,7 +8,7 @@
 import os
 from jupyter_core.paths import jupyter_config_path, jupyter_path
 from notebook.notebookapp import NotebookApp
-from traitlets import List, Unicode, default
+from traitlets import List, Dict, Unicode, default
 from traitlets.config.manager import BaseJSONConfigManager
 
 from .labextensions import find_labextension, validate_labextension_folder
@@ -16,26 +16,6 @@ from .labextensions import find_labextension, validate_labextension_folder
 from ._version import __version__
 
 
-def get_labextensions(parent=None):
-    """Get the list of enabled and valid lab extensions"""
-    extensions = []
-    config_dirs = [os.path.join(p, 'labconfig') for p in
-                   jupyter_config_path()]
-    for config_dir in config_dirs:
-        cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
-        data = cm.get("jupyterlab_config")
-        labextensions = (
-            data.setdefault("LabApp", {})
-            .setdefault("labextensions", {})
-        )
-        for name, enabled in labextensions.items():
-            if enabled:
-                warnings = validate_labextension_folder(name, find_labextension(name))
-                if not warnings:
-                    extensions.append(name)
-    return extensions
-
-
 class LabApp(NotebookApp):
     version = __version__
 
@@ -57,24 +37,7 @@ class LabApp(NotebookApp):
         help="The default URL to redirect to from `/`"
     )
 
-    extra_labextensions_path = List(Unicode(), config=True,
-        help="""extra paths to look for JupyterLab extensions"""
-    )
-    
-    labextensions = List(Unicode())
-    
-    @default('labextensions')
-    def _labextensions_default(self):
-        return get_labextensions(parent=self)
-
-    @property
-    def labextensions_path(self):
-        """The path to look for JupyterLab extensions"""
-        return self.extra_labextensions_path + jupyter_path('labextensions')
-
-    def init_webapp(self):
-        super(LabApp, self).init_webapp()
-        self.web_app.labextensions = self.labextensions
+    labextensions = Dict({}, config=True, help='foo')
 
 #-----------------------------------------------------------------------------
 # Main entry point

jupyterlab/labextensions.py

@@ -257,7 +257,8 @@ def uninstall_labextension_python(module,
 
 
 def _set_labextension_state(name, state,
-                           user=True, sys_prefix=False, logger=None):
+                           user=True, sys_prefix=False, logger=None,
+                           python_module=None):
     """Set whether the JupyterLab frontend should use the named labextension
 
     Returns True if the final state is the one requested.
@@ -273,24 +274,31 @@ def _set_labextension_state(name, state,
         Whether to update the sys.prefix, i.e. environment. Will override
         `user`.
     logger : Jupyter logger [optional]
-        Logger instance to use
+        Logger instance to use [optional]
+    python_module: string
+        The name of the python module associated with the extension.
     """
     user = False if sys_prefix else user
     config_dir = os.path.join(
-        _get_config_dir(user=user, sys_prefix=sys_prefix), 'labconfig')
+        _get_config_dir(user=user, sys_prefix=sys_prefix))
     cm = BaseJSONConfigManager(config_dir=config_dir)
     if logger:
         logger.info("{} extension {}...".format(
             "Enabling" if state else "Disabling",
             name
         ))
-    cfg = cm.get("jupyterlab_config")
+    cfg = cm.get("jupyter_notebook_config")
     labextensions = (
         cfg.setdefault("LabApp", {})
         .setdefault("labextensions", {})
     )
 
-    old_enabled = labextensions.get(name, None)
+    old_state = labextensions.get(name, None)
+    if old_state is None:
+        old_state = dict(enabled=False)
+    elif isinstance(old_state, bool):
+        old_state = dict(enabled=old_state)
+    old_enabled = old_state['enabled']
     new_enabled = state if state is not None else not old_enabled
 
     if logger:
@@ -299,12 +307,15 @@ def _set_labextension_state(name, state,
         else:
             logger.info(u"Disabling: %s" % (name))
 
-    labextensions[name] = new_enabled
+    labextensions[name] = dict(
+        enabled=new_enabled,
+        python_module=python_module
+    )
 
     if logger:
         logger.info(u"- Writing config: {}".format(config_dir))
 
-    cm.update("jupyterlab_config", cfg)
+    cm.update("jupyter_notebook_config", cfg)
 
     if new_enabled:
         full_dest = find_labextension(name)
@@ -437,6 +448,7 @@ def disable_labextension_python(module, user=True, sys_prefix=False,
     return _set_labextension_state_python(False, module, user, sys_prefix,
                                          logger=logger)
 
+
 def find_labextension(name):
     """Find a labextension path
 
@@ -873,7 +885,10 @@ class ListLabExtensionsApp(BaseLabExtensionApp):
             )
             if labextensions:
                 print(u'config dir: {}'.format(config_dir))
-            for name, enabled in sorted(labextensions.items()):
+            for name, config in sorted(labextensions.items()):
+                if isinstance(config, bool):
+                    config = dict(enabled=config)
+                enabled = config['enabled']
                 full_dest = find_labextension(name)
                 print(u'    {} {}: {}'.format(
                               name,