rag-verifier 0.1.0__py3-none-any.whl

rag_verifier/__init__.py

@@ -0,0 +1,27 @@
+"""rag-verifier 对外包入口。
+
+    from rag_verifier import verify_chunks
+
+只依赖验证层（不导入 docling/pymupdf/检索层），可作为独立组件嵌入任意
+Python 流水线：任意解析器产出的块 → 五关质量验证。
+"""
+from rag_verifier.chunking.rules import CHECKS, RuleContext, detect_language, list_rules, register_rule
+from rag_verifier.chunking.semantic_verifier import builtin_llm
+from rag_verifier.citation.verifier import verify_citation
+from rag_verifier.models import EvidenceCard, VerificationResult, VerificationStatus
+from rag_verifier.verify_api import verify_chunk, verify_chunks
+
+__all__ = [
+    "verify_chunk",
+    "verify_chunks",
+    "verify_citation",
+    "EvidenceCard",
+    "VerificationResult",
+    "VerificationStatus",
+    "builtin_llm",
+    "register_rule",
+    "detect_language",
+    "list_rules",
+    "RuleContext",
+    "CHECKS",
+]

rag_verifier/chunking/__init__.py

@@ -0,0 +1,3 @@
+from rag_verifier.chunking.splitter import split_document
+
+__all__ = ["split_document"]

rag_verifier/chunking/detector.py

@@ -0,0 +1,72 @@
+"""结构探测：扫描全文，识别文档的编号体系，据此选择切分策略。
+
+设计原则：切分器不预设文档类型。先统计「哪种编号模式在本文档中占主导」，
+再据此选切分器；探测不到任何结构时诚实降级到段落切分，并标注探测失败。
+
+注意：本模块的编号模式全部是行首锚定（配合 re.MULTILINE），
+因此探测必须跑在「保留换行」的清洗文本上——若先把换行拼掉，
+`^` 就只剩全文首行能匹配，所有计数都会失真。
+"""
+import re
+
+# 编号模式表：name -> 行首锚定正则
+PATTERNS = {
+    "clause_cn":     r"^第[一二三四五六七八九十百零〇\d]+条",      # 合同：第九条
+    "item_cn":       r"^（[一二三四五六七八九十]+）",              # 合同子条款：（一）
+    "chapter_cn":    r"^第[一二三四五六七八九十]+章",              # 章节：第三章
+    "clause_num":    r"^\d+(?:\.\d+)+\.?(\s|$)",                  # GB/T：5.1 / 5.1.1；RFC：5.6.（尾点）
+    "chapter_num":   r"^\d{1,2}(\s+\S.*)?$",                      # GB/T 顶级章：1 范围 / 5 显式标识
+    "appendix_num":  r"^[A-Z]\.\d+(?:\.\d+)*(\s|$)",             # 附录编号：A.1 / C.1.1 / D.2.1
+    "appendix_head": r"^附\s*录\s*[A-Z]",                        # 附录标题：附 录 A
+    "section_num":   r"^\d+\.\s",                                # 论文：1. 标题
+    "section_alpha": r"^[a-z]\.\s",                              # 论文：a. 标题
+    "article_en":    r"^Article\s+\d+",                          # 英文合同：Article 5
+    "section_en":    r"^Section\s+\d+",                          # 英文文件：Section 5
+}
+
+MIN_HITS = 3  # 某模式命中 ≥3 次，才认为它是本文档的编号体系
+
+# 切分器选择优先级（互斥判定，避免互相踩）：
+#   1) 「数字点层级」或附录编号 → 层级数字编号文档（GB/T 这类）
+#   2) 中文条款（第X条 / （一） / 第X章）→ 合同类
+#   3) 英文条款（Article / Section）
+#   4) 只有顶级章、没有子条款 → 仍是层级数字编号文档
+#   5) 都没有 → 段落兜底
+# clause_num 与 section_num 互斥：前者要求「数字点数字」(5.1)，后者要求「数字点 + 空格」(1. 标题)。
+# chapter_num 单独不足以判定：页码、"ICS 35.030"、表格序号这类裸数字也会命中它，
+# 所以它只在「已排除其他体系」之后作为兜底信号，不作为首选依据。
+NUMERIC_STRONG = ("clause_num", "appendix_num", "appendix_head")
+CHINESE_KEYS = ("clause_cn", "item_cn", "chapter_cn")
+ENGLISH_KEYS = ("article_en", "section_en")
+
+
+def is_active(active: dict, keys) -> bool:
+    return any(k in active for k in keys)
+
+
+def detect_structure(text: str) -> dict:
+    """统计各编号模式的命中数，返回命中数以及「主导模式」（命中 ≥ MIN_HITS）。"""
+    counts = {name: len(re.findall(pattern, text, re.MULTILINE)) for name, pattern in PATTERNS.items()}
+    active = {name: n for name, n in counts.items() if n >= MIN_HITS}
+    return {"counts": counts, "active": active}
+
+
+def select_splitter(active: dict) -> str:
+    """按优先级从「主导模式」里选切分器；一个都没有则段落兜底。
+
+    选中 ≠ 可用：hierarchical_chinese 的切块锚点只有「第X条」——（X）只是条内
+    二级切分、「第X章」不是它的锚点。主导信号若只有 item_cn/chapter_cn 而无
+    clause_cn，选中后一个锚点都打不到 → 静默 0 块（盲测白皮书实测：「（一）」
+    顿号体系文档 0 块）。锚点存在性校验：clause_cn 不在 active 就诚实降级。
+    """
+    if is_active(active, NUMERIC_STRONG):
+        return "hierarchical_numeric"
+    if is_active(active, CHINESE_KEYS):
+        if "clause_cn" in active:
+            return "hierarchical_chinese"
+        return "paragraph_fallback"
+    if is_active(active, ENGLISH_KEYS):
+        return "hierarchical_english"
+    if "chapter_num" in active:
+        return "hierarchical_numeric"
+    return "paragraph_fallback"

