workflows/preprocess_text.py

"""Run a deterministic, approval-gated reference text preprocessing experiment.

This tool is not a privacy scrubber, rights evaluator, or dataset release mechanism. It processes
only UTF-8 files explicitly named in an approved DATA LAB source manifest.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import tempfile
import unicodedata
from pathlib import Path
from typing import Any

from validate_manifest import load_manifest, validate_manifest


def sha256_bytes(value: bytes) -> str:
    return hashlib.sha256(value).hexdigest()


def normalize_text(text: str, unicode_form: str) -> str:
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    if unicode_form != "none":
        text = unicodedata.normalize(unicode_form, text)
    lines = [line.rstrip() for line in text.split("\n")]
    normalized: list[str] = []
    blank_count = 0
    for line in lines:
        if line:
            blank_count = 0
            normalized.append(line)
        else:
            blank_count += 1
            if blank_count <= 2:
                normalized.append("")
    return "\n".join(normalized).strip() + "\n"


def split_for_digest(digest: str) -> str:
    bucket = int(digest[:8], 16) % 10_000
    if bucket < 8_000:
        return "train"
    if bucket < 9_000:
        return "validation"
    return "test"


def _atomic_json(path: Path, value: Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile(
        "w", encoding="utf-8", dir=path.parent, delete=False, newline="\n"
    ) as handle:
        json.dump(value, handle, ensure_ascii=False, indent=2, sort_keys=True)
        handle.write("\n")
        temporary = Path(handle.name)
    temporary.replace(path)


def _atomic_jsonl(path: Path, values: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile(
        "w", encoding="utf-8", dir=path.parent, delete=False, newline="\n"
    ) as handle:
        for value in values:
            handle.write(json.dumps(value, ensure_ascii=False, sort_keys=True) + "\n")
        temporary = Path(handle.name)
    temporary.replace(path)


def run_preprocessing(
    manifest_path: Path,
    input_root: Path,
    output_root: Path,
    *,
    unicode_form: str = "NFC",
    min_characters: int = 1,
) -> dict[str, Any]:
    manifest_path = manifest_path.resolve()
    input_root = input_root.resolve()
    output_root = output_root.resolve()

    manifest = load_manifest(manifest_path)
    errors = validate_manifest(manifest)
    if errors:
        raise ValueError("manifest validation failed: " + "; ".join(errors))
    if manifest["decision"]["status"] != "approved":
        raise ValueError("preprocessing requires decision.status='approved'")
    if output_root == input_root or output_root.is_relative_to(input_root):
        raise ValueError("output directory must be outside the input directory")
    if min_characters < 1:
        raise ValueError("min_characters must be at least 1")

    records: list[dict[str, Any]] = []
    seen_content: set[str] = set()
    rejected = {"duplicate": 0, "too_short": 0}
    source_summaries: list[dict[str, Any]] = []

    for source in sorted(manifest["sources"], key=lambda item: item["source_id"]):
        relative_path = Path(*source["content_path"].split("/"))
        candidate = input_root / relative_path
        if candidate.is_symlink():
            raise ValueError(f"symlink input is not allowed: {source['content_path']}")
        resolved = candidate.resolve(strict=True)
        if not resolved.is_relative_to(input_root):
            raise ValueError(f"input escapes root: {source['content_path']}")
        raw = resolved.read_bytes()
        raw_digest = sha256_bytes(raw)
        if raw_digest != source["sha256"]:
            raise ValueError(f"SHA-256 mismatch for {source['source_id']}")
        try:
            text = raw.decode("utf-8", errors="strict")
        except UnicodeDecodeError as exc:
            raise ValueError(f"UTF-8 decode failed for {source['source_id']}: {exc}") from exc

        normalized = normalize_text(text, unicode_form)
        content_digest = sha256_bytes(normalized.encode("utf-8"))
        if len(normalized.strip()) < min_characters:
            rejected["too_short"] += 1
            continue
        if content_digest in seen_content:
            rejected["duplicate"] += 1
            continue
        seen_content.add(content_digest)
        record = {
            "id": content_digest,
            "source_id": source["source_id"],
            "split": split_for_digest(content_digest),
            "text": normalized,
        }
        records.append(record)
        source_summaries.append(
            {
                "source_id": source["source_id"],
                "input_sha256": raw_digest,
                "output_sha256": content_digest,
                "input_bytes": len(raw),
                "output_characters": len(normalized),
                "split": record["split"],
            }
        )

    records.sort(key=lambda item: (item["source_id"], item["id"]))
    manifest_digest = sha256_bytes(manifest_path.read_bytes())
    report = {
        "schema_version": "1.0",
        "dataset_id": manifest["dataset_id"],
        "manifest_sha256": manifest_digest,
        "settings": {
            "unicode_form": unicode_form,
            "min_characters": min_characters,
            "deduplication": "exact normalized UTF-8 SHA-256",
            "split_assignment": "SHA-256 bucket 80/10/10",
        },
        "counts": {
            "manifest_sources": len(manifest["sources"]),
            "accepted_records": len(records),
            "rejected_duplicate": rejected["duplicate"],
            "rejected_too_short": rejected["too_short"],
        },
        "sources": source_summaries,
        "warnings": [
            "This reference workflow does not establish privacy, copyright, safety, or data quality."
        ],
    }
    output_root.mkdir(parents=True, exist_ok=True)
    _atomic_jsonl(output_root / "records.jsonl", records)
    _atomic_json(output_root / "report.json", report)
    return report


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--manifest", required=True, type=Path)
    parser.add_argument("--input", required=True, type=Path, dest="input_root")
    parser.add_argument("--output", required=True, type=Path, dest="output_root")
    parser.add_argument("--unicode-form", choices=("none", "NFC", "NFKC"), default="NFC")
    parser.add_argument("--min-characters", type=int, default=1)
    args = parser.parse_args()

    try:
        report = run_preprocessing(
            args.manifest,
            args.input_root,
            args.output_root,
            unicode_form=args.unicode_form,
            min_characters=args.min_characters,
        )
    except (OSError, ValueError, json.JSONDecodeError) as exc:
        print(f"FAILED: {exc}")
        return 1

    print(json.dumps(report["counts"], sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())