| from __future__ import annotations |
|
|
| |
|
|
| import argparse |
| import csv |
| import os |
| import shutil |
| import sys |
| import re |
| from pathlib import Path |
|
|
| try: |
| from scripts.defextra_markers import ( |
| doi_suffix, |
| normalize_arxiv, |
| normalize_doi, |
| normalize_paper_id, |
| ) |
| from scripts.defextra_pdf_aliases import candidate_pdf_aliases |
| except ModuleNotFoundError as exc: |
| if exc.name != "scripts": |
| raise |
| PROJECT_ROOT = Path(__file__).resolve().parent.parent |
| if str(PROJECT_ROOT) not in sys.path: |
| sys.path.insert(0, str(PROJECT_ROOT)) |
| from scripts.defextra_markers import ( |
| doi_suffix, |
| normalize_arxiv, |
| normalize_doi, |
| normalize_paper_id, |
| ) |
| from scripts.defextra_pdf_aliases import candidate_pdf_aliases |
|
|
|
|
| def _build_pdf_index( |
| source_dirs: list[Path], |
| *, |
| skip_dir: Path | None = None, |
| ) -> dict[str, Path]: |
| index: dict[str, Path] = {} |
| version_re = re.compile(r"^(?P<base>.+?)(v\d+)$", re.IGNORECASE) |
| arxiv_re = re.compile(r"^(?P<base>\d{4}\.\d{4,5})v\d+$", re.IGNORECASE) |
| pii_re = re.compile(r"(S\d{8,})", re.IGNORECASE) |
| for source_dir in source_dirs: |
| if not source_dir.exists(): |
| continue |
| for suffix in ("*.pdf", "*.PDF"): |
| for path in source_dir.rglob(suffix): |
| if skip_dir is not None: |
| try: |
| path_abs = path.resolve() |
| except (OSError, RuntimeError): |
| path_abs = path.absolute() |
| if skip_dir == path_abs or skip_dir in path_abs.parents: |
| continue |
| stem = path.stem |
| for key in {stem, stem.lower()}: |
| index.setdefault(key, path) |
| if stem.startswith("paper_"): |
| stripped = stem[len("paper_") :] |
| if stripped: |
| index.setdefault(stripped, path) |
| index.setdefault(stripped.lower(), path) |
| if stem.endswith("_fixed") or stem.endswith("-fixed"): |
| base = ( |
| stem[: -len("_fixed")] |
| if stem.endswith("_fixed") |
| else stem[: -len("-fixed")] |
| ) |
| if base: |
| index[base] = path |
| index[base.lower()] = path |
| if base.startswith("paper_"): |
| stripped_base = base[len("paper_") :] |
| if stripped_base: |
| index[stripped_base] = path |
| index[stripped_base.lower()] = path |
| match = arxiv_re.match(stem) |
| if match: |
| base = match.group("base") |
| index.setdefault(base, path) |
| index.setdefault(base.lower(), path) |
| match = version_re.match(stem) |
| if match: |
| base = match.group("base") |
| index.setdefault(base, path) |
| index.setdefault(base.lower(), path) |
| pii_match = pii_re.search(stem) |
| if pii_match: |
| pii = pii_match.group(1) |
| index.setdefault(pii, path) |
| index.setdefault(pii.lower(), path) |
| return index |
|
|
|
|
| def _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]: |
| candidates = [] |
| if paper_id: |
| candidates.append(paper_id) |
| candidates.append(normalize_paper_id(paper_id)) |
| if doi: |
| norm_doi = normalize_doi(doi) |
| candidates.append(norm_doi) |
| candidates.append(doi_suffix(norm_doi)) |
| if arxiv: |
| norm_arxiv = normalize_arxiv(arxiv) |
| candidates.append(norm_arxiv) |
| ordered: list[str] = [] |
| seen = set() |
| for item in candidates: |
| value = (item or "").strip() |
| if not value: |
| continue |
| if value not in seen: |
| seen.add(value) |
| ordered.append(value) |
| for alias in candidate_pdf_aliases(paper_id, doi, arxiv): |
| value = (alias or "").strip() |
| if not value: |
| continue |
| if value not in seen: |
| seen.add(value) |
| ordered.append(value) |
| return ordered |
|
|
|
|
| def _normalize_title(title: str) -> str: |
| return " ".join(title.lower().split()) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="Build a test-only PDF folder for DefExtra hydration.", |
| ) |
| parser.add_argument( |
| "--legal-csv", |
| type=Path, |
| default=Path("results/paper_results/defextra_legal.csv"), |
| help="Legal DefExtra CSV with paper_ids.", |
| ) |
| parser.add_argument( |
| "--source-dir", |
| action="append", |
| type=Path, |
| default=[ |
| Path("ManualPDFsGROBID"), |
| Path("ManualPDFsGROBID/manual_pdfs/manual_pdfs"), |
| ], |
| help="Source PDF directory (can be repeated).", |
| ) |
| parser.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("ManualPDFsGROBID/test_pdfs"), |
| help="Output directory for test PDFs.", |
| ) |
| parser.add_argument( |
| "--mode", |
| choices=("symlink", "copy"), |
| default="symlink", |
| help="Whether to symlink or copy PDFs into the output dir.", |
| ) |
| parser.add_argument( |
| "--report", |
| type=Path, |
| default=None, |
| help="Optional report file listing missing PDFs.", |
| ) |
| args = parser.parse_args() |
|
|
| if not args.legal_csv.exists(): |
| raise SystemExit(f"Legal CSV not found: {args.legal_csv}") |
|
|
| pdf_index = _build_pdf_index( |
| args.source_dir, |
| skip_dir=args.output_dir.resolve(), |
| ) |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| missing: list[str] = [] |
| matched = 0 |
| seen_ids: set[str] = set() |
|
|
| with args.legal_csv.open("r", encoding="utf-8", newline="") as handle: |
| reader = csv.DictReader(handle) |
| rows = list(reader) |
|
|
| title_to_candidates: dict[str, list[str]] = {} |
| for row in rows: |
| title = _normalize_title(row.get("paper_title") or "") |
| if not title: |
| continue |
| paper_id = (row.get("paper_id") or "").strip() |
| doi = (row.get("paper_doi") or "").strip() |
| arxiv = (row.get("paper_arxiv") or "").strip() |
| candidates = _candidate_ids(paper_id, doi, arxiv) |
| if candidates: |
| title_to_candidates.setdefault(title, []).extend(candidates) |
|
|
| for row in rows: |
| paper_id = (row.get("paper_id") or "").strip() |
| if not paper_id or paper_id in seen_ids: |
| continue |
| seen_ids.add(paper_id) |
| doi = (row.get("paper_doi") or "").strip() |
| arxiv = (row.get("paper_arxiv") or "").strip() |
| title_key = _normalize_title(row.get("paper_title") or "") |
| path = None |
| for candidate in _candidate_ids(paper_id, doi, arxiv): |
| key = candidate.lower() |
| path = pdf_index.get(key) or pdf_index.get(f"paper_{key}") |
| if path is not None: |
| break |
| if path is None and title_key in title_to_candidates: |
| for candidate in title_to_candidates[title_key]: |
| key = candidate.lower() |
| path = pdf_index.get(key) or pdf_index.get(f"paper_{key}") |
| if path is not None: |
| break |
| if path is None: |
| missing.append(paper_id) |
| continue |
|
|
| dest_id = normalize_paper_id(paper_id) or paper_id |
| dest = args.output_dir / f"{dest_id}.pdf" |
| if dest.is_symlink(): |
| try: |
| current = dest.resolve(strict=True) |
| except (OSError, RuntimeError): |
| current = None |
| if current is None or current != path.resolve(): |
| dest.unlink() |
| else: |
| matched += 1 |
| continue |
| elif dest.exists(): |
| matched += 1 |
| continue |
|
|
| if args.mode == "copy": |
| shutil.copy2(path, dest) |
| else: |
| |
| rel = Path(os.path.relpath(path, start=dest.parent)) |
| dest.symlink_to(rel) |
| matched += 1 |
|
|
| print(f"Matched PDFs: {matched}") |
| print(f"Missing PDFs: {len(missing)}") |
| if missing: |
| print("Missing IDs (first 20):", ", ".join(missing[:20])) |
|
|
| if args.report is not None: |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text("\n".join(missing) + "\n", encoding="utf-8") |
| print(f"Wrote report to {args.report}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
