|
|
from __future__ import annotations |
|
|
|
|
|
|
|
|
|
|
|
import argparse |
|
|
import csv |
|
|
import re |
|
|
import sys |
|
|
from pathlib import Path |
|
|
from typing import Dict, Optional |
|
|
|
|
|
try: |
|
|
from scripts.defextra_markers import ( |
|
|
ANCHOR_WINDOW, |
|
|
ANCHOR_WINDOW_ALT, |
|
|
DocIndex, |
|
|
HASH_VERSION, |
|
|
TokenIndex, |
|
|
build_tei_index, |
|
|
hash_token_sequence, |
|
|
tokenize_text, |
|
|
normalize_paper_id, |
|
|
) |
|
|
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 ( |
|
|
ANCHOR_WINDOW, |
|
|
ANCHOR_WINDOW_ALT, |
|
|
DocIndex, |
|
|
HASH_VERSION, |
|
|
TokenIndex, |
|
|
build_tei_index, |
|
|
hash_token_sequence, |
|
|
tokenize_text, |
|
|
normalize_paper_id, |
|
|
) |
|
|
|
|
|
TRAILING_PUNCT = {".", ",", ";", ":", "?", "!"} |
|
|
TRAILING_QUOTES = {"'", '"', "”", "’", ")", "]"} |
|
|
CITATION_BRACKET_RE = re.compile(r"\[[0-9][0-9,;\s\-–]*\]") |
|
|
CITATION_PAREN_RE = re.compile(r"\([^)]*\d{4}[^)]*\)") |
|
|
|
|
|
|
|
|
def _extract_end_punct(text: str) -> str: |
|
|
trimmed = text.rstrip() |
|
|
if not trimmed: |
|
|
return "" |
|
|
i = len(trimmed) - 1 |
|
|
while i >= 0 and trimmed[i] in TRAILING_QUOTES: |
|
|
i -= 1 |
|
|
if i >= 0 and trimmed[i] in TRAILING_PUNCT: |
|
|
return trimmed[i] |
|
|
return "" |
|
|
|
|
|
|
|
|
def _spec( |
|
|
count: str, |
|
|
hash64: str, |
|
|
sha: str, |
|
|
) -> Optional[tuple[int, int, str]]: |
|
|
if not count or not hash64 or not sha: |
|
|
return None |
|
|
try: |
|
|
return int(count), int(hash64), sha |
|
|
except ValueError: |
|
|
return None |
|
|
|
|
|
|
|
|
def _build_mid_candidates( |
|
|
token_index: TokenIndex, |
|
|
mid_specs: 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, |
|
|
) -> Optional[tuple[int, int]]: |
|
|
if head_spec is None or tail_spec is None or expected_len <= 0: |
|
|
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 = _build_mid_candidates(token_index, mid_specs or []) |
|
|
best = None |
|
|
best_diff = None |
|
|
tol = max(5, int(expected_len * 0.3)) |
|
|
min_len = max(1, expected_len // 2) |
|
|
max_len = expected_len * 3 |
|
|
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 |
|
|
if mid_candidates and not _span_has_mid( |
|
|
mid_candidates, |
|
|
head_start, |
|
|
tail_end, |
|
|
): |
|
|
continue |
|
|
length = tail_end - head_start + 1 |
|
|
if length < min_len or length > max_len: |
|
|
continue |
|
|
if length < expected_len - tol or length > expected_len + tol: |
|
|
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, |
|
|
) -> 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 |
|
|
mid_candidates = _build_mid_candidates(token_index, mid_specs or []) |
|
|
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 _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]: |
|
|
candidates = [paper_id, normalize_paper_id(paper_id)] |
|
|
if doi: |
|
|
candidates.append(doi) |
|
|
if arxiv: |
|
|
candidates.append(arxiv) |
|
|
seen = set() |
|
|
ordered = [] |
|
|
for item in candidates: |
|
|
value = item.strip() |
|
|
if value and value not in seen: |
|
|
seen.add(value) |
|
|
ordered.append(value) |
|
|
return ordered |
|
|
|
|
|
|
|
|
def _resolve_tei_path( |
|
|
paper_id: str, |
|
|
doi: str, |
|
|
arxiv: str, |
|
|
tei_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] |
|
|
return None |
|
|
|
|
|
|
|
|
def main() -> None: |
|
|
parser = argparse.ArgumentParser( |
|
|
description="Build legal DefExtra CSV with GROBID markers.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--input-csv", |
|
|
type=Path, |
|
|
default=Path("results/paper_results/defextra_hf.csv"), |
|
|
help="Source DefExtra CSV (contains excerpts).", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--output-csv", |
|
|
type=Path, |
|
|
default=Path("results/paper_results/defextra_legal.csv"), |
|
|
help="Output legal DefExtra CSV (no excerpts).", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--tei-dir", |
|
|
type=Path, |
|
|
nargs="+", |
|
|
default=[ |
|
|
Path("ManualPDFsGROBID/manual_pdfs_grobid"), |
|
|
Path("ManualPDFsGROBID/new_grobid"), |
|
|
], |
|
|
help="Directories with GROBID TEI files.", |
|
|
) |
|
|
parser.add_argument( |
|
|
"--report", |
|
|
type=Path, |
|
|
default=None, |
|
|
help="Optional report path for missing TEI spans.", |
|
|
) |
|
|
args = parser.parse_args() |
|
|
|
|
|
if not args.input_csv.exists(): |
|
|
raise SystemExit(f"Input CSV not found: {args.input_csv}") |
|
|
|
|
|
tei_index = build_tei_index(args.tei_dir) |
|
|
doc_cache: Dict[str, Optional[DocIndex]] = {} |
|
|
token_cache: Dict[str, Optional[TokenIndex]] = {} |
|
|
|
|
|
rows = [] |
|
|
with args.input_csv.open("r", encoding="utf-8", newline="") as handle: |
|
|
reader = csv.DictReader(handle) |
|
|
for row in reader: |
|
|
rows.append(row) |
|
|
|
|
|
output_rows = [] |
|
|
missing_tei = 0 |
|
|
missing_def = 0 |
|
|
missing_ctx = 0 |
|
|
missing_def_rows: list[dict] = [] |
|
|
missing_ctx_rows: list[dict] = [] |
|
|
def_hash_available = 0 |
|
|
ctx_hash_available = 0 |
|
|
def_anchor_available = 0 |
|
|
ctx_anchor_available = 0 |
|
|
|
|
|
for row in rows: |
|
|
paper_id = (row.get("paper_id") or "").strip() |
|
|
doi = (row.get("paper_doi") or "").strip() |
|
|
arxiv = (row.get("paper_arxiv") or "").strip() |
|
|
definition = row.get("definition") or "" |
|
|
context = row.get("context") or "" |
|
|
|
|
|
if paper_id not in doc_cache: |
|
|
tei_path = _resolve_tei_path(paper_id, doi, arxiv, tei_index) |
|
|
if tei_path is None: |
|
|
doc_cache[paper_id] = None |
|
|
token_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, |
|
|
) |
|
|
|
|
|
doc_index = doc_cache.get(paper_id) |
|
|
def_start = def_end = ctx_start = ctx_end = "" |
|
|
def_match = ctx_match = "missing" |
|
|
def_hash64 = def_sha = def_tok_len = "" |
|
|
ctx_hash64 = ctx_sha = ctx_tok_len = "" |
|
|
def_head_hash64 = def_head_sha = def_head_len = "" |
|
|
def_tail_hash64 = def_tail_sha = def_tail_len = "" |
|
|
def_mid_hash64 = def_mid_sha = def_mid_len = "" |
|
|
def_head_alt_hash64 = def_head_alt_sha = def_head_alt_len = "" |
|
|
def_tail_alt_hash64 = def_tail_alt_sha = def_tail_alt_len = "" |
|
|
def_mid_alt_hash64 = def_mid_alt_sha = def_mid_alt_len = "" |
|
|
ctx_head_hash64 = ctx_head_sha = ctx_head_len = "" |
|
|
ctx_tail_hash64 = ctx_tail_sha = ctx_tail_len = "" |
|
|
ctx_mid_hash64 = ctx_mid_sha = ctx_mid_len = "" |
|
|
ctx_head_alt_hash64 = ctx_head_alt_sha = ctx_head_alt_len = "" |
|
|
ctx_tail_alt_hash64 = ctx_tail_alt_sha = ctx_tail_alt_len = "" |
|
|
ctx_mid_alt_hash64 = ctx_mid_alt_sha = ctx_mid_alt_len = "" |
|
|
def_anchor_has = False |
|
|
ctx_anchor_has = False |
|
|
def_preserve_linebreaks = "true" if "\n" in definition else "false" |
|
|
ctx_preserve_linebreaks = "true" if "\n" in context else "false" |
|
|
def_preserve_hyphenation = ( |
|
|
"true" |
|
|
if re.search(r"[A-Za-z]-\s+[A-Za-z]", definition) |
|
|
else "false" |
|
|
) |
|
|
ctx_preserve_hyphenation = ( |
|
|
"true" if re.search(r"[A-Za-z]-\s+[A-Za-z]", context) else "false" |
|
|
) |
|
|
def_has_bracket_citation = ( |
|
|
"true" if CITATION_BRACKET_RE.search(definition) else "false" |
|
|
) |
|
|
def_has_paren_citation = ( |
|
|
"true" if CITATION_PAREN_RE.search(definition) else "false" |
|
|
) |
|
|
def_has_letter_digit = ( |
|
|
"true" if re.search(r"[A-Za-z][0-9]", definition) else "false" |
|
|
) |
|
|
ctx_has_bracket_citation = ( |
|
|
"true" if CITATION_BRACKET_RE.search(context) else "false" |
|
|
) |
|
|
ctx_has_paren_citation = ( |
|
|
"true" if CITATION_PAREN_RE.search(context) else "false" |
|
|
) |
|
|
ctx_has_letter_digit = ( |
|
|
"true" if re.search(r"[A-Za-z][0-9]", context) else "false" |
|
|
) |
|
|
def_end_punct = _extract_end_punct(definition) |
|
|
ctx_end_punct = _extract_end_punct(context) |
|
|
|
|
|
def_tokens, _ = tokenize_text(definition, return_spans=False) |
|
|
if def_tokens: |
|
|
h64, sha, tok_len = hash_token_sequence(def_tokens) |
|
|
def_hash64 = str(h64) |
|
|
def_sha = sha |
|
|
def_tok_len = str(tok_len) |
|
|
def_hash_available += 1 |
|
|
if tok_len >= ANCHOR_WINDOW: |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[:ANCHOR_WINDOW], |
|
|
) |
|
|
def_head_hash64 = str(h64) |
|
|
def_head_sha = sha |
|
|
def_head_len = str(tok_len) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[-ANCHOR_WINDOW:], |
|
|
) |
|
|
def_tail_hash64 = str(h64) |
|
|
def_tail_sha = sha |
|
|
def_tail_len = str(tok_len) |
|
|
mid_start = max(0, (len(def_tokens) - ANCHOR_WINDOW) // 2) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[mid_start : mid_start + ANCHOR_WINDOW], |
|
|
) |
|
|
def_mid_hash64 = str(h64) |
|
|
def_mid_sha = sha |
|
|
def_mid_len = str(tok_len) |
|
|
def_anchor_has = True |
|
|
if tok_len >= 2: |
|
|
alt_window = ( |
|
|
ANCHOR_WINDOW_ALT |
|
|
if tok_len >= ANCHOR_WINDOW_ALT |
|
|
else max(2, tok_len - 1) |
|
|
) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[:alt_window], |
|
|
) |
|
|
def_head_alt_hash64 = str(h64) |
|
|
def_head_alt_sha = sha |
|
|
def_head_alt_len = str(tok_len) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[-alt_window:], |
|
|
) |
|
|
def_tail_alt_hash64 = str(h64) |
|
|
def_tail_alt_sha = sha |
|
|
def_tail_alt_len = str(tok_len) |
|
|
mid_start = max(0, (len(def_tokens) - alt_window) // 2) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
def_tokens[mid_start : mid_start + alt_window], |
|
|
) |
|
|
def_mid_alt_hash64 = str(h64) |
|
|
def_mid_alt_sha = sha |
|
|
def_mid_alt_len = str(tok_len) |
|
|
def_anchor_has = True |
|
|
|
|
|
ctx_tokens, _ = tokenize_text(context, return_spans=False) |
|
|
if ctx_tokens: |
|
|
h64, sha, tok_len = hash_token_sequence(ctx_tokens) |
|
|
ctx_hash64 = str(h64) |
|
|
ctx_sha = sha |
|
|
ctx_tok_len = str(tok_len) |
|
|
ctx_hash_available += 1 |
|
|
if tok_len >= ANCHOR_WINDOW: |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[:ANCHOR_WINDOW], |
|
|
) |
|
|
ctx_head_hash64 = str(h64) |
|
|
ctx_head_sha = sha |
|
|
ctx_head_len = str(tok_len) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[-ANCHOR_WINDOW:], |
|
|
) |
|
|
ctx_tail_hash64 = str(h64) |
|
|
ctx_tail_sha = sha |
|
|
ctx_tail_len = str(tok_len) |
|
|
mid_start = max(0, (len(ctx_tokens) - ANCHOR_WINDOW) // 2) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[mid_start : mid_start + ANCHOR_WINDOW], |
|
|
) |
|
|
ctx_mid_hash64 = str(h64) |
|
|
ctx_mid_sha = sha |
|
|
ctx_mid_len = str(tok_len) |
|
|
ctx_anchor_has = True |
|
|
if tok_len >= 2: |
|
|
alt_window = ( |
|
|
ANCHOR_WINDOW_ALT |
|
|
if tok_len >= ANCHOR_WINDOW_ALT |
|
|
else max(2, tok_len - 1) |
|
|
) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[:alt_window], |
|
|
) |
|
|
ctx_head_alt_hash64 = str(h64) |
|
|
ctx_head_alt_sha = sha |
|
|
ctx_head_alt_len = str(tok_len) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[-alt_window:], |
|
|
) |
|
|
ctx_tail_alt_hash64 = str(h64) |
|
|
ctx_tail_alt_sha = sha |
|
|
ctx_tail_alt_len = str(tok_len) |
|
|
mid_start = max(0, (len(ctx_tokens) - alt_window) // 2) |
|
|
h64, sha, tok_len = hash_token_sequence( |
|
|
ctx_tokens[mid_start : mid_start + alt_window], |
|
|
) |
|
|
ctx_mid_alt_hash64 = str(h64) |
|
|
ctx_mid_alt_sha = sha |
|
|
ctx_mid_alt_len = str(tok_len) |
|
|
ctx_anchor_has = True |
|
|
|
|
|
if def_anchor_has: |
|
|
def_anchor_available += 1 |
|
|
if ctx_anchor_has: |
|
|
ctx_anchor_available += 1 |
|
|
|
|
|
def_head_spec = _spec(def_head_len, def_head_hash64, def_head_sha) |
|
|
def_head_alt_spec = _spec( |
|
|
def_head_alt_len, |
|
|
def_head_alt_hash64, |
|
|
def_head_alt_sha, |
|
|
) |
|
|
def_mid_spec = _spec(def_mid_len, def_mid_hash64, def_mid_sha) |
|
|
def_mid_alt_spec = _spec( |
|
|
def_mid_alt_len, |
|
|
def_mid_alt_hash64, |
|
|
def_mid_alt_sha, |
|
|
) |
|
|
def_tail_spec = _spec(def_tail_len, def_tail_hash64, def_tail_sha) |
|
|
def_tail_alt_spec = _spec( |
|
|
def_tail_alt_len, |
|
|
def_tail_alt_hash64, |
|
|
def_tail_alt_sha, |
|
|
) |
|
|
ctx_head_spec = _spec(ctx_head_len, ctx_head_hash64, ctx_head_sha) |
|
|
ctx_head_alt_spec = _spec( |
|
|
ctx_head_alt_len, |
|
|
ctx_head_alt_hash64, |
|
|
ctx_head_alt_sha, |
|
|
) |
|
|
ctx_mid_spec = _spec(ctx_mid_len, ctx_mid_hash64, ctx_mid_sha) |
|
|
ctx_mid_alt_spec = _spec( |
|
|
ctx_mid_alt_len, |
|
|
ctx_mid_alt_hash64, |
|
|
ctx_mid_alt_sha, |
|
|
) |
|
|
ctx_tail_spec = _spec(ctx_tail_len, ctx_tail_hash64, ctx_tail_sha) |
|
|
ctx_tail_alt_spec = _spec( |
|
|
ctx_tail_alt_len, |
|
|
ctx_tail_alt_hash64, |
|
|
ctx_tail_alt_sha, |
|
|
) |
|
|
|
|
|
token_index = token_cache.get(paper_id) |
|
|
if doc_index is None: |
|
|
missing_tei += 1 |
|
|
else: |
|
|
def_span = doc_index.find_span(definition) |
|
|
if def_span is not None: |
|
|
def_start, def_end, def_match = def_span |
|
|
else: |
|
|
if def_hash64 and def_sha and def_tok_len and token_index: |
|
|
span = token_index.find_span_by_hash( |
|
|
int(def_tok_len), |
|
|
int(def_hash64), |
|
|
def_sha, |
|
|
) |
|
|
if span: |
|
|
def_start, def_end = span |
|
|
def_match = "hash" |
|
|
else: |
|
|
expected_len = int(def_tok_len or 0) |
|
|
head_specs = [ |
|
|
spec |
|
|
for spec in (def_head_spec, def_head_alt_spec) |
|
|
if spec |
|
|
] |
|
|
mid_specs = [ |
|
|
spec |
|
|
for spec in (def_mid_spec, def_mid_alt_spec) |
|
|
if spec |
|
|
] |
|
|
tail_specs = [ |
|
|
spec |
|
|
for spec in (def_tail_spec, def_tail_alt_spec) |
|
|
if spec |
|
|
] |
|
|
if ( |
|
|
token_index |
|
|
and expected_len |
|
|
and head_specs |
|
|
and tail_specs |
|
|
): |
|
|
for head in head_specs: |
|
|
for tail in tail_specs: |
|
|
anchor_span = _find_span_by_anchors( |
|
|
token_index, |
|
|
head, |
|
|
tail, |
|
|
expected_len, |
|
|
mid_specs=mid_specs, |
|
|
) |
|
|
if anchor_span: |
|
|
def_start, def_end = anchor_span |
|
|
def_match = "anchor" |
|
|
break |
|
|
if def_match == "anchor": |
|
|
break |
|
|
if ( |
|
|
def_match != "anchor" |
|
|
and token_index |
|
|
and expected_len |
|
|
): |
|
|
for spec, position in ( |
|
|
(def_head_spec, "head"), |
|
|
(def_head_alt_spec, "head"), |
|
|
(def_mid_spec, "head"), |
|
|
(def_mid_alt_spec, "head"), |
|
|
(def_tail_spec, "tail"), |
|
|
(def_tail_alt_spec, "tail"), |
|
|
): |
|
|
anchor_span = _find_span_from_anchor( |
|
|
token_index, |
|
|
spec, |
|
|
expected_len, |
|
|
position, |
|
|
mid_specs=mid_specs, |
|
|
) |
|
|
if anchor_span: |
|
|
def_start, def_end = anchor_span |
|
|
def_match = "anchor" |
|
|
break |
|
|
if def_match != "anchor": |
|
|
missing_def += 1 |
|
|
missing_def_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_definition_span", |
|
|
}, |
|
|
) |
|
|
else: |
|
|
missing_def += 1 |
|
|
missing_def_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_definition_span", |
|
|
}, |
|
|
) |
|
|
|
|
|
ctx_span = doc_index.find_span(context) |
|
|
if ctx_span is not None: |
|
|
ctx_start, ctx_end, ctx_match = ctx_span |
|
|
else: |
|
|
if ctx_hash64 and ctx_sha and ctx_tok_len and token_index: |
|
|
span = token_index.find_span_by_hash( |
|
|
int(ctx_tok_len), |
|
|
int(ctx_hash64), |
|
|
ctx_sha, |
|
|
) |
|
|
if span: |
|
|
ctx_start, ctx_end = span |
|
|
ctx_match = "hash" |
|
|
else: |
|
|
expected_len = int(ctx_tok_len or 0) |
|
|
head_specs = [ |
|
|
spec |
|
|
for spec in (ctx_head_spec, ctx_head_alt_spec) |
|
|
if spec |
|
|
] |
|
|
mid_specs = [ |
|
|
spec |
|
|
for spec in (ctx_mid_spec, ctx_mid_alt_spec) |
|
|
if spec |
|
|
] |
|
|
tail_specs = [ |
|
|
spec |
|
|
for spec in (ctx_tail_spec, ctx_tail_alt_spec) |
|
|
if spec |
|
|
] |
|
|
if ( |
|
|
token_index |
|
|
and expected_len |
|
|
and head_specs |
|
|
and tail_specs |
|
|
): |
|
|
for head in head_specs: |
|
|
for tail in tail_specs: |
|
|
anchor_span = _find_span_by_anchors( |
|
|
token_index, |
|
|
head, |
|
|
tail, |
|
|
expected_len, |
|
|
mid_specs=mid_specs, |
|
|
) |
|
|
if anchor_span: |
|
|
ctx_start, ctx_end = anchor_span |
|
|
ctx_match = "anchor" |
|
|
break |
|
|
if ctx_match == "anchor": |
|
|
break |
|
|
if ( |
|
|
ctx_match != "anchor" |
|
|
and token_index |
|
|
and expected_len |
|
|
): |
|
|
for spec, position in ( |
|
|
(ctx_head_spec, "head"), |
|
|
(ctx_head_alt_spec, "head"), |
|
|
(ctx_mid_spec, "head"), |
|
|
(ctx_mid_alt_spec, "head"), |
|
|
(ctx_tail_spec, "tail"), |
|
|
(ctx_tail_alt_spec, "tail"), |
|
|
): |
|
|
anchor_span = _find_span_from_anchor( |
|
|
token_index, |
|
|
spec, |
|
|
expected_len, |
|
|
position, |
|
|
mid_specs=mid_specs, |
|
|
) |
|
|
if anchor_span: |
|
|
ctx_start, ctx_end = anchor_span |
|
|
ctx_match = "anchor" |
|
|
break |
|
|
if ctx_match != "anchor": |
|
|
missing_ctx += 1 |
|
|
missing_ctx_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_context_span", |
|
|
}, |
|
|
) |
|
|
else: |
|
|
missing_ctx += 1 |
|
|
missing_ctx_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"concept": row.get("concept", ""), |
|
|
"reason": "missing_context_span", |
|
|
}, |
|
|
) |
|
|
|
|
|
output_rows.append( |
|
|
{ |
|
|
"paper_id": paper_id, |
|
|
"paper_title": row.get("paper_title", ""), |
|
|
"paper_doi": doi, |
|
|
"paper_arxiv": arxiv, |
|
|
"concept": row.get("concept", ""), |
|
|
"definition_type": row.get("definition_type", ""), |
|
|
"source_file": row.get("source_file", ""), |
|
|
"is_out_of_domain": row.get("is_out_of_domain", ""), |
|
|
"definition_preserve_linebreaks": def_preserve_linebreaks, |
|
|
"context_preserve_linebreaks": ctx_preserve_linebreaks, |
|
|
"definition_preserve_hyphenation": def_preserve_hyphenation, |
|
|
"context_preserve_hyphenation": ctx_preserve_hyphenation, |
|
|
"definition_has_bracket_citation": def_has_bracket_citation, |
|
|
"definition_has_paren_citation": def_has_paren_citation, |
|
|
"definition_has_letter_digit": def_has_letter_digit, |
|
|
"context_has_bracket_citation": ctx_has_bracket_citation, |
|
|
"context_has_paren_citation": ctx_has_paren_citation, |
|
|
"context_has_letter_digit": ctx_has_letter_digit, |
|
|
"definition_end_punct": def_end_punct, |
|
|
"context_end_punct": ctx_end_punct, |
|
|
"marker_version": "grobid_text_v1", |
|
|
"hash_version": HASH_VERSION, |
|
|
"definition_char_start": def_start, |
|
|
"definition_char_end": def_end, |
|
|
"definition_match": def_match, |
|
|
"definition_hash64": def_hash64, |
|
|
"definition_sha256": def_sha, |
|
|
"definition_token_count": def_tok_len, |
|
|
"definition_head_hash64": def_head_hash64, |
|
|
"definition_head_sha256": def_head_sha, |
|
|
"definition_head_token_count": def_head_len, |
|
|
"definition_mid_hash64": def_mid_hash64, |
|
|
"definition_mid_sha256": def_mid_sha, |
|
|
"definition_mid_token_count": def_mid_len, |
|
|
"definition_tail_hash64": def_tail_hash64, |
|
|
"definition_tail_sha256": def_tail_sha, |
|
|
"definition_tail_token_count": def_tail_len, |
|
|
"definition_head_alt_hash64": def_head_alt_hash64, |
|
|
"definition_head_alt_sha256": def_head_alt_sha, |
|
|
"definition_head_alt_token_count": def_head_alt_len, |
|
|
"definition_mid_alt_hash64": def_mid_alt_hash64, |
|
|
"definition_mid_alt_sha256": def_mid_alt_sha, |
|
|
"definition_mid_alt_token_count": def_mid_alt_len, |
|
|
"definition_tail_alt_hash64": def_tail_alt_hash64, |
|
|
"definition_tail_alt_sha256": def_tail_alt_sha, |
|
|
"definition_tail_alt_token_count": def_tail_alt_len, |
|
|
"context_char_start": ctx_start, |
|
|
"context_char_end": ctx_end, |
|
|
"context_match": ctx_match, |
|
|
"context_hash64": ctx_hash64, |
|
|
"context_sha256": ctx_sha, |
|
|
"context_token_count": ctx_tok_len, |
|
|
"context_head_hash64": ctx_head_hash64, |
|
|
"context_head_sha256": ctx_head_sha, |
|
|
"context_head_token_count": ctx_head_len, |
|
|
"context_mid_hash64": ctx_mid_hash64, |
|
|
"context_mid_sha256": ctx_mid_sha, |
|
|
"context_mid_token_count": ctx_mid_len, |
|
|
"context_tail_hash64": ctx_tail_hash64, |
|
|
"context_tail_sha256": ctx_tail_sha, |
|
|
"context_tail_token_count": ctx_tail_len, |
|
|
"context_head_alt_hash64": ctx_head_alt_hash64, |
|
|
"context_head_alt_sha256": ctx_head_alt_sha, |
|
|
"context_head_alt_token_count": ctx_head_alt_len, |
|
|
"context_mid_alt_hash64": ctx_mid_alt_hash64, |
|
|
"context_mid_alt_sha256": ctx_mid_alt_sha, |
|
|
"context_mid_alt_token_count": ctx_mid_alt_len, |
|
|
"context_tail_alt_hash64": ctx_tail_alt_hash64, |
|
|
"context_tail_alt_sha256": ctx_tail_alt_sha, |
|
|
"context_tail_alt_token_count": ctx_tail_alt_len, |
|
|
}, |
|
|
) |
|
|
|
|
|
fieldnames = [ |
|
|
"paper_id", |
|
|
"paper_title", |
|
|
"paper_doi", |
|
|
"paper_arxiv", |
|
|
"concept", |
|
|
"definition_type", |
|
|
"source_file", |
|
|
"is_out_of_domain", |
|
|
"definition_preserve_linebreaks", |
|
|
"context_preserve_linebreaks", |
|
|
"definition_preserve_hyphenation", |
|
|
"context_preserve_hyphenation", |
|
|
"definition_has_bracket_citation", |
|
|
"definition_has_paren_citation", |
|
|
"definition_has_letter_digit", |
|
|
"context_has_bracket_citation", |
|
|
"context_has_paren_citation", |
|
|
"context_has_letter_digit", |
|
|
"definition_end_punct", |
|
|
"context_end_punct", |
|
|
"marker_version", |
|
|
"hash_version", |
|
|
"definition_char_start", |
|
|
"definition_char_end", |
|
|
"definition_match", |
|
|
"definition_hash64", |
|
|
"definition_sha256", |
|
|
"definition_token_count", |
|
|
"definition_head_hash64", |
|
|
"definition_head_sha256", |
|
|
"definition_head_token_count", |
|
|
"definition_mid_hash64", |
|
|
"definition_mid_sha256", |
|
|
"definition_mid_token_count", |
|
|
"definition_tail_hash64", |
|
|
"definition_tail_sha256", |
|
|
"definition_tail_token_count", |
|
|
"definition_head_alt_hash64", |
|
|
"definition_head_alt_sha256", |
|
|
"definition_head_alt_token_count", |
|
|
"definition_mid_alt_hash64", |
|
|
"definition_mid_alt_sha256", |
|
|
"definition_mid_alt_token_count", |
|
|
"definition_tail_alt_hash64", |
|
|
"definition_tail_alt_sha256", |
|
|
"definition_tail_alt_token_count", |
|
|
"context_char_start", |
|
|
"context_char_end", |
|
|
"context_match", |
|
|
"context_hash64", |
|
|
"context_sha256", |
|
|
"context_token_count", |
|
|
"context_head_hash64", |
|
|
"context_head_sha256", |
|
|
"context_head_token_count", |
|
|
"context_mid_hash64", |
|
|
"context_mid_sha256", |
|
|
"context_mid_token_count", |
|
|
"context_tail_hash64", |
|
|
"context_tail_sha256", |
|
|
"context_tail_token_count", |
|
|
"context_head_alt_hash64", |
|
|
"context_head_alt_sha256", |
|
|
"context_head_alt_token_count", |
|
|
"context_mid_alt_hash64", |
|
|
"context_mid_alt_sha256", |
|
|
"context_mid_alt_token_count", |
|
|
"context_tail_alt_hash64", |
|
|
"context_tail_alt_sha256", |
|
|
"context_tail_alt_token_count", |
|
|
] |
|
|
|
|
|
args.output_csv.parent.mkdir(parents=True, exist_ok=True) |
|
|
with args.output_csv.open("w", encoding="utf-8", newline="") as handle: |
|
|
writer = csv.DictWriter(handle, fieldnames=fieldnames) |
|
|
writer.writeheader() |
|
|
for row in output_rows: |
|
|
writer.writerow(row) |
|
|
|
|
|
total = len(output_rows) |
|
|
print(f"Wrote {total} rows to {args.output_csv}") |
|
|
print( |
|
|
"Exact TEI spans missing - " |
|
|
f"TEI: {missing_tei}, def spans: {missing_def}, ctx spans: {missing_ctx}", |
|
|
) |
|
|
print( |
|
|
"Hash/anchor markers available - " |
|
|
f"def hash: {def_hash_available}/{total}, " |
|
|
f"ctx hash: {ctx_hash_available}/{total}, " |
|
|
f"def anchors: {def_anchor_available}/{total}, " |
|
|
f"ctx anchors: {ctx_anchor_available}/{total}", |
|
|
) |
|
|
print( |
|
|
"Note: missing exact TEI spans do not block hydration; " |
|
|
"hash/anchor markers are used as the primary fallback.", |
|
|
) |
|
|
|
|
|
if args.report is not None: |
|
|
report_lines = [] |
|
|
if missing_tei: |
|
|
report_lines.append(f"Missing TEI: {missing_tei}") |
|
|
report_lines.append(f"Missing definition spans: {missing_def}") |
|
|
report_lines.append(f"Missing context spans: {missing_ctx}") |
|
|
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 __name__ == "__main__": |
|
|
main() |
|
|
|
