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 _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_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 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 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 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 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 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)