src/run_metadata.py

"""Helpers for reproducibility metadata attached to collected traces."""

from __future__ import annotations

import json
import hashlib
import os
import platform
import re
import subprocess
import sys
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
from urllib.error import HTTPError, URLError
from urllib.parse import urlparse
from urllib.request import urlopen

import psutil

SCHEMA_VERSION = "0.3.0"
COLLECTOR_VERSION = "0.3.0"


def _compact_dict(value: dict[str, Any]) -> dict[str, Any]:
    """Drop keys with None values to keep stored metadata concise."""
    return {k: v for k, v in value.items() if v is not None}


def _run_command(command: list[str], cwd: Path | None = None) -> str | None:
    """Run a short command and return stripped stdout."""
    try:
        result = subprocess.run(
            command,
            cwd=cwd,
            capture_output=True,
            text=True,
            timeout=5,
            check=True,
        )
    except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
        return None
    output = result.stdout.strip() or result.stderr.strip()
    return output or None


def _run_command_success(command: list[str], cwd: Path | None = None) -> tuple[bool, str]:
    """Run a short command and preserve empty stdout on success."""
    try:
        result = subprocess.run(
            command,
            cwd=cwd,
            capture_output=True,
            text=True,
            timeout=5,
            check=True,
        )
    except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
        return False, ""
    return True, result.stdout.strip()


def _env_bool(name: str) -> bool | None:
    value = os.getenv(name)
    if value is None:
        return None
    lowered = value.strip().lower()
    if lowered in {"1", "true", "yes", "on"}:
        return True
    if lowered in {"0", "false", "no", "off"}:
        return False
    return None


def _env_int(name: str) -> int | None:
    value = os.getenv(name)
    if value is None:
        return None
    try:
        return int(value)
    except ValueError:
        return None


def _env_float(name: str) -> float | None:
    value = os.getenv(name)
    if value is None:
        return None
    try:
        return float(value)
    except ValueError:
        return None


def infer_quantization(model_artifact: str | None) -> str | None:
    """Infer a quantization label from the artifact name when possible."""
    if not model_artifact:
        return None
    match = re.search(r"(Q\d(?:_\d)?(?:_[A-Z0-9]+)*|F16|BF16|FP16|FP32)", model_artifact, re.IGNORECASE)
    if not match:
        return None
    return match.group(1).upper()


def normalize_chat_template(chat_template: str | None) -> str | None:
    """Store a stable template identifier without leaking local absolute paths."""
    if not chat_template:
        return None
    if "/" in chat_template or "\\" in chat_template:
        return Path(chat_template).name
    return chat_template


def _fetch_json(url: str) -> dict[str, Any] | None:
    """Fetch JSON from a local HTTP endpoint."""
    try:
        with urlopen(url, timeout=3) as response:
            return json.loads(response.read().decode("utf-8"))
    except (HTTPError, URLError, TimeoutError, ValueError):
        return None


def _api_urls(api_base: str) -> tuple[str, str]:
    """Return `/v1/models` and `/props` URLs derived from an OpenAI API base."""
    parsed = urlparse(api_base.rstrip("/"))
    origin = f"{parsed.scheme}://{parsed.netloc}"
    api_path = parsed.path.rstrip("/") or "/v1"
    models_url = f"{origin}{api_path}/models"
    props_url = f"{origin}/props"
    return models_url, props_url


