from __future__ import annotations import json import time from pathlib import Path from typing import Any from uuid import uuid4 from src.analyzer import analyze_policy, redactable from src.baseline import analyze_regex_only from src.domain import ( CODE_VERSION, DEFAULT_SEED, ENGINE_PROFILE, PRODUCT, DocFormat, EntityType, Family, Language, Method, PolicyAction, Split, Workflow, ) from src.explain import decide_verdict, finding_from_span, narrative, reasons, status_label from src.generator import documents_by_id, scenario_by_id, scenarios from src.metrics import aggregate_scores, comparison_rows, kpis_from, per_group, score_document from src.parsers import parse_pasted, parse_uploads from src.pdfio import build_pdf, redact_pdf from src.redaction import apply_text, leftover_values from src.reporting import input_hash, write_downloads from src.schemas import LabDocument, Span, ValidationReport from src.validation import validate_documents, validate_limits ROOT = Path(__file__).resolve().parents[1] def _user_document(name: str, text: str, fmt: DocFormat, metadata: dict[str, str] | None = None) -> LabDocument: return LabDocument( doc_id=f"USER-{name}", template="user", family=Family.USER.value, split=Split.USER, language=Language.MIXED, format=fmt, title=name, body=text, metadata=metadata or {}, description="Uploaded or pasted laboratory document", description_fa="سند آزمایشگاهی بارگذاری‌شده یا چسبانده‌شده", ) def _selected_documents( scenario_id: str, pasted: str, uploads: list[Any] | None, seed: int, ) -> tuple[list[LabDocument], list[dict[str, Any]], ValidationReport, str]: report = ValidationReport(ok=True) parsed = parse_uploads(uploads, report) extra: list[dict[str, Any]] = [] if pasted and pasted.strip(): item = parse_pasted(pasted, report) if item: parsed.insert(0, item) if parsed: documents = [ _user_document(item["name"], item["text"], item["format"], item.get("metadata") or {}) for item in parsed ] extra = parsed validate_limits(len(parsed), sum(int(item.get("pages") or 0) for item in parsed), sum(len(item["text"]) for item in parsed), report) report_docs = validate_documents(documents) if not report_docs.ok: report.issues.extend(report_docs.issues) report.ok = False return documents, extra, report, "upload" if scenario_id == "S00": report.add("empty", "Interactive mode needs pasted text or a file.", "text") return [], [], report, "interactive" scenario = scenario_by_id(scenario_id, seed) catalog = documents_by_id(seed) documents = [catalog[item] for item in scenario.doc_ids if item in catalog] return documents, extra, validate_documents(documents), scenario_id def _export_document( document: LabDocument, spans: list[Span], action: PolicyAction, upload: dict[str, Any] | None, ) -> tuple[str, dict[str, str], bytes | None, list[str]]: active = redactable(spans) text_out = apply_text(document.body, active, action) meta_out = {key: "" for key in document.metadata} pdf_bytes = None leftover: list[str] = [] values = [item.surface for item in active] if document.format is DocFormat.PDF: source = upload["raw"] if upload and upload.get("raw") else build_pdf(document.body, document.metadata) pdf_bytes, info = redact_pdf(source, values) text_out = info["text"] or text_out meta_out = {key: str(value or "") for key, value in (info.get("metadata") or {}).items()} leftover = info.get("leftover") or [] leftover.extend(leftover_values(text_out, [span.surface for span in document.gold_spans])) leftover.extend(leftover_values(" ".join(meta_out.values()), [item.surface for item in document.gold_meta])) return text_out, meta_out, pdf_bytes, leftover def run_pipeline( scenario_id: str = "S01", pasted: str = "", uploads: list[Any] | None = None, lang: str = "en", seed: int = DEFAULT_SEED, action: PolicyAction | str = PolicyAction.MASK, suppressed: list[str] | None = None, ) -> dict[str, Any]: started = time.perf_counter() policy_action = action if isinstance(action, PolicyAction) else PolicyAction(action) documents, extras, report, source = _selected_documents(scenario_id, pasted, uploads, seed) run_id = f"ariadlp-{uuid4().hex[:16]}" if not report.ok: empty = aggregate_scores(Method.POLICY.value, [], 0) kpis = kpis_from(0, empty, empty, 0, 0, 0, 0, 0, 0, policy_action) return { "run_id": run_id, "scenario_id": scenario_id, "verdict": decide_verdict(report, 0, 0, 0), "status_label": status_label(decide_verdict(report, 0, 0, 0), lang), "error": report.issues[0].message if report.issues else "Invalid input", "kpis": kpis, "validation": report, "findings": [], "finding_rows": [], "doc_rows": [], "span_rows": [], "comparison": [], "scores": {Method.POLICY: empty, Method.BASELINE: empty}, "reasons": [item.message for item in report.issues], "narrative": "", "documents": [], "exports": {}, "before_html": "", "after_html": "", "redacted_text": "", "engine_profile": ENGINE_PROFILE, "input_hash": "", "challenger_notes": [], } uploads_by_name = {item["name"]: item for item in extras} policy_preds: list[list[Span]] = [] baseline_preds: list[list[Span]] = [] policy_rows: list[dict] = [] baseline_rows: list[dict] = [] findings = [] exports: dict[str, Any] = {} suppressed_ids = set(suppressed or []) pages = 0 chars = 0 first_before = "" first_after = "" first_redacted = "" first_spans: list[Span] = [] for document in documents: upload = uploads_by_name.get(document.title) or uploads_by_name.get(document.doc_id.replace("USER-", "")) policy = analyze_policy(document.body) baseline = analyze_regex_only(document.body) if suppressed_ids: for span in policy: if span.finding_id in suppressed_ids: span.workflow = Workflow.SUPPRESSED policy_preds.append(policy) baseline_preds.append(baseline) export_text, export_meta, pdf_bytes, leftover = _export_document(document, policy, policy_action, upload) exports[document.doc_id] = { "text": export_text, "metadata": export_meta, "pdf": pdf_bytes, "leftover": leftover, "format": document.format.value, } policy_rows.append(score_document(document, policy, export_text, export_meta)) baseline_export = apply_text(document.body, redactable(baseline), policy_action) baseline_rows.append(score_document(document, baseline, baseline_export, document.metadata)) findings.extend(finding_from_span(document.doc_id, span, lang) for span in policy) chars += len(document.body) if document.format is DocFormat.PDF: pages += 1 if not first_redacted: first_before = document.body first_after = export_text first_redacted = export_text first_spans = policy policy_score = aggregate_scores(Method.POLICY.value, policy_rows, len(documents)) policy_score.by_type = per_group(documents, policy_preds, "type") policy_score.by_language = per_group(documents, policy_preds, "language") baseline_score = aggregate_scores(Method.BASELINE.value, baseline_rows, len(documents)) n_review = sum(1 for item in findings if item.workflow == Workflow.REVIEW.value or item.entity_type == EntityType.UNKNOWN.value) n_redacted = sum(1 for item in findings if item.workflow == Workflow.DETECTED.value) elapsed = int((time.perf_counter() - started) * 1000) kpis = kpis_from( len(documents), policy_score, baseline_score, len(findings), n_review, n_redacted, elapsed, pages, chars, policy_action, ) verdict = decide_verdict(report, len(documents), policy_score.leftover_exports, n_review) from src.redaction import highlight_html, highlight_redacted_html rtl = lang == "fa" finding_rows = [item.model_dump() for item in findings] span_rows = [ { "keep": item.workflow != Workflow.SUPPRESSED.value, "finding_id": item.finding_id, "doc_id": item.doc_id, "type": item.entity_type, "start": item.start, "end": item.end, "preview": item.surface_preview, "confidence": item.confidence, "workflow": item.workflow, "rule_id": item.rule_id, } for item in findings ] doc_rows = [ { "doc_id": document.doc_id, "template": document.template, "language": document.language.value, "format": document.format.value, "split": document.split.value, "n_gold": len(document.gold_spans), "leftover": len(exports[document.doc_id]["leftover"]), } for document in documents ] hashed = input_hash( { "scenario": scenario_id, "docs": [item.doc_id for item in documents], "action": policy_action.value, "version": CODE_VERSION, } ) return { "run_id": run_id, "product": PRODUCT, "scenario_id": scenario_id if source != "upload" else "upload", "source": source, "verdict": verdict, "status_label": status_label(verdict, lang), "error": None, "kpis": kpis, "validation": report, "findings": findings, "finding_rows": finding_rows, "doc_rows": doc_rows, "span_rows": span_rows, "comparison": comparison_rows(policy_score, baseline_score), "scores": {Method.POLICY: policy_score, Method.BASELINE: baseline_score}, "reasons": reasons(policy_score, baseline_score, lang), "narrative": narrative(kpis, lang), "documents": documents, "exports": exports, "before_html": highlight_html(first_before, first_spans, rtl=rtl), "after_html": highlight_redacted_html(first_after, rtl=rtl), "redacted_text": first_redacted, "original_text": first_before, "engine_profile": ENGINE_PROFILE, "input_hash": hashed, "policy_action": policy_action.value, "challenger_notes": [ { "doc_id": item.doc_id, "note": "Unknown / failed-checksum items stay on the review list and are not auto-redacted.", } for item in findings if item.entity_type == EntityType.UNKNOWN.value ][:20], } def evaluate_catalog(seed: int = DEFAULT_SEED) -> list[dict[str, Any]]: rows = [] for scenario in scenarios(seed): result = run_pipeline(scenario.scenario_id, "", None, "en", seed, PolicyAction.MASK) policy = result["scores"][Method.POLICY] rows.append( { "scenario_id": scenario.scenario_id, "method": Method.POLICY.value, "precision": round(policy.precision, 3), "recall": round(policy.recall, 3), "over_redaction": round(policy.over_redaction, 4), "residual_leak": round(policy.residual_leak, 3), "leftover_exports": policy.leftover_exports, "metadata_leaks": policy.metadata_leaks, "hardneg_hits": policy.hardneg_hits, "n_docs": policy.n_docs, } ) return rows def result_to_downloads(result: dict[str, Any], folder: Path) -> dict[str, str]: return write_downloads(result, folder) def load_sample(scenario_id: str = "S01") -> LabDocument: catalog = documents_by_id() scenario = scenario_by_id(scenario_id) return catalog[scenario.doc_ids[0]]