def clear_output(stdout=True, stderr=True, other=True): """Clear the output of the current cell receiving output. Optionally, each of stdout/stderr or other non-stream data (e.g. anything produced by display()) can be excluded from the clear event. By default, everything is cleared. Parameters ---------- stdout : bool [default: True] Whether to clear stdout. stderr : bool [default: True] Whether to clear stderr. other : bool [default: True] Whether to clear everything else that is not stdout/stderr (e.g. figures,images,HTML, any result of display()). """ from IPython.core.interactiveshell import InteractiveShell if InteractiveShell.initialized(): InteractiveShell.instance().display_pub.clear_output( stdout=stdout, stderr=stderr, other=other, ) else: from IPython.utils import io if stdout: print('\033[2K\r', file=io.stdout, end='') io.stdout.flush() if stderr: print('\033[2K\r', file=io.stderr, end='') io.stderr.flush()
def get_ipython(): """Get the global InteractiveShell instance. Returns None if no InteractiveShell instance is registered. """ from IPython.core.interactiveshell import InteractiveShell if InteractiveShell.initialized(): return InteractiveShell.instance()
def loadNoMagic(): ''' Load the magic functions when running iPython ''' if common.runningUnderIPython(): from IPython.core.interactiveshell import InteractiveShell if InteractiveShell.initialized(): localIP = InteractiveShell.instance() load_ipython_extension(localIP)
def running_from_terminal(): try: # Check if it is running inside IPython __IPYTHON__ # Check that it is available (i.e. that we are not in the # standard terminal vs the Notebook, QtConsole... #clear_output() from IPython.core.interactiveshell import InteractiveShell InteractiveShell.instance().display_pub.clear_output from IPython.core.display import clear_output return False except: return True
def clear_output(wait=False): """Clear the output of the current cell receiving output. Parameters ---------- wait : bool [default: false] Wait to clear the output until new output is available to replace it.""" from IPython.core.interactiveshell import InteractiveShell if InteractiveShell.initialized(): InteractiveShell.instance().display_pub.clear_output(wait) else: print('\033[2K\r', end='') sys.stdout.flush() print('\033[2K\r', end='') sys.stderr.flush()
def register_orgformatter(): from IPython.core.interactiveshell import InteractiveShell formatter = InteractiveShell.instance().display_formatter orgformatter = IPyOrgFormatter(parent=formatter) formatter.formatters[orgformatter.format_type] = orgformatter formatter.active_types.append(orgformatter.format_type) orgformatter.for_type(DataFrame, to_org)
def get_ip (self): """Get the global InteractiveShell instance.""" shell = InteractiveShell.instance() return shell
def set_matplotlib_formats(*formats, **kwargs): """Select figure formats for the inline backend. Optionally pass quality for JPEG. For example, this enables PNG and JPEG output with a JPEG quality of 90%:: In [1]: set_matplotlib_formats('png', 'jpeg', quality=90) To set this in your config files use the following:: c.InlineBackend.figure_formats = {'png', 'jpeg'} c.InlineBackend.print_figure_kwargs.update({'quality' : 90}) Parameters ---------- *formats : strs One or more figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'. **kwargs : Keyword args will be relayed to ``figure.canvas.print_figure``. """ from IPython.core.interactiveshell import InteractiveShell from IPython.core.pylabtools import select_figure_formats # build kwargs, starting with InlineBackend config kw = {} from ipykernel.pylab.config import InlineBackend cfg = InlineBackend.instance() kw.update(cfg.print_figure_kwargs) kw.update(**kwargs) shell = InteractiveShell.instance() select_figure_formats(shell, formats, **kw)
def display(*objs, **kwargs): """Display a Python object in all frontends. By default all representations will be computed and sent to the frontends. Frontends can decide which representation is used and how. Parameters ---------- objs : tuple of objects The Python objects to display. include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type string (MIME types) to exclue in the format data dict. If this is set all format types will be computed, except for those included in this argument. """ include = kwargs.get('include') exclude = kwargs.get('exclude') from IPython.core.interactiveshell import InteractiveShell inst = InteractiveShell.instance() format = inst.display_formatter.format publish = inst.display_pub.publish for obj in objs: format_dict = format(obj, include=include, exclude=exclude) publish('IPython.core.display.display', format_dict)
def format_display_data(obj, include=None, exclude=None): """Return a format data dict for an object. By default all format types will be computed. Parameters ---------- obj : object The Python object whose format data will be computed. Returns ------- format_dict : dict A dictionary of key/value pairs, one or each format that was generated for the object. The keys are the format types, which will usually be MIME type strings and the values and JSON'able data structure containing the raw data for the representation in that format. include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type string (MIME types) to exclue in the format data dict. If this is set all format types will be computed, except for those included in this argument. """ from IPython.core.interactiveshell import InteractiveShell return InteractiveShell.instance().display_formatter.format( obj, include, exclude )
def run_docstring_examples(obj, verbose=True): from IPython.core.interactiveshell import InteractiveShell import doctest inst = InteractiveShell.instance() globs = inst.user_ns return doctest.run_docstring_examples(obj, globs, verbose=verbose)
def add_display_formatter(new_formatter): from IPython.core.formatters import FormatterABC FormatterABC.register(new_formatter) from IPython.core.interactiveshell import InteractiveShell inst = InteractiveShell.instance() f = new_formatter(config=inst.display_formatter.config) inst.display_formatter.formatters[f.format_type] = f
def format_display_data(obj, include=None, exclude=None): """Return a format data dict for an object. By default all format types will be computed. The following MIME types are currently implemented: * text/plain * text/html * text/markdown * text/latex * application/json * application/javascript * application/pdf * image/png * image/jpeg * image/svg+xml Parameters ---------- obj : object The Python object whose format data will be computed. Returns ------- format_dict : dict A dictionary of key/value pairs, one or each format that was generated for the object. The keys are the format types, which will usually be MIME type strings and the values and JSON'able data structure containing the raw data for the representation in that format. include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type string (MIME types) to exclue in the format data dict. If this is set all format types will be computed, except for those included in this argument. """ from IPython.core.interactiveshell import InteractiveShell InteractiveShell.instance().display_formatter.format( obj, include, exclude )
def __init__(self, backend): import matplotlib.pyplot as plt from IPython.core.interactiveshell import InteractiveShell from IPython.core.pylabtools import backend2gui self.shell = InteractiveShell.instance() self.old_backend = backend2gui[str(plt.get_backend())] self.new_backend = backend
def display(*objs, **kwargs): """Display a Python object in all frontends. By default all representations will be computed and sent to the frontends. Frontends can decide which representation is used and how. Parameters ---------- objs : tuple of objects The Python objects to display. raw : bool, optional Are the objects to be displayed already mimetype-keyed dicts of raw display data, or Python objects that need to be formatted before display? [default: False] include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type strings (MIME types) to exclude in the format data dict. If this is set all format types will be computed, except for those included in this argument. metadata : dict, optional A dictionary of metadata to associate with the output. mime-type keys in this dictionary will be associated with the individual representation formats, if they exist. """ raw = kwargs.get('raw', False) include = kwargs.get('include') exclude = kwargs.get('exclude') metadata = kwargs.get('metadata') from IPython.core.interactiveshell import InteractiveShell if not raw: format = InteractiveShell.instance().display_formatter.format for obj in objs: # If _ipython_display_ is defined, use that to display this object. display_method = _safe_get_formatter_method(obj, '_ipython_display_') if display_method is not None: try: display_method(**kwargs) except NotImplementedError: pass else: continue if raw: publish_display_data(data=obj, metadata=metadata) else: format_dict, md_dict = format( obj, include=include, exclude=exclude) if metadata: # kwarg-specified metadata gets precedence _merge(md_dict, metadata) publish_display_data(data=format_dict, metadata=md_dict)
def publish_display_data(source, data, metadata=None): """Publish data and metadata to all frontends. See the ``display_data`` message in the messaging documentation for more details about this message type. The following MIME types are currently implemented: * text/plain * text/html * text/markdown * text/latex * application/json * application/javascript * image/png * image/jpeg * image/svg+xml Parameters ---------- source : str A string that give the function or method that created the data, such as 'IPython.core.page'. data : dict A dictionary having keys that are valid MIME types (like 'text/plain' or 'image/svg+xml') and values that are the data for that MIME type. The data itself must be a JSON'able data structure. Minimally all data should have the 'text/plain' data, which can be displayed by all frontends. If more than the plain text is given, it is up to the frontend to decide which representation to use. metadata : dict A dictionary for metadata related to the data. This can contain arbitrary key, value pairs that frontends can use to interpret the data. mime-type keys matching those in data can be used to specify metadata about particular representations. """ from IPython.core.interactiveshell import InteractiveShell InteractiveShell.instance().display_pub.publish( source, data, metadata )
def add_plot_payload(format, data, metadata={}): """ Add a plot payload to the current execution reply. Parameters: ----------- format : str Identifies the format of the plot data. data : str The raw plot data. metadata : dict, optional [default empty] Allows for specification of additional information about the plot data. """ payload = dict( source='IPython.zmq.pylab.backend_payload.add_plot_payload', format=format, data=data, metadata=metadata ) InteractiveShell.instance().payload_manager.write_payload(payload)
def pYPKa_ZE_ipynb_generator(tp, dir_="pYPKa_ZE_vectors"): cwd = os.getcwd() try: os.makedirs(dir_) except OSError as exception: if exception.errno == errno.EEXIST: pass else: print("The {} directory could not be created".format(dir_)) return None os.chdir(dir_) with open("standard_primers.txt","w") as f: f.write(read_data_file("standard_primers.txt")) with open("pYPKa.gb","w") as f: f.write(read_data_file("pYPKa.gb")) with open("pYPK_ZE.png","w") as f: f.write(read_bin_file("pYPK_ZE.png")) with open(tp.id+".gb","w") as f: f.write(tp.format("gb")) nbtemp = read_data_file("nb_template_pYPKa_ZE_insert.md") name = "pYPKa_ZE_{}.ipynb".format(tp.id) obj = notedown.MarkdownReader() nb = obj.to_notebook(nbtemp.format(tp=tp.id)) pp = ExecutePreprocessor() pp.timeout = 120 # seconds pp.interrupt_on_timeout = True shell = InteractiveShell.instance() nb_executed, resources = pp.preprocess(nb, resources={}) g={} l={} from io import StringIO old_stdout = sys.stdout redirected_output = sys.stdout = StringIO() for cell in nb.cells: if cell.cell_type == 'code': code = shell.input_transformer_manager.transform_cell(cell.source) exec(code, g, l) sys.stdout = old_stdout nbformat.write(nb, name) os.chdir(cwd) return FileLinks(dir_)
def ipython2python(code): """Transform IPython syntax to pure Python syntax Parameters ---------- code : str IPython code, to be transformed to pure Python """ shell = InteractiveShell.instance() return shell.input_transformer_manager.transform_cell(code)
def hello_world(): from IPython.core.interactiveshell import InteractiveShell # I replace \r\n with \n...this might cause problems for code that has legitimate \r characters in it # (like in a string) code = request.values.get('c','').replace('\r\n','\n') if len(code)>0: s="Code<br/><pre>%r</pre><hr/>"%code try: a=InteractiveShell() with capture() as out: a.run_cell(code) # c=compile(code,'<string>','exec') # with capture() as out: # exec c s+="Standard out<br/><pre>%s</pre><hr/>Standard Error<br/><pre>%s</pre>"%tuple(out) except Exception as e: s+="Error: %s"%e return s return "<form><textarea name='c' cols='100' rows='20'></textarea><br/><input type='submit'></form>"
def page(strng, start=0, screen_lines=0, pager_cmd=None, html=None, auto_html=False): """Print a string, piping through a pager. This version ignores the screen_lines and pager_cmd arguments and uses IPython's payload system instead. Parameters ---------- strng : str Text to page. start : int Starting line at which to place the display. html : str, optional If given, an html string to send as well. auto_html : bool, optional If true, the input string is assumed to be valid reStructuredText and is converted to HTML with docutils. Note that if docutils is not found, this option is silently ignored. Note ---- Only one of the ``html`` and ``auto_html`` options can be given, not both. """ # Some routines may auto-compute start offsets incorrectly and pass a # negative value. Offset to 0 for robustness. start = max(0, start) shell = InteractiveShell.instance() if auto_html: try: # These defaults ensure user configuration variables for docutils # are not loaded, only our config is used here. defaults = {'file_insertion_enabled': 0, 'raw_enabled': 0, '_disable_config': 1} html = publish_string(strng, writer_name='html', settings_overrides=defaults) except: pass payload = dict( source='IPython.zmq.page.page', text=strng, html=html, start_line_number=start ) shell.payload_manager.write_payload(payload)
def test_no_widget_view(): # ensure IPython shell is instantiated # otherwise display() just calls print shell = InteractiveShell.instance() with capture_output() as cap: w = Widget() display(w) assert cap.outputs == [], repr(cap.outputs) assert cap.stdout == '', repr(cap.stdout) assert cap.stderr == '', repr(cap.stderr)
def publish_display_data(data, metadata=None, source=None, *, transient=None, **kwargs): """Publish data and metadata to all frontends. See the ``display_data`` message in the messaging documentation for more details about this message type. The following MIME types are currently implemented: * text/plain * text/html * text/markdown * text/latex * application/json * application/javascript * image/png * image/jpeg * image/svg+xml Parameters ---------- data : dict A dictionary having keys that are valid MIME types (like 'text/plain' or 'image/svg+xml') and values that are the data for that MIME type. The data itself must be a JSON'able data structure. Minimally all data should have the 'text/plain' data, which can be displayed by all frontends. If more than the plain text is given, it is up to the frontend to decide which representation to use. metadata : dict A dictionary for metadata related to the data. This can contain arbitrary key, value pairs that frontends can use to interpret the data. mime-type keys matching those in data can be used to specify metadata about particular representations. source : str, deprecated Unused. transient : dict, keyword-only A dictionary of transient data, such as display_id. """ from IPython.core.interactiveshell import InteractiveShell display_pub = InteractiveShell.instance().display_pub # only pass transient if supplied, # to avoid errors with older ipykernel. # TODO: We could check for ipykernel version and provide a detailed upgrade message. if transient: kwargs['transient'] = transient display_pub.publish( data=data, metadata=metadata, **kwargs )
def setup_class(cls): pytest.importorskip('IPython') try: import mock except ImportError: try: from unittest import mock except ImportError: pytest.skip("Mock is not installed") cls.mock = mock from IPython.core.interactiveshell import InteractiveShell cls.display_formatter = InteractiveShell.instance().display_formatter
def crash_handler_lite(etype, evalue, tb): """a light excepthook, adding a small message to the usual traceback""" traceback.print_exception(etype, evalue, tb) from IPython.core.interactiveshell import InteractiveShell if InteractiveShell.initialized(): # we are in a Shell environment, give %magic example config = "%config " else: # we are not in a shell, show generic config config = "c." print(_lite_message_template.format(email=author_email, config=config), file=sys.stderr)
def custom_display(lhs, rhs): """ lhs: left hand side rhs: right hand side This function serves to inject the string for the left hand side of an assignment """ # This code is mainly copied from IPython/display.py # (IPython version 2.3.0) kwargs = {} raw = kwargs.get('raw', False) include = kwargs.get('include') exclude = kwargs.get('exclude') metadata = kwargs.get('metadata') from IPython.core.interactiveshell import InteractiveShell from IPython.core.displaypub import publish_display_data format = InteractiveShell.instance().display_formatter.format format_dict, md_dict = format(rhs, include=include, exclude=exclude) # exampl format_dict (for a sympy expression): # {u'image/png': '\x89PNG\r\n\x1a\n\x00 ...\x00\x00IEND\xaeB`\x82', # u'text/latex': '$$- 2 \\pi \\sin{\\left (2 \\pi t \\right )}$$', # u'text/plain': u'-2\u22c5\u03c0\u22c5sin(2\u22c5\u03c0\u22c5t)'} # it is up to IPython which item value is finally used # now merge the lhs into the dict: if not isinstance(lhs, basestring): raise TypeError('unexpexted Type for lhs object: %s' %type(lhs)) new_format_dict = {} for key, value in format_dict.items(): if 'text/' in key: new_value = lhs+' := '+value new_format_dict[key] = new_value else: # this happens e.g. for mime-type (i.e. key) 'image/png' new_format_dict = format_dict # legacy IPython 2.x support if IPython.__version__.startswith('2.'): publish_display_data('display', new_format_dict, md_dict) else: # indeed, I dont know with which version the api changed # but it does not really matter (for me) publish_display_data(data=new_format_dict, metadata=md_dict)
def _load_ipyhon(self): """ Try loading IPython shell. The result is set in self._ipython (can be None if IPython not available). """ # Init self._ipython = None import __main__ # Try importing IPython try: import IPython except ImportError: return # Version ok? if IPython.version_info < (1,): return # Create an IPython shell from IPython.core.interactiveshell import InteractiveShell self._ipython = InteractiveShell(user_module=__main__) # Set some hooks / event callbacks # Run hook (pre_run_code_hook is depreacted in 2.0) pre_run_cell_hook = self.ipython_pre_run_cell_hook if IPython.version_info < (2,): self._ipython.set_hook('pre_run_code_hook', pre_run_cell_hook) else: self._ipython.events.register('pre_run_cell', pre_run_cell_hook) # Other hooks self._ipython.set_hook('editor', self.ipython_editor_hook) self._ipython.set_custom_exc((bdb.BdbQuit,), self.dbstop_handler) # Some patching self._ipython.ask_exit = self.ipython_ask_exit # Make output be shown on Windows if sys.platform.startswith('win'): # IPython wraps std streams just like we do below, but # pyreadline adds *another* wrapper, which is where it # goes wrong. Here we set it back to bypass pyreadline. from IPython.utils import io io.stdin = io.IOStream(sys.stdin) io.stdout = io.IOStream(sys.stdout) io.stderr = io.IOStream(sys.stderr) # Ipython uses msvcrt e.g. for pausing between pages # but this does not work in pyzo import msvcrt msvcrt.getwch = msvcrt.getch = input # input is deffed above
def _get_interactive_locals(): """ If we are running under IPython, extracts the local variables; otherwise, returns an empty dict. """ try: __IPYTHON__ # pylint: disable=E0602 from IPython.core.interactiveshell import InteractiveShell return {k: v for k, v in InteractiveShell.instance().user_ns.items() if k[0] != '_' and k not in ( "Out", "In", "exit", "quit", "get_ipython")} except NameError: return {}
def __init__(self, local_ns=None, global_ns=None, default_value=None, **metadata): if local_ns is None and global_ns is None: try: #Avoid creating a new interactiveshell instance __IPYTHON__ except NameError: local_ns = globals() global_ns = globals() else: shell = InteractiveShell.instance() local_ns = shell.user_ns global_ns = shell.user_global_ns self.locals = local_ns self.globals = global_ns super(ExecutableTrait,self).__init__(default_value, **metadata)
def test_widget_view(): # ensure IPython shell is instantiated # otherwise display() just calls print shell = InteractiveShell.instance() with capture_output() as cap: w = Button() display(w) assert len(cap.outputs) == 1, "expect 1 output" mime_bundle = cap.outputs[0].data assert mime_bundle['text/plain'] == repr(w), "expected plain text output" assert 'application/vnd.jupyter.widget-view+json' in mime_bundle, "widget should have have a view" assert cap.stdout == '', repr(cap.stdout) assert cap.stderr == '', repr(cap.stderr)
def _ipython_display_(self, **kwargs): # from IPython.Widget._ipython_display_ if InteractiveShell.initialized(): if self.widget._view_name is not None: plaintext = repr(self) data = { "text/plain": plaintext, "application/vnd.jupyter.widget-view+json": { "version_major": 2, "version_minor": 0, "model_id": self.widget._model_id, }, } IPython.display.display(data, raw=True) self.widget._handle_displayed(**kwargs)
def _get_interactive_locals(): """ If we are running under IPython, extracts the local variables; otherwise, returns an empty dict. """ try: __IPYTHON__ # pylint: disable=E0602 from IPython.core.interactiveshell import InteractiveShell return { k: v for k, v in InteractiveShell.instance().user_ns.items() if k[0] != '_' and k not in ("Out", "In", "exit", "quit", "get_ipython") } except NameError: return {}
def append_display_data(self, display_object): """Append a display object as an output. Parameters ---------- display_object : IPython.core.display.DisplayObject The object to display (e.g., an instance of `IPython.display.Markdown` or `IPython.display.Image`). """ fmt = InteractiveShell.instance().display_formatter.format data, metadata = fmt(display_object) self.outputs += ({ 'output_type': 'display_data', 'data': data, 'metadata': metadata }, )
def ip(): """ Get an instance of IPython.InteractiveShell. Will raise a skip if IPython is not installed. """ pytest.importorskip("IPython", minversion="6.0.0") from IPython.core.interactiveshell import InteractiveShell # GH#35711 make sure sqlite history file handle is not leaked from traitlets.config import Config # isort:skip c = Config() c.HistoryManager.hist_file = ":memory:" return InteractiveShell(config=c)
def format_display_data(obj, include=None, exclude=None): """Return a format data dict for an object. By default all format types will be computed. The following MIME types are currently implemented: * text/plain * text/html * text/markdown * text/latex * application/json * application/javascript * application/pdf * image/png * image/jpeg * image/svg+xml Parameters ---------- obj : object The Python object whose format data will be computed. Returns ------- format_dict : dict A dictionary of key/value pairs, one or each format that was generated for the object. The keys are the format types, which will usually be MIME type strings and the values and JSON'able data structure containing the raw data for the representation in that format. include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type string (MIME types) to exclue in the format data dict. If this is set all format types will be computed, except for those included in this argument. """ from IPython.core.interactiveshell import InteractiveShell return InteractiveShell.instance().display_formatter.format( obj, include, exclude )
def publish_display_data(data, metadata=None, source=None, **kwargs): """Publish data and metadata to all frontends. See the ``display_data`` message in the messaging documentation for more details about this message type. The following MIME types are currently implemented: * text/plain * text/html * text/markdown * text/latex * application/json * application/javascript * image/png * image/jpeg * image/svg+xml Parameters ---------- data : dict A dictionary having keys that are valid MIME types (like 'text/plain' or 'image/svg+xml') and values that are the data for that MIME type. The data itself must be a JSON'able data structure. Minimally all data should have the 'text/plain' data, which can be displayed by all frontends. If more than the plain text is given, it is up to the frontend to decide which representation to use. metadata : dict A dictionary for metadata related to the data. This can contain arbitrary key, value pairs that frontends can use to interpret the data. mime-type keys matching those in data can be used to specify metadata about particular representations. source : str, deprecated Unused. transient : dict, keyword-only A dictionary of transient data, such as display_id. """ from IPython.core.interactiveshell import InteractiveShell display_pub = InteractiveShell.instance().display_pub # only pass transient if supplied, # to avoid errors with older ipykernel. # TODO: We could check for ipykernel version and provide a detailed upgrade message. display_pub.publish(data=data, metadata=metadata, **kwargs)
def write_notebook_source(path): nb = nbf.read(path, as_version=nbf.NO_CONVERT) # validate nbformat 4 only # transform the input to executable Python (clearly doesn't remove ipython code!!!) code = InteractiveShell.instance().input_transformer_manager.transform_cell(code_from_ipynb(nb)) # add imports to code add_imports = [] code_lines = code.splitlines() for code_line in code_lines: # many caveats - command line parameters : # http://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-run if code_line.strip().startswith("get_ipython().run_line_magic('run'"): # what about quotes? nb_path = code_line.split(', ')[1].strip(")'") # check if endswith .ipy[nb] nb_path = os.path.normpath(nb_path) if not os.path.isabs(nb_path): nb_path = os.path.normpath(os.path.dirname(path) + os.path.sep + nb_path) # recursive call to deal with run magics write_notebook_source(nb_path) # add imports common_path = os.path.commonpath([path, nb_path]) # if not common path bail! path_to_file = os.path.relpath(nb_path, common_path) path_to_file = os.path.dirname(path_to_file) # replace path separator with . following rules: # https://docs.pytest.org/en/latest/goodpractices.html path_to_file = (path_to_file.replace(os.path.sep, '.') + '.' + os.path.split(nb_path)[1]) path_to_file, _ = os.path.splitext(path_to_file) import_statement = ('from ' + path_to_file + ' import * ') add_imports.append(import_statement) # sort imports code = SortImports(file_contents=code, add_imports=add_imports).output # extract imports, function defs, class defs and constants code = filter_ast(ast.parse(code)) #code_from_ipynb(nb) # write the file py_path = os.path.splitext(path)[0] + '.py' with open(py_path, 'w', encoding='utf-8') as py_file: py_file.write(to_source(code)) print('Written file ', py_path) py_paths_written.append(py_path)
class IPythonStore: """ A connector for getting (one-way) items stored with IPython/Jupyter %store magic. It wraps the underlying PickleStoreDB (_db) most thinly, stripping out the 'autorestore/' namespace added by %store magic. """ _db = _InteractiveShell.instance().db # IPython's PickleStore _NAMESPACE = 'autorestore/' # IPython StoreMagic's "namespace" root = _path_join( str(_db.root), _NAMESPACE) # The root directory of the store, used for watching def _trim(self, key: str, _ns=_NAMESPACE): # _ns = self._NAMESPACE return key[len(_ns):] if key.startswith(_ns) else key def keys(self): return (self._trim(key) for key in self._db.keys()) def items(self): for key in self._db.keys(): try: yield self._trim(key), self._db[key] except KeyError: # Object unpickleable in this env; skip pass def get(self, key: str, default=None): return self._db.get(self._NAMESPACE + key, self._db.get(key)) def __getitem__(self, key): return self._db[self._NAMESPACE + key] def __delitem__(self, key): del self._db[self._NAMESPACE + key] def __contains__(self, key): return (self._NAMESPACE + key) in self._db def __iter__(self): return iter(self.keys()) def __len__(self): return len(list(self.keys()))
def display(*objs, **kwargs): """Display a Python object in all frontends. By default all representations will be computed and sent to the frontends. Frontends can decide which representation is used and how. Parameters ---------- objs : tuple of objects The Python objects to display. raw : bool, optional Are the objects to be displayed already mimetype-keyed dicts of raw display data, or Python objects that need to be formatted before display? [default: False] include : list or tuple, optional A list of format type strings (MIME types) to include in the format data dict. If this is set *only* the format types included in this list will be computed. exclude : list or tuple, optional A list of format type strings (MIME types) to exclude in the format data dict. If this is set all format types will be computed, except for those included in this argument. metadata : dict, optional A dictionary of metadata to associate with the output. mime-type keys in this dictionary will be associated with the individual representation formats, if they exist. """ raw = kwargs.get('raw', False) include = kwargs.get('include') exclude = kwargs.get('exclude') metadata = kwargs.get('metadata') from IPython.core.interactiveshell import InteractiveShell if raw: for obj in objs: publish_display_data('display', obj, metadata) else: format = InteractiveShell.instance().display_formatter.format for obj in objs: format_dict, md_dict = format(obj, include=include, exclude=exclude) if metadata: # kwarg-specified metadata gets precedence _merge(md_dict, metadata) publish_display_data('display', format_dict, md_dict)
def _is_notebook(self): try: from IPython.core.interactiveshell import InteractiveShell from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell as notebook from IPython.terminal.interactiveshell import TerminalInteractiveShell as shell if InteractiveShell.initialized(): ip = get_ipython() if isinstance(ip, notebook): return True elif isinstance(ip, shell): return False else: raise Exception('Wrong Shell') else: return False except Exception as e: self.print_error(e) return False
def enable_ipython_completer(): import sys if 'IPython' in sys.modules: ip_running = False try: from IPython.core.interactiveshell import InteractiveShell ip_running = InteractiveShell.initialized() except ImportError: # support <ipython-0.11 from IPython import ipapi as _ipapi ip_running = _ipapi.get() is not None except Exception: pass if ip_running: from . import ipy_completer return ipy_completer.load_ipython_extension() raise RuntimeError('completer must be enabled in active ipython session')
def hlt(line, cell): if not line: raise ValueError("Please provide a title for the highlight") outputs = [] def capture_display(msg): if msg['content']['data'] in outputs: # display only once return None outputs.append(msg['content']) return msg cell = cell.strip() annotation = None if cell.endswith('"""'): *rest, annotation = cell.split('"""')[:-1] cell = '"""'.join(rest) shell = InteractiveShell.instance() # Capture any output that is displayed before output (like matplotlib plots) shell.display_pub.register_hook(capture_display) header = f'## {line}' try: publish_display_data({'text/markdown': header}) result = shell.run_cell(cell).result outputs.append( dict( zip(('data', 'metadata'), shell.display_formatter.format(result)))) if annotation: publish_display_data({'text/markdown': annotation}) finally: shell.display_pub.unregister_hook(capture_display) all_out = outputs env.o.add_highlight(line, all_out) return None
def create_inputhook_gevent(mgr): """Create an input hook for running the gevent event loop. Parameters ---------- mgr : an InputHookManager Returns ------- An inputhook """ # Re-use previously created inputhook if any ip = InteractiveShell.instance() if hasattr(ip, '_inputhook_gevent'): return ip._inputhook_gevent got_kbdint = [False] def inputhook_gevent(): """PyOS_InputHook python hook for Gevent. """ try: ignore_CTRL_C() gevent.sleep(0.01) while not stdin_ready(): gevent.sleep(0.05) except: ignore_CTRL_C() from traceback import print_exc print_exc() finally: allow_CTRL_C() return 0 def preprompthook_gevent(ishell): if got_kbdint[0]: mgr.set_inputhook(inputhook_gevent) got_kbdint[0] = False ip._inputhook_gevent = inputhook_gevent ip.set_hook('pre_prompt_hook', preprompthook_gevent) return inputhook_gevent
def _ipython_display_(self, **kwargs): from IPython.core.interactiveshell import InteractiveShell import IPython # from IPython.Widget._ipython_display_ if InteractiveShell.initialized(): if self.widget._view_name is not None: plaintext = repr(self) data = { 'text/plain': plaintext, 'application/vnd.jupyter.widget-view+json': { 'version_major': 2, 'version_minor': 0, 'model_id': self.widget._model_id } } IPython.display.display(data, raw=True) self.widget._handle_displayed(**kwargs)
def __init__(self, local_ns=None, global_ns=None, default_value=None, **metadata): if local_ns is None and global_ns is None: try: #Avoid creating a new interactiveshell instance __IPYTHON__ except NameError: local_ns = globals() global_ns = globals() else: shell = InteractiveShell.instance() local_ns = shell.user_ns global_ns = shell.user_global_ns self.locals = local_ns self.globals = global_ns super(ExecutableTrait, self).__init__(default_value, **metadata)
def save_n_explore(folder, path): """ Save and explore job-folder. For use with ipython interactive terminal only. """ from .. import is_interactive from ..error import interactive as ierror if not is_interactive: raise ierror('Not in interactive session.') from IPython.core.interactiveshell import InteractiveShell from ..ipython.explore import explore from ..ipython.savefolders import savefolders import pylada pylada.interactive.jobfolder = folder.root pylada.interactive.jobfolder_path = path shell = InteractiveShell.instance() savefolders(shell, path) explore(shell, '{0} --file'.format(path))
def _update_plot(self): # Set max of 4 frames per second if time.time() - self._last_draw < 0.25: return self._last_draw = time.time() self.ax.relim() self.ax.cla() self.ax.plot(self.xdata, self.ydata) self.ax.legend(labels=[f"{self.ylabel} ({self.ydata[-1]:.4f})"]) if InteractiveShell.initialized(): # Support for notebook backend. print("ADLStream", end="") # Needed due to a bug (StackOverflow #66176016). display(self.fig) clear_output(wait=True) plt.pause(1e-9)
def run_notebook(path, start=0, last=None): shell = InteractiveShell.instance() with io.open(path, 'r', encoding='utf-8') as f: nb = read(f, 4) result = [] if last is None: last = len(nb.cells) for cell_num in range(start, last): if nb.cells[cell_num].cell_type == 'code': # transform the input to executable Python code = shell.input_transformer_manager.transform_cell( nb.cells[cell_num].source) # run the code in themodule else: code = nb.cells[cell_num].source result.append(shell.run_cell(code)) return result
def ipython2python(code): """Transform IPython syntax to pure Python syntax Parameters ---------- code : str IPython code, to be transformed to pure Python """ try: from IPython.core.interactiveshell import InteractiveShell except ImportError: warnings.warn( "IPython is needed to transform IPython syntax to pure Python." " Install ipython if you need this functionality." ) return code else: shell = InteractiveShell.instance() return shell.input_transformer_manager.transform_cell(code)
def render(self): from IPython.core.interactiveshell import InteractiveShell display_pub = InteractiveShell.instance().display_pub try: display_pub.register_hook(self.hook_msg) super(PixieDustApp, self).render() except RunInPixieDebugger: self.options.pop("handlerId") self.options['new_parent_prefix'] = False entity={ "breakpoints": ["{}.{}".format(self.__pixieapp_class_name__, self.breakpoints)], "code": self.get_pd_controls()["command"] } self.breakpoints = None runPixieApp( "pixiedust.apps.debugger.PixieDebugger", parent_pixieapp=self, entity=entity, **{"options":self.options}) finally: display_pub.unregister_hook(self.hook_msg)
def cache(line, cell): key = str(hash(cell.strip())) cache = env.o.get_cached().get(key) if cache: print(f"Using cached version ('{key}')") for output in cache: publish_display_data(**output) return None outputs = [] def capture_display(msg): if msg['content']['data'] in outputs: # display only once return None outputs.append(msg['content']) return msg shell = InteractiveShell.instance() # Capture any output that is displayed before output (like matplotlib plots) shell.display_pub.register_hook(capture_display) try: output = shell.run_cell(cell) result = output.result if output.error_in_exec: raise RuntimeError("Error in cell output, not caching") outputs.append( dict( zip(('data', 'metadata'), shell.display_formatter.format(result)))) finally: shell.display_pub.unregister_hook(capture_display) all_out = outputs env.o.cache_result(key, all_out) return None
def print_notebook_dependencies(notebook_name, path=None): # notebook_path = import_notebooks.find_notebook(notebook_name, path) notebook_path = notebook_name # load the notebook with io.open(notebook_path, 'r', encoding='utf-8') as f: notebook = nbformat.read(f, 4) shell = InteractiveShell.instance() modules = set() for cell in notebook.cells: if cell.cell_type == 'code': # transform the input to executable Python code = shell.input_transformer_manager.transform_cell(cell.source) for match in re.finditer(RE_IMPORT, code): modules.add(match.group(1)) for match in re.finditer(RE_FROM, code): modules.add(match.group(1)) for module in modules: print(module)
def print_callback(val): """ Internal function. This function is called via a call back returning from IPC to Cython to Python. It tries to perform incremental printing to IPython Notebook or Jupyter Notebook and when all else fails, just prints locally. """ success = False try: # for reasons I cannot fathom, regular printing, even directly # to io.stdout does not work. # I have to intrude rather deep into IPython to make it behave if have_ipython: if InteractiveShell.initialized(): IPython.display.publish_display_data({'text/plain':val,'text/html':'<pre>' + val + '</pre>'}) success = True except: pass if not success: print(val) sys.stdout.flush()
def load_notebook(fullname: str): """Import a notebook as a module.""" shell = InteractiveShell.instance() path = fullname # load the notebook object with open(path, 'r', encoding='utf-8') as f: notebook = read(f, 4) # create the module and add it to sys.modules mod = types.ModuleType(fullname) mod.__file__ = path # mod.__loader__ = self mod.__dict__['get_ipython'] = get_ipython sys.modules[fullname] = mod # extra work to ensure that magics that would affect the user_ns # actually affect the notebook module's ns save_user_ns = shell.user_ns shell.user_ns = mod.__dict__ try: for cell in notebook.cells: if cell.cell_type == 'code': try: # only run valid python code ast.parse(cell.source) except SyntaxError: continue try: # pylint: disable=exec-used exec(cell.source, mod.__dict__) except NameError: print(cell.source) raise finally: shell.user_ns = save_user_ns return mod
def set_matplotlib_formats(*formats, **kwargs): """Select figure formats for the inline backend. Optionally pass quality for JPEG. For example, this enables PNG and JPEG output with a JPEG quality of 90%:: In [1]: set_matplotlib_formats('png', 'jpeg', quality=90) To set this in your config files use the following:: c.InlineBackend.figure_formats = {'pdf', 'png', 'svg'} c.InlineBackend.quality = 90 Parameters ---------- *formats : list, tuple One or a set of figure formats to enable: 'png', 'retina', 'jpeg', 'svg', 'pdf'. quality : int A percentage for the quality of JPEG figures. Defaults to 90. """ from IPython.core.interactiveshell import InteractiveShell from IPython.core.pylabtools import select_figure_formats shell = InteractiveShell.instance() select_figure_formats(shell, formats, quality=90)
def create_notebook_with_imports(path, toplevel=True): """Create notebook that only has imports and return path""" try: with open(path) as fil: notebook = nbformat.read(fil, as_version=4) metadata = notebook["metadata"] except Exception as exc: # pylint: disable=broad-except print("Failed to load notebook {}".format(exc)) return (None, False) language_info = metadata.get("language_info", {}) language = language_info.get("name", "unknown") if language == "python": shell = InteractiveShell.instance() for cell in notebook['cells']: if cell.get("cell_type") == "code": source = cell["source"] or "" cell["source"] = "" try: source = shell.input_transformer_manager.transform_cell( source) if "\0" in source: source = source.replace("\0", "\n") tree = ast.parse(source) visitor = ImportVisitor() visitor.visit(tree) cell["source"] = visitor.import_only_code(toplevel) except (IndentationError, SyntaxError): pass try: with open(path + ".julimp", "w") as fil: nbformat.write(notebook, fil) return (path + ".julimp", True) except Exception as exc: # pylint: disable=broad-except print("Failed to save notebook {}".format(exc)) return (None, False) return (path, False)
import os from pathlib import Path from IPython.core.alias import Alias from IPython.core.interactiveshell import InteractiveShell from IPython.core.magic import MagicAlias from IPython.utils.text import dedent, indent shell = InteractiveShell.instance() magics = shell.magics_manager.magics def _strip_underline(line): chars = set(line.strip()) if len(chars) == 1 and ('-' in chars or '=' in chars): return "" else: return line def format_docstring(func): docstring = (func.__doc__ or "Undocumented").rstrip() docstring = indent(dedent(docstring)) # Sphinx complains if indented bits have rst headings in, so strip out # any underlines in the docstring. lines = [_strip_underline(l) for l in docstring.splitlines()] return "\n".join(lines) output = [ "Line magics", "===========", "", ]
def __init__(self, path=None): self.shell = InteractiveShell.instance() self.path = path
def create_inputhook_qt4(mgr, app=None): """Create an input hook for running the Qt4 application event loop. Parameters ---------- mgr : an InputHookManager app : Qt Application, optional. Running application to use. If not given, we probe Qt for an existing application object, and create a new one if none is found. Returns ------- A pair consisting of a Qt Application (either the one given or the one found or created) and a inputhook. Notes ----- We use a custom input hook instead of PyQt4's default one, as it interacts better with the readline packages (issue #481). The inputhook function works in tandem with a 'pre_prompt_hook' which automatically restores the hook as an inputhook in case the latter has been temporarily disabled after having intercepted a KeyboardInterrupt. """ if app is None: app = QtCore.QCoreApplication.instance() if app is None: app = QtGui.QApplication([" "]) # Re-use previously created inputhook if any ip = InteractiveShell.instance() if hasattr(ip, "_inputhook_qt4"): return app, ip._inputhook_qt4 # Otherwise create the inputhook_qt4/preprompthook_qt4 pair of # hooks (they both share the got_kbdint flag) def inputhook_qt4(): """PyOS_InputHook python hook for Qt4. Process pending Qt events and if there's no pending keyboard input, spend a short slice of time (50ms) running the Qt event loop. As a Python ctypes callback can't raise an exception, we catch the KeyboardInterrupt and temporarily deactivate the hook, which will let a *second* CTRL+C be processed normally and go back to a clean prompt line. """ try: allow_CTRL_C() app = QtCore.QCoreApplication.instance() if not app: # shouldn't happen, but safer if it happens anyway... return 0 app.processEvents(QtCore.QEventLoop.AllEvents, 300) if not stdin_ready(): # Generally a program would run QCoreApplication::exec() # from main() to enter and process the Qt event loop until # quit() or exit() is called and the program terminates. # # For our input hook integration, we need to repeatedly # enter and process the Qt event loop for only a short # amount of time (say 50ms) to ensure that Python stays # responsive to other user inputs. # # A naive approach would be to repeatedly call # QCoreApplication::exec(), using a timer to quit after a # short amount of time. Unfortunately, QCoreApplication # emits an aboutToQuit signal before stopping, which has # the undesirable effect of closing all modal windows. # # To work around this problem, we instead create a # QEventLoop and call QEventLoop::exec(). Other than # setting some state variables which do not seem to be # used anywhere, the only thing QCoreApplication adds is # the aboutToQuit signal which is precisely what we are # trying to avoid. timer = QtCore.QTimer() event_loop = QtCore.QEventLoop() timer.timeout.connect(event_loop.quit) while not stdin_ready(): timer.start(50) event_loop.exec_() timer.stop() except KeyboardInterrupt: global got_kbdint, sigint_timer ignore_CTRL_C() got_kbdint = True mgr.clear_inputhook() # This generates a second SIGINT so the user doesn't have to # press CTRL+C twice to get a clean prompt. # # Since we can't catch the resulting KeyboardInterrupt here # (because this is a ctypes callback), we use a timer to # generate the SIGINT after we leave this callback. # # Unfortunately this doesn't work on Windows (SIGINT kills # Python and CTRL_C_EVENT doesn't work). if os.name == "posix": pid = os.getpid() if not sigint_timer: sigint_timer = threading.Timer( 0.01, os.kill, args=[pid, signal.SIGINT] ) sigint_timer.start() else: print("\nKeyboardInterrupt - Ctrl-C again for new prompt") except: # NO exceptions are allowed to escape from a ctypes callback ignore_CTRL_C() from traceback import print_exc print_exc() print("Got exception from inputhook_qt4, unregistering.") mgr.clear_inputhook() finally: allow_CTRL_C() return 0 def preprompthook_qt4(ishell): """'pre_prompt_hook' used to restore the Qt4 input hook (in case the latter was temporarily deactivated after a CTRL+C) """ global got_kbdint, sigint_timer if sigint_timer: sigint_timer.cancel() sigint_timer = None if got_kbdint: mgr.set_inputhook(inputhook_qt4) got_kbdint = False ip._inputhook_qt4 = inputhook_qt4 ip.set_hook("pre_prompt_hook", preprompthook_qt4) return app, inputhook_qt4
def init_alias(self): # InteractiveShell defines alias's we want, but TerminalInteractiveShell defines # ones we don't. So don't use super and instead go right to InteractiveShell InteractiveShell.init_alias(self)