file2records 0.2.0__py3-none-any.whl

file2records/__init__.py

@@ -0,0 +1,15 @@
+"""file2records: turn a folder of papers into a structured dataset you can check.
+
+    import file2records as fr
+    project = fr.Project("my-review")
+    project.add("papers/")
+    project.extract(model=fr.rwth())
+    project.export("dataset.csv")
+
+See project.py for the API, cli.py for the command line, main.py for the web app.
+"""
+__version__ = "0.2.0"
+
+from .project import Project, rwth  # noqa: E402
+
+__all__ = ["Project", "rwth", "__version__"]

file2records/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

file2records/bundle.py

@@ -0,0 +1,155 @@
+"""The export bundle: a dataset together with what produced it.
+
+A CSV of records on its own is not reproducible -- it cannot say which model wrote it, under
+which prompt, against which schema, or which rows a human then corrected. The bundle is the data
+beside the config and a manifest that pins both.
+
+What it leaves out by default matters as much. Papers obtained through publishers' text-and-data
+mining agreements may be read and mined, not redistributed -- and a bundle is made to be shared.
+So the paper text and the source files go in only when asked for (`include_text`,
+`include_files`), which is the right call for open-access papers and the caller's to make.
+Without them every record still names its paper's DOI and the ids of the chunks it came from,
+which is enough for anyone with access to the paper to check it.
+
+No key ever enters the bundle; model settings are copied without their key variables.
+"""
+import csv
+import io
+import json
+import subprocess
+import time
+import zipfile
+from pathlib import Path
+
+from . import __version__, config, models, report, storage
+from .storage import read_json
+
+
+def csv_bytes(columns, rows) -> bytes:
+    buffer = io.StringIO()
+    writer = csv.DictWriter(buffer, fieldnames=columns, extrasaction="ignore")
+    writer.writeheader()
+    writer.writerows(rows)
+    return buffer.getvalue().encode("utf-8")
+
+
+def git_commit() -> str | None:
+    """Which checkout produced this, when run from one. None for an installed package, whose
+    version is recorded instead."""
+    try:
+        return subprocess.check_output(["git", "-C", str(Path(__file__).resolve().parent),
+                                        "rev-parse", "HEAD"],
+                                       text=True, stderr=subprocess.DEVNULL, timeout=5).strip()
+    except Exception:
+        return None
+
+
+def build(paper_ids: list[str] | None = None, *, include_text: bool = False,
+          include_files: bool = False, profiles: list[dict] | None = None) -> bytes:
+    """The zip as bytes. `paper_ids` limits it to those papers (None: all of them)."""
+    record_columns, record_rows = report.flat_records(paper_ids)
+    paper_columns, paper_rows = report.papers_table(paper_ids)
+    summary = report.build()
+    settings = config.get_settings()
+    if profiles is None:
+        profiles = [{k: v for k, v in p.items()} for p in models.listing(lambda _: False)]
+    chosen = {r["paper_id"] for r in paper_rows}
+
+    manifest = {
+        "exported_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "tool": "file2records",
+        "version": __version__,
+        "git_commit": git_commit(),
+        "papers": len(paper_rows),
+        "records": len(record_rows),
+        "includes_paper_text": include_text,
+        "models": {
+            "extract": (models.get(settings.get("extract_model", "")) or {}).get("model"),
+            "judge": (models.get(settings.get("judge_model", "")) or {}).get("model"),
+            # per paper too: a corpus is often built across more than one model
+            "per_paper": {r["paper_id"]: {"extract": r["extract_model"], "judge": r["judge_model"]}
+                          for r in paper_rows},
+        },
+        "spend": summary.get("totals", {}).get("spend", {}),
+        "source_tracking_default": settings.get("source_tracking_default", True),
+    }
+
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as bundle:
+        bundle.writestr("manifest.json", json.dumps(manifest, indent=2, ensure_ascii=False))
+        bundle.writestr("README.md", _readme(manifest))
+        bundle.writestr("data/records.csv", csv_bytes(record_columns, record_rows))
+        bundle.writestr("data/records.json", json.dumps(record_rows, indent=1, ensure_ascii=False))
+        bundle.writestr("data/papers.csv", csv_bytes(paper_columns, paper_rows))
+        bundle.writestr("data/report.json", json.dumps(summary, indent=2, ensure_ascii=False))
+
+        # config: everything that decides what a run produces, and nothing that authenticates it
+        bundle.writestr("config/schema.json",
+                        json.dumps({"fields": config.get_schema()}, indent=2, ensure_ascii=False))
+        bundle.writestr("config/extract_prompt.txt", config.get_extract_prompt())
+        bundle.writestr("config/judge_prompt.txt", config.get_judge_prompt())
+        bundle.writestr("config/few_shot.json",
+                        json.dumps(config.get_few_shot(), indent=2, ensure_ascii=False))
+        bundle.writestr("config/models.json", json.dumps(
+            [{k: v for k, v in m.items()
+              if k in ("id", "name", "model", "api_base", "api_version")} for m in profiles],
+            indent=2, ensure_ascii=False))
+
+        # the per-paper working files, so a reviewer can trace any row back to its chunk
+        for stage, directory in (("extracted", storage.EXTRACTED), ("judged", storage.JUDGED)):
+            for path in sorted(directory.glob("*.json")):
+                if path.stem in chosen:
+                    bundle.write(path, f"{stage}/{path.name}")
+        for path in sorted(storage.PARSED.glob("*.json")):
+            if path.stem not in chosen:
+                continue
+            paper = read_json(path, {})
+            if not include_text:
+                paper["chunks"] = [{"id": c["id"]} for c in paper.get("chunks", [])]
+            bundle.writestr(f"parsed/{path.name}", json.dumps(paper, indent=1, ensure_ascii=False))
+        if include_files:
+            for pid in sorted(chosen):
+                if (source := storage.source_file(pid)) is not None:
+                    bundle.write(source, f"papers/{source.name}")
+    return buffer.getvalue()
+
+
+def _readme(manifest: dict) -> str:
+    m = manifest["models"]
+    text_note = (
+        "`chunks[].text` holds the paper text, because this bundle was exported with it. Check "
+        "the papers' licences before sharing it."
+        if manifest["includes_paper_text"] else
+        "Paper text is not included -- papers obtained under text-and-data-mining terms may be "
+        "mined, not redistributed. Each chunk keeps its `id`, and each record its paper's DOI, "
+        "so anyone with access to the paper can check a value against its source.")
+    return f"""# file2records bundle
+
+{manifest['records']} records from {manifest['papers']} paper(s), exported
+{manifest['exported_at']} by file2records {manifest['version']}.
+
+## What is here
+
+- `data/records.csv`, `data/records.json` — one row per record, with the paper's DOI, the
+  judge's verdict and any reviewer flag or note. `extract_model` and `judge_model` say what
+  produced each row.
+- `data/papers.csv` — one row per paper: DOI, chunks in, records out, model, tokens, cost.
+- `data/report.json` — completeness by field, what the judge changed, totals.
+- `config/` — the schema, both prompts, the worked examples and the model settings that
+  produced this. API keys are not included.
+- `parsed/`, `extracted/`, `judged/` — the working files, so any row can be traced back to the
+  chunk it came from. `source_chunk_ids` on a record refers to `chunks[].id` in `parsed/`.
+- `papers/` — the source files, if you exported with them.
+
+{text_note}
+
+## Reading it
+
+Extraction model: `{m['extract'] or 'not set'}` · judge model: `{m['judge'] or 'not set'}`.
+Papers may differ from these if the corpus was built across more than one model; see
+`models.per_paper` in `manifest.json`.
+
+`model_records` in `extracted/*.json` is what the model originally said, kept beside the
+corrected records the moment anything was edited. A corrected dataset that cannot be diffed
+against the model's own output is not evidence of anything.
+"""

