nbdev 3.2.2__tar.gz → 3.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdev
-Version: 3.2.2
+Version: 3.3.1
 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.1}/nbdev/__init__.py

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

{nbdev-3.2.2 → nbdev-3.3.1}/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.1}/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.get('metadata')).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.1/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.1}/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.1/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.get('metadata')).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.1}/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.1}/nbdev/release.py

@@ -63,7 +63,7 @@ def _release_head():
 def update_changelog(txt, ver, notes, marker='<!-- do not remove -->\n'):
     "Insert `notes` into changelog `txt` after `marker`, replacing any existing section for `ver`"
     txt = re.sub(rf'\n## {re.escape(ver)}\n.*?(?=\n## |\Z)', '', txt, flags=re.S)
-    return txt.replace(marker, marker+notes+'\n')
+    return txt.replace(marker, marker+notes.rstrip('\n')+'\n\n').rstrip('\n')+'\n'
 
 # %% ../nbs/api/18_release.ipynb #0b36471a
 class Release:
@@ -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.1/nbdev/skill.py

@@ -0,0 +1,56 @@
+"""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 source, docs, examples, and tests at once: the rendered page explains the public API, and executing the same cells builds and verifies it. Write it to be read top to bottom, interleaving implementation with explanation, examples, outputs, and failure demonstrations. These conventions matter most for published libraries with docs sites; in internal projects, match the surrounding notebooks instead.
+
+# Notebooks generate modules
+
+`nbdev-export` writes exported cells to the module named by `#| default_exp`; never hand-edit generated `.py` files, `__all__`, `_modidx.py`, or generated module docstrings: the next export overwrites them. Each exported section's marker (`# %% ../nbs/04_usage.ipynb #a45f753a`) leads back to the cell to change. The module docstring is the title cell's `>` description joined with every exported markdown cell after the H1; for a long docstring, prefer one exported markdown cell per section.
+
+Projects mix notebook-sourced and plain modules deliberately: notebooks where narrative earns its keep (public API with a docs page, code best explained through examples, tests that double as documentation), plain `.py` for dense mechanism iterated quickly under pytest. Check the file, never the repo: view its first few lines - a generated module opens with the `# AUTOGENERATED! DO NOT EDIT!` warning naming its source notebook, and `# %%` cell markers precede each definition (so a few lines of context around any def also answer it). No marker means hand-written and edited directly. Tests follow the source form: cells for notebook modules, `tests/*.py` for plain ones.
+
+For project-level questions, read `nbs/index.ipynb`, not `README.md`: the README is generated from it, renders worse, and can be stale if regeneration lagged. When they disagree, index.ipynb is the truth; regenerate with `nbdev-readme` after editing it.
+
+# Structure
+
+Pick one documentation form deliberately rather than mixing accidentally: tutorial (guided learning), how-to (a practical task), explanation (a focused topic), or reference (a component and its API, easy to scan).
+
+Open with an H1 title cell plus `>` subtitle line, introduce the page in a sentence or two, and get to the subject quickly. H2 headings divide major concepts; don't fragment a short narrative into tiny sections. Every heading goes in its own markdown cell, separate from body prose: Jupyter collapses sections by cell.
+
+# Develop one idea at a time
+
+The rhythm: add the smallest useful implementation, explain what it does and why it has that form, demonstrate it executably, assert where that improves the example, display the result a reader should notice, move on. A cell may bundle several closely related checks, but needs a markdown introduction saying what it establishes; if the introduction gets complicated, split the cell. Prefer extending an existing example over adding a near-duplicate cell. Build classes incrementally with `@patch` so each method sits beside its explanation, unless splitting makes the API harder to understand.
+
+# Helpers
+
+Internal use is often the first evidence an abstraction is worth exposing, not a reason to hide it. Reserve underscores for machinery with no coherent independent contract; a helper only useful to the library itself hints at an awkward internal design.
+
+# Prose and docstrings
+
+Markdown explains what the code cannot: why an abstraction exists, what distinction the next example demonstrates, which details are guarantees and which merely describe an example. Never narrate code line by line or write empty transitions ("Now we test the function"); state the lesson ("A missing leaf returns `None`, so success status alone does not establish existence"). Place prose where it reads correctly on the generated page, normally right after the definition it explains.
+
+Keep docstrings to a short statement of what the symbol does; extended explanation, examples, and warnings go in markdown cells, where they render properly and can include executable results. Document parameters and returns with docments, keeping their docs beside the signature instead of repeating it in the docstring. Backtick symbol names in prose; nbdev links them, so prefer names over hand-maintained URLs.
+
+# Examples are documentation and tests
+
+Write each example as page content first, then make it verify behavior: realistic values, the shortest path to the idea, an informative displayed result, direct assertions that reinforce the lesson, reuse of objects introduced earlier, and important errors demonstrated executably with `expect_fail` (one focused example per contract). Keep test plumbing out of reader-facing cells: mocks, dense comprehensions, and long setup make poor documentation, so extract a tiny helper or hide the check. Assertions verify; the final expression teaches: end cells with the value worth displaying, and design a compact `_repr_markdown_` or structured summary when it turns later examples into documentation for free. Plots, tables, images, and rich HTML all count as evidence. Stored outputs are part of the explanation: keep them focused, and never dump a large structure without saying what matters in it. Test helpers come from `fastcore.test` (`test_eq`, `expect_fail`, ...), in plain code cells. Show rather than claim; executable evidence keeps documentation synchronized with behavior.
+
+# State flows downward
+
+Keep imports in dedicated import cells, define values near first use, reuse established objects, don't reassign names later cells depend on, introduce shared setup explicitly, and end exploratory cells with the expression whose output records what was learned, so a reader never searches far upward for where a value came from. The import rule is strict and covers test cells: the docs build runs each import-containing cell in a fresh namespace where no other cell has run, so a cell mixing imports with other code breaks the build or silently runs at documentation time.
+
+# Directives
+
+`#| default_exp` names the module. `#| export` marks exported cells; underscore-prefixed helpers may export without joining the public API. `#| hide` keeps necessary but distracting material off the page. `#| eval: false` is for cells that genuinely must not run, not for suppressing broken ones, and it cascades: an unevaluated cell cannot create state for later evaluated cells.
+
+# nbdev v3
+
+Everything here describes nbdev v3 (released Jan 2026, possibly after a model's training cutoff). Key user-visible changes from v2: config moved from `settings.ini` to `pyproject.toml` - standard metadata in `[project]`, nbdev-specific keys in `[tool.nbdev]` (defaults `nbs_path='nbs'`, `doc_path='_docs'`), version in `__init__.py` via `dynamic = ["version"]`, and `_modidx` registered under `[project.entry-points.nbdev]`. CLI commands use hyphens (`nbdev-export`, `nbdev-test`, ...) though Python functions keep underscores. GitHub workflows use the v3 actions (`fastai/workflows/nbdev3-ci`, `quarto-ghp3`).
+
+# Before you finish
+
+Each new test cell ran red then green: it failed before the change and passed after. Re-read the touched section as a reader would, against the conventions above - style damage fails silently: tests pass, export succeeds, and the harm only shows on the docs page.
+
+The governing test: pleasant and informative to read, convincing when executed, useful as the source of the library it documents.
+"""

{nbdev-3.2.2 → nbdev-3.3.1}/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.1}/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.1/nbdev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdev
-Version: 3.2.2
+Version: 3.3.1
 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.1}/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.1}/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.1}/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.1}/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)