| |
| """Resolve arXiv resources to verified conference or journal versions.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import html |
| import json |
| import re |
| import ssl |
| import sys |
| import time |
| import unicodedata |
| import urllib.error |
| import urllib.request |
| from datetime import datetime, timezone |
| from difflib import SequenceMatcher |
| from pathlib import Path |
| from urllib.parse import quote, urlencode, urlparse |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| SOURCE_AUDIT = ROOT / "data" / "resource_source_audit.csv" |
| OUTPUT = ROOT / "data" / "arxiv_publication_audit.csv" |
| VERIFIED_OVERRIDES = ROOT / "data" / "arxiv_publication_overrides.csv" |
| USER_AGENT = "awesome-loop-engineering-publication-resolver/1.0 (https://github.com/ChaoYue0307/awesome-loop-engineering)" |
| DBLP_API = "https://dblp.uni-trier.de/search/publ/api" |
|
|
| FIELDS = [ |
| "row_id", |
| "arxiv_id", |
| "resource_title", |
| "arxiv_title", |
| "arxiv_year", |
| "status", |
| "published_title", |
| "publication_date", |
| "publication_year", |
| "publication_venue", |
| "publisher", |
| "doi", |
| "published_url", |
| "record_url", |
| "metadata_source", |
| "match_score", |
| "checked_on", |
| ] |
|
|
| PUBLISHED_DBLP_TYPES = { |
| "Conference and Workshop Papers", |
| "Journal Articles", |
| "Parts in Books or Collections", |
| } |
| PUBLISHED_CROSSREF_TYPES = { |
| "book-chapter", |
| "journal-article", |
| "proceedings-article", |
| "reference-entry", |
| } |
| PREPRINT_VENUES = {"", "corr", "arxiv"} |
|
|
| VENUE_NAMES = { |
| "AAAI": "AAAI Conference on Artificial Intelligence", |
| "ACL": "Annual Meeting of the Association for Computational Linguistics (ACL)", |
| "CHI": "ACM CHI Conference on Human Factors in Computing Systems", |
| "COLM": "Conference on Language Modeling (COLM)", |
| "EACL": "Conference of the European Chapter of the Association for Computational Linguistics (EACL)", |
| "EMNLP": "Conference on Empirical Methods in Natural Language Processing (EMNLP)", |
| "ICLR": "International Conference on Learning Representations (ICLR)", |
| "ICML": "International Conference on Machine Learning (ICML)", |
| "IJCAI": "International Joint Conference on Artificial Intelligence (IJCAI)", |
| "NAACL": "Conference of the North American Chapter of the Association for Computational Linguistics (NAACL)", |
| "NeurIPS": "Advances in Neural Information Processing Systems (NeurIPS)", |
| "TMLR": "Transactions on Machine Learning Research", |
| } |
|
|
| PUBLISHER_BY_HOST = { |
| "aclanthology.org": "Association for Computational Linguistics", |
| "dl.acm.org": "Association for Computing Machinery", |
| "ieeexplore.ieee.org": "IEEE", |
| "jmlr.org": "JMLR.org", |
| "openreview.net": "OpenReview", |
| "ojs.aaai.org": "AAAI Press", |
| "papers.nips.cc": "Neural Information Processing Systems Foundation", |
| "proceedings.mlr.press": "PMLR", |
| "link.springer.com": "Springer", |
| "usenix.org": "USENIX Association", |
| } |
|
|
|
|
| def clean(value: object) -> str: |
| if value is None: |
| return "" |
| return " ".join(html.unescape(str(value)).strip().split()) |
|
|
|
|
| def normalize_doi(value: object) -> str: |
| doi = clean(value) |
| for prefix in ("https://doi.org/", "http://doi.org/", "doi:"): |
| if doi.lower().startswith(prefix): |
| doi = doi[len(prefix) :] |
| break |
| if doi.lower().startswith("10.48550/arxiv."): |
| return "" |
| return doi |
|
|
|
|
| def normalize_title(value: object) -> str: |
| title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", clean(value)) |
| title = re.sub(r"<[^>]+>", " ", title) |
| title = unicodedata.normalize("NFKD", title).encode("ascii", "ignore").decode("ascii") |
| return " ".join(re.findall(r"[a-z0-9]+", title.lower())) |
|
|
|
|
| def title_match(left: str, right: str) -> tuple[float, float]: |
| left_norm = normalize_title(left) |
| right_norm = normalize_title(right) |
| ratio = SequenceMatcher(None, left_norm, right_norm).ratio() |
| left_tokens = set(left_norm.split()) |
| right_tokens = set(right_norm.split()) |
| union = left_tokens | right_tokens |
| jaccard = len(left_tokens & right_tokens) / len(union) if union else 0.0 |
| return ratio, jaccard |
|
|
|
|
| def surname(value: str) -> str: |
| parts = re.findall(r"[a-z]+", unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode("ascii").lower()) |
| while parts and parts[-1].isdigit(): |
| parts.pop() |
| return parts[-1] if parts else "" |
|
|
|
|
| def author_overlap(source_authors: str, candidate_authors: list[str]) -> bool: |
| source = {surname(author) for author in source_authors.split(";") if surname(author)} |
| candidate = {surname(author) for author in candidate_authors if surname(author)} |
| return bool(source & candidate) |
|
|
|
|
| def json_request( |
| url: str, |
| timeout: float, |
| attempts: int = 3, |
| cache_path: Path | None = None, |
| offline: bool = False, |
| ) -> dict[str, object]: |
| if cache_path and cache_path.exists(): |
| try: |
| return json.loads(cache_path.read_text(encoding="utf-8")) |
| except json.JSONDecodeError: |
| return {} |
| if offline: |
| return {} |
| context = ssl._create_unverified_context() |
| request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept": "application/json"}) |
| for attempt in range(1, attempts + 1): |
| try: |
| with urllib.request.urlopen(request, timeout=timeout, context=context) as response: |
| return json.loads(response.read().decode("utf-8")) |
| except ( |
| urllib.error.URLError, |
| urllib.error.HTTPError, |
| ConnectionError, |
| TimeoutError, |
| json.JSONDecodeError, |
| ): |
| if attempt == attempts: |
| return {} |
| time.sleep(attempt) |
| return {} |
|
|
|
|
| def list_value(value: object) -> list[object]: |
| if value in (None, ""): |
| return [] |
| return value if isinstance(value, list) else [value] |
|
|
|
|
| def dblp_authors(info: dict[str, object]) -> list[str]: |
| authors = info.get("authors") or {} |
| if not isinstance(authors, dict): |
| return [] |
| values = list_value(authors.get("author")) |
| result = [] |
| for value in values: |
| if isinstance(value, dict): |
| result.append(clean(value.get("text"))) |
| else: |
| result.append(clean(value)) |
| return [value for value in result if value] |
|
|
|
|
| def choose_official_url(info: dict[str, object], doi: str) -> str: |
| if doi: |
| return f"https://doi.org/{doi}" |
| electronic_editions = [clean(value) for value in list_value(info.get("ee"))] |
| electronic_editions = [ |
| value |
| for value in electronic_editions |
| if value and "arxiv.org" not in value.lower() and "10.48550/arxiv" not in value.lower() |
| ] |
| preferred_hosts = tuple(PUBLISHER_BY_HOST) |
| for value in electronic_editions: |
| if urlparse(value).netloc.lower() in preferred_hosts: |
| return value |
| return electronic_editions[0] if electronic_editions else clean(info.get("url")) |
|
|
|
|
| def publication_year_from_crossref(message: dict[str, object]) -> str: |
| for field in ("published-print", "published-online", "published", "issued"): |
| value = message.get(field) |
| if not isinstance(value, dict): |
| continue |
| parts = value.get("date-parts") |
| if isinstance(parts, list) and parts and isinstance(parts[0], list) and parts[0]: |
| return str(parts[0][0]) |
| return "" |
|
|
|
|
| def publication_date_from_crossref(message: dict[str, object]) -> str: |
| for field in ("published-print", "published-online", "published", "issued"): |
| value = message.get(field) |
| if not isinstance(value, dict): |
| continue |
| parts = value.get("date-parts") |
| if not isinstance(parts, list) or not parts or not isinstance(parts[0], list) or not parts[0]: |
| continue |
| date_parts = parts[0] |
| if len(date_parts) >= 3: |
| return f"{int(date_parts[0]):04d}-{int(date_parts[1]):02d}-{int(date_parts[2]):02d}" |
| return str(date_parts[0]) |
| return "" |
|
|
|
|
| def crossref_message_for_doi( |
| doi: str, |
| timeout: float, |
| cache_path: Path | None = None, |
| offline: bool = False, |
| ) -> dict[str, object]: |
| if not doi: |
| return {} |
| payload = json_request( |
| f"https://api.crossref.org/works/{quote(doi, safe='')}", |
| timeout, |
| cache_path=cache_path, |
| offline=offline, |
| ) |
| message = payload.get("message") |
| return message if isinstance(message, dict) else {} |
|
|
|
|
| def display_venue(venue: str, year: str, crossref: dict[str, object]) -> str: |
| crossref_type = clean(crossref.get("type")) |
| container = next((clean(value) for value in list_value(crossref.get("container-title")) if clean(value)), "") |
| event = crossref.get("event") or {} |
| event_name = clean(event.get("name")) if isinstance(event, dict) else "" |
| if crossref_type == "journal-article" and container: |
| base = container |
| elif event_name: |
| base = event_name |
| else: |
| base = VENUE_NAMES.get(venue, venue) |
| if year and year not in base: |
| return f"{base} {year}" |
| return base |
|
|
|
|
| def publisher_for(url: str, venue: str, crossref: dict[str, object]) -> str: |
| publisher = clean(crossref.get("publisher")) |
| if publisher: |
| return publisher |
| host = urlparse(url).netloc.lower().removeprefix("www.") |
| for domain, name in PUBLISHER_BY_HOST.items(): |
| if host == domain or host.endswith(f".{domain}"): |
| return name |
| if venue in {"ACL", "EACL", "EMNLP", "NAACL"}: |
| return "Association for Computational Linguistics" |
| if venue == "AAAI": |
| return "AAAI Press" |
| if venue == "NeurIPS": |
| return "Neural Information Processing Systems Foundation" |
| if venue in {"ICML"}: |
| return "PMLR" |
| if venue in {"ICLR", "TMLR", "COLM"}: |
| return "OpenReview" |
| return venue |
|
|
|
|
| def published_dblp_candidate( |
| row: dict[str, str], |
| timeout: float, |
| cache_dir: Path | None = None, |
| offline: bool = False, |
| ) -> dict[str, str] | None: |
| query_title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", row["source_title"]) or row["title"] |
| params = urlencode({"q": query_title, "format": "json", "h": "30"}) |
| cache_path = cache_dir / "dblp" / f"{row['arxiv_id']}.json" if cache_dir else None |
| payload = json_request( |
| f"{DBLP_API}?{params}", |
| timeout, |
| cache_path=cache_path, |
| offline=offline, |
| ) |
| result = payload.get("result") or {} |
| hits = result.get("hits") or {} if isinstance(result, dict) else {} |
| values = list_value(hits.get("hit")) if isinstance(hits, dict) else [] |
| candidates: list[tuple[tuple[float, ...], dict[str, object], float]] = [] |
|
|
| for value in values: |
| if not isinstance(value, dict) or not isinstance(value.get("info"), dict): |
| continue |
| info = value["info"] |
| venue = clean(info.get("venue")) |
| kind = clean(info.get("type")) |
| if venue.lower() in PREPRINT_VENUES or kind not in PUBLISHED_DBLP_TYPES: |
| continue |
| candidate_title = clean(info.get("title")).rstrip(".") |
| ratio, jaccard = title_match(query_title, candidate_title) |
| authors_match = author_overlap(row["authors"], dblp_authors(info)) |
| exact = normalize_title(query_title) == normalize_title(candidate_title) |
| accepted = exact or (ratio >= 0.94 and jaccard >= 0.82 and authors_match) |
| if not accepted: |
| continue |
| doi = normalize_doi(info.get("doi")) |
| score = (float(exact), ratio, jaccard, float(authors_match), float(bool(doi))) |
| candidates.append((score, info, ratio)) |
|
|
| if not candidates: |
| return None |
|
|
| _, info, score = max(candidates, key=lambda candidate: candidate[0]) |
| venue = clean(info.get("venue")) |
| year = clean(info.get("year")) |
| doi = normalize_doi(info.get("doi")) |
| crossref_path = cache_dir / "crossref-doi" / f"{row['arxiv_id']}.json" if cache_dir else None |
| crossref = crossref_message_for_doi(doi, timeout, crossref_path, offline) |
| if crossref: |
| published_title = next((clean(value) for value in list_value(crossref.get("title")) if clean(value)), "") |
| if published_title and title_match(query_title, published_title)[0] < 0.90: |
| crossref = {} |
| official_url = choose_official_url(info, doi) |
| crossref_year = publication_year_from_crossref(crossref) |
| year = crossref_year or year |
| return { |
| "published_title": clean(info.get("title")).rstrip("."), |
| "publication_date": publication_date_from_crossref(crossref) or year, |
| "publication_year": year, |
| "publication_venue": display_venue(venue, year, crossref), |
| "publisher": publisher_for(official_url, venue, crossref), |
| "doi": doi, |
| "published_url": official_url, |
| "record_url": clean(info.get("url")), |
| "metadata_source": "DBLP API + primary publication record", |
| "match_score": f"{score:.3f}", |
| } |
|
|
|
|
| def crossref_authors(message: dict[str, object]) -> list[str]: |
| values = list_value(message.get("author")) |
| result = [] |
| for value in values: |
| if not isinstance(value, dict): |
| continue |
| result.append(clean(f"{clean(value.get('given'))} {clean(value.get('family'))}")) |
| return [value for value in result if value] |
|
|
|
|
| def published_crossref_candidate( |
| row: dict[str, str], |
| timeout: float, |
| cache_dir: Path | None = None, |
| offline: bool = False, |
| ) -> dict[str, str] | None: |
| query_title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", row["source_title"]) or row["title"] |
| params = urlencode({"query.title": query_title, "rows": "8"}) |
| cache_path = cache_dir / "crossref-search" / f"{row['arxiv_id']}.json" if cache_dir else None |
| payload = json_request( |
| f"https://api.crossref.org/works?{params}", |
| timeout, |
| cache_path=cache_path, |
| offline=offline, |
| ) |
| message = payload.get("message") or {} |
| items = list_value(message.get("items")) if isinstance(message, dict) else [] |
| candidates: list[tuple[tuple[float, ...], dict[str, object], float]] = [] |
| for item in items: |
| if not isinstance(item, dict) or clean(item.get("type")) not in PUBLISHED_CROSSREF_TYPES: |
| continue |
| candidate_title = next((clean(value) for value in list_value(item.get("title")) if clean(value)), "") |
| ratio, jaccard = title_match(query_title, candidate_title) |
| authors_match = author_overlap(row["authors"], crossref_authors(item)) |
| exact = normalize_title(query_title) == normalize_title(candidate_title) |
| if not (exact or (ratio >= 0.97 and jaccard >= 0.90 and authors_match)): |
| continue |
| doi = normalize_doi(item.get("DOI")) |
| if not doi: |
| continue |
| candidates.append(((float(exact), ratio, jaccard, float(authors_match)), item, ratio)) |
|
|
| if not candidates: |
| return None |
| _, item, score = max(candidates, key=lambda candidate: candidate[0]) |
| year = publication_year_from_crossref(item) |
| container = next((clean(value) for value in list_value(item.get("container-title")) if clean(value)), "") |
| event = item.get("event") or {} |
| event_name = clean(event.get("name")) if isinstance(event, dict) else "" |
| venue = event_name or container |
| if year and year not in venue: |
| venue = f"{venue} {year}" |
| doi = normalize_doi(item.get("DOI")) |
| official_url = f"https://doi.org/{doi}" |
| return { |
| "published_title": next((clean(value) for value in list_value(item.get("title")) if clean(value)), ""), |
| "publication_date": publication_date_from_crossref(item) or year, |
| "publication_year": year, |
| "publication_venue": venue, |
| "publisher": publisher_for(official_url, "", item), |
| "doi": doi, |
| "published_url": official_url, |
| "record_url": official_url, |
| "metadata_source": "Crossref API + DOI record", |
| "match_score": f"{score:.3f}", |
| } |
|
|
|
|
| def existing_publication_candidate( |
| row: dict[str, str], |
| timeout: float, |
| cache_dir: Path | None = None, |
| offline: bool = False, |
| ) -> dict[str, str] | None: |
| venue = clean(row.get("publication_venue")) |
| if venue.lower() in PREPRINT_VENUES: |
| return None |
| doi = normalize_doi(row.get("doi")) |
| crossref_path = cache_dir / "crossref-doi" / f"{row['arxiv_id']}.json" if cache_dir else None |
| crossref = crossref_message_for_doi(doi, timeout, crossref_path, offline) |
| year = publication_year_from_crossref(crossref) or clean(row.get("publication_year")) |
| published_url = f"https://doi.org/{doi}" if doi else clean(row.get("url")) |
| return { |
| "published_title": re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", clean(row.get("source_title"))) or clean(row.get("title")), |
| "publication_date": publication_date_from_crossref(crossref) or year, |
| "publication_year": year, |
| "publication_venue": display_venue(venue, year, crossref), |
| "publisher": publisher_for(published_url, venue, crossref), |
| "doi": doi, |
| "published_url": published_url, |
| "record_url": clean(row.get("url")), |
| "metadata_source": "arXiv journal reference" + (" + DOI record" if crossref else ""), |
| "match_score": "1.000", |
| } |
|
|
|
|
| def base_output(row: dict[str, str], checked_on: str) -> dict[str, str]: |
| arxiv_title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", clean(row.get("source_title"))) or clean(row.get("title")) |
| return { |
| "row_id": clean(row.get("row_id")), |
| "arxiv_id": clean(row.get("arxiv_id")), |
| "resource_title": clean(row.get("title")), |
| "arxiv_title": arxiv_title, |
| "arxiv_year": clean(row.get("publication_year")), |
| "status": "preprint-only", |
| "published_title": "", |
| "publication_date": "", |
| "publication_year": "", |
| "publication_venue": "", |
| "publisher": "", |
| "doi": "", |
| "published_url": "", |
| "record_url": "", |
| "metadata_source": "DBLP and Crossref exact-title audit", |
| "match_score": "", |
| "checked_on": checked_on, |
| } |
|
|
|
|
| def read_source_rows() -> list[dict[str, str]]: |
| with SOURCE_AUDIT.open(encoding="utf-8", newline="") as handle: |
| return [row for row in csv.DictReader(handle) if row.get("arxiv_id")] |
|
|
|
|
| def read_existing() -> dict[str, dict[str, str]]: |
| if not OUTPUT.exists(): |
| return {} |
| with OUTPUT.open(encoding="utf-8", newline="") as handle: |
| return {row["arxiv_id"]: row for row in csv.DictReader(handle)} |
|
|
|
|
| def read_verified_overrides() -> dict[str, dict[str, str]]: |
| if not VERIFIED_OVERRIDES.exists(): |
| return {} |
| with VERIFIED_OVERRIDES.open(encoding="utf-8", newline="") as handle: |
| return {row["arxiv_id"]: row for row in csv.DictReader(handle)} |
|
|
|
|
| def verified_candidate(row: dict[str, str], overrides: dict[str, dict[str, str]]) -> dict[str, str] | None: |
| override = overrides.get(row["arxiv_id"]) |
| if not override: |
| return None |
| return { |
| "status": override["status"], |
| "published_title": re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", clean(row.get("source_title"))) or clean(row.get("title")), |
| "publication_date": override["publication_date"], |
| "publication_year": override["publication_year"], |
| "publication_venue": override["publication_venue"], |
| "publisher": override["publisher"], |
| "doi": normalize_doi(override["doi"]), |
| "published_url": override["published_url"], |
| "record_url": override["record_url"], |
| "metadata_source": override["metadata_source"], |
| "match_score": "1.000", |
| } |
|
|
|
|
| def resolve_row( |
| row: dict[str, str], |
| timeout: float, |
| delay: float, |
| cache_dir: Path | None, |
| offline: bool, |
| overrides: dict[str, dict[str, str]], |
| ) -> dict[str, str] | None: |
| candidate = verified_candidate(row, overrides) |
| if candidate: |
| return candidate |
| candidate = published_dblp_candidate(row, timeout, cache_dir, offline) |
| if delay: |
| time.sleep(delay) |
| if candidate: |
| return candidate |
| candidate = published_crossref_candidate(row, timeout, cache_dir, offline) |
| if delay: |
| time.sleep(delay) |
| return candidate or existing_publication_candidate(row, timeout, cache_dir, offline) |
|
|
|
|
| def dblp_query(row: dict[str, str]) -> str: |
| query_title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", row["source_title"]) or row["title"] |
| return f"{DBLP_API}?{urlencode({'q': query_title, 'format': 'json', 'h': '30'})}" |
|
|
|
|
| def crossref_search_query(row: dict[str, str]) -> str: |
| query_title = re.sub(r"^\[\d{4}\.\d{4,5}\]\s*", "", row["source_title"]) or row["title"] |
| return f"https://api.crossref.org/works?{urlencode({'query.title': query_title, 'rows': '8'})}" |
|
|
|
|
| def write_curl_config(path: Path, requests: list[tuple[str, Path]]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| lines: list[str] = [ |
| "location", |
| "silent", |
| "show-error", |
| "retry = 2", |
| "connect-timeout = 15", |
| "max-time = 45", |
| ] |
| for url, output in requests: |
| output.parent.mkdir(parents=True, exist_ok=True) |
| lines.extend( |
| [ |
| f'output = "{output}"', |
| f'url = "{url}"', |
| ] |
| ) |
| path.write_text("\n".join(lines) + "\n", encoding="utf-8") |
|
|
|
|
| def write_dblp_curl_config(path: Path, cache_dir: Path, rows: list[dict[str, str]]) -> None: |
| requests = [(dblp_query(row), cache_dir / "dblp" / f"{row['arxiv_id']}.json") for row in rows] |
| write_curl_config(path, requests) |
| print(f"Wrote {len(requests)} DBLP requests to {path}.") |
|
|
|
|
| def write_crossref_curl_config(path: Path, cache_dir: Path, rows: list[dict[str, str]], timeout: float) -> None: |
| requests: list[tuple[str, Path]] = [] |
| for row in rows: |
| dblp_candidate = published_dblp_candidate(row, timeout, cache_dir, offline=True) |
| doi = normalize_doi(dblp_candidate.get("doi")) if dblp_candidate else "" |
| if not doi: |
| doi = normalize_doi(row.get("doi")) |
| if doi: |
| requests.append( |
| ( |
| f"https://api.crossref.org/works/{quote(doi, safe='')}", |
| cache_dir / "crossref-doi" / f"{row['arxiv_id']}.json", |
| ) |
| ) |
| if not dblp_candidate: |
| requests.append( |
| ( |
| crossref_search_query(row), |
| cache_dir / "crossref-search" / f"{row['arxiv_id']}.json", |
| ) |
| ) |
| write_curl_config(path, requests) |
| print(f"Wrote {len(requests)} Crossref requests to {path}.") |
|
|
|
|
| def validate_snapshot( |
| rows: list[dict[str, str]], |
| source_rows: list[dict[str, str]], |
| overrides: dict[str, dict[str, str]], |
| ) -> list[str]: |
| failures: list[str] = [] |
| expected = {row["arxiv_id"] for row in source_rows} |
| actual = {row["arxiv_id"] for row in rows} |
| by_id = {row["arxiv_id"]: row for row in rows} |
| if expected != actual: |
| failures.append(f"snapshot IDs differ: missing={sorted(expected - actual)}, extra={sorted(actual - expected)}") |
| unknown_overrides = set(overrides) - expected |
| if unknown_overrides: |
| failures.append(f"verified overrides are not present in the source audit: {sorted(unknown_overrides)}") |
| for row in rows: |
| if row["status"] not in {"preprint-only", "accepted", "published"}: |
| failures.append(f"{row['arxiv_id']}: invalid status {row['status']!r}") |
| if row["status"] in {"accepted", "published"}: |
| required = ("publication_year", "publication_venue", "publisher", "published_url", "metadata_source") |
| missing = [field for field in required if not row.get(field)] |
| if missing: |
| failures.append(f"{row['arxiv_id']}: resolved row missing {', '.join(missing)}") |
| if row.get("publication_venue", "").lower() in PREPRINT_VENUES: |
| failures.append(f"{row['arxiv_id']}: resolved row still names a preprint venue") |
| for arxiv_id, override in overrides.items(): |
| row = by_id.get(arxiv_id) |
| if not row: |
| continue |
| for field in ( |
| "status", |
| "publication_date", |
| "publication_year", |
| "publication_venue", |
| "publisher", |
| "doi", |
| "published_url", |
| "record_url", |
| "metadata_source", |
| ): |
| expected_value = normalize_doi(override[field]) if field == "doi" else override[field] |
| if row.get(field, "") != expected_value: |
| failures.append( |
| f"{arxiv_id}: {field} differs from verified override " |
| f"({row.get(field, '')!r} != {expected_value!r})" |
| ) |
| return failures |
|
|
|
|
| def write_rows(rows: list[dict[str, str]]) -> None: |
| with OUTPUT.open("w", encoding="utf-8", newline="") as handle: |
| writer = csv.DictWriter(handle, fieldnames=FIELDS, lineterminator="\n") |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--check", action="store_true", help="validate the checked-in snapshot without network access") |
| parser.add_argument("--refresh", action="store_true", help="refresh every arXiv record instead of only new entries") |
| parser.add_argument("--timeout", type=float, default=20.0) |
| parser.add_argument("--delay", type=float, default=0.15, help="polite delay between API requests") |
| parser.add_argument("--limit", type=int, default=0, help="resolve only the first N rows (development only)") |
| parser.add_argument("--cache-dir", type=Path, help="read API responses from a reusable local cache") |
| parser.add_argument("--offline", action="store_true", help="do not make network requests; requires --cache-dir") |
| parser.add_argument("--write-dblp-curl-config", type=Path, help="write a curl config for caching DBLP responses") |
| parser.add_argument("--write-crossref-curl-config", type=Path, help="write a curl config after DBLP responses are cached") |
| args = parser.parse_args() |
|
|
| source_rows = read_source_rows() |
| existing = read_existing() |
| overrides = read_verified_overrides() |
| if args.write_dblp_curl_config: |
| if not args.cache_dir: |
| parser.error("--write-dblp-curl-config requires --cache-dir") |
| write_dblp_curl_config(args.write_dblp_curl_config, args.cache_dir, source_rows) |
| return 0 |
| if args.write_crossref_curl_config: |
| if not args.cache_dir: |
| parser.error("--write-crossref-curl-config requires --cache-dir") |
| write_crossref_curl_config(args.write_crossref_curl_config, args.cache_dir, source_rows, args.timeout) |
| return 0 |
| if args.offline and not args.cache_dir: |
| parser.error("--offline requires --cache-dir") |
| if args.check: |
| failures = validate_snapshot(list(existing.values()), source_rows, overrides) |
| if failures: |
| print("arXiv publication audit check failed:", file=sys.stderr) |
| for failure in failures: |
| print(f"- {failure}", file=sys.stderr) |
| return 1 |
| resolved = sum(row["status"] in {"accepted", "published"} for row in existing.values()) |
| accepted = sum(row["status"] == "accepted" for row in existing.values()) |
| print( |
| f"Validated {len(existing)} arXiv publication decisions " |
| f"({resolved} venue-resolved; {accepted} accepted and awaiting archival publication)." |
| ) |
| return 0 |
|
|
| checked_on = datetime.now(timezone.utc).date().isoformat() |
| output_rows: list[dict[str, str]] = [] |
| refresh_rows = source_rows[: args.limit or None] |
| refresh_ids = {row["arxiv_id"] for row in refresh_rows} |
| for index, row in enumerate(source_rows, 1): |
| old = existing.get(row["arxiv_id"]) |
| if row["arxiv_id"] not in refresh_ids or (old and not args.refresh and old.get("arxiv_title") == base_output(row, checked_on)["arxiv_title"]): |
| output_rows.append(old or base_output(row, checked_on)) |
| continue |
| print(f"[{index}/{len(source_rows)}] {row['arxiv_id']} {row['title']}", flush=True) |
| output = base_output(row, checked_on) |
| candidate = resolve_row( |
| row, |
| timeout=args.timeout, |
| delay=args.delay, |
| cache_dir=args.cache_dir, |
| offline=args.offline, |
| overrides=overrides, |
| ) |
| if candidate: |
| output.update({key: value for key, value in candidate.items() if key != "status"}) |
| output["status"] = candidate.get("status", "published") |
| output_rows.append(output) |
|
|
| failures = validate_snapshot(output_rows, source_rows, overrides) |
| if failures: |
| for failure in failures: |
| print(f"- {failure}", file=sys.stderr) |
| return 1 |
| write_rows(output_rows) |
| resolved = sum(row["status"] in {"accepted", "published"} for row in output_rows) |
| accepted = sum(row["status"] == "accepted" for row in output_rows) |
| print( |
| f"Wrote {len(output_rows)} decisions to {OUTPUT.relative_to(ROOT)} " |
| f"({resolved} venue-resolved; {accepted} accepted and awaiting archival publication)." |
| ) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
