structverify 0.3.0__py3-none-any.whl

structverify/detection/schema/temporal_hints.py

@@ -0,0 +1,130 @@
+"""detection/schema/temporal_hints.py — schema induction 시점 hint 빌더.
+
+schema_inductor.py에서 분리 (로직 move-only, 동작 변경 없음).
+
+[v6.15] 상대 시점 표현 → 절대 연도 변환표
+[v6.19] multi_temporal 판정 — 단정 hint vs 변환표 분기
+[v6.20] claim_text 정규식 스캔 — 그래프 누락 보완
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from structverify.core.schemas import Claim
+from structverify.utils.logger import get_logger
+
+if TYPE_CHECKING:
+    from structverify.graph.graph_builder import ClaimGraph
+
+logger = get_logger(__name__)
+
+
+# [v6.20] claim 문장 텍스트에서 직접 셀 상대/절대 시점 표현 패턴.
+# document_graph의 LLM temporal agent가 한 문장의 표현을 일부 누락하면
+# (예: "작년...재작년..."에서 "작년"을 빠뜨림) count_temporal_expressions가
+# 1을 반환 → multi_temporal=False → 잘못된 단정 hint. 그래서 그래프와
+# 별개로 claim_text를 정규식으로 스캔해 보수적으로 multi 여부를 판정한다.
+_TEMPORAL_TEXT_PATTERNS = (
+    "재작년", "지지난해", "지지난 해",
+    "작년", "지난해", "지난 해", "전년",
+    "올해", "금년", "이번 해",
+    "내년", "이듬해", "다음 해",
+    "내후년",
+)
+
+
+def _count_temporal_in_text(text: str) -> int:
+    """claim 문장 텍스트에서 상대 시점 표현의 개수를 센다.
+
+    "작년 X도, 재작년 Y도" → 2 (작년 1 + 재작년 1).
+    겹치는 패턴 중복 카운트를 막기 위해, 긴 패턴부터 매칭하며
+    매칭된 구간을 소거한다 ('재작년'을 먼저 잡아야 '작년'이
+    그 안에서 다시 안 잡힌다).
+    """
+    if not text:
+        return 0
+    s = str(text)
+    count = 0
+    # 긴 패턴 우선 (재작년 → 작년 순서 보장)
+    for pat in sorted(_TEMPORAL_TEXT_PATTERNS, key=len, reverse=True):
+        while pat in s:
+            count += 1
+            s = s.replace(pat, "\x00" * len(pat), 1)  # 매칭 구간 소거
+    return count
+
+
+def _build_temporal_hint(graph: "ClaimGraph", claim: Claim) -> str:
+    """
+    그래프 시점 해소 결과를 prompt hint 텍스트로.
+
+    [v6.15] 상대 시점 표현 매핑 강화:
+      anchor_year 기준으로 '내년/올해/작년/지난해/재작년'을 모두 절대 연도로
+      변환하는 표를 LLM에게 명시 → time_period=null 방지.
+    """
+    prov = graph.temporal_provenance(claim)
+    anchor_year = graph.get_anchor_year()
+
+    # [v6.19] 한 문장에 시간표현이 여러 개면 (예: "작년 X도, 재작년 Y도")
+    # temporal_provenance가 어느 표현이 이 claim의 것인지 구분 못 하고
+    # 첫 번째를 무조건 반환한다 → 단정적 hint가 틀릴 수 있음.
+    # 이 경우 단정하지 말고 anchor 변환표만 줘서 LLM이 claim 문맥으로
+    # 직접 시점을 고르게 한다.
+    _te_count = graph.count_temporal_expressions(claim)
+    # [v6.20] 그래프 카운트와 별개로 claim 문장 텍스트도 직접 스캔.
+    # temporal agent가 표현을 누락해도(그래프 te_count=1) 텍스트에
+    # 상대표현이 2개 이상이면 multi로 판정 → 잘못된 단정 hint 방지.
+    _text_te_count = _count_temporal_in_text(
+        getattr(claim, "claim_text", "") or ""
+    )
+    multi_temporal = (_te_count > 1) or (_text_te_count > 1)
+
+    # [v6.19 진단] multi_temporal 판정과 분기 결정을 로그로 — 어느 경로를
+    # 탔는지 안 보여서 temporal 수정이 먹혔는지 확인이 안 됨.
+    _branch = (
+        "단정(prov)" if (prov and prov.get("resolved") and not multi_temporal)
+        else ("변환표(anchor)" if anchor_year is not None else "없음")
+    )
+    logger.info(
+        f"[temporal_hint] {getattr(claim, 'sent_id', '?')}: "
+        f"te_count={_te_count} text_te={_text_te_count} "
+        f"multi_temporal={multi_temporal} "
+        f"prov_resolved={(prov or {}).get('resolved')} "
+        f"prov_expr={(prov or {}).get('expression')!r} "
+        f"anchor={anchor_year} → branch={_branch}"
+    )
+
+    if prov and prov.get("resolved") and not multi_temporal:
+        return (
+            f"\n[시점 정보 — 그래프 해소 결과]\n"
+            f"- 원문 표현: {prov.get('expression')}\n"
+            f"- 해소된 절대 시점: {prov['resolved']}\n"
+            f"- 근거: {prov.get('basis') or '문서 anchor 기반'}\n"
+            f"위 절대 시점을 time_period로 사용하세요."
+        )
+    elif anchor_year is not None:
+        # [v6.15] 상대 표현 → 절대 연도 변환표를 명시적으로 제공
+        multi_note = ""
+        if multi_temporal:
+            # [v6.19] 한 문장에 시간표현이 여러 개 — 수치별로 구분 지시
+            multi_note = (
+                f"- ⚠️ 이 문장에는 시점 표현이 *둘 이상* 있습니다 "
+                f"(예: '작년 X도, 재작년 Y도').\n"
+                f"  각 수치 바로 앞/근처의 시점 표현을 보고 schema마다 "
+                f"time_period를 *개별적으로* 정확히 매칭하세요.\n"
+                f"  모든 수치에 같은 시점을 쓰지 마세요.\n"
+            )
+        return (
+            f"\n[시점 정보 — 문서 anchor]\n"
+            f"- 이 문서의 기준 연도(anchor_year): {anchor_year}\n"
+            f"{multi_note}"
+            f"- 상대 시점 표현은 *반드시* 아래 표대로 절대 연도로 변환하세요:\n"
+            f"    '내후년'        → {anchor_year + 2}\n"
+            f"    '내년/이듬해'   → {anchor_year + 1}\n"
+            f"    '올해/금년/현재' → {anchor_year}\n"
+            f"    '작년/지난해'   → {anchor_year - 1}\n"
+            f"    '재작년'        → {anchor_year - 2}\n"
+            f"- ★ 검증 대상 문장에 위 상대 표현이 하나라도 있으면\n"
+            f"  time_period를 절대 연도(예: '{anchor_year + 1}')로 *반드시* 채우세요.\n"
+            f"- ★ time_period를 null로 두지 마세요. 시점 단서가 전혀 없을 때만 null."
+        )
+    return ""

structverify/detection/schema/validate.py

@@ -0,0 +1,193 @@
+"""detection/schema/validate.py — schema induction 수치·source_phrase 검증.
+
+schema_inductor.py에서 분리 (로직 move-only, 동작 변경 없음).
+
+[v6.14] context leak 방지 — _source_phrase_in_claim
+[v6.14 E] value 환산 정확성 — _verify_and_correct_value
+[박재윤 2026-05-18] _extract_numbers_from_text "N만 NNNN" 패턴
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from structverify.core.schemas import ClaimSchema
+
+
+# ── [v6.14 E fix] value 환산 정확성 검증 ───────────────────────────────
+
+def _verify_and_correct_value(
+    value: float | None,
+    source_phrase: str,
+) -> tuple[float | None, bool]:
+    """
+    LLM이 보낸 value의 환산 정확성을 source_phrase로부터 검증.
+
+    "2만 171" → 21710 같은 환산 오류를 잡아냄:
+    - source_phrase에서 우리 코드로 수치 추출 (한글 단위 포함)
+    - 그 수치 집합 중 value와 *가장 가까운 값* 찾음
+    - 차이가 0.5% 이상이면 → 그 가까운 값으로 교체
+
+    Returns:
+        (corrected_value, was_corrected_flag)
+    """
+    if value is None or not source_phrase:
+        return value, False
+
+    sp_numbers = _extract_numbers_from_text(source_phrase)
+    if not sp_numbers:
+        return value, False  # 환산 불가능한 표현 → 그대로
+
+    # value에 가장 가까운 수
+    closest = min(sp_numbers, key=lambda n: abs(n - value))
+
+    # 차이 작으면 OK
+    if abs(closest - value) < 0.001:
+        return value, False
+    if value != 0 and abs(closest - value) / abs(value) < 0.005:
+        return value, False
+
+    # 차이 큼 — closest로 교체
+    return float(closest), True
+
+
+# ── [v6.14] Context leak 방지를 위한 검증 헬퍼 ───────────────────────────────
+
+def _source_phrase_in_claim(phrase: str, claim_text: str) -> bool:
+    """
+    LLM이 제공한 source_phrase가 claim_text에 등장하는지 검증.
+
+    [v6.15] 3단계 비교:
+      1) 직접 substring
+      2) 공백 제거 후 비교
+      3) 숫자 기준 비교 — source_phrase의 모든 숫자가 claim_text에 있으면 통과
+         ("6.8%" vs "6.8%↑" 처럼 기호 차이로 1·2단계가 실패하는 경우 대응)
+    """
+    if not phrase or not claim_text:
+        return False
+    # 1) 직접 substring
+    if phrase in claim_text:
+        return True
+    # 2) 공백 제거 후 비교 (예: "1만 7921 건" vs "1만 7921건")
+    phrase_no_space = re.sub(r"\s+", "", phrase)
+    claim_no_space = re.sub(r"\s+", "", claim_text)
+    if phrase_no_space in claim_no_space:
+        return True
+    # 3) [v6.15] 숫자 기준 비교 — 기호(↑↓%、 등) 차이 흡수
+    #    source_phrase의 숫자들이 모두 claim_text 안에 있으면 leak 아님
+    phrase_nums = re.findall(r"\d+\.?\d*", phrase)
+    if phrase_nums:
+        claim_nums = set(re.findall(r"\d+\.?\d*", claim_text))
+        if all(n in claim_nums for n in phrase_nums):
+            return True
+    return False
+
+
+def _value_in_claim_text(value: float, claim_text: str) -> bool:
+    """
+    source_phrase가 누락된 경우 fallback. value의 환산 전 표기가 문장에 있는지 검증.
+
+    예: value=20171 → "2만 171", "20171", "20,171" 등 매칭 시도.
+    """
+    if value is None:
+        return True
+    if not claim_text:
+        return False
+
+    # 텍스트에서 모든 수치(한글 단위 포함) 추출 → 집합 만들고 value와 매칭
+    numbers = _extract_numbers_from_text(claim_text)
+    for n in numbers:
+        if abs(n - value) < 0.001:
+            return True
+        if value != 0 and abs(n - value) / abs(value) < 0.005:
+            return True
+    return False
+
+
+def _extract_numbers_from_text(text: str) -> set[float]:
+    """
+    텍스트에서 한글 단위 포함 모든 수치 추출.
+
+    - "2만 171" → 20171
+    - "1만 9059" → 19059
+    - "6.7" → 6.7
+    - "0.76" → 0.76
+    - "238,317" → 238317
+    """
+    numbers: set[float] = set()
+
+    # 콤마 포함 숫자 그룹을 안전 파싱 (예: "1,500" → 1500). 콤마가 없으면 그대로.
+    # [버그수정] 기존 (\d+)는 "1,500만"에서 콤마에 끊겨 "500만"=5,000,000으로 오파싱 →
+    #           [\d,]+로 콤마를 포함해 "1,500만"=15,000,000으로 올바르게.
+    def _n(s: str) -> int:
+        return int(s.replace(",", ""))
+
+    # [박재윤 - 2026-05-18] "N만 N천" 복합 패턴 (앞 패턴보다 먼저 실행 필요)
+    # "2869만 3000명" → 28693000
+    # "159만 명" 같은 경우와 구분: 뒤 숫자가 1000 단위인 경우
+    for m in re.finditer(r"([\d,]+)\s*만\s*(\d{4})", text):
+        numbers.add(float(_n(m.group(1)) * 10000 + int(m.group(2))))
+
+    # 1) 한글 단위 — "N만 M" 또는 "N만"
+    for m in re.finditer(r"([\d,]+)\s*만\s*([\d,]+)?", text):
+        n = _n(m.group(1)) * 10000
+        if m.group(2):
+            n += _n(m.group(2))
+        numbers.add(float(n))
+
+    # 2) 한글 단위 — "N억 M" 또는 "N억"
+    for m in re.finditer(r"([\d,]+)\s*억\s*([\d,]+)?", text):
+        n = _n(m.group(1)) * 100_000_000
+        if m.group(2):
+            n += _n(m.group(2))
+        numbers.add(float(n))
+
+    # 3) 한글 단위 — "N천 M" (앞에 만/억 없을 때만)
+    for m in re.finditer(r"(?<![만억\d,])([\d,]+)\s*천\s*([\d,]+)?", text):
+        n = _n(m.group(1)) * 1000
+        if m.group(2):
+            n += _n(m.group(2))
+        numbers.add(float(n))
+
+    # "N만 M천" 복합 패턴
+    for m in re.finditer(r"([\d,]+)\s*만\s*([\d,]+)\s*천", text):
+        numbers.add(float(_n(m.group(1)) * 10000 + _n(m.group(2)) * 1000))
+
+    # 4) 일반 숫자 (콤마 포함 정수 + 소수)
+    for m in re.finditer(r"[\d,]+(?:\.\d+)?", text):
+        s = m.group().replace(",", "")
+        if not s or s in (".",):
+            continue
+        try:
+            numbers.add(float(s))
+        except ValueError:
+            pass
+
+    return numbers
+
+
+def _validate_schema(schema: ClaimSchema) -> bool:
+    """indicator 없으면 KOSIS 검색 불가 → 실패 처리."""
+    if not schema.indicator or len(schema.indicator.strip()) < 2:
+        return False
+    return True
+
+
+def _safe_float(v: Any) -> float | None:
+    """다양한 수치 표현 → float 변환.
+
+    LLM이 이미 한글 단위를 환산해줘야 하지만, 혹시 문자열로 넘어올 때를 위한 백업.
+    """
+    if v is None:
+        return None
+    if isinstance(v, (int, float)):
+        return float(v)
+    if isinstance(v, str):
+        cleaned = re.sub(r"[%,약\s]", "", v.strip())
+        match = re.search(r"-?[\d.]+", cleaned)
+        if match:
+            try:
+                return float(match.group())
+            except ValueError:
+                pass
+    return None

