scripts/apm_metrics.py

"""Shared metric utilities for the Assistive Prompt Mediation benchmark."""

from __future__ import annotations

import json
import math
import re
from collections import Counter
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional


META_PATTERNS = [
    r"\bAs an AI\b",
    r"\bI (can|will|cannot|can't)\b",
    r"\bSure[, ]",
    r"\bHere(?: is|'s)\b",
    r"\bLet me\b",
]

ASSISTED_TEXT_FIELDS = (
    "model_response",
    "response",
    "assistant_response",
    "assist_prompt",
    "assisted_prompt",
    "mediated_prompt",
    "output",
)

RAW_PROMPT_FIELDS = (
    "noisy_prompt",
    "input_prompt",
    "prompt",
    "user_prompt",
)

CHINESE_LANGUAGE_CODES = {"cn", "zh", "zh-cn", "zh_hans", "zh-hans"}
CJK_REGEX = re.compile(r"[\u4e00-\u9fff]")


def load_json_or_jsonl(path: str | Path) -> List[Dict[str, Any]]:
    """Load a JSON array or JSONL file as a list of dictionaries."""

    path = Path(path)
    with path.open("r", encoding="utf-8") as f:
        first_char = f.read(1)
        f.seek(0)
        if not first_char:
            return []
        if first_char == "[":
            data = json.load(f)
            if not isinstance(data, list):
                raise ValueError(f"{path} must contain a JSON array")
            return data
        return [json.loads(line) for line in f if line.strip()]


def write_json(data: Any, path: str | Path) -> None:
    """Write JSON with stable UTF-8 formatting."""

    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def entropy(text: str) -> float:
    """Character-level Shannon entropy used by the structural burden score."""

    if not text:
        return 0.0

    counts = Counter(text)
    total = sum(counts.values())
    return -sum((count / total) * math.log2(count / total) for count in counts.values())


def cognitive_burden(text: str) -> float:
    """Compute the structural cognitive burden proxy B(p)."""

    tokens = re.findall(r"\w+|[^\w\s]", text)
    length = len(tokens)
    punctuation_density = sum(1 for token in tokens if re.match(r"[^\w\s]", token)) / max(length, 1)

    return round(
        0.4 * length
        + 0.3 * punctuation_density * 100
        + 0.3 * entropy(text) * 10,
        3,
    )


def protocol_compliance(text: str) -> Dict[str, Any]:
    """Detect responses that ask questions or add meta/explanatory text."""

    question_marks = text.count("?") + text.count("\uff1f")
    meta_hits = sum(bool(re.search(pattern, text, re.IGNORECASE)) for pattern in META_PATTERNS)

    asked_question = question_marks > 0
    added_explanation = meta_hits > 0

    return {
        "asked_question": asked_question,
        "added_explanation": added_explanation,
        "protocol_compliant": not (asked_question or added_explanation),
        "question_marks": question_marks,
        "meta_phrase_hits": meta_hits,
    }


def language_script_match(text: str, language: Optional[str]) -> Dict[str, Any]:
    """Check whether Chinese outputs are mostly CJK characters.

    Non-Chinese languages return null values because this lightweight diagnostic
    is only defined for the Chinese-script condition used in the benchmark workflow.
    """

    lang = (language or "").lower()
    if lang not in CHINESE_LANGUAGE_CODES:
        return {"script_match": None, "script_ratio": None}

    chars = [char for char in text if char.strip()]
    if not chars:
        return {"script_match": False, "script_ratio": 0.0}

    cjk_count = sum(bool(CJK_REGEX.match(char)) for char in chars)
    ratio = cjk_count / len(chars)
    return {"script_match": ratio >= 0.9, "script_ratio": round(ratio, 3)}


def first_present(record: Mapping[str, Any], fields: tuple[str, ...]) -> Optional[str]:
    """Return the first non-empty string-like value from a set of fields."""

    for field in fields:
        value = record.get(field)
        if value is None:
            continue
        value = str(value)
        if value.strip():
            return value
    return None


def extract_assisted_text(record: Mapping[str, Any]) -> Optional[str]:
    """Extract a model's mediated/assisted prompt from common output fields."""

    return first_present(record, ASSISTED_TEXT_FIELDS)


def extract_raw_prompt(record: Mapping[str, Any]) -> Optional[str]:
    """Extract the noisy user prompt from common input fields."""

    return first_present(record, RAW_PROMPT_FIELDS)


def compute_metrics(
    record: Mapping[str, Any],
    *,
    model: Optional[str] = None,
    noise: Optional[str] = None,
) -> Optional[Dict[str, Any]]:
    """Compute row-level APM benchmark metrics for one model output."""

    raw_prompt = extract_raw_prompt(record)
    assisted_text = extract_assisted_text(record)
    if raw_prompt is None or assisted_text is None:
        return None

    b_raw = cognitive_burden(raw_prompt)
    b_assist = cognitive_burden(assisted_text)
    language = record.get("language")

    row: Dict[str, Any] = {
        "example_id": record.get("example_id"),
        "model": record.get("model") or model,
        "noise": record.get("noise") or noise,
        "language": language,
        "alpha": record.get("alpha"),
        **protocol_compliance(assisted_text),
        **language_script_match(assisted_text, language),
        "B_raw": b_raw,
        "B_assist": b_assist,
        "BRS": round(b_raw - b_assist, 3),
    }
    return row


def flatten_judge_fields(record: Mapping[str, Any]) -> Dict[str, Any]:
    """Collect judge metrics, accepting nested or already-prefixed schemas."""

    flattened: Dict[str, Any] = {}

    judge = record.get("judge")
    if isinstance(judge, Mapping):
        for key, value in judge.items():
            flattened[f"judge_{key}"] = value

    for key, value in record.items():
        if key.startswith("judge_"):
            flattened[key] = value

    return flattened


def normalize_bool(value: Any) -> bool:
    """Convert common serialized boolean values into Python booleans."""

    if isinstance(value, bool):
        return value
    if value is None:
        return False
    if isinstance(value, (int, float)):
        return bool(value)
    if isinstance(value, str):
        return value.strip().lower() in {"1", "true", "yes", "y", "pass"}
    return bool(value)