| """Run griffe.find_breaking_changes on every pair in pairs.csv. |
| |
| Usage: griffe-venv/bin/python -I run_griffe.py <workdir> [ids...] |
| Per pair: download+unpack both releases (fetch.py) into separate dirs, griffe.load each |
| top-level package with search_paths=[that dir] only, diff, append rows to griffe_changes.csv |
| and runs.csv. Each pair runs in a child process with a timeout. |
| """ |
| import csv, json, multiprocessing as mp, shutil, sys, time, traceback |
| from pathlib import Path |
|
|
| HERE = Path(__file__).resolve().parent |
| OUT = HERE.parent |
| sys.path.insert(0, str(HERE)) |
| import fetch |
|
|
| CH_FIELDS = ["id", "project", "from_version", "to_version", "path", "change_type", "param", "tool_label", "breaking", "raw"] |
| RUN_FIELDS = ["tool", "tool_version", "id", "project", "status", "seconds", "notes"] |
| TIMEOUT = 900 |
|
|
|
|
| def append(path, fields, rows): |
| new = not path.exists() |
| with open(path, "a", newline="") as f: |
| w = csv.DictWriter(f, fieldnames=fields) |
| if new: |
| w.writeheader() |
| w.writerows(rows) |
|
|
|
|
| def map_breakage(b, griffe): |
| K = griffe.BreakageKind |
| k = b.kind |
| param = "" |
| ct = "other" |
| if k == K.OBJECT_REMOVED: |
| ct = "removed" |
| elif k == K.PARAMETER_REMOVED: |
| param = b.old_value.name |
| kind = str(b.old_value.kind.value) |
| ct = {"variadic positional": "vararg_removed", "variadic keyword": "varkw_removed"}.get(kind, "param_removed") |
| elif k == K.PARAMETER_ADDED_REQUIRED: |
| param = b.new_value.name |
| ct = "required_param_added" |
| elif k == K.PARAMETER_CHANGED_REQUIRED: |
| param = b.old_value.name |
| ct = "default_removed" |
| elif k == K.PARAMETER_MOVED: |
| param = b.old_value.name |
| ct = "positional_reordered" |
| elif k == K.PARAMETER_CHANGED_KIND: |
| param = b.old_value.name |
| nk = str(b.new_value.kind.value) |
| ct = {"keyword-only": "became_keyword_only", "positional-only": "became_positional_only"}.get(nk, "other") |
| elif k == K.PARAMETER_CHANGED_DEFAULT: |
| param = b.old_value.name |
| path = b.obj.path |
| |
| def short(v): |
| if v is None: |
| return "None" |
| if hasattr(v, "name") and hasattr(v, "kind") and hasattr(v, "default"): |
| return f"{v.name}:{v.kind.value}" + (f"={v.default}" if v.default is not None else "") |
| if hasattr(v, "path"): |
| return f"{getattr(v, 'kind', '')}:{v.path}" |
| return str(v) |
| raw = f"{k.value}: {path}" + (f" [{param}]" if param else "") + f" old={short(b.old_value)!s:.80} new={short(b.new_value)!s:.80}" |
| raw = " ".join(str(raw).split())[:300] |
| return dict(path=path, change_type=ct, param=param, tool_label=k.name, breaking="yes", raw=raw) |
|
|
|
|
| def child(pair, work, q): |
| import griffe |
| try: |
| t0 = time.time() |
| a, fa, ta = fetch.fetch(pair["project"], pair["from_version"], work / "old") |
| b, fb, tb = fetch.fetch(pair["project"], pair["to_version"], work / "new") |
| t1 = time.time() |
| pkgs = sorted(n for n in set(ta) & set(tb) if not n.startswith("_")) or sorted(set(ta) & set(tb)) |
| gone = sorted(set(ta) - set(tb)) |
| rows, errs = [], [] |
| |
| |
| loaders = {} |
| for side, root, names in (("old", a, ta), ("new", b, tb)): |
| ld = griffe.GriffeLoader(search_paths=[str(root)], allow_inspection=False) |
| for name in names: |
| try: |
| ld.load(name) |
| except Exception as e: |
| errs.append(f"{side}:{name}: {type(e).__name__}: {e}"[:200]) |
| try: |
| ld.resolve_aliases(implicit=False, external=False) |
| except Exception as e: |
| errs.append(f"{side}: resolve_aliases {type(e).__name__}: {e}"[:200]) |
| loaders[side] = ld |
| for name in pkgs: |
| try: |
| old = loaders["old"].modules_collection[name] |
| new = loaders["new"].modules_collection[name] |
| for br in griffe.find_breaking_changes(old, new): |
| rows.append(map_breakage(br, griffe)) |
| except Exception as e: |
| errs.append(f"{name}: {type(e).__name__}: {e}"[:200]) |
| t2 = time.time() |
| q.put(dict(ok=not (errs and not rows and len(errs) == len(pkgs)), rows=rows, |
| notes=f"artifacts={fa} | {fb}; packages={','.join(pkgs)}; fetch_s={t1-t0:.1f}; analysis_s={t2-t1:.1f}" |
| + (f"; top-level only in old (not reported by griffe): {','.join(gone)}" if gone else "") |
| + (f"; errors: {' / '.join(errs)}" if errs else ""))) |
| except Exception as e: |
| q.put(dict(ok=False, rows=[], notes=f"{type(e).__name__}: {e}"[:300] + " " + traceback.format_exc(limit=2).replace("\n", " ")[:300])) |
|
|
|
|
| def main(): |
| work_root = Path(sys.argv[1]) |
| only = set(sys.argv[2:]) |
| import importlib.metadata as md |
| ver = md.version("griffe") |
| pairs = list(csv.DictReader(open(OUT / "pairs.csv"))) |
| for p in pairs: |
| if only and p["id"] not in only: |
| continue |
| work = work_root / f"griffe_{p['id']}" |
| work.mkdir(parents=True, exist_ok=True) |
| q = mp.Queue() |
| t0 = time.time() |
| proc = mp.Process(target=child, args=(p, work, q)) |
| proc.start() |
| res = None |
| try: |
| res = q.get(timeout=TIMEOUT) |
| except Exception: |
| pass |
| proc.join(10) |
| if proc.is_alive(): |
| proc.kill() |
| secs = time.time() - t0 |
| if res is None: |
| res = dict(ok=False, rows=[], notes=f"timeout after {TIMEOUT}s") |
| base = {k: p[k] for k in ("id", "project", "from_version", "to_version")} |
| append(OUT / "griffe_changes.csv", CH_FIELDS, [{**base, **r} for r in res["rows"]]) |
| append(OUT / "runs.csv", RUN_FIELDS, [dict(tool="griffe", tool_version=ver, id=p["id"], project=p["project"], |
| status="ok" if res["ok"] else "failed", seconds=f"{secs:.1f}", |
| notes=f"changes={len(res['rows'])}; " + res["notes"])]) |
| print(p["id"], p["project"], "ok" if res["ok"] else "FAILED", len(res["rows"]), f"{secs:.1f}s", flush=True) |
| shutil.rmtree(work, ignore_errors=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
