def convert_figure(self, data_format, data): """ Convert a single SVG figure to PDF. Returns converted data. """ #Work in a temporary directory with TemporaryDirectory() as tmpdir: #Write fig to temp file input_filename = os.path.join(tmpdir, 'figure.svg') # SVG data is unicode text with io.open(input_filename, 'w', encoding='utf8') as f: f.write(cast_unicode_py2(data)) #Call conversion application output_filename = os.path.join(tmpdir, 'figure.pdf') shell = self.command.format(from_filename=input_filename, to_filename=output_filename) subprocess.call(shell, shell=True) #Shell=True okay since input is trusted. #Read output from drive # return value expects a filename if os.path.isfile(output_filename): with open(output_filename, 'rb') as f: # PDF is a nb supported binary, data type, so base64 encode. return base64.encodestring(f.read()) else: raise TypeError("Inkscape svg to pdf conversion failed")
def execute_request(self, stream, ident, parent): """handle an execute_request""" # This function is mostly a copy-pasted version from ipykernel, # but it is split into several functions in order to allow # overriding them in subclasses. # ============ BEGIN COPY-PASTE ============= try: content = parent[u'content'] code = py3compat.cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return metadata = self.init_metadata(parent) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = self.do_execute(code, silent, store_history, user_expressions, allow_stdin) # ============ END COPY-PASTE ============= self.send_execute_reply(stream, ident, parent, metadata, reply_content)
def execute_request(self, stream, ident, parent): """handle an execute_request""" try: content = parent[u'content'] code = py3compat.cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return md = self._make_metadata(parent['metadata']) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = self.do_execute(code, silent, store_history, user_expressions, allow_stdin) self.send_execute_reply(stream, ident, parent, md, reply_content)
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 init_prompt_toolkit_cli(self): # Pre-populate history from IPython's history database history = [] last_cell = u"" for _, _, cell in self.history_manager.get_tail( self.history_load_length, include_latest=True): # Ignore blank lines and consecutive duplicates cell = cast_unicode_py2(cell.rstrip()) if cell and (cell != last_cell): history.append(cell)
def execute_request(self, stream, ident, parent): """handle an execute_request""" try: content = parent[u'content'] code = py3compat.cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return stop_on_error = content.get('stop_on_error', True) md = self._make_metadata(parent['metadata']) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = self.do_execute(code, silent, store_history, user_expressions, allow_stdin) # Flush output before sending the reply. sys.stdout.flush() sys.stderr.flush() # FIXME: on rare occasions, the flush doesn't seem to make it to the # clients... This seems to mitigate the problem, but we definitely need # to better understand what's going on. if self._execute_sleep: time.sleep(self._execute_sleep) # Send the reply. reply_content = json_clean(reply_content) md['status'] = reply_content['status'] if reply_content['status'] == 'error' and \ reply_content['ename'] == 'UnmetDependency': md['dependencies_met'] = False reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent, metadata=md, ident=ident) self.log.debug("%s", reply_msg) if not silent and reply_msg['content']['status'] == u'error' and stop_on_error: self._abort_queues()
def execute_request(self, stream, ident, parent): """handle an execute_request - overridden for ipyparallel metadata Once ipykernel has init/finish_metadata, this should be removed. """ try: content = parent[u'content'] code = cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return stop_on_error = content.get('stop_on_error', True) md = self.init_metadata(parent) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = self.do_execute(code, silent, store_history, user_expressions, allow_stdin) # finish building metadata md = self.finish_metadata(parent, md, reply_content) # Flush output before sending the reply. sys.stdout.flush() sys.stderr.flush() # Send the reply. reply_content = json_clean(reply_content) reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent, metadata=md, ident=ident) self.log.debug("%s", reply_msg) if not silent and reply_msg['content'][ 'status'] == u'error' and stop_on_error: self._abort_queues()
def writes(self, nb, **kwargs): """Serialize a NotebookNode object as a JSON string""" kwargs['cls'] = BytesEncoder kwargs['indent'] = 1 kwargs['sort_keys'] = True kwargs['separators'] = (',',': ') kwargs.setdefault('ensure_ascii', False) # don't modify in-memory dict nb = copy.deepcopy(nb) if kwargs.pop('split_lines', True): nb = split_lines(nb) nb = strip_transient(nb) return py3compat.cast_unicode_py2(json.dumps(nb, **kwargs), 'utf-8')
def _hook_execute_request_msg(self, parent): try: content = parent[u'content'] code = py3compat.cast_unicode_py2(content[u'code']) silent = content[u'silent'] allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return self.execute_request_msg_id = parent['header']['msg_id'] if not silent: self.execution_count += 1 cell_log_id = self._get_cell_id(parent) if cell_log_id is not None: self.log_history_file_path = os.path.join(self.log_path, cell_log_id, cell_log_id + u'.json') else: self.log_history_file_path = None self.log_history_id = cell_log_id self.log_history_data = self._read_log_history_file() notebook_data = self._get_notebook_data(parent) self.exec_info = ExecutionInfo(code, self.get_server_signature(), notebook_data) if not silent: env = self._get_config(self.kc) self.summarize_on, new_code = self.is_summarize_on(code, env) self._init_default_config() self._start_log() if self.summarize_on: self._start_summarize() self._load_env(env) if not self.log_history_id is None: meme = {'lc_cell_meme': {'current': self.log_history_id}} self.log_buff_append(u'{}\n----\n'.format(json.dumps(meme))) self.log_buff_append(u'{}\n----\n'.format(code)) # code self._log_buff_flush() self.log_buff_append(self.exec_info.to_logfile_header() + u'----\n') content[u'code'] = new_code self.flush_stream_event.clear() self._allow_stdin = allow_stdin
def execute_request(self, stream, ident, parent): """handle an execute_request - overridden for ipyparallel metadata Once ipykernel has init/finish_metadata, this should be removed. """ try: content = parent[u'content'] code = cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return stop_on_error = content.get('stop_on_error', True) md = self.init_metadata(parent) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = self.do_execute(code, silent, store_history, user_expressions, allow_stdin) # finish building metadata md = self.finish_metadata(parent, md, reply_content) # Flush output before sending the reply. sys.stdout.flush() sys.stderr.flush() # Send the reply. reply_content = json_clean(reply_content) reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent, metadata=md, ident=ident) self.log.debug("%s", reply_msg) if not silent and reply_msg['content']['status'] == u'error' and stop_on_error: self._abort_queues()
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 __init__(self, parent, ident): self.parent = parent self.ident = ident content = self.content = parent[u'content'] header = self.header = parent['header'] self.code = py3compat.cast_unicode_py2(content[u'code']) self.silent = content[u'silent'] self.store_history = content.get(u'store_history', not self.silent) self.user_expressions = content.get('user_expressions', {}) self.allow_stdin = content.get('allow_stdin', False) self.metadata = parent[u'metadata'] self.msg_id = header['msg_id'] self.msg_type = header['msg_type'] # Fields to populate later self.execution_count = None
def raw_input(self, prompt=''): """Forward raw_input to frontends Raises ------ StdinNotImplentedError if active frontend doesn't support stdin. """ if not self._allow_stdin: raise StdinNotImplementedError( "raw_input was called, but this frontend does not support input requests." ) return self._input_request( py3compat.cast_unicode_py2(prompt), self._parent_ident, self._parent_header, password=False, )
def _find_uninstall_nbextension(filename, logger=None): """Remove nbextension files from the first location they are found. Returns True if files were removed, False otherwise. """ filename = cast_unicode_py2(filename) for nbext in jupyter_path('nbextensions'): path = pjoin(nbext, filename) if os.path.lexists(path): if logger: logger.info("Removing: %s" % path) if os.path.isdir(path) and not os.path.islink(path): shutil.rmtree(path) else: os.remove(path) return True return False
def uninstall_labextension(name, user=False, sys_prefix=False, prefix=None, labextensions_dir=None, logger=None): """Uninstall a Javascript extension of JupyterLab Removes staged files and/or directories in the labextensions directory and removes the extension from the frontend config. Parameters ---------- name: str The name of the labextension. user : bool [default: False] Whether to uninstall from the user's labextensions directory. Otherwise do a system-wide uninstall (e.g. /usr/local/share/jupyter/labextensions). sys_prefix : bool [default: False] Uninstall from the sys.prefix, i.e. environment prefix : str [optional] Specify prefix, if it should differ from default (e.g. /usr/local). Will uninstall from ``<prefix>/share/jupyter/labextensions`` labextensions_dir : str [optional] Specify absolute path of labextensions directory explicitly. logger : Jupyter logger [optional] Logger instance to use """ labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir) dest = cast_unicode_py2(name) full_dest = pjoin(labext, 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) disable_labextension(name, user=user, sys_prefix=sys_prefix, logger=logger)
def execute_request(self, stream, ident, parent): """handle an execute_request""" try: content = parent[u'content'] code = py3compat.cast_unicode_py2(content[u'code']) silent = content[u'silent'] store_history = content.get(u'store_history', not silent) user_expressions = content.get('user_expressions', {}) allow_stdin = content.get('allow_stdin', False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return stop_on_error = content.get('stop_on_error', True) # grab and remove uuid from user_expressions # there just for convenience of not modifying the msg protocol uuid = user_expressions.pop('__uuid__', None) code_dict = user_expressions.pop('__code_dict__', dict()) self._outer_stream = stream self._outer_ident = ident self._outer_parent = parent self._outer_stop_on_error = stop_on_error self._outer_allow_stdin = allow_stdin self._outer_code_dict = code_dict # stash since will be global self.inner_execute_request(code, uuid, silent, store_history, user_expressions) self._outer_stream = None self._outer_ident = None self._outer_parent = None self._outer_stop_on_error = None self._outer_allow_stdin = None self._outer_code_dict = None
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.""" nbext = _get_nbextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir) dest = cast_unicode_py2(dest) full_dest = os.path.join(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 install_labextension(path, name, overwrite=False, symlink=False, user=False, prefix=None, labextensions_dir=None, logger=None, sys_prefix=False): """Install a Javascript extension for JupyterLab Stages files and/or directories into the labextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install Archives (zip or tarballs) will be extracted into the labextensions directory. name : str name the labextension is installed to. For example, if name is 'foo', then the source file will be installed to 'labextensions/foo'. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in labextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. user : bool [default: False] Whether to install to the user's labextensions directory. Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/labextensions). prefix : str [optional] Specify install prefix, if it should differ from default (e.g. /usr/local). Will install to ``<prefix>/share/jupyter/labextensions`` labextensions_dir : str [optional] Specify absolute path of labextensions directory explicitly. logger : Jupyter logger [optional] Logger instance to use sys_prefix : bool [default: False] Install into the sys.prefix, i.e. environment """ # the actual path to which we eventually installed full_dest = None labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir) # make sure labextensions dir exists ensure_dir_exists(labext) # forcing symlink parameter to False if os.symlink does not exist (e.g., on Windows machines running python 2) if not hasattr(os, 'symlink'): symlink = False if isinstance(path, (list, tuple)): raise TypeError( "path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions" ) path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): raise NotImplementedError( 'Urls are not yet supported for labextensions') elif path.endswith('.zip') or _safe_is_tarfile(path): raise NotImplementedError( 'Archive files are not yet supported for labextensions') else: destination = cast_unicode_py2(name) full_dest = normpath(pjoin(labext, destination)) if overwrite and 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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = pjoin(parent, file) dest_file = pjoin(dest_dir, file) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def install_nbextension(path, overwrite=False, symlink=False, user=False, prefix=None, nbextensions_dir=None, destination=None, verbose=DEPRECATED_ARGUMENT, logger=None, sys_prefix=False): """Install a Javascript extension for the notebook Stages files and/or directories into the nbextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install By default, the file will be installed with its base name, so '/path/to/foo' will install to 'nbextensions/foo'. See the destination argument below to change this. Archives (zip or tarballs) will be extracted into the nbextensions directory. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in nbextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. 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. destination : str [optional] 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. logger : Jupyter logger [optional] Logger instance to use """ if verbose != DEPRECATED_ARGUMENT: import warnings warnings.warn( "`install_nbextension`'s `verbose` parameter is deprecated, it will have no effects and will be removed in Notebook 5.0", DeprecationWarning) # the actual path to which we eventually installed full_dest = None nbext = _get_nbextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir) # make sure nbextensions dir exists ensure_dir_exists(nbext) # forcing symlink parameter to False if os.symlink does not exist (e.g., on Windows machines running python 2) if not hasattr(os, 'symlink'): symlink = False if isinstance(path, (list, tuple)): raise TypeError( "path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions" ) path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): if symlink: raise ValueError("Cannot symlink from URLs") # Given a URL, download it with TemporaryDirectory() as td: filename = urlparse(path).path.split('/')[-1] local_path = os.path.join(td, filename) if logger: logger.info("Downloading: %s -> %s" % (path, local_path)) urlretrieve(path, local_path) # now install from the local copy full_dest = install_nbextension(local_path, overwrite=overwrite, symlink=symlink, nbextensions_dir=nbext, destination=destination, logger=logger) elif path.endswith('.zip') or _safe_is_tarfile(path): if symlink: raise ValueError("Cannot symlink from archives") if destination: raise ValueError("Cannot give destination for archives") if logger: logger.info("Extracting: %s -> %s" % (path, nbext)) if path.endswith('.zip'): archive = zipfile.ZipFile(path) elif _safe_is_tarfile(path): archive = tarfile.open(path) archive.extractall(nbext) archive.close() # TODO: what to do here full_dest = None else: if not destination: destination = basename(normpath(path)) destination = cast_unicode_py2(destination) full_dest = normpath(pjoin(nbext, destination)) if overwrite and 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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file_name in files: src = pjoin(parent, file_name) dest_file = pjoin(dest_dir, file_name) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def read(self, fp, **kwargs): """Read a notebook from a file like object""" nbs = cast_unicode_py2(fp.read()) return self.reads(nbs, **kwargs)
def install_nbextension(path, overwrite=False, symlink=False, user=False, prefix=None, nbextensions_dir=None, destination=None, verbose=DEPRECATED_ARGUMENT, logger=None, sys_prefix=False ): """Install a Javascript extension for the notebook Stages files and/or directories into the nbextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install By default, the file will be installed with its base name, so '/path/to/foo' will install to 'nbextensions/foo'. See the destination argument below to change this. Archives (zip or tarballs) will be extracted into the nbextensions directory. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in nbextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. 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. destination : str [optional] 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. logger : Jupyter logger [optional] Logger instance to use """ if verbose != DEPRECATED_ARGUMENT: import warnings warnings.warn("`install_nbextension`'s `verbose` parameter is deprecated, it will have no effects and will be removed in Notebook 5.0", DeprecationWarning) # the actual path to which we eventually installed full_dest = None nbext = _get_nbextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir) # make sure nbextensions dir exists ensure_dir_exists(nbext) # forcing symlink parameter to False if os.symlink does not exist (e.g., on Windows machines running python 2) if not hasattr(os, 'symlink'): symlink = False if isinstance(path, (list, tuple)): raise TypeError("path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions") path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): if symlink: raise ValueError("Cannot symlink from URLs") # Given a URL, download it with TemporaryDirectory() as td: filename = urlparse(path).path.split('/')[-1] local_path = os.path.join(td, filename) if logger: logger.info("Downloading: %s -> %s" % (path, local_path)) urlretrieve(path, local_path) # now install from the local copy full_dest = install_nbextension(local_path, overwrite=overwrite, symlink=symlink, nbextensions_dir=nbext, destination=destination, logger=logger) elif path.endswith('.zip') or _safe_is_tarfile(path): if symlink: raise ValueError("Cannot symlink from archives") if destination: raise ValueError("Cannot give destination for archives") if logger: logger.info("Extracting: %s -> %s" % (path, nbext)) if path.endswith('.zip'): archive = zipfile.ZipFile(path) elif _safe_is_tarfile(path): archive = tarfile.open(path) archive.extractall(nbext) archive.close() # TODO: what to do here full_dest = None else: if not destination: destination = basename(path) destination = cast_unicode_py2(destination) full_dest = normpath(pjoin(nbext, destination)) if overwrite and 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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = pjoin(parent, file) dest_file = pjoin(dest_dir, file) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def write(self, nb, fp, **kwargs): """Write a notebook to a file like object""" nbs = cast_unicode_py2(self.writes(nb, **kwargs)) return fp.write(nbs)
def install_nbextension(path, overwrite=False, symlink=False, user=False, prefix=None, nbextensions_dir=None, destination=None, verbose=1): """Install a Javascript extension for the notebook Stages files and/or directories into the nbextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install By default, the file will be installed with its base name, so '/path/to/foo' will install to 'nbextensions/foo'. See the destination argument below to change this. Archives (zip or tarballs) will be extracted into the nbextensions directory. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in nbextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. 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. destination : str [optional] 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. verbose : int [default: 1] Set verbosity level. The default is 1, where file actions are printed. set verbose=2 for more output, or verbose=0 for silence. """ nbext = _get_nbext_dir(nbextensions_dir, user, prefix) # make sure nbextensions dir exists ensure_dir_exists(nbext) if isinstance(path, (list, tuple)): raise TypeError( "path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions" ) path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): if symlink: raise ValueError("Cannot symlink from URLs") # Given a URL, download it with TemporaryDirectory() as td: filename = urlparse(path).path.split('/')[-1] local_path = os.path.join(td, filename) if verbose >= 1: print("downloading %s to %s" % (path, local_path)) urlretrieve(path, local_path) # now install from the local copy install_nbextension(local_path, overwrite=overwrite, symlink=symlink, nbextensions_dir=nbext, destination=destination, verbose=verbose) elif path.endswith('.zip') or _safe_is_tarfile(path): if symlink: raise ValueError("Cannot symlink from archives") if destination: raise ValueError("Cannot give destination for archives") if verbose >= 1: print("extracting %s to %s" % (path, nbext)) if path.endswith('.zip'): archive = zipfile.ZipFile(path) elif _safe_is_tarfile(path): archive = tarfile.open(path) archive.extractall(nbext) archive.close() else: if not destination: destination = basename(path) destination = cast_unicode_py2(destination) full_dest = pjoin(nbext, destination) if overwrite and os.path.lexists(full_dest): if verbose >= 1: print("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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if verbose >= 1: print("symlink %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if verbose >= 2: print("making directory %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = pjoin(parent, file) # print("%r, %r" % (dest_dir, file)) dest_file = pjoin(dest_dir, file) _maybe_copy(src, dest_file, verbose) else: src = path _maybe_copy(src, full_dest, verbose)
def install_labextension(path, name, overwrite=False, symlink=False, user=False, prefix=None, labextensions_dir=None, logger=None, sys_prefix=False ): """Install a Javascript extension for JupyterLab Stages files and/or directories into the labextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install Archives (zip or tarballs) will be extracted into the labextensions directory. name : str name the labextension is installed to. For example, if name is 'foo', then the source file will be installed to 'labextensions/foo'. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in labextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. user : bool [default: False] Whether to install to the user's labextensions directory. Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/labextensions). prefix : str [optional] Specify install prefix, if it should differ from default (e.g. /usr/local). Will install to ``<prefix>/share/jupyter/labextensions`` labextensions_dir : str [optional] Specify absolute path of labextensions directory explicitly. logger : Jupyter logger [optional] Logger instance to use sys_prefix : bool [default: False] Install into the sys.prefix, i.e. environment """ # the actual path to which we eventually installed full_dest = None labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, prefix=prefix, labextensions_dir=labextensions_dir) # make sure labextensions dir exists ensure_dir_exists(labext) # forcing symlink parameter to False if os.symlink does not exist (e.g., on Windows machines running python 2) if not hasattr(os, 'symlink'): symlink = False if isinstance(path, (list, tuple)): raise TypeError("path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions") path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): raise NotImplementedError('Urls are not yet supported for labextensions') elif path.endswith('.zip') or _safe_is_tarfile(path): raise NotImplementedError('Archive files are not yet supported for labextensions') else: destination = cast_unicode_py2(name) full_dest = normpath(pjoin(labext, destination)) if overwrite and 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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = pjoin(parent, file) dest_file = pjoin(dest_dir, file) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def install_nbextension(path, overwrite=False, symlink=False, user=False, prefix=None, nbextensions_dir=None, destination=None, logger=None, sys_prefix=False): """Install a Javascript extension for the notebook.""" # the actual path to which we eventually installed full_dest = None nbext = _get_nbextension_dir( user=user, sys_prefix=sys_prefix, prefix=prefix, nbextensions_dir=nbextensions_dir) # make sure nbextensions dir exists ensure_dir_exists(nbext) # forcing symlink parameter to False if os.symlink does not exist (e.g., # on Windows machines running python 2) if not hasattr(os, 'symlink'): symlink = False if isinstance(path, (list, tuple)): raise TypeError("path must be a string pointing to a single extension " "to install; call this function multiple times to " "install multiple extensions") path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): if symlink: raise ValueError("Cannot symlink from URLs") # Given a URL, download it with TemporaryDirectory() as td: filename = urlparse(path).path.split('/')[-1] local_path = os.path.join(td, filename) if logger: logger.info("Downloading: %s -> %s" % (path, local_path)) urlretrieve(path, local_path) # now install from the local copy full_dest = install_nbextension( local_path, overwrite=overwrite, symlink=symlink, nbextensions_dir=nbext, destination=destination, logger=logger) elif path.endswith('.zip') or _safe_is_tarfile(path): if symlink: raise ValueError("Cannot symlink from archives") if destination: raise ValueError("Cannot give destination for archives") if logger: logger.info("Extracting: %s -> %s" % (path, nbext)) if path.endswith('.zip'): archive = zipfile.ZipFile(path) elif _safe_is_tarfile(path): archive = tarfile.open(path) archive.extractall(nbext) archive.close() # TODO: what to do here full_dest = None else: if not destination: destination = os.path.basename(path) destination = cast_unicode_py2(destination) full_dest = os.path.normpath(os.path.join(nbext, destination)) if overwrite and 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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): # end in path separator path = os.path.join(os.path.abspath(path), '') for parent, dirs, files in os.walk(path): dest_dir = os.path.join(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = os.path.join(parent, file) dest_file = os.path.join(dest_dir, file) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def develop_labextension(path, symlink=True, overwrite=False, user=False, labextensions_dir=None, destination=None, logger=None, sys_prefix=False): """Install a dynamic extension for JupyterLab Stages files and/or directories into the labextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install By default, the file will be installed with its base name, so '/path/to/foo' will install to 'labextensions/foo'. See the destination argument below to change this. Archives (zip or tarballs) will be extracted into the labextensions directory. user : bool [default: False] Whether to install to the user's labextensions directory. Otherwise do a system-wide install (e.g. /usr/local/share/jupyter/labextensions). overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: True] If True, create a symlink in labextensions, rather than copying files. Windows support for symlinks requires a permission bit which only admin users have by default, so don't rely on it. labextensions_dir : str [optional] Specify absolute path of labextensions directory explicitly. destination : str [optional] name the labextension is installed to. For example, if destination is 'foo', then the source file will be installed to 'labextensions/foo', regardless of the source name. logger : Jupyter logger [optional] Logger instance to use """ # the actual path to which we eventually installed full_dest = None labext = _get_labextension_dir(user=user, sys_prefix=sys_prefix, labextensions_dir=labextensions_dir) # make sure labextensions dir exists ensure_dir_exists(labext) if isinstance(path, (list, tuple)): raise TypeError( "path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions" ) path = cast_unicode_py2(path) if not destination: destination = basename(normpath(path)) destination = cast_unicode_py2(destination) full_dest = normpath(pjoin(labext, destination)) if overwrite and 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) # Make sure the parent directory exists os.makedirs(os.path.dirname(full_dest), exist_ok=True) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if logger: logger.info("Symlinking: %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif not os.path.islink(full_dest): raise ValueError("%s exists and is not a symlink" % path) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if logger: logger.info("Making directory: %s" % dest_dir) os.makedirs(dest_dir) for file_name in files: src = pjoin(parent, file_name) dest_file = pjoin(dest_dir, file_name) _maybe_copy(src, dest_file, logger=logger) else: src = path _maybe_copy(src, full_dest, logger=logger) return full_dest
def execute_request(self, stream, ident, parent): """handle an execute_request""" try: content = parent[u"content"] code = py3compat.cast_unicode_py2(content[u"code"]) silent = content[u"silent"] store_history = content.get(u"store_history", not silent) user_expressions = content.get("user_expressions", {}) allow_stdin = content.get("allow_stdin", False) except: self.log.error("Got bad msg: ") self.log.error("%s", parent) return stop_on_error = content.get("stop_on_error", True) metadata = self.init_metadata(parent) # Re-broadcast our input for the benefit of listening clients, and # start computing output if not silent: self.execution_count += 1 self._publish_execute_input(code, parent, self.execution_count) reply_content = yield gen.maybe_future( self.do_execute( code, silent, store_history, user_expressions, allow_stdin, )) # Flush output before sending the reply. sys.stdout.flush() sys.stderr.flush() # FIXME: on rare occasions, the flush doesn't seem to make it to the # clients... This seems to mitigate the problem, but we definitely need # to better understand what's going on. if self._execute_sleep: time.sleep(self._execute_sleep) # Send the reply. reply_content = json_clean(reply_content) metadata = self.finish_metadata(parent, metadata, reply_content) reply_msg = self.session.send( stream, u"execute_reply", reply_content, parent, metadata=metadata, ident=ident, ) self.log.debug("%s", reply_msg) if not silent and reply_msg["content"][ "status"] == u"error" and stop_on_error: yield self._abort_queues()
def install_nbextension(path, overwrite=False, symlink=False, user=False, prefix=None, nbextensions_dir=None, destination=None, verbose=1): """Install a Javascript extension for the notebook Stages files and/or directories into the nbextensions directory. By default, this compares modification time, and only stages files that need updating. If `overwrite` is specified, matching files are purged before proceeding. Parameters ---------- path : path to file, directory, zip or tarball archive, or URL to install By default, the file will be installed with its base name, so '/path/to/foo' will install to 'nbextensions/foo'. See the destination argument below to change this. Archives (zip or tarballs) will be extracted into the nbextensions directory. overwrite : bool [default: False] If True, always install the files, regardless of what may already be installed. symlink : bool [default: False] If True, create a symlink in nbextensions, rather than copying files. Not allowed with URLs or archives. Windows support for symlinks requires Vista or above, Python 3, and a permission bit which only admin users have by default, so don't rely on it. 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. destination : str [optional] 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. verbose : int [default: 1] Set verbosity level. The default is 1, where file actions are printed. set verbose=2 for more output, or verbose=0 for silence. """ nbext = _get_nbext_dir(nbextensions_dir, user, prefix) # make sure nbextensions dir exists ensure_dir_exists(nbext) if isinstance(path, (list, tuple)): raise TypeError("path must be a string pointing to a single extension to install; call this function multiple times to install multiple extensions") path = cast_unicode_py2(path) if path.startswith(('https://', 'http://')): if symlink: raise ValueError("Cannot symlink from URLs") # Given a URL, download it with TemporaryDirectory() as td: filename = urlparse(path).path.split('/')[-1] local_path = os.path.join(td, filename) if verbose >= 1: print("downloading %s to %s" % (path, local_path)) urlretrieve(path, local_path) # now install from the local copy install_nbextension(local_path, overwrite=overwrite, symlink=symlink, nbextensions_dir=nbext, destination=destination, verbose=verbose) elif path.endswith('.zip') or _safe_is_tarfile(path): if symlink: raise ValueError("Cannot symlink from archives") if destination: raise ValueError("Cannot give destination for archives") if verbose >= 1: print("extracting %s to %s" % (path, nbext)) if path.endswith('.zip'): archive = zipfile.ZipFile(path) elif _safe_is_tarfile(path): archive = tarfile.open(path) archive.extractall(nbext) archive.close() else: if not destination: destination = basename(path) destination = cast_unicode_py2(destination) full_dest = pjoin(nbext, destination) if overwrite and os.path.lexists(full_dest): if verbose >= 1: print("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) if symlink: path = os.path.abspath(path) if not os.path.exists(full_dest): if verbose >= 1: print("symlink %s -> %s" % (full_dest, path)) os.symlink(path, full_dest) elif os.path.isdir(path): path = pjoin(os.path.abspath(path), '') # end in path separator for parent, dirs, files in os.walk(path): dest_dir = pjoin(full_dest, parent[len(path):]) if not os.path.exists(dest_dir): if verbose >= 2: print("making directory %s" % dest_dir) os.makedirs(dest_dir) for file in files: src = pjoin(parent, file) # print("%r, %r" % (dest_dir, file)) dest_file = pjoin(dest_dir, file) _maybe_copy(src, dest_file, verbose) else: src = path _maybe_copy(src, full_dest, verbose)