Agent/examples_how/overall_derivation/tools/find_pattern.py

"""
查找 Pattern Tool - 从 pattern 库中获取符合条件概率阈值的 pattern

功能：读取账号的 pattern 库，合并去重后按条件概率筛选，返回 topN 条 pattern（含 pattern 名称、条件概率）。
"""

import json
import sys
from pathlib import Path
from typing import Any, Optional

# 保证直接运行或作为包加载时都能解析 utils / tools（IDE 可跳转）
_root = Path(__file__).resolve().parent.parent
if str(_root) not in sys.path:
    sys.path.insert(0, str(_root))
from examples_how.overall_derivation.utils.conditional_ratio_calc import calc_pattern_conditional_ratio
from point_match import _load_match_data, match_derivation_to_post_points
from find_tree_node import _load_trees

try:
    from agent.tools import tool, ToolResult, ToolContext
except ImportError:
    def tool(*args, **kwargs):
        return lambda f: f
    ToolResult = None  # 仅用 main() 测核心逻辑时可无 agent
    ToolContext = None

# 与 pattern_data_process 一致的 key 定义
TOP_KEYS = [
    "depth_max_with_name",
    "depth_mixed",
    "depth_max_concrete",
    "depth2_medium",
    "depth1_abstract",
]
SUB_KEYS = ["two_x", "one_x", "zero_x"]

_BASE_INPUT = Path(__file__).resolve().parent.parent / "input"


def _build_node_info(account_name: str) -> dict[str, dict]:
    """
    构建人设树节点信息映射: node_name -> {
        "type": 节点 _type（"class" / "ID" 等）,
        "children": 子节点名称列表（仅分类节点有值）,
        "siblings": 兄弟节点名称列表（不含自身）,
    }
    """
    node_info: dict[str, dict] = {}

    def _walk(node_dict: dict):
        children_dict = node_dict.get("children") or {}
        child_entries = [(n, c) for n, c in children_dict.items() if isinstance(c, dict)]
        child_names = [n for n, _ in child_entries]
        for name, child in child_entries:
            sub_children = child.get("children") or {}
            sub_child_names = [n for n, c in sub_children.items() if isinstance(c, dict)]
            node_info[name] = {
                "type": child.get("_type", ""),
                "children": sub_child_names,
                "siblings": [n for n in child_names if n != name],
            }
            _walk(child)

    for _dim_name, root in _load_trees(account_name):
        _walk(root)
    return node_info


def _pattern_file(account_name: str) -> Path:
    """pattern 库文件：../input/{account_name}/原始数据/pattern/processed_edge_data.json"""
    return _BASE_INPUT / account_name / "原始数据" / "pattern" / "processed_edge_data.json"


def _slim_pattern(p: dict) -> tuple[float, int, list[str], int]:
    """提取 name 列表（去重保序）、support、length、post_count。"""
    names = [item["name"] for item in (p.get("items") or [])]
    seen = set()
    unique = []
    for n in names:
        if n not in seen:
            seen.add(n)
            unique.append(n)
    support = round(float(p.get("support", 0)), 4)
    length = int(p.get("length", 0))
    post_count = int(p.get("post_count", 0))
    return support, length, unique, post_count


def _merge_and_dedupe(patterns: list[dict]) -> list[dict]:
    """
    按 items 的 name 集合去重（不区分顺序），留 support 最大；
    输出格式保留 s、l、i（nameA+nameB+nameC）及 post_count，供条件概率计算使用。
    """
    key_to_best: dict[tuple, tuple[float, int, int]] = {}
    for p in patterns:
        support, length, unique, post_count = _slim_pattern(p)
        if not unique:
            continue
        key = tuple(sorted(unique))
        if key not in key_to_best or support > key_to_best[key][0]:
            key_to_best[key] = (support, length, post_count)
    out = []
    for k, (s, l, post_count) in key_to_best.items():
        if s < 0.1:
            continue
        out.append({
            "s": s,
            "l": l,
            "i": "+".join(k),
            "post_count": post_count,
        })
    out.sort(key=lambda x: x["s"] * x["l"], reverse=True)
    return out


def _load_and_merge_patterns(account_name: str) -> list[dict]:
    """读取 pattern 库 JSON，按 TOP_KEYS/SUB_KEYS 合并为列表并做合并、去重。"""
    path = _pattern_file(account_name)
    if not path.is_file():
        return []
    with open(path, "r", encoding="utf-8") as f:
        data = json.load(f)
    all_patterns = []
    for top in TOP_KEYS:
        if top not in data:
            continue
        block = data[top]
        for sub in SUB_KEYS:
            all_patterns.extend(block.get(sub) or [])
    return _merge_and_dedupe(all_patterns)


