AI 回答里的品牌提及怎么判：别名归一、否定语境和排名位置的解析实现

"""解析一条 AI 回答：提到了哪些品牌、怎么提到的、语气、排第几。"""
import re, unicodedata
from dataclasses import dataclass, field

# ---------- 1. 别名表 ----------
# names: 现用名（含中英文、简称）；old: 改名前的旧名；domains: 官网域名
BRANDS = {
    "甲数据": {"names": ["甲数据", "JiaData", "Jia Data"], "old": ["甲分析"], "domains": ["jiadata.example"]},
    "甲数据云": {"names": ["甲数据云"], "old": [], "domains": []},  # 另一家公司，名字包含「甲数据」
    "乙监测": {"names": ["乙监测", "YiWatch"], "old": [], "domains": ["yiwatch.example"]},
}


def norm(s):
    s = unicodedata.normalize("NFKC", s)          # 全角转半角：ＪｉａＤａｔａ -> JiaData
    return re.sub(r"[ \t]+", " ", s).lower()


def _alias_pattern(alias):
    p = re.escape(norm(alias)).replace(r"\ ", r"[\s\-_]*")   # Jia Data / Jia-Data / jiadata
    if re.fullmatch(r"[a-z0-9.\-_ ]+", norm(alias)):
        p = rf"(?<![a-z0-9]){p}(?![a-z0-9])"                # jiadata 不命中 jiadatax
    return p


def build_alias_index(brands):
    """展开成 (别名, 品牌, 类型) 列表，按别名长度倒序，长的先匹配"""
    idx = []
    for b, conf in brands.items():
        for kind in ("names", "old", "domains"):
            for a in conf[kind]:
                idx.append((a, b, kind))
    idx.sort(key=lambda x: len(norm(x[0])), reverse=True)
    return [(re.compile(_alias_pattern(a)), b, kind) for a, b, kind in idx]

# ---------- 2. 先把链接和角标拿掉 ----------
MD_LINK = re.compile(r"\[([^\]]*)\]\((?:https?://)?[^)\s]+\)")
BARE_URL = re.compile(r"https?://[^\s<>()\[\]【】\"'，。；、]+")
CITE_MARK = re.compile(r"【[^】]{0,40}】|\[\^?\\?-?\d{1,3}\]|\[\d+(?:,\s*\d+)*\]")


def clean(text):
    urls = BARE_URL.findall(text) + re.findall(r"\]\(((?:https?://)?[^)\s]+)\)", text)
    text = MD_LINK.sub(lambda m: m.group(1), text)
    text = BARE_URL.sub(" ", text)
    text = CITE_MARK.sub("", text)
    return norm(text), [norm(u) for u in urls]


@dataclass
class Hit:
    brand: str
    kind: str      # names / old / domains
    start: int
    end: int


def find_hits(text, index):
    """最长优先，命中过的位置不再给更短的别名用"""
    taken = [False] * len(text)
    hits = []
    for pat, brand, kind in index:
        for m in pat.finditer(text):
            if any(taken[m.start():m.end()]):
                continue
            for i in range(m.start(), m.end()):
                taken[i] = True
            hits.append(Hit(brand, kind, m.start(), m.end()))
    return sorted(hits, key=lambda h: h.start)

# ---------- 3. 语气：只认「主语是这个品牌」的否定 ----------
GENERIC = ["不建议只看", "而不是", "不是简单", "不只是", "不仅", "无论"]
NEG = ["不推荐", "不建议选", "不适合", "不支持", "只覆盖", "没有覆盖", "缺少", "缺乏", "较弱", "存疑", "谨慎选择"]
COMPARE = ["弱于", "不如", "逊于", "低于"]   # 「X 弱于 Y」：X 是弱的一方，Y 不算负面
CLAUSE_SPLIT = re.compile(r"[。！？!?；;\n，,]")


