| |
| """Validate that every file under data/ contains real diff content. |
| |
| A file is valid when, for each `=== <url> ===` section (or for the whole |
| body if there is no separator), the section contains `diff --git ` at |
| column 0 OR starts with `From <sha40> Mon Sep 17 00:00:00 2001`. |
| |
| Invalid files and the reason are written to .logs/invalid_diffs.tsv and |
| printed as a summary on stdout. |
| |
| Usage: |
| python validate_diffs.py [DATA_DIR] |
| |
| If DATA_DIR is omitted, defaults to ./data next to this script. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import pathlib |
| import re |
| import sys |
| from collections import Counter |
|
|
|
|
| SCRIPT_DIR = pathlib.Path(__file__).resolve().parent |
| DEFAULT_DATA_DIR = SCRIPT_DIR / "data" |
| LOG_DIR = SCRIPT_DIR / ".logs" |
|
|
| _DIFF_GIT_RE = re.compile(rb"^diff --git ", re.M) |
| _GIT_FORMAT_PATCH_RE = re.compile(rb"^From [0-9a-f]{40} Mon Sep ") |
| _SECTION_SEP_RE = re.compile(rb"^=== (.+?) ===$", re.M) |
| _HTML_HINT_RE = re.compile(rb"<(?:html|head|body|!doctype)\b", re.I) |
|
|
|
|
| def looks_like_diff(body: bytes) -> bool: |
| if not body: |
| return False |
| if _DIFF_GIT_RE.search(body): |
| return True |
| return bool(_GIT_FORMAT_PATCH_RE.match(body.split(b"\n", 1)[0])) |
|
|
|
|
| def classify_bad(body: bytes) -> str: |
| """Return a short reason describing why `body` is not a diff.""" |
| if not body: |
| return "empty file" |
| stripped = body.strip() |
| if not stripped: |
| return "whitespace only" |
| head = body[:4096] |
| if _HTML_HINT_RE.search(head): |
| title = re.search(rb"<title[^>]*>(.*?)</title>", head, re.I | re.S) |
| if title: |
| t = title.group(1).strip().decode("utf-8", "replace")[:120] |
| return f"HTML page (title: {t!r})" |
| return "HTML page" |
| if head.lstrip().startswith((b"{", b"[")): |
| return "JSON payload (likely API error)" |
| if b"Not Found" in head or b"404" in head[:200]: |
| return "looks like 404 / not-found text" |
| if b"Rate limit" in head or b"rate limit" in head: |
| return "rate-limit message" |
| try: |
| text_preview = head.decode("utf-8") |
| except UnicodeDecodeError: |
| return f"binary / non-utf8 content ({len(body)} B)" |
| snippet = " ".join(text_preview.split())[:120] |
| return f"no `diff --git` and no git-format-patch header; starts with: {snippet!r}" |
|
|
|
|
| def validate_file(path: pathlib.Path) -> list[str]: |
| """Return a list of reasons why `path` is invalid (empty list = OK).""" |
| try: |
| body = path.read_bytes() |
| except OSError as e: |
| return [f"unreadable: {e}"] |
|
|
| if not body: |
| return ["empty file"] |
|
|
| sep_matches = list(_SECTION_SEP_RE.finditer(body)) |
| if not sep_matches: |
| if looks_like_diff(body): |
| return [] |
| return [classify_bad(body)] |
|
|
| reasons: list[str] = [] |
| for i, m in enumerate(sep_matches): |
| url = m.group(1).decode("utf-8", "replace") |
| start = m.end() + 1 |
| end = sep_matches[i + 1].start() if i + 1 < len(sep_matches) else len(body) |
| section = body[start:end] |
| if not looks_like_diff(section): |
| reasons.append(f"section {i + 1} ({url}): {classify_bad(section)}") |
| return reasons |
|
|
|
|
| def main() -> int: |
| data_dir = pathlib.Path(sys.argv[1]) if len(sys.argv) > 1 else DEFAULT_DATA_DIR |
| if not data_dir.is_dir(): |
| print(f"error: {data_dir} is not a directory", file=sys.stderr) |
| return 2 |
|
|
| LOG_DIR.mkdir(parents=True, exist_ok=True) |
| log_path = LOG_DIR / "invalid_diffs.tsv" |
|
|
| files = sorted(p for p in data_dir.rglob("*") if p.is_file()) |
| print(f"[scan] {len(files)} file(s) under {data_dir}", file=sys.stderr) |
|
|
| invalid = 0 |
| reason_counts: Counter[str] = Counter() |
| with open(log_path, "w", encoding="utf-8") as log: |
| log.write("path\treason\n") |
| for path in files: |
| reasons = validate_file(path) |
| if not reasons: |
| continue |
| invalid += 1 |
| rel = path.relative_to(data_dir) |
| for r in reasons: |
| |
| head = r.split(":", 1)[0].split(";", 1)[0][:80] |
| reason_counts[head] += 1 |
| log.write(f"{rel}\t{r}\n") |
|
|
| ok = len(files) - invalid |
| print(f"[done] ok={ok} invalid={invalid} log={log_path}", file=sys.stderr) |
| if reason_counts: |
| print("[summary] top reasons:", file=sys.stderr) |
| for reason, n in reason_counts.most_common(10): |
| print(f" {n:>6} {reason}", file=sys.stderr) |
| return 1 if invalid else 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