def _parse_derived_list(derived_items: list[dict[str, str]]) -> list[tuple[str, str]]:
    """将 agent 传入的 [{"topic": "x", "source_node": "y"}, ...] 转为 DerivedItem 列表。"""
    out = []
    for item in derived_items:
        if isinstance(item, dict):
            topic = item.get("topic") or item.get("已推导的选题点")
            source = item.get("source_node") or item.get("推导来源人设树节点")
            if topic is not None and source is not None:
                out.append((str(topic).strip(), str(source).strip()))
        elif isinstance(item, (list, tuple)) and len(item) >= 2:
            out.append((str(item[0]).strip(), str(item[1]).strip()))
    return out


def get_patterns_by_conditional_ratio(
    account_name: str,
    derived_list: list[tuple[str, str]],
    conditional_ratio_threshold: float,
    top_n: int,
    post_id: str = "",
) -> list[dict[str, Any]]:
    """
    从 pattern 库中获取条件概率 >= 阈值的 pattern，按以下优先级排序后返回 top_n 条：
      1. pattern 元素中直接包含已推导选题点（topic）的排最前；
      2. pattern 元素与任意已推导选题点的匹配分 >= 0.8 的次之（从 match_data 文件读取，
         key 为 (帖子选题点, 人设树节点)，pattern 元素视为人设树节点）；
      3. 按条件概率降序；
      4. 按 length 降序。
    derived_list 为空时，条件概率使用 pattern 自身的 support（s）。
    返回每项：pattern名称（nameA+nameB+nameC）、条件概率。
    """
    merged = _load_and_merge_patterns(account_name)
    print(f"_load_and_merge_patterns,patterns: {len(merged)}")
    if not merged:
        return []
    base_dir = _BASE_INPUT
    scored: list[tuple[dict, float]] = []

    if not derived_list:
        # derived_items 为空：条件概率取 pattern 本身的 support (s)
        for p in merged:
            ratio = float(p.get("s", 0))
            if ratio >= conditional_ratio_threshold:
                scored.append((p, ratio))
    else:
        for p in merged:
            ratio = calc_pattern_conditional_ratio(
                account_name, derived_list, p, base_dir=base_dir
            )
            if ratio >= conditional_ratio_threshold:
                scored.append((p, ratio))

    derived_topics = {topic for topic, _ in derived_list} if derived_list else set()

    # 次优先：从 match_data 文件加载 (帖子选题点, 人设树节点) -> 匹配分，
    # 用已推导选题点（topic）作为帖子选题点，pattern 元素作为人设树节点，
    # 检查是否存在匹配分 >= 0.8 的组合。
    match_lookup: dict[tuple[str, str], float] = {}
    if derived_topics and post_id:
        match_lookup = _load_match_data(account_name, post_id)

    def _sort_key(x: tuple[dict, float]) -> tuple:
        p, ratio = x
        elements = set(p["i"].split("+"))
        has_derived = bool(elements & derived_topics)
        has_high_match = False
        if not has_derived and match_lookup:
            for elem in elements:
                for dt in derived_topics:
                    if match_lookup.get((dt, elem), 0.0) >= 0.8:
                        has_high_match = True
                        break
                if has_high_match:
                    break
        return (not has_derived, not has_high_match, -ratio, -p["l"])

    scored.sort(key=_sort_key)
    result = []
    for p, ratio in scored[:top_n]:
        result.append({
            "pattern名称": p["i"],
            "条件概率": round(ratio, 6),
        })
    return result


