def install(user=False, symlink=False, enable=False):
"""Install the widget nbextension and optionally enable it.
Parameters
----------
user: bool
Install for current user instead of system-wide.
symlink: bool
Symlink instead of copy (for development).
"""
try:
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
except ModuleNotFoundError:
print('"notebook" not installed, silently failing...')
return
widgetsdir = pjoin(dirname(abspath(__file__)), 'widgets')
install_nbextension(widgetsdir,
destination='arcgis',
user=user,
symlink=symlink)
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {
"arcgis/mapview": True,
}})
def install_server_extension(enable=True):
"""Register ipyparallel clusters tab as a notebook server extension
Toggle with enable=True/False.
"""
# server-side
server = BaseJSONConfigManager(config_dir=jupyter_config_dir())
server_cfg = server.get('jupyter_notebook_config')
app_cfg = server_cfg.get('NotebookApp', {})
server_extensions = app_cfg.get('server_extensions', [])
server_ext = 'ipyparallel.nbextension'
server_changed = False
if enable and server_ext not in server_extensions:
server_extensions.append(server_ext)
server_changed = True
elif (not enable) and server_ext in server_extensions:
server_extensions.remove(server_ext)
server_changed = True
if server_changed:
server.update('jupyter_notebook_config', {
'NotebookApp': {
'server_extensions': server_extensions,
}
})
# frontend config (*way* easier because it's a dict)
frontend = FrontendConfigManager()
frontend.update('tree', {
'load_extensions': {
'ipyparallel/main': enable or None,
}
})
def install(user=False, symlink=False, overwrite=False, enable=False,
**kwargs):
"""Install the nbpresent nbextension.
Parameters
----------
user: bool
Install for current user instead of system-wide.
symlink: bool
Symlink instead of copy (for development).
overwrite: bool
Overwrite previously-installed files for this extension
enable: bool
Enable the extension on every notebook launch
**kwargs: keyword arguments
Other keyword arguments passed to the install_nbextension command
"""
print("Installing nbpresent nbextension...")
directory = join(dirname(abspath(__file__)), 'static', 'nbpresent')
install_nbextension(directory, destination='nbpresent',
symlink=symlink, user=user, overwrite=overwrite,
**kwargs)
if enable:
print("Enabling nbpresent at every notebook launch...")
cm = ConfigManager()
cm.update('notebook',
{"load_extensions": {"nbpresent/nbpresent.min": True}})
def _install_extension_nb41(enable=True):
"""deprecated, pre-4.2 implementation of installing notebook extension"""
# server-side
server = BaseJSONConfigManager(config_dir=jupyter_config_dir())
server_cfg = server.get('jupyter_notebook_config')
app_cfg = server_cfg.get('NotebookApp', {})
server_extensions = app_cfg.get('server_extensions', [])
server_ext = 'ipyparallel.nbextension'
server_changed = False
if enable and server_ext not in server_extensions:
server_extensions.append(server_ext)
server_changed = True
elif (not enable) and server_ext in server_extensions:
server_extensions.remove(server_ext)
server_changed = True
if server_changed:
server.update(
'jupyter_notebook_config',
{'NotebookApp': {
'server_extensions': server_extensions,
}},
)
# frontend config (*way* easier because it's a dict)
frontend = FrontendConfigManager()
frontend.update(
'tree',
{'load_extensions': {
'ipyparallel/main': enable or None,
}},
)
def _install_extension_nb41(enable=True):
"""deprecated, pre-4.2 implementation of installing notebook extension"""
# server-side
server = BaseJSONConfigManager(config_dir=jupyter_config_dir())
server_cfg = server.get('jupyter_notebook_config')
app_cfg = server_cfg.get('NotebookApp', {})
server_extensions = app_cfg.get('server_extensions', [])
server_ext = 'ipyparallel.nbextension'
server_changed = False
if enable and server_ext not in server_extensions:
server_extensions.append(server_ext)
server_changed = True
elif (not enable) and server_ext in server_extensions:
server_extensions.remove(server_ext)
server_changed = True
if server_changed:
server.update('jupyter_notebook_config', {
'NotebookApp': {
'server_extensions': server_extensions,
}
})
# frontend config (*way* easier because it's a dict)
frontend = FrontendConfigManager()
frontend.update('tree', {
'load_extensions': {
'ipyparallel/main': enable or None,
}
})
def install_server_extension(enable=True):
"""Register ipyparallel clusters tab as a notebook server extension
Toggle with enable=True/False.
"""
# server-side
server = BaseJSONConfigManager()
server_cfg = server.get('jupyter_notebook_config')
app_cfg = server_cfg.get('NotebookApp', {})
server_extensions = app_cfg.get('server_extensions', [])
server_ext = 'ipyparallel.nbextension'
server_changed = False
if enable and server_ext not in server_extensions:
server_extensions.append(server_ext)
server_changed = True
elif (not enable) and server_ext in server_extensions:
server_extensions.remove(server_ext)
server_changed = True
if server_changed:
server.update(
'jupyter_notebook_config',
{'NotebookApp': {
'server_extensions': server_extensions,
}})
# frontend config (*way* easier because it's a dict)
frontend = FrontendConfigManager()
frontend.update(
'tree', {'load_extensions': {
'ipyparallel/main': enable or None,
}})
def install(user=False, symlink=False, quiet=False, enable=False):
"""Install the widget nbextension and optionally enable it.
Parameters
----------
user: bool
Install for current user instead of system-wide.
symlink: bool
Symlink instead of copy (for development).
enable: bool
Enable the extension after installing it.
quiet: bool
Suppress print statements about progress.
"""
if not quiet:
print("Installing nbextension ...")
staticdir = pjoin(dirname(abspath(__file__)), "static")
install_nbextension(staticdir, destination="widgets", user=user, symlink=symlink)
if enable:
if not quiet:
print("Enabling the extension ...")
cm = ConfigManager()
cm.update("notebook", {"load_extensions": {"widgets/extension": True}})
if not quiet:
print("Done.")
def patch():
from notebook.services.config import ConfigManager
from IPython.paths import locate_profile
cm = ConfigManager(profile_dir=locate_profile(get_ipython().profile))
cm.update('livereveal', {'width': '100%', 'height': 700, 'margin': 0.2,})
from IPython.display import HTML
HTML('''<style>.CodeMirror{min-width:100% !important;}</style>''')
def setup_config(self):
# This is apparently a singleton?
cm = ConfigManager()
cm.update('common',
{'GoogleAnalytics': {
'tracking_id': self.tracking_id
}})
def install(user=False, symlink=False, quiet=False, enable=False):
"""Install the widget nbextension and optionally enable it.
Parameters
----------
user: bool
Install for current user instead of system-wide.
symlink: bool
Symlink instead of copy (for development).
enable: bool
Enable the extension after installing it.
quiet: bool
Suppress print statements about progress.
"""
if not quiet:
print("Installing nbextension ...")
staticdir = pjoin(dirname(abspath(__file__)), 'static')
install_nbextension(staticdir,
destination='widgets',
user=user,
symlink=symlink)
if enable:
if not quiet:
print("Enabling the extension ...")
cm = ConfigManager()
cm.update(
'notebook',
{"load_extensions": {
"widgets/notebook/js/extension": True,
}})
if not quiet:
print("Done.")
def start(self):
self.log.info("Activating jupyter_dashboards_bundlers JS notebook extensions")
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'dashboards_local_deploy': {
'label': 'Local Dashboard',
'module_name': 'dashboards_bundlers.local_deploy',
'group': 'deploy'
},
'dashboards_php_download': {
'label': 'PHP Dashboard bundle (.zip)',
'module_name': 'dashboards_bundlers.php_download',
'group': 'download'
},
'dashboards_server_upload': {
'label': 'Dashboard on Jupyter Dashboards Server',
'module_name': 'dashboards_bundlers.server_upload',
'group': 'deploy'
},
'dashboards_server_download': {
'label': 'Jupyter Dashboards Server bundle (.zip)',
'module_name': 'dashboards_bundlers.server_download',
'group': 'download'
}
}
})
self.log.info("Done.")
def disable_bundler(self):
'''Disables the notebook bundler extension.'''
cm = ConfigManager(parent=self, config=self.config)
cm.update(
'notebook',
{'jupyter_cms_bundlers': {
'notebook_associations_download': None
}})
def install(config_dir, use_symlink=False, enable=True):
# Install the livereveal code.
install_nbextension(livereveal_dir, symlink=use_symlink,
overwrite=use_symlink, user=True)
if enable:
cm = ConfigManager(config_dir=config_dir)
cm.update('notebook', {"load_extensions": {"livereveal/main": True}})
def disable_nbextension(self, name):
# Local import to avoid circular import issue on Py 2
from notebook.services.config import ConfigManager
cm = ConfigManager(parent=self, config=self.config)
if name not in cm.get(self.section).get('load_extensions', {}):
sys.exit('{} is not enabled in section {}'.format(name, self.section))
# We're using a dict as a set - updating with None removes the key
cm.update(self.section, {"load_extensions": {name: None}})
def run(self):
_install.run(self)
if install_nbextension is not None and ConfigManager is not None:
cm = ConfigManager()
cm.update('notebook',
{"load_extensions": {
"demdraper/index": True
}})
def disable_bundler(self):
'''Disables the notebook bundler extension.'''
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'notebook_associations_download': None
}
})
def install(enable=False, **kwargs):
"""Install the nbpresent nbextension assets and optionally enables the
nbextension and server extension for every run.
Parameters
----------
enable: bool
Enable the extension on every notebook launch
**kwargs: keyword arguments
Other keyword arguments passed to the install_nbextension command
"""
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
directory = join(dirname(abspath(__file__)), "static", "nbpresent")
kwargs = {k: v for k, v in kwargs.items() if not (v is None)}
kwargs["destination"] = "nbpresent"
install_nbextension(directory, **kwargs)
if enable:
path = jupyter_config_dir()
if "prefix" in kwargs:
path = join(kwargs["prefix"], "etc", "jupyter")
if not exists(path):
print("Making directory", path)
os.makedirs(path)
cm = ConfigManager(config_dir=path)
print("Enabling nbpresent server component in", cm.config_dir)
cfg = cm.get("jupyter_notebook_config")
print("Existing config...")
pprint(cfg)
server_extensions = cfg.setdefault("NotebookApp", {}).setdefault("server_extensions", [])
if "nbpresent" not in server_extensions:
cfg["NotebookApp"]["server_extensions"] += ["nbpresent"]
cm.update("jupyter_notebook_config", cfg)
print("New config...")
pprint(cm.get("jupyter_notebook_config"))
_jupyter_config_dir = jupyter_config_dir()
# try:
# subprocess.call(["conda", "info", "--root"])
# print("conda detected")
# _jupyter_config_dir = ENV_CONFIG_PATH[0]
# except OSError:
# print("conda not detected")
cm = ConfigManager(config_dir=join(_jupyter_config_dir, "nbconfig"))
print("Enabling nbpresent nbextension at notebook launch in", cm.config_dir)
if not exists(cm.config_dir):
print("Making directory", cm.config_dir)
os.makedirs(cm.config_dir)
cm.update("notebook", {"load_extensions": {"nbpresent/nbpresent.min": True}})
def start(self):
self.log.info("Deactivating jupyter_kernel_gateway_bundlers notebook extension")
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'microservice_dockerfile_download' : None
}
})
self.log.info("Done.")
def run(self):
_develop.run(self)
install_nbextension(extension_dir,
symlink=True,
overwrite=True,
user=True,
destination="validation")
cm = ConfigManager()
cm.update("notebook", {"load_extensions": {"example/index": True}})
def disable_nbextension(self, name):
# Local import to avoid circular import issue on Py 2
from notebook.services.config import ConfigManager
cm = ConfigManager(parent=self, config=self.config)
if name not in cm.get(self.section).get('load_extensions', {}):
sys.exit('{} is not enabled in section {}'.format(
name, self.section))
# We're using a dict as a set - updating with None removes the key
cm.update(self.section, {"load_extensions": {name: None}})
def configure(url, client_id):
"""Configure the Jupyter server extension."""
from notebook.services.config import ConfigManager
cm = ConfigManager()
cm.update('renku.notebook.oic', {
'client_id': client_id,
'url': url,
})
def run(self):
_develop.run(self)
install_nbextension(extension_dir,
symlink=True,
overwrite=True,
user=True,
destination="idaho_map")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {"idaho_map/index": True}})
def config_configManager():
print("Update ConfigManager")
from notebook.services.config import ConfigManager
cm = ConfigManager()
cm.update('livereveal', {
'theme': 'serif',
'start_slideshow_at': 'selected',
'width': 1680,
'height': 768,
})
def install(use_symlink=False, enable=True):
# Install the livereveal code.
install_nbextension(livereveal_dir,
symlink=use_symlink,
overwrite=use_symlink,
user=True)
if enable:
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {"livereveal/main": True}})
def install(enable=False, disable=False, prefix=None):
"""Install the nb_config_manager config piece.
Parameters
----------
enable: bool
Enable the nb_config_manager on every notebook launch
disable: bool
Disable nb_config_manager on every notebook launch
"""
from notebook.services.config import ConfigManager
if enable:
if prefix is not None:
path = join(prefix, "etc", "jupyter")
if not exists(path):
print("Making directory", path)
os.makedirs(path)
else:
path = jupyter_config_dir()
cm = ConfigManager(config_dir=path)
print("Enabling nb_config_manager in", cm.config_dir)
cfg = cm.get("jupyter_notebook_config")
print("Existing config...")
pprint(cfg)
notebook_app = cfg.setdefault("NotebookApp", {})
if "config_manager_class" not in notebook_app:
cfg["NotebookApp"]["config_manager_class"] = "nb_config_manager.EnvironmentConfigManager"
cm.update("jupyter_notebook_config", cfg)
print("New config...")
pprint(cm.get("jupyter_notebook_config"))
if disable:
if prefix is not None:
path = join(prefix, "etc", "jupyter")
else:
path = jupyter_config_dir()
cm = ConfigManager(config_dir=path)
print("Disabling nb_config_manager in", cm.config_dir)
cfg = cm.get("jupyter_notebook_config")
print("Existing config...")
pprint(cfg)
config_manager = cfg["NotebookApp"]["config_manager_class"]
if "nb_config_manager.EnvironmentConfigManager" == config_manager:
cfg["NotebookApp"].pop("config_manager_class")
cm.set("jupyter_notebook_config", cfg)
print("New config...")
pprint(cm.get("jupyter_notebook_config"))
def run(self):
_develop.run(self)
install_nbextension(
extension_dir,
symlink=True,
overwrite=True,
user=False,
sys_prefix=True, # to install it inside virtualenv
destination="robomission")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {"robomission/index": True}})
def start(self):
self.log.info("Deactivating jupyter_dashboards_bundlers JS notebook extensions")
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'dashboards_local_deploy' : None,
'dashboards_php_download' : None,
'dashboards_server_upload' : None
}
})
self.log.info("Done.")
def run_nbextension_install(develop):
import sys
sysprefix = hasattr(sys, 'real_prefix')
if sysprefix:
install_nbextension(extension_dir, symlink=develop, sys_prefix=sysprefix)
else:
install_nbextension(extension_dir, symlink=develop, user=user)
if enable is not None:
print("Enabling the extension ...")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {enable: True}})
def run(self):
_develop.run(self)
install_nbextension(
extension_dir,
symlink=True,
overwrite=True,
user=False,
sys_prefix=True, # to install it inside virtualenv
destination="robomission")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {"robomission/index": True } })
def enable_server_extension(self, extension):
'''Enables the server side extension in the user config.'''
server_cm = ConfigManager(config_dir=jupyter_config_dir())
makedirs(server_cm.config_dir)
cfg = server_cm.get('jupyter_notebook_config')
server_extensions = (cfg.setdefault('NotebookApp', {}).setdefault(
'server_extensions', []))
if extension not in server_extensions:
cfg['NotebookApp']['server_extensions'] += [extension]
server_cm.update('jupyter_notebook_config', cfg)
def start(self):
self.log.info("Deactivating jupyter_dashboards_bundlers JS notebook extensions")
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'dashboards_local_deploy' : None,
'dashboards_php_download' : None,
'dashboards_server_upload' : None,
'dashboards_server_download' : None
}
})
self.log.info("Done.")
def enable_bundler(self):
'''Enables the notebook bundler extension.'''
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'notebook_associations_download': {
'label': 'IPython Notebook bundle (.zip)',
'module_name': 'jupyter_cms.nb_bundler',
'group': 'download'
}
}
})
def run(self):
_develop.run(self)
if install_nbextension is not None and ConfigManager is not None:
install_nbextension(extension_dir,
symlink=True,
overwrite=True,
user=True,
destination="demdraper")
cm = ConfigManager()
cm.update('notebook',
{"load_extensions": {
"demdraper/index": True
}})
def enable_bundler(self):
'''Enables the notebook bundler extension.'''
cm = ConfigManager(parent=self, config=self.config)
cm.update(
'notebook', {
'jupyter_cms_bundlers': {
'notebook_associations_download': {
'label': 'IPython Notebook bundle (.zip)',
'module_name': 'jupyter_cms.nb_bundler',
'group': 'download'
}
}
})
def setup_config(self):
"""
Updates the config for the duration of the user session.
"""
cm = ConfigManager()
cm.update(
CONFIG_SECTION,
{
'GoogleAnalytics': {
'tracking_id': self.tracking_id
}
}
)
def start(self):
self.log.info("Activating jupyter_kernel_gateway_bundlers JS notebook extensions")
cm = ConfigManager(parent=self, config=self.config)
cm.update('notebook', {
'jupyter_cms_bundlers': {
'microservice_dockerfile_download': {
'label': 'Microservice Docker bundle (.zip)',
'module_name': 'kernel_gateway_bundlers.dockerfile_download',
'group': 'download'
}
}
})
self.log.info("Done.")
def run(self):
open_tools_widget_path = EXTENSION_NAME+"/"+OPEN_TOOLS_WIDGET
git_tree_widget_path = EXTENSION_NAME+"/"+GIT_TREE_WIDGET
git_notebook_widget_path = EXTENSION_NAME+"/"+GIT_NOTEBOOK_WIDGET
# Install Python package
install.run(self)
# Install JavaScript extensions to ~/.local/jupyter/
install_nbextension(EXT_DIR, overwrite=True, user=True)
# Activate the JS extensions on the notebook, tree, and edit screens
js_cm = ConfigManager()
js_cm.update('tree', {"load_extensions": {open_tools_widget_path: True}})
js_cm.update('notebook', {"load_extensions": {open_tools_widget_path: True}})
js_cm.update('edit', {"load_extensions": {open_tools_widget_path: True}})
js_cm.update('notebook', {"load_extensions": {git_notebook_widget_path: True}})
js_cm.update('tree', {"load_extensions": {git_tree_widget_path: True}})
# Activate the Python server extension
server_extension_name = EXTENSION_NAME+"."+HANDLER_NAME
jupyter_config_file = os.path.join(jupyter_config_dir(), "jupyter_notebook_config.json")
if not os.path.isfile(jupyter_config_file):
with open(jupyter_config_file, "w") as jsonFile:
initial_data = {
"NotebookApp":{
"nbserver_extensions": {},
"server_extensions": []
}
}
json.dump(initial_data, jsonFile, indent=4)
with open(jupyter_config_file, "r") as jsonFile:
data = json.load(jsonFile)
if 'server_extensions' not in data['NotebookApp']:
data['NotebookApp']['server_extensions'] = []
if 'nbserver_extensions' not in data['NotebookApp']:
data['NotebookApp']['nbserver_extensions'] = {}
if server_extension_name not in data['NotebookApp']['server_extensions']:
data['NotebookApp']['server_extensions'] += [server_extension_name]
data['NotebookApp']['nbserver_extensions'][server_extension_name] = True
with open(jupyter_config_file, "w") as jsonFile:
json.dump(data, jsonFile, indent=4)
def run(self):
# Install Python package
install.run(self)
# Install JavaScript extensions to ~/.local/jupyter/
install_nbextension(EXT_DIR, overwrite=True, user=True)
# Activate the JS extensions on the notebook, tree, and edit screens
js_cm = ConfigManager()
js_cm.update('notebook',
{"load_extensions": {
'nbdocker/notebook': True
}})
js_cm.update('tree', {"load_extensions": {'nbdocker/dashboard': True}})
js_cm.update('edit', {"load_extensions": {'nbdocker/editor': True}})
# Activate the Python server extension
server_cm = ConfigManager(config_dir=jupyter_config_dir())
cfg = server_cm.get('jupyter_notebook_config')
server_extensions = (cfg.setdefault('NotebookApp', {}).setdefault(
'server_extensions', []))
if extension not in server_extensions:
cfg['NotebookApp']['server_extensions'] += [
'nbdocker.DockerHanlder'
]
server_cm.update('jupyter_notebook_config', cfg)
def _jupyter_install(package_name, package_main, package_installation_path):
install_nbextension, ConfigManager = __get_jupyter_note_utils()
if install_nbextension and ConfigManager:
print("Installing %s to jupyter.." % package_name)
install_nbextension(package_installation_path,
symlink=False, user=True)
print("Enabling %s on jupyter.." % package_name)
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {package_main: True}})
else:
warnings.warn("No jupyter notebook found in your environment. "
"Hence jupyter nbextensions were not installed. "
"If you would like to have them,"
"please issue 'pip install jupyter'.")
def run_nbextension_install(develop):
try:
# IPython/Jupyter 4.0
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
except ImportError:
# Pre-schism
from IPython.html.nbextensions import install_nbextension
from IPython.html.services.config import ConfigManager
install_nbextension(extension_dir, symlink=develop, user=user, verbose=2)
if enable is not None:
print("Enabling the extension ...")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {enable: True}})
def enable_server_extension(self, extension):
'''Enables the server side extension in the user config.'''
server_cm = ConfigManager(config_dir=jupyter_config_dir())
makedirs(server_cm.config_dir)
cfg = server_cm.get('jupyter_notebook_config')
server_extensions = (
cfg.setdefault('NotebookApp', {})
.setdefault('server_extensions', [])
)
if extension not in server_extensions:
cfg['NotebookApp']['server_extensions'] += [extension]
server_cm.update('jupyter_notebook_config', cfg)
def _install_notebook_extension():
print('Installing notebook extension')
install_nbextension(EXT_DIR, overwrite=True, user=True)
cm = ConfigManager()
print('Enabling extension for notebook')
cm.update('notebook', {"load_extensions": {'urth_cms_js/notebook/main': True}})
print('Enabling extension for dashboard')
cm.update('tree', {"load_extensions": {'urth_cms_js/dashboard/main': True}})
print('Enabling extension for text editor')
cm.update('edit', {"load_extensions": {'urth_cms_js/editor/main': True}})
print('Enabling notebook and associated files bundler')
cm.update('notebook', {
'jupyter_cms_bundlers': {
'notebook_associations_download': {
'label': 'IPython Notebook bundle (.zip)',
'module_name': 'urth.cms.nb_bundler',
'group': 'download'
}
}
})
print('Installing notebook server extension')
fn = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.py')
with open(fn, 'r+') as fh:
lines = fh.read()
if SERVER_EXT_CONFIG not in lines:
fh.seek(0, 2)
fh.write('\n')
fh.write(SERVER_EXT_CONFIG)
def run(self):
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
_develop.run(self)
install_nbextension(EXTENSION_DIR, symlink=True,
overwrite=True, user=False, destination="mlvis")
cm = ConfigManager()
cm.update('notebook', {"load_extensions":
{
"mlvis/index": True,
"mlvis/extension": True
}
})
def run(self):
from notebook.nbextensions import install_nbextension
if self.source:
livereveal_dir = self.source
else:
lib_dir = os.path.join(get_python_lib(), 'livereveal')
if os.path.exists(lib_dir):
livereveal_dir = lib_dir
else:
livereveal_dir = os.path.join(os.path.dirname(__file__), 'livereveal')
install_nbextension(livereveal_dir, symlink=self.develop,
overwrite=self.develop, user=True)
if not self.no_enable:
from notebook.services.config import ConfigManager
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {"livereveal/main": True}})
def _install_notebook_extension():
cm = ConfigManager()
print('Installing notebook extension')
cm.update('notebook', {
'jupyter_cms_bundlers': {
'dashboards_local_deploy': {
'label': 'Local Dashboard',
'module_name': 'dashboards_bundlers.local_deploy',
'group': 'deploy'
},
'dashboards_php_download': {
'label': 'PHP Dashboard bundle (.zip)',
'module_name': 'dashboards_bundlers.php_download',
'group': 'download'
}
}
})
def _install_notebook_extension():
cm = ConfigManager()
print('Installing notebook extension')
cm.update(
'notebook', {
'jupyter_cms_bundlers': {
'dashboards_local_deploy': {
'label': 'Local Dashboard',
'module_name': 'dashboards_bundlers.local_deploy',
'group': 'deploy'
},
'dashboards_php_download': {
'label': 'PHP Dashboard bundle (.zip)',
'module_name': 'dashboards_bundlers.php_download',
'group': 'download'
}
}
})
def disable_server_extension(self, extension):
'''Disables the server side extension in the user config.'''
server_cm = ConfigManager(config_dir=jupyter_config_dir())
makedirs(server_cm.config_dir)
cfg = server_cm.get('jupyter_notebook_config')
if ('NotebookApp' in cfg and 'server_extensions' in cfg['NotebookApp']
and extension in cfg['NotebookApp']['server_extensions']):
cfg['NotebookApp']['server_extensions'].remove(extension)
server_cm.update('jupyter_notebook_config', cfg)
server_extensions = (cfg.setdefault('NotebookApp', {}).setdefault(
'server_extensions', []))
if extension in server_extensions:
cfg['NotebookApp']['server_extensions'].remove(extension)
server_cm.update('jupyter_notebook_config', cfg)
def run(self):
server_extension_name = EXTENSION_NAME+"."+HANDLER_NAME
frontend_extension_notebook = EXTENSION_NAME+"/"+WIDGET_NOTEBOOK
frontend_extension_tree = EXTENSION_NAME+"/"+WIDGET_TREE
# Install Python package
install.run(self)
# Install JavaScript extensions to ~/.local/jupyter/
#nbex_dir = os.path.expanduser('~/.ipython/nbextensions')
install_nbextension(EXT_DIR, overwrite=True, user=True)# user=True,)
# Activate the JS extensions on the notebook, tree, and edit screens
js_cm = ConfigManager()
js_cm.update('notebook', {"load_extensions": {frontend_extension_notebook: True}})
js_cm.update('tree', {"load_extensions": {frontend_extension_tree: True}})
# Activate the Python server extension
jupyter_config_file = os.path.join(jupyter_config_dir(), "jupyter_notebook_config.json")
if not os.path.isfile(jupyter_config_file):
with open(jupyter_config_file, "w") as jsonFile:
initial_data = {
"NotebookApp":{
"nbserver_extensions": {},
"server_extensions": []
}
}
json.dump(initial_data, jsonFile, indent=4)
with open(jupyter_config_file, "r") as jsonFile:
data = json.load(jsonFile)
if 'server_extensions' not in data['NotebookApp']:
data['NotebookApp']['server_extensions'] = []
if 'nbserver_extensions' not in data['NotebookApp']:
data['NotebookApp']['nbserver_extensions'] = {}
if server_extension_name not in data['NotebookApp']['server_extensions']:
data['NotebookApp']['server_extensions'] += [server_extension_name]
data['NotebookApp']['nbserver_extensions'][server_extension_name] = True
with open(jupyter_config_file, "w") as jsonFile:
json.dump(data, jsonFile, indent=4)
def install(user=True, symlink=False):
"""Install the widget nbextension.
Parameters
----------
user: bool
Install for current user instead of system-wide.
symlink: bool
Symlink instead of copy (for development).
"""
staticdir = resource_filename('nglview', os.path.join('html', 'static'))
install_nbextension(staticdir, destination='nglview',
user=user, symlink=symlink)
cm = ConfigManager()
cm.update('notebook', {
"load_extensions": {
"widgets/notebook/js/extension": True,
}
})
def install(enable=False, **kwargs):
"""Install the nbpresent nbextension assets and optionally enables the
nbextension and server extension for every run.
Parameters
----------
enable: bool
Enable the extension on every notebook launch
**kwargs: keyword arguments
Other keyword arguments passed to the install_nbextension command
"""
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
directory = join(dirname(abspath(__file__)), 'static', 'nbpresent')
kwargs = {k: v for k, v in kwargs.items() if not (v is None)}
kwargs["destination"] = "nbpresent"
install_nbextension(directory, **kwargs)
if enable:
if "prefix" in kwargs:
path = join(kwargs["prefix"], "etc", "jupyter")
if not exists(path):
os.makedirs(path)
cm = ConfigManager(config_dir=path)
print("Enabling for", cm.config_dir)
print("Enabling nbpresent server component...")
cm.update(
"jupyter_notebook_config", {
"notebook": {
"load_extensions": {"nbpresent/nbpresent.min": True}
},
"NotebookApp": {
"server_extensions": ["nbpresent"]
}
}
)
def setup_notebook_config(self):
# Set the notebook extension to launch on startup by
# modifying the notebook.json
ensure_dir_exists(ConfigManager()._config_dir_default())
# Elements to be added
version = 2
data_element = {'stepsize_nb-ext/main': None}
for i in range(1, version):
data_element['stepsize_nb-ext/main_v0-%i' % i] = None
data_element['stepsize_nb-ext/main_v0-%i' % version] = True
data = {'load_extensions': data_element}
try:
cm = ConfigManager()
cm.update('notebook', data)
print("OUTCOME: Added the Stepsize notebook extension "
"configuration to the notebook.json")
except:
print("WARNING: An error occured when trying to add %s to the "
"notebook.json" % (data))
print("ERROR: %s" % (sys.exc_info()[0]))
raise
def install_extension():
# Import inside run() so if the user doesn't have jupyter notebook yet, we grab that dependency,
# then run this code which imports it.
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
from jupyter_core.paths import jupyter_config_dir
# Install JavaScript extension
install_nbextension(os.path.join(EXT_DIR, "extensions", "spark.js"), overwrite=True, user=True)
# Activate the JS extensions on the notebook
js_cm = ConfigManager()
js_cm.update('notebook', {"load_extensions": {'spark': True}})
# Activate the Python server extension
server_cm = ConfigManager(config_dir=jupyter_config_dir())
cfg = server_cm.get('jupyter_notebook_config')
server_extensions = cfg.setdefault('NotebookApp', {}).setdefault('server_extensions', [])
if "jupyter-spark.spark" not in server_extensions:
cfg['NotebookApp']['server_extensions'] += ['jupyter-spark.spark']
server_cm.update('jupyter_notebook_config', cfg)
def disable_server_extension(self, extension):
'''Disables the server side extension in the user config.'''
server_cm = ConfigManager(config_dir=jupyter_config_dir())
makedirs(server_cm.config_dir)
cfg = server_cm.get('jupyter_notebook_config')
if ('NotebookApp' in cfg and
'server_extensions' in cfg['NotebookApp'] and
extension in cfg['NotebookApp']['server_extensions']):
cfg['NotebookApp']['server_extensions'].remove(extension)
server_cm.update('jupyter_notebook_config', cfg)
server_extensions = (
cfg.setdefault('NotebookApp', {})
.setdefault('server_extensions', [])
)
if extension in server_extensions:
cfg['NotebookApp']['server_extensions'].remove(extension)
server_cm.update('jupyter_notebook_config', cfg)
def run_nbextension_install(self, develop):
# Check if the user flag was set.
user_ = user
if user is None:
user_ = not _is_root()
try:
# IPython/Jupyter 4.0
from notebook.nbextensions import install_nbextension
from notebook.services.config import ConfigManager
except ImportError:
# Pre-schism
from IPython.html.nbextensions import install_nbextension
from IPython.html.services.config import ConfigManager
extension_dir = self._nbextension_dir()
install_nbextension(extension_dir, symlink=develop, user=user_)
if enable is not None:
print("Enabling the extension ...")
cm = ConfigManager()
cm.update('notebook', {"load_extensions": {enable: True}})
def run(self):
print('Installing Python module')
install.run(self)
print('Installing notebook extension')
install_nbextension(EXT_DIR, overwrite=True, user=True)
cm = ConfigManager()
print('Enabling extension for notebook')
cm.update('notebook', {"load_extensions": {'urth_widgets/js/main': True}})
print('Installing notebook server extension')
fn = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.py')
if os.path.isfile(fn):
with open(fn, 'r+') as fh:
lines = fh.read()
if SERVER_EXT_CONFIG not in lines:
fh.seek(0, 2)
fh.write('\n')
fh.write(SERVER_EXT_CONFIG)
else:
with open(fn, 'w') as fh:
fh.write('c = get_config()\n')
fh.write(SERVER_EXT_CONFIG)
def run(self):
print('Installing Python module')
install.run(self)
print('Installing notebook extension')
install_nbextension(EXT_DIR, overwrite=True, user=True)
cm = ConfigManager()
print('Enabling extension for notebook')
cm.update('notebook', {"load_extensions": {'urth_cms_js/notebook/main': True}})
print('Enabling extension for dashboard')
cm.update('tree', {"load_extensions": {'urth_cms_js/dashboard/main': True}})
print('Enabling extension for text editor')
cm.update('edit', {"load_extensions": {'urth_cms_js/editor/main': True}})
print('Installing notebook server extension')
fn = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.py')
with open(fn, 'r+') as fh:
lines = fh.read()
if SERVER_EXT_CONFIG not in lines:
fh.seek(0, 2)
fh.write('\n')
fh.write(SERVER_EXT_CONFIG)
