def list_nbextensions(self):
"""List all the nbextensions"""
config_dirs = [os.path.join(p, 'nbconfig') for p in jupyter_config_path()]
print("Known nbextensions:")
for config_dir in config_dirs:
head = u' config dir: {}'.format(config_dir)
head_shown = False
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
for section in NBCONFIG_SECTIONS:
data = cm.get(section)
if 'load_extensions' in data:
if not head_shown:
# only show heading if there is an nbextension here
print(head)
head_shown = True
print(u' {} section'.format(section))
for require, enabled in data['load_extensions'].items():
print(u' {} {}'.format(
require,
GREEN_ENABLED if enabled else RED_DISABLED))
if enabled:
validate_nbextension(require, logger=self.log)
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 list_nbextensions(self):
"""List all the nbextensions"""
config_dirs = [os.path.join(p, 'nbconfig') for p in jupyter_config_path()]
print("Known bundlerextensions:")
for config_dir in config_dirs:
head = u' config dir: {}'.format(config_dir)
head_shown = False
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get('notebook')
if 'bundlerextensions' in data:
if not head_shown:
# only show heading if there is an nbextension here
print(head)
head_shown = True
for bundler_id, info in data['bundlerextensions'].items():
label = info.get('label')
module = info.get('module_name')
if label is None or module is None:
msg = u' {} {}'.format(bundler_id, RED_DISABLED)
else:
msg = u' "{}" from {} {}'.format(
label, module, GREEN_ENABLED
)
print(msg)
def list_nbextensions(self):
"""List all the nbextensions"""
config_dirs = [
os.path.join(p, 'nbconfig') for p in jupyter_config_path()
]
print("Known nbextensions:")
for config_dir in config_dirs:
head = u' config dir: {}'.format(config_dir)
head_shown = False
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
for section in NBCONFIG_SECTIONS:
data = cm.get(section)
if 'load_extensions' in data:
if not head_shown:
# only show heading if there is an nbextension here
print(head)
head_shown = True
print(u' {} section'.format(section))
for require, enabled in data['load_extensions'].items():
print(u' {} {}'.format(
require,
GREEN_ENABLED if enabled else RED_DISABLED))
if enabled:
validate_nbextension(require, logger=self.log)
def _set_nbextension_state(section, require, state, user=True, sys_prefix=False, logger=None):
"""Set whether the section's frontend should require the named nbextension
Returns True if the final state is the one requested.
Parameters
----------
section : string
The section of the server to change, one of NBCONFIG_SECTIONS
require : string
An importable AMD module inside the nbextensions static path
state : bool
The state in which to leave the extension
user : bool [default: True]
Whether to update the user's .jupyter/nbextensions directory
sys_prefix : bool [default: False]
Whether to update the sys.prefix, i.e. environment. Will override
`user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = os.path.join(_get_config_dir(user=user, sys_prefix=sys_prefix), "nbconfig")
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} {} extension {}...".format("Enabling" if state else "Disabling", section, require))
cm.update(section, {"load_extensions": {require: state}})
validate_nbextension(require, logger=logger)
return cm.get(section).get(require) == state
def get(self, section_name):
"""Get the config from all config sections."""
config = {}
for p in self.read_config_path:
cm = BaseJSONConfigManager(config_dir=p)
recursive_update(config, cm.get(section_name))
return config
def _install_kernelspec_manager(prefix, disable=False):
CKSM = "beakerx.kernel_spec.BeakerXKernelSpec"
KSMC = "kernel_spec_class"
action_prefix = "Dis" if disable else "En"
log.info("{}abling BeakerX server config...".format(action_prefix))
path = os.path.join(prefix, "etc", "jupyter")
if not os.path.exists(path):
log.debug("Making directory {}...".format(path))
os.makedirs(path)
cm = BaseJSONConfigManager(config_dir=path)
cfg = cm.get("jupyter_notebook_config")
log.debug("Existing config in {}...\n{}".format(path, _pretty(cfg)))
nb_app = cfg.setdefault("KernelSpecManager", {})
if disable and nb_app.get(KSMC, None) == CKSM:
nb_app.pop(KSMC)
elif not disable:
nb_app.update({KSMC: CKSM})
log.debug("Writing config in {}...".format(path))
cm.set("jupyter_notebook_config", cfg)
cfg = cm.get("jupyter_notebook_config")
log.debug("Verifying config in {}...\n{}".format(path, _pretty(cfg)))
if disable:
assert KSMC not in cfg["KernelSpecManager"]
else:
assert cfg["KernelSpecManager"][KSMC] == CKSM
log.info("{}abled BeakerX server config".format(action_prefix))
def list_labextensions(self):
"""List all the labextensions"""
print("Known labextensions:")
seen = False
for config_dir in jupyter_config_path():
config_dir = os.path.join(config_dir, CONFIG_DIR)
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
labextensions = cm.get('labextensions')
if labextensions:
print(u'config dir: {}'.format(config_dir))
seen = True
for name, config in sorted(labextensions.items()):
if isinstance(config, bool):
config = dict(enabled=config)
enabled = config['enabled']
full_dest = find_labextension(name)
print(u' {} {}: {}'.format(
name,
GREEN_ENABLED if enabled else RED_DISABLED,
full_dest if not None else RED_X+" Files not found"
))
if full_dest is not None:
validate_labextension_folder(name, full_dest, self.log)
if not seen:
print('....None found!')
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_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 toggle_serverextension_python(import_name,
enabled=None,
parent=None,
user=True,
sys_prefix=False,
logger=None):
"""Toggle a server extension.
By default, toggles the extension in the system-wide Jupyter configuration
location (e.g. /usr/local/etc/jupyter).
Parameters
----------
import_name : str
Importable Python module (dotted-notation) exposing the magic-named
`load_jupyter_server_extension` function
enabled : bool [default: None]
Toggle state for the extension. Set to None to toggle, True to enable,
and False to disable the extension.
parent : Configurable [default: None]
user : bool [default: True]
Toggle in the user's configuration location (e.g. ~/.jupyter).
sys_prefix : bool [default: False]
Toggle in the current Python environment's configuration location
(e.g. ~/.envs/my-env/etc/jupyter). Will override `user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
cfg = cm.get("jupyter_notebook_config")
server_extensions = (cfg.setdefault("NotebookApp",
{}).setdefault("server_extensions",
[]))
old_enabled = import_name in server_extensions
new_enabled = enabled if enabled is not None else not old_enabled
if logger:
if new_enabled:
logger.info(u"Enabling: %s" % (import_name))
else:
logger.info(u"Disabling: %s" % (import_name))
if new_enabled:
if not old_enabled:
server_extensions.append(import_name)
elif old_enabled:
while import_name in server_extensions:
server_extensions.pop(server_extensions.index(import_name))
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
cm.update("jupyter_notebook_config", cfg)
if new_enabled:
validate_serverextension(import_name, logger)
def get(self, section_name):
"""Get the config from all config sections."""
config = {}
for p in self.read_config_path:
cm = BaseJSONConfigManager(config_dir=p)
recursive_update(config, cm.get(section_name))
return config
def _write_config_data(section,
data,
user=False,
sys_prefix=False,
logger=None):
"""Update the config for the current context
Parameters
----------
section: string
The section of data to update.
data : object
An object which can be accepted by ConfigManager.update
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
logger: logger instance
The logger instance.
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
config_man = BaseJSONConfigManager(config_dir=config_dir)
config_man.update(section, data)
def list_nbextensions(self):
"""List all the nbextensions"""
config_dirs = [
os.path.join(p, 'nbconfig') for p in jupyter_config_path()
]
print("Known bundlerextensions:")
for config_dir in config_dirs:
head = u' config dir: {}'.format(config_dir)
head_shown = False
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get('notebook')
if 'bundlerextensions' in data:
if not head_shown:
# only show heading if there is an nbextension here
print(head)
head_shown = True
for bundler_id, info in data['bundlerextensions'].items():
label = info.get('label')
module = info.get('module_name')
if label is None or module is None:
msg = u' {} {}'.format(bundler_id, RED_DISABLED)
else:
msg = u' "{}" from {} {}'.format(
label, module, GREEN_ENABLED)
print(msg)
def list_labextensions(self):
"""List all the labextensions"""
print("Known labextensions:")
for config_dir in jupyter_config_path():
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get(CONFIG_NAME)
labextensions = (
data.setdefault("LabApp", {})
.setdefault("labextensions", {})
)
if labextensions:
print(u'config dir: {}'.format(config_dir))
for name, config in sorted(labextensions.items()):
if isinstance(config, bool):
config = dict(enabled=config)
enabled = config['enabled']
full_dest = find_labextension(name)
print(u' {} {}: {}'.format(
name,
GREEN_ENABLED if enabled else RED_DISABLED,
full_dest if not None else RED_X+" Files not found"
))
if full_dest is not None:
validate_labextension_folder(name, full_dest, self.log)
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 get(self, section_name):
"""Get the config from all config sections."""
config = {}
# step through back to front, to ensure front of the list is top priority
for p in self.read_config_path[::-1]:
cm = BaseJSONConfigManager(config_dir=p)
recursive_update(config, cm.get(section_name))
return config
def test_nbextension_disable(self):
self.test_nbextension_enable()
disable_nbextension(section='notebook', require=u'ƒ')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get(u'ƒ', False)
assert not enabled
def test_nbextension_disable(self):
self.test_nbextension_enable()
disable_nbextension(section='notebook', require=u'ƒ')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get(u'ƒ', False)
assert not enabled
def test_labextension_disable(self):
self.test_labextension_enable()
disable_labextension(self.name)
config_dir = os.path.join(_get_config_dir(user=True), 'labconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('jupyterlab_config').get('LabApp', {}).get('labextensions', {}).get(self.name, False)
assert not enabled
def get(self, section_name):
"""Get the config from all config sections."""
config = {}
# step through back to front, to ensure front of the list is top priority
for p in self.read_config_path[::-1]:
cm = BaseJSONConfigManager(config_dir=p)
recursive_update(config, cm.get(section_name))
return config
def test_nbextensionpy_enable(self):
self._inject_mock_extension('notebook')
install_nbextension_python('mockextension', user=True)
enable_nbextension_python('mockextension')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get('_mockdestination/index', False)
assert enabled
def test_labextensionpy_enable(self):
self._inject_mock_extension()
install_labextension_python('mockextension', user=True)
enable_labextension_python('mockextension')
config_dir = os.path.join(_get_config_dir(user=True), 'labconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('jupyterlab_config').get('LabApp', {}).get('labextensions', {}).get('mockextension', False)
assert enabled
def test_nbextensionpy_enable(self):
self._inject_mock_extension('notebook')
install_nbextension_python('mockextension', user=True)
enable_nbextension_python('mockextension')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get('_mockdestination/index', False)
assert enabled
def toggle_serverextension_python(import_name, enabled=None, parent=None,
user=True, sys_prefix=False, logger=None):
"""Toggle a server extension.
By default, toggles the extension in the system-wide Jupyter configuration
location (e.g. /usr/local/etc/jupyter).
Parameters
----------
import_name : str
Importable Python module (dotted-notation) exposing the magic-named
`load_jupyter_server_extension` function
enabled : bool [default: None]
Toggle state for the extension. Set to None to toggle, True to enable,
and False to disable the extension.
parent : Configurable [default: None]
user : bool [default: True]
Toggle in the user's configuration location (e.g. ~/.jupyter).
sys_prefix : bool [default: False]
Toggle in the current Python environment's configuration location
(e.g. ~/.envs/my-env/etc/jupyter). Will override `user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
cfg = cm.get("jupyter_notebook_config")
server_extensions = (
cfg.setdefault("NotebookApp", {})
.setdefault("server_extensions", [])
)
old_enabled = import_name in server_extensions
new_enabled = enabled if enabled is not None else not old_enabled
if logger:
if new_enabled:
logger.info(u"Enabling: %s" % (import_name))
else:
logger.info(u"Disabling: %s" % (import_name))
if new_enabled:
if not old_enabled:
server_extensions.append(import_name)
elif old_enabled:
while import_name in server_extensions:
server_extensions.pop(server_extensions.index(import_name))
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
cm.update("jupyter_notebook_config", cfg)
if new_enabled:
validate_serverextension(import_name, logger)
def test_enable(self):
"""Should add the bundler to the notebook configuration."""
enable_bundler_python('notebook.bundler.zip_bundler')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
bundlers = cm.get('notebook').get('bundlerextensions', {})
self.assertEqual(len(bundlers), 1)
self.assertIn('notebook_zip_download', bundlers)
def test_disable(self):
"""Should remove the bundler from the notebook configuration."""
self.test_enable()
disable_bundler_python('notebook.bundler.zip_bundler')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
bundlers = cm.get('notebook').get('bundlerextensions', {})
self.assertEqual(len(bundlers), 0)
def test_enable(self):
"""Should add the bundler to the notebook configuration."""
enable_bundler_python('notebook.bundler.zip_bundler')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
bundlers = cm.get('notebook').get('bundlerextensions', {})
self.assertEqual(len(bundlers), 1)
self.assertIn('notebook_zip_download', bundlers)
def test_disable(self):
"""Should remove the bundler from the notebook configuration."""
self.test_enable()
disable_bundler_python('notebook.bundler.zip_bundler')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
bundlers = cm.get('notebook').get('bundlerextensions', {})
self.assertEqual(len(bundlers), 0)
def uninstall_nbextension(dest,
require=None,
user=False,
sys_prefix=False,
prefix=None,
nbextensions_dir=None,
logger=None):
"""Uninstall a Javascript extension of the notebook
Removes staged files and/or directories in the nbextensions directory and
removes the extension from the frontend config.
Parameters
----------
dest : str
path to file, directory, zip or tarball archive, or URL to install
name the nbextension is installed to. For example, if destination is 'foo', then
the source file will be installed to 'nbextensions/foo', regardless of the source name.
This cannot be specified if an archive is given as the source.
require : str [optional]
require.js path used to load the extension.
If specified, frontend config loading extension will be removed.
user : bool [default: False]
Whether to install to the user's nbextensions directory.
Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/nbextensions).
prefix : str [optional]
Specify install prefix, if it should differ from default (e.g. /usr/local).
Will install to ``<prefix>/share/jupyter/nbextensions``
nbextensions_dir : str [optional]
Specify absolute path of nbextensions directory explicitly.
logger : Jupyter logger [optional]
Logger instance to use
"""
nbext = _get_nbextension_dir(user=user,
sys_prefix=sys_prefix,
prefix=prefix,
nbextensions_dir=nbextensions_dir)
dest = cast_unicode_py2(dest)
full_dest = pjoin(nbext, dest)
if os.path.lexists(full_dest):
if logger:
logger.info("Removing: %s" % full_dest)
if os.path.isdir(full_dest) and not os.path.islink(full_dest):
shutil.rmtree(full_dest)
else:
os.remove(full_dest)
# Look through all of the config sections making sure that the nbextension
# doesn't exist.
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if require:
for section in NBCONFIG_SECTIONS:
cm.update(section, {"load_extensions": {require: None}})
def _set_labextension_state(name, state,
user=True, sys_prefix=False, logger=None):
"""Set whether the JupyterLab frontend should use the named labextension
Returns True if the final state is the one requested.
Parameters
name : string
The name of the extension.
state : bool
The state in which to leave the extension
user : bool [default: True]
Whether to update the user's .jupyter/labextensions directory
sys_prefix : bool [default: False]
Whether to update the sys.prefix, i.e. environment. Will override
`user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix), 'labconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} extension {}...".format(
"Enabling" if state else "Disabling",
name
))
cfg = cm.get("jupyterlab_config")
labextensions = (
cfg.setdefault("LabApp", {})
.setdefault("labextensions", {})
)
old_enabled = labextensions.get(name, None)
new_enabled = state if state is not None else not old_enabled
if logger:
if new_enabled:
logger.info(u"Enabling: %s" % (name))
else:
logger.info(u"Disabling: %s" % (name))
labextensions[name] = new_enabled
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
cm.update("jupyterlab_config", cfg)
if new_enabled:
full_dest = find_labextension(name)
validate_labextension_folder(name, full_dest, logger=logger)
return old_enabled == state
def _set_labextension_state(name,
state,
user=True,
sys_prefix=False,
logger=None):
"""Set whether the JupyterLab frontend should use the named labextension
Returns True if the final state is the one requested.
Parameters
name : string
The name of the extension.
state : bool
The state in which to leave the extension
user : bool [default: True]
Whether to update the user's .jupyter/labextensions directory
sys_prefix : bool [default: False]
Whether to update the sys.prefix, i.e. environment. Will override
`user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix), 'labconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} extension {}...".format(
"Enabling" if state else "Disabling", name))
cfg = cm.get("jupyterlab_config")
labextensions = (cfg.setdefault("LabApp",
{}).setdefault("labextensions", {}))
old_enabled = labextensions.get(name, None)
new_enabled = state if state is not None else not old_enabled
if logger:
if new_enabled:
logger.info(u"Enabling: %s" % (name))
else:
logger.info(u"Disabling: %s" % (name))
labextensions[name] = new_enabled
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
cm.update("jupyterlab_config", cfg)
if new_enabled:
full_dest = find_labextension(name)
validate_labextension_folder(name, full_dest, logger=logger)
return old_enabled == state
def install(enable=False, disable=False, prefix=None, verbose=False):
"""Install the nb_conda_kernels config piece.
Parameters
----------
enable: bool
Enable the BeakerX server config on every notebook launch
disable: bool
Disable BeakerX server config
"""
if verbose:
log.setLevel(logging.DEBUG)
if enable == disable:
log.error("Please provide (one of) --enable or --disable")
raise ValueError(enable, disable)
log.info("{}abling BeakerX server config...".format("En" if enable else "Dis"))
path = jupyter_config_dir()
if prefix is not None:
path = join(prefix, "etc", "jupyter")
if not exists(path):
log.debug("Making directory {}...".format(path))
os.makedirs(path)
cm = BaseJSONConfigManager(config_dir=path)
cfg = cm.get("jupyter_notebook_config")
log.debug("Existing config in {}...\n{}".format(path, pretty(cfg)))
nb_app = cfg.setdefault("KernelSpecManager", {})
if enable:
nb_app.update({KSMC: CKSM})
elif disable and nb_app.get(KSMC, None) == CKSM:
nb_app.pop(KSMC)
log.debug("Writing config in {}...".format(path))
cm.set("jupyter_notebook_config", cfg)
cfg = cm.get("jupyter_notebook_config")
log.debug("Verifying config in {}...\n{}".format(path, pretty(cfg)))
if enable:
assert cfg["KernelSpecManager"][KSMC] == CKSM
else:
assert KSMC not in cfg["KernelSpecManager"]
log.info("{}abled BeakerX server config".format("En" if enable else "Dis"))
def test_nbextension_enable(self):
with TemporaryDirectory() as d:
f = u'ƒ.js'
src = pjoin(d, f)
touch(src)
install_nbextension(src, user=True)
enable_nbextension(section='notebook', require=u'ƒ')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get(u'ƒ', False)
assert enabled
def test_labextension_enable(self):
with TemporaryDirectory() as d:
f = u'ƒ.js'
src = pjoin(d, f)
touch(src)
install_labextension(src, self.name, user=True)
enable_labextension(self.name)
config_dir = os.path.join(_get_config_dir(user=True), 'labconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('jupyterlab_config').get('LabApp', {}).get('labextensions', {}).get(self.name, False)
assert enabled
def test_nbextension_enable(self):
with TemporaryDirectory() as d:
f = u'ƒ.js'
src = pjoin(d, f)
touch(src)
install_nbextension(src, user=True)
enable_nbextension(section='notebook', require=u'ƒ')
config_dir = os.path.join(_get_config_dir(user=True), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
enabled = cm.get('notebook').get('load_extensions', {}).get(u'ƒ', False)
assert enabled
def labextensions(self):
extensions = []
config_dirs = [
os.path.join(p, 'labconfig') for p in jupyter_config_path()
]
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get("jupyterlab_config")
labextensions = (data.setdefault("LabApp", {}).setdefault(
"labextensions", {}))
for name, enabled in labextensions.items():
if enabled:
extensions.append(name)
return extensions
def _write_config_data(data, user=False, sys_prefix=False):
"""Update the config for the current context
Parameters
----------
data : object
An object which can be accepted by ConfigManager.update
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
config_man = BaseJSONConfigManager(config_dir=config_dir)
config_man.update('jupyter_notebook_config', data)
def get_labextensions(parent=None):
"""Get the list of enabled and valid lab extensions"""
extensions = []
config_dirs = [os.path.join(p, 'labconfig') for p in jupyter_config_path()]
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
data = cm.get("jupyterlab_config")
labextensions = (data.setdefault("LabApp",
{}).setdefault("labextensions", {}))
for name, enabled in labextensions.items():
if enabled:
warnings = validate_labextension(name)
if not warnings:
extensions.append(name)
return extensions
def _write_config_data(data, user=False, sys_prefix=False):
"""Update the config for the current context
Parameters
----------
data : object
An object which can be accepted by ConfigManager.update
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
config_man = BaseJSONConfigManager(config_dir=config_dir)
config_man.update('jupyterlab_config', data)
def uninstall_nbextension(
dest, require=None, user=False, sys_prefix=False, prefix=None, nbextensions_dir=None, logger=None
):
"""Uninstall a Javascript extension of the notebook
Removes staged files and/or directories in the nbextensions directory and
removes the extension from the frontend config.
Parameters
----------
dest : str
path to file, directory, zip or tarball archive, or URL to install
name the nbextension is installed to. For example, if destination is 'foo', then
the source file will be installed to 'nbextensions/foo', regardless of the source name.
This cannot be specified if an archive is given as the source.
require : str [optional]
require.js path used to load the extension.
If specified, frontend config loading extension will be removed.
user : bool [default: False]
Whether to install to the user's nbextensions directory.
Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/nbextensions).
prefix : str [optional]
Specify install prefix, if it should differ from default (e.g. /usr/local).
Will install to ``<prefix>/share/jupyter/nbextensions``
nbextensions_dir : str [optional]
Specify absolute path of nbextensions directory explicitly.
logger : Jupyter logger [optional]
Logger instance to use
"""
nbext = _get_nbextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir)
dest = cast_unicode_py2(dest)
full_dest = pjoin(nbext, dest)
if os.path.lexists(full_dest):
if logger:
logger.info("Removing: %s" % full_dest)
if os.path.isdir(full_dest) and not os.path.islink(full_dest):
shutil.rmtree(full_dest)
else:
os.remove(full_dest)
# Look through all of the config sections making sure that the nbextension
# doesn't exist.
config_dir = os.path.join(_get_config_dir(user=user, sys_prefix=sys_prefix), "nbconfig")
cm = BaseJSONConfigManager(config_dir=config_dir)
if require:
for section in NBCONFIG_SECTIONS:
cm.update(section, {"load_extensions": {require: None}})
def get_labextensions(parent=None):
"""Get the list of enabled lab extensions"""
extensions = []
config_dirs = [os.path.join(p, 'labconfig') for p in
jupyter_config_path()]
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir)
data = cm.get("jupyterlab_config")
labextensions = (
data.setdefault("LabApp", {})
.setdefault("labextensions", {})
)
for name, enabled in labextensions.items():
if enabled:
extensions.append(name)
return extensions
def _read_config_data(user=False, sys_prefix=False):
"""Get the config for the current context
Returns the string to the enviornment
Parameters
----------
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
config_man = BaseJSONConfigManager(config_dir=config_dir)
return config_man.get('jupyterlab_config')
def _read_config_data(user=False, sys_prefix=False):
"""Get the config for the current context
Returns the string to the enviornment
Parameters
----------
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
config_man = BaseJSONConfigManager(config_dir=config_dir)
return config_man.get('jupyter_notebook_config')
def _find_disable_nbextension(section, require, logger=None):
"""Disable an nbextension from the first config location where it is enabled.
Returns True if it changed any config, False otherwise.
"""
for config_dir in jupyter_config_path():
cm = BaseJSONConfigManager(
config_dir=os.path.join(config_dir, 'nbconfig'))
d = cm.get(section)
if d.get('load_extensions', {}).get(require, None):
if logger:
logger.info("Disabling %s extension in %s", require, config_dir)
cm.update(section, {'load_extensions': {require: None}})
return True
return False
def _find_disable_nbextension(section, require, logger=None):
"""Disable an nbextension from the first config location where it is enabled.
Returns True if it changed any config, False otherwise.
"""
for config_dir in jupyter_config_path():
cm = BaseJSONConfigManager(
config_dir=os.path.join(config_dir, 'nbconfig'))
d = cm.get(section)
if d.get('load_extensions', {}).get(require, None):
if logger:
logger.info("Disabling %s extension in %s", require,
config_dir)
cm.update(section, {'load_extensions': {require: None}})
return True
return False
def list_server_extensions(self):
"""List all enabled and disabled server extensions, by config path
Enabled extensions are validated, potentially generating warnings.
"""
config_dirs = jupyter_config_path()
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get("jupyter_notebook_config")
server_extensions = (data.setdefault("NotebookApp", {}).setdefault(
"nbserver_extensions", {}))
if server_extensions:
print(u'config dir: {}'.format(config_dir))
for import_name, enabled in server_extensions.items():
print(u' {} {}'.format(
import_name, GREEN_ENABLED if enabled else RED_DISABLED))
validate_serverextension(import_name, self.log)
def _set_nbextension_state(section, require, state,
user=True, sys_prefix=False, logger=None):
"""Set whether the section's frontend should require the nbextension."""
user = False if sys_prefix else user
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} {} extension {}...".format(
"Enabling" if state else "Disabling",
section,
require
))
cm.update(section, {"load_extensions": {require: state}})
validate_nbextension(require, logger=logger)
return cm.get(section).get(require) == state
def _set_nbextension_state(section,
require,
state,
user=True,
sys_prefix=False,
logger=None,
root=None):
"""Set whether the section's frontend should require the named nbextension
Returns True if the final state is the one requested.
Parameters
----------
section : string
The section of the server to change, one of NBCONFIG_SECTIONS
require : string
An importable AMD module inside the nbextensions static path
state : bool
The state in which to leave the extension
user : bool [default: True]
Whether to update the user's .jupyter/nbextensions directory
sys_prefix : bool [default: False]
Whether to update the sys.prefix, i.e. environment. Will override
`user`.
logger : Jupyter logger [optional]
Logger instance to use
root : str [optional]
Specify absolute path to root directory.
All other paths will be treated as subdirectories of this.
"""
user = False if sys_prefix else user
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix, root=root),
'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} {} extension {}...".format(
"Enabling" if state else "Disabling", section, require))
cm.update(section, {"load_extensions": {require: state}})
validate_nbextension(require, logger=logger)
return cm.get(section).get(require) == state
def _set_bundler_state(name, label, module_name, group, state,
user=True, sys_prefix=False, logger=None):
"""Set whether a bundler is enabled or disabled.
Returns True if the final state is the one requested.
Parameters
----------
name : string
Unique name of the bundler
label : string
Human-readable label for the bundler menu item in the notebook UI
module_name : string
Dotted module/package name containing the bundler
group : string
'download' or 'deploy' indicating the parent menu containing the label
state : bool
The state in which to leave the extension
user : bool [default: True]
Whether to update the user's .jupyter/nbconfig directory
sys_prefix : bool [default: False]
Whether to update the sys.prefix, i.e. environment. Will override
`user`.
logger : Jupyter logger [optional]
Logger instance to use
"""
user = False if sys_prefix else user
config_dir = os.path.join(
_get_config_dir(user=user, sys_prefix=sys_prefix), 'nbconfig')
cm = BaseJSONConfigManager(config_dir=config_dir)
if logger:
logger.info("{} {} bundler {}...".format(
"Enabling" if state else "Disabling",
name,
module_name
))
if state:
cm.update(BUNDLER_SECTION, {
BUNDLER_SUBSECTION: {
name: {
"label": label,
"module_name": module_name,
"group" : group
}
}
})
else:
cm.update(BUNDLER_SECTION, {
BUNDLER_SUBSECTION: {
name: None
}
})
return (cm.get(BUNDLER_SECTION)
.get(BUNDLER_SUBSECTION, {})
.get(name) is not None) == state
def _write_config_data(data, user=False, sys_prefix=False, logger=None):
"""Update the config for the current context
Parameters
----------
data : object
An object which can be accepted by ConfigManager.update
user : bool [default: False]
Get the user's .jupyter config directory
sys_prefix : bool [default: False]
Get sys.prefix, i.e. ~/.envs/my-env/etc/jupyter
logger: logger instance
The logger instance.
"""
config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix)
if logger:
logger.info(u"- Writing config: {}".format(config_dir))
config_man = BaseJSONConfigManager(config_dir=config_dir)
config_man.update(CONFIG_NAME, data)
def list_labextensions(self):
"""List all the labextensions"""
config_dirs = [
os.path.join(p, 'labconfig') for p in jupyter_config_path()
]
print("Known labextensions:")
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get("jupyterlab_config")
labextensions = (data.setdefault("LabApp", {}).setdefault(
"labextensions", {}))
if labextensions:
print(u'config dir: {}'.format(config_dir))
for name, enabled in labextensions.items():
print(u' {} {}'.format(
name, GREEN_ENABLED if enabled else RED_DISABLED))
validate_labextension(name, self.log)
def list_server_extensions(self):
"""List all enabled and disabled server extensions, by config path
Enabled extensions are validated, potentially generating warnings.
"""
config_dirs = jupyter_config_path()
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get("jupyter_notebook_config")
server_extensions = (
data.setdefault("NotebookApp", {})
.setdefault("nbserver_extensions", {})
)
if server_extensions:
print(u'config dir: {}'.format(config_dir))
for import_name, enabled in server_extensions.items():
print(u' {} {}'.format(
import_name,
GREEN_ENABLED if enabled else RED_DISABLED))
validate_serverextension(import_name, self.log)
def list_labextensions(self):
"""List all the labextensions"""
config_dirs = [os.path.join(p, 'labconfig') for p in jupyter_config_path()]
print("Known labextensions:")
for config_dir in config_dirs:
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get("jupyterlab_config")
labextensions = (
data.setdefault("LabApp", {})
.setdefault("labextensions", {})
)
if labextensions:
print(u'config dir: {}'.format(config_dir))
for name, enabled in labextensions.items():
print(u' {} {}'.format(
name,
GREEN_ENABLED if enabled else RED_DISABLED))
validate_labextension(name, self.log)
def set_password(args):
password = args.password
while not password :
password1 = getpass("" if args.quiet else "Provide password: "******"" if args.quiet else "Repeat password: "******"Passwords do not match, try again")
elif len(password1) < 4:
print("Please provide at least 4 characters")
else:
password = password1
password_hash = passwd(password)
cfg = BaseJSONConfigManager(config_dir=jupyter_config_dir())
cfg.update('jupyter_notebook_config', {
'NotebookApp': {
'password': password_hash,
}
})
if not args.quiet:
print("password stored in config dir: %s" % jupyter_config_dir())
def list_labextensions(self):
"""List all the labextensions"""
print("Known labextensions:")
for config_dir in jupyter_config_path():
cm = BaseJSONConfigManager(parent=self, config_dir=config_dir)
data = cm.get(CONFIG_NAME)
labextensions = (data.setdefault(CONFIG_SECTION, {}).setdefault(
"labextensions", {}))
if labextensions:
print(u'config dir: {}'.format(config_dir))
for name, config in sorted(labextensions.items()):
if isinstance(config, bool):
config = dict(enabled=config)
enabled = config['enabled']
full_dest = find_labextension(name)
print(u' {} {}: {}'.format(
name, GREEN_ENABLED if enabled else RED_DISABLED,
full_dest if not None else RED_X + " Files not found"))
if full_dest is not None:
validate_labextension_folder(name, full_dest, self.log)