def get_llama_server_metadata(api_base: str | None) -> dict[str, Any]:
    """Query live llama-server endpoints for model/config metadata."""
    if not api_base:
        return {}

    models_url, props_url = _api_urls(api_base)
    models = _fetch_json(models_url) or {}
    props = _fetch_json(props_url) or {}
    if not models and not props:
        return {}

    model_path = props.get("model_path")
    model_meta = None

    data_models = models.get("data")
    if isinstance(data_models, list) and data_models:
        first = data_models[0]
        if isinstance(first, dict):
            model_meta = first.get("meta")
            model_path = model_path or first.get("id")

    named_models = models.get("models")
    if not model_path and isinstance(named_models, list) and named_models:
        first = named_models[0]
        if isinstance(first, dict):
            model_path = first.get("model") or first.get("name")

    generation_settings = props.get("default_generation_settings", {})
    params = generation_settings.get("params", {}) if isinstance(generation_settings, dict) else {}

    chat_template_raw = props.get("chat_template")
    chat_template_id = None
    if isinstance(chat_template_raw, str) and chat_template_raw:
        digest = hashlib.sha256(chat_template_raw.encode("utf-8")).hexdigest()[:12]
        chat_template_id = f"sha256:{digest}"

    return _compact_dict({
        "model_artifact": Path(model_path).name if model_path else None,
        "context_length": generation_settings.get("n_ctx") if isinstance(generation_settings, dict) else None,
        "serving_engine_version": props.get("build_info"),
        "chat_template_id": chat_template_id,
        "chat_format": params.get("chat_format"),
        "reasoning_format": params.get("reasoning_format"),
        "reasoning_in_content": params.get("reasoning_in_content"),
        "n_ctx_train": model_meta.get("n_ctx_train") if isinstance(model_meta, dict) else None,
        "n_params": model_meta.get("n_params") if isinstance(model_meta, dict) else None,
    })


def build_run_id(prefix: str = "run") -> str:
    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    return f"{prefix}-{timestamp}"


def get_repo_root(start_path: Path) -> Path:
    output = _run_command(["git", "rev-parse", "--show-toplevel"], cwd=start_path)
    if output:
        return Path(output)
    return start_path


def get_git_metadata(repo_root: Path) -> dict[str, Any]:
    """Collect git revision metadata for reproducibility."""
    git_commit = _run_command(["git", "rev-parse", "HEAD"], cwd=repo_root)
    ok, dirty_output = _run_command_success(["git", "status", "--short"], cwd=repo_root)
    git_dirty = bool(dirty_output) if ok else None
    return _compact_dict({
        "git_commit": git_commit,
        "git_dirty": git_dirty,
    })


def get_serving_engine_version(serving_engine: str, explicit_version: str | None = None) -> str | None:
    """Resolve a serving engine version from explicit metadata or local binaries."""
    if explicit_version:
        return explicit_version.splitlines()[0].strip()
    if serving_engine == "llama.cpp":
        version = _run_command(["llama-server", "--version"])
        if version:
            return version.splitlines()[0].strip()
        return None
    return None


def get_hardware_metadata() -> dict[str, Any]:
    """Collect lightweight host hardware metadata."""
    cpu_brand = platform.processor() or None
    if platform.system() == "Darwin":
        cpu_brand = _run_command(["sysctl", "-n", "machdep.cpu.brand_string"]) or cpu_brand
    memory_total = None
    try:
        memory_total = psutil.virtual_memory().total
    except Exception:
        memory_total = None

    return _compact_dict({
        "os": platform.system(),
        "os_release": platform.release(),
        "machine": platform.machine(),
        "cpu": cpu_brand,
        "cpu_count_logical": os.cpu_count(),
        "memory_total_bytes": memory_total,
    })


def get_fixture_version(path: Path | None) -> str | None:
    """Hash the current fixture tree so runs can be tied to an exact testdata state."""
    if path is None or not path.exists():
        return None

    digest = hashlib.sha256()
    for file_path in sorted(p for p in path.rglob("*") if p.is_file()):
        rel_path = file_path.relative_to(path).as_posix()
        digest.update(rel_path.encode("utf-8"))
        digest.update(b"\0")
        with open(file_path, "rb") as f:
            for chunk in iter(lambda: f.read(1024 * 1024), b""):
                digest.update(chunk)
    return digest.hexdigest()