def tone(text, hits):
    """返回 {品牌: 'limit'}，只标负面/局限，其余当中性"""
    out = {}
    pos = 0
    for clause in CLAUSE_SPLIT.split(text):
        start, end = pos, pos + len(clause)
        pos = end + 1
        inside = [h for h in hits if start <= h.start < end]
        if not inside or any(g in clause for g in GENERIC):
            continue
        for cue in NEG + COMPARE:
            i = clause.find(cue)
            if i < 0:
                continue
            before = [h.brand for h in inside if h.end - start <= i]
            after = [h.brand for h in inside if h.start - start >= i + len(cue)]
            if cue in COMPARE:
                target = before[-1:]
            else:
                target = before[-1:] or after[:1]
            for b in target:
                out[b] = "limit"
    return out

# ---------- 4. 排名：先找「推荐块」，再数先后 ----------
TABLE_ROW = re.compile(r"^\s*\|(.+)\|\s*$")
NUMBERED = re.compile(r"^\s*(?:#{1,6}\s*)?(?:\*\*)?\s*(\d{1,2})\s*[.、)）]")
BULLET = re.compile(r"^\s*[-*•]\s+")
HEADING = re.compile(r"^\s*#{1,6}\s+")


def rank(text, hits, brand):
    """返回 (名次, 依据)。名次 = 该品牌在同一个块里是第几个出现的已知品牌"""
    lines = text.split("\n")
    offsets, p = [], 0
    for ln in lines:
        offsets.append(p)
        p += len(ln) + 1

    def brands_in(i):
        s, e = offsets[i], offsets[i] + len(lines[i])
        seen = []
        for h in hits:
            if s <= h.start < e and h.kind != "domains" and h.brand not in seen:
                seen.append(h.brand)
        return seen

    # 连续的同类行算一个块：表格行 / 编号行 / 列表行 / 标题行
    def kind_of(ln):
        if TABLE_ROW.match(ln):
            return "table"
        if NUMBERED.match(ln):
            return "numbered"
        if BULLET.match(ln):
            return "bullet"
        if HEADING.match(ln):
            return "heading"
        return None

    blocks, cur, cur_kind = [], [], None
    for i, ln in enumerate(lines):
        k = kind_of(ln)
        if k and (k == cur_kind or (k == "heading" and cur_kind == "heading")):
            cur.append(i)
        else:
            if cur:
                blocks.append((cur_kind, cur))
            cur, cur_kind = ([i], k) if k else ([], None)
    if cur:
        blocks.append((cur_kind, cur))
    # 标题之间隔着正文，单独再收一遍：所有标题行合成一个块
    heads = [i for i, ln in enumerate(lines) if HEADING.match(ln)]
    if heads:
        blocks.append(("heading", heads))

    for k, idxs in blocks:
        order = []
        for i in idxs:
            for b in brands_in(i)[:1]:          # 每行只取第一个品牌，算这一行的「主角」
                if b not in order:
                    order.append(b)
        if len(order) >= 2 and brand in order:  # 块里至少两家已知品牌才算推荐清单
            return order.index(brand) + 1, k
    order = []
    for h in hits:
        if h.kind != "domains" and h.brand not in order:
            order.append(h.brand)
    return (order.index(brand) + 1, "prose") if brand in order else (None, None)

# ---------- 5. 汇总 ----------
@dataclass
class Result:
    mentioned: dict = field(default_factory=dict)   # 品牌 -> names / old / domain_only
    url_only: set = field(default_factory=set)
    tone: dict = field(default_factory=dict)
    rank: dict = field(default_factory=dict)


def analyze(answer, index=None, brands=BRANDS):
    index = index or build_alias_index(brands)
    text, urls = clean(answer)
    hits = find_hits(text, index)
    res = Result()
    for b in brands:
        kinds = {h.kind for h in hits if h.brand == b}
        if "names" in kinds:
            res.mentioned[b] = "names"
        elif "old" in kinds:
            res.mentioned[b] = "old"
        elif "domains" in kinds:
            res.mentioned[b] = "domain_only"      # 只有域名，多半是来源角标，单列不算提及
        elif any(d in u for u in urls for d in brands[b]["domains"]):
            res.url_only.add(b)
    named = [h for h in hits if h.kind != "domains"]
    res.tone = tone(text, named)
    for b, k in res.mentioned.items():
        if k != "domain_only":
            res.rank[b] = rank(text, hits, b)
    return res

