execnb 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

execnb/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.5"
+__version__ = "0.1.7"

execnb/_modidx.py

@@ -3,10 +3,9 @@
 d = { 'settings': { 'branch': 'master',
                 'doc_baseurl': '/execnb/',
                 'doc_host': 'https://fastai.github.io',
-                'git_url': 'https://github.com/fastai/execnb/tree/master/',
+                '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,27 +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.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.render_outputs': ('shell.html#render_outputs', 'execnb/shell.py')}}}

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)
@@ -28,7 +30,7 @@ class NbCell(AttrDict):
 
     def parsed_(self):
         if self.cell_type!='code' or self.source.strip()[:1] in ['%', '!']: return
-        if '_parsed_' not in self: 
+        if '_parsed_' not in self:
             try: self._parsed_ = ast.parse(self.source).body
             # you can assign the result of ! to a variable in a notebook cell
             # which will result in a syntax error if parsed with the ast module.
@@ -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,28 +53,31 @@ 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
     "Create an `NbCell` containing `text`"
     assert cell_type in {'code', 'markdown', 'raw'}
     if 'metadata' not in kwargs: kwargs['metadata']={}
+    if cell_type == 'code':
+        kwargs['outputs']=[]
+        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)
@@ -80,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/shell.py

@@ -1,65 +1,106 @@
+"""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
 
-import os
-os.environ['MPLBACKEND'] = 'module://matplotlib_inline.backend_inline'
-
-from fastcore.imports import *
-from fastcore.basics import *
+from fastcore.utils import *
 from fastcore.script import call_parse
+from fastcore.ansi import ansi2html
 
-import multiprocessing
+import mistletoe,multiprocessing,types,traceback,signal
 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.interactiveshell import InteractiveShell, ExecutionInfo, ExecutionResult
 from IPython.core.displayhook import DisplayHook
-from IPython.core.displaypub import DisplayPublisher
+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 io import StringIO
+from html import escape
+try: from matplotlib_inline.backend_inline import set_matplotlib_formats
+except ImportError: set_matplotlib_formats = None
+
 
-from .fastshell import FastInteractiveShell
 from .nbio import *
 from .nbio import _dict2obj
 
-from collections.abc import Callable
-
 # %% auto 0
-__all__ = ['CaptureShell', '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)
+__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))
 
-# %% ../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)
@@ -68,82 +109,56 @@ def _format_mimedata(k, v):
         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 _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 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 _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
 
-    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
+# %% ../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"
-    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
+    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"
@@ -155,15 +170,40 @@ def cell(self:CaptureShell, cell, stdout=True, stderr=True):
         for o in outs:
             if 'execution_count' in o: cell['execution_count'] = o['execution_count']
 
-# %% ../nbs/02_shell.ipynb 28
+# %% ../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
+            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`
            ):
@@ -173,16 +213,16 @@ def run_all(self:CaptureShell,
         if not preproc(cell):
             self.cell(cell)
             postproc(cell)
-        if self.exc and exc_stop: raise self.exc[1] from None
+        if self.exc and exc_stop: raise self.exc from None
 
-# %% ../nbs/02_shell.ipynb 42
+# %% ../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
+            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`
@@ -196,7 +236,7 @@ def execute(self:CaptureShell,
                  inject_code=inject_code, inject_idx=inject_idx)
     if dest: write_nb(nb, dest)
 
-# %% ../nbs/02_shell.ipynb 46
+# %% ../nbs/02_shell.ipynb
 @patch
 def prettytb(self:CaptureShell, 
              fname:str|Path=None): # filename to print alongside the traceback
@@ -204,11 +244,11 @@ def prettytb(self:CaptureShell,
     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]}"
+    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[1]).__name__}{fname_str}:\n{_fence}\n{cell_str}\n"
+    return f"{type(self.exc).__name__}{fname_str}:\n{_fence}\n{cell_str}\n"
 
-# %% ../nbs/02_shell.ipynb 65
+# %% ../nbs/02_shell.ipynb
 @call_parse
 def exec_nb(
     src:str, # Notebook path to read from
@@ -221,3 +261,29 @@ def exec_nb(
     "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.5.dist-info → execnb-0.1.7.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: execnb
-Version: 0.1.5
+Version: 0.1.7
 Summary: A description of your project
-Home-page: https://github.com/fastai/execnb/tree/master/
+Home-page: https://github.com/fastai/execnb/
 Author: Jeremy Howard
 Author-email: j@fast.ai
 License: Apache Software License 2.0
@@ -16,14 +16,15 @@ Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastcore (>=1.5.5)
+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
-================
+# execnb
+
 
 <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
 

execnb-0.1.7.dist-info/RECORD

@@ -0,0 +1,10 @@
+execnb/__init__.py,sha256=YpKDcdV7CqL8n45u267wKtyloM13FSVbOdrqgNZnSLM,22
+execnb/_modidx.py,sha256=3wJwFT95tiaCPmj7VMQEIim5qLTcOatC2od-ze5WJcc,5771
+execnb/nbio.py,sha256=gs3EGN0sP2j47XUH31rTn2KT57b3wWnBZsn9AoZm2JQ,3677
+execnb/shell.py,sha256=4wuuyphJ0M0NCvjQ2RbJlstDHUXFmnWNJExRdveiLew,11958
+execnb-0.1.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+execnb-0.1.7.dist-info/METADATA,sha256=BqAfeem0tFfd_BxveYlY1_kxWuW35KGZc4AHAaSOSSw,3275
+execnb-0.1.7.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+execnb-0.1.7.dist-info/entry_points.txt,sha256=jZ8LPZCqnu4hXN_AgQpm05hVnTE-C25YK_4aiVX4i78,84
+execnb-0.1.7.dist-info/top_level.txt,sha256=VGWmzsw8FOlT1r5TdOxaTWIAyRdclcxNdJ2r1hojf5U,7
+execnb-0.1.7.dist-info/RECORD,,

{execnb-0.1.5.dist-info → execnb-0.1.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-execnb/__init__.py,sha256=rPSfWgIeq2YWVPyESOAwCBt8vftsTpIkuLAGDEzyRQc,22
-execnb/_modidx.py,sha256=gpQj6i1HkFABwB73tBR5iaLqNDZNUY3wilOxlO7P5FQ,4833
-execnb/fastshell.py,sha256=ODng8r7-b74lRiCR2nENHuIMubxnkfArh0Su2VMHMSs,4285
-execnb/nbio.py,sha256=9k15675BTHIWDNVbbN_B93g6pCDECBDX4g7HgxHvyys,3568
-execnb/shell.py,sha256=se6sLSEql-zTbHWOH0P_fQ8Qg1WJCEv4s2HCfoaaOfE,8911
-execnb-0.1.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-execnb-0.1.5.dist-info/METADATA,sha256=t5lJC6cUeocujmRxcvQ0nSnMUo4L3VJ8IfbB6lsyfxc,3278
-execnb-0.1.5.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-execnb-0.1.5.dist-info/entry_points.txt,sha256=jZ8LPZCqnu4hXN_AgQpm05hVnTE-C25YK_4aiVX4i78,84
-execnb-0.1.5.dist-info/top_level.txt,sha256=VGWmzsw8FOlT1r5TdOxaTWIAyRdclcxNdJ2r1hojf5U,7
-execnb-0.1.5.dist-info/RECORD,,