12.1 模板与变量

#!/usr/bin/env python3
# file: sim/na_12_1_template_variable.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/na_12_1_template_variable.py
"""卷一 12.1 模板与变量（S 层）：文本里的占位怎么从规格的命名实体表取值。

模板文法（本节唯一口径）：
    {<ns>:<id>.name}   ns ∈ {char, loc, faction}，取值来自规格的三段
    {{  /  }}          字面花括号转义
    未知占位            原样保留，计入未命中

只做文本的**结构**：占位解析、变量表规模、可模板化点计数。不评价文本好坏，
也不对文本做摘要（跨语言摘要只对状态做）。

四步：
  1) 由规格三段拼出变量表，打印规模与命名唯一性；
  2) 渲染全部 48 条 line 与 115 条选项文本，统计**行内占位**出现次数；
  3) 用「说话人模板」渲染全部 48 条 utterance，统计**字段级占位**；
  4) 扫描可模板化点（正文里的命名实体字面，最长匹配优先），把字面改写成
     占位后回渲染，断言占位全部命中、渲染长度与原字面长度整数一致。
"""
from __future__ import annotations

import json
import os
import re
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SPEC = os.path.join(ROOT, "config/story_spec.json")
OUT = os.path.join(ROOT, "out/na_12_1_template_variable.json")

TOKEN = re.compile(r"\{\{|\}\}|\{([^{}]*)\}")
N_DIALOGUE, N_CHOICES, N_ENV = 48, 115, 24


def load_spec() -> dict:
    with open(SPEC, encoding="utf-8") as fh:
        return json.load(fh)


def build_env(spec: dict) -> dict:
    """变量表：命名实体（角色 / 地点 / 派系）的显示名，键是占位写法。"""
    env: dict[str, str] = {}
    for c in spec["characters"]:
        env[f"char:{c['id']}.name"] = c["name"]
    for loc in spec["world"]["locations"]:
        env[f"loc:{loc['id']}.name"] = loc["name"]
    for f in spec["world"]["factions"]:
        env[f"faction:{f['id']}.name"] = f["name"]
    return env


def render(tpl: str, env: dict) -> tuple[str, list, list]:
    """模板渲染：返回 (结果, 命中的占位键, 未命中的占位键)。"""
    parts, hits, miss = [], [], []
    pos = 0
    for m in TOKEN.finditer(tpl):
        parts.append(tpl[pos:m.start()])
        tok = m.group(0)
        if tok == "{{":
            parts.append("{")
        elif tok == "}}":
            parts.append("}")
        else:
            key = m.group(1).strip()
            if key in env:
                parts.append(env[key])
                hits.append(key)
            else:
                parts.append(tok)
                miss.append(key)
        pos = m.end()
    parts.append(tpl[pos:])
    return "".join(parts), hits, miss


def templatize(text: str, name2key: dict) -> tuple[str, list]:
    """把正文里的命名实体字面改写成占位（最长匹配优先，避免短名吃掉长名）。"""
    out, subs, i = [], [], 0
    while i < len(text):
        best = None
        for name in name2key:
            if text.startswith(name, i) and (best is None or len(name) > len(best)):
                best = name
        if best is not None:
            out.append("{" + name2key[best] + "}")
            subs.append(best)
            i += len(best)
        else:
            out.append(text[i])
            i += 1
    return "".join(out), subs


