| | 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() |
| |
|