def normalize_server_args(
    *,
    api_base: str | None,
    tool_choice: str | None,
    context_length: int | None,
    chat_template: str | None,
    jinja: bool | None = None,
    flash_attn: bool | None = None,
    n_gpu_layers: int | None = None,
    temperature: float | None = None,
    top_p: float | None = None,
) -> dict[str, Any]:
    """Store a structured subset of serving args instead of a raw shell command."""
    return _compact_dict({
        "api_base": api_base,
        "tool_choice": tool_choice,
        "context_length": context_length,
        "chat_template": chat_template,
        "jinja": jinja,
        "flash_attn": flash_attn,
        "n_gpu_layers": n_gpu_layers,
        "temperature": temperature,
        "top_p": top_p,
    })


def build_trace_metadata(
    *,
    repo_root: Path,
    run_id: str,
    model_id: str,
    api_base: str | None,
    model_artifact: str | None,
    quantization: str | None,
    serving_engine: str,
    serving_engine_version: str | None,
    tool_choice: str | None,
    context_length: int | None,
    max_steps: int | None,
    dataset_name: str | None,
    dataset_split: str | None,
    dataset_offset: int | None,
    chat_template: str | None,
    prompt_sanitization_version: str | None,
    fixture_dir: Path | None,
    server_args_normalized: dict[str, Any],
) -> dict[str, Any]:
    """Build the metadata block stored on every trace."""
    server_metadata = get_llama_server_metadata(api_base) if serving_engine == "llama.cpp" else {}
    resolved_model_artifact = server_metadata.get("model_artifact") or model_artifact
    resolved_context_length = server_metadata.get("context_length") or context_length
    resolved_chat_template = chat_template or server_metadata.get("chat_template_id")
    resolved_serving_engine_version = (
        server_metadata.get("serving_engine_version") or serving_engine_version
    )
    server_reported = _compact_dict({
        "chat_format": server_metadata.get("chat_format"),
        "reasoning_format": server_metadata.get("reasoning_format"),
        "reasoning_in_content": server_metadata.get("reasoning_in_content"),
        "n_ctx_train": server_metadata.get("n_ctx_train"),
        "n_params": server_metadata.get("n_params"),
    })

    metadata = {
        "schema_version": SCHEMA_VERSION,
        "collector_version": COLLECTOR_VERSION,
        "python_version": platform.python_version(),
        "platform": f"{sys.platform}-{platform.machine()}",
        "run_id": run_id,
        "model_family": model_id,
        "model_artifact": resolved_model_artifact,
        "quantization": quantization or infer_quantization(resolved_model_artifact),
        "serving_engine": serving_engine,
        "serving_engine_version": get_serving_engine_version(
            serving_engine, resolved_serving_engine_version
        ),
        "tool_choice": tool_choice,
        "context_length": resolved_context_length,
        "max_steps": max_steps,
        "dataset_name": dataset_name,
        "dataset_split": dataset_split,
        "dataset_offset": dataset_offset,
        "chat_template": normalize_chat_template(resolved_chat_template),
        "prompt_sanitization_version": prompt_sanitization_version,
        "fixture_version": get_fixture_version(fixture_dir),
        "server_args_normalized": server_args_normalized or None,
        "server_reported": server_reported or None,
        "hardware": get_hardware_metadata(),
        **get_git_metadata(repo_root),
    }
    if "git_commit" in metadata:
        metadata["collector_git_commit"] = metadata["git_commit"]
    return _compact_dict(metadata)


def write_run_manifest(
    *,
    repo_root: Path,
    run_id: str,
    trace_metadata: dict[str, Any],
    output_path: str | Path,
    raw_command: list[str],
) -> Path:
    """Write one manifest per collection run with fuller reproduction details."""
    manifest_dir = repo_root / "runs"
    manifest_dir.mkdir(parents=True, exist_ok=True)
    manifest_path = manifest_dir / f"{run_id}.json"
    manifest = {
        "created_at_utc": datetime.now(timezone.utc).isoformat(),
        "run_id": run_id,
        "output_path": str(output_path),
        "cwd": str(repo_root),
        "raw_command": raw_command,
        "trace_metadata": trace_metadata,
    }
    with open(manifest_path, "w") as f:
        json_text = json.dumps(manifest, indent=2, sort_keys=True)
        f.write(json_text + "\n")
    return manifest_path