def main() -> int:
    spec = load_spec()
    dlg = spec["dialogue"]
    env = build_env(spec)
    name2key = {v: k for k, v in env.items()}

    n_char = sum(1 for k in env if k.startswith("char:"))
    n_loc = sum(1 for k in env if k.startswith("loc:"))
    n_fac = sum(1 for k in env if k.startswith("faction:"))
    print(f"变量表（命名实体）：char={n_char}  loc={n_loc}  faction={n_fac}  合计 {len(env)} 个绑定")
    if len(name2key) != len(env):
        print("FAIL 显示名不唯一，无法反查占位键")
        return 1

    # ---- 1) 行内占位：48 条 line ----
    line_hit = line_miss = 0
    for n in dlg:
        _, h, m = render(n["line"], env)
        line_hit += len(h)
        line_miss += len(m)

    # ---- 2) 行内占位：115 条选项文本 ----
    ch_hit = ch_miss = 0
    for n in dlg:
        for c in (n.get("choices") or []):
            _, h, m = render(c["text"], env)
            ch_hit += len(h)
            ch_miss += len(m)
    inline = line_hit + line_miss + ch_hit + ch_miss
    print(f"行内占位：48 条 line 里 {line_hit + line_miss} 处，115 条选项文本里 {ch_hit + ch_miss} 处，合计 {inline} 处")

    # ---- 3) 字段级占位：说话人模板 ----
    utt_hit: list = []
    utt_miss: list = []
    for n in dlg:
        tpl = "{" + f"char:{n['speaker']}.name" + "}：" + n["line"]
        _, h, m = render(tpl, env)
        utt_hit += h
        utt_miss += m
    miss_ids = sorted(set(utt_miss))
    print(f"字段级说话人占位：{len(utt_hit) + len(utt_miss)} 处（命中 {len(utt_hit)} / 未命中 {len(utt_miss)}），"
          f"未命中 id = {miss_ids}")

    # ---- 4) 可模板化点：正文里的命名实体字面 ----
    rows: list[dict] = []
    for n in dlg:
        tpl, subs = templatize(n["line"], name2key)
        if subs:
            rows.append({"kind": "line", "id": n["id"], "tpl": tpl, "subs": len(subs)})
        for c in (n.get("choices") or []):
            ctpl, csubs = templatize(c["text"], name2key)
            if csubs:
                rows.append({"kind": "choice", "id": c["id"], "tpl": ctpl, "subs": len(csubs)})
    subs_total = sum(r["subs"] for r in rows)
    rt_ok = 0
    for r in rows:
        rendered, h, m = render(r["tpl"], env)
        if not m and len(rendered) == len(render_src(spec, r)):
            rt_ok += 1
    n_line_rows = sum(1 for r in rows if r["kind"] == "line")
    n_ch_rows = len(rows) - n_line_rows
    print(f"可模板化点：含命名实体字面的行 {len(rows)} 条（line {n_line_rows} / choice {n_ch_rows}），"
          f"共 {subs_total} 处字面")
    print(f"  改写为占位后回渲染：占位全部命中、长度整数一致 {rt_ok}/{len(rows)} 行")

    report = {
        "env": {"char": n_char, "loc": n_loc, "faction": n_fac, "total": len(env)},
        "inline_placeholders": {"lines": line_hit + line_miss, "choices": ch_hit + ch_miss, "total": inline},
        "speaker_placeholders": {"total": len(utt_hit) + len(utt_miss), "hit": len(utt_hit),
                                 "miss": len(utt_miss), "miss_ids": miss_ids},
        "templatizable": {"rows": len(rows), "line_rows": n_line_rows, "choice_rows": n_ch_rows,
                          "substitutions": subs_total, "roundtrip_length_ok": rt_ok},
    }
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w", encoding="utf-8") as fh:
        json.dump(report, fh, ensure_ascii=False, indent=2)
        fh.write("\n")

    # ---- 整数不变量 ----
    if len(dlg) != N_DIALOGUE:
        print(f"FAIL 对话节点数 {len(dlg)} != {N_DIALOGUE}")
        return 1
    n_choices = sum(len(n.get("choices") or []) for n in dlg)
    if n_choices != N_CHOICES:
        print(f"FAIL 选项数 {n_choices} != {N_CHOICES}")
        return 1
    if len(env) != N_ENV:
        print(f"FAIL 变量表 {len(env)} != {N_ENV}")
        return 1
    if rt_ok != len(rows):
        print("FAIL 有行在回渲染时长度不一致")
        return 1
    print("OK na_12_1_template_variable：变量表 24 个绑定，48 条 line 无行内占位，"
          "字段级占位 48 处，可模板化点 33 处全部可回渲染")
    return 0


def render_src(spec: dict, row: dict) -> str:
    """取该行改写前的原始字面（用于长度整数比对）。"""
    if row["kind"] == "line":
        return next(n["line"] for n in spec["dialogue"] if n["id"] == row["id"])
    for n in spec["dialogue"]:
        for c in (n.get("choices") or []):
            if c["id"] == row["id"]:
                return c["text"]
    raise KeyError(row["id"])


if __name__ == "__main__":
    sys.exit(main())

变量表（命名实体）：char=6  loc=14  faction=4  合计 24 个绑定
行内占位：48 条 line 里 0 处，115 条选项文本里 0 处，合计 0 处
字段级说话人占位：48 处（命中 28 / 未命中 20），未命中 id = ['char:narrator.name']
可模板化点：含命名实体字面的行 32 条（line 10 / choice 22），共 33 处字面
  改写为占位后回渲染：占位全部命中、长度整数一致 32/32 行
OK na_12_1_template_variable：变量表 24 个绑定，48 条 line 无行内占位，字段级占位 48 处，可模板化点 33 处全部可回渲染