structverify/detection/schema_inductor.py

@@ -0,0 +1,112 @@
+"""
+detection/schema_inductor.py — Dynamic Schema Induction (Step 5)
+
+[김예슬 - 2026-04-22]
+- SCHEMA_INDUCTION_PROMPT: 도메인 컨텍스트 주입 + 예시 강화
+- _safe_float(): 다양한 수치 표현 파싱 ("64.2%", "약 64" 등)
+- _validate_schema(): 최소 유효성 검증
+- 재시도 로직 추가 (최대 2회)
+
+[김예슬 - 2026-04-24]
+- generate_json() → generate_structured() 으로 교체
+  · Structured Outputs (HCX-007) → JSON Schema 보장 (파싱 실패 없음)
+- CLAIM_SCHEMA_JSON_SCHEMA: ClaimSchema에 대응하는 JSON Schema 정의 추가
+
+[v6.11 - 2026-05-12]
+- 룰베이스 후처리 제거 (_cleanse_indicator, _normalize_time_period)
+- 박재유 SYSTEM_PROMPT 스타일 차용: 단위 강제 + indicator 정제 + parent_path 추출
+- ClaimSchema 신규 필드 추출: parent_path / is_approximate / modifier
+- 모든 정제 책임은 LLM에게 위임 (룰 베이스 X)
+
+# [박재윤 - 2026-05-14]: SCHEMA_INDUCTION_PROMPT system_prompt 개선
+#   · 예보/예상/전망/예측 indicator → schema 추출 금지 규칙 추가
+
+# [박재윤 - 2026-05-15]: SCHEMA_INDUCTION_PROMPT 수치 추출 규칙 보강
+#   · "~였다/~이다/~다" 패턴 수치도 추출 대상 명시 (근원물가 2.2% 누락 방지)
+#   · "N만 M천" 복합 단위 패턴 _extract_numbers_from_text에 추가
+#     (24만 2천 → 242000 환산 오류 방지)
+
+# [박재윤 - 2026-05-18]: SCHEMA_INDUCTION_PROMPT source_phrase 원문 보존 규칙 추가
+#   · "23만 8000명" → source_phrase 원문 그대로 (8000→8천 변환 금지)
+
+# [박재윤 - 2026-05-18]: _extract_numbers_from_text "N만 NNNN" 패턴 추가
+#   · "2869만 3000명" → 28693000 환산 (4자리 숫자 붙는 패턴)
+"""
+from __future__ import annotations
+
+from structverify.core.schemas import Claim
+from structverify.detection.prompts.schema import DOMAIN_HINTS
+
+from structverify.detection.schema.validate import _source_phrase_in_claim
+
+from structverify.detection.schema.expand import (
+    _dedup_null_schemas,
+    _expand_claims_from_schemas,
+)
+from structverify.detection.schema.induce import _induce_multiple
+from structverify.detection.schema.regenerate import regenerate_schema
+from structverify.detection._config import detected_domain
+from structverify.detection._llm import get_llm_client
+from structverify.detection.schema.temporal_hints import _build_temporal_hint
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+# ── 메인 진입점 ────────────────────────────────────────────────────────
+async def induce_schemas(
+    claims: list[Claim],
+    config: dict | None = None,
+    graph: "ClaimGraph | None" = None,
+) -> list[Claim]:
+    """
+    각 주장에서 ClaimSchema들을 동적으로 유도한다.
+
+    [v6.13] 한 claim에서 *여러 ClaimSchema* 추출 가능 (박재유 방식).
+    LLM이 한 문장의 모든 검증 가능 수치를 list로 반환.
+    첫 schema는 원래 claim에 부착, 나머지는 claim 복제해서 부착.
+
+    [v6 멀티홉] graph 있으면 시점 해소 결과를 prompt hint로 주입.
+    """
+    config = config or {}
+    llm = get_llm_client(config)
+    success, fail = 0, 0
+    expanded: list[Claim] = []
+
+    for claim in claims:
+        domain = detected_domain(config)
+        domain_hint = (
+            f"주요 지표 예시: {DOMAIN_HINTS[domain]}"
+            if domain in DOMAIN_HINTS else ""
+        )
+
+        context = getattr(claim, "context_text", None) or claim.claim_text
+        temporal_hint = _build_temporal_hint(graph, claim) if graph else ""
+        # [v6.16] 시점 표현이 전혀 없는 claim의 fallback 기준 연도
+        anchor_year = graph.get_anchor_year() if graph else None
+
+        schemas = await _induce_multiple(
+            llm, claim.claim_text, domain, domain_hint,
+            context=context, temporal_hint=temporal_hint,
+            anchor_year=anchor_year,
+        )
+
+        if not schemas:
+            # 검증 가능 수치 0개 — 원래 claim은 유지하되 schema=None
+            fail += 1
+            expanded.append(claim)
+            logger.warning(
+                f"스키마 유도: {claim.sent_id} → 검증 가능 수치 없음"
+            )
+            continue
+
+        schemas = _dedup_null_schemas(schemas)
+        new_claims = _expand_claims_from_schemas(claim, schemas)
+        expanded.extend(new_claims)
+        success += len(new_claims)
+
+    logger.info(
+        f"스키마 유도 완료: {len(claims)}개 claim → {len(expanded)}개 claim "
+        f"(성공 schema {success}건, 실패 claim {fail}건)"
+    )
+    return expanded