nbdev 3.2.2__tar.gz → 3.3.0__tar.gz

{nbdev-3.2.2/nbdev.egg-info → nbdev-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdev
-Version: 3.2.2
+Version: 3.3.0
 Summary: Create delightful software with Jupyter Notebooks
 Author-email: "Jeremy Howard and the fast.ai community" <j@fast.ai>
 License: Apache-2.0
@@ -13,13 +13,13 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastcore>=1.14.6
-Requires-Dist: execnb>=0.2.4
+Requires-Dist: fastcore>=2.1.3
+Requires-Dist: execnb>=0.2.8
 Requires-Dist: astunparse
-Requires-Dist: ghapi>=2.0.0
+Requires-Dist: ghapi>=2.0.2
 Requires-Dist: watchdog
 Requires-Dist: asttokens
 Requires-Dist: setuptools

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.2.2"
+__version__ = "3.3.0"
 
 from .doclinks import nbdev_export
 from .showdoc import show_doc

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/_modidx.py

@@ -5,14 +5,23 @@ d = { 'settings': { 'branch': 'main',
                 'doc_host': 'https://nbdev.fast.ai',
                 'git_url': 'https://github.com/AnswerDotAI/nbdev',
                 'lib_path': 'nbdev'},
-  'syms': { 'nbdev.clean': { 'nbdev.clean._add_jupyter_hooks': ('api/clean.html#_add_jupyter_hooks', 'nbdev/clean.py'),
+  'syms': { 'nbdev.clean': { 'nbdev.clean._add_attrs': ('api/clean.html#_add_attrs', 'nbdev/clean.py'),
+                             'nbdev.clean._add_jupyter_hooks': ('api/clean.html#_add_jupyter_hooks', 'nbdev/clean.py'),
+                             'nbdev.clean._canon_dirs': ('api/clean.html#_canon_dirs', 'nbdev/clean.py'),
+                             'nbdev.clean._cfg_drivers': ('api/clean.html#_cfg_drivers', 'nbdev/clean.py'),
                              'nbdev.clean._clean_cell': ('api/clean.html#_clean_cell', 'nbdev/clean.py'),
                              'nbdev.clean._clean_cell_output': ('api/clean.html#_clean_cell_output', 'nbdev/clean.py'),
                              'nbdev.clean._clean_cell_output_id': ('api/clean.html#_clean_cell_output_id', 'nbdev/clean.py'),
+                             'nbdev.clean._cmt_dirs': ('api/clean.html#_cmt_dirs', 'nbdev/clean.py'),
+                             'nbdev.clean._dir_moves': ('api/clean.html#_dir_moves', 'nbdev/clean.py'),
                              'nbdev.clean._git_root': ('api/clean.html#_git_root', 'nbdev/clean.py'),
+                             'nbdev.clean._hoist_nb_meta': ('api/clean.html#_hoist_nb_meta', 'nbdev/clean.py'),
                              'nbdev.clean._nbdev_clean': ('api/clean.html#_nbdev_clean', 'nbdev/clean.py'),
                              'nbdev.clean._reconfigure': ('api/clean.html#_reconfigure', 'nbdev/clean.py'),
+                             'nbdev.clean._rm_dir_lines': ('api/clean.html#_rm_dir_lines', 'nbdev/clean.py'),
                              'nbdev.clean._skip_or_sub': ('api/clean.html#_skip_or_sub', 'nbdev/clean.py'),
+                             'nbdev.clean._to_comments': ('api/clean.html#_to_comments', 'nbdev/clean.py'),
+                             'nbdev.clean._to_meta': ('api/clean.html#_to_meta', 'nbdev/clean.py'),
                              'nbdev.clean.clean_jupyter': ('api/clean.html#clean_jupyter', 'nbdev/clean.py'),
                              'nbdev.clean.clean_nb': ('api/clean.html#clean_nb', 'nbdev/clean.py'),
                              'nbdev.clean.nbdev_clean': ('api/clean.html#nbdev_clean', 'nbdev/clean.py'),
@@ -61,11 +70,20 @@ d = { 'settings': { 'branch': 'main',
                               'nbdev.config.update_version': ('api/config.html#update_version', 'nbdev/config.py'),
                               'nbdev.config.write_cells': ('api/config.html#write_cells', 'nbdev/config.py')},
             'nbdev.diff': { 'nbdev.diff._cell_changes': ('api/diff.html#_cell_changes', 'nbdev/diff.py'),
+                            'nbdev.diff._diff_order': ('api/diff.html#_diff_order', 'nbdev/diff.py'),
+                            'nbdev.diff._dline': ('api/diff.html#_dline', 'nbdev/diff.py'),
+                            'nbdev.diff._file_srcs': ('api/diff.html#_file_srcs', 'nbdev/diff.py'),
                             'nbdev.diff._nb_srcdict': ('api/diff.html#_nb_srcdict', 'nbdev/diff.py'),
+                            'nbdev.diff._src': ('api/diff.html#_src', 'nbdev/diff.py'),
+                            'nbdev.diff._srcdict': ('api/diff.html#_srcdict', 'nbdev/diff.py'),
                             'nbdev.diff.cell_diffs': ('api/diff.html#cell_diffs', 'nbdev/diff.py'),
                             'nbdev.diff.changed_cells': ('api/diff.html#changed_cells', 'nbdev/diff.py'),
+                            'nbdev.diff.nb_diff': ('api/diff.html#nb_diff', 'nbdev/diff.py'),
+                            'nbdev.diff.nbdev_diff': ('api/diff.html#nbdev_diff', 'nbdev/diff.py'),
+                            'nbdev.diff.nbdev_diff_driver': ('api/diff.html#nbdev_diff_driver', 'nbdev/diff.py'),
                             'nbdev.diff.nbs_pair': ('api/diff.html#nbs_pair', 'nbdev/diff.py'),
                             'nbdev.diff.read_nb_from_git': ('api/diff.html#read_nb_from_git', 'nbdev/diff.py'),
+                            'nbdev.diff.render_diff': ('api/diff.html#render_diff', 'nbdev/diff.py'),
                             'nbdev.diff.source_diff': ('api/diff.html#source_diff', 'nbdev/diff.py')},
             'nbdev.doclinks': { 'nbdev.doclinks.NbdevLookup': ('api/doclinks.html#nbdevlookup', 'nbdev/doclinks.py'),
                                 'nbdev.doclinks.NbdevLookup.__getitem__': ( 'api/doclinks.html#nbdevlookup.__getitem__',
@@ -193,17 +211,9 @@ d = { 'settings': { 'branch': 'main',
                                'nbdev.process.Processor.__call__': ('api/process.html#processor.__call__', 'nbdev/process.py'),
                                'nbdev.process.Processor.__init__': ('api/process.html#processor.__init__', 'nbdev/process.py'),
                                'nbdev.process.Processor.cell': ('api/process.html#processor.cell', 'nbdev/process.py'),
-                               'nbdev.process._dir_pre': ('api/process.html#_dir_pre', 'nbdev/process.py'),
-                               'nbdev.process._directive': ('api/process.html#_directive', 'nbdev/process.py'),
                                'nbdev.process._is_direc': ('api/process.html#_is_direc', 'nbdev/process.py'),
                                'nbdev.process._mk_procs': ('api/process.html#_mk_procs', 'nbdev/process.py'),
-                               'nbdev.process._norm_quarto': ('api/process.html#_norm_quarto', 'nbdev/process.py'),
-                               'nbdev.process._partition_cell': ('api/process.html#_partition_cell', 'nbdev/process.py'),
-                               'nbdev.process._quarto_re': ('api/process.html#_quarto_re', 'nbdev/process.py'),
-                               'nbdev.process.extract_directives': ('api/process.html#extract_directives', 'nbdev/process.py'),
-                               'nbdev.process.first_code_ln': ('api/process.html#first_code_ln', 'nbdev/process.py'),
                                'nbdev.process.instantiate': ('api/process.html#instantiate', 'nbdev/process.py'),
-                               'nbdev.process.nb_lang': ('api/process.html#nb_lang', 'nbdev/process.py'),
                                'nbdev.process.opt_set': ('api/process.html#opt_set', 'nbdev/process.py')},
             'nbdev.processors': { 'nbdev.processors.FilterDefaults': ('api/processors.html#filterdefaults', 'nbdev/processors.py'),
                                   'nbdev.processors.FilterDefaults.__call__': ( 'api/processors.html#filterdefaults.__call__',
@@ -357,6 +367,7 @@ d = { 'settings': { 'branch': 'main',
                                'nbdev.showdoc.doc': ('api/showdoc.html#doc', 'nbdev/showdoc.py'),
                                'nbdev.showdoc.show_doc': ('api/showdoc.html#show_doc', 'nbdev/showdoc.py'),
                                'nbdev.showdoc.showdoc_nm': ('api/showdoc.html#showdoc_nm', 'nbdev/showdoc.py')},
+            'nbdev.skill': {},
             'nbdev.sync': { 'nbdev.sync._mod_files': ('api/sync.html#_mod_files', 'nbdev/sync.py'),
                             'nbdev.sync._to_absolute': ('api/sync.html#_to_absolute', 'nbdev/sync.py'),
                             'nbdev.sync._update_mod': ('api/sync.html#_update_mod', 'nbdev/sync.py'),

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/clean.py

@@ -13,6 +13,7 @@ from astunparse import unparse
 from textwrap import indent
 
 from fastcore.nbio import *
+from fastcore.nbio import _directive, _dir_line, _meta_directives, _unparse_dir
 from fastcore.script import *
 from fastcore.utils import *
 from fastcore.xtras import *
@@ -93,11 +94,13 @@ def clean_nb(
     allowed_cell_metadata_keys:list=None, # Preserve the list of keys in cell level metadata
     clean_ids=True, # Remove ids from plaintext reprs?
     allowed_out_metadata_keys:list=None, # Preserve the list of keys in output metadata
+    repair:bool=True, # Fix structural problems first (see `repair_nb`)?
 ):
     "Clean `nb` from superfluous metadata"
-    metadata_keys = {"kernelspec", "jekyll", "jupytext", "doc", "widgets"}
+    if repair: repair_nb(nb)
+    metadata_keys = {"kernelspec", "jekyll", "jupytext", "doc", "widgets", "nbdev"}
     if allowed_metadata_keys: metadata_keys.update(allowed_metadata_keys)
-    cell_metadata_keys = {"hide_input"}
+    cell_metadata_keys = {"hide_input", "nbdev"}
     if allowed_cell_metadata_keys: cell_metadata_keys.update(allowed_cell_metadata_keys)
     out_meta_keys = set()
     if allowed_out_metadata_keys: out_meta_keys.update(allowed_out_metadata_keys)
@@ -126,14 +129,73 @@ def process_write(warn_msg, proc_nb, f_in, f_out=None, disp=False):
         warn(f'{warn_msg}')
         warn(e)
 
+# %% ../nbs/api/11_clean.ipynb #f6e854ac
+def _cmt_dirs(cell):
+    "Comment directives in `cell` as `{name: value}`, plus the partitioned `(dirs,code)` lines"
+    dirs,code = cell._partition()
+    return dict(t for t in (_directive(s, cell.lang_) for s in dirs) if t),dirs,code
+
+def _rm_dir_lines(cell, dirs, code, names):
+    "Rewrite `cell` source without the directive lines in `names`"
+    cell.set_source(''.join([o for o in dirs if (t:=_directive(o, cell.lang_)) is None or t[0] not in names] + code))
+
+def _to_meta(cell, names):
+    "Move comment directives in `names` to the cell's `nbdev` metadata key"
+    cmts,dirs,code = _cmt_dirs(cell)
+    move = {k:v for k,v in cmts.items() if k in names}
+    if not move: return
+    cell.setdefault('metadata',{}).setdefault('nbdev',{}).update({k:_unparse_dir(v) for k,v in move.items()})
+    _rm_dir_lines(cell, dirs, code, move)
+
+def _to_comments(cell, names):
+    "Move directives in `names` from the cell's `nbdev` metadata key to comments"
+    move = {k:v for k,v in _meta_directives(cell).items() if k in names}
+    if not move: return
+    nbd = cell.metadata['nbdev']
+    for k in move: nbd.pop(k, None)
+    if not nbd: del cell.metadata['nbdev']
+    dirs,code = cell._partition()
+    cell.set_source(''.join(dirs + [_dir_line(k, v, cell.lang_) for k,v in move.items()] + code))
+
+# %% ../nbs/api/11_clean.ipynb #6e8d013d
+def _canon_dirs(cell):
+    "Rewrite `cell`'s comment directives in canonical form (colon-separated, bare for true)"
+    dirs,code = cell._partition()
+    new = [o if (t:=_directive(o, cell.lang_)) is None else _dir_line(*t, lang=cell.lang_) for o in dirs]
+    if new != dirs: cell.set_source(''.join(new + code))
+
+def _hoist_nb_meta(nb, names=('default_exp',)):
+    "Move notebook-scope directives in `names` to notebook metadata, dropping any cell left empty"
+    for c in list(nb.cells):
+        cmts,dirs,code = _cmt_dirs(c)
+        move = {k:v for k,v in cmts.items() if k in names}
+        if not move: continue
+        nb.setdefault('metadata',{}).setdefault('nbdev',{}).update({k:_unparse_dir(v) for k,v in move.items()})
+        _rm_dir_lines(c, dirs, code, move)
+        left = set(c.directives) - {'hide'}
+        if not left and not ''.join(c._partition()[1]).strip(): nb.cells.remove(c)
+
+def _dir_moves(nb, dirs=False, to_meta=None, to_comments=None, nb_meta=False):
+    "Apply directive migrations to loaded notebook dict `nb` in place"
+    nbo = dict2nb(nb)
+    if to_meta:
+        for c in nbo.cells: _to_meta(c, to_meta.split())
+    if to_comments:
+        for c in nbo.cells: _to_comments(c, to_comments.split())
+    if nb_meta: _hoist_nb_meta(nbo)
+    if dirs:
+        for c in nbo.cells: _canon_dirs(c)
+    nb['cells'],nb['metadata'] = nbo.cells,nbo.metadata
+
 # %% ../nbs/api/11_clean.ipynb #714357ce
-def _nbdev_clean(nb, path=None, clear_all=None):
+def _nbdev_clean(nb, path=None, clear_all=None, repair=True, dirs=False, to_meta=None, to_comments=None, nb_meta=False):
     cfg = get_config(path=path)
     clear_all = clear_all or cfg.clear_all
     allowed_metadata_keys = cfg.get("allowed_metadata_keys") or []
     allowed_cell_metadata_keys = cfg.get("allowed_cell_metadata_keys") or []
     allowed_out_metadata_keys = cfg.get("allowed_out_metadata_keys") or []
-    clean_nb(nb, clear_all, allowed_metadata_keys, allowed_cell_metadata_keys, cfg.clean_ids, allowed_out_metadata_keys)
+    if dirs or to_meta or to_comments or nb_meta: _dir_moves(nb, dirs, to_meta, to_comments, nb_meta)
+    clean_nb(nb, clear_all, allowed_metadata_keys, allowed_cell_metadata_keys, cfg.clean_ids, allowed_out_metadata_keys, repair=repair)
     if path: nbdev_trust.__wrapped__(path)
 
 # %% ../nbs/api/11_clean.ipynb #6af3b9d4
@@ -142,11 +204,16 @@ def nbdev_clean(
     fname:str=None, # A notebook name or glob to clean
     clear_all:bool=False, # Remove all cell metadata and cell outputs?
     disp:bool=False,  # Print the cleaned outputs
-    stdin:bool=False # Read notebook from input stream
+    stdin:bool=False, # Read notebook from input stream
+    repair:bool_arg=True, # Fix structural problems, e.g. stray outputs on non-code cells (see `repair_nb`)?
+    dirs:bool=False, # Rewrite comment directives in canonical form?
+    to_meta:str=None, # Space-separated directive names to move from comments to cell metadata
+    to_comments:str=None, # Space-separated directive names to move from cell metadata to comments
+    nb_meta:bool=False # Move `default_exp` into notebook metadata?
 ):
     "Clean all notebooks in `fname` to avoid merge conflicts"
     # Git hooks will pass the notebooks in stdin
-    _clean = partial(_nbdev_clean, clear_all=clear_all)
+    _clean = partial(_nbdev_clean, clear_all=clear_all, repair=repair, dirs=dirs, to_meta=to_meta, to_comments=to_comments, nb_meta=nb_meta)
     _write = partial(process_write, warn_msg='Failed to clean notebook', proc_nb=_clean)
     if stdin: return _write(f_in=sys.stdin, f_out=sys.stdout)
     if fname is None: fname = get_config().nbs_path
@@ -193,8 +260,29 @@ def _git_root():
     except OSError: return None
 
 # %% ../nbs/api/11_clean.ipynb #e6083614
+def _add_attrs(path, attrs):
+    "Append missing attribute lines to git attributes file at `path`"
+    txt = path.read_text() if path.exists() else ''
+    have = [l.split() for l in txt.splitlines()]  # whitespace-insensitive: nbdime writes its lines with tabs
+    for attr in attrs:
+        if attr.split() not in have:
+            if txt and not txt.endswith('\n'): txt+='\n'
+            txt += attr+'\n'
+    path.write_text(txt)
+
+def _cfg_drivers(loc, merge, diff):
+    "Define the `jupyternotebook` merge/diff drivers via `git config <loc>`"
+    if merge:
+        run(f'git config {loc} merge.jupyternotebook.name "resolve conflicts with nbdev_fix"')
+        run(f'git config {loc} merge.jupyternotebook.driver "nbdev-merge %O %A %B %P"')
+    if diff: run(f'git config {loc} diff.jupyternotebook.command nbdev-diff-driver')
+
 @call_parse
-def nbdev_install_hooks():
+def nbdev_install_hooks(
+    merge:bool_arg=True, # Install the notebook merge driver?
+    diff:bool_arg=True, # Install the notebook diff driver?
+    globally:bool_arg=False # Define the drivers in `~/.gitconfig` and the global attributes file, instead of repo files?
+):
     "Install Jupyter and git hooks to automatically clean, trust, and fix merge conflicts in notebooks"
     cfg_path = Path.home()/'.jupyter'
     cfg_path.mkdir(exist_ok=True)
@@ -204,6 +292,16 @@ def nbdev_install_hooks():
         upd = _add_jupyter_hooks(src, fn)
         if upd is not None: fn.write_text(upd)
 
+    nbdev_attrs = (['*.ipynb merge=jupyternotebook'] if merge else []) + (['*.ipynb diff=jupyternotebook'] if diff else [])
+    if globally:
+        _cfg_drivers('--global', merge, diff)
+        rc,p = run('git config --global --get core.attributesFile', ignore_ex=True)
+        if rc: p = os.environ.get('XDG_CONFIG_HOME', '~/.config') + '/git/attributes'
+        attrs_path = Path(p).expanduser()
+        attrs_path.parent.mkdir(parents=True, exist_ok=True)
+        _add_attrs(attrs_path, nbdev_attrs)
+        return print("Hooks are installed globally.")
+
     repo_path = _git_root()
     if repo_path is None:
         sys.stderr.write('Not in a git repository, git hooks cannot be installed.\n')
@@ -215,7 +313,8 @@ def nbdev_install_hooks():
     os.chmod(fn, os.stat(fn).st_mode | stat.S_IEXEC)
 
     cmd = 'git config --local include.path ../.gitconfig'
-    (repo_path/'.gitconfig').write_text(f'''# Generated by nbdev-install-hooks
+    cfg_fn = repo_path/'.gitconfig'
+    cfg_fn.write_text(f'''# Generated by nbdev-install-hooks
 #
 # If you need to disable this instrumentation do:
 #   git config --local --unset include.path
@@ -223,19 +322,10 @@ def nbdev_install_hooks():
 # To restore:
 #   {cmd}
 #
-[merge "nbdev-merge"]
-	name = resolve conflicts with nbdev_fix
-	driver = nbdev-merge %O %A %B %P
 ''')
+    _cfg_drivers(f'--file "{cfg_fn}"', merge, diff)
     run(cmd)
 
-    attrs_path = repo_path/'.gitattributes'
-    nbdev_attr = '*.ipynb merge=nbdev-merge\n'
-    try:
-        attrs = attrs_path.read_text()
-        if nbdev_attr not in attrs:
-            if not attrs.endswith('\n'): attrs+='\n'
-            attrs_path.write_text(attrs+nbdev_attr)
-    except FileNotFoundError: attrs_path.write_text(nbdev_attr)
+    _add_attrs(repo_path/'.gitattributes', nbdev_attrs)
 
     print("Hooks are installed.")

nbdev-3.3.0/nbdev/diff.py

@@ -0,0 +1,198 @@
+"""Cell-level git diffs for notebooks
+
+Docs: https://nbdev.fast.ai/api/diff.html.md"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/api/19_diff.ipynb.
+
+# %% auto #0
+__all__ = ['read_nb_from_git', 'nbs_pair', 'changed_cells', 'source_diff', 'cell_diffs', 'render_diff', 'nb_diff',
+           'nbdev_diff_driver', 'nbdev_diff']
+
+# %% ../nbs/api/19_diff.ipynb #10c8ad0b
+import json
+from fastcore.utils import *
+from fastcore.meta import delegates
+from fastcore.script import *
+from difflib import unified_diff
+from subprocess import CalledProcessError
+from typing import Annotated
+from fastgit import Git
+from fastcore.nbio import *
+from .doclinks import nbglob
+
+# %% ../nbs/api/19_diff.ipynb #a8981115
+def read_nb_from_git(
+    g:Git, # The git object
+    path, # The path to the notebook (absolute or relative to git root)
+    ref=None # The git ref to read from (e.g. HEAD); None for working dir
+)->AttrDict: # The notebook; empty if `path` doesn't exist at `ref`
+    "Read notebook from git ref (e.g. HEAD) at path, or working dir if ref is None"
+    path = Path(path)
+    if path.is_absolute(): path = path.relative_to(g.top())
+    if ref is None: return read_nb(g.top()/path)
+    try: raw = g.show(f'{ref}:{path}', raise_exc=True)
+    except CalledProcessError as e:
+        if " in '" not in str(e.stderr): raise
+        return new_nb([])
+    return dict2nb(json.loads(raw))
+
+# %% ../nbs/api/19_diff.ipynb #3ac25702
+def _src(c): return c.get('source','')
+
+def _srcdict(nb, f=noop):
+    "Dict of cell id->`f(cell)`, with positional fallback ids for pre-4.5 notebooks"
+    return {c.get('id', f'c{c.idx_}'): f(c) for c in nb.cells}
+
+def _nb_srcdict(g:Git, nb_path, ref=None, f=noop): return _srcdict(read_nb_from_git(g, nb_path, ref), f)
+
+# %% ../nbs/api/19_diff.ipynb #27ff9a7b
+def nbs_pair(
+    nb_path, # Path to the notebook
+    ref_a='HEAD', # First git ref (None for working dir)
+    ref_b=None, # Second git ref (None for working dir)
+    f=noop  # Function to call on contents
+): # Tuple of two notebooks
+    "NBs at two refs; None means working dir. By default provides HEAD and working dir"
+    nb_path = Path(nb_path).resolve()
+    g = Git(nb_path.parent)
+    return _nb_srcdict(g, nb_path, ref_a, f), _nb_srcdict(g, nb_path, ref_b, f)
+
+# %% ../nbs/api/19_diff.ipynb #958aeaf8
+def _cell_changes(
+    nb_path, # Path to the notebook
+    fn, # function to call to get dict values
+    ref_a='HEAD', # First git ref (None for working dir)
+    ref_b=None, # Second git ref (None for working dir)
+    adds=True, # Include cells in b but not in a
+    changes=True, # Include cells with different content
+    dels=False, # Include cells in a but not in b
+    metadata=False, # Consider cell metadata when comparing
+    outputs=False # Consider cell outputs when comparing
+): # Dict of results
+    "Apply fn(cell_id, old_content, new_content) to changed cells between two refs"
+    def cell_content(c):
+        res = c.get('source', '')
+        if metadata: res += '\n# metadata: ' + json.dumps(c.get('metadata', {}), sort_keys=True)
+        if outputs: res += '\n# outputs: ' + json.dumps(c.get('outputs', []), sort_keys=True)
+        return res
+    old,new = nbs_pair(nb_path, ref_a, ref_b, f=cell_content)
+    res = {}
+    if adds: res |= {cid: fn(cid, '', new[cid]) for cid in new if cid not in old}
+    if changes: res |= {cid: fn(cid, old[cid], new[cid]) for cid in new if cid in old and new[cid] != old[cid]}
+    if dels: res |= {cid: fn(cid, old[cid], '') for cid in old if cid not in new}
+    return res
+
+# %% ../nbs/api/19_diff.ipynb #6a723bc8
+@delegates(_cell_changes)
+def changed_cells(nb_path, **kwargs):
+    "Return set of cell IDs for changed/added/deleted cells between two refs"
+    def f(cid,o,n): return cid
+    return set(_cell_changes(nb_path, f, **kwargs).keys())
+
+# %% ../nbs/api/19_diff.ipynb #079eedb0
+def source_diff(
+    old_source, # Original source string
+    new_source # New source string
+): # Unified diff string
+    "Return unified diff string for source change"
+    return '\n'.join(unified_diff(old_source.splitlines(), new_source.splitlines(), lineterm=''))
+
+# %% ../nbs/api/19_diff.ipynb #38216afa
+@delegates(_cell_changes)
+def cell_diffs(nb_path, **kwargs):
+    "{cell_id:diff} for changed/added/deleted cells between two refs"
+    def f(cid,o,n): return source_diff(o,n)
+    return _cell_changes(nb_path, f, **kwargs)
+
+# %% ../nbs/api/19_diff.ipynb #d670e58e
+_dcolors = {'-':'\x1b[31m', '+':'\x1b[32m', '@':'\x1b[36m', '#':'\x1b[1m', '# ':'\x1b[1;7m'}
+
+def _dline(l, maxlen=120, color=False):
+    "Truncate `l` to `maxlen` with an ellipsis, optionally colored by its leading diff marker"
+    if maxlen and len(l)>maxlen: l = l[:maxlen]+'…'
+    c = (_dcolors.get(l[:2]) or _dcolors.get(l[:1])) if color else None
+    return f'{c}{l}\x1b[0m' if c else l
+
+# %% ../nbs/api/19_diff.ipynb #342fc231
+def _diff_order(old, new):
+    "All cell ids in notebook order: `new`'s order, with deleted ids after their predecessor in `old`"
+    res,olds = list(new),list(old)
+    for i,cid in enumerate(olds):
+        if cid in new: continue
+        pred = first(o for o in reversed(olds[:i]) if o in res)
+        res.insert(res.index(pred)+1 if pred else 0, cid)
+    return res
+
+# %% ../nbs/api/19_diff.ipynb #eb3fc128
+def render_diff(
+    old, # `{id: source}` for the old version of the notebook
+    new, # `{id: source}` for the new version
+    maxlen:int=120, # Truncate diff lines to this width (falsy: no limit)
+    color:bool=False # Add ANSI colors?
+): # One section per changed cell, in notebook order
+    "Render cell-level changes between two notebooks as truncated unified diffs"
+    res = []
+    for cid in _diff_order(old, new):
+        o,n = old.get(cid,''), new.get(cid,'')
+        if cid in old and cid in new and o==n: continue
+        kind = 'modified' if cid in old and cid in new else 'added' if cid in new else 'deleted'
+        lines = [f'## {kind} {cid}:'] + source_diff(o,n).splitlines()[2:]
+        res.append('\n'.join(_dline(l, maxlen, color) for l in lines))
+    return '\n\n'.join(res)
+
+# %% ../nbs/api/19_diff.ipynb #7f90d675
+def nb_diff(
+    nb_path, # Path to the notebook
+    ref_a='HEAD', # First git ref
+    ref_b=None, # Second git ref; None for working dir
+    maxlen:int=120, # Truncate diff lines to this width (falsy: no limit)
+    color:bool=False # Add ANSI colors?
+): # Rendered diff of changed cells
+    "Rendered cell diff for `nb_path` between two refs"
+    a,b = nbs_pair(nb_path, ref_a, ref_b, f=_src)
+    return render_diff(a, b, maxlen=maxlen, color=color)
+
+# %% ../nbs/api/19_diff.ipynb #ab9f0b26
+def _file_srcs(path):
+    "`{id: source}` from an ipynb file; `{}` when missing or empty (e.g. `/dev/null`)"
+    p = Path(path)
+    if not p.exists() or not p.stat().st_size: return {}
+    return _srcdict(read_nb(p), _src)
+
+_pos = Annotated[str, {'opt':False, 'nargs':'?'}]  # optional positional CLI arg, as git passes them
+
+@call_parse
+def nbdev_diff_driver(
+    path:str, # Repo path of the notebook being diffed
+    old_file:_pos=None, # Pre-change file (git temp file, or /dev/null)
+    old_hex:_pos=None, # Pre-change blob hash
+    old_mode:_pos=None, # Pre-change file mode
+    new_file:_pos=None, # Post-change file
+    new_hex:_pos=None, # Post-change blob hash
+    new_mode:_pos=None, # Post-change file mode
+    rename_to:_pos=None, # New repo path, when git detected a rename
+    similarity:_pos=None, # Similarity score, when git detected a rename
+    maxlen:int=120 # Truncate diff lines to this width (0 for no limit)
+):
+    "Git external diff driver for notebooks; installed by `nbdev-install-hooks`"
+    if not new_file: return print(f'unmerged: {path}')
+    color = sys.stdout.isatty() or os.environ.get('GIT_PAGER_IN_USE')=='true'
+    res = render_diff(_file_srcs(old_file), _file_srcs(new_file), maxlen=maxlen, color=color)
+    if not res: return
+    print(_dline(f'# {path}', 0, color))
+    print(res, end='\n\n')
+
+# %% ../nbs/api/19_diff.ipynb #2604c719
+@call_parse
+def nbdev_diff(
+    path:str=None, # Notebook or directory (default: project's notebooks folder)
+    ref_a:str='HEAD', # First git ref
+    ref_b:str=None, # Second git ref (default: working directory)
+    maxlen:int=120, # Truncate diff lines to this width (0 for no limit)
+    color:bool_arg=None # Add ANSI colors? (default: only if stdout is a tty)
+):
+    "Cell-level diffs for changed notebooks between two git refs"
+    if color is None: color = sys.stdout.isatty()
+    for p in sorted(nbglob(path)):
+        res = nb_diff(p, ref_a, ref_b, maxlen=maxlen, color=color)
+        if res: print(_dline(f'# {p}', 0, color), res, sep='\n', end='\n\n')

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/migrate.py

@@ -9,6 +9,7 @@ __all__ = ['MigrateProc', 'fp_md_fm', 'migrate_nb', 'migrate_md', 'nbdev_migrate
 
 # %% ../nbs/api/16_migrate.ipynb #5b687fa0-dc50-48df-8bfc-e98df34e7572
 from .process import *
+from fastcore.nbio import first_code_ln, langs
 from .frontmatter import *
 from .frontmatter import _fm2dict, _re_fm_md, _dict2fm, _insertfm
 from .processors import *

nbdev-3.3.0/nbdev/process.py

@@ -0,0 +1,88 @@
+"""A notebook processor
+
+Docs: https://nbdev.fast.ai/api/process.html.md"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/api/03_process.ipynb.
+
+# %% auto #0
+__all__ = ['opt_set', 'instantiate', 'NBProcessor', 'Processor']
+
+# %% ../nbs/api/03_process.ipynb #59172c3d
+from .config import *
+from .maker import *
+from .imports import *
+
+from fastcore.nbio import *
+from fastcore.nbio import _meta_directives
+from fastcore.script import *
+from fastcore.imports import *
+
+from collections import defaultdict
+
+# %% ../nbs/api/03_process.ipynb #e6701805
+def opt_set(var, newval):
+    "newval if newval else var"
+    return newval if newval else var
+
+# %% ../nbs/api/03_process.ipynb #98c9d556
+def instantiate(x, **kwargs):
+    "Instantiate `x` if it's a type"
+    return x(**kwargs) if isinstance(x,type) else x
+
+def _mk_procs(procs, nb): return L(procs).map(instantiate, nb=nb)
+
+# %% ../nbs/api/03_process.ipynb #ab147efe
+def _is_direc(f): return getattr(f, '__name__', '-')[-1]=='_'
+
+# %% ../nbs/api/03_process.ipynb #7c81f109
+class NBProcessor:
+    "Process cells and nbdev comments in a notebook"
+    def __init__(self, path=None, procs=None, nb=None, debug=False, rm_directives=True, process=False):
+        self.nb = read_nb(path) if nb is None else nb
+        self.lang = nb_lang(self.nb)
+        for cell in self.nb.cells: cell.directives_ = cell.directives
+        nbdirs = {k:v for k,v in _meta_directives(self.nb).items() if not any(k in c.directives_ for c in self.nb.cells)}
+        if nbdirs:
+            fc = first(c for c in self.nb.cells if c.cell_type=='code')
+            if fc is not None: fc.directives_ = nbdirs | fc.directives_
+        if rm_directives:
+            for cell in self.nb.cells: cell.remove_directives(quarto=rm_directives=='quarto')
+        self.procs = _mk_procs(procs, nb=self.nb)
+        self.debug,self.rm_directives = debug,rm_directives
+        if process: self.process()
+
+    def _process_cell(self, proc, cell):
+        if not hasattr(cell,'source'): return
+        if cell.cell_type=='code' and cell.directives_:
+            # Option 1: `proc` is directive name with `_` suffix
+            f = getattr(proc, '__name__', '-').rstrip('_')
+            if f in cell.directives_: self._process_comment(proc, cell, f)
+            
+            # Option 2: `proc` contains a method named `_{directive}_`
+            for cmd in cell.directives_:
+                f = getattr(proc, f'_{cmd}_', None)
+                if f: self._process_comment(f, cell, cmd)
+        if callable(proc) and not _is_direc(proc): cell = opt_set(cell, proc(cell))
+
+    def _process_comment(self, proc, cell, cmd):
+        args = cell.directives_[cmd].split()
+        if self.debug: print(cmd, args, proc)
+        return proc(cell, *args)
+        
+    def _proc(self, proc):
+        if hasattr(proc,'begin'): proc.begin()
+        for cell in self.nb.cells: self._process_cell(proc, cell)
+        if hasattr(proc,'end'): proc.end()
+        self.nb.cells = [c for c in self.nb.cells if c and getattr(c,'source',None) is not None]
+        for i,cell in enumerate(self.nb.cells): cell.idx_ = i
+
+    def process(self):
+        "Process all cells with all processors"
+        for proc in self.procs: self._proc(proc)
+
+# %% ../nbs/api/03_process.ipynb #fa1f8668
+class Processor:
+    "Base class for processors"
+    def __init__(self, nb): self.nb = nb
+    def cell(self, cell): pass
+    def __call__(self, cell): return self.cell(cell)

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/processors.py

@@ -68,7 +68,7 @@ def cell_lang(cell): return nested_attr(cell, 'metadata.language', 'python')
 def _want_doc(c):
     d = c.directives_
     show_d = set(['export', 'exports', 'exec_doc']).intersection(d)
-    return c.source and c.cell_type=='code' and show_d and 'hide' not in d and d.get('include:') != ['false']
+    return c.source and c.cell_type=='code' and show_d and 'hide' not in d and d.get('include') != 'false'
 
 class add_show_docs(Processor):
     "Add show_doc cells after exported cells, unless they are already documented"
@@ -234,7 +234,7 @@ def _do_eval(cell):
     if not cell.source or 'nbdev_export'+'()' in cell.source: return
     trees = cell.parsed_()
     if cell.cell_type != 'code' or not trees: return
-    if cell.directives_.get('eval:', [''])[0].lower() == 'false': return
+    if cell.directives_.get('eval', '').lower() == 'false': return
 
     _show_dirs = {'export','exports','exporti','exec_doc'}
     if cell.directives_.keys() & _show_dirs: return True
@@ -292,6 +292,6 @@ class FilterDefaults:
     
     def nb_proc(self, nb):
         "Get an `NBProcessor` with these processors"
-        return NBProcessor(nb=nb, procs=self.procs())
+        return NBProcessor(nb=nb, procs=self.procs(), rm_directives='quarto')
     
     def __call__(self, nb): return self.nb_proc(nb).process()

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/release.py

@@ -121,7 +121,9 @@ async def release(self:Release):
     "Tag and create a release in GitHub for the current version"
     ver = self.cfg.version
     notes = self.latest_notes()
-    await self.gh.create_release(ver, branch=_release_head(), body=notes)
+    default = (await self.gh.repos.get()).default_branch
+    latest = 'true' if _release_branch()==default else 'false'
+    await self.gh.create_release(ver, branch=_release_head(), body=notes, make_latest=latest)
     return ver
 
 # %% ../nbs/api/18_release.ipynb #22101171

nbdev-3.3.0/nbdev/skill.py

@@ -0,0 +1,181 @@
+"""Author clear, executable nbdev notebooks where code, prose, examples, outputs, and tests form one coherent narrative.
+
+# The notebook is the product
+
+An nbdev notebook is simultaneously source code, documentation, examples, and tests. Write it to be read from top to bottom. The rendered page should explain the public API, while executing the same cells should build and verify it.
+
+Do not treat an nbdev notebook as a Python module divided arbitrarily into cells. Use the notebook medium deliberately: interleave implementation with explanation, executable examples, useful outputs, plots, images, tables, diagrams, and demonstrations of failure whenever they communicate the idea better than prose alone.
+
+These conventions matter most for published libraries with rendered documentation sites. Internal projects with no docs page can be looser: match the surrounding notebooks' style rather than imposing every rule here.
+
+# Notebooks generate modules
+
+The notebook is the source of truth: `nbdev-export` writes exported cells to the module named by `#| default_exp`, and generated `.py` files are never edited by hand. Each exported section carries a marker like `# %% ../nbs/04_usage.ipynb #a45f753a` naming its source notebook and cell, so module code always leads back to the cell to change. `__all__`, `_modidx.py`, and module docstrings likewise regenerate on export - renames and additions propagate automatically, so never hand-edit them.
+
+The module docstring comes from the notebook's opening markdown: the title cell's `>` description line, joined with every *exported* markdown cell after the H1 (a markdown cell whose first line is `#| export`). For a long module docstring, prefer one exported markdown cell per section over packing everything into the title blockquote; both work.
+
+Not every module must come from a notebook, and projects often mix the two deliberately. Choose per module: notebook-sourced when narrative earns its keep - public API whose docs page matters, code best explained through interleaved prose and examples, tests that double as documentation; plain `.py` when the code is dense interlocking mechanism, iterated quickly, and covered by pytest, where cell-by-cell narrative would add friction rather than clarity. Check the file, never the repo: a `# %%` autogen marker at the top means notebook-sourced, no marker means hand-written and edited directly, and `nbdev-export` only rewrites marked files. Tests follow the source form: example and test cells for notebook modules, `tests/*.py` pytest files for plain ones.
+
+# Choose the kind of page
+
+Decide which form of documentation the notebook provides:
+
+- A **tutorial** teaches through a guided learning experience.
+- A **how-to guide** helps a reader accomplish a practical task.
+- An **explanation** develops understanding of a focused topic.
+- A **reference** describes a technical component and its API.
+
+Do not mix these forms accidentally. A reference page can contain examples, but should remain easy to scan for symbols and behavior. A tutorial should advance in a purposeful sequence rather than becoming an API inventory. A how-to should solve its stated problem without expanding into a general course. An explanation should clarify concepts and trade-offs rather than masquerading as step-by-step instructions.
+
+# Open the notebook well
+
+Start with a markdown cell containing an H1 title and a blockquote subtitle:
+
+```markdown
+# Great title
+
+> A short description of what this page provides
+```
+
+Then introduce the page briefly. For a reference notebook, describe the component and orient the reader to its main symbols. For a tutorial or how-to, state what the reader will learn or accomplish. For an explanation, name the question or idea under discussion. Get to the subject quickly.
+
+Use headings to make longer pages navigable. H2 headings normally divide major concepts or groups of symbols. Lower-level headings can organize longer discussions, but avoid fragmenting a short narrative into many tiny sections.
+
+# Develop one idea at a time
+
+A productive nbdev rhythm is:
+
+1. Add the smallest useful implementation.
+2. Explain what it does and why it has that form.
+3. Demonstrate it with executable code.
+4. Assert the behavior where an assertion improves the example.
+5. Display the result a reader should notice.
+6. Continue to the next idea.
+
+This is a pattern, not a demand that every code cell contain one statement. A test or example cell may demonstrate several closely related facts. It must have a markdown introduction that tells the reader what the cell is about to establish. If that introduction becomes complicated, does not naturally introduce everything shown, or reads like an explanation of unrelated checks, the cell is doing too much and should be split. Conversely, prefer extending an existing example cell with a closely related check over adding a near-duplicate cell.
+
+Keep definitions small enough to understand in context. When a class benefits from incremental development, define its core first and add methods later with `@patch`. This lets each method appear beside its explanation and examples. Keep a class together when splitting it would make the API harder, not easier, to understand.
+
+# Prefer helpers with a public purpose
+
+A helper introduced to make the notebook's own examples or tests clearer may also be a useful part of the library. Internal use is often the first evidence that an abstraction is worth exposing, not a reason to hide it.
+
+Ask whether the helper gives users a concise, coherent operation they would otherwise need to reconstruct from lower-level internals. A good public helper:
+
+- removes repeated knowledge of internal data structures
+- gives a common operation a clear name and contract
+- makes examples and downstream code easier to read
+- provides one place to adapt callers when internals change
+- is useful independently of the implementation that first needed it
+
+For example, a function that constructs a canonical tool-call object may first appear while building a test fixture, but it is also useful to developers constructing those objects themselves. The fixture is its first consumer, not its justification for being private.
+
+Treat private helpers with some suspicion. An underscore is appropriate for implementation machinery that has no coherent independent contract, but not merely because a function was first written for internal use. If a helper is only useful to the library itself, consider whether it exposes an awkward internal design that should instead become a small, reusable public abstraction.
+
+# Make prose earn its place
+
+Markdown should explain information the code does not express well:
+
+- why an abstraction exists
+- what distinction matters
+- what behavior the next example demonstrates
+- why a design choice was made
+- what limitation or failure motivated the implementation
+- how a symbol relates to the rest of the API
+- which details are guarantees and which merely describe an example
+
+Do not translate code line by line into English. Do not write empty transitions such as “Now we test the function.” State the lesson instead: “A missing leaf returns `None`, so success status alone does not establish existence.”
+
+Place prose where it reads correctly in the generated page. An exported definition is normally followed by markdown explaining the symbol and introducing its first example.
+
+# Keep docstrings short
+
+Use a short docstring to say what a public symbol does. Put extended explanations, examples, trade-offs, warnings, and rich media in markdown cells, where they render properly and can include executable results.
+
+Use docments beside parameters and return values. They keep argument documentation close to the signature without repeating the signature in a long docstring.
+
+Use backticks around related symbols in prose. nbdev can turn symbol references into documentation links, so prefer symbol names over manually maintained documentation URLs.
+
+# Examples are documentation and tests
+
+Write every example as part of the page first, then make it verify behavior where useful. Good examples:
+
+- use realistic, comprehensible values
+- show the shortest path to the idea being taught
+- produce an informative representation or result
+- include direct assertions that reinforce rather than obscure the lesson
+- reuse objects introduced naturally earlier in the notebook
+- demonstrate important errors with executable failing examples
+
+Avoid test-suite plumbing in reader-facing cells. Dense mocks, deeply nested comprehensions, long setup blocks, and many unrelated assertions make poor documentation even when they test correctly. Extract a tiny helper when setup obscures the behavior. Hide necessary but unreadable checks rather than forcing them into the page narrative.
+
+Do not weaken a clear example merely to tolerate a future change that would invalidate its premise. If an example exists to show that an object contains a particular behavior, it should fail when that behavior disappears so the author notices and reassesses the page.
+
+A code cell often ends with the value that should be displayed. The final line might show an object’s representation, a table, a plot, an image, a diff, a count, or another visual result of what was created or tested. Assertions verify; the final expression teaches. Prefer a useful stored output over ending every cell silently.
+
+# Use notebook outputs deliberately
+
+Notebooks can communicate with more than text. Use plots, images, tables, diagrams, videos, terminal recordings, rich HTML, and custom representations when they make behavior easier to grasp.
+
+Design useful object representations when appropriate. A compact `_repr_markdown_`, table, plot, or structured summary can turn later examples into clear documentation without repeated formatting code.
+
+Stored outputs are part of the explanation. They show the reader what an example produced and preserve evidence from an executed notebook. Keep them focused and readable; do not dump large structures without saying what matters in them.
+
+# Show failures as behavior
+
+Errors are part of an API. When a failure mode matters, demonstrate it with executable code and an assertion such as `expect_fail`, rather than describing it only in prose. A reader should be able to see which input fails and what rule is being enforced.
+
+Keep failure examples focused. A large defensive test covering many hypothetical errors is less useful than one example for each important contract.
+
+# Let state flow downward
+
+Notebook state is sequential. Make that sequence easy to follow:
+
+- keep imports in dedicated import cells
+- define values shortly before they are first used
+- reuse established objects instead of rebuilding near-duplicates
+- avoid reassigning a name when later cells depend on its earlier meaning
+- move genuinely shared setup into a small, clearly introduced helper
+- end exploratory cells with the expression whose output records what was learned
+
+A reader should not need to search far upward to understand where a value came from. If several later examples rely on setup, introduce the setup explicitly and explain its role.
+
+The import rule is strict, and covers every cell including tests: the docs build executes each cell that contains an import in a fresh namespace where the other cells have not run, so a cell mixing imports with other code either breaks the build with a NameError or silently runs at documentation time.
+
+# Use directives purposefully
+
+`#| default_exp` selects the generated module. `#| export` marks implementation for export. Private underscore-prefixed helpers may be exported with their public consumers without becoming part of the public API. `#| hide` keeps necessary but distracting material off the rendered page. `#| eval: false` is for examples that genuinely must not run automatically, not for suppressing broken cells.
+
+Directives affect both execution and documentation, so apply them according to the role of the whole cell. In particular, an unevaluated cell cannot create state required by later evaluated cells - so newly marking a cell `eval: false` means cascading the directive to the cells that depend on it.
+
+# Prefer executable evidence
+
+Whenever practical, show rather than claim:
+
+- display the object instead of describing its representation
+- run the transformation instead of paraphrasing the result
+- draw the plot instead of only discussing its shape
+- trigger the error instead of merely listing it
+- compare outputs when a distinction matters
+
+Executable evidence keeps documentation synchronized with behavior. Assertions turn important examples into regression tests, while visible outputs keep those tests useful to human readers.
+
+# Common authoring failures
+
+Avoid these patterns:
+
+- a large implementation followed much later by one large test section
+- several abstractions introduced before any is demonstrated
+- markdown that merely narrates the next line of code
+- long docstrings carrying material better expressed in notebook cells
+- imports mixed into example or test cells
+- repeated setup copied across examples
+- reader-facing cells dominated by mocks or cleanup machinery
+- many unrelated checks under one vague introduction
+- assertions that hide the result the reader needs to see
+- pages with no clear reader, purpose, or documentation form
+- descriptions of behavior that could be demonstrated directly
+- large outputs with no guidance about what to notice
+
+The governing test is simple: the notebook should be pleasant and informative to read, convincing when executed, and useful as the source of the library it documents.
+"""

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/sync.py

@@ -12,7 +12,6 @@ from .imports import *
 from .config import *
 from .maker import *
 from .process import *
-from .process import _partition_cell
 from .export import *
 from .doclinks import _iter_py_cells
 
@@ -61,7 +60,7 @@ def _update_nb(nb_path, cells, lib_dir):
         nbcell = nb_cells_by_id.get(cell.cell_id)
         if nbcell is None:
             raise ValueError(f"Cell ID '{cell.cell_id}' not found in notebook '{nb_path}'")
-        dirs,_ = _partition_cell(nbcell, 'python')
+        dirs,_ = nbcell._partition()
         nbcell.source = ''.join(dirs) + _to_absolute(cell.code, cell.py_path, lib_dir)
     write_nb(nbp.nb, nb_path)
 

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev/test.py

@@ -52,7 +52,7 @@ def test_nb(
             if cell.cell_type != 'code': return True
             if 'nbdev_export'+'(' in cell.source: return True
             direc = getattr(cell, 'directives_', {}) or {}
-            if direc.get('eval:', [''])[0].lower() == 'false': return True
+            if direc.get('eval', '').lower() == 'false': return True
             return flags & direc.keys()
 
         start = time.time()

{nbdev-3.2.2 → nbdev-3.3.0/nbdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdev
-Version: 3.2.2
+Version: 3.3.0
 Summary: Create delightful software with Jupyter Notebooks
 Author-email: "Jeremy Howard and the fast.ai community" <j@fast.ai>
 License: Apache-2.0
@@ -13,13 +13,13 @@ Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastcore>=1.14.6
-Requires-Dist: execnb>=0.2.4
+Requires-Dist: fastcore>=2.1.3
+Requires-Dist: execnb>=0.2.8
 Requires-Dist: astunparse
-Requires-Dist: ghapi>=2.0.0
+Requires-Dist: ghapi>=2.0.2
 Requires-Dist: watchdog
 Requires-Dist: asttokens
 Requires-Dist: setuptools

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ nbdev/scrubmagics.py
 nbdev/serve.py
 nbdev/serve_drv.py
 nbdev/showdoc.py
+nbdev/skill.py
 nbdev/sync.py
 nbdev/test.py
 nbdev.egg-info/PKG-INFO

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev.egg-info/entry_points.txt

@@ -6,6 +6,8 @@ nbdev-clean = nbdev.clean:nbdev_clean
 nbdev-conda = nbdev.release:release_conda
 nbdev-contributing = nbdev.quarto:nbdev_contributing
 nbdev-create-config = nbdev.config:nbdev_create_config
+nbdev-diff = nbdev.diff:nbdev_diff
+nbdev-diff-driver = nbdev.diff:nbdev_diff_driver
 nbdev-docs = nbdev.quarto:nbdev_docs
 nbdev-export = nbdev.doclinks:nbdev_export
 nbdev-filter = nbdev.cli:nbdev_filter
@@ -36,3 +38,6 @@ watch-export = nbdev.cli:watch_export
 
 [nbdev]
 nbdev = nbdev._modidx:d
+
+[pyskills]
+nbdev.skill = nbdev.skill

{nbdev-3.2.2 → nbdev-3.3.0}/nbdev.egg-info/requires.txt

@@ -1,7 +1,7 @@
-fastcore>=1.14.6
-execnb>=0.2.4
+fastcore>=2.1.3
+execnb>=0.2.8
 astunparse
-ghapi>=2.0.0
+ghapi>=2.0.2
 watchdog
 asttokens
 setuptools

{nbdev-3.2.2 → nbdev-3.3.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "nbdev"
 description = "Create delightful software with Jupyter Notebooks"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {text = "Apache-2.0"}
 authors = [{name = "Jeremy Howard and the fast.ai community", email = "j@fast.ai"}]
 keywords = ["nbdev", "fastai", "jupyter", "notebook", "export"]
@@ -19,7 +19,7 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
 ]
 dynamic = ["version"]
-dependencies = [ "fastcore>=1.14.6", "execnb>=0.2.4", "astunparse", "ghapi>=2.0.0", "watchdog", "asttokens",
+dependencies = [ "fastcore>=2.1.3", "execnb>=0.2.8", "astunparse", "ghapi>=2.0.2", "watchdog", "asttokens",
     "setuptools", "build", "fastgit>=0.0.7", "pyyaml", "tomli; python_version < '3.11'", ]
 
 [project.optional-dependencies]
@@ -37,6 +37,8 @@ nbdev-update-license = "nbdev.cli:nbdev_update_license"
 nbdev-export = "nbdev.doclinks:nbdev_export"
 nbdev-fix = "nbdev.merge:nbdev_fix"
 nbdev-merge = "nbdev.merge:nbdev_merge"
+nbdev-diff = "nbdev.diff:nbdev_diff"
+nbdev-diff-driver = "nbdev.diff:nbdev_diff_driver"
 nbdev-trust = "nbdev.clean:nbdev_trust"
 nbdev-clean = "nbdev.clean:nbdev_clean"
 nbdev-install-hooks = "nbdev.clean:nbdev_install_hooks"
@@ -69,6 +71,9 @@ watch-export = "nbdev.cli:watch_export"
 [project.entry-points.nbdev]
 nbdev = "nbdev._modidx:d"
 
+[project.entry-points.pyskills]
+"nbdev.skill" = "nbdev.skill"
+
 [tool.setuptools.dynamic]
 version = {attr = "nbdev.__version__"}
 

nbdev-3.2.2/nbdev/diff.py

@@ -1,94 +0,0 @@
-"""Get ipynb diffs by cell
-
-Docs: https://nbdev.fast.ai/api/diff.html.md"""
-
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/api/19_diff.ipynb.
-
-# %% auto #0
-__all__ = ['read_nb_from_git', 'nbs_pair', 'changed_cells', 'source_diff', 'cell_diffs']
-
-# %% ../nbs/api/19_diff.ipynb #10c8ad0b
-import json
-from fastcore.utils import *
-from fastcore.meta import delegates
-from difflib import unified_diff
-from fastgit import Git
-from fastcore.nbio import *
-
-# %% ../nbs/api/19_diff.ipynb #a8981115
-def read_nb_from_git(
-    g:Git, # The git object
-    path, # The path to the notebook (absolute or relative to git root)
-    ref=None # The git ref to read from (e.g. HEAD); None for working dir
-)->AttrDict: # The notebook
-    "Read notebook from git ref (e.g. HEAD) at path, or working dir if ref is None"
-    path = Path(path)
-    if path.is_absolute(): path = path.relative_to(g.top())
-    if ref is None: return read_nb(g.top()/path)
-    raw = g.show(f'{ref}:{path}')
-    return dict2nb(json.loads(raw))
-
-# %% ../nbs/api/19_diff.ipynb #3ac25702
-def _nb_srcdict(g:Git, nb_path, ref=None, f=noop):
-    "Dict of id->source"
-    nb = read_nb_from_git(g, nb_path, ref)
-    return {c['id']: f(c) for c in nb.cells}
-
-# %% ../nbs/api/19_diff.ipynb #27ff9a7b
-def nbs_pair(
-    nb_path, # Path to the notebook
-    ref_a='HEAD', # First git ref (None for working dir)
-    ref_b=None, # Second git ref (None for working dir)
-    f=noop  # Function to call on contents
-): # Tuple of two notebooks
-    "NBs at two refs; None means working dir. By default provides HEAD and working dir"
-    nb_path = Path(nb_path).resolve()
-    g = Git(nb_path.parent)
-    return _nb_srcdict(g, nb_path, ref_a, f), _nb_srcdict(g, nb_path, ref_b, f)
-
-# %% ../nbs/api/19_diff.ipynb #958aeaf8
-def _cell_changes(
-    nb_path, # Path to the notebook
-    fn, # function to call to get dict values
-    ref_a='HEAD', # First git ref (None for working dir)
-    ref_b=None, # Second git ref (None for working dir)
-    adds=True, # Include cells in b but not in a
-    changes=True, # Include cells with different content
-    dels=False, # Include cells in a but not in b
-    metadata=False, # Consider cell metadata when comparing
-    outputs=False # Consider cell outputs when comparing
-): # Dict of results
-    "Apply fn(cell_id, old_content, new_content) to changed cells between two refs"
-    def cell_content(c):
-        res = c.get('source', '')
-        if metadata: res += '\n# metadata: ' + json.dumps(c.get('metadata', {}), sort_keys=True)
-        if outputs: res += '\n# outputs: ' + json.dumps(c.get('outputs', []), sort_keys=True)
-        return res
-    old,new = nbs_pair(nb_path, ref_a, ref_b, f=cell_content)
-    res = {}
-    if adds: res |= {cid: fn(cid, '', new[cid]) for cid in new if cid not in old}
-    if changes: res |= {cid: fn(cid, old[cid], new[cid]) for cid in new if cid in old and new[cid] != old[cid]}
-    if dels: res |= {cid: fn(cid, old[cid], '') for cid in old if cid not in new}
-    return res
-
-# %% ../nbs/api/19_diff.ipynb #6a723bc8
-@delegates(_cell_changes)
-def changed_cells(nb_path, **kwargs):
-    "Return set of cell IDs for changed/added/deleted cells between two refs"
-    def f(cid,o,n): return cid
-    return set(_cell_changes(nb_path, f, **kwargs).keys())
-
-# %% ../nbs/api/19_diff.ipynb #079eedb0
-def source_diff(
-    old_source, # Original source string
-    new_source # New source string
-): # Unified diff string
-    "Return unified diff string for source change"
-    return '\n'.join(unified_diff(old_source.splitlines(), new_source.splitlines(), lineterm=''))
-
-# %% ../nbs/api/19_diff.ipynb #38216afa
-@delegates(_cell_changes)
-def cell_diffs(nb_path, **kwargs):
-    "{cell_id:diff} for changed/added/deleted cells between two refs"
-    def f(cid,o,n): return source_diff(o,n)
-    return _cell_changes(nb_path, f, **kwargs)

nbdev-3.2.2/nbdev/process.py

@@ -1,138 +0,0 @@
-"""A notebook processor
-
-Docs: https://nbdev.fast.ai/api/process.html.md"""
-
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/api/03_process.ipynb.
-
-# %% auto #0
-__all__ = ['langs', 'nb_lang', 'first_code_ln', 'extract_directives', 'opt_set', 'instantiate', 'NBProcessor', 'Processor']
-
-# %% ../nbs/api/03_process.ipynb #59172c3d
-from .config import *
-from .maker import *
-from .imports import *
-
-from fastcore.nbio import *
-from fastcore.script import *
-from fastcore.imports import *
-
-from collections import defaultdict
-
-# %% ../nbs/api/03_process.ipynb #48e04902-f4a1-4247-ae0c-1e30bc054166
-# from https://github.com/quarto-dev/quarto-cli/blob/main/src/resources/jupyter/notebook.py
-langs = defaultdict(
-    lambda: '#',  r = "#", python = "#", julia = "#", scala = "//", matlab = "%", csharp = "//", fsharp = "//",
-    c = ["/*","*/"], css = ["/*","*/"], sas = ["*",";"], powershell = "#", bash = "#", sql = "--", mysql = "--", psql = "--",
-    lua = "--", cpp = "//", cc = "//", stan = "#", octave = "#", fortran = "!", fortran95 = "!", awk = "#", gawk = "#", stata = "*",
-    java = "//", groovy = "//", sed = "#", perl = "#", ruby = "#", tikz = "%", javascript = "//", js = "//", d3 = "//", node = "//",
-    sass = "//", coffee = "#", go = "//", asy = "//", haskell = "--", dot = "//", apl = "⍝")
-
-# %% ../nbs/api/03_process.ipynb #c54390ab-1cb9-4146-9e88-609f1fc5544a
-def nb_lang(nb): return nested_attr(nb, 'metadata.kernelspec.language', 'python')
-
-# %% ../nbs/api/03_process.ipynb #2974d8cc-870c-4362-b2b1-e35f94c28dd9
-def _dir_pre(lang=None): return fr"\s*{langs[lang]}\s*\|"
-def _quarto_re(lang=None): return re.compile(_dir_pre(lang) + r'\s*[\w|-]+\s*:')
-
-# %% ../nbs/api/03_process.ipynb #484a1df8
-def _directive(s, lang='python'):
-    s = re.sub('^'+_dir_pre(lang), f"{langs[lang]}|", s)
-    if s.strip().endswith(':'): s = s.replace(':', '') # You can append colon at the end to be Quarto compliant.  Ex: #| hide:
-    if ':' in s: s = s.replace(':', ': ')
-    s = (s.strip()[2:]).strip().split()
-    if not s: return None
-    direc,*args = s
-    return direc,args
-
-# %% ../nbs/api/03_process.ipynb #100a91fb-8b46-4feb-afbf-d1e78c14cfd6
-def _norm_quarto(s, lang='python'):
-    "normalize quarto directives so they have a space after the colon"
-    m = _quarto_re(lang).match(s)
-    return m.group(0) + ' ' + _quarto_re(lang).sub('', s).lstrip() if m else s
-
-# %% ../nbs/api/03_process.ipynb #69befb76-aa77-4923-bfcc-2606613d706f
-_cell_mgc = re.compile(r"^\s*%%\w+")
-
-def first_code_ln(code_list, re_pattern=None, lang='python'):
-    "get first line number where code occurs, where `code_list` is a list of code"
-    if re_pattern is None: re_pattern = _dir_pre(lang)
-    return first(i for i,o in enumerate(code_list) if o.strip() != '' and not re.match(re_pattern, o) and not _cell_mgc.match(o))
-
-# %% ../nbs/api/03_process.ipynb #b3eee2d6-59b9-45f3-affd-4de2bd1284d1
-def _partition_cell(cell, lang):
-    if not cell.source: return [],[]
-    lines = cell.source.splitlines(True)
-    first_code = first_code_ln(lines, lang=lang)
-    return lines[:first_code],lines[first_code:]
-
-# %% ../nbs/api/03_process.ipynb #3cca78a4
-def extract_directives(cell, remove=True, lang='python'):
-    "Take leading comment directives from lines of code in `ss`, remove `#|`, and split"
-    dirs,code = _partition_cell(cell, lang)
-    if not dirs: return {}
-    if remove:
-        # Leave Quarto directives and cell magic in place for later processing
-        cell['source'] = ''.join([_norm_quarto(o, lang) for o in dirs if _quarto_re(lang).match(o) or _cell_mgc.match(o)] + code)
-    return dict(L(_directive(s, lang) for s in dirs).filter())
-
-# %% ../nbs/api/03_process.ipynb #e6701805
-def opt_set(var, newval):
-    "newval if newval else var"
-    return newval if newval else var
-
-# %% ../nbs/api/03_process.ipynb #98c9d556
-def instantiate(x, **kwargs):
-    "Instantiate `x` if it's a type"
-    return x(**kwargs) if isinstance(x,type) else x
-
-def _mk_procs(procs, nb): return L(procs).map(instantiate, nb=nb)
-
-# %% ../nbs/api/03_process.ipynb #ab147efe
-def _is_direc(f): return getattr(f, '__name__', '-')[-1]=='_'
-
-# %% ../nbs/api/03_process.ipynb #7c81f109
-class NBProcessor:
-    "Process cells and nbdev comments in a notebook"
-    def __init__(self, path=None, procs=None, nb=None, debug=False, rm_directives=True, process=False):
-        self.nb = read_nb(path) if nb is None else nb
-        self.lang = nb_lang(self.nb)
-        for cell in self.nb.cells: cell.directives_ = extract_directives(cell, remove=rm_directives, lang=self.lang)
-        self.procs = _mk_procs(procs, nb=self.nb)
-        self.debug,self.rm_directives = debug,rm_directives
-        if process: self.process()
-
-    def _process_cell(self, proc, cell):
-        if not hasattr(cell,'source'): return
-        if cell.cell_type=='code' and cell.directives_:
-            # Option 1: `proc` is directive name with `_` suffix
-            f = getattr(proc, '__name__', '-').rstrip('_')
-            if f in cell.directives_: self._process_comment(proc, cell, f)
-            
-            # Option 2: `proc` contains a method named `_{directive}_`
-            for cmd in cell.directives_:
-                f = getattr(proc, f'_{cmd}_', None)
-                if f: self._process_comment(f, cell, cmd)
-        if callable(proc) and not _is_direc(proc): cell = opt_set(cell, proc(cell))
-
-    def _process_comment(self, proc, cell, cmd):
-        args = cell.directives_[cmd]
-        if self.debug: print(cmd, args, proc)
-        return proc(cell, *args)
-        
-    def _proc(self, proc):
-        if hasattr(proc,'begin'): proc.begin()
-        for cell in self.nb.cells: self._process_cell(proc, cell)
-        if hasattr(proc,'end'): proc.end()
-        self.nb.cells = [c for c in self.nb.cells if c and getattr(c,'source',None) is not None]
-        for i,cell in enumerate(self.nb.cells): cell.idx_ = i
-
-    def process(self):
-        "Process all cells with all processors"
-        for proc in self.procs: self._proc(proc)
-
-# %% ../nbs/api/03_process.ipynb #fa1f8668
-class Processor:
-    "Base class for processors"
-    def __init__(self, nb): self.nb = nb
-    def cell(self, cell): pass
-    def __call__(self, cell): return self.cell(cell)