nbs/api/10_processors.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "750913d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp processors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b8b4a6",
   "metadata": {},
   "source": [
    "# processors\n",
    "> Some processors for NBProcessor\n",
    "- order: 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2398f5ef-06d3-4890-8a54-7cf4f81f3894",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "import ast\n",
    "import importlib\n",
    "\n",
    "from nbdev.config import *\n",
    "from nbdev.imports import *\n",
    "from nbdev.process import *\n",
    "from nbdev.showdoc import *\n",
    "from nbdev.doclinks import *\n",
    "from nbdev.frontmatter import *\n",
    "from nbdev.frontmatter import _fm2dict\n",
    "\n",
    "from execnb.nbio import *\n",
    "from execnb.shell import *\n",
    "from fastcore.imports import *\n",
    "from fastcore.xtras import *\n",
    "import sys,yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce00cb74",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "from fastcore.test import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d36f27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "_test_file = '../../tests/docs_test.ipynb'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f23622a",
   "metadata": {},
   "source": [
    "On this page we'll be using this private helper to process a notebook and return the results, to simplify testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfdcb1c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _run_procs(procs=None, return_nb=False, path=_test_file):\n",
    "    nbp = NBProcessor(path, procs)\n",
    "    nbp.process()\n",
    "    if return_nb: return nbp.nb\n",
    "    return '\\n'.join([str(cell) for cell in nbp.nb.cells])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ab33554",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_langs = 'bash|html|javascript|js|latex|markdown|perl|ruby|sh|svg'\n",
    "_lang_pattern = re.compile(rf'^\\s*%%\\s*({_langs})\\s*$', flags=re.MULTILINE)\n",
    "\n",
    "class populate_language(Processor):\n",
    "    \"Set cell language based on NB metadata and magics\"\n",
    "    def begin(self): self.language = nb_lang(self.nb)\n",
    "    def cell(self, cell):\n",
    "        if cell.cell_type != 'code': return\n",
    "        lang = _lang_pattern.findall(cell.source)\n",
    "        if lang: cell.metadata.language = lang[0]\n",
    "        else: cell.metadata.language = self.language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f652cd59",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "res = _run_procs(populate_language, return_nb=True)\n",
    "assert set(L(res.cells).attrgot('metadata').attrgot('language').filter()) == {'python', 'bash'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "382949b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class insert_warning(Processor):\n",
    "    \"Insert Autogenerated Warning Into Notebook after the first cell.\"\n",
    "    content = \"<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->\"\n",
    "    def begin(self): self.nb.cells.insert(1, mk_cell(self.content, 'markdown'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "923b3b37",
   "metadata": {},
   "source": [
    "This preprocessor inserts a warning in the markdown destination that the file is autogenerated.  This warning is inserted in the second cell so we do not interfere with front matter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ce46fe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(insert_warning)\n",
    "assert \"<!-- WARNING: THIS FILE WAS AUTOGENERATED!\" in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3918b2bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "L('foo', None, 'a').filter(lambda x:x == 1)\n",
    "_tstre = re.compile('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa1069b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_def_types = (ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef)\n",
    "def _def_names(cell, shown):\n",
    "    cellp = cell.parsed_()\n",
    "    return [showdoc_nm(o) for o in concat(cellp)\n",
    "            if isinstance(o,_def_types) and o.name not in shown and (o.name[0]!='_' or o.name[:2]=='__')] if cellp else []\n",
    "\n",
    "def _get_nm(tree):\n",
    "    i = tree.value.args[0]\n",
    "    if hasattr(i, 'id'): val = i.id\n",
    "    else: val = try_attrs(i.value, 'id', 'func', 'attr')\n",
    "    return f'{val}.{i.attr}' if isinstance(i, ast.Attribute) else i.id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13cbb041",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _show_docs(trees):\n",
    "    return [t for t in trees if isinstance(t,ast.Expr) and nested_attr(t, 'value.func.id')=='show_doc']\n",
    "\n",
    "def cell_lang(cell): return nested_attr(cell, 'metadata.language', 'python')\n",
    "\n",
    "def _want_doc(c):\n",
    "    d = c.directives_\n",
    "    show_d = set(['export', 'exports', 'exec_doc']).intersection(d)\n",
    "    return c.source and c.cell_type=='code' and show_d and 'hide' not in d and d.get('include:') != ['false']\n",
    "\n",
    "class add_show_docs(Processor):\n",
    "    \"Add show_doc cells after exported cells, unless they are already documented\"\n",
    "    def begin(self):\n",
    "        nb = self.nb\n",
    "        exports = L(cell for cell in nb.cells if _want_doc(cell))\n",
    "        trees = L(nb.cells).map(NbCell.parsed_).concat()\n",
    "        shown_docs = {_get_nm(t) for t in _show_docs(trees)}\n",
    "        for cell in reversed(exports):\n",
    "            if cell_lang(cell) != 'python':  raise ValueError(f\"{cell.metadata.language} can't export:\\n{cell.source}\")\n",
    "            nms = _def_names(cell, shown_docs)\n",
    "            for nm in nms:\n",
    "                new_cell = mk_cell(f'show_doc({nm})')\n",
    "                new_cell.has_sd = True\n",
    "                nb.cells.insert(cell.idx_+1, new_cell)\n",
    "        nb.has_docs_ = shown_docs or exports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cae6902a",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs([populate_language, add_show_docs])\n",
    "assert \"show_doc(some_func)'\" in res\n",
    "assert \"show_doc(and_another)'\" in res\n",
    "assert \"show_doc(another_func)'\" not in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da28855a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "# tests @patch works\n",
    "_nb = _run_procs([populate_language, add_show_docs], return_nb=True, path='../../tests/showdoc_test.ipynb')\n",
    "assert r'show_doc(Foo.a_method)' in L(_nb.cells).attrgot('source')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22b1972e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def fdiv(attrs=''):\n",
    "    \"Create a fenced div markdown cell in quarto\"\n",
    "    if attrs: attrs = ' {'+attrs+'}'\n",
    "    return mk_cell(':::'+attrs, cell_type='markdown')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09a0be27",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = fdiv('.py-2')\n",
    "test_eq(a.cell_type, 'markdown')\n",
    "test_eq(a.source, '::: {.py-2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27bc8ad4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def boxify(cells):\n",
    "    \"Add a box around `cells`\"\n",
    "    if not isinstance(cells, list): cells = [cells]\n",
    "    res = [fdiv('.py-2 .px-3 .mb-4 fig-align=\"center\" .border .rounded .shadow-sm')]\n",
    "    return res+cells+[fdiv()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a7127ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class mv_exports(Processor):\n",
    "    \"Move `exports` cells to after the `show_doc`\"\n",
    "    def begin(self):\n",
    "        cells = self.nb.cells\n",
    "        exports = L(c for c in cells if c.cell_type=='code' and 'exports' in c.directives_)\n",
    "        for cell in reversed(exports):\n",
    "            idx = cell.idx_\n",
    "            if getattr(cells[idx+1], 'has_sd', 0):\n",
    "                doccell = cells.pop(idx+1)\n",
    "                srccell = cells.pop(idx)\n",
    "                cells[idx:idx] = [doccell,srccell]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7eff7d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_re_defaultexp = re.compile(r'^\\s*#\\|\\s*default_exp\\s+(\\S+)', flags=re.MULTILINE)\n",
    "\n",
    "def _default_exp(nb):\n",
    "    \"get the default_exp from a notebook\"\n",
    "    code_src = L(nb.cells).filter(lambda x: x.cell_type == 'code').attrgot('source')\n",
    "    default_exp = first(code_src.filter().map(_re_defaultexp.search).filter())\n",
    "    return default_exp.group(1) if default_exp else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77d9215a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "_testnb = read_nb('../../tests/docs_test.ipynb')\n",
    "test_eq(_default_exp(_testnb), 'foobar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03e8fece-bf92-4a1d-9f8b-ef209107ff95",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def add_links(cell):\n",
    "    \"Add links to markdown cells\"\n",
    "    nl = NbdevLookup()\n",
    "    if cell.cell_type == 'markdown': cell.source = nl.linkify(cell.source)\n",
    "    for o in cell.get('outputs', []):\n",
    "        if hasattr(o, 'data') and hasattr(o['data'], 'text/markdown'):\n",
    "            o.data['text/markdown'] = [nl.link_line(s) for s in o.data['text/markdown']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ec86ad0-b020-4c5c-9154-cc34b95d58d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(add_links)\n",
    "assert \"[`numpy.array`](https://numpy.org/doc/stable/reference/generated/numpy.array.html#numpy.array)\" in res\n",
    "assert \"[`ModuleMaker`](https://nbdev.fast.ai/api/maker.html#modulemaker) but not a link to `foobar`.\" in res\n",
    "assert \"A link in a docstring: [`ModuleMaker`](https://nbdev.fast.ai/api/maker.html#modulemaker).\" in res\n",
    "assert \"And not a link to <code>dict2nb</code>.\" in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "809e9225",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def add_fold(cell):\n",
    "    \"Add `code-fold` to `exports` cells\"\n",
    "    if cell.cell_type != 'code' or 'exports' not in cell.directives_: return\n",
    "    cell.source = f'#| code-fold: show\\n#| code-summary: \"Exported source\"\\n{cell.source}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb50c88",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(add_fold)\n",
    "assert \"#| code-fold: show\" in res"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "463b9def-91ad-4b05-92c3-e074954e4faf",
   "metadata": {},
   "source": [
    "Gets rid of colors that are streamed from standard out, which can interfere with static site generators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84073fa6-5907-41f2-b8b8-568a96112fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_re_ansi_escape = re.compile(r'\\x1B(?:[@-Z\\\\-_]|\\[[0-?]*[ -/]*[@-~])')\n",
    "\n",
    "def strip_ansi(cell):\n",
    "    \"Strip Ansi Characters.\"\n",
    "    for outp in cell.get('outputs', []):\n",
    "        if outp.get('name')=='stdout': outp['text'] = [_re_ansi_escape.sub('', o) for o in outp.text]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc2bed97",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(strip_ansi)\n",
    "assert not _re_ansi_escape.findall(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "640b7eca",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def strip_hidden_metadata(cell):\n",
    "    '''Strips \"hidden\" metadata property from code cells so it doesn't interfere with docs rendering'''\n",
    "    if cell.cell_type == 'code' and 'metadata' in cell: cell.metadata.pop('hidden',None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "995ebd32",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def hide_(cell):\n",
    "    \"Hide cell from output\"\n",
    "    del(cell['source'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74cd3876",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(hide_)\n",
    "assert 'you will not be able to see this cell at all either' not in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb415328-044f-44ca-ac77-4f5ae65c2235",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _re_hideline(lang=None): return re.compile(fr'{langs[lang]}\\|\\s*hide_line\\s*$', re.MULTILINE)\n",
    "\n",
    "def hide_line(cell):\n",
    "    \"Hide lines of code in code cells with the directive `hide_line` at the end of a line of code\"\n",
    "    lang = cell_lang(cell)\n",
    "    if cell.cell_type == 'code' and _re_hideline(lang).search(cell.source):\n",
    "        cell.source = '\\n'.join([c for c in cell.source.splitlines() if not _re_hideline(lang).search(c)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20322d06-7adb-4d50-b1d5-b10ec5f5f2ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(hide_line)\n",
    "assert r\"def show():\\n    a = 2\\n    b = 3\" not in res\n",
    "assert r\"def show():\\n    a = 2\"                in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96a84b1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "# integration test with hide_line\n",
    "_nb = _run_procs([populate_language,hide_line], path='../../tests/APL.ipynb')\n",
    "assert 'hide_line' not in _nb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8ccf1d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def filter_stream_(cell, *words):\n",
    "    \"Remove output lines containing any of `words` in `cell` stream output\"\n",
    "    if not words: return\n",
    "    for outp in cell.get('outputs', []):\n",
    "        if outp.output_type == 'stream':\n",
    "            outp['text'] = [l for l in outp.text if not re.search('|'.join(words), l)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96dfdefb-ba07-4ab1-8a23-18e2b27ad707",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(filter_stream_)\n",
    "exp=r\"'A line\\n', 'Another line.\\n'\"\n",
    "assert exp in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "848fd452-3d63-4c41-aaa6-e14cbeb9fdcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_aimagics_pattern = re.compile(r'^\\s*(%%ai.? |%%ai.?$)', re.MULTILINE)\n",
    "\n",
    "def ai_magics(cell):\n",
    "    \"A preprocessor to convert AI magics to markdown\"\n",
    "    if cell.cell_type == 'code' and _aimagics_pattern.search(cell.source):\n",
    "        cell.cell_type ='markdown'\n",
    "        cell.source = '\\n'.join(cell.source.splitlines()[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39541a1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(ai_magics)\n",
    "assert \"'source': 'This is a test.'\" in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a9c8fd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_magics_pattern = re.compile(r'^\\s*(%%|%).*', re.MULTILINE)\n",
    "\n",
    "def clean_magics(cell):\n",
    "    \"A preprocessor to remove cell magic commands\"\n",
    "    if cell.cell_type == 'code': cell.source = _magics_pattern.sub('', cell.source).strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6acf27ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(clean_magics)\n",
    "assert \"%%\" not in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93e27a52",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_re_hdr_dash = re.compile(r'^#+\\s+.*\\s+-\\s*$', re.MULTILINE)\n",
    "\n",
    "def rm_header_dash(cell):\n",
    "    \"Remove headings that end with a dash -\"\n",
    "    if cell.source:\n",
    "        src = cell.source.strip()\n",
    "        if cell.cell_type == 'markdown' and src.startswith('#') and src.endswith(' -'): del(cell['source'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4a9ac53",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(rm_header_dash)\n",
    "assert 'some words' in res\n",
    "assert 'A heading to Hide' not in res\n",
    "assert 'Yet another heading to hide' not in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75faf537",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_hide_dirs = {'export','exporti', 'hide','default_exp'}\n",
    "\n",
    "def rm_export(cell):\n",
    "    \"Remove cells that are exported or hidden\"\n",
    "    if cell.directives_ and (cell.directives_.keys() & _hide_dirs): del(cell['source'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcb05919",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs(rm_export)\n",
    "assert 'dontshow' not in res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d9a0a30",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "_re_showdoc = re.compile(r'^show_doc', re.MULTILINE)\n",
    "def _is_showdoc(cell): return cell['cell_type'] == 'code' and _re_showdoc.search(cell.source)\n",
    "def _add_directives(cell, d):\n",
    "    for k,v in d.items():\n",
    "        if not re.findall(fr'#\\| *{k}:', cell.source): cell.source = f'#| {k}: {v}\\n' + cell.source\n",
    "\n",
    "def clean_show_doc(cell):\n",
    "    \"Remove ShowDoc input cells\"\n",
    "    if not _is_showdoc(cell): return\n",
    "    _add_directives(cell, {'output':'asis','echo':'false'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ebda551",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _ast_contains(trees, types):\n",
    "    for tree in trees:\n",
    "        for node in ast.walk(tree):\n",
    "            if isinstance(node, types): return True\n",
    "\n",
    "def _do_eval(cell):\n",
    "    if cell_lang(cell) != 'python': return\n",
    "    if not cell.source or 'nbdev_export'+'()' in cell.source: return\n",
    "    trees = cell.parsed_()\n",
    "    if cell.cell_type != 'code' or not trees: return\n",
    "    if cell.directives_.get('eval:', [''])[0].lower() == 'false': return\n",
    "\n",
    "    _show_dirs = {'export','exports','exporti','exec_doc'}\n",
    "    if cell.directives_.keys() & _show_dirs: return True\n",
    "    if _ast_contains(trees, (ast.Import, ast.ImportFrom)):\n",
    "        if _ast_contains(trees, (ast.Expr, ast.Assign)):\n",
    "            warn(f'Found cells containing imports and other code. See FAQ.\\n---\\n{cell.source}\\n---\\n')\n",
    "        return True\n",
    "    if _show_docs(trees): return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867cf721",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class exec_show_docs(Processor):\n",
    "    \"Execute cells needed for `show_docs` output, including exported cells and imports\"\n",
    "    def begin(self):\n",
    "        if nb_lang(self.nb) != 'python': return\n",
    "        self.k = CaptureShell()\n",
    "        self.k.run_cell('from nbdev.showdoc import show_doc')\n",
    "\n",
    "    def __call__(self, cell):\n",
    "        if not self.nb.has_docs_ or not hasattr(self, 'k'): return\n",
    "        fm = getattr(self.nb, 'frontmatter_', {})\n",
    "        if str2bool(fm.get('skip_showdoc', False)): return\n",
    "        if _do_eval(cell): self.k.cell(cell)\n",
    "        title = fm.get('title', '')\n",
    "        if self.k.exc: \n",
    "            raise Exception(f\"Error{' in notebook: '+title if title else ''} in cell {cell.idx_} :\\n{cell.source}\") from self.k.exc\n",
    "\n",
    "    def end(self):\n",
    "        try: from ipywidgets import Widget\n",
    "        except ImportError: pass\n",
    "        else:\n",
    "            mimetype = 'application/vnd.jupyter.widget-state+json'\n",
    "            old = nested_idx(self.nb.metadata, 'widgets', mimetype) or {'state': {}}\n",
    "            new = Widget.get_manager_state(drop_defaults=True)\n",
    "            widgets = {**old, **new, 'state': {**old.get('state', {}), **new['state']}}\n",
    "            self.nb.metadata['widgets'] = {mimetype: widgets}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad5df898",
   "metadata": {},
   "outputs": [],
   "source": [
    "res = _run_procs([add_show_docs, exec_show_docs])\n",
    "assert res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a761e07c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "def _import_obj(s):\n",
    "    mod_nm, obj_nm = s.split(':')\n",
    "    mod = importlib.import_module(mod_nm)\n",
    "    return getattr(mod, obj_nm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b450cff",
   "metadata": {},
   "outputs": [],
   "source": [
    "#| export\n",
    "class FilterDefaults:\n",
    "    \"Override `FilterDefaults` to change which notebook processors are used\"\n",
    "    def xtra_procs(self):\n",
    "        imps = get_config().get('procs', '').split()\n",
    "        return [_import_obj(o) for o in imps]\n",
    "\n",
    "    def base_procs(self):\n",
    "        return [FrontmatterProc, populate_language, add_show_docs, insert_warning,\n",
    "                strip_ansi, hide_line, filter_stream_, rm_header_dash,\n",
    "                clean_show_doc, exec_show_docs, rm_export, ai_magics, clean_magics, hide_, add_links,\n",
    "                add_fold, mv_exports, strip_hidden_metadata]\n",
    "\n",
    "    def procs(self):\n",
    "        \"Processors for export\"\n",
    "        skip_procs = get_config().get('skip_procs', '').split(',')\n",
    "        return L(self.base_procs()).filter(lambda x: x.__name__ not in skip_procs) + self.xtra_procs()\n",
    "    \n",
    "    def nb_proc(self, nb):\n",
    "        \"Get an `NBProcessor` with these processors\"\n",
    "        return NBProcessor(nb=nb, procs=self.procs())\n",
    "    \n",
    "    def __call__(self, nb): return self.nb_proc(nb).process()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af909f4",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "079a05ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "#|hide\n",
    "import nbdev; nbdev.nbdev_export()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c35ef8df",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}