@tool(
    description="按条件概率从 pattern 库中筛选 pattern，优先返回包含已推导选题点的 pattern，并检查每个 pattern 的元素是否与帖子选题点匹配。"
    "功能：根据账号与已推导选题点（可选），筛选条件概率不低于阈值的 pattern；当 derived_items 非空时，优先返回 pattern 元素中包含已推导选题点的 pattern；同时对每个 pattern 的所有元素做帖子选题点匹配，匹配结果直接包含在返回数据中。"
    "参数：account_name 为账号名；post_id 为帖子ID，用于加载帖子选题点并做匹配判断；derived_items 为已推导选题点列表，每项含 topic（或已推导的选题点）与 source_node（或推导来源人设树节点），可为空，为空时条件概率使用 pattern 自身的 support；conditional_ratio_threshold 为条件概率阈值；top_n 为返回条数上限，默认 100。"
    "返回：ToolResult，output 为可读的 pattern 列表文本"
)
async def find_pattern(
    account_name: str,
    post_id: str,
    derived_items: list[dict[str, str]],
    conditional_ratio_threshold: float,
    top_n: int = 100,
    context: Optional[ToolContext] = None,
) -> ToolResult:
    """
    按条件概率阈值从 pattern 库筛选 pattern，返回最多 top_n 条（按条件概率降序）。
    当 derived_items 非空时，优先返回元素中包含已推导选题点的 pattern。
    返回前对每个 pattern 的所有元素做帖子选题点匹配，匹配结果直接包含在返回数据中。

    参数
    -------
    account_name : 账号名，用于定位该账号的 pattern 库。
    post_id : 帖子ID，用于加载帖子选题点并与 pattern 元素做匹配判断。
    derived_items : 已推导选题点列表，可为空。非空时每项为字典，需含 topic（或「已推导的选题点」）与 source_node（或「推导来源人设树节点」）；为空时各 pattern 的条件概率取其自身 support。
    conditional_ratio_threshold : 条件概率阈值，仅返回条件概率 >= 该值的 pattern。
    top_n : 返回条数上限，默认 100。
    context : 可选，Agent 工具上下文。

    返回
    -------
    ToolResult：
        - title: 结果标题。
        - output: 可读的 pattern 列表文本（每行：pattern名称、条件概率、帖子匹配情况）。
          "帖子选题点匹配": 无匹配时为 "无"，有匹配时为 list[{"pattern元素", "帖子选题点", "匹配分数"}]}。
        - 出错时 error 为错误信息。
    """
    pattern_path = _pattern_file(account_name)
    if not pattern_path.is_file():
        return ToolResult(
            title="Pattern 库不存在",
            output=f"pattern 文件不存在: {pattern_path}",
            error="Pattern file not found",
        )
    try:
        derived_list = _parse_derived_list(derived_items or [])
        items = get_patterns_by_conditional_ratio(
            account_name, derived_list, conditional_ratio_threshold, top_n, post_id
        )
        # 批量收集所有 pattern 元素，统一做一次帖子选题点匹配
        if items and post_id:
            all_elements: list[str] = []
            seen_elements: set[str] = set()
            for item in items:
                for elem in item["pattern名称"].split("+"):
                    elem = elem.strip()
                    if elem and elem not in seen_elements:
                        all_elements.append(elem)
                        seen_elements.add(elem)
            matched_results = await match_derivation_to_post_points(all_elements, account_name, post_id)
            elem_match_map: dict[str, list] = {}
            for m in matched_results:
                elem_match_map.setdefault(m["推导选题点"], []).append({
                    "帖子选题点": m["帖子选题点"],
                    "匹配分数": m["匹配分数"],
                })
            for item in items:
                pattern_matches = []
                for elem in item["pattern名称"].split("+"):
                    elem = elem.strip()
                    for post_match in elem_match_map.get(elem, []):
                        pattern_matches.append({
                            "pattern元素": elem,
                            "帖子选题点": post_match["帖子选题点"],
                            "匹配分数": post_match["匹配分数"],
                        })
                # 仅当 pattern 元素匹配到至少 2 个不同帖子选题点时才返回匹配信息，否则为无
                distinct_post_points = len({m["帖子选题点"] for m in pattern_matches})
                item["帖子选题点匹配"] = (
                    pattern_matches if distinct_post_points >= 2 else "无"
                )


        # [临时] 仅保留有帖子选题点匹配的记录（distinct_post_points>=2），方便后续删除
        items = [x for x in items if isinstance(x.get("帖子选题点匹配"), list)]

        # 对未匹配帖子选题点的 pattern 元素，通过人设树子节点/兄弟节点扩展匹配
        if items and post_id:
            node_info_map = _build_node_info(account_name)
            all_candidates_set: set[str] = set()
            item_unmatched_info: list[list[tuple[str, list[str]]]] = []

            for item in items:
                pattern_matches = item.get("帖子选题点匹配", [])
                matched_elems = (
                    {m["pattern元素"] for m in pattern_matches}
                    if isinstance(pattern_matches, list) else set()
                )
                all_elems = [e.strip() for e in item["pattern名称"].split("+")]
                unmatched = [e for e in all_elems if e not in matched_elems]

                elem_candidates: list[tuple[str, list[str], str]] = []
                for elem in unmatched:
                    info = node_info_map.get(elem)
                    if not info:
                        continue
                    if info["type"] == "class" and info["children"]:
                        candidates = info["children"]
                        expand_type = "子节点"
                    else:
                        candidates = info["siblings"]
                        expand_type = "兄弟节点"
                    if candidates:
                        elem_candidates.append((elem, candidates, expand_type))
                        all_candidates_set.update(candidates)
                item_unmatched_info.append(elem_candidates)

            if all_candidates_set:
                candidate_matches = await match_derivation_to_post_points(
                    list(all_candidates_set), account_name, post_id
                )
                cand_match_map: dict[str, list[tuple[str, float]]] = {}
                for m in candidate_matches:
                    cand_match_map.setdefault(m["推导选题点"], []).append(
                        (m["帖子选题点"], m["匹配分数"])
                    )
                for item, elem_cands in zip(items, item_unmatched_info):
                    for elem, candidates, expand_type in elem_cands:
                        best_cand, best_pp, best_sc = None, None, -1.0
                        for cand in candidates:
                            for pp, sc in cand_match_map.get(cand, []):
                                if sc > best_sc:
                                    best_cand, best_pp, best_sc = cand, pp, sc
                        if best_cand is not None:
                            item["帖子选题点匹配"].append({
                                "pattern元素": elem,
                                "帖子选题点": best_pp,
                                "匹配分数": best_sc,
                                "扩展节点": best_cand,
                                "扩展类型": expand_type,
                            })

        # 同一 pattern 内帖子选题点去重：同一帖子选题点出现多次时只保留分数最高的
        for item in items:
            matches = item.get("帖子选题点匹配")
            if not isinstance(matches, list):
                continue
            best_by_pp: dict[str, dict] = {}
            for m in matches:
                pp = m["帖子选题点"]
                if pp not in best_by_pp or m["匹配分数"] > best_by_pp[pp]["匹配分数"]:
                    best_by_pp[pp] = m
            item["帖子选题点匹配"] = list(best_by_pp.values())

        if not items:
            output = f"未找到条件概率 >= {conditional_ratio_threshold} 的 pattern"
        else:
            lines = []
            for x in items:
                match_info = x.get("帖子选题点匹配", "无")
                if isinstance(match_info, list):
                    match_str = "、".join(
                        (
                            f"{m['扩展节点']}({m['pattern元素']}的{m['扩展类型']})→{m['帖子选题点']}({m['匹配分数']})"
                            if "扩展节点" in m else
                            f"{m['pattern元素']}→{m['帖子选题点']}({m['匹配分数']})"
                        )
                        for m in match_info
                    )
                else:
                    match_str = str(match_info)
                lines.append(f"- {x['pattern名称']}\t条件概率={x['条件概率']}\t帖子选题点匹配={match_str}")
            output = "\n".join(lines)
        return ToolResult(
            title=f"符合条件概率的 Pattern ({account_name}, 阈值={conditional_ratio_threshold})",
            output=output,
            metadata={
                "account_name": account_name,
                "conditional_ratio_threshold": conditional_ratio_threshold,
                "top_n": top_n,
                "count": len(items),
            },
        )
    except Exception as e:
        return ToolResult(
            title="查找 Pattern 失败",
            output=str(e),
            error=str(e),
        )


