def test_json(): tmpdir = tempfile.mkdtemp() try: root_data = dict(a=1, x=2, nest={'a': 1, 'x': 2}) with open(os.path.join(tmpdir, 'foo.json'), 'w') as f: json.dump(root_data, f) # also make a foo.d/ directory with multiple json files os.makedirs(os.path.join(tmpdir, 'foo.d')) with open(os.path.join(tmpdir, 'foo.d', 'a.json'), 'w') as f: json.dump(dict(a=2, b=1, nest={'a': 2, 'b': 1}), f) with open(os.path.join(tmpdir, 'foo.d', 'b.json'), 'w') as f: json.dump( dict(a=3, b=2, c=3, nest={ 'a': 3, 'b': 2, 'c': 3 }, only_in_b={'x': 1}), f) manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False) data = manager.get('foo') assert 'a' in data assert 'x' in data assert 'b' not in data assert 'c' not in data assert data['a'] == 1 assert 'x' in data['nest'] # if we write it out, it also shouldn't pick up the subdirectoy manager.set('foo', data) data = manager.get('foo') assert data == root_data manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=True) data = manager.get('foo') assert 'a' in data assert 'b' in data assert 'c' in data # files should be read in order foo.d/a.json foo.d/b.json foo.json assert data['a'] == 1 assert data['b'] == 2 assert data['c'] == 3 assert data['nest']['a'] == 1 assert data['nest']['b'] == 2 assert data['nest']['c'] == 3 assert data['nest']['x'] == 2 # when writing out, we don't want foo.d/*.json data to be included in the root foo.json manager.set('foo', data) manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False) data = manager.get('foo') assert data == root_data finally: shutil.rmtree(tmpdir)
def test_json(tmp_path): tmpdir = str(tmp_path) root_data = dict(a=1, x=2, nest={"a": 1, "x": 2}) with open(os.path.join(tmpdir, "foo.json"), "w") as f: json.dump(root_data, f) # also make a foo.d/ directory with multiple json files os.makedirs(os.path.join(tmpdir, "foo.d")) with open(os.path.join(tmpdir, "foo.d", "a.json"), "w") as f: json.dump(dict(a=2, b=1, nest={"a": 2, "b": 1}), f) with open(os.path.join(tmpdir, "foo.d", "b.json"), "w") as f: json.dump( dict(a=3, b=2, c=3, nest={ "a": 3, "b": 2, "c": 3 }, only_in_b={"x": 1}), f) manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False) data = manager.get("foo") assert "a" in data assert "x" in data assert "b" not in data assert "c" not in data assert data["a"] == 1 assert "x" in data["nest"] # if we write it out, it also shouldn't pick up the subdirectoy manager.set("foo", data) data = manager.get("foo") assert data == root_data manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=True) data = manager.get("foo") assert "a" in data assert "b" in data assert "c" in data # files should be read in order foo.d/a.json foo.d/b.json foo.json assert data["a"] == 1 assert data["b"] == 2 assert data["c"] == 3 assert data["nest"]["a"] == 1 assert data["nest"]["b"] == 2 assert data["nest"]["c"] == 3 assert data["nest"]["x"] == 2 # when writing out, we don't want foo.d/*.json data to be included in the root foo.json manager.set("foo", data) manager = BaseJSONConfigManager(config_dir=tmpdir, read_directory=False) data = manager.get("foo") assert data == root_data
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() # Iterate over all locations where extensions might be named. for config_dir in config_dirs: cm = BaseJSONConfigManager(parent=self, config_dir=config_dir) data = cm.get("jupyter_server_config") server_extensions = (data.setdefault("ServerApp", {}).setdefault( "jpserver_extensions", {})) if server_extensions: self.log.info(u'config dir: {}'.format(config_dir)) # Iterate over packages listed in jpserver_extensions. for pkg_name, enabled in server_extensions.items(): # Attempt to get extension metadata _, __ = _get_server_extension_metadata(pkg_name) self.log.info(u' {} {}'.format( pkg_name, GREEN_ENABLED if enabled else RED_DISABLED)) try: self.log.info(" - Validating {}...".format(pkg_name)) version = validate_server_extension(pkg_name) self.log.info(" {} {} {}".format( pkg_name, version, GREEN_OK)) except ExtensionValidationError as err: self.log.warn(" {} {}".format(RED_X, err))
def list_extensions(self): """List all the extensions""" config_dirs = [ os.path.join(p, 'serverconfig') 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('jupyter_server') if 'bundlerextensions' in data: if not head_shown: # only show heading if there is an extension 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 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_disable(self): """Should remove the bundler from the notebook configuration.""" self.test_enable() disable_bundler_python('jupyter_server.bundler.zip_bundler') config_dir = os.path.join(_get_config_dir(user=True), 'serverconfig') cm = BaseJSONConfigManager(config_dir=config_dir) bundlers = cm.get('jupyter_server').get('bundlerextensions', {}) self.assertEqual(len(bundlers), 0)
def test_enable(self): """Should add the bundler to the notebook configuration.""" enable_bundler_python('jupyter_server.bundler.zip_bundler') config_dir = os.path.join(_get_config_dir(user=True), 'serverconfig') cm = BaseJSONConfigManager(config_dir=config_dir) bundlers = cm.get('jupyter_server').get('bundlerextensions', {}) self.assertEqual(len(bundlers), 1) self.assertIn('notebook_zip_download', bundlers)
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 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/serverconfig 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), 'serverconfig') 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 toggle_server_extension_python(import_name, enabled=None, parent=None, user=False, sys_prefix=True): """Toggle the boolean setting for a given server extension in a Jupyter config file. """ sys_prefix = False if user else sys_prefix config_dir = _get_config_dir(user=user, sys_prefix=sys_prefix) cm = BaseJSONConfigManager(parent=parent, config_dir=config_dir) cfg = cm.get("jupyter_server_config") server_extensions = cfg.setdefault("ServerApp", {}).setdefault("jpserver_extensions", {}) old_enabled = server_extensions.get(import_name, None) new_enabled = enabled if enabled is not None else not old_enabled server_extensions[import_name] = new_enabled cm.update("jupyter_server_config", cfg)
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_server_config") server_extensions = data.setdefault("ServerApp", {}).setdefault( "jpserver_extensions", {}) if server_extensions: self.log.info(u"config dir: {}".format(config_dir)) for import_name, enabled in server_extensions.items(): self.log.info(u" {} {}".format( import_name, GREEN_ENABLED if enabled else RED_DISABLED)) try: self.log.info(" - Validating {}...".format(import_name)) _, __, version = validate_server_extension(import_name) self.log.info(" {} {} {}".format( import_name, version, GREEN_OK)) except ExtensionValidationError as err: self.log.warn(" {} {}".format(RED_X, err))
def get_config(user=True): cm = BaseJSONConfigManager(config_dir=_get_config_dir(user)) data = cm.get("jupyter_server_config") return data.get("ServerApp", {}).get("jpserver_extensions", {})