def initialize(webapp, notebook_dir, connection_url, settings):
if os.name == 'nt':
default_shell = 'powershell.exe'
else:
default_shell = which('sh')
shell = settings.get('shell_command',
[os.environ.get('SHELL') or default_shell]
)
# Enable login mode - to automatically source the /etc/profile script
if os.name != 'nt':
shell.append('-l')
terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(
shell_command=shell,
extra_env={'JUPYTER_SERVER_ROOT': notebook_dir,
'JUPYTER_SERVER_URL': connection_url,
},
)
terminal_manager.log = app_log
base_url = webapp.settings['base_url']
handlers = [
(ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
(ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
{'term_manager': terminal_manager}),
(ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
(ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
]
webapp.add_handlers(".*$", handlers)
def load_jupyter_server_extension(nbapp):
webapp = nbapp.web_app
base_url = webapp.settings['base_url']
webapp.add_handlers(".*$", [
(ujoin(base_url, r"/nbextensions"), NBExtensionHandler),
(ujoin(base_url, r"/nbextensions/"), NBExtensionHandler),
(ujoin(base_url, r"/nbextensions/config/rendermd/(.*)"), RenderExtensionHandler),
])
def load_jupyter_server_extension(nbapp):
webapp = nbapp.web_app
base_url = webapp.settings['base_url']
mdregex = r'([^"\'>]+.md)'
webapp.add_handlers(".*$", [
(ujoin(base_url, r"/rendermd/%s" % mdregex), RenderExtensionHandler),
(ujoin(base_url, r"/nbextensions"), NBExtensionHandler),
(ujoin(base_url, r"/nbextensions/"), NBExtensionHandler)
])
def _get_lab_config(self, manifest):
"""Get the config data for the page template."""
static_prefix = ujoin(self.base_url, PREFIX)
labextensions = self.labextensions
main = manifest['main']['entry']
bundles = [ujoin(static_prefix, name + '.bundle.js') for name in
['loader', 'main']]
entries = []
# Only load CSS files if they exist.
css_files = []
for css_file in ['main.css']:
if os.path.isfile(os.path.join(BUILT_FILES, css_file)):
css_files.append(ujoin(static_prefix, css_file))
configData = dict(
terminalsAvailable=self.settings.get('terminals_available', False),
)
# Gather the lab extension files and entry points.
for (name, data) in sorted(labextensions.items()):
for value in data.values():
if not isinstance(value, dict):
continue
if value.get('entry', None):
entries.append(value['entry'])
bundles.append('%s/%s/%s' % (
self.extension_prefix, name, value['files'][0]
))
for fname in value['files']:
if os.path.splitext(fname)[1] == '.css':
css_files.append('%s/%s/%s' % (
self.extension_prefix, name, fname
))
python_module = data.get('python_module', None)
if python_module:
try:
value = get_labextension_config_python(python_module)
configData.update(value)
except Exception as e:
self.log.error(e)
mathjax_config = self.settings.get('mathjax_config',
'TeX-AMS_HTML-full,Safe')
config = dict(
static_prefix=static_prefix,
page_title='JupyterLab Alpha Preview',
mathjax_url=self.mathjax_url,
mathjax_config=mathjax_config,
jupyterlab_main=main,
jupyterlab_css=css_files,
jupyterlab_bundles=bundles,
plugin_entries=entries,
)
config['jupyterlab_config'] = configData
return config
def get(self):
static_prefix = ujoin(self.base_url, PREFIX)
labextensions = self.application.labextensions
data = get_labextension_manifest_data_by_folder(BUILT_FILES)
if 'main' not in data or 'extensions' not in data:
msg = ('JupyterLab build artifacts not detected, please see ' +
'CONTRIBUTING.md for build instructions.')
self.log.error(msg)
self.write(self.render_template('error.html',
status_code=500,
status_message='JupyterLab Error',
page_title='JupyterLab Error',
message=msg))
return
main = data['main']['entry']
bundles = [ujoin(static_prefix, name + '.bundle.js') for name in
['loader', 'main', 'extensions']]
entries = [data['extensions']['entry']]
# Only load CSS files if they exist.
css_files = []
for css_file in ['main.css', 'extensions.css']:
if os.path.isfile(os.path.join(BUILT_FILES, css_file)):
css_files.append(ujoin(static_prefix, css_file))
# Gather the lab extension files and entry points.
for name in labextensions:
data = get_labextension_manifest_data_by_name(name)
if data is None:
self.log.warn('Could not locate extension: ' + name)
continue
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
))
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
))
def initialize(webapp):
shell = os.environ.get('SHELL') or 'sh'
terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(shell_command=[shell])
terminal_manager.log = app_log
base_url = webapp.settings['base_url']
handlers = [
(ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
(ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
{'term_manager': terminal_manager}),
(ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
(ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
]
webapp.add_handlers(".*$", handlers)
def get(self, action):
example_id = self.get_argument('example_id')
if action == 'preview':
self.finish(self.manager.preview_example(example_id))
elif action == 'fetch':
dest = self.get_argument('dest')
dest = self.manager.fetch_example(example_id, dest)
self.redirect(ujoin(self.base_url, 'notebooks', dest))
elif action == 'submit':
dest = self.manager.submit_example(example_id)
self.redirect(ujoin(self.base_url, 'tree#examples' + dest))
elif action == 'delete':
self.manager.delete_example(example_id)
self.redirect(ujoin(self.base_url))
def get(self, action):
example_id = self.get_argument('example_id')
if action == 'preview':
self.finish(self.manager.preview_example(example_id))
elif action == 'fetch':
dest = self.get_argument('dest')
self.manager.fetch_example(example_id, dest)
# nbconvert appends '.ipynb' if it isn't present
if not dest.endswith('.ipynb'):
dest += '.ipynb'
self.redirect(ujoin(self.base_url, 'notebooks', dest))
elif action == 'submit':
dest = self.manager.submit_example(example_id)
preview_url = '/examples/preview?example_id={}'.format(dest)
self.redirect(ujoin(self.base_url, preview_url))
def get(self, path="/"):
config = self.nteract_config
settings_dir = config.settings_dir
assets_dir = config.assets_dir
base_url = self.settings['base_url']
url = ujoin(base_url, config.page_url, '/static/')
# Handle page config data.
page_config = dict()
page_config.update(self.settings.get('page_config_data', {}))
page_config.setdefault('appName', config.name)
page_config.setdefault('appVersion', config.version)
mathjax_config = self.settings.get('mathjax_config',
'TeX-AMS_HTML-full,Safe')
config = dict(
page_title=config.page_title,
mathjax_url=self.mathjax_url,
mathjax_config=mathjax_config,
page_config=page_config,
public_url=url,
contents_path=path,
page=self.page,
)
self.write(self.render_template('index.html', **config))
def get(self, action):
try:
notebook_id = unquote(self.get_argument('notebook_id'))
# Submit a notebook
if action == 'submit':
name = unquote(self.get_argument('name', default=None))
dest = self.manager.storage.submit(notebook_id, name, True);
self.finish(str(dest));
# Delete a notebook
elif action == 'delete':
if self.manager.storage.delete(notebook_id):
self.finish("OK");
else:
raise web.HTTPError(404, "Impossible to delete: %s" % notebook_id);
# Preview a notebook
elif action == 'preview':
self.finish(self.manager.storage.preview(notebook_id))
# Fetch a notebook
elif action == 'fetch':
dest = unquote(self.get_argument('dest'))
if not dest.endswith('.ipynb'):
dest += '.ipynb'
url = quote(self.manager.storage.fetch(notebook_id, dest));
self.redirect(ujoin(self.base_url, 'notebooks', url))
else:
self.finish("%s is not a valid action!" % action);
except Exception as e:
self.log.error("Error happen when do %s on %s" % (action, notebook_id))
self.log.error(str(e));
raise web.HTTPError(500, "Error happen when do %s on %s" % (action, notebook_id));
def load_jupyter_server_extension(nbapp):
"""Load and initialise the server extension."""
logger = ConfiguratorLogger(nbapp.log)
logger.debug('Loading {}'.format(__version__))
webapp = nbapp.web_app
# ensure our template gets into search path
templates_dir = os.path.join(os.path.dirname(__file__), 'templates')
logger.debug(' Editing templates path to add {}'.format(templates_dir))
rootloader = webapp.settings['jinja2_env'].loader
for loader in getattr(rootloader, 'loaders', [rootloader]):
if hasattr(loader, 'searchpath') and \
templates_dir not in loader.searchpath:
loader.searchpath.append(templates_dir)
base_url = webapp.settings['base_url']
# make sure our static files are available
static_files_path = os.path.normpath(os.path.join(
os.path.dirname(__file__), 'static'))
logger.debug(
' Editing nbextensions path to add {}'.format(static_files_path))
if static_files_path not in webapp.settings['nbextensions_path']:
webapp.settings['nbextensions_path'].append(static_files_path)
# add our new custom handlers
logger.debug(' Adding new handlers')
new_handlers = [(ujoin(base_url, '/nbextensions/' + u), h) for u, h in [
(r"?", NBExtensionHandlerPage),
(r"nbextensions_configurator/list$", NBExtensionHandlerJSON),
(r"nbextensions_configurator/rendermd/(.*)", RenderExtensionHandler),
]]
webapp.add_handlers(".*$", new_handlers)
logger.info('enabled {}'.format(__version__))
def load_jupyter_server_extension(nbapp):
webapp = nbapp.web_app
base_url = webapp.settings['base_url']
zsd = find_zotero_styles_dir()
if zsd:
webapp.add_handlers(".*$", [
(ujoin(base_url, r"/cite2c/styles/?"), ListStylesHandler,
{'path': zsd}),
(ujoin(base_url, r"/cite2c/styles/(.+)"), StaticFileHandler,
{'path': zsd}),
])
else:
nbapp.log.warning('Could not find Zotero citation styles directory.')
webapp.add_handlers(".*$", zotero_oauth.handlers(base_url))
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
windows = sys.platform.startswith('win')
webapp = nbapp.web_app
webapp.settings['example_manager'] = Examples(parent=nbapp)
base_url = webapp.settings['base_url']
install_nbextension(static, destination='nbexamples', symlink=not windows,
user=True)
cfgm = nbapp.config_manager
cfgm.update('tree', {
'load_extensions': {
'nbexamples/main': True,
}
})
cfgm.update('notebook', {
'load_extensions': {
'nbexamples/submit-example-button': True,
}
})
ExampleActionHandler.base_url = base_url # used to redirect after fetch
webapp.add_handlers(".*$", [
(ujoin(base_url, pat), handler)
for pat, handler in default_handlers
])
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
c = Config()
c.FormgradeApp.authenticator_class = 'notebookauth.NotebookAuth'
c.BaseAuth.connect_ip = nbapp.ip
c.BaseAuth.connect_port = nbapp.port
c.BaseAuth.url_prefix = '/formgrader'
c.NotebookAuth.notebook_base_url = nbapp.base_url
c.NotebookAuth.notebook_url_prefix = "instructor"
c.NbGrader.log_level = nbapp.log_level
c.NbGrader.course_directory = os.path.join(os.getcwd(), "instructor")
formgrader = FormgradeApp(parent=nbapp)
formgrader.update_config(c)
super(FormgradeApp, formgrader).initialize([])
formgrader.init_tornado_settings()
formgrader.init_handlers()
# update handlers
webapp = nbapp.web_app
base_url = webapp.settings["base_url"]
handlers = []
for handler in formgrader.handlers:
handler = list(handler)
handler[0] = ujoin(base_url, handler[0])
handlers.append(tuple(handler))
webapp.add_handlers(".*$", handlers)
# update settings
formgrader.tornado_settings['nbgrader_mathjax_url'] = webapp.settings['mathjax_url']
formgrader.tornado_settings['log_function'] = webapp.settings['log_function']
webapp.settings.update(formgrader.tornado_settings)
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
windows = sys.platform.startswith('win')
webapp = nbapp.web_app
webapp.settings['shared_manager'] = SharedManager(parent=nbapp)
base_url = webapp.settings['base_url']
install_nbextension(static, destination='nbshared', symlink=not windows, user=True)
# cfgm = nbapp.config_manager
# cfgm.update('tree', {
# 'load_extensions': {
# 'nbexamples/main': True,
# }
# })
# cfgm.update('notebook', {
# 'load_extensions': {
# 'nbexamples/submit-example-button': True,
# }
# })
webapp.add_handlers(".*$", [
(ujoin(base_url, pat), handler)
for pat, handler in default_handlers
])
def add_lab_handlers(self, webapp):
"""Add the lab-specific handlers to the tornado app."""
base_url = webapp.settings['base_url']
webapp.add_handlers(".*$",
[(ujoin(base_url, h[0]),) + h[1:] for h in default_handlers])
extension_prefix = ujoin(base_url, EXTENSION_PREFIX)
labextension_handler = (
r"%s/(.*)" % extension_prefix, FileFindHandler, {
'path': jupyter_path('labextensions'),
'no_cache_paths': ['/'], # don't cache anything in labbextensions
}
)
webapp.add_handlers(".*$", [labextension_handler])
base_dir = os.path.realpath(os.path.join(HERE, '..'))
dev_mode = os.path.exists(os.path.join(base_dir, '.git'))
if dev_mode:
self.log.info(DEV_NOTE_NPM)
def get(self):
self.write(self.render_template('lab.html',
static_prefix=ujoin(self.application.settings['base_url'], PREFIX),
page_title='Pre-Alpha Jupyter Lab Demo',
terminals_available=self.settings['terminals_available'],
mathjax_url=self.mathjax_url,
mathjax_config='TeX-AMS_HTML-full,Safe',
#mathjax_config=self.mathjax_config # for the next release of the notebook
))
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
webapp = nbapp.web_app
webapp.settings['assignment_list_manager'] = AssignmentList(parent=nbapp)
base_url = webapp.settings['base_url']
webapp.add_handlers(".*$", [
(ujoin(base_url, pat), handler)
for pat, handler in default_handlers
])
def load_jupyter_server_extension(nbapp):
base_dir = os.path.realpath(os.path.join(HERE, '..'))
dev_mode = os.path.exists(os.path.join(base_dir, '.git'))
if dev_mode:
nbapp.log.info(DEV_NOTE_NPM)
nbapp.log.info('JupyterLab alpha preview extension loaded from %s'%HERE)
webapp = nbapp.web_app
base_url = webapp.settings['base_url']
webapp.add_handlers(".*$", [(ujoin(base_url, h[0]),) + h[1:] for h in default_handlers])
def initialize(webapp, notebook_dir, connection_url):
shell = os.environ.get('SHELL') or 'sh'
terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(
shell_command=[shell],
extra_env={'JUPYTER_SERVER_ROOT': notebook_dir,
'JUPYTER_SERVER_URL': connection_url,
},
)
terminal_manager.log = app_log
base_url = webapp.settings['base_url']
handlers = [
(ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
(ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
{'term_manager': terminal_manager}),
(ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
(ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
]
webapp.add_handlers(".*$", handlers)
def _validate(self, data, base_url, page_url, workspaces_url):
workspace = json.load(data)
if 'data' not in workspace:
raise Exception('The `data` field is missing.')
if 'metadata' not in workspace:
raise Exception('The `metadata` field is missing.')
if 'id' not in workspace['metadata']:
raise Exception('The `id` field is missing in `metadata`.')
id = workspace['metadata']['id']
if id != ujoin(base_url, page_url) and not id.startswith(ujoin(base_url, workspaces_url)):
error = '%s does not match page_url or start with workspaces_url.'
raise Exception(error % id)
return workspace
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
nbapp.log.info("Loading the validate_assignment nbgrader serverextension")
webapp = nbapp.web_app
base_url = webapp.settings['base_url']
webapp.settings['notebook_dir'] = nbapp.notebook_dir
webapp.add_handlers(".*$", [
(ujoin(base_url, pat), handler)
for pat, handler in default_handlers
])
def get(self):
static_prefix = ujoin(self.base_url, PREFIX)
labextensions = self.application.labextensions
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']
bundles = [ujoin(static_prefix, name + '.bundle.js') for name in
['loader', 'main', 'extensions']]
entries = [data['extensions']['entry']]
# Gather the lab extension files and entry points.
for name in labextensions:
data = get_labextension_manifest_data_by_name(name)
if data is None:
self.log.warn('Could not locate extension: ' + name)
continue
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
))
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
))
def load_jupyter_server_extension(nbapp):
"""Load the nbserver"""
webapp = nbapp.web_app
webapp.settings['example_manager'] = Examples(parent=nbapp)
base_url = webapp.settings['base_url']
ExampleActionHandler.base_url = base_url # used to redirect after fetch
webapp.add_handlers(".*$", [
(ujoin(base_url, pat), handler)
for pat, handler in default_handlers
])
def load_jupyter_server_extension(nbapp):
"""Load the nbserver extension"""
webapp = nbapp.web_app
webapp.settings['env_manager'] = EnvManager(parent=nbapp)
base_url = webapp.settings['base_url']
webapp.add_handlers(".*$", [
(ujoin(base_url, NS, pat), handler)
for pat, handler in default_handlers
])
nbapp.log.info("[nb_conda] enabled")
def add_handlers(web_app, labextensions):
"""Add the appropriate handlers to the web app.
"""
base_url = web_app.settings['base_url']
prefix = ujoin(base_url, PREFIX)
extension_prefix = ujoin(base_url, EXTENSION_PREFIX)
handlers = [
(prefix + r'/?', LabHandler, {
'labextensions': labextensions,
'extension_prefix': extension_prefix
}),
(prefix + r"/(.*)", FileFindHandler, {
'path': BUILT_FILES
}),
(extension_prefix + r"/(.*)", FileFindHandler, {
'path': jupyter_path('labextensions'),
'no_cache_paths': ['/'], # don't cache anything in labextensions
})
]
web_app.add_handlers(".*$", handlers)
def initialize(webapp, notebook_dir, connection_url, settings):
default_shell = which('sh')
if not default_shell and os.name == 'nt':
default_shell = 'powershell.exe'
shell = settings.get('shell_command',
[os.environ.get('SHELL') or default_shell]
)
terminal_manager = webapp.settings['terminal_manager'] = NamedTermManager(
shell_command=shell,
extra_env={'JUPYTER_SERVER_ROOT': notebook_dir,
'JUPYTER_SERVER_URL': connection_url,
},
)
terminal_manager.log = app_log
base_url = webapp.settings['base_url']
handlers = [
(ujoin(base_url, r"/terminals/(\w+)"), TerminalHandler),
(ujoin(base_url, r"/terminals/websocket/(\w+)"), TermSocket,
{'term_manager': terminal_manager}),
(ujoin(base_url, r"/api/terminals"), api_handlers.TerminalRootHandler),
(ujoin(base_url, r"/api/terminals/(\w+)"), api_handlers.TerminalHandler),
]
webapp.add_handlers(".*$", handlers)
def initialize_webapp(self, config, webapp):
base_url = webapp.settings['base_url']
webapp.ktile_config_manager = KtileConfigManager(
self.default_cache)
webapp.add_handlers('.*$', [
# kernel_name
(ujoin(base_url, r'/ktile/([^/]*)'),
KtileHandler,
dict(ktile_config_manager=webapp.ktile_config_manager)),
# kernel_name, layer_name
(ujoin(base_url, r'/ktile/([^/]*)/([^/]*)'),
KtileLayerHandler,
dict(ktile_config_manager=webapp.ktile_config_manager)),
# kernel_name, layer_name, x, y, z, extension
(ujoin(base_url,
r'/ktile/([^/]*)/([^/]*)/([^/]*)/([^/]*)/([^/\.]*)\.(.*)'),
KtileTileHandler,
dict(ktile_config_manager=webapp.ktile_config_manager)),
])
def init_webapp(self):
"""initialize tornado webapp and httpserver.
"""
super(ExampleApp, self).init_webapp()
wsettings = self.web_app.settings
base_url = wsettings['base_url']
settings_path = ujoin(
base_url, default_settings_path + '(?P<section_name>[\w.-]+)'
)
wsettings.setdefault('page_config_data', dict())
wsettings['page_config_data']['token'] = self.token
default_handlers = [
(ujoin(base_url, '/example?'), ExampleHandler),
(ujoin(base_url, '/example/(.*)'), FileFindHandler,
{'path': 'build'}),
((settings_path, SettingsHandler, {
'schemas_dir': os.path.join(HERE, 'schemas'),
'settings_dir': ''
})
)
]
self.web_app.add_handlers(".*$", default_handlers)
def get(self, path="/"):
config = self.nteract_config
settings_dir = config.settings_dir
assets_dir = config.assets_dir
base_url = self.settings['base_url']
url = ujoin(base_url, config.page_url, '/static/')
# Handle page config data.
page_config = dict()
page_config.update(self.settings.get('page_config_data', {}))
page_config.setdefault('appName', config.name)
page_config.setdefault('appVersion', config.version)
mathjax_config = self.settings.get('mathjax_config', 'TeX-AMS_HTML-full,Safe')
asset_url = config.asset_url
if asset_url is "":
asset_url = base_url
# Ensure there's a trailing slash
if not asset_url.endswith('/'):
asset_url = asset_url + '/'
filename = path.split("/")[-1]
if filename:
page_title = '{filename} - nteract'.format(filename=filename)
else:
page_title = 'nteract'
bookstore_settings = self.settings.get("bookstore", {})
bookstore_settings['enabled'] = all(value for value in bookstore_settings.get("validation", {}).values())
config = dict(
ga_code=config.ga_code,
asset_url=asset_url,
page_title=page_title,
mathjax_url=self.mathjax_url,
mathjax_config=mathjax_config,
page_config=page_config,
public_url=url,
contents_path=path,
page=self.page,
bookstore=bookstore_settings
)
self.write(self.render_template('index.html', **config))
def setup_handlers(nbapp):
route_pattern = ujoin(nbapp.settings['base_url'], '/wifi/scan')
nbapp.add_handlers('.*', [(route_pattern, WifiHandler)])
def setup_handlers(web_app):
web_app.add_handlers('.*', [
(ujoin(web_app.settings['base_url'], 'novnc/(.*)'), NoVNCHandler,
dict(state={})),
(ujoin(web_app.settings['base_url'], 'novnc'), AddSlashHandler)
])
def get(self):
self.redirect(
ujoin(self.base_url, 'simplest/tree')
)
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Delay imports to speed up jlpmapp
from json import dumps
from jupyterlab_server import add_handlers
from notebook.utils import url_path_join as ujoin, url_escape
from notebook._version import version_info
from tornado.ioloop import IOLoop
from markupsafe import Markup
from .handlers.build_handler import build_path, Builder, BuildHandler
from .handlers.extension_manager_handler import (
extensions_handler_path, ExtensionManager, ExtensionHandler
)
from .handlers.error_handler import ErrorHandler
from .commands import (
DEV_DIR, HERE, ensure_app, ensure_core, ensure_dev, watch,
watch_dev, get_app_dir
)
web_app = nbapp.web_app
logger = nbapp.log
base_url = nbapp.base_url
# Handle the app_dir
app_dir = getattr(nbapp, 'app_dir', get_app_dir())
# Check for core mode.
core_mode = False
if getattr(nbapp, 'core_mode', False) or app_dir.startswith(HERE):
app_dir = HERE
core_mode = True
logger.info('Running JupyterLab in core mode')
# Check for dev mode.
dev_mode = False
if getattr(nbapp, 'dev_mode', False) or app_dir.startswith(DEV_DIR):
app_dir = DEV_DIR
dev_mode = True
logger.info('Running JupyterLab in dev mode')
# Set the value on nbapp so it will get picked up in load_config
nbapp.app_dir = app_dir
config = load_config(nbapp)
config.app_name = 'JupyterLab'
config.app_namespace = 'jupyterlab'
config.page_url = '/lab'
config.cache_files = True
# Check for watch.
watch_mode = getattr(nbapp, 'watch', False)
if watch_mode and core_mode:
logger.warn('Cannot watch in core mode, did you mean --dev-mode?')
watch_mode = False
if core_mode and dev_mode:
logger.warn('Conflicting modes, choosing dev_mode over core_mode')
core_mode = False
page_config = web_app.settings.setdefault('page_config_data', dict())
page_config['buildAvailable'] = not core_mode and not dev_mode
page_config['buildCheck'] = not core_mode and not dev_mode
page_config['devMode'] = dev_mode
page_config['token'] = nbapp.token
# Export the version info tuple to a JSON array. This gets printed
# inside double quote marks, so we render it to a JSON string of the
# JSON data (so that we can call JSON.parse on the frontend on it).
# We also have to wrap it in `Markup` so that it isn't escaped
# by Jinja. Otherwise, if the version has string parts these will be
# escaped and then will have to be unescaped on the frontend.
page_config['notebookVersion'] = Markup(dumps(dumps(version_info))[1:-1])
if nbapp.file_to_run and type(nbapp).__name__ == "LabApp":
relpath = os.path.relpath(nbapp.file_to_run, nbapp.notebook_dir)
uri = url_escape(ujoin('/lab/tree', *relpath.split(os.sep)))
nbapp.default_url = uri
nbapp.file_to_run = ''
# Print messages.
logger.info('JupyterLab extension loaded from %s' % HERE)
logger.info('JupyterLab application directory is %s' % app_dir)
build_url = ujoin(base_url, build_path)
builder = Builder(logger, core_mode, app_dir)
build_handler = (build_url, BuildHandler, {'builder': builder})
handlers = [build_handler]
errored = False
if core_mode:
logger.info(CORE_NOTE.strip())
ensure_core(logger)
elif dev_mode:
if not watch_mode:
ensure_dev(logger)
logger.info(DEV_NOTE)
# Make sure the app dir exists.
else:
msgs = ensure_app(app_dir)
if msgs:
[logger.error(msg) for msg in msgs]
handler = (ujoin(base_url, '/lab'), ErrorHandler, { 'messages': msgs })
handlers.append(handler)
errored = True
if watch_mode:
logger.info('Starting JupyterLab watch mode...')
# Set the ioloop in case the watch fails.
nbapp.ioloop = IOLoop.current()
if dev_mode:
watch_dev(logger)
else:
watch(app_dir, logger)
page_config['buildAvailable'] = False
config.cache_files = False
if not core_mode and not errored:
ext_url = ujoin(base_url, extensions_handler_path)
ext_manager = ExtensionManager(logger, app_dir)
ext_handler = (ext_url, ExtensionHandler, {'manager': ext_manager})
handlers.append(ext_handler)
# Must add before the root server handlers to avoid shadowing.
web_app.add_handlers('.*$', handlers)
# Add the root handlers if we have not errored.
if not errored:
add_handlers(web_app, config)
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Delay imports to speed up jlpmapp
from json import dumps
from jupyterlab_server import add_handlers
from notebook.utils import url_path_join as ujoin, url_escape
from notebook._version import version_info
from tornado.ioloop import IOLoop
from markupsafe import Markup
from .handlers.build_handler import build_path, Builder, BuildHandler
from .handlers.extension_manager_handler import (extensions_handler_path,
ExtensionManager,
ExtensionHandler)
from .handlers.error_handler import ErrorHandler
from .commands import (DEV_DIR, HERE, ensure_app, ensure_core, ensure_dev,
watch, watch_dev, get_app_dir, AppOptions)
web_app = nbapp.web_app
logger = nbapp.log
base_url = nbapp.base_url
# Handle the app_dir
app_dir = getattr(nbapp, 'app_dir', get_app_dir())
build_handler_options = AppOptions(logger=logger, app_dir=app_dir)
# Check for core mode.
core_mode = False
if getattr(nbapp, 'core_mode', False) or app_dir.startswith(HERE):
app_dir = HERE
core_mode = True
logger.info('Running JupyterLab in core mode')
# Check for dev mode.
dev_mode = False
if getattr(nbapp, 'dev_mode', False) or app_dir.startswith(DEV_DIR):
app_dir = DEV_DIR
dev_mode = True
logger.info('Running JupyterLab in dev mode')
# Set the value on nbapp so it will get picked up in load_config
nbapp.app_dir = app_dir
config = load_config(nbapp)
config.app_name = 'JupyterLab'
config.app_namespace = 'jupyterlab'
config.app_url = '/lab'
config.cache_files = True
# Check for watch.
watch_mode = getattr(nbapp, 'watch', False)
if watch_mode and core_mode:
logger.warn('Cannot watch in core mode, did you mean --dev-mode?')
watch_mode = False
if core_mode and dev_mode:
logger.warn('Conflicting modes, choosing dev_mode over core_mode')
core_mode = False
page_config = web_app.settings.setdefault('page_config_data', dict())
page_config.setdefault('buildAvailable', not core_mode and not dev_mode)
page_config.setdefault('buildCheck', not core_mode and not dev_mode)
page_config['devMode'] = dev_mode
page_config['token'] = nbapp.token
# Handle quit button with support for Notebook < 5.6
page_config['quitButton'] = getattr(nbapp, 'quit_button', False)
# Client-side code assumes notebookVersion is a JSON-encoded string
page_config['notebookVersion'] = dumps(version_info)
page_config['exposeAppInBrowser'] = getattr(nbapp, 'expose_app_in_browser',
False)
if nbapp.file_to_run and type(nbapp).__name__ == "LabApp":
relpath = os.path.relpath(nbapp.file_to_run, nbapp.notebook_dir)
uri = url_escape(ujoin('/lab/tree', *relpath.split(os.sep)))
nbapp.default_url = uri
nbapp.file_to_run = ''
# Print messages.
logger.info('JupyterLab extension loaded from %s' % HERE)
logger.info('JupyterLab application directory is %s' % app_dir)
build_url = ujoin(base_url, build_path)
builder = Builder(core_mode, app_options=build_handler_options)
build_handler = (build_url, BuildHandler, {'builder': builder})
handlers = [build_handler]
errored = False
if core_mode:
logger.info(CORE_NOTE.strip())
ensure_core(logger)
elif dev_mode:
if not watch_mode:
ensure_dev(logger)
logger.info(DEV_NOTE)
# Make sure the app dir exists.
elif not watch_mode:
msgs = ensure_app(app_dir)
if msgs:
[logger.error(msg) for msg in msgs]
handler = (ujoin(base_url, '/lab'), ErrorHandler, {
'messages': msgs
})
handlers.append(handler)
errored = True
if watch_mode:
logger.info('Starting JupyterLab watch mode...')
# Set the ioloop in case the watch fails.
nbapp.ioloop = IOLoop.current()
if dev_mode:
watch_dev(logger)
else:
watch(app_options=build_handler_options)
page_config['buildAvailable'] = False
config.cache_files = False
if not core_mode and not errored:
ext_url = ujoin(base_url, extensions_handler_path)
ext_manager = ExtensionManager(app_options=build_handler_options)
ext_handler = (ext_url, ExtensionHandler, {'manager': ext_manager})
handlers.append(ext_handler)
# Must add before the root server handlers to avoid shadowing.
web_app.add_handlers('.*$', handlers)
# If running under JupyterHub, add more metadata.
if hasattr(nbapp, 'hub_prefix'):
page_config['hubPrefix'] = nbapp.hub_prefix
page_config['hubHost'] = nbapp.hub_host
page_config['hubUser'] = nbapp.user
page_config['shareUrl'] = ujoin(nbapp.hub_prefix, 'user-redirect')
# Assume the server_name property indicates running JupyterHub 1.0.
if hasattr(nbapp, 'server_name'):
page_config['hubServerName'] = nbapp.server_name
api_token = os.getenv('JUPYTERHUB_API_TOKEN', '')
page_config['token'] = api_token
# Add the root handlers if we have not errored.
if not errored:
add_handlers(web_app, config)
def add_handlers(web_app, config):
"""Add the appropriate handlers to the web app.
"""
# Normalize directories.
for name in config.trait_names():
if not name.endswith('_dir'):
continue
value = getattr(config, name)
setattr(config, name, value.replace(os.sep, '/'))
# Set up the main page handler.
base_url = web_app.settings['base_url']
lab_url = ujoin(base_url, config.page_url, r'/?')
tree_url = ujoin(base_url, config.tree_url, r'/.+')
handlers = [
(lab_url, LabHandler, {'lab_config': config}),
(tree_url, LabHandler, {'lab_config': config})
]
# Cache all or none of the files depending on the `cache_files` setting.
no_cache_paths = [] if config.cache_files else ['/']
# Handle local static assets.
if config.static_dir:
config.public_url = ujoin(base_url, default_public_url)
handlers.append((config.public_url + '(.*)', FileFindHandler, {
'path': config.static_dir,
'no_cache_paths': no_cache_paths
}))
# Handle local settings.
if config.schemas_dir:
config.settings_url = ujoin(base_url, default_settings_url)
settings_path = config.settings_url + '(?P<section_name>.+)'
handlers.append((settings_path, SettingsHandler, {
'app_settings_dir': config.app_settings_dir,
'schemas_dir': config.schemas_dir,
'settings_dir': config.user_settings_dir
}))
# Handle saved workspaces.
if config.workspaces_dir:
# Handle JupyterLab client URLs that include workspaces.
config.workspaces_url = ujoin(base_url, default_workspaces_url)
workspaces_path = ujoin(base_url, config.workspaces_url, r'/.+')
handlers.append((workspaces_path, LabHandler, {'lab_config': config}))
# Handle API requests for workspaces.
config.workspaces_api_url = ujoin(base_url, default_workspaces_api_url)
workspaces_api_path = config.workspaces_api_url + '(?P<space_name>.+)'
handlers.append((workspaces_api_path, WorkspacesHandler, {
'workspaces_url': config.workspaces_url,
'path': config.workspaces_dir
}))
# Handle local themes.
if config.themes_dir:
config.themes_url = ujoin(base_url, default_themes_url)
handlers.append((
ujoin(config.themes_url, '(.*)'),
ThemesHandler,
{
'themes_url': config.themes_url,
'path': config.themes_dir,
'no_cache_paths': no_cache_paths
}
))
# Let the lab handler act as the fallthrough option instead of a 404.
handlers.append((
ujoin(base_url, config.page_url, r'/?.*'),
NotFoundHandler,
{'lab_config': config}
))
web_app.add_handlers('.*$', handlers)
def setup_handlers(web_app):
web_app.add_handlers('.*', [
(ujoin(web_app.settings['base_url'], 'dlstudio/(.*)'),
DLStudioProxyHandler, dict(state={})),
(ujoin(web_app.settings['base_url'], 'dlstudio'), AddSlashHandler)
])
def get_configurable_nbextensions(nbextension_dirs=None,
exclude_dirs=['mathjax'],
log=None):
"""Build a list of configurable nbextensions based on YAML descriptor files
descriptor files must:
- be located under one of nbextension_dirs
- have the extension '.yaml'
- containing (at minimum) the following keys:
- Type: must be 'IPython Notebook Extension' or
'Jupyter Notebook Extension'
- Main: url of the nbextension's main javascript file, relative to yaml
"""
if nbextension_dirs is None:
nbextension_dirs = get_nbextensions_path()
extension_list = []
required_keys = {'Type', 'Main'}
valid_types = {'IPython Notebook Extension', 'Jupyter Notebook Extension'}
do_log = (log is not None)
# Traverse through nbextension subdirectories to find all yaml files
for root_nbext_dir in nbextension_dirs:
if do_log:
log.debug(
'Looking for nbextension yaml descriptor files in {}'.format(
root_nbext_dir))
for direct, dirs, files in os.walk(root_nbext_dir, followlinks=True):
# filter to exclude directories
dirs[:] = [d for d in dirs if d not in exclude_dirs]
for filename in files:
if not filename.endswith('.yaml'):
continue
yaml_path = os.path.join(direct, filename)
yaml_relpath = os.path.relpath(yaml_path, root_nbext_dir)
with open(yaml_path, 'r') as stream:
try:
extension = yaml.load(stream, Loader=SafeLoader)
except ScannerError:
if do_log:
log.warning('Failed to load yaml file {}'.format(
yaml_relpath))
continue
if not isinstance(extension, dict):
continue
if any(key not in extension for key in required_keys):
continue
if extension['Type'].strip() not in valid_types:
continue
extension.setdefault('Compatibility', '?.x')
extension.setdefault('Section', 'notebook')
# generate relative URLs within the nbextensions namespace,
# from urls relative to the yaml file
yaml_dir_url = path2url(os.path.dirname(yaml_relpath))
key_map = [
('Link', 'readme'),
('Icon', 'icon'),
('Main', 'require'),
]
for from_key, to_key in key_map:
# str needed in python 3, otherwise it ends up bytes
from_val = str(extension.get(from_key, ''))
if not from_val:
continue
if absolute_url_re.match(from_val):
extension[to_key] = from_val
else:
extension[to_key] = posixpath.normpath(
ujoin(yaml_dir_url, from_val))
# strip .js extension in require path
extension['require'] = os.path.splitext(
extension['require'])[0]
if do_log:
log.debug('Found nbextension {!r} in {}'.format(
extension.setdefault('Name', extension['require']),
yaml_relpath,
))
extension_list.append(extension)
return extension_list
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Print messages.
here = os.path.dirname(__file__)
nbapp.log.info('JupyterLab alpha preview extension loaded from %s' % here)
app_dir = get_app_dir()
if hasattr(nbapp, 'app_dir'):
app_dir = get_app_dir(nbapp.app_dir)
web_app = nbapp.web_app
config = LabConfig()
config.assets_dir = os.path.join(app_dir, 'static')
config.settings_dir = os.path.join(app_dir, 'settings')
config.page_title = 'JupyterLab Alpha Preview'
config.page_url = '/lab'
config.dev_mode = False
# Check for core mode.
core_mode = ''
if hasattr(nbapp, 'core_mode'):
core_mode = nbapp.core_mode
# Check for an app dir that is local.
if app_dir == here or app_dir == os.path.join(here, 'build'):
core_mode = True
config.settings_dir = ''
# Run core mode if explicit or there is no static dir and no
# installed extensions.
installed = list_extensions(app_dir)
fallback = not installed and not os.path.exists(config.assets_dir)
web_app.settings.setdefault('page_config_data', dict())
web_app.settings['page_config_data']['token'] = nbapp.token
if not core_mode:
build_needed, msg = should_build(app_dir)
if build_needed:
nbapp.log.warn('Build required: %s' % msg)
web_app.settings['page_config_data']['buildRequired'] = msg
if core_mode or fallback:
config.assets_dir = os.path.join(here, 'build')
if not os.path.exists(config.assets_dir):
msg = 'Static assets not built, please see CONTRIBUTING.md'
nbapp.log.error(msg)
else:
sentinel = os.path.join(here, 'build', 'release_data.json')
config.dev_mode = not os.path.exists(sentinel)
if config.dev_mode:
nbapp.log.info(DEV_NOTE_NPM)
elif core_mode or fallback:
nbapp.log.info(CORE_NOTE.strip())
add_handlers(web_app, config)
user_settings_dir = get_user_settings_dir()
if core_mode or fallback:
schemas_dir = os.path.join(here, 'schemas')
else:
schemas_dir = os.path.join(app_dir, 'schemas')
base_url = web_app.settings['base_url']
settings_url = ujoin(base_url, settings_path)
settings_handler = (settings_url, SettingsHandler, {
'schemas_dir': schemas_dir,
'settings_dir': user_settings_dir
})
nbapp.log.error('shemas_dir: %s' % schemas_dir)
web_app.add_handlers(".*$", [settings_handler])
def command(verb, *paths):
resp = request(verb, ujoin(info['url'], *paths))
resp.raise_for_status()
return resp
def rewrite(x):
pat = ujoin(webapp.settings['base_url'], x[0].lstrip('/'))
return (pat, ) + x[1:]
def setup_handlers(web_app):
web_app.add_handlers('.*', [
(ujoin(web_app.settings['base_url'],
'vscode/(.*)'), VSCodeProxyHandler, dict(state={})),
(ujoin(web_app.settings['base_url'], 'vscode'), AddSlashHandler),
])
def handlers(base_url):
return [
(ujoin(base_url, r"/cite2c/zotero_oauth"), ZoteroOauthHandler),
(ujoin(base_url,
r"/cite2c/zotero_oauth_cb"), ZoteroOauthCallbackHandler),
]
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Delay imports to speed up jlpmapp
from jupyterlab_launcher import add_handlers, LabConfig
from notebook.utils import url_path_join as ujoin, url_escape
from tornado.ioloop import IOLoop
from .build_handler import build_path, Builder, BuildHandler
from .commands import (get_app_dir, get_user_settings_dir, watch,
ensure_dev, watch_dev, pjoin, DEV_DIR, HERE,
get_app_info, ensure_core, get_workspaces_dir)
web_app = nbapp.web_app
logger = nbapp.log
config = LabConfig()
app_dir = getattr(nbapp, 'app_dir', get_app_dir())
user_settings_dir = getattr(nbapp, 'user_settings_dir',
get_user_settings_dir())
workspaces_dir = getattr(nbapp, 'workspaces_dir', get_workspaces_dir())
# Print messages.
logger.info('JupyterLab beta preview extension loaded from %s' % HERE)
logger.info('JupyterLab application directory is %s' % app_dir)
config.app_name = 'JupyterLab Beta'
config.app_namespace = 'jupyterlab'
config.page_url = '/lab'
config.cache_files = True
# Check for core mode.
core_mode = False
if getattr(nbapp, 'core_mode', False) or app_dir.startswith(HERE):
core_mode = True
logger.info('Running JupyterLab in core mode')
# Check for dev mode.
dev_mode = False
if getattr(nbapp, 'dev_mode', False) or app_dir.startswith(DEV_DIR):
dev_mode = True
logger.info('Running JupyterLab in dev mode')
# Check for watch.
watch_mode = getattr(nbapp, 'watch', False)
if watch_mode and core_mode:
logger.warn('Cannot watch in core mode, did you mean --dev-mode?')
watch_mode = False
if core_mode and dev_mode:
logger.warn('Conflicting modes, choosing dev_mode over core_mode')
core_mode = False
page_config = web_app.settings.setdefault('page_config_data', dict())
page_config['buildAvailable'] = not core_mode and not dev_mode
page_config['buildCheck'] = not core_mode and not dev_mode
page_config['token'] = nbapp.token
page_config['devMode'] = dev_mode
if nbapp.file_to_run:
relpath = os.path.relpath(nbapp.file_to_run, nbapp.notebook_dir)
uri = url_escape(ujoin('/lab/tree', *relpath.split(os.sep)))
nbapp.default_url = uri
nbapp.file_to_run = ''
if core_mode:
app_dir = HERE
logger.info(CORE_NOTE.strip())
ensure_core(logger)
elif dev_mode:
app_dir = DEV_DIR
ensure_dev(logger)
if not watch_mode:
logger.info(DEV_NOTE)
config.app_settings_dir = pjoin(app_dir, 'settings')
config.schemas_dir = pjoin(app_dir, 'schemas')
config.themes_dir = pjoin(app_dir, 'themes')
config.workspaces_dir = workspaces_dir
info = get_app_info(app_dir)
config.app_version = info['version']
public_url = info['publicUrl']
if public_url:
config.public_url = public_url
else:
config.static_dir = pjoin(app_dir, 'static')
config.user_settings_dir = user_settings_dir
# The templates end up in the built static directory.
config.templates_dir = pjoin(app_dir, 'static')
if watch_mode:
logger.info('Starting JupyterLab watch mode...')
# Set the ioloop in case the watch fails.
nbapp.ioloop = IOLoop.current()
if dev_mode:
watch_dev(logger)
else:
watch(app_dir, logger)
page_config['buildAvailable'] = False
config.cache_files = False
base_url = web_app.settings['base_url']
build_url = ujoin(base_url, build_path)
builder = Builder(logger, core_mode, app_dir)
build_handler = (build_url, BuildHandler, {'builder': builder})
# Must add before the launcher handlers to avoid shadowing.
web_app.add_handlers('.*$', [build_handler])
add_handlers(web_app, config)
def get_configurable_nbextensions(nbextension_dirs,
exclude_dirs=('mathjax', ),
as_dict=False,
log=None):
"""Build a list of configurable nbextensions based on YAML descriptor files.
descriptor files must:
- be located under one of nbextension_dirs
- have the file extension '.yaml' or '.yml'
- contain (at minimum) the following keys:
- Type: must be 'IPython Notebook Extension' or
'Jupyter Notebook Extension'
- Main: relative url of the nbextension's main javascript file
"""
extension_dict = {}
required_keys = {'Type', 'Main'}
valid_types = {'IPython Notebook Extension', 'Jupyter Notebook Extension'}
# Traverse through nbextension subdirectories to find all yaml files
# However, don't check directories twice. See
# github.com/Jupyter-contrib/jupyter_nbextensions_configurator/issues/25
already_checked = set()
for root_nbext_dir in nbextension_dirs:
if root_nbext_dir in already_checked:
continue
else:
already_checked.add(root_nbext_dir)
if log:
log.debug(
'Looking for nbextension yaml descriptor files in {}'.format(
root_nbext_dir))
for direct, dirs, files in os.walk(root_nbext_dir, followlinks=True):
# filter to exclude directories
dirs[:] = [d for d in dirs if d not in exclude_dirs]
for filename in files:
if os.path.splitext(filename)[1] not in ['.yml', '.yaml']:
continue
yaml_path = os.path.join(direct, filename)
yaml_relpath = os.path.relpath(yaml_path, root_nbext_dir)
with open(yaml_path, 'r') as stream:
try:
extension = yaml.load(stream, Loader=SafeLoader)
except yaml.YAMLError:
if log:
log.warning('Failed to load yaml file {}'.format(
yaml_relpath))
continue
if not isinstance(extension, dict):
continue
if any(key not in extension for key in required_keys):
continue
if extension['Type'].strip() not in valid_types:
continue
extension.setdefault('Compatibility', '?.x')
extension.setdefault('Section', 'notebook')
# generate relative URLs within the nbextensions namespace,
# from urls relative to the yaml file
yaml_dir_url = path2url(os.path.dirname(yaml_relpath))
key_map = [
('Link', 'readme'),
('Icon', 'icon'),
('Main', 'require'),
]
for from_key, to_key in key_map:
# str needed in python 3, otherwise it ends up bytes
from_val = str(extension.get(from_key, ''))
if not from_val:
continue
if absolute_url_re.match(from_val):
extension[to_key] = from_val
else:
extension[to_key] = posixpath.normpath(
ujoin(yaml_dir_url, from_val))
# strip .js file extension in require path
require = extension['require'] = os.path.splitext(
extension['require'])[0]
extension.setdefault('Name', extension['require'])
if log:
if require in extension_dict:
msg = 'nbextension {!r} has duplicate listings'.format(
extension['require'])
msg += ' in both {!r} and {!r}'.format(
yaml_path, extension_dict[require]['yaml_path'])
log.warning(msg)
extension['duplicate'] = True
else:
log.debug('Found nbextension {!r} in {}'.format(
extension['Name'], yaml_relpath))
extension_dict[require] = {
'yaml_path': yaml_path,
'extension': extension
}
if as_dict:
return extension_dict
return [val['extension'] for val in extension_dict.values()]
def setup_handlers(web_app):
web_app.add_handlers(
'.*',
[(ujoin(web_app.settings['base_url'], 'openrefine/(.*)'),
OpenRefineProxyHandler, dict(state={'port': 3333})),
(ujoin(web_app.settings['base_url'], 'openrefine'), AddSlashHandler)])
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Delay imports to speed up jlpmapp
from json import dumps
from jupyterlab_launcher import add_handlers, LabConfig
from notebook.utils import url_path_join as ujoin, url_escape
from notebook._version import version_info
from tornado.ioloop import IOLoop
from markupsafe import Markup
from .build_handler import build_path, Builder, BuildHandler
from .demo_handler import demo_build_path, DemoBuilder, DemoHandler
from .tianchi_game_handler import tianchi_game_path, TianchiGameBuilder, TianchiGameHandler
from .tianchi_upload_handler import tianchi_upload_path, TianchiUploadBuilder, TianchiUploadHandler
from .tianchi_user_handler import tianchi_user_path, TianchiUserBuilder, TianchiUserHandler
from .tianchi_game_list_handler import tianchi_game_list_path, TianchiGameListBuilder, TianchiGameListHandler
from .progress_handler import progress_build_path, ProgressHandler, ProgressBuilder
from .notebook_proxy import notebook_proxy_path, NotebookProxyBuilder, NotebookProxyHandler
from .community_download_dataset_handler import community_dataset_download_path, CommunityDatasetDownloadBuilder, \
CommunityDatasetDownloadHandler
from .community_download_notebook_handler import community_notebook_download_path, CommunityNotebookDownloadBuilder, \
CommunityNotebookDownloadHandler
from .file_exists_handler import file_exists_path, FileExistBuilder, FileExistHandler
from .community_upload_notebook_handler import community_upload_notebook_path, CommunityNotebookUploadBuilder, CommunityNotebookUploadHandler
from .dsw.handlers import file_upload_path, FileUploadHanler, FileUploadBuilder
from jupyterlab.extension_manager_handler import (extensions_handler_path,
ExtensionManager,
ExtensionHandler)
from .commands import (get_app_dir, get_user_settings_dir, watch,
ensure_dev, watch_dev, pjoin, DEV_DIR, HERE,
get_app_info, ensure_core, get_workspaces_dir)
from .git_oper_handler import git_oper_path, GitOperBuilder, GitOperHandler
web_app = nbapp.web_app
logger = nbapp.log
config = LabConfig()
app_dir = getattr(nbapp, 'app_dir', get_app_dir())
user_settings_dir = getattr(nbapp, 'user_settings_dir',
get_user_settings_dir())
workspaces_dir = getattr(nbapp, 'workspaces_dir', get_workspaces_dir())
# Print messages.
logger.info('JupyterLab extension loaded from %s' % HERE)
logger.info('JupyterLab application directory is %s' % app_dir)
config.app_name = 'JupyterLab'
config.app_namespace = 'jupyterlab'
config.page_url = '/lab'
config.cache_files = True
# Check for core mode.
core_mode = False
if getattr(nbapp, 'core_mode', False) or app_dir.startswith(HERE):
core_mode = True
logger.info('Running JupyterLab in core mode')
# Check for dev mode.
dev_mode = False
if getattr(nbapp, 'dev_mode', False) or app_dir.startswith(DEV_DIR):
dev_mode = True
logger.info('Running JupyterLab in dev mode')
# Check for watch.
watch_mode = getattr(nbapp, 'watch', False)
if watch_mode and core_mode:
logger.warn('Cannot watch in core mode, did you mean --dev-mode?')
watch_mode = False
if core_mode and dev_mode:
logger.warn('Conflicting modes, choosing dev_mode over core_mode')
core_mode = False
page_config = web_app.settings.setdefault('page_config_data', dict())
page_config['buildAvailable'] = not core_mode and not dev_mode
page_config['buildCheck'] = not core_mode and not dev_mode
page_config['token'] = nbapp.token
page_config['devMode'] = dev_mode
# Export the version info tuple to a JSON array. This gets printed
# inside double quote marks, so we render it to a JSON string of the
# JSON data (so that we can call JSON.parse on the frontend on it).
# We also have to wrap it in `Markup` so that it isn't escaped
# by Jinja. Otherwise, if the version has string parts these will be
# escaped and then will have to be unescaped on the frontend.
page_config['notebookVersion'] = Markup(dumps(dumps(version_info))[1:-1])
if nbapp.file_to_run and type(nbapp).__name__ == "LabApp":
relpath = os.path.relpath(nbapp.file_to_run, nbapp.notebook_dir)
uri = url_escape(ujoin('/lab/tree', *relpath.split(os.sep)))
nbapp.default_url = uri
nbapp.file_to_run = ''
if core_mode:
app_dir = HERE
logger.info(CORE_NOTE.strip())
ensure_core(logger)
elif dev_mode:
app_dir = DEV_DIR
ensure_dev(logger)
if not watch_mode:
logger.info(DEV_NOTE)
config.app_settings_dir = pjoin(app_dir, 'settings')
config.schemas_dir = pjoin(app_dir, 'schemas')
config.themes_dir = pjoin(app_dir, 'themes')
config.workspaces_dir = workspaces_dir
info = get_app_info(app_dir)
config.app_version = info['version']
public_url = info['publicUrl']
if public_url:
config.public_url = public_url
else:
config.static_dir = app_dir
# logger.info('public_url is %s', public_url)
# config.static_dir = pjoin(app_dir, 'static')
# logger.info('config.static_dir is %s', config.static_dir)
# if dev_mode:
config.static_dir = pjoin(app_dir, 'static')
config.user_settings_dir = user_settings_dir
# The templates end up in the built static directory.
config.templates_dir = pjoin(app_dir, 'static')
if watch_mode:
logger.info('Starting JupyterLab watch mode...')
# Set the ioloop in case the watch fails.
nbapp.ioloop = IOLoop.current()
if dev_mode:
watch_dev(logger)
else:
watch(app_dir, logger)
page_config['buildAvailable'] = False
config.cache_files = False
base_url = web_app.settings['base_url']
build_url = ujoin(base_url, build_path)
builder = Builder(logger, core_mode, app_dir)
build_handler = (build_url, BuildHandler, {'builder': builder})
handlers = [build_handler]
demo_url = ujoin(base_url, demo_build_path)
demo_builder = DemoBuilder(logger, core_mode, app_dir)
demo_handler = (demo_url, DemoHandler, {'builder': demo_builder})
handlers.append(demo_handler)
progress_url = ujoin(base_url, progress_build_path)
progress_builder = ProgressBuilder(logger, core_mode, app_dir)
progress_handler = (progress_url, ProgressHandler, {
'builder': progress_builder
})
handlers.append(progress_handler)
# tianchi_download_url = ujoin(base_url, tianchi_download_path)
# tianchi_download_builder = TianchiDownloadBuilder(logger, core_mode, app_dir)
# tianchi_download_handler = (tianchi_download_url, TianchiDownloadHandler, {'builder': tianchi_download_builder})
# handlers.append(tianchi_download_handler)
tianchi_game_url = ujoin(base_url, tianchi_game_path)
tianchi_game_builder = TianchiGameBuilder(logger, core_mode, app_dir)
tianchi_game_handler = (tianchi_game_url, TianchiGameHandler, {
'builder': tianchi_game_builder
})
handlers.append(tianchi_game_handler)
tianchi_upload_url = ujoin(base_url, tianchi_upload_path)
tianchi_upload_builder = TianchiUploadBuilder(logger, core_mode, app_dir)
tianchi_upload_handler = (tianchi_upload_url, TianchiUploadHandler, {
'builder': tianchi_upload_builder
})
handlers.append(tianchi_upload_handler)
tianchi_user_url = ujoin(base_url, tianchi_user_path)
tianchi_user_builder = TianchiUserBuilder(logger, core_mode, app_dir)
tianchi_user_handler = (tianchi_user_url, TianchiUserHandler, {
'builder': tianchi_user_builder
})
handlers.append(tianchi_user_handler)
tianchi_game_list_url = ujoin(base_url, tianchi_game_list_path)
tianchi_game_list_builder = TianchiGameListBuilder(logger, core_mode,
app_dir)
tianchi_game_list_handler = (tianchi_game_list_url, TianchiGameListHandler,
{
'builder': tianchi_game_list_builder
})
handlers.append(tianchi_game_list_handler)
notebook_proxy_url = ujoin(base_url, notebook_proxy_path)
notebook_proxy_builder = NotebookProxyBuilder(logger, core_mode, app_dir)
notebook_proxy_handler = (notebook_proxy_url, NotebookProxyHandler, {
'builder': notebook_proxy_builder
})
handlers.append(notebook_proxy_handler)
community_dataset_download_url = ujoin(base_url,
community_dataset_download_path)
community_dataset_download_builder = CommunityDatasetDownloadBuilder(
logger, core_mode, app_dir)
community_dataset_download_handler = (
community_dataset_download_url, CommunityDatasetDownloadHandler, {
'builder': community_dataset_download_builder
})
handlers.append(community_dataset_download_handler)
community_notebook_download_url = ujoin(base_url,
community_notebook_download_path)
community_notebook_download_builder = CommunityNotebookDownloadBuilder(
logger, core_mode, app_dir)
community_notebook_download_handler = (
community_notebook_download_url, CommunityNotebookDownloadHandler, {
'builder': community_notebook_download_builder
})
handlers.append(community_notebook_download_handler)
file_exists_url = ujoin(base_url, file_exists_path)
file_exists_builder = FileExistBuilder(logger, core_mode, app_dir)
file_exists_handler = (file_exists_url, FileExistHandler, {
'builder': file_exists_builder
})
handlers.append(file_exists_handler)
community_upload_notebook_url = ujoin(base_url,
community_upload_notebook_path)
community_upload_notebook_builder = CommunityNotebookUploadBuilder(
logger, core_mode, app_dir)
community_upload_notebook_handler = (community_upload_notebook_url,
CommunityNotebookUploadHandler, {
'builder':
community_upload_notebook_builder
})
handlers.append(community_upload_notebook_handler)
# large file upload
file_upload = ujoin(base_url, file_upload_path)
file_upload_builder = FileUploadBuilder(logger, core_mode, app_dir)
file_upload_handler = (file_upload, FileUploadHanler, {
'builder': file_upload_builder
})
handlers.append(file_upload_handler)
git_oper_url = ujoin(base_url, git_oper_path)
git_oper_builder = GitOperBuilder(logger, core_mode, app_dir)
git_oper_handler = (git_oper_url, GitOperHandler, {
'builder': git_oper_builder
})
handlers.append(git_oper_handler)
from jupyterlab.custom_file_handler import CustomFileHandler
handlers.append((r"/files/(.*)", CustomFileHandler, {}))
if not core_mode:
ext_url = ujoin(base_url, extensions_handler_path)
ext_manager = ExtensionManager(logger, app_dir)
ext_handler = (ext_url, ExtensionHandler, {'manager': ext_manager})
handlers.append(ext_handler)
# Must add before the launcher handlers to avoid shadowing.
logger.info('now handlers is')
logger.info(handlers)
web_app.add_handlers('.*$', handlers)
add_handlers(web_app, config)
def setup_handlers(nbapp):
route_pattern = ujoin(nbapp.settings['base_url'], '/git/commit')
nbapp.add_handlers('.*', [(route_pattern, GitCommitHandler)])
def load_jupyter_server_extension(nbapp):
"""Load the JupyterLab server extension.
"""
# Delay imports to speed up jlpmapp
from jupyterlab_launcher import add_handlers, LabConfig
from notebook.utils import url_path_join as ujoin
from tornado.ioloop import IOLoop
from .build_handler import build_path, Builder, BuildHandler
from .commands import (
get_app_dir, get_user_settings_dir, watch, ensure_dev, watch_dev,
pjoin, DEV_DIR, HERE, get_app_info, ensure_core
)
from ._version import __version__
web_app = nbapp.web_app
logger = nbapp.log
config = LabConfig()
app_dir = getattr(nbapp, 'app_dir', get_app_dir())
# Print messages.
logger.info('JupyterLab alpha preview extension loaded from %s' % HERE)
logger.info('JupyterLab application directory is %s' % app_dir)
config.app_name = 'JupyterLab'
config.app_namespace = 'jupyterlab'
config.page_url = '/lab'
config.cache_files = True
# Check for core mode.
core_mode = False
if getattr(nbapp, 'core_mode', False) or app_dir.startswith(HERE):
core_mode = True
logger.info('Running JupyterLab in core mode')
# Check for dev mode.
dev_mode = False
if getattr(nbapp, 'dev_mode', False) or app_dir.startswith(DEV_DIR):
dev_mode = True
logger.info('Running JupyterLab in dev mode')
# Check for watch.
watch_mode = getattr(nbapp, 'watch', False)
if watch_mode and core_mode:
logger.warn('Cannot watch in core mode, did you mean --dev-mode?')
watch_mode = False
if core_mode and dev_mode:
logger.warn('Conflicting modes, choosing dev_mode over core_mode')
core_mode = False
page_config = web_app.settings.setdefault('page_config_data', dict())
page_config['buildAvailable'] = not core_mode and not dev_mode
page_config['buildCheck'] = not core_mode and not dev_mode
page_config['token'] = nbapp.token
page_config['devMode'] = dev_mode
if core_mode:
app_dir = HERE
logger.info(CORE_NOTE.strip())
ensure_core(logger)
elif dev_mode:
app_dir = DEV_DIR
ensure_dev(logger)
if not watch_mode:
logger.info(DEV_NOTE)
config.app_settings_dir = pjoin(app_dir, 'settings')
config.schemas_dir = pjoin(app_dir, 'schemas')
config.themes_dir = pjoin(app_dir, 'themes')
info = get_app_info(app_dir)
config.app_version = info['version']
public_url = info['publicUrl']
if public_url:
config.public_url = public_url
else:
config.static_dir = pjoin(app_dir, 'static')
config.user_settings_dir = get_user_settings_dir()
config.templates_dir = pjoin(app_dir, 'static')
if watch_mode:
logger.info('Starting JupyterLab watch mode...')
# Set the ioloop in case the watch fails.
nbapp.ioloop = IOLoop.current()
if dev_mode:
watch_dev(logger)
else:
watch(app_dir, logger)
page_config['buildAvailable'] = False
config.cache_files = False
add_handlers(web_app, config)
base_url = web_app.settings['base_url']
build_url = ujoin(base_url, build_path)
builder = Builder(logger, core_mode, app_dir)
build_handler = (build_url, BuildHandler, {'builder': builder})
page_config['themePath'] = ujoin(base_url, '/lab/api/themes')
if 'rc' in __version__:
raise ValueError('remove the theme path shim')
web_app.add_handlers(".*$", [build_handler])
