nbdev 3.2.1__tar.gz → 3.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nbdev
-Version: 3.2.1
+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,18 +13,18 @@ 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
 Requires-Dist: build
-Requires-Dist: fastgit
+Requires-Dist: fastgit>=0.0.7
 Requires-Dist: pyyaml
 Requires-Dist: tomli; python_version < "3.11"
 Provides-Extra: dev

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

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

{nbdev-3.2.1 → 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__',
@@ -313,11 +323,17 @@ d = { 'settings': { 'branch': 'main',
                                'nbdev.release.Release.changelog': ('api/release.html#release.changelog', 'nbdev/release.py'),
                                'nbdev.release.Release.latest_notes': ('api/release.html#release.latest_notes', 'nbdev/release.py'),
                                'nbdev.release.Release.release': ('api/release.html#release.release', 'nbdev/release.py'),
+                               'nbdev.release._check_changelog_base': ('api/release.html#_check_changelog_base', 'nbdev/release.py'),
                                'nbdev.release._find_config': ('api/release.html#_find_config', 'nbdev/release.py'),
                                'nbdev.release._get_conda_meta': ('api/release.html#_get_conda_meta', 'nbdev/release.py'),
+                               'nbdev.release._is_ancestor': ('api/release.html#_is_ancestor', 'nbdev/release.py'),
                                'nbdev.release._issue_txt': ('api/release.html#_issue_txt', 'nbdev/release.py'),
                                'nbdev.release._issues_txt': ('api/release.html#_issues_txt', 'nbdev/release.py'),
                                'nbdev.release._load_json': ('api/release.html#_load_json', 'nbdev/release.py'),
+                               'nbdev.release._release_branch': ('api/release.html#_release_branch', 'nbdev/release.py'),
+                               'nbdev.release._release_head': ('api/release.html#_release_head', 'nbdev/release.py'),
+                               'nbdev.release._remote_shas': ('api/release.html#_remote_shas', 'nbdev/release.py'),
+                               'nbdev.release._require_release_branch': ('api/release.html#_require_release_branch', 'nbdev/release.py'),
                                'nbdev.release._run': ('api/release.html#_run', 'nbdev/release.py'),
                                'nbdev.release._write_yaml': ('api/release.html#_write_yaml', 'nbdev/release.py'),
                                'nbdev.release.anaconda_upload': ('api/release.html#anaconda_upload', 'nbdev/release.py'),
@@ -351,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.1 → 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.1 → 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.1 → 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()