def main() -> None:
    """本地测试：用家有大志账号、已推导选题点，查询符合条件概率阈值的 pattern（含帖子匹配）。"""
    import asyncio

    account_name = "家有大志"
    post_id = "68fb6a5c000000000302e5de"
    # 已推导选题点，每项：已推导的选题点 + 推导来源人设树节点
    # derived_items = [
    #     {"topic": "分享", "source_node": "分享"},
    #     {"topic": "植入方式", "source_node": "植入方式"},
    #     {"topic": "叙事结构", "source_node": "叙事结构"},
    # ]
    derived_items = derived_items = [{"source_node":"分享","topic":"分享"},{"source_node":"叙事结构","topic":"叙事结构"},{"source_node":"图片文字","topic":"图片文字"},{"source_node":"补充说明式","topic":"补充说明式"},{"source_node":"幽默化标题","topic":"幽默化标题"},{"source_node":"标题","topic":"标题"}]
    conditional_ratio_threshold = 0.01
    top_n = 2000

    # 1）直接调用核心函数（不含帖子匹配，仅验证排序逻辑）
    # derived_list = _parse_derived_list(derived_items)
    # items = get_patterns_by_conditional_ratio(
    #     account_name, derived_list, conditional_ratio_threshold, top_n, post_id
    # )
    # print(f"账号: {account_name}, 阈值: {conditional_ratio_threshold}, top_n: {top_n}")
    # print(f"共 {len(items)} 条 pattern:\n")
    # for x in items:
    #     print(f"  - {x['pattern名称']}\t条件概率={x['条件概率']}")

    # 2）有 agent 时通过 tool 接口再跑一遍（含帖子选题点匹配）
    if ToolResult is not None:
        async def run_tool():
            result = await find_pattern(
                account_name=account_name,
                post_id=post_id,
                derived_items=derived_items,
                conditional_ratio_threshold=conditional_ratio_threshold,
                top_n=top_n,
            )
            print("\n--- Tool 返回 ---")
            print(result.output)
        asyncio.run(run_tool())


if __name__ == "__main__":
    main()