execnb 0.1.6__tar.gz → 0.1.7__tar.gz

{execnb-0.1.6/execnb.egg-info → execnb-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: execnb
-Version: 0.1.6
+Version: 0.1.7
 Summary: A description of your project
 Home-page: https://github.com/fastai/execnb/
 Author: Jeremy Howard
@@ -18,6 +18,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastcore>=1.5.5
 Requires-Dist: ipython
+Requires-Dist: mistletoe
 Provides-Extra: dev
 Requires-Dist: matplotlib; extra == "dev"
 Requires-Dist: Pillow; extra == "dev"

execnb-0.1.7/execnb/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.7"

{execnb-0.1.6 → execnb-0.1.7}/execnb/_modidx.py

@@ -5,8 +5,7 @@ d = { 'settings': { 'branch': 'master',
                 'doc_host': 'https://fastai.github.io',
                 'git_url': 'https://github.com/fastai/execnb/',
                 'lib_path': 'execnb'},
-  'syms': { 'execnb.fastshell': {},
-            'execnb.nbio': { 'execnb.nbio.NbCell': ('nbio.html#nbcell', 'execnb/nbio.py'),
+  'syms': { 'execnb.nbio': { 'execnb.nbio.NbCell': ('nbio.html#nbcell', 'execnb/nbio.py'),
                              'execnb.nbio.NbCell.__eq__': ('nbio.html#nbcell.__eq__', 'execnb/nbio.py'),
                              'execnb.nbio.NbCell.__hash__': ('nbio.html#nbcell.__hash__', 'execnb/nbio.py'),
                              'execnb.nbio.NbCell.__init__': ('nbio.html#nbcell.__init__', 'execnb/nbio.py'),
@@ -23,31 +22,36 @@ d = { 'settings': { 'branch': 'master',
                              'execnb.nbio.write_nb': ('nbio.html#write_nb', 'execnb/nbio.py')},
             'execnb.shell': { 'execnb.shell.CaptureShell': ('shell.html#captureshell', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.__init__': ('shell.html#captureshell.__init__', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell._add_exec': ('shell.html#captureshell._add_exec', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell._add_out': ('shell.html#captureshell._add_out', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell._result': ('shell.html#captureshell._result', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell._showtraceback': ('shell.html#captureshell._showtraceback', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell._stream': ('shell.html#captureshell._stream', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.cell': ('shell.html#captureshell.cell', 'execnb/shell.py'),
+                              'execnb.shell.CaptureShell.complete': ('shell.html#captureshell.complete', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.enable_gui': ('shell.html#captureshell.enable_gui', 'execnb/shell.py'),
-                              'execnb.shell.CaptureShell.enable_matplotlib': ( 'shell.html#captureshell.enable_matplotlib',
-                                                                               'execnb/shell.py'),
                               'execnb.shell.CaptureShell.execute': ('shell.html#captureshell.execute', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.prettytb': ('shell.html#captureshell.prettytb', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.run': ('shell.html#captureshell.run', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.run_all': ('shell.html#captureshell.run_all', 'execnb/shell.py'),
+                              'execnb.shell.CaptureShell.run_cell': ('shell.html#captureshell.run_cell', 'execnb/shell.py'),
                               'execnb.shell.CaptureShell.set_path': ('shell.html#captureshell.set_path', 'execnb/shell.py'),
-                              'execnb.shell._CaptureHook': ('shell.html#_capturehook', 'execnb/shell.py'),
-                              'execnb.shell._CaptureHook.__call__': ('shell.html#_capturehook.__call__', 'execnb/shell.py'),
-                              'execnb.shell._CaptureHook.quiet': ('shell.html#_capturehook.quiet', 'execnb/shell.py'),
-                              'execnb.shell._CapturePub': ('shell.html#_capturepub', 'execnb/shell.py'),
-                              'execnb.shell._CapturePub.publish': ('shell.html#_capturepub.publish', 'execnb/shell.py'),
+                              'execnb.shell.ExecutionInfo.__repr__': ('shell.html#executioninfo.__repr__', 'execnb/shell.py'),
+                              'execnb.shell.ExecutionResult.__repr__': ('shell.html#executionresult.__repr__', 'execnb/shell.py'),
+                              'execnb.shell.SmartCompleter': ('shell.html#smartcompleter', 'execnb/shell.py'),
+                              'execnb.shell.SmartCompleter.__call__': ('shell.html#smartcompleter.__call__', 'execnb/shell.py'),
+                              'execnb.shell.SmartCompleter.__init__': ('shell.html#smartcompleter.__init__', 'execnb/shell.py'),
+                              'execnb.shell._CustDisplayHook': ('shell.html#_custdisplayhook', 'execnb/shell.py'),
+                              'execnb.shell._CustDisplayHook.log_output': ('shell.html#_custdisplayhook.log_output', 'execnb/shell.py'),
+                              'execnb.shell._CustDisplayHook.write_format_data': ( 'shell.html#_custdisplayhook.write_format_data',
+                                                                                   'execnb/shell.py'),
+                              'execnb.shell._CustDisplayHook.write_output_prompt': ( 'shell.html#_custdisplayhook.write_output_prompt',
+                                                                                     'execnb/shell.py'),
                               'execnb.shell._false': ('shell.html#_false', 'execnb/shell.py'),
                               'execnb.shell._format_mimedata': ('shell.html#_format_mimedata', 'execnb/shell.py'),
+                              'execnb.shell._mk_out': ('shell.html#_mk_out', 'execnb/shell.py'),
                               'execnb.shell._out_exc': ('shell.html#_out_exc', 'execnb/shell.py'),
+                              'execnb.shell._out_nb': ('shell.html#_out_nb', 'execnb/shell.py'),
                               'execnb.shell._out_stream': ('shell.html#_out_stream', 'execnb/shell.py'),
                               'execnb.shell.exec_nb': ('shell.html#exec_nb', 'execnb/shell.py'),
                               'execnb.shell.find_output': ('shell.html#find_output', 'execnb/shell.py'),
+                              'execnb.shell.format_exc': ('shell.html#format_exc', 'execnb/shell.py'),
                               'execnb.shell.out_error': ('shell.html#out_error', 'execnb/shell.py'),
                               'execnb.shell.out_exec': ('shell.html#out_exec', 'execnb/shell.py'),
-                              'execnb.shell.out_stream': ('shell.html#out_stream', 'execnb/shell.py')}}}
+                              'execnb.shell.out_stream': ('shell.html#out_stream', 'execnb/shell.py'),
+                              'execnb.shell.render_outputs': ('shell.html#render_outputs', 'execnb/shell.py')}}}

{execnb-0.1.6 → execnb-0.1.7}/execnb/nbio.py

@@ -1,9 +1,11 @@
+"""Reading and writing Jupyter notebooks"""
+
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/01_nbio.ipynb.
 
 # %% auto 0
 __all__ = ['NbCell', 'dict2nb', 'read_nb', 'new_nb', 'mk_cell', 'nb2dict', 'nb2str', 'write_nb']
 
-# %% ../nbs/01_nbio.ipynb 2
+# %% ../nbs/01_nbio.ipynb
 from fastcore.basics import *
 from fastcore.imports import *
 
@@ -11,11 +13,11 @@ import ast,functools
 from pprint import pformat,pprint
 from json import loads,dumps
 
-# %% ../nbs/01_nbio.ipynb 6
+# %% ../nbs/01_nbio.ipynb
 def _read_json(self, encoding=None, errors=None):
     return loads(Path(self).read_text(encoding=encoding, errors=errors))
 
-# %% ../nbs/01_nbio.ipynb 13
+# %% ../nbs/01_nbio.ipynb
 class NbCell(AttrDict):
     def __init__(self, idx, cell):
         super().__init__(cell)
@@ -38,7 +40,7 @@ class NbCell(AttrDict):
     def __hash__(self): return hash(self.source) + hash(self.cell_type)
     def __eq__(self,o): return self.source==o.source and self.cell_type==o.cell_type
 
-# %% ../nbs/01_nbio.ipynb 15
+# %% ../nbs/01_nbio.ipynb
 def _dict2obj(d, list_func=list, dict_func=AttrDict):
     "Convert (possibly nested) dicts (or lists of dicts) to `AttrDict`"
     if isinstance(d, list): return list(map(_dict2obj, d))
@@ -51,19 +53,19 @@ def dict2nb(js=None, **kwargs):
     nb.cells = [NbCell(*o) for o in enumerate(nb.cells)]
     return nb
 
-# %% ../nbs/01_nbio.ipynb 20
+# %% ../nbs/01_nbio.ipynb
 def read_nb(path):
     "Return notebook at `path`"
     res = dict2nb(_read_json(path, encoding='utf-8'))
     res['path_'] = str(path)
     return res
 
-# %% ../nbs/01_nbio.ipynb 26
+# %% ../nbs/01_nbio.ipynb
 def new_nb(cells=None, meta=None, nbformat=4, nbformat_minor=5):
     "Returns an empty new notebook"
     return dict2nb(cells=cells or [],metadata=meta or {},nbformat=nbformat,nbformat_minor=nbformat_minor)
 
-# %% ../nbs/01_nbio.ipynb 28
+# %% ../nbs/01_nbio.ipynb
 def mk_cell(text,  # `source` attr in cell
             cell_type='code',  # `cell_type` attr in cell
             **kwargs):  # any other attrs to add to cell
@@ -75,7 +77,7 @@ def mk_cell(text,  # `source` attr in cell
         kwargs['execution_count']=0
     return NbCell(0, dict(cell_type=cell_type, source=text, directives_={}, **kwargs))
 
-# %% ../nbs/01_nbio.ipynb 31
+# %% ../nbs/01_nbio.ipynb
 def nb2dict(d, k=None):
     "Convert parsed notebook to `dict`"
     if k=='source': return d.splitlines(keepends=True)
@@ -83,13 +85,13 @@ def nb2dict(d, k=None):
     if not isinstance(d, dict): return d
     return dict(**{k:nb2dict(v,k) for k,v in d.items() if k[-1] != '_'})
 
-# %% ../nbs/01_nbio.ipynb 34
+# %% ../nbs/01_nbio.ipynb
 def nb2str(nb):
     "Convert `nb` to a `str`"
     if isinstance(nb, (AttrDict,list)): nb = nb2dict(nb)
     return dumps(nb, sort_keys=True, indent=1, ensure_ascii=False) + "\n"
 
-# %% ../nbs/01_nbio.ipynb 37
+# %% ../nbs/01_nbio.ipynb
 def write_nb(nb, path):
     "Write `nb` to `path`"
     new = nb2str(nb)

execnb-0.1.7/execnb/shell.py

@@ -0,0 +1,289 @@
+"""A shell for running notebook code without a notebook server"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_shell.ipynb.
+
+# %% ../nbs/02_shell.ipynb 2
+from __future__ import annotations
+
+from fastcore.utils import *
+from fastcore.script import call_parse
+from fastcore.ansi import ansi2html
+
+import mistletoe,multiprocessing,types,traceback,signal
+try:
+    if sys.platform == 'darwin': multiprocessing.set_start_method("fork")
+except RuntimeError: pass # if re-running cell
+
+from IPython.core.interactiveshell import InteractiveShell, ExecutionInfo, ExecutionResult
+from IPython.core.displayhook import DisplayHook
+from IPython.utils.capture import capture_output
+from IPython.utils.text import strip_ansi
+from IPython.core.completer import IPCompleter,provisionalcompleter
+from IPython.core.hooks import CommandChainDispatcher
+from IPython.core.completerlib import module_completer
+from IPython.utils.strdispatch import StrDispatch
+from IPython.display import display as disp, HTML
+
+from base64 import b64encode
+from html import escape
+try: from matplotlib_inline.backend_inline import set_matplotlib_formats
+except ImportError: set_matplotlib_formats = None
+
+
+from .nbio import *
+from .nbio import _dict2obj
+
+# %% auto 0
+__all__ = ['CaptureShell', 'format_exc', 'render_outputs', 'find_output', 'out_exec', 'out_stream', 'out_error', 'exec_nb',
+           'SmartCompleter']
+
+# %% ../nbs/02_shell.ipynb
+class _CustDisplayHook(DisplayHook):
+    def write_output_prompt(self): pass
+    def write_format_data(self, data, md_dict): pass
+    def log_output(self, format_dict): pass
+
+@patch
+def __repr__(self: ExecutionInfo): return f'cell: {self.raw_cell}; id: {self.cell_id}'
+
+@patch
+def __repr__(self: ExecutionResult): return f'result: {self.result}; err: {self.error_in_exec}; info: <{self.info}>'
+
+# %% ../nbs/02_shell.ipynb
+class CaptureShell(InteractiveShell):
+    displayhook_class = _CustDisplayHook
+
+    def __init__(self, path:str|Path=None, mpl_format='retina', history=False, timeout=None):
+        super().__init__()
+        self.history_manager.enabled = history
+        self.timeout = timeout
+        self.result,self.exc = None,None
+        if path: self.set_path(path)
+        self.display_formatter.active = True
+        if not IN_NOTEBOOK: InteractiveShell._instance = self
+        if set_matplotlib_formats:
+            self.enable_matplotlib("inline")
+            self.run_cell("from matplotlib_inline.backend_inline import set_matplotlib_formats")
+            self.run_cell(f"set_matplotlib_formats('{mpl_format}')")
+
+    def run_cell(self, raw_cell, store_history=False, silent=False, shell_futures=True, cell_id=None,
+                 stdout=True, stderr=True, display=True, timeout=None):
+        if not timeout: timeout = self.timeout
+        # TODO what if there's a comment?
+        semic = raw_cell.rstrip().endswith(';')
+        if timeout:
+            def handler(*args): raise TimeoutError()
+            signal.signal(signal.SIGALRM, handler)
+            signal.alarm(timeout)
+        with capture_output(display=display, stdout=stdout, stderr=stderr) as c:
+            result = super().run_cell(raw_cell, store_history, silent, shell_futures=shell_futures, cell_id=cell_id)
+        if timeout: signal.alarm(0)
+        return AttrDict(result=result, stdout='' if semic else c.stdout, stderr=c.stderr,
+                        display_objects=c.outputs, exception=result.error_in_exec, quiet=semic)
+    
+    def set_path(self, path):
+        "Add `path` to python path, or `path.parent` if it's a file"
+        path = Path(path)
+        if path.is_file(): path = path.parent
+        self.run_cell(f"import sys; sys.path.insert(0, '{path.as_posix()}')")
+    
+    def enable_gui(self, gui=None): pass
+
+# %% ../nbs/02_shell.ipynb
+def format_exc(e):
+    "Format exception `e` as a string"
+    return ''.join(traceback.format_exception(type(e), e, e.__traceback__))
+
+# %% ../nbs/02_shell.ipynb
+def _out_stream(text, name): return dict(name=name, output_type='stream', text=text.splitlines(True))
+def _out_exc(e):
+    ename = type(e).__name__
+    tb = traceback.extract_tb(e.__traceback__)#.format()
+    return dict(ename=str(ename), evalue=str(e), output_type='error', traceback=format_exc(e))
+
+def _format_mimedata(k, v):
+    "Format mime-type keyed data consistently with Jupyter"
+    if k.startswith('text/'): return v.splitlines(True)
+    if k.startswith('image/') and isinstance(v, bytes):
+        v = b64encode(v).decode()
+        return v+'\n' if not v.endswith('\n') else v
+    return v
+
+def _mk_out(data, meta, output_type='display_data'):
+    fd = {k:_format_mimedata(k,v) for k,v in data.items()}
+    return dict(data=fd, metadata=meta, output_type=output_type)
+
+def _out_nb(o, fmt):
+    res = []
+    if o.stdout: res.append(_out_stream(o.stdout, 'stdout'))
+    if o.stderr: res.append(_out_stream(o.stderr, 'stderr'))
+    if o.exception: res.append(_out_exc(o.exception))
+    r = o.result.result
+    for x in o.display_objects: res.append(_mk_out(x.data, x.metadata))
+    if r is not None and not o.quiet:
+        res.append(_mk_out(*fmt.format(r), 'execute_result'))
+    return res
+
+# %% ../nbs/02_shell.ipynb
+@patch
+def run(self:CaptureShell,
+        code:str, # Python/IPython code to run
+        stdout=True, # Capture stdout and save as output?
+        stderr=True): # Capture stderr and save as output?
+    "Run `code`, returning a list of all outputs in Jupyter notebook format"
+    res = self.run_cell(code, stdout=stdout, stderr=stderr)
+    self.result = res.result.result
+    self.exc = res.exception
+    return _out_nb(res, self.display_formatter)
+
+# %% ../nbs/02_shell.ipynb
+def render_outputs(outputs, ansi_renderer=strip_ansi):
+    def render_output(out):
+        otype = out['output_type']
+        if otype == 'stream':
+            txt = ansi_renderer(''.join(out['text']))
+            return f"<pre>{txt}</pre>" if out['name']=='stdout' else f"<pre class='stderr'>{txt}</pre>"
+        elif otype in ('display_data','execute_result'):
+            data = out['data']
+            _g = lambda t: ''.join(data[t]) if t in data else None
+            if d := _g('text/html'): return d
+            if d := _g('application/javascript'): return f'<script>{d}</script>'
+            if d := _g('text/markdown'): return mistletoe.markdown(d)
+            if d := _g('image/svg+xml'): return d
+            if d := _g('image/jpeg'): return f'<img src="data:image/jpeg;base64,{d}"/>'
+            if d := _g('image/png'): return f'<img src="data:image/png;base64,{d}"/>'
+            if d := _g('text/latex'): return f'<div class="math">${d}$</div>'
+            if d := _g('text/plain'): return f"<pre>{escape(d)}</pre>"
+        return ''
+    
+    return '\n'.join(map(render_output, outputs))
+
+# %% ../nbs/02_shell.ipynb
+@patch
+def cell(self:CaptureShell, cell, stdout=True, stderr=True):
+    "Run `cell`, skipping if not code, and store outputs back in cell"
+    if cell.cell_type!='code': return
+    self._cell_idx = cell.idx_ + 1
+    outs = self.run(cell.source)
+    if outs:
+        cell.outputs = _dict2obj(outs)
+        for o in outs:
+            if 'execution_count' in o: cell['execution_count'] = o['execution_count']
+
+# %% ../nbs/02_shell.ipynb
+def find_output(outp, # Output from `run`
+                ot='execute_result' # Output_type to find
+               ):
+    "Find first output of type `ot` in `CaptureShell.run` output"
+    return first(o for o in outp if o['output_type']==ot)
+
+# %% ../nbs/02_shell.ipynb
+def out_exec(outp):
+    "Get data from execution result in `outp`."
+    out = find_output(outp)
+    if out: return '\n'.join(first(out['data'].values()))
+
+# %% ../nbs/02_shell.ipynb
+def out_stream(outp):
+    "Get text from stream in `outp`."
+    out = find_output(outp, 'stream')
+    if out: return ('\n'.join(out['text'])).strip()
+
+# %% ../nbs/02_shell.ipynb
+def out_error(outp):
+    "Get traceback from error in `outp`."
+    out = find_output(outp, 'error')
+    if out: return '\n'.join(out['traceback'])
+
+# %% ../nbs/02_shell.ipynb
+def _false(o): return False
+
+@patch
+def run_all(self:CaptureShell,
+            nb, # A notebook read with `nbclient` or `read_nb`
+            exc_stop:bool=False, # Stop on exceptions?
+            preproc:callable=_false, # Called before each cell is executed
+            postproc:callable=_false, # Called after each cell is executed
+            inject_code:str|None=None, # Code to inject into a cell
+            inject_idx:int=0 # Cell to replace with `inject_code`
+           ):
+    "Run all cells in `nb`, stopping at first exception if `exc_stop`"
+    if inject_code is not None: nb.cells[inject_idx].source = inject_code
+    for cell in nb.cells:
+        if not preproc(cell):
+            self.cell(cell)
+            postproc(cell)
+        if self.exc and exc_stop: raise self.exc from None
+
+# %% ../nbs/02_shell.ipynb
+@patch
+def execute(self:CaptureShell,
+            src:str|Path, # Notebook path to read from
+            dest:str|None=None, # Notebook path to write to
+            exc_stop:bool=False, # Stop on exceptions?
+            preproc:callable=_false, # Called before each cell is executed
+            postproc:callable=_false, # Called after each cell is executed
+            inject_code:str|None=None, # Code to inject into a cell
+            inject_path:str|Path|None=None, # Path to file containing code to inject into a cell
+            inject_idx:int=0 # Cell to replace with `inject_code`
+):
+    "Execute notebook from `src` and save with outputs to `dest"
+    nb = read_nb(src)
+    self._fname = src
+    self.set_path(Path(src).parent.resolve())
+    if inject_path is not None: inject_code = Path(inject_path).read_text()
+    self.run_all(nb, exc_stop=exc_stop, preproc=preproc, postproc=postproc,
+                 inject_code=inject_code, inject_idx=inject_idx)
+    if dest: write_nb(nb, dest)
+
+# %% ../nbs/02_shell.ipynb
+@patch
+def prettytb(self:CaptureShell, 
+             fname:str|Path=None): # filename to print alongside the traceback
+    "Show a pretty traceback for notebooks, optionally printing `fname`."
+    fname = fname if fname else self._fname
+    _fence = '='*75
+    cell_intro_str = f"While Executing Cell #{self._cell_idx}:" if self._cell_idx else "While Executing:"
+    cell_str = f"\n{cell_intro_str}\n{format_exc(self.exc)}"
+    fname_str = f' in {fname}' if fname else ''
+    return f"{type(self.exc).__name__}{fname_str}:\n{_fence}\n{cell_str}\n"
+
+# %% ../nbs/02_shell.ipynb
+@call_parse
+def exec_nb(
+    src:str, # Notebook path to read from
+    dest:str='', # Notebook path to write to
+    exc_stop:bool=False, # Stop on exceptions?
+    inject_code:str=None, # Code to inject into a cell
+    inject_path:str=None, # Path to file containing code to inject into a cell
+    inject_idx:int=0 # Cell to replace with `inject_code`
+):
+    "Execute notebook from `src` and save with outputs to `dest`"
+    CaptureShell().execute(src, dest, exc_stop=exc_stop, inject_code=inject_code,
+                           inject_path=inject_path, inject_idx=inject_idx)
+
+# %% ../nbs/02_shell.ipynb
+class SmartCompleter(IPCompleter):
+    def __init__(self, shell, namespace=None, jedi=False):
+        if namespace is None: namespace = shell.user_ns
+        super().__init__(shell, namespace)
+        self.use_jedi = jedi
+        sdisp = StrDispatch()
+        self.custom_completers = sdisp
+        import_disp = CommandChainDispatcher()
+        import_disp.add(types.MethodType(module_completer, shell))
+        sdisp.add_s('import', import_disp)
+        sdisp.add_s('from', import_disp)
+
+    def __call__(self, c):
+        if not c: return []
+        with provisionalcompleter():
+            return [o.text.rpartition('.')[-1]
+                    for o in self.completions(c, len(c))
+                    if o.type not in ('magic', 'path')]
+
+# %% ../nbs/02_shell.ipynb
+@patch
+def complete(self:CaptureShell, c):
+    if not hasattr(self, '_completer'): self._completer = SmartCompleter(self)
+    return self._completer(c)

{execnb-0.1.6 → execnb-0.1.7/execnb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: execnb
-Version: 0.1.6
+Version: 0.1.7
 Summary: A description of your project
 Home-page: https://github.com/fastai/execnb/
 Author: Jeremy Howard
@@ -18,6 +18,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastcore>=1.5.5
 Requires-Dist: ipython
+Requires-Dist: mistletoe
 Provides-Extra: dev
 Requires-Dist: matplotlib; extra == "dev"
 Requires-Dist: Pillow; extra == "dev"

{execnb-0.1.6 → execnb-0.1.7}/execnb.egg-info/SOURCES.txt

@@ -1,11 +1,11 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 settings.ini
 setup.py
 execnb/__init__.py
 execnb/_modidx.py
-execnb/fastshell.py
 execnb/nbio.py
 execnb/shell.py
 execnb.egg-info/PKG-INFO

{execnb-0.1.6 → execnb-0.1.7}/execnb.egg-info/requires.txt

@@ -1,5 +1,6 @@
 fastcore>=1.5.5
 ipython
+mistletoe
 
 [dev]
 matplotlib

execnb-0.1.7/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=64.0"]
+build-backend = "setuptools.build_meta"

{execnb-0.1.6 → execnb-0.1.7}/settings.ini

@@ -9,9 +9,9 @@ user = fastai
 author = Jeremy Howard
 author_email = j@fast.ai
 branch = master
-version = 0.1.6
+version = 0.1.7
 min_python = 3.7
-requirements = fastcore>=1.5.5 ipython
+requirements = fastcore>=1.5.5 ipython mistletoe
 dev_requirements = matplotlib Pillow
 console_scripts = exec_nb=execnb.shell:exec_nb
 audience = Developers
@@ -25,13 +25,13 @@ recursive = False
 tst_flags = notest
 doc_host = https://fastai.github.io
 doc_baseurl = /execnb/
-git_url = https://github.com/%(user)s/%(repo)s/
+git_url = https://github.com/fastai/execnb/
 lib_path = execnb
 title = execnb
 black_formatting = False
 readme_nb = index.ipynb
-allowed_metadata_keys =
-allowed_cell_metadata_keys =
+allowed_metadata_keys = 
+allowed_cell_metadata_keys = 
 conda_user = fastai
 preview_port = 3000
 preview_host = localhost
@@ -39,4 +39,6 @@ jupyter_hooks = True
 clean_ids = True
 clear_all = False
 put_version_in_init = True
+cell_number = False
+skip_procs = 
 

execnb-0.1.6/execnb/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.6"

execnb-0.1.6/execnb/fastshell.py

@@ -1,124 +0,0 @@
-# Copyright (c) IPython Development Team.
-# Modifications by Jeremy Howard
-# Distributed under the terms of the Modified BSD License.
-
-import os, sys, warnings
-from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
-from IPython.core.history import HistoryAccessorBase
-from IPython.core.autocall import ZMQExitAutocall
-from IPython.core.magic import magics_class, line_magic, Magics
-from IPython.utils.process import system
-from traitlets import Instance, Type, Any, default, observe
-
-@magics_class
-class KernelMagics(Magics):
-    @line_magic
-    def edit(self, parameter_s='', last_call=['','']): pass
-
-    @line_magic
-    def clear(self, arg_s): pass
-
-    @line_magic
-    def less(self, arg_s): pass
-
-    more = line_magic('more')(less)
-
-    # Man calls a pager, so we also need to redefine it
-    if os.name == 'posix':
-        @line_magic
-        def man(self, arg_s): pass
-
-    @line_magic
-    def autosave(self, arg_s): pass
-
-def noop(*args, **kwargs): return args
-
-class DummyHistory(HistoryAccessorBase):
-    def __init__(self, *args, **kw): self.enabled=False
-    def __getattr__(self, k): return noop
-    _log_validate = False
-
-class FastInteractiveShell(InteractiveShell):
-    data_pub_class = Any()
-    parent_header = Any()
-    exiter = Instance(ZMQExitAutocall)
-
-    def init_history(self): self.history_manager=DummyHistory()
-    def atexit_operations(self, *args, **kwargs): pass
-
-    @default('exiter')
-    def _default_exiter(self): return ZMQExitAutocall(self)
-
-    @observe('exit_now')
-    def _update_exit_now(self, change): pass
-
-    keepkernel_on_exit = None
-
-    def init_environment(self):
-        "Configure the user's environment."
-        env = os.environ
-        env['TERM'] = 'xterm-color'
-        env['CLICOLOR'] = '1'
-        env['PAGER'] = 'cat'
-        env['GIT_PAGER'] = 'cat'
-
-    def init_data_pub(self): pass
-
-    @property
-    def data_pub(self):
-        if not hasattr(self, '_data_pub'):
-            warnings.warn("InteractiveShell.data_pub is deprecated outside IPython parallel.", DeprecationWarning, stacklevel=2)
-            self._data_pub = self.data_pub_class(parent=self)
-            self._data_pub.session = self.display_pub.session
-            self._data_pub.pub_socket = self.display_pub.pub_socket
-        return self._data_pub
-
-    @data_pub.setter
-    def data_pub(self, pub): self._data_pub = pub
-
-    def ask_exit(self):
-        "Engage the exit actions."
-        self.exit_now = (not self.keepkernel_on_exit)
-        payload = dict( source='ask_exit', keepkernel=self.keepkernel_on_exit,)
-        self.payload_manager.write_payload(payload)
-
-    def set_next_input(self, text, replace=False):
-        "Send the specified text to the frontend to be presented at the next input cell."
-        payload = dict( source='set_next_input', text=text, replace=replace,)
-        self.payload_manager.write_payload(payload)
-
-    def set_parent(self, parent):
-        "Set the parent header for associating output with its triggering input"
-        self.parent_header = parent
-        self.displayhook.set_parent(parent)
-        self.display_pub.set_parent(parent)
-        if hasattr(self, '_data_pub'): self.data_pub.set_parent(parent)
-        try: sys.stdout.set_parent(parent)
-        except AttributeError: pass
-        try: sys.stderr.set_parent(parent)
-        except AttributeError: pass
-
-    def get_parent(self): return self.parent_header
-
-    def init_magics(self):
-        super().init_magics()
-        self.register_magics(KernelMagics)
-        self.magics_manager.register_alias('ed', 'edit')
-
-    def init_virtualenv(self): pass
-
-    def system_piped(self, cmd):
-        "Call the given cmd in a subprocess, piping stdout/err "
-        if cmd.rstrip().endswith('&'): raise OSError("Background processes not supported.")
-        if sys.platform == 'win32':
-            cmd = self.var_expand(cmd, depth=1)
-            from IPython.utils._process_win32 import AvoidUNCPath
-            with AvoidUNCPath() as path:
-                if path is not None: cmd = 'pushd %s &&%s' % (path, cmd)
-                self.user_ns['_exit_code'] = system(cmd)
-        else: self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=1))
-
-    system = system_piped
-
-InteractiveShellABC.register(FastInteractiveShell)
-

execnb-0.1.6/execnb/shell.py

@@ -1,248 +0,0 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/02_shell.ipynb.
-
-# %% ../nbs/02_shell.ipynb 2
-from __future__ import annotations
-
-import os
-os.environ['MPLBACKEND'] = 'module://matplotlib_inline.backend_inline'
-
-from fastcore.imports import *
-from fastcore.basics import *
-from fastcore.script import call_parse
-
-import multiprocessing
-try:
-    if sys.platform == 'darwin': multiprocessing.set_start_method("fork")
-except RuntimeError: pass # if re-running cell
-
-import tokenize
-from IPython.core.interactiveshell import InteractiveShell
-from IPython.core.displayhook import DisplayHook
-from IPython.core.displaypub import DisplayPublisher
-from base64 import b64encode
-from io import StringIO
-
-from .fastshell import FastInteractiveShell
-from .nbio import *
-from .nbio import _dict2obj
-
-from collections.abc import Callable
-
-# %% auto 0
-__all__ = ['CaptureShell', 'find_output', 'out_exec', 'out_stream', 'out_error', 'exec_nb']
-
-# %% ../nbs/02_shell.ipynb 4
-# IPython requires a DisplayHook and DisplayPublisher
-# We override `__call__` and `publish` to save outputs instead of printing them
-class _CaptureHook(DisplayHook):
-    "Called when displaying a result"
-
-    def quiet(self):
-        "Should we silence because of ';'?"
-        sio = StringIO(self.shell._code)
-        tokens = list(tokenize.generate_tokens(sio.readline))
-        for t in reversed(tokens):
-            if t.type in (tokenize.ENDMARKER, tokenize.NL, tokenize.NEWLINE, tokenize.COMMENT): continue
-            return t.type == tokenize.OP and t.string == ';'
-
-    def __call__(self, result=None):
-        if result is None or self.quiet(): return
-        self.fill_exec_result(result)
-        self.shell._result(result)
-
-class _CapturePub(DisplayPublisher):
-    "Called when adding an output"
-    def publish(self, data, metadata=None, **kwargs): self.shell._add_out(data, metadata, typ='display_data')
-
-# %% ../nbs/02_shell.ipynb 5
-# These are the standard notebook formats for exception and stream data (e.g stdout)
-def _out_exc(ename, evalue, traceback): return dict(ename=str(ename), evalue=str(evalue), output_type='error', traceback=traceback)
-def _out_stream(text, name): return dict(name=name, output_type='stream', text=text.splitlines(True))
-
-# %% ../nbs/02_shell.ipynb 6
-def _format_mimedata(k, v):
-    "Format mime-type keyed data consistently with Jupyter"
-    if k.startswith('text/'): return v.splitlines(True)
-    if k.startswith('image/') and isinstance(v, bytes):
-        v = b64encode(v).decode()
-        return v+'\n' if not v.endswith('\n') else v
-    return v
-
-# %% ../nbs/02_shell.ipynb 8
-class CaptureShell(FastInteractiveShell):
-    "Execute the IPython/Jupyter source code"
-    def __init__(self,
-                 path:str|Path=None): # Add `path` to python path
-        super().__init__(displayhook_class=_CaptureHook, display_pub_class=_CapturePub)
-        InteractiveShell._instance = self
-        self.out,self.count = [],1
-        self.exc = self.result = self._fname = self._cell_idx = self._stdout = self._stderr = None
-        if IN_NOTEBOOK:
-            try: self.enable_matplotlib('inline')
-            except ModuleNotFoundError: pass
-        if path: self.set_path(path)
-
-    def enable_matplotlib(self, gui=None):
-        "Enable `matplotlib` in a nested shell"
-        from matplotlib_inline.backend_inline import configure_inline_support
-        configure_inline_support.current_backend = 'unset'
-        return super().enable_matplotlib(gui)
-    
-    def set_path(self, path):
-        "Add `path` to python path, or `path.parent` if it's a file"
-        path = Path(path)
-        if path.is_file(): path = path.parent
-        self.run_cell(f"import sys; sys.path.insert(0, '{path.as_posix()}')")
-
-    def enable_gui(self, gui=None):
-        "Disable GUI (over-ridden; called by IPython)"
-        pass
-    
-    def _showtraceback(self, etype, evalue, stb: str):
-        self.out.append(_out_exc(etype, evalue, stb))
-        self.exc = (etype, evalue, '\n'.join(stb))
-
-    def _add_out(self, data, meta, typ='execute_result', **kwargs):
-        self._stream()
-        fd = {k:_format_mimedata(k,v) for k,v in data.items()}
-        self.out.append(dict(data=fd, metadata=meta, output_type=typ, **kwargs))
-
-    def _add_exec(self, result, meta, typ='execute_result'):
-        self._add_out(result, meta, execution_count=self.count)
-        self.count += 1
-
-    def _result(self, result):
-        self.result = result
-        self._add_exec(*self.display_formatter.format(result))
-
-    def _stream(self):
-        for nm in ('stdout','stderr'):
-            attr = '_'+nm
-            std = getattr(self, attr)
-            if std is not None:
-                text = std.getvalue()
-                if text:
-                    self.out.append(_out_stream(text, nm))
-                    setattr(self, attr, StringIO())
-
-# %% ../nbs/02_shell.ipynb 11
-@patch
-def run(self:CaptureShell,
-        code:str, # Python/IPython code to run
-        stdout=True, # Capture stdout and save as output?
-        stderr=True): # Capture stderr and save as output?
-    "Run `code`, returning a list of all outputs in Jupyter notebook format"
-    self._code = code
-    self.exc = False
-    self.out.clear()
-    sys_stdout,sys_stderr = sys.stdout,sys.stderr
-    if stdout: self._stdout = sys.stdout = StringIO()
-    if stderr: self._stderr = sys.stderr = StringIO()
-    try: self.run_cell(code)
-    finally: sys.stdout,sys.stderr = sys_stdout,sys_stderr
-    self._stream()
-    return [*self.out]
-
-# %% ../nbs/02_shell.ipynb 24
-@patch
-def cell(self:CaptureShell, cell, stdout=True, stderr=True):
-    "Run `cell`, skipping if not code, and store outputs back in cell"
-    if cell.cell_type!='code': return
-    self._cell_idx = cell.idx_ + 1
-    outs = self.run(cell.source)
-    if outs:
-        cell.outputs = _dict2obj(outs)
-        for o in outs:
-            if 'execution_count' in o: cell['execution_count'] = o['execution_count']
-
-# %% ../nbs/02_shell.ipynb 27
-def find_output(outp, # Output from `run`
-                ot='execute_result' # Output_type to find
-               ):
-    "Find first output of type `ot` in `CaptureShell.run` output"
-    return first(o for o in outp if o['output_type']==ot)
-
-# %% ../nbs/02_shell.ipynb 30
-def out_exec(outp):
-    "Get data from execution result in `outp`."
-    out = find_output(outp)
-    if out: return '\n'.join(first(out['data'].values()))
-
-# %% ../nbs/02_shell.ipynb 32
-def out_stream(outp):
-    "Get text from stream in `outp`."
-    out = find_output(outp, 'stream')
-    if out: return ('\n'.join(out['text'])).strip()
-
-# %% ../nbs/02_shell.ipynb 34
-def out_error(outp):
-    "Get traceback from error in `outp`."
-    out = find_output(outp, 'error')
-    if out: return '\n'.join(out['traceback'])
-
-# %% ../nbs/02_shell.ipynb 37
-def _false(o): return False
-
-@patch
-def run_all(self:CaptureShell,
-            nb, # A notebook read with `nbclient` or `read_nb`
-            exc_stop:bool=False, # Stop on exceptions?
-            preproc:Callable=_false, # Called before each cell is executed
-            postproc:Callable=_false, # Called after each cell is executed
-            inject_code:str|None=None, # Code to inject into a cell
-            inject_idx:int=0 # Cell to replace with `inject_code`
-           ):
-    "Run all cells in `nb`, stopping at first exception if `exc_stop`"
-    if inject_code is not None: nb.cells[inject_idx].source = inject_code
-    for cell in nb.cells:
-        if not preproc(cell):
-            self.cell(cell)
-            postproc(cell)
-        if self.exc and exc_stop: raise self.exc[1] from None
-
-# %% ../nbs/02_shell.ipynb 51
-@patch
-def execute(self:CaptureShell,
-            src:str|Path, # Notebook path to read from
-            dest:str|None=None, # Notebook path to write to
-            exc_stop:bool=False, # Stop on exceptions?
-            preproc:Callable=_false, # Called before each cell is executed
-            postproc:Callable=_false, # Called after each cell is executed
-            inject_code:str|None=None, # Code to inject into a cell
-            inject_path:str|Path|None=None, # Path to file containing code to inject into a cell
-            inject_idx:int=0 # Cell to replace with `inject_code`
-):
-    "Execute notebook from `src` and save with outputs to `dest"
-    nb = read_nb(src)
-    self._fname = src
-    self.set_path(Path(src).parent.resolve())
-    if inject_path is not None: inject_code = Path(inject_path).read_text()
-    self.run_all(nb, exc_stop=exc_stop, preproc=preproc, postproc=postproc,
-                 inject_code=inject_code, inject_idx=inject_idx)
-    if dest: write_nb(nb, dest)
-
-# %% ../nbs/02_shell.ipynb 55
-@patch
-def prettytb(self:CaptureShell, 
-             fname:str|Path=None): # filename to print alongside the traceback
-    "Show a pretty traceback for notebooks, optionally printing `fname`."
-    fname = fname if fname else self._fname
-    _fence = '='*75
-    cell_intro_str = f"While Executing Cell #{self._cell_idx}:" if self._cell_idx else "While Executing:"
-    cell_str = f"\n{cell_intro_str}\n{self.exc[-1]}"
-    fname_str = f' in {fname}' if fname else ''
-    return f"{type(self.exc[1]).__name__}{fname_str}:\n{_fence}\n{cell_str}\n"
-
-# %% ../nbs/02_shell.ipynb 74
-@call_parse
-def exec_nb(
-    src:str, # Notebook path to read from
-    dest:str='', # Notebook path to write to
-    exc_stop:bool=False, # Stop on exceptions?
-    inject_code:str=None, # Code to inject into a cell
-    inject_path:str=None, # Path to file containing code to inject into a cell
-    inject_idx:int=0 # Cell to replace with `inject_code`
-):
-    "Execute notebook from `src` and save with outputs to `dest`"
-    CaptureShell().execute(src, dest, exc_stop=exc_stop, inject_code=inject_code,
-                           inject_path=inject_path, inject_idx=inject_idx)