|
|
from __future__ import annotations |
|
|
|
|
|
|
|
|
|
|
|
import argparse |
|
|
import csv |
|
|
import re |
|
|
import subprocess |
|
|
from pathlib import Path |
|
|
from typing import Dict, Optional |
|
|
|
|
|
import sys |
|
|
|
|
|
try: |
|
|
from scripts.defextra_markers import ( |
|
|
DocIndex, |
|
|
HASH_VERSION, |
|
|
TokenIndex, |
|
|
build_tei_index, |
|
|
doi_suffix, |
|
|
extract_ids_from_tei, |
|
|
extract_text_from_pdf, |
|
|
hash_token_sequence, |
|
|
normalize_arxiv, |
|
|
normalize_doi, |
|
|
normalize_paper_id, |
|
|
strip_citations, |
|
|
tokenize_text, |
|
|
) |
|
|
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 ( |
|
|
DocIndex, |
|
|
HASH_VERSION, |
|
|
TokenIndex, |
|
|
build_tei_index, |
|
|
doi_suffix, |
|
|
extract_ids_from_tei, |
|
|
extract_text_from_pdf, |
|
|
hash_token_sequence, |
|
|
normalize_arxiv, |
|
|
normalize_doi, |
|
|
normalize_paper_id, |
|
|
strip_citations, |
|
|
tokenize_text, |
|
|
) |
|
|
from scripts.defextra_pdf_aliases import candidate_pdf_aliases |
|
|
|
|
|
TRAILING_PUNCT = set(".,;:?!)]}\"'") |
|
|
END_PUNCT = {".", ",", ";", ":", "?", "!"} |
|
|
TRAILING_QUOTES = {"'", '"', "”", "’", ")", "]"} |
|
|
CITATION_BRACKET_RE = re.compile(r"\[[0-9][0-9,;\s\-–]*\]") |
|
|
CITATION_PAREN_RE = re.compile(r"\([^)]*\d{4}[^)]*\)") |
|
|
|
|
|
|
|
|
def _extend_span_end(doc_text: str, end: int) -> int: |
|
|
if end < 0: |
|
|
return end |
|
|
limit = len(doc_text) |
|
|
while end < limit and doc_text[end] in TRAILING_PUNCT: |
|
|
end += 1 |
|
|
j = end |
|
|
while j < limit and doc_text[j].isspace(): |
|
|
j += 1 |
|
|
if j < limit and doc_text[j] in TRAILING_PUNCT: |
|
|
end = j + 1 |
|
|
while end < limit and doc_text[end] in TRAILING_PUNCT: |
|
|
end += 1 |
|
|
return end |
|
|
|
|
|
|
|
|
def _extract_with_trailing_punct( |
|
|
doc_text: str, |
|
|
start: Optional[int], |
|
|
end: Optional[int], |
|
|
) -> str: |
|
|
if start is None or end is None: |
|
|
return "" |
|
|
if start < 0 or end > len(doc_text) or start >= end: |
|
|
return "" |
|
|
end = _extend_span_end(doc_text, end) |
|
|
return doc_text[start:end] |
|
|
|
|
|
|
|
|
def _token_count(text: str) -> int: |
|
|
tokens, _ = tokenize_text(text or "", return_spans=False) |
|
|
return len(tokens) |
|
|
|
|
|
|
|
|
def _row_flag(row: dict, key: str, default: bool = False) -> bool: |
|
|
value = (row.get(key) or "").strip().lower() |
|
|
if not value: |
|
|
return default |
|
|
return value == "true" |
|
|
|
|
|
|
|
|
def _trim_pattern( |
|
|
text: str, |
|
|
expected: int, |
|
|
pattern: re.Pattern[str], |
|
|
) -> str: |
|
|
if not text or expected <= 0: |
|
|
return text |
|
|
while True: |
|
|
current = _token_count(text) |
|
|
best = text |
|
|
best_diff = abs(current - expected) |
|
|
improved = False |
|
|
for match in pattern.finditer(text): |
|
|
candidate = ( |
|
|
text[: match.start()] + " " + text[match.end() :] |
|
|
).strip() |
|
|
diff = abs(_token_count(candidate) - expected) |
|
|
if diff < best_diff: |
|
|
best = candidate |
|
|
best_diff = diff |
|
|
improved = True |
|
|
if not improved: |
|
|
break |
|
|
text = best |
|
|
if _token_count(text) <= expected: |
|
|
break |
|
|
return text |
|
|
|
|
|
|
|
|
def _trim_citations(text: str, expected: int) -> str: |
|
|
if not text or expected <= 0: |
|
|
return text |
|
|
current = _token_count(text) |
|
|
if current <= expected: |
|
|
return text |
|
|
text = _trim_pattern(text, expected, CITATION_BRACKET_RE) |
|
|
if _token_count(text) <= expected: |
|
|
return text |
|
|
text = _trim_pattern(text, expected, CITATION_PAREN_RE) |
|
|
return text |
|
|
|
|
|
|
|
|
def _trim_to_token_count(text: str, expected: int) -> str: |
|
|
if not text or expected <= 0: |
|
|
return text |
|
|
tokens, spans = tokenize_text(text, return_spans=True) |
|
|
if not spans or len(spans) <= expected: |
|
|
return text |
|
|
end_idx = spans[expected - 1][1] |
|
|
end_idx = _extend_span_end(text, end_idx) |
|
|
return text[:end_idx].rstrip() |
|
|
|
|
|
|
|
|
def _cleanup_spacing(text: str) -> str: |
|
|
if not text: |
|
|
return text |
|
|
value = text |
|
|
value = value.replace("“", '"').replace("”", '"') |
|
|
value = value.replace("’", "'").replace("‘", "'") |
|
|
|
|
|
def _dash_repl(match: re.Match[str]) -> str: |
|
|
run = match.group(0) |
|
|
return "--" if len(run) >= 2 else "-" |
|
|
|
|
|
value = re.sub(r"[\u2010-\u2015\u2212\u2043]+", _dash_repl, value) |
|
|
value = value.replace("\ufb00", "ff") |
|
|
value = value.replace("\ufb01", "fi") |
|
|
value = value.replace("\ufb02", "fl") |
|
|
value = value.replace("\ufb03", "ffi") |
|
|
value = value.replace("\ufb04", "ffl") |
|
|
value = value.replace("…", "...") |
|
|
value = re.sub(r"-{3,}", "--", value) |
|
|
value = re.sub(r"([a-z0-9])([.!?])(?=[A-Z])", r"\1\2 ", value) |
|
|
value = re.sub(r"([A-Za-z]),(?=[A-Za-z])", r"\1, ", value) |
|
|
value = re.sub(r"([A-Za-z0-9])([;:])(?=[A-Za-z])", r"\1\2 ", value) |
|
|
value = re.sub(r"(\d)\s+(s)\b", r"\1\2", value) |
|
|
value = re.sub(r"([0-9])([A-Za-z])", r"\1 \2", value) |
|
|
value = re.sub(r"[ \t]+([,.;:!?])", r"\1", value) |
|
|
value = re.sub(r"\(\s+", "(", value) |
|
|
value = re.sub(r"\s+\)", ")", value) |
|
|
value = re.sub(r"\[\s+", "[", value) |
|
|
value = re.sub(r"\s+\]", "]", value) |
|
|
value = re.sub(r"\)(?=[A-Za-z0-9])", ") ", value) |
|
|
value = re.sub(r"\](?=[A-Za-z0-9])", "] ", value) |
|
|
|
|
|
def _space_citation_commas(match: re.Match[str]) -> str: |
|
|
inner = match.group(1) |
|
|
inner = re.sub(r",(?!\\s)", ", ", inner) |
|
|
return f"[{inner}]" |
|
|
|
|
|
value = re.sub(r"\[([0-9,;\s\-–]+)\]", _space_citation_commas, value) |
|
|
value = re.sub(r"[ \t]{2,}", " ", value) |
|
|
return value |
|
|
|
|
|
|
|
|
def _normalize_whitespace( |
|
|
text: str, |
|
|
preserve_linebreaks: bool, |
|
|
) -> str: |
|
|
if not text: |
|
|
return text |
|
|
value = _cleanup_spacing(text) |
|
|
if preserve_linebreaks: |
|
|
value = re.sub(r"[ \t]{2,}", " ", value) |
|
|
return value |
|
|
value = re.sub(r"\s+", " ", value).strip() |
|
|
return value |
|
|
|
|
|
|
|
|
def _normalize_hyphenation( |
|
|
text: str, |
|
|
preserve_hyphenation: bool, |
|
|
) -> str: |
|
|
if not text: |
|
|
return text |
|
|
if preserve_hyphenation: |
|
|
return text |
|
|
return re.sub(r"([A-Za-z])-\s+([A-Za-z])", r"\1\2", text) |
|
|
|
|
|
|
|
|
def _postprocess_text( |
|
|
text: str, |
|
|
expected_tokens: int, |
|
|
preserve_linebreaks: bool, |
|
|
preserve_hyphenation: bool, |
|
|
keep_bracket_citations: bool = True, |
|
|
keep_paren_citations: bool = True, |
|
|
split_letter_digit: bool = True, |
|
|
) -> str: |
|
|
value = text |
|
|
if not keep_bracket_citations: |
|
|
value = CITATION_BRACKET_RE.sub(" ", value) |
|
|
if not keep_paren_citations: |
|
|
value = CITATION_PAREN_RE.sub(" ", value) |
|
|
value = _trim_citations(value, expected_tokens) |
|
|
value = _trim_to_token_count(value, expected_tokens) |
|
|
value = _cleanup_spacing(value) |
|
|
if split_letter_digit: |
|
|
value = re.sub(r"([A-Za-z])([0-9])", r"\1 \2", value) |
|
|
value = _normalize_hyphenation(value, preserve_hyphenation) |
|
|
return _normalize_whitespace(value, preserve_linebreaks) |
|
|
|
|
|
|
|
|
def _ensure_trailing_punct(text: str, end_punct: str) -> str: |
|
|
if not text or not end_punct: |
|
|
stripped = text.rstrip() |
|
|
if not stripped: |
|
|
return text |
|
|
i = len(stripped) - 1 |
|
|
suffix = "" |
|
|
while i >= 0 and stripped[i] in TRAILING_QUOTES: |
|
|
suffix = stripped[i] + suffix |
|
|
i -= 1 |
|
|
base = stripped[: i + 1] |
|
|
if base and base[-1] in END_PUNCT: |
|
|
base = base[:-1] |
|
|
if base and suffix: |
|
|
if ")" in suffix and "(" not in base: |
|
|
suffix = suffix.replace(")", "") |
|
|
if "]" in suffix and "[" not in base: |
|
|
suffix = suffix.replace("]", "") |
|
|
return f"{base}{suffix}" |
|
|
stripped = text.rstrip() |
|
|
if not stripped: |
|
|
return text |
|
|
i = len(stripped) - 1 |
|
|
suffix = "" |
|
|
while i >= 0 and stripped[i] in TRAILING_QUOTES: |
|
|
suffix = stripped[i] + suffix |
|
|
i -= 1 |
|
|
base = stripped[: i + 1] |
|
|
if base and base[-1] in END_PUNCT: |
|
|
base = base[:-1] + end_punct |
|
|
else: |
|
|
base = f"{base}{end_punct}" |
|
|
return f"{base}{suffix}" |
|
|
|
|
|
|
|
|
def _find_pdf_hash_span( |
|
|
row: dict, |
|
|
pdf_token_index: Optional[TokenIndex], |
|
|
prefix: str, |
|
|
) -> Optional[tuple[int, int]]: |
|
|
if pdf_token_index is None: |
|
|
return None |
|
|
spec = _select_hash_specs(row, prefix) |
|
|
if spec: |
|
|
span = pdf_token_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
return span |
|
|
return None |
|
|
|
|
|
|
|
|
def _bool_flag(value: str) -> bool: |
|
|
return (value or "").strip().lower() == "true" |
|
|
|
|
|
|
|
|
def _strip_flags(row: dict, prefix: str) -> tuple[bool, bool]: |
|
|
keep_bracket = _bool_flag(row.get(f"{prefix}_has_bracket_citation", "")) |
|
|
keep_paren = _bool_flag(row.get(f"{prefix}_has_paren_citation", "")) |
|
|
return (not keep_bracket), (not keep_paren) |
|
|
|
|
|
|
|
|
def _span_matches_hash(row: dict, text: str, prefix: str) -> bool: |
|
|
if not text: |
|
|
return False |
|
|
expected_hash = row.get(f"{prefix}_hash64") or "" |
|
|
expected_sha = row.get(f"{prefix}_sha256") or "" |
|
|
if not expected_hash or not expected_sha: |
|
|
return False |
|
|
strip_brackets, strip_parens = _strip_flags(row, prefix) |
|
|
check_text = strip_citations( |
|
|
text, |
|
|
strip_brackets=strip_brackets, |
|
|
strip_parens=strip_parens, |
|
|
) |
|
|
tokens, _ = tokenize_text(check_text, return_spans=True) |
|
|
hash64, sha, _ = hash_token_sequence(tokens) |
|
|
return str(hash64) == str(expected_hash) and sha == expected_sha |
|
|
|
|
|
|
|
|
def _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]: |
|
|
candidates = [ |
|
|
paper_id, |
|
|
normalize_paper_id(paper_id), |
|
|
] |
|
|
if doi: |
|
|
candidates.append(doi) |
|
|
candidates.append(doi_suffix(doi)) |
|
|
if arxiv: |
|
|
candidates.append(arxiv) |
|
|
candidates.append(normalize_arxiv(arxiv)) |
|
|
seen = set() |
|
|
ordered = [] |
|
|
for item in candidates: |
|
|
value = (item or "").strip() |
|
|
if value and 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 value and value not in seen: |
|
|
seen.add(value) |
|
|
ordered.append(value) |
|
|
return ordered |
|
|
|
|
|
|
|
|
def _normalize_title(title: str) -> str: |
|
|
return " ".join(title.lower().split()) |
|
|
|
|
|
|
|
|
def _build_meta_index( |
|
|
tei_index: Dict[str, Path], |
|
|
) -> tuple[Dict[str, Path], Dict[str, Path]]: |
|
|
doi_index: Dict[str, Path] = {} |
|
|
arxiv_index: Dict[str, Path] = {} |
|
|
for path in tei_index.values(): |
|
|
doi, arxiv = extract_ids_from_tei(path) |
|
|
if doi: |
|
|
doi_index.setdefault(normalize_doi(doi), path) |
|
|
doi_index.setdefault(doi_suffix(doi), path) |
|
|
if arxiv: |
|
|
arxiv_index.setdefault(normalize_arxiv(arxiv), path) |
|
|
return doi_index, arxiv_index |
|
|
|
|
|
|
|
|
def _resolve_tei_path( |
|
|
paper_id: str, |
|
|
doi: str, |
|
|
arxiv: str, |
|
|
tei_index: Dict[str, Path], |
|
|
doi_index: Dict[str, Path], |
|
|
arxiv_index: Dict[str, Path], |
|
|
) -> Optional[Path]: |
|
|
for candidate in _candidate_ids(paper_id, doi, arxiv): |
|
|
if candidate in tei_index: |
|
|
return tei_index[candidate] |
|
|
if candidate.startswith("paper_"): |
|
|
stripped = candidate[len("paper_") :] |
|
|
if stripped in tei_index: |
|
|
return tei_index[stripped] |
|
|
if doi: |
|
|
doi_key = normalize_doi(doi) |
|
|
if doi_key in doi_index: |
|
|
return doi_index[doi_key] |
|
|
doi_key = doi_suffix(doi) |
|
|
if doi_key in doi_index: |
|
|
return doi_index[doi_key] |
|
|
if arxiv: |
|
|
arxiv_key = normalize_arxiv(arxiv) |
|
|
if arxiv_key in arxiv_index: |
|
|
return arxiv_index[arxiv_key] |
|
|
return None |
|
|
|
|
|
|
|
|
def _tei_stem(path: Path) -> str: |
|
|
name = path.name |
|
|
if name.endswith(".grobid.tei.xml"): |
|
|
name = name[: -len(".grobid.tei.xml")] |
|
|
return name |
|
|
|
|
|
|
|
|
def _build_pdf_index(pdf_dir: Path) -> Dict[str, Path]: |
|
|
index: Dict[str, Path] = {} |
|
|
if not pdf_dir.exists(): |
|
|
return index |
|
|
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 suffix in ("*.pdf", "*.PDF"): |
|
|
for path in pdf_dir.rglob(suffix): |
|
|
stem = path.stem |
|
|
index.setdefault(stem, path) |
|
|
index.setdefault(normalize_paper_id(stem), path) |
|
|
index.setdefault(f"paper_{stem}", path) |
|
|
if stem.startswith("paper_"): |
|
|
stripped = stem[len("paper_") :] |
|
|
if stripped: |
|
|
index.setdefault(stripped, path) |
|
|
index.setdefault(normalize_paper_id(stripped), 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[normalize_paper_id(base)] = path |
|
|
index[f"paper_{base}"] = path |
|
|
if base.startswith("paper_"): |
|
|
stripped_base = base[len("paper_") :] |
|
|
if stripped_base: |
|
|
index[stripped_base] = path |
|
|
index[normalize_paper_id(stripped_base)] = path |
|
|
match = arxiv_re.match(stem) |
|
|
if match: |
|
|
base = match.group("base") |
|
|
index.setdefault(base, path) |
|
|
index.setdefault(normalize_paper_id(base), path) |
|
|
match = version_re.match(stem) |
|
|
if match: |
|
|
base = match.group("base") |
|
|
index.setdefault(base, path) |
|
|
index.setdefault(normalize_paper_id(base), path) |
|
|
pii_match = pii_re.search(stem) |
|
|
if pii_match: |
|
|
pii = pii_match.group(1) |
|
|
index.setdefault(pii, path) |
|
|
index.setdefault(normalize_paper_id(pii), path) |
|
|
return index |
|
|
|
|
|
|
|
|
def _select_hash_specs( |
|
|
row: dict, |
|
|
prefix: str, |
|
|
) -> Optional[tuple[int, int, str]]: |
|
|
hash_version = (row.get("hash_version") or "").strip() |
|
|
if hash_version and hash_version != HASH_VERSION: |
|
|
return None |
|
|
count = row.get(f"{prefix}_token_count") or "" |
|
|
hash64 = row.get(f"{prefix}_hash64") or "" |
|
|
sha = row.get(f"{prefix}_sha256") or "" |
|
|
if not count or not hash64 or not sha: |
|
|
return None |
|
|
try: |
|
|
return int(count), int(hash64), sha |
|
|
except ValueError: |
|
|
return None |
|
|
|
|
|
|
|
|
def _select_anchor_specs( |
|
|
row: dict, |
|
|
prefix: str, |
|
|
position: str, |
|
|
) -> Optional[tuple[int, int, str]]: |
|
|
hash_version = (row.get("hash_version") or "").strip() |
|
|
if hash_version and hash_version != HASH_VERSION: |
|
|
return None |
|
|
count = row.get(f"{prefix}_{position}_token_count") or "" |
|
|
hash64 = row.get(f"{prefix}_{position}_hash64") or "" |
|
|
sha = row.get(f"{prefix}_{position}_sha256") or "" |
|
|
if not count or not hash64 or not sha: |
|
|
return None |
|
|
try: |
|
|
return int(count), int(hash64), sha |
|
|
except ValueError: |
|
|
return None |
|
|
|
|
|
|
|
|
def _select_anchor_spec_list( |
|
|
row: dict, |
|
|
prefix: str, |
|
|
position: str, |
|
|
) -> list[tuple[int, int, str]]: |
|
|
specs: list[tuple[int, int, str]] = [] |
|
|
primary = _select_anchor_specs(row, prefix, position) |
|
|
if primary is not None: |
|
|
specs.append(primary) |
|
|
alt_count = row.get(f"{prefix}_{position}_alt_token_count") or "" |
|
|
alt_hash = row.get(f"{prefix}_{position}_alt_hash64") or "" |
|
|
alt_sha = row.get(f"{prefix}_{position}_alt_sha256") or "" |
|
|
hash_version = (row.get("hash_version") or "").strip() |
|
|
if hash_version and hash_version != HASH_VERSION: |
|
|
return specs |
|
|
if alt_count and alt_hash and alt_sha: |
|
|
try: |
|
|
specs.append((int(alt_count), int(alt_hash), alt_sha)) |
|
|
except ValueError: |
|
|
pass |
|
|
return specs |
|
|
|
|
|
|
|
|
def _match_doc_by_hash( |
|
|
token_index: TokenIndex, |
|
|
hash_specs: list[tuple[int, int, str]], |
|
|
) -> int: |
|
|
score = 0 |
|
|
for window, hash64, sha in hash_specs: |
|
|
if token_index.find_span_by_hash(window, hash64, sha): |
|
|
score += 1 |
|
|
return score |
|
|
|
|
|
|
|
|
def _build_mid_candidates( |
|
|
token_index: TokenIndex, |
|
|
mid_specs: Optional[list[tuple[int, int, str]]], |
|
|
) -> list[tuple[int, int]]: |
|
|
if not mid_specs: |
|
|
return [] |
|
|
candidates: list[tuple[int, int]] = [] |
|
|
for spec in mid_specs: |
|
|
for position in token_index.find_token_positions_by_hash(*spec): |
|
|
candidates.append((position, spec[0])) |
|
|
return candidates |
|
|
|
|
|
|
|
|
def _span_has_mid( |
|
|
mid_candidates: list[tuple[int, int]], |
|
|
start_idx: int, |
|
|
end_idx: int, |
|
|
) -> bool: |
|
|
for mid_start, mid_len in mid_candidates: |
|
|
mid_end = mid_start + mid_len - 1 |
|
|
if mid_start >= start_idx and mid_end <= end_idx: |
|
|
return True |
|
|
return False |
|
|
|
|
|
|
|
|
def _find_span_by_anchors( |
|
|
token_index: TokenIndex, |
|
|
head_spec: Optional[tuple[int, int, str]], |
|
|
tail_spec: Optional[tuple[int, int, str]], |
|
|
expected_len: int, |
|
|
mid_specs: Optional[list[tuple[int, int, str]]] = None, |
|
|
*, |
|
|
require_mid: bool = False, |
|
|
) -> Optional[tuple[int, int]]: |
|
|
if head_spec is None or tail_spec is None: |
|
|
return None |
|
|
head_positions = token_index.find_token_positions_by_hash(*head_spec) |
|
|
tail_positions = token_index.find_token_positions_by_hash(*tail_spec) |
|
|
if not head_positions or not tail_positions: |
|
|
return None |
|
|
mid_candidates = [] |
|
|
if require_mid: |
|
|
mid_candidates = _build_mid_candidates(token_index, mid_specs) |
|
|
if not mid_candidates: |
|
|
return None |
|
|
best = None |
|
|
best_diff = None |
|
|
tol = max(5, int(expected_len * 0.3)) if expected_len else 10 |
|
|
min_len = max(1, expected_len // 2) if expected_len else 1 |
|
|
max_len = expected_len * 3 if expected_len else None |
|
|
for head_start in head_positions: |
|
|
head_end = head_start + head_spec[0] - 1 |
|
|
for tail_start in tail_positions: |
|
|
tail_end = tail_start + tail_spec[0] - 1 |
|
|
if tail_end < head_end: |
|
|
continue |
|
|
length = tail_end - head_start + 1 |
|
|
if mid_candidates and not _span_has_mid( |
|
|
mid_candidates, |
|
|
head_start, |
|
|
tail_end, |
|
|
): |
|
|
continue |
|
|
if expected_len: |
|
|
if length < min_len or (max_len and length > max_len): |
|
|
continue |
|
|
if length < expected_len - tol or length > expected_len + tol: |
|
|
continue |
|
|
diff = abs(length - expected_len) |
|
|
else: |
|
|
diff = length |
|
|
if best_diff is None or diff < best_diff: |
|
|
best_diff = diff |
|
|
best = (head_start, tail_end) |
|
|
if best is None and expected_len: |
|
|
for head_start in head_positions: |
|
|
head_end = head_start + head_spec[0] - 1 |
|
|
for tail_start in tail_positions: |
|
|
tail_end = tail_start + tail_spec[0] - 1 |
|
|
if tail_end < head_end: |
|
|
continue |
|
|
length = tail_end - head_start + 1 |
|
|
if mid_candidates and not _span_has_mid( |
|
|
mid_candidates, |
|
|
head_start, |
|
|
tail_end, |
|
|
): |
|
|
continue |
|
|
if length < min_len or (max_len and length > max_len): |
|
|
continue |
|
|
diff = abs(length - expected_len) |
|
|
if best_diff is None or diff < best_diff: |
|
|
best_diff = diff |
|
|
best = (head_start, tail_end) |
|
|
if best is None: |
|
|
return None |
|
|
start_char = token_index.spans[best[0]][0] |
|
|
end_char = token_index.spans[best[1]][1] |
|
|
return start_char, end_char |
|
|
|
|
|
|
|
|
def _find_span_from_anchor( |
|
|
token_index: TokenIndex, |
|
|
anchor_spec: Optional[tuple[int, int, str]], |
|
|
expected_len: int, |
|
|
position: str, |
|
|
mid_specs: Optional[list[tuple[int, int, str]]] = None, |
|
|
*, |
|
|
require_mid: bool = False, |
|
|
require_unique: bool = False, |
|
|
) -> Optional[tuple[int, int]]: |
|
|
if anchor_spec is None or expected_len <= 0: |
|
|
return None |
|
|
positions = token_index.find_token_positions_by_hash(*anchor_spec) |
|
|
if not positions: |
|
|
return None |
|
|
if require_unique and len(positions) != 1: |
|
|
return None |
|
|
mid_candidates = [] |
|
|
if require_mid: |
|
|
mid_candidates = _build_mid_candidates(token_index, mid_specs) |
|
|
if not mid_candidates: |
|
|
return None |
|
|
if position == "tail": |
|
|
positions = list(reversed(positions)) |
|
|
for anchor_start in positions: |
|
|
if position == "head": |
|
|
start_idx = anchor_start |
|
|
end_idx = anchor_start + expected_len - 1 |
|
|
else: |
|
|
anchor_end = anchor_start + anchor_spec[0] - 1 |
|
|
end_idx = anchor_end |
|
|
start_idx = end_idx - expected_len + 1 |
|
|
if start_idx < 0 or end_idx >= len(token_index.tokens): |
|
|
continue |
|
|
if mid_candidates and not _span_has_mid( |
|
|
mid_candidates, |
|
|
start_idx, |
|
|
end_idx, |
|
|
): |
|
|
continue |
|
|
start_char = token_index.spans[start_idx][0] |
|
|
end_char = token_index.spans[end_idx][1] |
|
|
return start_char, end_char |
|
|
return None |
|
|
|
|
|
|
|
|
def _pick_best_doc( |
|
|
token_indexes: Dict[Path, TokenIndex], |
|
|
hash_specs: list[tuple[int, int, str]], |
|
|
) -> Optional[Path]: |
|
|
best_path = None |
|
|
best_score = 0 |
|
|
tie = False |
|
|
for path, token_index in token_indexes.items(): |
|
|
score = _match_doc_by_hash(token_index, hash_specs) |
|
|
if score > best_score: |
|
|
best_score = score |
|
|
best_path = path |
|
|
tie = False |
|
|
elif score == best_score and score > 0: |
|
|
tie = True |
|
|
if best_score == 0 or tie: |
|
|
return None |
|
|
return best_path |
|
|
|
|
|
|
|
|
def _pick_best_pdf( |
|
|
pdf_paths: list[Path], |
|
|
pdf_token_cache: Dict[Path, TokenIndex], |
|
|
hash_specs: list[tuple[int, int, str]], |
|
|
) -> Optional[Path]: |
|
|
best_path = None |
|
|
best_score = 0 |
|
|
tie = False |
|
|
for path in pdf_paths: |
|
|
if path not in pdf_token_cache: |
|
|
pdf_text = extract_text_from_pdf(path) |
|
|
pdf_token_cache[path] = TokenIndex.from_text(pdf_text) |
|
|
token_index = pdf_token_cache[path] |
|
|
score = _match_doc_by_hash(token_index, hash_specs) |
|
|
if score > best_score: |
|
|
best_score = score |
|
|
best_path = path |
|
|
tie = False |
|
|
elif score == best_score and score > 0: |
|
|
tie = True |
|
|
if best_score == 0 or tie: |
|
|
return None |
|
|
return best_path |
|
|
|
|
|
|
|
|
def _run_grobid(input_dir: Path, output_dir: Path, config: Path) -> None: |
|
|
output_dir.mkdir(parents=True, exist_ok=True) |
|
|
cmd = [ |
|
|
sys.executable, |
|
|
"scripts/pdf_to_grobid.py", |
|
|
"--input_folder", |
|
|
str(input_dir), |
|
|
"--output_folder", |
|
|
str(output_dir), |
|
|
] |
|
|
if config and config.exists(): |
|
|
cmd.extend(["--config", str(config)]) |
|
|
subprocess.run(cmd, check=True) |
|
|
|
|
|
|
|
|
def main() -> None: |
|
|
parser = argparse.ArgumentParser( |
|
|
description="Hydrate DefExtra legal CSV using user-provided PDFs.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--legal-csv", |
|
|
type=Path, |
|
|
default=Path("results/paper_results/defextra_legal.csv"), |
|
|
help="Legal DefExtra CSV with markers.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--pdf-dir", |
|
|
type=Path, |
|
|
required=True, |
|
|
help="Directory with user-provided PDFs.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--grobid-out", |
|
|
type=Path, |
|
|
default=Path("outputs/defextra_grobid"), |
|
|
help="Output directory for GROBID TEI files.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--grobid-config", |
|
|
type=Path, |
|
|
default=Path("config.json"), |
|
|
help="Optional GROBID client config path.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--skip-grobid", |
|
|
action="store_true", |
|
|
help="Skip running GROBID (expects TEI files already present).", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--output-csv", |
|
|
type=Path, |
|
|
default=Path("results/paper_results/defextra_hydrated.csv"), |
|
|
help="Output hydrated CSV with excerpts.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--report", |
|
|
type=Path, |
|
|
default=None, |
|
|
help="Optional report path for missing matches.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--require-complete", |
|
|
action="store_true", |
|
|
help="Exit with error if any definition/context is missing.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--filter-to-pdfs", |
|
|
action="store_true", |
|
|
help="Only process rows that can be mapped to a provided PDF.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--allow-pdf-hash-mismatch", |
|
|
action="store_true", |
|
|
help=( |
|
|
"Continue when a PDF filename matches but hash markers do not. " |
|
|
"By default, such PDFs are skipped and reported." |
|
|
), |
|
|
) |
|
|
args = parser.parse_args() |
|
|
|
|
|
if not args.legal_csv.exists(): |
|
|
raise SystemExit(f"Legal CSV not found: {args.legal_csv}") |
|
|
if not args.pdf_dir.exists(): |
|
|
raise SystemExit(f"PDF dir not found: {args.pdf_dir}") |
|
|
|
|
|
if not args.skip_grobid: |
|
|
try: |
|
|
_run_grobid(args.pdf_dir, args.grobid_out, args.grobid_config) |
|
|
except subprocess.CalledProcessError: |
|
|
raise SystemExit( |
|
|
"GROBID processing failed. Ensure the GROBID server is running " |
|
|
"and reachable (default: http://localhost:8070), or supply " |
|
|
"--grobid-config with the correct server URL.", |
|
|
) |
|
|
|
|
|
tei_index = build_tei_index([args.grobid_out]) |
|
|
doi_index, arxiv_index = _build_meta_index(tei_index) |
|
|
pdf_index = _build_pdf_index(args.pdf_dir) |
|
|
doc_cache: Dict[str, Optional[DocIndex]] = {} |
|
|
token_cache: Dict[str, Optional[TokenIndex]] = {} |
|
|
tei_path_cache: Dict[str, Optional[Path]] = {} |
|
|
pdf_token_cache: Dict[Path, TokenIndex] = {} |
|
|
pdf_token_cache_stripped: Dict[tuple[Path, bool, bool], TokenIndex] = {} |
|
|
tei_token_cache_stripped: Dict[tuple[Path, bool, bool], TokenIndex] = {} |
|
|
pdf_failed: set[Path] = set() |
|
|
|
|
|
def _get_stripped_index( |
|
|
cache: Dict[tuple[Path, bool, bool], TokenIndex], |
|
|
source_path: Optional[Path], |
|
|
source_text: str, |
|
|
strip_brackets: bool, |
|
|
strip_parens: bool, |
|
|
) -> Optional[TokenIndex]: |
|
|
if source_path is None: |
|
|
return None |
|
|
if not strip_brackets and not strip_parens: |
|
|
return None |
|
|
key = (source_path, strip_brackets, strip_parens) |
|
|
if key not in cache: |
|
|
stripped = strip_citations( |
|
|
source_text, |
|
|
strip_brackets=strip_brackets, |
|
|
strip_parens=strip_parens, |
|
|
) |
|
|
cache[key] = TokenIndex.from_text(stripped) |
|
|
return cache[key] |
|
|
|
|
|
with args.legal_csv.open("r", encoding="utf-8", newline="") as handle: |
|
|
reader = csv.DictReader(handle) |
|
|
legal_rows = list(reader) |
|
|
|
|
|
paper_hashes: Dict[str, list[tuple[int, int, str]]] = {} |
|
|
title_to_ids: Dict[str, list[str]] = {} |
|
|
id_to_row: Dict[str, dict] = {} |
|
|
for row in legal_rows: |
|
|
paper_id = (row.get("paper_id") or "").strip() |
|
|
if not paper_id: |
|
|
continue |
|
|
if paper_id not in id_to_row: |
|
|
id_to_row[paper_id] = row |
|
|
title_key = _normalize_title(row.get("paper_title") or "") |
|
|
if title_key: |
|
|
title_to_ids.setdefault(title_key, []).append(paper_id) |
|
|
specs: list[tuple[int, int, str]] = [] |
|
|
for prefix in ("definition", "context"): |
|
|
spec = _select_hash_specs(row, prefix) |
|
|
if spec is None: |
|
|
continue |
|
|
token_count, _, _ = spec |
|
|
if token_count >= 5: |
|
|
specs.append(spec) |
|
|
if specs: |
|
|
paper_hashes.setdefault(paper_id, []).extend(specs) |
|
|
for prefix in ("definition", "context"): |
|
|
for position in ("head", "mid", "tail"): |
|
|
for spec in _select_anchor_spec_list(row, prefix, position): |
|
|
if spec and spec[0] >= 5: |
|
|
paper_hashes.setdefault(paper_id, []).append(spec) |
|
|
|
|
|
tei_token_indexes: Dict[Path, TokenIndex] = {} |
|
|
allowed_stems = set(pdf_index.keys()) if pdf_index else set() |
|
|
for tei_path in tei_index.values(): |
|
|
if allowed_stems: |
|
|
stem = _tei_stem(tei_path) |
|
|
stem_norm = normalize_paper_id(stem) |
|
|
stem_stripped = ( |
|
|
stem[len("paper_") :] if stem.startswith("paper_") else stem |
|
|
) |
|
|
if ( |
|
|
stem not in allowed_stems |
|
|
and stem_norm not in allowed_stems |
|
|
and stem_stripped not in allowed_stems |
|
|
): |
|
|
continue |
|
|
try: |
|
|
doc_index = DocIndex.from_tei(tei_path) |
|
|
except Exception: |
|
|
continue |
|
|
tei_token_indexes[tei_path] = TokenIndex.from_text(doc_index.doc_text) |
|
|
|
|
|
output_rows = [] |
|
|
missing_papers = set() |
|
|
missing_defs = 0 |
|
|
missing_ctxs = 0 |
|
|
hydrated_from_pdf = 0 |
|
|
hydrated_from_anchor = 0 |
|
|
pdf_hash_mismatches: list[dict[str, str]] = [] |
|
|
pdf_hash_mismatch_seen: set[tuple[str, str]] = set() |
|
|
missing_def_rows: list[dict] = [] |
|
|
missing_ctx_rows: list[dict] = [] |
|
|
|
|
|
for row in legal_rows: |
|
|
paper_id = (row.get("paper_id") or "").strip() |
|
|
doi = (row.get("paper_doi") or "").strip() |
|
|
arxiv = (row.get("paper_arxiv") or "").strip() |
|
|
|
|
|
if paper_id not in doc_cache: |
|
|
tei_path = _resolve_tei_path( |
|
|
paper_id, |
|
|
doi, |
|
|
arxiv, |
|
|
tei_index, |
|
|
doi_index, |
|
|
arxiv_index, |
|
|
) |
|
|
if tei_path is None: |
|
|
hash_specs = paper_hashes.get(paper_id, []) |
|
|
if hash_specs: |
|
|
tei_path = _pick_best_doc( |
|
|
tei_token_indexes, |
|
|
hash_specs, |
|
|
) |
|
|
if tei_path is None: |
|
|
doc_cache[paper_id] = None |
|
|
token_cache[paper_id] = None |
|
|
tei_path_cache[paper_id] = None |
|
|
else: |
|
|
doc_index = DocIndex.from_tei(tei_path) |
|
|
doc_cache[paper_id] = doc_index |
|
|
token_cache[paper_id] = TokenIndex.from_text( |
|
|
doc_index.doc_text, |
|
|
) |
|
|
tei_path_cache[paper_id] = tei_path |
|
|
|
|
|
doc_index = doc_cache.get(paper_id) |
|
|
tei_token_index = token_cache.get(paper_id) |
|
|
definition = "" |
|
|
context = "" |
|
|
pdf_token_index: Optional[TokenIndex] = None |
|
|
pdf_path = None |
|
|
tei_path = tei_path_cache.get(paper_id) |
|
|
pdf_direct_match = False |
|
|
if tei_path is not None: |
|
|
stem = _tei_stem(tei_path) |
|
|
pdf_path = pdf_index.get(stem) or pdf_index.get( |
|
|
normalize_paper_id(stem), |
|
|
) |
|
|
if pdf_path is not None: |
|
|
pdf_direct_match = True |
|
|
if pdf_path is None: |
|
|
for candidate in _candidate_ids(paper_id, doi, arxiv): |
|
|
pdf_path = pdf_index.get(candidate) |
|
|
if pdf_path: |
|
|
pdf_direct_match = True |
|
|
break |
|
|
if pdf_path is None: |
|
|
title_key = _normalize_title(row.get("paper_title") or "") |
|
|
for other_id in title_to_ids.get(title_key, []): |
|
|
if other_id == paper_id: |
|
|
continue |
|
|
other_row = id_to_row.get(other_id, {}) |
|
|
other_doi = (other_row.get("paper_doi") or "").strip() |
|
|
other_arxiv = (other_row.get("paper_arxiv") or "").strip() |
|
|
for candidate in _candidate_ids( |
|
|
other_id, |
|
|
other_doi, |
|
|
other_arxiv, |
|
|
): |
|
|
pdf_path = pdf_index.get(candidate) |
|
|
if pdf_path: |
|
|
pdf_direct_match = True |
|
|
break |
|
|
if pdf_path: |
|
|
break |
|
|
hash_specs = paper_hashes.get(paper_id, []) |
|
|
if pdf_path is not None and hash_specs: |
|
|
if pdf_path not in pdf_token_cache: |
|
|
pdf_text = extract_text_from_pdf(pdf_path) |
|
|
pdf_token_cache[pdf_path] = TokenIndex.from_text(pdf_text) |
|
|
pdf_token_index = pdf_token_cache[pdf_path] |
|
|
if _match_doc_by_hash(pdf_token_index, hash_specs) == 0: |
|
|
mismatch_key = (paper_id, str(pdf_path)) |
|
|
if mismatch_key not in pdf_hash_mismatch_seen: |
|
|
pdf_hash_mismatch_seen.add(mismatch_key) |
|
|
pdf_hash_mismatches.append( |
|
|
{"paper_id": paper_id, "pdf": str(pdf_path)}, |
|
|
) |
|
|
if not args.allow_pdf_hash_mismatch and pdf_direct_match: |
|
|
print( |
|
|
f"Warning: PDF hash markers did not match for {pdf_path.name}; " |
|
|
"skipping PDF (use --allow-pdf-hash-mismatch to override).", |
|
|
file=sys.stderr, |
|
|
) |
|
|
elif args.allow_pdf_hash_mismatch: |
|
|
print( |
|
|
f"Warning: PDF hash markers did not match for {pdf_path.name}; " |
|
|
"continuing with direct filename match.", |
|
|
file=sys.stderr, |
|
|
) |
|
|
if not args.allow_pdf_hash_mismatch: |
|
|
pdf_path = None |
|
|
pdf_token_index = None |
|
|
pdf_direct_match = False |
|
|
if pdf_path is None and hash_specs: |
|
|
pdf_paths = list({p for p in pdf_index.values()}) |
|
|
if pdf_paths: |
|
|
pdf_path = _pick_best_pdf( |
|
|
pdf_paths, |
|
|
pdf_token_cache, |
|
|
hash_specs, |
|
|
) |
|
|
|
|
|
if args.filter_to_pdfs and pdf_path is None: |
|
|
continue |
|
|
|
|
|
if pdf_path is not None and pdf_path not in pdf_token_cache: |
|
|
try: |
|
|
pdf_text = extract_text_from_pdf(pdf_path) |
|
|
pdf_token_cache[pdf_path] = TokenIndex.from_text(pdf_text) |
|
|
except Exception as exc: |
|
|
pdf_token_cache[pdf_path] = TokenIndex.from_text("") |
|
|
if pdf_path not in pdf_failed: |
|
|
pdf_failed.add(pdf_path) |
|
|
print( |
|
|
f"Warning: PDF text extraction failed for {pdf_path.name}: {exc}", |
|
|
file=sys.stderr, |
|
|
) |
|
|
pdf_token_index = pdf_token_cache.get(pdf_path) if pdf_path else None |
|
|
|
|
|
if doc_index is None: |
|
|
missing_papers.add(paper_id) |
|
|
else: |
|
|
def_start = row.get("definition_char_start") or "" |
|
|
def_end = row.get("definition_char_end") or "" |
|
|
ctx_start = row.get("context_char_start") or "" |
|
|
ctx_end = row.get("context_char_end") or "" |
|
|
def_strip_brackets, def_strip_parens = _strip_flags( |
|
|
row, |
|
|
"definition", |
|
|
) |
|
|
ctx_strip_brackets, ctx_strip_parens = _strip_flags(row, "context") |
|
|
|
|
|
if not definition and tei_token_index: |
|
|
spec = _select_hash_specs(row, "definition") |
|
|
if spec: |
|
|
span = tei_token_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not definition: |
|
|
stripped_index = _get_stripped_index( |
|
|
tei_token_cache_stripped, |
|
|
tei_path, |
|
|
doc_index.doc_text, |
|
|
def_strip_brackets, |
|
|
def_strip_parens, |
|
|
) |
|
|
if stripped_index is not None: |
|
|
span = stripped_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
stripped_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not definition and not (def_start and def_end): |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("definition_token_count") or 0) |
|
|
for head_spec in head_specs or [None]: |
|
|
for tail_spec in tail_specs or [None]: |
|
|
if head_spec is None or tail_spec is None: |
|
|
continue |
|
|
span = _find_span_by_anchors( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_by_anchors( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
break |
|
|
if definition: |
|
|
break |
|
|
if not definition: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("definition_token_count") or 0) |
|
|
span = None |
|
|
for head_spec in head_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span is None: |
|
|
for tail_spec in tail_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
elif span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not definition and def_start and def_end: |
|
|
candidate = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
int(def_start), |
|
|
int(def_end), |
|
|
) |
|
|
if _span_matches_hash(row, candidate, "definition"): |
|
|
definition = candidate |
|
|
if not definition and pdf_token_index: |
|
|
span = _find_pdf_hash_span(row, pdf_token_index, "definition") |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
if not definition: |
|
|
stripped_index = _get_stripped_index( |
|
|
pdf_token_cache_stripped, |
|
|
pdf_path, |
|
|
pdf_token_index.doc_text, |
|
|
def_strip_brackets, |
|
|
def_strip_parens, |
|
|
) |
|
|
if stripped_index is not None: |
|
|
span = _find_pdf_hash_span( |
|
|
row, |
|
|
stripped_index, |
|
|
"definition", |
|
|
) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
stripped_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
|
|
|
if not context and tei_token_index: |
|
|
spec = _select_hash_specs(row, "context") |
|
|
if spec: |
|
|
span = tei_token_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not context: |
|
|
stripped_index = _get_stripped_index( |
|
|
tei_token_cache_stripped, |
|
|
tei_path, |
|
|
doc_index.doc_text, |
|
|
ctx_strip_brackets, |
|
|
ctx_strip_parens, |
|
|
) |
|
|
if stripped_index is not None: |
|
|
span = stripped_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
stripped_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not context and not (ctx_start and ctx_end): |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("context_token_count") or 0) |
|
|
for head_spec in head_specs or [None]: |
|
|
for tail_spec in tail_specs or [None]: |
|
|
if head_spec is None or tail_spec is None: |
|
|
continue |
|
|
span = _find_span_by_anchors( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_by_anchors( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
break |
|
|
if context: |
|
|
break |
|
|
if not context: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("context_token_count") or 0) |
|
|
span = None |
|
|
for head_spec in head_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span is None: |
|
|
for tail_spec in tail_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
elif span is None: |
|
|
span = _find_span_from_anchor( |
|
|
tei_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
if not context and ctx_start and ctx_end: |
|
|
candidate = _extract_with_trailing_punct( |
|
|
doc_index.doc_text, |
|
|
int(ctx_start), |
|
|
int(ctx_end), |
|
|
) |
|
|
if _span_matches_hash(row, candidate, "context"): |
|
|
context = candidate |
|
|
if not context and pdf_token_index: |
|
|
span = _find_pdf_hash_span(row, pdf_token_index, "context") |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
if not context: |
|
|
stripped_index = _get_stripped_index( |
|
|
pdf_token_cache_stripped, |
|
|
pdf_path, |
|
|
pdf_token_index.doc_text, |
|
|
ctx_strip_brackets, |
|
|
ctx_strip_parens, |
|
|
) |
|
|
if stripped_index is not None: |
|
|
span = _find_pdf_hash_span( |
|
|
row, |
|
|
stripped_index, |
|
|
"context", |
|
|
) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
stripped_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
|
|
|
if not definition and pdf_path is not None and pdf_token_index: |
|
|
spec = _select_hash_specs(row, "definition") |
|
|
if spec: |
|
|
span = pdf_token_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
if not definition: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("definition_token_count") or 0) |
|
|
for head_spec in head_specs or [None]: |
|
|
for tail_spec in tail_specs or [None]: |
|
|
if head_spec is None or tail_spec is None: |
|
|
continue |
|
|
span = _find_span_by_anchors( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_by_anchors( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
) |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
hydrated_from_anchor += 1 |
|
|
break |
|
|
if definition: |
|
|
break |
|
|
if not definition: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"definition", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("definition_token_count") or 0) |
|
|
span = None |
|
|
for head_spec in head_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span is None: |
|
|
for tail_spec in tail_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span: |
|
|
definition = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
hydrated_from_anchor += 1 |
|
|
|
|
|
if not definition: |
|
|
missing_defs += 1 |
|
|
missing_def_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_definition", |
|
|
}, |
|
|
) |
|
|
|
|
|
if not context and pdf_path is not None and pdf_token_index: |
|
|
spec = _select_hash_specs(row, "context") |
|
|
if spec: |
|
|
span = pdf_token_index.find_span_by_hash(*spec) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
if not context: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("context_token_count") or 0) |
|
|
for head_spec in head_specs or [None]: |
|
|
for tail_spec in tail_specs or [None]: |
|
|
if head_spec is None or tail_spec is None: |
|
|
continue |
|
|
span = _find_span_by_anchors( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_by_anchors( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
) |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
hydrated_from_anchor += 1 |
|
|
break |
|
|
if context: |
|
|
break |
|
|
if not context: |
|
|
head_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"head", |
|
|
) |
|
|
mid_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"mid", |
|
|
) |
|
|
tail_specs = _select_anchor_spec_list( |
|
|
row, |
|
|
"context", |
|
|
"tail", |
|
|
) |
|
|
expected_len = int(row.get("context_token_count") or 0) |
|
|
span = None |
|
|
for head_spec in head_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
head_spec, |
|
|
expected_len, |
|
|
"head", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span is None: |
|
|
for tail_spec in tail_specs: |
|
|
if mid_specs: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_mid=True, |
|
|
) |
|
|
if span is None: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
require_unique=True, |
|
|
) |
|
|
else: |
|
|
span = _find_span_from_anchor( |
|
|
pdf_token_index, |
|
|
tail_spec, |
|
|
expected_len, |
|
|
"tail", |
|
|
mid_specs, |
|
|
) |
|
|
if span: |
|
|
break |
|
|
if span: |
|
|
context = _extract_with_trailing_punct( |
|
|
pdf_token_index.doc_text, |
|
|
span[0], |
|
|
span[1], |
|
|
) |
|
|
hydrated_from_pdf += 1 |
|
|
hydrated_from_anchor += 1 |
|
|
|
|
|
if not context: |
|
|
missing_ctxs += 1 |
|
|
missing_ctx_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_context", |
|
|
}, |
|
|
) |
|
|
|
|
|
def_preserve_lines = _row_flag( |
|
|
row, |
|
|
"definition_preserve_linebreaks", |
|
|
) |
|
|
ctx_preserve_lines = _row_flag( |
|
|
row, |
|
|
"context_preserve_linebreaks", |
|
|
) |
|
|
def_preserve_hyph = _row_flag( |
|
|
row, |
|
|
"definition_preserve_hyphenation", |
|
|
) |
|
|
ctx_preserve_hyph = _row_flag( |
|
|
row, |
|
|
"context_preserve_hyphenation", |
|
|
) |
|
|
def_keep_bracket = _row_flag( |
|
|
row, |
|
|
"definition_has_bracket_citation", |
|
|
True, |
|
|
) |
|
|
def_keep_paren = _row_flag( |
|
|
row, |
|
|
"definition_has_paren_citation", |
|
|
True, |
|
|
) |
|
|
def_split_letter_digit = not _row_flag( |
|
|
row, |
|
|
"definition_has_letter_digit", |
|
|
) |
|
|
ctx_keep_bracket = _row_flag( |
|
|
row, |
|
|
"context_has_bracket_citation", |
|
|
True, |
|
|
) |
|
|
ctx_keep_paren = _row_flag( |
|
|
row, |
|
|
"context_has_paren_citation", |
|
|
True, |
|
|
) |
|
|
ctx_split_letter_digit = not _row_flag( |
|
|
row, |
|
|
"context_has_letter_digit", |
|
|
) |
|
|
|
|
|
output_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"paper_title": row.get("paper_title", ""), |
|
|
"paper_doi": doi, |
|
|
"paper_arxiv": arxiv, |
|
|
"concept": row.get("concept", ""), |
|
|
"definition": _ensure_trailing_punct( |
|
|
_postprocess_text( |
|
|
definition, |
|
|
int(row.get("definition_token_count") or 0), |
|
|
def_preserve_lines, |
|
|
def_preserve_hyph, |
|
|
def_keep_bracket, |
|
|
def_keep_paren, |
|
|
def_split_letter_digit, |
|
|
), |
|
|
row.get("definition_end_punct", ""), |
|
|
), |
|
|
"context": _ensure_trailing_punct( |
|
|
_postprocess_text( |
|
|
context, |
|
|
int(row.get("context_token_count") or 0), |
|
|
ctx_preserve_lines, |
|
|
ctx_preserve_hyph, |
|
|
ctx_keep_bracket, |
|
|
ctx_keep_paren, |
|
|
ctx_split_letter_digit, |
|
|
), |
|
|
row.get("context_end_punct", ""), |
|
|
), |
|
|
"definition_type": row.get("definition_type", ""), |
|
|
"source_file": row.get("source_file", ""), |
|
|
"is_out_of_domain": row.get("is_out_of_domain", ""), |
|
|
}, |
|
|
) |
|
|
|
|
|
args.output_csv.parent.mkdir(parents=True, exist_ok=True) |
|
|
with args.output_csv.open("w", encoding="utf-8", newline="") as handle: |
|
|
fieldnames = [ |
|
|
"paper_id", |
|
|
"paper_title", |
|
|
"paper_doi", |
|
|
"paper_arxiv", |
|
|
"concept", |
|
|
"definition", |
|
|
"context", |
|
|
"definition_type", |
|
|
"source_file", |
|
|
"is_out_of_domain", |
|
|
] |
|
|
writer = csv.DictWriter(handle, fieldnames=fieldnames) |
|
|
writer.writeheader() |
|
|
for row in output_rows: |
|
|
writer.writerow(row) |
|
|
|
|
|
print(f"Wrote hydrated CSV to {args.output_csv}") |
|
|
print(f"Missing TEI for {len(missing_papers)} papers") |
|
|
print(f"Missing definition spans: {missing_defs}") |
|
|
print(f"Missing context spans: {missing_ctxs}") |
|
|
print( |
|
|
"Hydrated from PDF fallback: " |
|
|
f"{hydrated_from_pdf} (anchors used: {hydrated_from_anchor})", |
|
|
) |
|
|
if args.report is not None: |
|
|
report_lines = [] |
|
|
if missing_papers: |
|
|
report_lines.append("Missing papers:") |
|
|
for paper_id in sorted(missing_papers): |
|
|
report_lines.append(f"- {paper_id}") |
|
|
report_lines.append("") |
|
|
if pdf_hash_mismatches: |
|
|
report_lines.append( |
|
|
"PDF hash mismatches (filename matched, hash did not):", |
|
|
) |
|
|
for item in pdf_hash_mismatches: |
|
|
report_lines.append( |
|
|
f"- {item['paper_id']} | {item['pdf']}", |
|
|
) |
|
|
report_lines.append( |
|
|
"Note: rerun with --allow-pdf-hash-mismatch to continue with these PDFs.", |
|
|
) |
|
|
report_lines.append("") |
|
|
report_lines.append(f"Missing definition spans: {missing_defs}") |
|
|
report_lines.append(f"Missing context spans: {missing_ctxs}") |
|
|
if missing_def_rows: |
|
|
report_lines.append("") |
|
|
report_lines.append("Missing definitions (paper_id | concept):") |
|
|
for item in missing_def_rows: |
|
|
report_lines.append( |
|
|
f"- {item['paper_id']} | {item['concept']}", |
|
|
) |
|
|
if missing_ctx_rows: |
|
|
report_lines.append("") |
|
|
report_lines.append("Missing contexts (paper_id | concept):") |
|
|
for item in missing_ctx_rows: |
|
|
report_lines.append( |
|
|
f"- {item['paper_id']} | {item['concept']}", |
|
|
) |
|
|
args.report.parent.mkdir(parents=True, exist_ok=True) |
|
|
args.report.write_text( |
|
|
"\n".join(report_lines) + "\n", |
|
|
encoding="utf-8", |
|
|
) |
|
|
print(f"Wrote report to {args.report}") |
|
|
if args.require_complete and (missing_defs or missing_ctxs): |
|
|
raise SystemExit( |
|
|
"Hydration incomplete: " |
|
|
f"{missing_defs} definitions, {missing_ctxs} contexts missing.", |
|
|
) |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
main() |
|
|
|
