Merge pull request #1 from quantlabio/quantlab

0.2.0

Author: QuantLab

.travis.yml

@@ -5,7 +5,6 @@ python:
 sudo: false
 install:
     - pip install setuptools pip --upgrade
-    - pip install -e .
+    - pip install -v -e ".[test]"
 script:
-    - cd
-    - python -c "import quantlab_launcher"
+    - py.test

quantlab_launcher/_version.py

@@ -1,2 +1,2 @@
-version_info = (0, 1, 2)
+version_info = (0, 2, 0)
 __version__ = ".".join(map(str, version_info))

quantlab_launcher/app.py

@@ -18,7 +18,7 @@ class QuantLabLauncherApp(NotebookApp):
 
     def start(self):
         add_handlers(self.web_app, self.quantlab_config)
-        super.start()
+        NotebookApp.start(self)
 
 
 main = QuantLabLauncherApp.launch_instance

quantlab_launcher/handlers.py

@@ -10,8 +10,9 @@
 from notebook.base.handlers import IPythonHandler, FileFindHandler
 from jinja2 import FileSystemLoader
 from notebook.utils import url_path_join as ujoin
-from traitlets import HasTraits, Unicode, Bool
+from traitlets import HasTraits, Unicode, Bool, List
 
+from .settings_handler import SettingsHandler
 
 #-----------------------------------------------------------------------------
 # Module globals
@@ -20,6 +21,11 @@
 HERE = os.path.dirname(__file__)
 FILE_LOADER = FileSystemLoader(HERE)
 
+# The default paths for the application.
+default_static_path = r'quantlab/static/'
+default_settings_path = r'quantlab/api/settings/'
+default_themes_path = r'/quantlab/api/themes/'
+
 
 class QuantLabHandler(IPythonHandler):
     """Render the QuantLab View."""
@@ -35,19 +41,19 @@ def get(self):
         assets_dir = config.assets_dir
 
         base_url = self.settings['base_url']
-        url = ujoin(base_url, config.page_url, '/static/')
-
-        bundle_files = []
-        css_files = []
-        for entry in ['main']:
-            css_file = entry + '.css'
-            if os.path.isfile(os.path.join(assets_dir, css_file)):
-                css_files.append(ujoin(url, css_file))
-            bundle_file = entry + '.bundle.js'
-            if os.path.isfile(os.path.join(assets_dir, bundle_file)):
-                bundle_files.append(ujoin(url, bundle_file))
-
-        if not bundle_files:
+        js_files = set(config.static_js_urls)
+        css_files = set(config.static_css_urls)
+
+        if config.assets_dir:
+            for entry in ['main']:
+                css_file = entry + '.css'
+                if os.path.isfile(os.path.join(assets_dir, css_file)):
+                    css_files.add(ujoin(config.static_url, css_file))
+                bundle_file = entry + '.bundle.js'
+                if os.path.isfile(os.path.join(assets_dir, bundle_file)):
+                    js_files.add(ujoin(config.static_url, bundle_file))
+
+        if not js_files:
             msg = ('%s build artifacts not detected in "%s".\n' +
                    'Please see README for build instructions.')
             msg = msg % (config.name, config.assets_dir)
@@ -69,6 +75,8 @@ def get(self):
         page_config.setdefault('appVersion', config.version)
         page_config.setdefault('appNamespace', config.namespace)
         page_config.setdefault('devMode', config.dev_mode)
+        page_config.setdefault('settingsPath', config.settings_url)
+        page_config.setdefault('themePath', config.themes_url);
         page_config.setdefault(
             'settingsDir', config.settings_dir.replace(os.sep, '/')
         )
@@ -91,9 +99,9 @@ def get(self):
             mathjax_url=self.mathjax_url,
             mathjax_config=mathjax_config,
             css_files=css_files,
-            bundle_files=bundle_files,
+            js_files=js_files,
             page_config=page_config,
-            public_url=url
+            public_url=config.static_url
         )
         self.write(self.render_template('index.html', **config))
 
@@ -105,10 +113,10 @@ class QuantLabConfig(HasTraits):
     """The quantlab application configuration object.
     """
     settings_dir = Unicode('',
-        help='The settings directory')
+        help='The application settings directory')
 
     assets_dir = Unicode('',
-        help='The assets directory')
+        help='The location of the static assets directory')
 
     name = Unicode('',
         help='The name of the application')
@@ -125,41 +133,74 @@ class QuantLabConfig(HasTraits):
     page_url = Unicode('/quantlab',
         help='The url for the application')
 
+    static_url = Unicode('',
+        help='The optional override static url for the application')
+
+    static_js_urls = List(Unicode(),
+        help='The optional list of static JavaScript urls to serve')
+
+    static_css_urls = List(Unicode(),
+        help='The optional list of static CSS urls to serve')
+
     dev_mode = Bool(False,
         help='Whether the application is in dev mode')
 
+    settings_url = Unicode('',
+        help='The optional override url of the settings handler')
+
+    schemas_dir = Unicode('',
+        help='The location of the settings schemas directory')
+
+    user_settings_dir = Unicode('',
+        help='The location of the user settings directory')
+
+    themes_url = Unicode('',
+        help='The optional theme override url')
+
+    themes_dir = Unicode('',
+        help='The location of the themes directory')
+
 
 def add_handlers(web_app, config):
     """Add the appropriate handlers to the web app.
     """
+    # Set up the main page handler.
     base_url = web_app.settings['base_url']