from mention import analyze
samples = {
 "A 全角+括号别名": "推荐 ＪｉａＤａｔａ（甲数据），上手快。",
 "B 只在链接里": "提及率的算法可以参考这篇[对比](https://www.jiadata.example/blog/rate)。",
 "C 来源角标": "看趋势比看单周数字重要得多jiadata.example。周报首页放 6 项。",
 "D 名字被包含": "甲数据云的私有化部署做得不错。",
 "E 旧名": "国内可用甲分析、乙监测等工具。",
 "F 泛化否定": "比较甲数据和其他平台，不建议只看覆盖几个平台。",
 "G 比较句": "适合已经在用传统 SEO 工具的团队，但深度弱于乙监测、甲数据。",
 "H 真否定": "如果主要看国内大模型，甲数据只覆盖海外平台，不适合。",
 "I 表格排名": "| 工具 | 特点 |\n|---|---|\n| 乙监测 | 覆盖广 |\n| 甲数据 | 有原文回放 |",
 "J 编号排名": "1. **乙监测**：老牌\n2. **甲数据**：按天采样\n3. 其他",
 "K 正文顺序": "常见的有乙监测，也有人用甲数据。",
}
for k, t in samples.items():
    r = analyze(t)
    print(f"{k:<10} 提及={r.mentioned} 仅链接={r.url_only or '-'} 语气={r.tone or '-'} 排名={r.rank or '-'}")

A 全角+括号别名  提及={'甲数据': 'names'} 仅链接=- 语气=- 排名={'甲数据': (1, 'prose')}
B 只在链接里    提及={} 仅链接={'甲数据'} 语气=- 排名=-
C 来源角标     提及={'甲数据': 'domain_only'} 仅链接=- 语气=- 排名=-
D 名字被包含    提及={'甲数据云': 'names'} 仅链接=- 语气=- 排名={'甲数据云': (1, 'prose')}
E 旧名       提及={'甲数据': 'old', '乙监测': 'names'} 仅链接=- 语气=- 排名={'甲数据': (1, 'prose'), '乙监测': (2, 'prose')}
F 泛化否定     提及={'甲数据': 'names'} 仅链接=- 语气=- 排名={'甲数据': (1, 'prose')}
G 比较句      提及={'甲数据': 'names', '乙监测': 'names'} 仅链接=- 语气=- 排名={'甲数据': (2, 'prose'), '乙监测': (1, 'prose')}
H 真否定      提及={'甲数据': 'names'} 仅链接=- 语气={'甲数据': 'limit'} 排名={'甲数据': (1, 'prose')}
I 表格排名     提及={'甲数据': 'names', '乙监测': 'names'} 仅链接=- 语气=- 排名={'甲数据': (2, 'table'), '乙监测': (1, 'table')}
J 编号排名     提及={'甲数据': 'names', '乙监测': 'names'} 仅链接=- 语气=- 排名={'甲数据': (2, 'numbered'), '乙监测': (1, 'numbered')}
K 正文顺序     提及={'甲数据': 'names', '乙监测': 'names'} 仅链接=- 语气=- 排名={'甲数据': (2, 'prose'), '乙监测': (1, 'prose')}

import json, os, sys
from openai import OpenAI
from mention import analyze, build_alias_index, BRANDS

client = OpenAI(api_key=os.environ["HUNYUAN_API_KEY"],
                base_url=os.getenv("HUNYUAN_BASE_URL", "https://api.hunyuan.cloud.tencent.com/v1"))
index = build_alias_index(BRANDS)

for q in [l.strip() for l in open(sys.argv[1], encoding="utf-8") if l.strip()]:
    resp = client.chat.completions.create(
        model=os.getenv("HUNYUAN_MODEL", "hunyuan-turbos-latest"),
        messages=[{"role": "user", "content": q}],
        extra_body={"enable_enhancement": True},   # 混元的扩展参数：开启搜索增强
    )
    r = analyze(resp.choices[0].message.content or "", index)
    print(json.dumps({"q": q, "mentioned": r.mentioned, "url_only": sorted(r.url_only),
                      "tone": r.tone, "rank": r.rank}, ensure_ascii=False))