file2records/cli.py

@@ -0,0 +1,207 @@
+"""The `file2records` command.
+
+    file2records serve my-review                 the web app on that project folder
+    file2records add my-review papers/           read files and folders into it
+    file2records papers my-review                what is in it
+    file2records search my-review "glycoly[sz]is"
+    file2records check my-review                 what is missing before a run
+    file2records extract my-review --only "glycoly[sz]is" --exclude "positron|tomograph"
+    file2records judge my-review
+    file2records export my-review dataset.csv    (.csv, .json, or .zip for the full bundle)
+
+Every command takes the project folder first. Model commands use the model chosen in the web
+app's Settings unless --model is given: any litellm model string, or rwth/<name> for RWTH's
+KI:connect (key from RWTH_API_KEY).
+"""
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from . import __version__
+
+
+def _project(folder):
+    from .project import Project
+    project = Project(folder)
+    # Keys saved through the web app live in the project's .env; a .env in the current folder
+    # is read too. Neither overrides a variable already set in the shell.
+    load_dotenv(project.path / ".env")
+    load_dotenv(Path.cwd() / ".env")
+    return project
+
+
+def _filters(p):
+    p.add_argument("--only", metavar="REGEX",
+                   help="only papers whose full text matches this regular expression")
+    p.add_argument("--exclude", metavar="REGEX",
+                   help="skip papers whose full text matches this regular expression")
+
+
+def _print_result(r):
+    name = r.get("filename") or r["id"]
+    if r.get("error"):
+        print(f"  ✗ {name}: {r['error']}")
+    elif "n_chunks" in r:
+        doi = f"  doi:{r['doi']}" if r.get("doi") else ""
+        print(f"  ✓ {name}  [{r['format']}]  {r['n_chunks']} chunks{doi}")
+    elif "n_records" in r:
+        print(f"  ✓ {name}: {r['n_records']} records in {r['seconds']}s")
+    else:
+        print(f"  ✓ {name}: {r['n_verdicts']} verdicts in {r['seconds']}s")
+
+
+def cmd_serve(args):
+    os.environ["WORKSPACE_DIR"] = str(Path(args.folder).resolve())
+    _project(args.folder)                        # creates the folder, opens it
+    import uvicorn
+    from .main import app
+    url = f"http://{args.host}:{args.port}"
+    print(f"file2records {__version__} — project {Path(args.folder).resolve()}\nOpen {url}")
+    if not args.no_browser:
+        import threading
+        import webbrowser
+        threading.Timer(1.0, webbrowser.open, [url]).start()
+    uvicorn.run(app, host=args.host, port=args.port, log_level="warning")
+
+
+def cmd_add(args):
+    project = _project(args.folder)
+    print(f"Reading into {project.path}")
+    results = project.add(*args.paths, source_tracking=not args.no_source_tracking,
+                          on_file=_print_result)
+    failed = sum(1 for r in results if r.get("error"))
+    print(f"{len(results) - failed} added, {failed} failed")
+    return 1 if failed and failed == len(results) else 0
+
+
+def cmd_papers(args):
+    papers = _project(args.folder).papers()
+    if not papers:
+        print("No papers yet. Add some:  file2records add <folder> <files or folders>")
+    for p in papers:
+        state = "judged" if p["judged"] else "extracted" if p["extracted"] else "parsed"
+        records = "" if p["n_records"] is None else f"{p['n_records']} records"
+        print(f"{p['id']:50.50}  {p['format']:8}  {state:9}  {records:11}  {p['doi']}")
+
+
+def cmd_search(args):
+    hits = _project(args.folder).search(args.pattern, ignore_case=not args.case_sensitive)
+    for h in hits:
+        print(f"\n{h['filename']}  ({h['matches']} matches)")
+        for s in h["snippets"]:
+            print(f"    …{s['before'][-60:]}[{s['match']}]{s['after'][:60]}…".replace("\n", " "))
+    total = sum(h["matches"] for h in hits)
+    print(f"\n{len(hits)} papers, {total} matches")
+
+
+def cmd_check(args):
+    project = _project(args.folder)
+    ok = True
+    for stage in ("extract", "judge"):
+        missing = project.check(stage, args.model)
+        ok &= stage == "judge" or not missing
+        print(f"{stage}: {'ready' if not missing else 'not ready'}")
+        for m in missing:
+            hint = " Or pass --model, e.g. rwth/gpt-oss-120b." if m.startswith("Choose a model") else ""
+            print(f"  - {m}{hint}")
+    return 0 if ok else 1
+
+
+def _run_stage(args, stage):
+    project = _project(args.folder)
+    run = project.extract if stage == "extract" else project.judge
+    results = run(args.model, only=args.only, exclude=args.exclude, redo=args.redo,
+                  on_paper=_print_result)
+    if not results:
+        print(f"Nothing to {stage}: every chosen paper is done already (--redo to run again).")
+    failed = sum(1 for r in results if r.get("error"))
+    print(f"{len(results) - failed} done, {failed} failed")
+    return 1 if failed else 0
+
+
+def cmd_export(args):
+    path = _project(args.folder).export(args.output, only=args.only, exclude=args.exclude,
+                                        include_text=args.include_text,
+                                        include_files=args.include_files)
+    print(f"Wrote {path}")
+
+
+FOLDER = "the project folder (created if it does not exist)"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="file2records",
+        description="Turn papers (PDF, XML, HTML, Word, Markdown) into a structured dataset.",
+        epilog="examples:\n" + "\n".join(__doc__.splitlines()[2:10]) +
+               "\n\ndocs: https://enkhnyam.github.io/chemistry-data-extractor-toolkit/",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--version", action="version", version=f"file2records {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True, metavar="COMMAND")
+
+    p = sub.add_parser("serve", help="open the web app on a project folder")
+    p.add_argument("folder", nargs="?", default="workspace", help=FOLDER + " (default: %(default)s)")
+    p.add_argument("--port", type=int, default=8000)
+    p.add_argument("--host", default="127.0.0.1",
+                   help="keep the default unless you know why: the app has no login")
+    p.add_argument("--no-browser", action="store_true")
+    p.set_defaults(func=cmd_serve)
+
+    p = sub.add_parser("add", help="read files or folders of papers into a project")
+    p.add_argument("folder", help=FOLDER)
+    p.add_argument("paths", nargs="+", help="paper files, or folders of them")
+    p.add_argument("--no-source-tracking", action="store_true",
+                   help="don't tag chunks, so records won't cite the passage they came from")
+    p.set_defaults(func=cmd_add)
+
+    p = sub.add_parser("papers", help="list the papers in a project")
+    p.add_argument("folder", help=FOLDER)
+    p.set_defaults(func=cmd_papers)
+
+    p = sub.add_parser("search", help="search the full text of every paper with a regex")
+    p.add_argument("folder", help=FOLDER)
+    p.add_argument("pattern", help="a regular expression, e.g. \"glycoly[sz]is\"")
+    p.add_argument("--case-sensitive", action="store_true")
+    p.set_defaults(func=cmd_search)
+
+    p = sub.add_parser("check", help="say what is missing before a run")
+    p.add_argument("folder", help=FOLDER)
+    p.add_argument("--model")
+    p.set_defaults(func=cmd_check)
+
+    for stage, text in (("extract", "extract records from papers not extracted yet"),
+                        ("judge", "audit extracted records with a second model")):
+        p = sub.add_parser(stage, help=text)
+        p.add_argument("folder", help=FOLDER)
+        p.add_argument("--model", help='litellm model string, or rwth/<name> '
+                                       '(default: the model chosen in Settings)')
+        p.add_argument("--redo", action="store_true", help="also re-run papers already done")
+        _filters(p)
+        p.set_defaults(func=lambda a, s=stage: _run_stage(a, s))
+
+    p = sub.add_parser("export", help="write records to .csv / .json, or a .zip bundle")
+    p.add_argument("folder", help=FOLDER)
+    p.add_argument("output", help="a .csv or .json file of records, or a .zip bundle")
+    p.add_argument("--include-text", action="store_true",
+                   help="put the paper text in a .zip bundle (check the papers' licences)")
+    p.add_argument("--include-files", action="store_true",
+                   help="put the source files in a .zip bundle (check the papers' licences)")
+    _filters(p)
+    p.set_defaults(func=cmd_export)
+    return parser
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args) or 0
+    except (ValueError, RuntimeError, FileNotFoundError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

file2records/config.py

@@ -0,0 +1,96 @@
+"""Reads/writes the four things that make this tool generic: the schema, the extraction
+prompt, the judge rubric, and few-shot examples. All under workspace/config/, all editable
+from the Settings page -- change these four and the same pipeline runs on a different
+domain, no code changes."""
+from . import exemplar
+from . import storage
+from .storage import read_json, write_json
+from .dynschema import PLACEHOLDER_SCHEMA
+
+
+
+def settings_file():
+    return storage.CONFIG / "settings.json"
+
+
+def schema_file():
+    return storage.CONFIG / "schema.json"
+
+
+def extract_prompt_file():
+    return storage.CONFIG / "extract_prompt.txt"
+
+
+def judge_prompt_file():
+    return storage.CONFIG / "judge_prompt.txt"
+
+
+def few_shot_file():
+    return storage.CONFIG / "few_shot.json"
+
+DEFAULT_SETTINGS = {
+    # Which named model profile each stage calls; see server/models.py. Empty until chosen.
+    "extract_model": "",
+    "judge_model": "",
+    "source_tracking_default": True,  # a real default: provenance on unless turned off
+}
+
+def get_settings() -> dict:
+    return {**DEFAULT_SETTINGS, **read_json(settings_file(), {})}
+
+
+def save_settings(patch: dict) -> dict:
+    cfg = get_settings()
+    cfg.update(patch)
+    write_json(settings_file(), cfg)
+    return cfg
+
+
+def get_schema() -> list[dict]:
+    """Empty until someone defines one. A shipped default meant every new install began with
+    ten PET fields nobody chose, and an extraction that looked like it had worked."""
+    return read_json(schema_file(), {"fields": []})["fields"]
+
+
+def save_schema(fields: list[dict]) -> None:
+    write_json(schema_file(), {"fields": fields})
+
+
+def _get_text(path) -> str:
+    """A prompt nobody has written yet is empty, not somebody else's.
+
+    This used to fall back to a built-in PET prompt, which meant a first run quietly extracted
+    ionic-liquid chemistry from whatever you uploaded and looked like it had worked. The
+    example text is still shown -- as placeholder text in the box -- but it is never the value.
+    """
+    return path.read_text(encoding="utf-8") if path.exists() else ""
+
+
+def get_extract_prompt() -> str:
+    return _get_text(extract_prompt_file())
+
+
+def save_extract_prompt(text: str) -> None:
+    extract_prompt_file().write_text(text, encoding="utf-8")
+
+
+def get_judge_prompt() -> str:
+    return _get_text(judge_prompt_file())
+
+
+def placeholders() -> dict:
+    """Everything shown as grey example text in an empty field. None of it is ever a value."""
+    return {"extract": exemplar.EXTRACT_PROMPT, "judge": exemplar.JUDGE_PROMPT,
+            "model": "gpt-4o-mini", "schema": PLACEHOLDER_SCHEMA}
+
+
+def save_judge_prompt(text: str) -> None:
+    judge_prompt_file().write_text(text, encoding="utf-8")
+
+
+def get_few_shot() -> list[dict]:
+    return read_json(few_shot_file(), [])
+
+
+def save_few_shot(examples: list[dict]) -> None:
+    write_json(few_shot_file(), examples)

file2records/demo/NOTICE.md

@@ -0,0 +1,34 @@
+# The demo paper, and why it is here
+
+This folder ships one real paper so that a fresh clone has something to run on. It is open
+access under **CC BY 3.0**, on the *publisher's own published version* — which is what makes
+redistributing the PDF itself lawful, rather than only the right to read it.
+
+| File | Citation | Licence |
+|---|---|---|
+| `pdfs/…lewis-acidic…pdf` | Qun Feng Yue, Lin Fei Xiao, Mi Lin Zhang and Xue Feng Bai, *The Glycolysis of Poly(ethylene terephthalate) Waste: Lewis Acidic Ionic Liquids as High Efficient Catalysts*, **Polymers** 2013, **5**, 1258–1271. [10.3390/polym5041258](https://doi.org/10.3390/polym5041258) | [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/) |
+
+The PDF and the text derived from it under `parsed/` are redistributed unmodified in substance.
+The row above is the attribution the licence requires: creator, title, source and licence, each
+with a link. CC BY 3.0 requires attribution and nothing else: you may redistribute and adapt,
+including commercially, provided the creators are credited as above.
+
+The rest of this repository is MIT (see `LICENSE`). This PDF is not MIT; it stays under CC BY,
+and the MIT licence does not extend to it.
+
+## Why only one
+
+The PET database this toolkit was generalised out of uses seven papers as redistributable
+worked examples. Five of those seven are open access only as a **submitted-version deposit** in
+an institutional repository (mostly `ir.ipe.ac.cn`), under CC BY-NC-SA. That licence covers the
+deposited manuscript, not the publisher's typeset PDF, and it is the publisher's PDF that exists
+on disk. Redistributing the text of those five is fine and is what the database does;
+redistributing the publisher's PDF is not, so they are not shipped here.
+
+An earlier version of this demo also shipped *Amino Acid-Based Cholinium Ionic Liquids as
+Sustainable Catalysts for PET Depolymerization* (ACS Sustainable Chem. Eng. 2021,
+[10.1021/acssuschemeng.1c04060](https://doi.org/10.1021/acssuschemeng.1c04060)). That article is
+CC BY 4.0 and redistributing it was lawful, but ACS stamps every PDF download with the IP address
+it was fetched from, and publishing that line alongside the file served nobody. Re-downloading
+does not help — the stamp is applied to every copy — so the paper was removed rather than
+replaced. One paper is enough to show what the tool does.

file2records/demo/config/extract_prompt.txt

@@ -0,0 +1,51 @@
+You extract experimental data for PET depolymerisation from a paper's text and tables.
+The reaction is glycolysis, methanolysis or hydrolysis, and the catalyst may be an ionic liquid,
+a metal salt, an acid or base, or none. Treat all three routes the same way.
+SKIP papers and rows for any other route, including aminolysis and enzymatic degradation.
+Extract only what is stated; leave anything unreported as null. The output structure is
+enforced by the response schema, so focus on getting the values and their sources right.
+
+## What to extract
+- INCLUDE the current study's ("this work") depolymerisation experiments reported in text and
+  tables, whichever route they use.
+- SKIP these rows entirely:
+  - literature / cited results — a Source or Reference column, "Ref. N", "[N]", "et al.";
+  - RSM / Box-Behnken / optimization tables (coded factors and a single modeled response);
+  - data that appears only in a figure/image;
+  - characterization or kinetics tables (NMR shifts, bond lengths, Arrhenius) — not depolymerisation runs.
+- Extract EVERY qualifying row: N current-study rows → N records. Don't merge or stop early.
+
+## Catalyst naming
+- Use the paper's shorthand in bracket notation, with digits inline rather than subscripts (a
+  formula printed with subscript counts is recorded with normal digits).
+- Join physical mixtures as written. No catalyst / uncatalyzed → "none".
+- A catalyst named only by a code from a synthesis recipe (e.g. "IL-1", "Cat-A"): keep the code
+  verbatim unless the paper equates it with a clean chemical name. (Reading the code literally is
+  what lets the extraction match the ground truth.)
+
+## Global reaction conditions
+Conditions stated once — in the methods or a table footnote — apply to EVERY row of that table.
+Propagate them to all records, and convert amounts to grams:
+- catalyst wt% → g:  catalyst_g = wt%/100 × PET_g
+- solvent:PET mass ratio → g:  solvent_g = ratio × PET_g  (the solvent is whichever reagent the
+  reaction uses — ethylene glycol, methanol, water, an amine)
+- molar ratio → g via molecular weight (PET repeat unit ≈ 192 g/mol)
+
+## Values
+- Ignore placeholder wording ("a certain amount", "specific temperature", a bare symbol) — take
+  the concrete value from the table; if there is none, use null.
+- temperature_c: copy exactly, never convert.  reaction_time_min: hours × 60.
+- yield_percent, selectivity_percent, conversion_percent are DIFFERENT metrics — put each value
+  only in the field the paper labels it as (a conversion column → conversion_percent, a
+  selectivity column → selectivity_percent, a yield column → yield_percent).
+- null (not 0) when a value is unreported.  pressure_atm: null unless a number is stated.
+
+## Skip-these examples (schematic — illustrate the row shape, not real data)
+Literature (cited Source):             RSM / optimization (coded factors):
+| Source | Catalyst | Temp |          | Run | A:factor | B:factor | Response |
+| Ref. N | <cited>  | ...  |          | 1   | lo       | hi       | ...      |
+
+## Source chunks
+The text is split into chunks tagged "ID: <uuid>". For each record, list in source_chunk_ids
+every chunk that supplied a value — usually the table chunk, the footnote/conditions chunk, and
+any chunk that defined a catalyst code.

file2records/demo/config/few_shot.json

@@ -0,0 +1 @@
+[]