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