-    url = ujoin(base_url, config.page_url)
-    assets_dir = config.assets_dir
-
-    package_file = os.path.join(assets_dir, 'package.json')
-    with open(package_file) as fid:
-        data = json.load(fid)
-
-    config.version = (config.version or data['quantlab']['version'] or
-                      data['version'])
-    config.name = config.name or data['quantlab']['name']
-
     handlers = [
-        (url + r'/?', QuantLabHandler, {
+        (ujoin(base_url, config.page_url, r'/?'), QuantLabHandler, {
             'quantlab_config': config
-        }),
-        (url + r"/static/(.*)", FileFindHandler, {
-            'path': assets_dir
-        }),
-
+        })
     ]
 
-    # Backward compatibility.
-    if 'publicPath' in data['quantlab']:
-        handlers.append(
-            (data['quantlab']['publicPath'] + r"/(.*)", FileFindHandler, {
-                'path': assets_dir
-            })
-        )
+    # Handle the static assets.
+    if config.assets_dir and not config.static_url:
+        config.static_url = ujoin(base_url, default_static_path)
+        handlers.append((config.static_url + "(.*)", FileFindHandler, {
+            'path': config.assets_dir
+        }))
+
+        package_file = os.path.join(config.assets_dir, 'package.json')
+        with open(package_file) as fid:
+            data = json.load(fid)
+
+        config.version = (config.version or data['quantlab']['version'] or
+                          data['version'])
+        config.name = config.name or data['quantlab']['name']
+
+    # Handle the settings.
+    if config.schemas_dir and not config.settings_url:
+        config.settings_url = ujoin(base_url, default_settings_path)
+        settings_path = config.settings_url + '(?P<section_name>[\w.-]+)'
+        handlers.append((settings_path, SettingsHandler, {
+            'schemas_dir': config.schemas_dir,
+            'settings_dir': config.user_settings_dir
+        }))
+
+    # Handle the themes.
+    if config.themes_dir and not config.themes_url:
+        config.themes_url = ujoin(base_url, default_themes_path)
+        handlers.append((ujoin(config.themes_url, "(.*)"), FileFindHandler, {
+            'path': config.themes_dir
+        }))
 
     web_app.add_handlers(".*$", handlers)

quantlab_launcher/index.html

@@ -27,8 +27,8 @@
 
   {% block favicon %}<link rel="shortcut icon" type="image/x-icon" href="{{ base_url }}static/base/images/favicon.ico">{% endblock %}
 
-  {% for bundle_file in bundle_files %}
-  <script src="{{ bundle_file }}" type="text/javascript" charset="utf-8"></script>
+  {% for js_file in js_files %}
+  <script src="{{ js_file }}" type="text/javascript" charset="utf-8"></script>
   {% endfor %}
 
   {% if mathjax_url %}

quantlab_launcher/settings_handler.py

@@ -0,0 +1,95 @@
+"""Tornado handlers for frontend config storage."""
+
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+import json
+import os
+from tornado import web
+
+from notebook.base.handlers import APIHandler, json_errors
+
+try:
+    from jsonschema import ValidationError
+    from jsonschema import Draft4Validator as Validator
+except ImportError:
+    Validator = None
+
+
+class SettingsHandler(APIHandler):
+
+    def initialize(self, schemas_dir, settings_dir):
+        self.schemas_dir = schemas_dir
+        self.settings_dir = settings_dir
+
+    @json_errors
+    @web.authenticated
+    def get(self, section_name):
+        self.set_header('Content-Type', "application/json")
+        path = os.path.join(self.schemas_dir, section_name + ".json")
+
+        if not os.path.exists(path):
+            raise web.HTTPError(404, "Schema not found: %r" % section_name)
+        with open(path) as fid:
+            # Attempt to load the schema file.
+            try:
+                schema = json.load(fid)
+            except Exception as e:
+                name = section_name
+                message = "Failed parsing schema ({}): {}".format(name, str(e))
+                raise web.HTTPError(500, message)
+
+        path = os.path.join(self.settings_dir, section_name + '.json')
+        settings = dict()
+        if os.path.exists(path):
+            with open(path) as fid:
+                # Attempt to load the settings file.
+                try:
+                    settings = json.load(fid)
+                except Exception as e:
+                    self.log.warn(str(e))
+
+        # Validate the data against the schema.
+        if Validator is not None and len(settings):
+            validator = Validator(schema)
+            try:
+                validator.validate(settings)
+            except ValidationError as e:
+                self.log.warn(str(e))
+                settings = dict()
+
+        resp = dict(id=section_name, data=dict(user=settings), schema=schema)
+        self.finish(json.dumps(resp))
+
+    @json_errors
+    @web.authenticated
+    def patch(self, section_name):
+        if not self.settings_dir:
+            raise web.HTTPError(404, "No current settings directory")
+
+        path = os.path.join(self.schemas_dir, section_name + '.json')
+
+        if not os.path.exists(path):
+            raise web.HTTPError(404, "Schema not found for: %r" % section_name)
+
+        data = self.get_json_body()  # Will raise 400 if content is not valid JSON
+
+        # Validate the data against the schema.
+        if Validator is not None:
+            with open(path) as fid:
+                schema = json.load(fid)
+            validator = Validator(schema)
+            try:
+                validator.validate(data)
+            except ValidationError as e:
+                raise web.HTTPError(400, str(e))
+
+        # Create the settings dir as needed.
+        if not os.path.exists(self.settings_dir):
+            os.makedirs(self.settings_dir)
+
+        path = os.path.join(self.settings_dir, section_name + '.json')
+
+        with open(path, 'w') as fid:
+            json.dump(data, fid)
+
+        self.set_status(204)