def setup_info(): server_cm = ConfigManager(config_dir=j_path.jupyter_config_dir()) cfg = server_cm.get('jupyter_notebook_config') server_extensions = (cfg.setdefault('NotebookApp', {}) .setdefault('server_extensions', []) ) extension = 'hide_code.hide_code' if extension not in server_extensions: ext = 'Not loaded' else: ext = 'Loaded' files = [] for (dirpath, dirnames, filenames) in os.walk(path.join(Utils.get_site_package_dir(), 'hide_code')): files.extend(filenames) break custom_js = '' with open(path.join(Utils.get_site_package_dir(), 'notebook','static','custom','custom.js'), 'r') as f: for line in iter(f): if not line.startswith(' *') and not line.startswith('/'): custom_js = custom_js + line + ' ' return ("Installation dir: {0}\nConfiguration dir: {1}\nExport handler extensions: {2}\nHide Code files: {3}\nCustom JS contents: {4}" .format(Utils.get_site_package_dir(), j_path.jupyter_config_dir(), ext, files, custom_js))
def test_config_dir_windows(): with no_config_env: config = jupyter_config_dir() assert config == home_jupyter with config_env: config = jupyter_config_dir() assert config == jupyter_config_env
def test_config_dir_linux(): with windows, no_config_env: config = jupyter_config_dir() assert config == home_jupyter with windows, config_env: config = jupyter_config_dir() assert config == jupyter_config_env
def test_config_dir_darwin(): with darwin, no_config_env: config = jupyter_config_dir() assert config == home_jupyter with darwin, config_env: config = jupyter_config_dir() assert config == jupyter_config_env
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 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 enable_server_extension(self, extension): loader = JSONFileConfigLoader('jupyter_notebook_config.json', jupyter_config_dir()) try: config = loader.load_config() except ConfigFileNotFound: config = Config() if 'server_extensions' not in config.NotebookApp: config.NotebookApp.server_extensions = [] if extension not in config.NotebookApp.server_extensions: config.NotebookApp.server_extensions.append(extension) # save the updated config with io.open(os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json'), 'w+') as f: f.write(six.u(json.dumps(config, indent=2)))
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 get_notebook_path(): """Returns the absolute path of the Notebook or None if it cannot be determined NOTE: works only when the security is token-based or there is also no password """ connection_file = os.path.basename(ipykernel.get_connection_file()) kernel_id = connection_file.split('-', 1)[1].split('.')[0] # Assumes you've already run `jupyter notebook --generate-config` to generate # `jupyter_notebook_config.py` and have edited and/or uncommented the line # containing `c.FileContentsManager.root_dir =`: c = Config() file_path = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.py') exec(open(file_path).read()) root_dir = c['FileContentsManager']['root_dir'] for srv in notebookapp.list_running_servers(): try: if srv['token'] == '' and not srv[ 'password']: # No token and no password, ahem... req = urllib.request.urlopen(srv['url'] + 'api/sessions') else: req = urllib.request.urlopen(srv['url'] + 'api/sessions?token=' + srv['token']) sessions = json.load(req) for sess in sessions: if sess['kernel']['id'] == kernel_id: return os.path.abspath( os.path.join(root_dir, sess['notebook']['path'])) except: pass # There may be stale entries in the runtime directory return None
def _get_config_manager(level): """Get the location of config files for the current context Returns the string to the environment """ allowed = ["all", "user", "sys_prefix", "system", "app", "extension"] if level not in allowed: raise ValueError(f"Page config level must be one of: {allowed}") config_name = "labconfig" if level == "all": return ConfigManager(config_dir_name=config_name) if level == "user": config_dir = jupyter_config_dir() elif level == "sys_prefix": # Delayed import since this gets monkey-patched in tests from jupyter_core.paths import ENV_CONFIG_PATH config_dir = ENV_CONFIG_PATH[0] else: config_dir = SYSTEM_CONFIG_PATH[0] full_config_path = osp.join(config_dir, config_name) return ConfigManager(read_config_path=[full_config_path], write_config_dir=full_config_path)
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 save(self, content): makedirs(paths.jupyter_config_dir(), exist_ok=True) with fdopen(os_open(self.__config_path, O_RDWR | O_CREAT, 0o600), 'w+') as json_file: json_file.seek(0) json_file.truncate() json_file.write( json.dumps(self.__dict_merge(self.__default_config.copy(), content), indent=2, sort_keys=True))
def get_config_dir(args): if args.system: return jp.SYSTEM_CONFIG_PATH[0] elif args.sys_prefix: return jp.ENV_CONFIG_PATH[0] else: return jp.jupyter_config_dir()
def jupyter_config_dirs(): import jupyter_core.paths as jupypaths cdirs = {'user': jupypaths.jupyter_config_dir(), 'environment': jupypaths.ENV_CONFIG_PATH[0], 'system': jupypaths.SYSTEM_CONFIG_PATH[0]} return {k: os.path.join(v, 'nbconfig') for k,v in cdirs.items()}
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_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 jupyter(): '''Configuration for Jupyter ''' # Get the path to Jupyter config jupyter_dir = jupyter_config_dir() # Set a target path for the CSS file custom_dir = os.path.join(jupyter_dir, 'custom') custom_css_path = os.path.join(custom_dir, 'custom.css') if os.path.isfile(custom_css_path): # Incase the user already uses a custom CSS file, back it up backup_css_path = os.path.join(custom_dir, 'custom.backup') os.rename(custom_css_path, backup_css_path) else: # Otherwise check if the custom folder is there if not os.path.isdir(custom_dir): os.makedirs(custom_dir) resource_package = 'nbfancy' config_path = '/tools/css' # Do not use os.path.join() css_dir = pkg_resources.resource_filename(resource_package, config_path) # Copy our custom CSS file to the path copy(os.path.join(css_dir, 'custom.css'), custom_css_path) try: copytree(os.path.join(css_dir, 'css'), os.path.join(custom_dir, 'css')) except FileExistsError as e: print('ERROR: You already have a directory named') print(os.path.join(custom_dir, 'css')) print('Remove or rename and try again.') print( 'Install will continue, on the assumption that these files are left over from a previous build.' )
def persist_config(config_file=None, mode=0o600): """Context manager that can be used to modify a config object On exit of the context manager, the config will be written back to disk, by default with user-only (600) permissions. """ if config_file is None: config_file = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json') loader = JSONFileConfigLoader(os.path.basename(config_file), os.path.dirname(config_file)) try: config = loader.load_config() except ConfigFileNotFound: config = Config() yield config with io.open(config_file, 'w', encoding='utf8') as f: f.write(cast_unicode(json.dumps(config, indent=2))) try: os.chmod(config_file, mode) except Exception as e: tb = traceback.format_exc() warnings.warn("Failed to set permissions on %s:\n%s" % (config_file, tb), RuntimeWarning)
def save_setting_to_file(content): makedirs(paths.jupyter_config_dir(), exist_ok=True) with fdopen( osopen(EnvironmentSettings.config_path, O_RDWR | O_CREAT | O_TRUNC, 0o600), 'w+') as file: file.write( json.dumps(json.loads(content), indent=4, sort_keys=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 persist_config(config_file=None, mode=0o600): """Context manager that can be used to modify a config object On exit of the context manager, the config will be written back to disk, by default with user-only (600) permissions. """ if config_file is None: config_file = os.path.join(jupyter_config_dir(), "jupyter_server_config.json") os.makedirs(os.path.dirname(config_file), exist_ok=True) loader = JSONFileConfigLoader(os.path.basename(config_file), os.path.dirname(config_file)) try: config = loader.load_config() except ConfigFileNotFound: config = Config() yield config with open(config_file, "w", encoding="utf8") as f: f.write(json.dumps(config, indent=2)) try: os.chmod(config_file, mode) except Exception: tb = traceback.format_exc() warnings.warn(f"Failed to set permissions on {config_file}:\n{tb}", RuntimeWarning)
def persist_config(config_file=None, mode=0o600): """Context manager that can be used to modify a config object On exit of the context manager, the config will be written back to disk, by default with user-only (600) permissions. """ if config_file is None: config_file = os.path.join(jupyter_config_dir(), 'jupyter_server_config.json') loader = JSONFileConfigLoader(os.path.basename(config_file), os.path.dirname(config_file)) try: config = loader.load_config() except ConfigFileNotFound: config = Config() yield config with io.open(config_file, 'w', encoding='utf8') as f: f.write(cast_unicode(json.dumps(config, indent=2))) try: os.chmod(config_file, mode) except Exception as e: tb = traceback.format_exc() warnings.warn("Failed to set permissions on %s:\n%s" % (config_file, tb), RuntimeWarning)
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 _install_server_extension(): # Install 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 jupyter_config_dirs(): import jupyter_core.paths as jupypaths cdirs = { 'user': jupypaths.jupyter_config_dir(), 'environment': jupypaths.ENV_CONFIG_PATH[0], 'system': jupypaths.SYSTEM_CONFIG_PATH[0] } return {k: os.path.join(v, 'nbconfig') for k, v in cdirs.items()}
def clear_download(cls): localdir = os.path.join(jupyter_config_dir(), "custom", "labext", cls.id()) localdir = Path(localdir) if Path(localdir / "js").exists(): shutil.rmtree(os.path.join(localdir, "js")) if Path(localdir / "css").exists(): shutil.rmtree(os.path.join(localdir, "css"))
def enable_server_extension(self, extension): loader = JSONFileConfigLoader('jupyter_notebook_config.json', jupyter_config_dir()) try: config = loader.load_config() except ConfigFileNotFound: config = Config() if 'server_extensions' not in config.NotebookApp: config.NotebookApp.server_extensions = [] if extension not in config.NotebookApp.server_extensions: config.NotebookApp.server_extensions.append(extension) # save the updated config with io.open( os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json'), 'w+') as f: f.write(six.u(json.dumps(config, indent=2)))
class TableSettings: def __init__(self): pass def save(self, content): makedirs(paths.jupyter_config_dir(), exist_ok=True) with fdopen(os_open(self.__config_path, O_RDWR | O_CREAT, 0o600), 'w+') as json_file: json_file.seek(0) json_file.truncate() json_file.write( json.dumps(self.__dict_merge(self.__default_config.copy(), content), indent=2, sort_keys=True)) def load(self): try: json_file = open(self.__config_path) data = self.__dict_merge(self.__default_config, json.load(json_file)) except: data = self.__default_config self.save(data) return data def load_options(self): return self.load().get('beakerx_tabledisplay').get('options') __default_config = { "beakerx_tabledisplay": { "version": 1, "options": { "auto_link_table_links": False, "show_publication": True } } } __config_path = path.join(paths.jupyter_config_dir(), 'beakerx_tabledisplay.json') def __dict_merge(self, target, *args): if len(args) > 1: for obj in args: self.__dict_merge(target, obj) return target obj = args[0] if not isinstance(obj, dict): return obj for k, v in obj.items(): if k in target and isinstance(target[k], dict): self.__dict_merge(target[k], v) else: target[k] = copy.deepcopy(v) return target
def __init__(self, name, **kwargs): self.name = name self.prefix = kwargs.get('prefix', None) self.kwargs = kwargs if self.prefix is None: self.path = jupyter_config_dir() else: self.path = join(self.prefix, "etc", "jupyter") self.cm = ConfigManager(config_dir=join(self.path, 'nbconfig')) self.cm_server = ConfigManager(config_dir=self.path)
def setup_server_config(self, EXT_CONFIG): # Set the server extension to launch on startup by modifying the # jupyter_notebook_config.py CONFIG = os.path.join(jupyter_config_dir(), 'jupyter_config.py') ensure_dir_exists(jupyter_config_dir()) if os.path.isfile(CONFIG): pass else: c = JupyterApp() c.write_default_config() with open(CONFIG, 'r+') as fh: lines = fh.read() for i in EXT_CONFIG: if i not in lines: fh.seek(0, 2) fh.write('\n') fh.write(i) print("OUTCOME: Added the Stepsize server extension " "configuration to the jupyter_config.py")
def save_json_config(json_file, newconfig): """ Save config as JSON file :param json_file: Filename of JSON file :param newconfig: New traitlets based configuration """ s = json.dumps(newconfig, indent=2, separators=(',', ': '), sort_keys=True) json_config = os.path.join(jupyter_config_dir(), json_file) make_backup(json_config) with open(json_config, 'w') as f: f.write(s)
def test_paths(): output = get_jupyter_output('--paths') for d in (jupyter_config_dir(), jupyter_data_dir(), jupyter_runtime_dir()): assert d in output for key in ('config', 'data', 'runtime'): assert ('%s:' % key) in output for path in (jupyter_config_path(), jupyter_path()): for d in path: assert d in output
def test_paths(): output = get_jupyter_output("--paths") for d in (jupyter_config_dir(), jupyter_data_dir(), jupyter_runtime_dir()): assert d in output for key in ("config", "data", "runtime"): assert ("%s:" % key) in output for path in (jupyter_config_path(), jupyter_path()): for d in path: assert d in output
def install_post_save_hook(config_path: Optional[Path] = None): """Splices the post save hook into the global Jupyter configuration file """ if config_path is None: config_dir = jupyter_config_dir() config_path = Path(config_dir) / "jupyter_notebook_config.py" config_path = config_path.expanduser().resolve() if not config_path.exists(): logger.debug( f"No existing Jupyter configuration detected at {config_path}. Creating..." ) config_path.parent.mkdir(exist_ok=True, parents=True) with config_path.open("w") as fp: fp.write(post_save_hook_initialize_block) logger.info("nbautoexport post-save hook installed.") return # If config exists, check for existing nbautoexport initialize block and install as appropriate logger.debug(f"Detected existing Jupyter configuration at {config_path}") with config_path.open("r") as fp: config = fp.read() if block_regex.search(config): logger.debug("Detected existing nbautoexport post-save hook.") version_match = version_regex.search(config) if version_match: existing_version = version_match.group() logger.debug( f"Existing post-save hook is version {existing_version}") else: existing_version = "" logger.debug("Existing post-save hook predates versioning.") if parse_version(existing_version) < parse_version(__version__): logger.info( f"Updating nbautoexport post-save hook with version {__version__}..." ) with config_path.open("w") as fp: # Open as w replaces existing file. We're replacing entire config. fp.write( block_regex.sub(post_save_hook_initialize_block, config)) else: logger.debug("No changes made.") return else: logger.info("Installing post-save hook.") with config_path.open("a") as fp: # Open as a just appends. We append block at the end of existing file. fp.write("\n" + post_save_hook_initialize_block) logger.info("nbautoexport post-save hook installed.")
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_server_config", {"ServerApp": { "password": password_hash, }}) if not args.quiet: print("password stored in config dir: %s" % jupyter_config_dir())
def _get_config_dir(level): """Get the location of config files for the current context Returns the string to the environment """ if level == 'user': extdir = jupyter_config_dir() elif level == 'sys_prefix': extdir = ENV_CONFIG_PATH[0] else: extdir = SYSTEM_CONFIG_PATH[0] return extdir
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 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_jupyter_config_path_prefer_env(): with prefer_env, patch.object(site, 'ENABLE_USER_SITE', True): path = jupyter_config_path() # deduplicated expected values values = list(dict.fromkeys([ paths.ENV_CONFIG_PATH[0], jupyter_config_dir(), os.path.join(site.getuserbase(), 'etc', 'jupyter') ])) for p,v in zip(path, values): assert p == v
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 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 load_json_config(json_filename): """ Load config as JSON file :param json_filename: Filename of JSON file :return: Traitlets based configuration """ json_config = os.path.join(jupyter_config_dir(), json_filename) if debug is True: print("Configuring %s" % json_config) if os.path.isfile(json_config) is True: cl = JSONFileConfigLoader(json_config) config = cl.load_config() else: config = Config() return config
def _get_config_dir(user=False, sys_prefix=False): """Get the location of config files for the current context.""" user = False if sys_prefix else user if user and sys_prefix: raise ArgumentConflict( "Cannot specify more than one of user or sys_prefix") if user: nbext = jupyter_config_dir() elif sys_prefix: nbext = ENV_CONFIG_PATH[0] else: nbext = SYSTEM_CONFIG_PATH[0] return nbext
def save_setting_to_file(content): makedirs(paths.jupyter_config_dir(), exist_ok=True) with fdopen(osopen(EnvironmentSettings.config_path, O_RDWR | O_CREAT, 0o600), 'w+') as file: file_content = file.read() new_settings = json.loads(content) if file_content: saved_settings = json.loads(file_content) file.seek(0) file.truncate() for setting_name in new_settings['beakerx']: saved_settings['beakerx'][setting_name] = new_settings['beakerx'][setting_name] else: saved_settings = new_settings file.write(json.dumps(saved_settings, indent=4, sort_keys=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 __enter__(self): if JUPYTER: self.pdir = jupyter_config_dir() self.cff_name = 'jupyter_notebook_config.json' else: self.pdir = locate_profile(self.profile) self.cff_name = 'ipython_notebook_config.json' jc = JSONFileConfigLoader(self.cff_name, self.pdir) try: self.config = jc.load_config(); except (ConfigFileNotFound,ValueError): self.config = Config() return self.config
def persist_config(mode=0o600): """Context manager that can be use to modify a config object On exit of the context manager, the config will be written back to disk, by default with 600 permissions. """ loader = JSONFileConfigLoader('jupyter_notebook_config.json', jupyter_config_dir()) try: config = loader.load_config() except ConfigFileNotFound: config = Config() yield config filepath = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.json') with io.open(filepath, 'w') as f: f.write(six.u(json.dumps(config, indent=2))) try: os.chmod(filepath, mode) except Exception: traceback.print_exc() print("Something went wrong changing file permissions")
def remove_server_config(CONFIG, EXT_CONFIG): # Removes the config in the jupyter_config.py if os.path.isfile(CONFIG): # Creates a backup file timestamp = datetime.datetime.now().strftime("%d-%m-%Y_T%H-%M-%S") title = ('backup_config_' + timestamp + '.py') BACKUP = os.path.join(jupyter_config_dir(), title) print("ACTION: Creating a backup jupter_config.py, %s" % (BACKUP)) shutil.copyfile(CONFIG, BACKUP) # Counter count = 0 try: f = open(CONFIG, 'r') lines = f.readlines() f.close() f = open(CONFIG, 'w') for line in lines: if any(i in line for i in EXT_CONFIG): pass count += 1 else: f.write(line) f.truncate() f.close() if count > 0: print("OUTCOME: Removed the Stepsize extension " \ "configuration from the jupyter_config.py") except: print("WARNING: An error occured when trying to remove the " \ "Stepsize server configuration from the jupyter_config.py") print("ERROR: %s, at line %d" % (sys.exc_info()[0], sys.exc_traceback.tb_lineno)) else: print("WARNING: Unable to remove the Stepsize extension " \ "configuration since the jupyter_config.py does not exist in " \ "%s" % (jupyter_config_dir()))
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(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)
def _get_config_dir(user=False, sys_prefix=False): """Get the location of config files 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 """ user = False if sys_prefix else user if user and sys_prefix: raise ArgumentConflict("Cannot specify more than one of user or sys_prefix") if user: nbext = jupyter_config_dir() elif sys_prefix: nbext = ENV_CONFIG_PATH[0] else: nbext = SYSTEM_CONFIG_PATH[0] return nbext