rag_verifier/chunking/rules.py

@@ -0,0 +1,90 @@
+"""规则注册表：按检查项 + 语种分组，内置规则与第三方规则走同一接口。
+
+语种由 detect_language 按 CJK 字符占比自动判定（zh / en）；
+lang="any" 的规则对所有语种生效。规则按注册顺序执行，先命中先返回。
+
+第三方扩展示例（不改本仓库任何文件）：
+
+    from rag_verifier.chunking.rules import register_rule
+
+    @register_rule("completeness", lang="en", id="no_currency_unit")
+    def my_rule(card, ctx):
+        # 返回 VerificationResult 表示命中，返回 None 表示放行
+        ...
+        return None
+"""
+import re
+from dataclasses import dataclass
+from typing import Callable
+
+from rag_verifier.models import EvidenceCard
+
+CJK_RE = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]")
+
+CHECKS = (
+    "independence",
+    "completeness",
+    "traceability",
+    "semantic_independence",
+    "template_completeness",
+)
+
+
+def detect_language(text: str) -> str:
+    """按 CJK 字符占比判定语种：非空白字符中 CJK 占比 ≥15% 判 zh，否则 en。
+
+    纯符号/数字块（如 "3.1"）判为 en——中英规则对这类块都不命中，
+    不影响判定结果。
+    """
+    if not text:
+        return "en"
+    cjk = len(CJK_RE.findall(text))
+    nonspace = len(re.sub(r"\s", "", text))
+    if nonspace and cjk / nonspace >= 0.15:
+        return "zh"
+    return "en"
+
+
+@dataclass
+class RuleContext:
+    """规则执行上下文：语种 + 前一块 + 源文本 + 全文。"""
+
+    lang: str
+    prev_chunk: str = ""
+    source_text: str = ""
+    full_doc: str = ""
+
+
+@dataclass
+class Rule:
+    id: str
+    check: str
+    lang: str  # zh / en / any
+    fn: Callable[[EvidenceCard, RuleContext], object]
+
+
+_RULES: list[Rule] = []
+
+
+def register_rule(check: str, lang: str = "any", id: str | None = None):
+    """注册规则。check 必须是 CHECKS 之一；lang 为 zh / en / any。"""
+    if check not in CHECKS:
+        raise ValueError(f"未知检查项: {check}（可选: {', '.join(CHECKS)}）")
+    if lang not in ("zh", "en", "any"):
+        raise ValueError(f"未知语种: {lang}（可选: zh / en / any）")
+
+    def deco(fn):
+        _RULES.append(Rule(id=id or fn.__name__, check=check, lang=lang, fn=fn))
+        return fn
+
+    return deco
+
+
+def rules_for(check: str, lang: str) -> list[Rule]:
+    """取出某检查项在当前语种下生效的规则（保持注册顺序）。"""
+    return [r for r in _RULES if r.check == check and r.lang in ("any", lang)]
+
+
+def list_rules() -> list[dict]:
+    """规则清单（调试/文档用途）。"""
+    return [{"id": r.id, "check": r.check, "lang": r.lang} for r in _RULES]