#!/usr/bin/env python3 """ extract_code.py — CODE-PRESERVING re-extraction of the EQC notebooks. Companion to parse_reports.py (which is text-only and DROPS runnable code). This one keeps every code cell verbatim so the notebooks can be ATTACHED to RAG chunks (payload riders keyed by dataset_id) — the agent then sees the real cdsapi / copernicusmarine / xarray / plot code, not just prose. Does NOT mutate any Qdrant index and does NOT touch existing parsed/*.md. Outputs (all new): eqc_qa/notebooks_code/.md full reconstruction (```python fences) eqc_qa/notebooks_by_dataset.json dataset_id -> [notebook attach records] eqc_qa/extract_code_stats.json summary Mapping reuses eqc_qa/reports.jsonl (matched_dataset_id / store / confidence). """ import json import re import sys from pathlib import Path ROOT = Path(__file__).resolve().parent REPO = ROOT / "repo" MANIFEST = ROOT / "reports.jsonl" OUT_MD = ROOT / "notebooks_code" OUT_SIDECAR = ROOT / "notebooks_by_dataset.json" OUT_STATS = ROOT / "extract_code_stats.json" SOURCE_REPO = "ecmwf-projects/c3s2-eqc-quality-assessment" LICENSE = "Apache-2.0" DOWNLOAD_RE = re.compile( r"cdsapi|\.retrieve\(|copernicusmarine|\bcm\.(subset|get|open_dataset)|" r"c3s_eqc_automatic_quality_control|\bdownload\.|from .*import .*download|" r"!?\bwget\b|urlretrieve|requests\.get|\.hda\b|EO:", re.I, ) ANALYZE_RE = re.compile( r"\bimport xarray|\bxr\.|\.open_dataset|\.open_mfdataset|\bimport pandas|\bpd\.|" r"\bimport numpy|\bnp\.|\bscipy|\bxskillscore|\bruptures|\.groupby\(|\.resample\(|" r"\.mean\(|\.sel\(|\.isel\(", re.I, ) PLOT_RE = re.compile( r"\bmatplotlib|\bplt\.|\bcartopy|\bccrs\b|\bcmocean|\.plot\(|\.plot\.|seaborn|\bsns\.", re.I, ) def log(*a): print(*a, file=sys.stderr, flush=True) def _src(cell) -> str: s = cell.get("source", "") return "".join(s) if isinstance(s, list) else s def code_line_count(code: str) -> int: n = 0 for ln in code.splitlines(): st = ln.strip() if st and not st.startswith("#"): n += 1 return n def text_outputs(cell) -> list[str]: """Trimmed text outputs (stdout/stderr/text-plain), dropping progress-bar / warning noise.""" out = [] for o in cell.get("outputs", []): ot = o.get("output_type") s = None if ot == "stream": t = o.get("text", "") s = "".join(t) if isinstance(t, list) else t elif ot in ("execute_result", "display_data"): tp = (o.get("data") or {}).get("text/plain") if tp is not None: s = "".join(tp) if isinstance(tp, list) else tp if not s: continue s = s.strip() if not s or re.fullmatch(r"<[^>]+>", s) or s.startswith("= 8: out.append(s[:1500]) # cap giant dumps return out def classify(code: str) -> list[str]: kinds = [] if DOWNLOAD_RE.search(code): kinds.append("download") if ANALYZE_RE.search(code): kinds.append("analyze") if PLOT_RE.search(code): kinds.append("plot") return kinds or ["other"] def extract_notebook(path: Path) -> dict: nb = json.loads(path.read_text(encoding="utf-8", errors="replace")) parts = [] # reconstructed md n_code_cells = 0 n_code_lines = 0 kinds = set() title = "" for cell in nb.get("cells", []): ct = cell.get("cell_type") if ct == "markdown": txt = _src(cell).strip() if txt: parts.append(txt) if not title: for ln in txt.splitlines(): if ln.startswith("# "): title = ln[2:].strip() break elif ct == "code": src = _src(cell).rstrip() if not src.strip(): continue n_code_cells += 1 n_code_lines += code_line_count(src) kinds.update(classify(src)) parts.append("```python\n" + src + "\n```") for to in text_outputs(cell): parts.append("```text\n" + to + "\n```") return { "content_md": "\n\n".join(parts).strip(), "title": title or path.stem, "n_code_cells": n_code_cells, "n_code_lines": n_code_lines, "recipe_kinds": sorted(kinds), } def main(): OUT_MD.mkdir(exist_ok=True) manifest = {r["report_id"]: r for r in (json.loads(l) for l in MANIFEST.read_text().splitlines() if l.strip())} log(f"manifest: {len(manifest)} reports") sidecar: dict[str, list] = {} unmatched: list = [] stats = {"notebooks": 0, "code_cells": 0, "code_lines": 0, "with_download": 0, "with_analyze": 0, "with_plot": 0, "attached_datasets": 0, "unmatched_notebooks": 0} for nb in sorted(REPO.rglob("*.ipynb")): report_id = nb.stem rec = manifest.get(report_id, {}) ex = extract_notebook(nb) if ex["n_code_cells"] == 0: continue # prose-only (e.g. Applications write-ups) — nothing to attach # write full reconstruction (OUT_MD / f"{report_id}.md").write_text(ex["content_md"], encoding="utf-8") attach = { "notebook_id": report_id, "title": ex["title"], "store": rec.get("store") or "CDS", "matched_dataset_id": rec.get("matched_dataset_id") or "", "raw_dataset_id": rec.get("dataset_id") or "", "category": rec.get("category") or "", "aspect": rec.get("aspect") or "", "match_confidence": rec.get("match_confidence") or "unmatched", "source_repo": SOURCE_REPO, "license": LICENSE, "src_path": rec.get("src_path") or str(nb.relative_to(REPO)), "md_path": str((OUT_MD / f"{report_id}.md").relative_to(ROOT.parent)), "n_code_cells": ex["n_code_cells"], "n_code_lines": ex["n_code_lines"], "recipe_kinds": ex["recipe_kinds"], } stats["notebooks"] += 1 stats["code_cells"] += ex["n_code_cells"] stats["code_lines"] += ex["n_code_lines"] stats["with_download"] += "download" in ex["recipe_kinds"] stats["with_analyze"] += "analyze" in ex["recipe_kinds"] stats["with_plot"] += "plot" in ex["recipe_kinds"] key = attach["matched_dataset_id"] if key: sidecar.setdefault(key, []).append(attach) else: unmatched.append(attach) stats["unmatched_notebooks"] += 1 stats["attached_datasets"] = len(sidecar) OUT_SIDECAR.write_text(json.dumps( {"by_dataset": sidecar, "unmatched": unmatched}, ensure_ascii=False, indent=2)) OUT_STATS.write_text(json.dumps(stats, indent=2)) log(f"notebooks with code : {stats['notebooks']}") log(f"code cells / lines : {stats['code_cells']} / {stats['code_lines']:,}") log(f"download/analyze/plot: {stats['with_download']}/{stats['with_analyze']}/{stats['with_plot']}") log(f"attached to datasets : {stats['attached_datasets']} (unmatched notebooks: {stats['unmatched_notebooks']})") log(f"-> {OUT_SIDECAR.relative_to(ROOT.parent)}, {OUT_MD.relative_to(ROOT.parent)}/*.md") if __name__ == "__main__": main()