| """Build ``data/<cc>/full_text.jsonl`` from an offline source. |
| |
| Two sources, both producing the JSONL shape the inference step consumes |
| (one object per line with a filesystem-safe ``case_id`` slug and ``full_text``): |
| |
| 1. A Goldenset's ``full_text`` column — for jurisdictions whose judgment text |
| already lives in the workbook (e.g. Brazil). |
| 2. A directory of PDFs (``--pdf-dir``) — for jurisdictions delivered as PDF |
| bundles (e.g. India's ``india_judgments.zip``). Each PDF's stem is the |
| ``case_id``; text is extracted with pypdf. |
| |
| Rows/files whose text is empty or shorter than ``--min-chars`` are reported |
| and skipped. |
| |
| Usage: |
| uv run legex-build-fulltext --country br |
| uv run legex-build-fulltext --xlsx "data/br/Goldenset_Brazil_final (...).xlsx" |
| uv run legex-build-fulltext --country in --pdf-dir data/raw/india_real/pdf |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import logging |
| import re |
| import sys |
| from pathlib import Path |
|
|
| from openpyxl import load_workbook |
| from pypdf import PdfReader |
|
|
| from legex.pdf_export.core import safe_slug |
| from legex.utils import full_text_jsonl_path, goldenset_path, goldenset_sheet |
|
|
| log = logging.getLogger("legex.build_full_text") |
|
|
| _WS_RE = re.compile(r"\s+") |
|
|
|
|
| def _norm_ws(text: str) -> str: |
| return _WS_RE.sub(" ", text).strip() |
|
|
|
|
| def build_from_pdf_dir( |
| pdf_dir: Path, |
| out_path: Path, |
| *, |
| min_chars: int, |
| ) -> tuple[int, int]: |
| """Extract text from every PDF in ``pdf_dir``. Returns (written, skipped).""" |
| pdfs = sorted(pdf_dir.glob("*.pdf")) |
| if not pdfs: |
| raise ValueError(f"no PDFs in {pdf_dir}") |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| written = skipped = 0 |
| with out_path.open("w", encoding="utf-8") as f: |
| for pdf in pdfs: |
| try: |
| reader = PdfReader(str(pdf)) |
| body = _norm_ws(" ".join((p.extract_text() or "") for p in reader.pages)) |
| except Exception as exc: |
| log.warning("skip %s: %s", pdf.name, exc) |
| skipped += 1 |
| continue |
| if len(body) < min_chars: |
| skipped += 1 |
| log.warning("skip %s: %d chars", pdf.name, len(body)) |
| continue |
| f.write( |
| json.dumps({"case_id": pdf.stem, "full_text": body}, ensure_ascii=False) + "\n" |
| ) |
| written += 1 |
| return written, skipped |
|
|
|
|
| def build_from_xlsx( |
| xlsx: Path, |
| out_path: Path, |
| *, |
| min_chars: int, |
| ) -> tuple[int, int]: |
| """Returns (written, skipped).""" |
| wb = load_workbook(xlsx, read_only=True, data_only=True) |
| try: |
| ws = goldenset_sheet(wb) |
| rows = ws.iter_rows(values_only=True) |
| header = [str(c).strip() if c is not None else "" for c in next(rows)] |
| lower = {h.lower(): i for i, h in enumerate(header)} |
| if "full_text" not in lower: |
| raise ValueError(f"{xlsx} GOLDENSET sheet has no full_text column ({header})") |
| if "case_id" not in lower: |
| raise ValueError(f"{xlsx} GOLDENSET sheet has no case_id column") |
|
|
| ft_idx = lower["full_text"] |
| id_idx = lower["case_id"] |
| link_idx = lower.get("link") |
|
|
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| written = skipped = 0 |
| seen: set[str] = set() |
| with out_path.open("w", encoding="utf-8") as f: |
| for i, row in enumerate(rows): |
| if not any(c not in (None, "") for c in row): |
| continue |
| case_id = row[id_idx] |
| text = row[ft_idx] |
| link = row[link_idx] if link_idx is not None and link_idx < len(row) else None |
| body = _norm_ws(str(text)) if text is not None else "" |
| if len(body) < min_chars: |
| skipped += 1 |
| log.warning("skip row %d (case_id=%r): %d chars", i + 2, case_id, len(body)) |
| continue |
| slug = safe_slug( |
| str(case_id) if case_id is not None else "", str(link or ""), i |
| ) |
| if slug in seen: |
| slug = f"{slug}_{i}" |
| seen.add(slug) |
| f.write( |
| json.dumps({"case_id": slug, "full_text": body}, ensure_ascii=False) + "\n" |
| ) |
| written += 1 |
| finally: |
| wb.close() |
| return written, skipped |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| logging.basicConfig(level=logging.INFO, format="%(message)s") |
| parser = argparse.ArgumentParser(description="Build full_text.jsonl from a Goldenset column.") |
| parser.add_argument("--country", help="Country code; resolves the goldenset and output path.") |
| parser.add_argument("--xlsx", type=Path, help="Explicit workbook path (overrides --country lookup).") |
| parser.add_argument("--pdf-dir", type=Path, help="Extract from a directory of PDFs (stem = case_id).") |
| parser.add_argument("--out", type=Path, help="Output JSONL (default data/<cc>/full_text.jsonl).") |
| parser.add_argument("--min-chars", type=int, default=100, help="Skip rows shorter than this.") |
| parser.add_argument("--force", action="store_true", help="Overwrite an existing full_text.jsonl.") |
| args = parser.parse_args(argv) |
|
|
| if not args.country and not args.xlsx and not args.pdf_dir: |
| parser.error("provide --country, --xlsx, and/or --pdf-dir") |
|
|
| out_path = args.out or ( |
| full_text_jsonl_path(args.country) if args.country else None |
| ) |
| if out_path is None: |
| parser.error("--out is required when --country is not given") |
| if out_path.exists() and not args.force: |
| log.error("%s exists; pass --force to overwrite", out_path) |
| return 1 |
|
|
| if args.pdf_dir: |
| if not args.pdf_dir.is_dir(): |
| log.error("pdf dir not found: %s", args.pdf_dir) |
| return 2 |
| written, skipped = build_from_pdf_dir(args.pdf_dir, out_path, min_chars=args.min_chars) |
| else: |
| xlsx = args.xlsx or goldenset_path(args.country) |
| if not xlsx.exists(): |
| log.error("workbook not found: %s", xlsx) |
| return 2 |
| written, skipped = build_from_xlsx(xlsx, out_path, min_chars=args.min_chars) |
|
|
| log.info("wrote %d rows (%d skipped) -> %s", written, skipped, out_path) |
| return 0 if written else 1 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
