structverify 0.3.0__py3-none-any.whl

structverify/storage/db_manager.py

@@ -0,0 +1,157 @@
+"""
+# 수정자: 박재윤
+# 수정 날짜: 2026-04-26
+# 수정 내용: __init__ psycopg2 연결 구현, save_claims INSERT 구현
+
+# [DONE] __init__ DB 연결 초기화
+# [DONE] save_claims 배치 INSERT 구현
+# [DONE] save_results 배치 INSERT 구현 (claimed_value, true_value, deviation 계산 포함)
+# [DONE] save_claims ON CONFLICT (claim_id) DO NOTHING 추가 (중복 실행 방지)
+# [DONE] save_claims/save_results 매번 새 연결로 변경 (long-running 연결 끊김 방지)
+# [DONE] save_claims domain 파라미터 추가
+# [DONE] save_claims/save_results 재실행 시 기존 데이터 삭제 후 재삽입
+# [DONE] save_claims source_type 파라미터 추가
+# [TODO] save_document 구현
+# [TODO] save_feedback 구현
+"""
+from __future__ import annotations
+import os
+from structverify.core.schemas import SIRDocument, Claim, VerificationResult
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class DBManager:
+    def __init__(self, config: dict | None = None):
+        self.config = config or {}
+        from dotenv import load_dotenv
+        load_dotenv()
+
+    def _get_conn(self):
+        import psycopg2
+        return psycopg2.connect(
+            host=os.getenv("POSTGRES_HOST"),
+            port=os.getenv("POSTGRES_PORT"),
+            dbname=os.getenv("POSTGRES_DB"),
+            user=os.getenv("POSTGRES_USER"),
+            password=os.getenv("POSTGRES_PASSWORD")
+        )
+
+    async def save_document(self, doc: SIRDocument) -> None:
+        """
+        SIR 문서를 PostgreSQL에 저장한다.
+
+        TODO [박재윤]: documents 테이블 INSERT 구현
+          INSERT INTO documents (doc_id, source_type, source_uri, sir_json, extracted_at)
+          VALUES ($1, $2, $3, $4::jsonb, $5)
+          ON CONFLICT (doc_id) DO NOTHING
+
+          - doc_id: str(doc.doc_id)
+          - source_type: doc.source_type.value
+          - sir_json: doc.model_dump_json() 또는 json.dumps
+          - 비동기 세션 사용 (async with self.AsyncSession() as session)
+        """
+        logger.warning(f"DB 저장 stub: doc {doc.doc_id}")
+
+    async def save_claims(self, claims: list[Claim], domain: str = None, source_type: str = None) -> None:
+        # [v3] - 박재윤: 매번 새 연결 + 재실행 시 기존 데이터 삭제 후 재삽입
+        # [v4] - 박재윤: source_type 파라미터 추가
+        conn = self._get_conn()
+        cur = conn.cursor()
+
+        if claims:
+            request_id = str(claims[0].doc_id)
+            # [v3] - 박재윤: 같은 기사 재실행 시 기존 데이터 삭제 후 재삽입
+            cur.execute(
+                "DELETE FROM results WHERE claim_id IN (SELECT claim_id FROM claims WHERE request_id = %s)",
+                (request_id,)
+            )
+            cur.execute("DELETE FROM claims WHERE request_id = %s", (request_id,))
+            cur.execute(
+                "INSERT INTO requests (request_id, source_type, domain, submitted_at) VALUES (%s, %s, %s, NOW()) ON CONFLICT (request_id) DO UPDATE SET source_type = EXCLUDED.source_type, domain = EXCLUDED.domain, submitted_at = NOW()",
+                (request_id, source_type, domain)
+            )
+
+        for claim in claims:
+            indicator = claim.schema.indicator if claim.schema else None
+            value     = claim.schema.value     if claim.schema else None
+            unit      = claim.schema.unit      if claim.schema else None
+            time_ref  = claim.schema.time_period if claim.schema else None
+
+            cur.execute("""
+                INSERT INTO claims (claim_id, request_id, field_name, field_value,
+                                unit, is_approximate, modifier, parent_path,
+                                time_reference, context)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            """, (
+                str(claim.claim_id), str(claim.doc_id),
+                indicator, value, unit,
+                False, None, None,
+                time_ref, claim.claim_text
+            ))
+
+        conn.commit()
+        cur.close()
+        conn.close()
+        logger.info(f"Claims 저장 완료: {len(claims)}건")
+
+    async def save_results(self, results: list[VerificationResult], claims: list[Claim] = None) -> None:
+        # [v3] - 박재윤: 매번 새 연결 + 재실행 시 기존 데이터 삭제 후 재삽입
+        conn = self._get_conn()
+        cur = conn.cursor()
+
+        if results:
+            # 기존 results 삭제 (재실행 시 중복 방지)
+            claim_ids = [str(r.claim_id) for r in results]
+            cur.execute(
+                "DELETE FROM results WHERE claim_id = ANY(%s)", (claim_ids,)
+            )
+
+        claim_value_map = {}
+        if claims:
+            for c in claims:
+                if c.schema and c.schema.value is not None:
+                    claim_value_map[str(c.claim_id)] = c.schema.value
+
+        for result in results:
+            ev = result.evidence
+            claimed_value = claim_value_map.get(str(result.claim_id))
+            true_value = ev.official_value if ev else None
+
+            deviation = None
+            if claimed_value and true_value and true_value != 0:
+                deviation = abs(claimed_value - true_value) / abs(true_value)
+
+            cur.execute("""
+                INSERT INTO results (result_id, claim_id, truth_id,
+                                    claimed_value, true_value, deviation,
+                                    match_status, reason, explanation, judged_at)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            """, (
+                str(result.result_id),
+                str(result.claim_id),
+                None,
+                claimed_value,
+                true_value,
+                deviation,
+                result.verdict.value,
+                result.mismatch_type.value if result.mismatch_type else None,
+                result.explanation,
+                result.created_at,
+            ))
+
+        conn.commit()
+        cur.close()
+        conn.close()
+        logger.info(f"Results 저장 완료: {len(results)}건")
+
+    async def save_feedback(self, event) -> None:
+        """
+        TODO [박재윤]: feedback_events 테이블 INSERT 구현
+          INSERT INTO feedback_events
+            (event_id, claim_id, feedback_type, original_verdict,
+             corrected_verdict, reviewer_note, created_at)
+          VALUES ...
+        """
+        logger.warning(f"DB 저장 stub: feedback {event}")

structverify/storage/dwh_manager.py

@@ -0,0 +1,92 @@
+"""
+storage/dwh_manager.py — DWH 매니저 (Snowflake / BigQuery / ClickHouse)
+
+검증 결과 로그, 모델 성능, 비용 데이터를 분석 계층에 적재한다.
+
+[박재윤]
+- Snowflake connector 연결 및 executemany INSERT 구현 담당
+- verification_logs, model_metrics, llm_cost_logs 테이블 적재
+- init_snowflake.sql의 테이블 구조에 맞춰 구현
+"""
+from __future__ import annotations
+import os
+from typing import Any
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class DWHManager:
+    def __init__(self, config: dict | None = None):
+        self.config = config or {}
+        self.provider = self.config.get("provider", "snowflake")
+
+    def _get_snowflake_conn(self):
+        """
+        Snowflake 연결 생성
+
+        TODO [박재윤]: snowflake.connector.connect() 구현
+          import snowflake.connector
+          cfg = self.config.get("snowflake", {})
+          return snowflake.connector.connect(
+              account=os.environ.get(cfg.get("account_env", "SNOWFLAKE_ACCOUNT")),
+              user=os.environ.get(cfg.get("user_env", "SNOWFLAKE_USER")),
+              password=os.environ.get(cfg.get("password_env", "SNOWFLAKE_PASSWORD")),
+              warehouse=cfg.get("warehouse", "STRUCTVERIFY_WH"),
+              database=cfg.get("database", "STRUCTVERIFY_DB"),
+              schema=cfg.get("schema", "PUBLIC"),
+          )
+        """
+        logger.warning("Snowflake 연결 stub")
+        return None
+
+    async def load_verification_logs(self, records: list[dict[str, Any]]) -> None:
+        """
+        검증 결과 로그를 DWH에 적재한다.
+
+        TODO [박재윤]: Snowflake executemany 배치 INSERT 구현
+          conn = self._get_snowflake_conn()
+          cursor = conn.cursor()
+          sql = 
+              INSERT INTO verification_logs
+                (result_id, claim_id, verdict, confidence, mismatch_type,
+                 domain, model_version, latency_ms, created_at)
+              VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+          rows = [
+              (r["result_id"], r["claim_id"], r["verdict"], r["confidence"],
+               r.get("mismatch_type"), r.get("domain"), r.get("model_version"),
+               r.get("latency_ms"), r.get("created_at"))
+              for r in records
+          ]
+          cursor.executemany(sql, rows)
+          conn.commit()
+          cursor.close()
+          conn.close()
+
+        TODO [박재윤]: BigQuery/ClickHouse 분기 구현 (provider 설정에 따라)
+        """
+        logger.warning(f"DWH 적재 stub ({self.provider}): {len(records)} records")
+
+    async def load_model_metrics(self, metrics: dict[str, Any]) -> None:
+        """
+        모델 성능 지표를 DWH에 적재한다.
+
+        TODO [박재윤]: model_metrics 테이블 INSERT 구현
+          INSERT INTO model_metrics
+            (job_id, domain, model_version, eval_score, sample_count, created_at)
+          VALUES (...)
+        """
+        logger.warning(f"DWH 모델 지표 stub: {metrics}")
+
+    async def load_llm_costs(self, cost_records: list[dict[str, Any]]) -> None:
+        """
+        LLM 호출 비용 데이터를 DWH에 적재한다.
+
+        TODO [박재윤]: llm_cost_logs 테이블 INSERT 구현
+          INSERT INTO llm_cost_logs
+            (call_id, provider, model, input_tokens, output_tokens,
+             cost_usd, task_type, created_at)
+          VALUES (...)
+          - Langfuse 연동 시 자동 수집 가능
+        """
+        logger.warning(f"DWH 비용 stub: {len(cost_records)} records")

structverify/storage/init_db.py

@@ -0,0 +1,99 @@
+#  아래 스크립 트 파일 CreateTable, DbConnect,openapiyes/noSave.test.py 전부 베이스라인 코드에 침투예정.
+
+"""
+# 수정자: 박재윤
+# 수정 날짜: 2026-04-26
+# 수정 내용: requests, claims, truths, results 테이블 생성 스크립트 구현
+
+# [DONE] CREATE TABLE 4개 구현
+# [DONE] pgvector extension 추가
+# [DONE] kosis_stat_catalog 테이블 추가
+"""
+import psycopg2
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+conn = psycopg2.connect(
+    host=os.getenv("POSTGRES_HOST"),
+    port=os.getenv("POSTGRES_PORT"),
+    dbname=os.getenv("POSTGRES_DB"),
+    user=os.getenv("POSTGRES_USER"),
+    password=os.getenv("POSTGRES_PASSWORD")
+)
+print("PostgreSQL 연결 확인")
+print(f"Host: {os.getenv('POSTGRES_HOST')}, Port: {os.getenv('POSTGRES_PORT')}, DB: {os.getenv('POSTGRES_DB')}, User: {os.getenv('POSTGRES_USER')}")
+
+cur = conn.cursor()
+cur.execute("SELECT version();")
+version = cur.fetchone()
+print(f"PostgreSQL 버전: {version[0]}")
+
+
+cur.execute("""
+    CREATE EXTENSION IF NOT EXISTS vector;
+
+    CREATE TABLE IF NOT EXISTS requests (
+        request_id VARCHAR PRIMARY KEY,
+        source_type VARCHAR,
+        domain VARCHAR,
+        raw_data JSONB,
+        submitted_at TIMESTAMP DEFAULT NOW()
+    );
+
+    CREATE TABLE IF NOT EXISTS claims (
+        claim_id VARCHAR PRIMARY KEY,
+        request_id VARCHAR REFERENCES requests(request_id),
+        field_name VARCHAR,
+        field_value FLOAT,
+        unit VARCHAR,
+        is_approximate BOOLEAN DEFAULT FALSE,
+        modifier VARCHAR,
+        parent_path VARCHAR,
+        time_reference VARCHAR,
+        context TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS truths (
+        truth_id VARCHAR PRIMARY KEY,
+        request_id VARCHAR REFERENCES requests(request_id),
+        field_name VARCHAR,
+        field_value FLOAT,
+        unit VARCHAR,
+        parent_path VARCHAR,
+        time_reference VARCHAR,
+        source VARCHAR
+    );
+
+    CREATE TABLE IF NOT EXISTS results (
+        result_id VARCHAR PRIMARY KEY,
+        claim_id VARCHAR REFERENCES claims(claim_id),
+        truth_id VARCHAR REFERENCES truths(truth_id),
+        claimed_value FLOAT,
+        true_value FLOAT,
+        deviation FLOAT,
+        match_status VARCHAR,
+        reason TEXT,
+        explanation TEXT,
+        judged_at TIMESTAMP DEFAULT NOW()
+    );
+            
+    CREATE TABLE IF NOT EXISTS kosis_stat_catalog (
+        stat_id VARCHAR PRIMARY KEY,
+        stat_name VARCHAR,
+        org_id VARCHAR,
+        org_name VARCHAR,
+        category_path VARCHAR,
+        keywords TEXT[],
+        embedding vector(1024),
+        raw_meta_json JSONB,
+        fetched_at TIMESTAMP DEFAULT NOW()
+    );
+""")
+
+conn.commit()
+cur.close()
+conn.close()
+
+print("테이블 5개 생성 완료")

structverify/storage/raw_storage.py

@@ -0,0 +1,29 @@
+"""
+storage/raw_storage.py — 원본 파일 저장 (S3 / MinIO)
+
+원본 PDF, HTML, DOCX 파일을 절대 수정/삭제하지 않고 보존한다.
+"""
+from __future__ import annotations
+from structverify.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class RawStorage:
+    def __init__(self, config: dict | None = None):
+        self.config = config or {}
+        # TODO: boto3 S3 client 또는 MinIO client 초기화
+
+    async def save(self, doc_id: str, data: bytes, filename: str) -> str:
+        """
+        원본 파일을 S3/MinIO에 저장하고 key를 반환한다.
+        TODO: s3_client.put_object(Bucket=bucket, Key=key, Body=data) 구현
+        """
+        key = f"raw/{doc_id}/{filename}"
+        logger.warning(f"Raw Storage 저장 stub: {key}")
+        return key
+
+    async def get(self, key: str) -> bytes:
+        """TODO: s3_client.get_object() 구현"""
+        logger.warning(f"Raw Storage 조회 stub: {key}")
+        return b""

structverify/training/__init__.py

@@ -0,0 +1,26 @@
+"""structverify.training — 감독 학습 루프 (계획 기능).
+
+OSS 설계: 차별화되는 부분(데이터 준비·품질·이상감지·자가평가)은 이 모듈이 소유하고,
+실제 파인튜닝은 표준 데이터셋(chat jsonl)으로 넘겨 생태계(TRL/unsloth/axolotl)에 위임한다.
+
+코어(GPU 불필요, 여기서 동작): dataset export · DataCurator · TrainDoctor · EvalGate · LearningLoop
+GPU 필요: recipe/train_qlora.py (핸드오프 or [training] extra)
+
+    from structverify.training import LearningLoop, EvalGate
+    loop = LearningLoop(engine).add_seed()
+    ds, _ = loop.prepare("train.jsonl")          # ① 데이터 + 🕵 품질검사
+    loop.train(ds, "./adapter", run=False)       # ② GPU 머신에서 실행할 명령 반환
+    loop.diagnose("./adapter/trainer_state.json")# 🩺 로그 진단
+    # loop.evaluate(eval_set, tuned_engine=...)  # 🚦 자가평가 → 채택/거부
+"""
+from .curator import DataCurator, CurationReport
+from .dataset import build_seed_dataset, export_dataset, read_jsonl, write_jsonl
+from .doctor import TrainDoctor, Diagnosis
+from .evalgate import EvalGate, EvalResult, GateDecision
+from .loop import LearningLoop
+
+__all__ = [
+    "LearningLoop", "DataCurator", "TrainDoctor", "EvalGate",
+    "CurationReport", "Diagnosis", "EvalResult", "GateDecision",
+    "build_seed_dataset", "export_dataset", "read_jsonl", "write_jsonl",
+]

structverify/training/curator.py

@@ -0,0 +1,124 @@
+"""structverify.training.curator — DataCurator (학습셋 품질 검사, 코어·GPU 불필요).
+
+export/seed 데이터셋을 학습 전에 점검:
+  · 포맷 유효성 (messages 3-turn, 빈 응답 없음)
+  · 태스크별 출력 검증 (schema/verdict = JSON 파싱, sql = 읽기전용 SELECT)
+  · 중복 제거 (같은 user→assistant)
+  · 태스크 분포(편중) 리포트
+나쁜 샘플은 *사유와 함께* 격리(quarantine)하고, 통과한 것만 clean 셋으로 반환.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+_FORBIDDEN_SQL = re.compile(
+    r"\b(insert|update|delete|drop|alter|create|merge|truncate|grant|revoke)\b", re.IGNORECASE)
+
+
+@dataclass
+class CurationReport:
+    total: int = 0
+    kept: int = 0
+    dropped: list[dict] = field(default_factory=list)   # [{reason, sample}]
+    by_task: dict[str, int] = field(default_factory=dict)
+    warnings: list[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        lines = [f"[DataCurator] 총 {self.total} → 통과 {self.kept} · 격리 {len(self.dropped)}"]
+        if self.by_task:
+            dist = ", ".join(f"{k} {v}" for k, v in sorted(self.by_task.items()))
+            lines.append(f"  태스크 분포(통과): {dist}")
+        for w in self.warnings:
+            lines.append(f"  ⚠ {w}")
+        for d in self.dropped[:12]:
+            lines.append(f"  ✗ 격리({d['reason']}): {d['sample'][:70]}")
+        if len(self.dropped) > 12:
+            lines.append(f"  … 외 {len(self.dropped) - 12}건")
+        return "\n".join(lines)
+
+
+def _valid_json_output(text: str) -> bool:
+    m = re.search(r"\{[\s\S]*\}", text)
+    if not m:
+        return False
+    try:
+        json.loads(m.group(0))
+        return True
+    except json.JSONDecodeError:
+        return False
+
+
+def _valid_sql_output(text: str) -> bool:
+    s = text.strip().rstrip(";").strip()
+    if not re.match(r"(?is)^\s*(with|select)\b", s):
+        return False
+    if ";" in s or _FORBIDDEN_SQL.search(s):
+        return False
+    return bool(re.search(r"(?is)\bfrom\b", s))
+
+
+class DataCurator:
+    """학습셋 품질 게이트. curate(rows) → (clean_rows, CurationReport)."""
+
+    def curate(self, rows: list[dict], *, min_per_task: int = 3) -> tuple[list[dict], CurationReport]:
+        rep = CurationReport(total=len(rows))
+        seen: set = set()
+        clean: list[dict] = []
+        for row in rows:
+            reason = self._reject_reason(row)
+            key = self._dedup_key(row)
+            if reason is None and key in seen:
+                reason = "중복"
+            if reason is not None:
+                rep.dropped.append({"reason": reason, "sample": self._preview(row)})
+                continue
+            seen.add(key)
+            clean.append(row)
+            t = str(row.get("task", "?"))
+            rep.by_task[t] = rep.by_task.get(t, 0) + 1
+        rep.kept = len(clean)
+        # 편중 경고
+        for t, n in rep.by_task.items():
+            if n < min_per_task:
+                rep.warnings.append(f"태스크 '{t}' 예시 {n}개 — {min_per_task}개 미만(과소). 보강 권장")
+        if not rep.by_task:
+            rep.warnings.append("통과한 예시가 없음 — 포맷 확인 필요")
+        return clean, rep
+
+    # ── 내부 ──
+    @staticmethod
+    def _msgs(row: dict) -> list[dict]:
+        return row.get("messages") or []
+
+    def _reject_reason(self, row: dict) -> str | None:
+        msgs = self._msgs(row)
+        if len(msgs) < 2:
+            return "messages 부족"
+        roles = [m.get("role") for m in msgs]
+        if "user" not in roles or "assistant" not in roles:
+            return "user/assistant 누락"
+        out = next((m.get("content", "") for m in msgs if m.get("role") == "assistant"), "")
+        if not str(out).strip():
+            return "빈 응답"
+        task = row.get("task")
+        if task in ("schema", "verdict") and not _valid_json_output(out):
+            return "JSON 출력 아님"
+        if task == "sql" and not _valid_sql_output(out):
+            return "안전한 SELECT 아님"
+        return None
+
+    @staticmethod
+    def _dedup_key(row: dict):
+        msgs = row.get("messages") or []
+        u = next((m.get("content") for m in msgs if m.get("role") == "user"), "")
+        a = next((m.get("content") for m in msgs if m.get("role") == "assistant"), "")
+        return (str(u).strip(), str(a).strip())
+
+    @staticmethod
+    def _preview(row: dict) -> str:
+        msgs = row.get("messages") or []
+        u = next((m.get("content") for m in msgs if m.get("role") == "user"), "")
+        return str(u).replace("\n", " ")[:80]

structverify/training/dataset.py

@@ -0,0 +1,134 @@
+"""structverify.training.dataset — 학습 데이터셋 준비 (코어, GPU 불필요).
+
+두 경로:
+  · export_dataset(reports)  — 실제 검증 결과(확정 정답) → verdict/schema 예시로 변환
+  · build_seed_dataset()     — 시작용 seed 예시(아래 SEED) 를 jsonl로 (도메인 확장의 출발점)
+
+표준 chat 포맷(messages) jsonl → TRL/unsloth/axolotl 어디서든 학습. 우리 방식에 안 가둠.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Iterable
+
+from .tasks import build_example
+
+# ── SEED 예시 ────────────────────────────────────────────────────────────────
+# StructVerify가 코드로 하드닝한 동작들을 그대로 모델에 각인시키는 실제 예시:
+#   · 한국어 큰수 파싱("1,500만"→15,000,000)  · 순매출=net 공식  · 비율/증감율 SQL
+#   · 단위 일관성(원시값+기본단위)            · 판정 근거 톤
+_SEED_SPECS: list[dict] = [
+    # ---- schema: claim → 구조화 추출 (한국어 숫자·단위 파싱 각인) ----
+    dict(task="schema", claim_text="2023년 말 기준 당사의 누적 고객 수는 150만 명에 이르렀습니다.",
+         output='{"indicator": "누적 고객 수", "value": 1500000, "unit": "명", "time_period": "2023", "population": null}'),
+    dict(task="schema", claim_text="누적 주문 건수는 1,500만 건을 돌파하였습니다.",
+         output='{"indicator": "누적 주문 건수", "value": 15000000, "unit": "건", "time_period": null, "population": null}'),
+    dict(task="schema", claim_text="당사와 거래하는 공급업체는 총 10만 개사입니다.",
+         output='{"indicator": "공급업체 수", "value": 100000, "unit": "개", "time_period": null, "population": null}'),
+    dict(task="schema", claim_text="누적 총 순매출은 21,791억 달러를 기록했습니다.",
+         output='{"indicator": "총 순매출", "value": 21791, "unit": "억 달러", "time_period": null, "population": null}'),
+    dict(task="schema", claim_text="건당 평균 주문 금액은 151,121달러입니다.",
+         output='{"indicator": "평균 주문 금액", "value": 151121, "unit": "달러", "time_period": null, "population": null}'),
+    dict(task="schema", claim_text="1997년 순매출은 3,304억 달러였습니다.",
+         output='{"indicator": "순매출", "value": 3304, "unit": "억 달러", "time_period": "1997", "population": null}'),
+    dict(task="schema", claim_text="유럽(EUROPE)이 4,369억 달러로 가장 높은 매출을 기록했습니다.",
+         output='{"indicator": "지역별 순매출", "value": 4369, "unit": "억 달러", "time_period": null, "population": "유럽"}'),
+    dict(task="schema", claim_text="아메리카 권역 순매출은 전체 순매출의 약 20%를 차지합니다.",
+         output='{"indicator": "순매출 비율", "value": 20, "unit": "%", "time_period": null, "population": "아메리카"}'),
+    dict(task="schema", claim_text="1998년에는 전년 대비 약 41% 감소하였습니다.",
+         output='{"indicator": "순매출 증감율", "value": -41, "unit": "%", "time_period": "1998", "population": null}'),
+    dict(task="schema", claim_text="쉬었음 청년이 23만 8천명으로 집계됐다.",
+         output='{"indicator": "쉬었음 청년 수", "value": 238000, "unit": "명", "time_period": null, "population": "청년"}'),
+    dict(task="schema", claim_text="출생아 수는 2만 171명이었다.",
+         output='{"indicator": "출생아 수", "value": 20171, "unit": "명", "time_period": null, "population": null}'),
+    # ---- sql: 지표 → 집계/파생 SQL (net 공식·최소테이블·비율·증감율 각인) ----
+    dict(task="sql", indicator="총 고객수", claim_text="누적 고객 수는 150만 명입니다.",
+         schema_hint="CUSTOMER(c_custkey, c_name, c_mktsegment, c_nationkey)",
+         output="SELECT COUNT(DISTINCT c_custkey) FROM CUSTOMER"),
+    dict(task="sql", indicator="총 순매출(순=할인반영)", claim_text="누적 총 순매출은 21,791억 달러입니다.",
+         schema_hint="LINEITEM(l_orderkey, l_extendedprice, l_discount, l_quantity)",
+         output="SELECT SUM(l_extendedprice*(1-l_discount)) FROM LINEITEM"),
+    dict(task="sql", indicator="1996년 주문 건수", claim_text="1996년 주문 건수는 약 228만 건입니다.",
+         schema_hint="ORDERS(o_orderkey, o_orderdate, o_totalprice, o_custkey)",
+         output="SELECT COUNT(*) FROM ORDERS WHERE YEAR(o_orderdate)=1996"),
+    dict(task="sql", indicator="MACHINERY 세그먼트 고객 수", claim_text="기계 세그먼트 고객은 30만 명입니다.",
+         schema_hint="CUSTOMER(c_custkey, c_mktsegment)  ※불필요한 JOIN 금지",
+         output="SELECT COUNT(DISTINCT c_custkey) FROM CUSTOMER WHERE c_mktsegment='MACHINERY'"),
+    dict(task="sql", indicator="지역별 순매출(유럽)", claim_text="유럽 순매출은 4,369억 달러입니다.",
+         schema_hint="LINEITEM·ORDERS·CUSTOMER·NATION·REGION (l_orderkey=o_orderkey, o_custkey=c_custkey, c_nationkey=n_nationkey, n_regionkey=r_regionkey)",
+         output=("SELECT SUM(l_extendedprice*(1-l_discount)) FROM LINEITEM "
+                 "JOIN ORDERS ON l_orderkey=o_orderkey JOIN CUSTOMER ON o_custkey=c_custkey "
+                 "JOIN NATION ON c_nationkey=n_nationkey JOIN REGION ON n_regionkey=r_regionkey "
+                 "WHERE r_name='EUROPE'")),
+    dict(task="sql", indicator="순매출 비율(아메리카/전체)", claim_text="아메리카는 전체 순매출의 약 20%입니다.",
+         schema_hint="LINEITEM·ORDERS·CUSTOMER·NATION·REGION",
+         output=("SELECT (SELECT SUM(l_extendedprice*(1-l_discount)) FROM LINEITEM "
+                 "JOIN ORDERS ON l_orderkey=o_orderkey JOIN CUSTOMER ON o_custkey=c_custkey "
+                 "JOIN NATION ON c_nationkey=n_nationkey JOIN REGION ON n_regionkey=r_regionkey "
+                 "WHERE r_name='AMERICA') / (SELECT SUM(l_extendedprice*(1-l_discount)) FROM LINEITEM) * 100")),
+    dict(task="sql", indicator="순매출 증감율(1998 vs 1997)", claim_text="1998년은 1997년 대비 약 41% 감소했습니다.",
+         schema_hint="LINEITEM·ORDERS (l_orderkey=o_orderkey, o_orderdate)  ※FILTER 금지, 서브쿼리 2개",
+         output=("SELECT (a.v - b.v)/b.v*100 FROM "
+                 "(SELECT SUM(l_extendedprice*(1-l_discount)) v FROM LINEITEM JOIN ORDERS ON l_orderkey=o_orderkey WHERE YEAR(o_orderdate)=1998) a, "
+                 "(SELECT SUM(l_extendedprice*(1-l_discount)) v FROM LINEITEM JOIN ORDERS ON l_orderkey=o_orderkey WHERE YEAR(o_orderdate)=1997) b")),
+    # ---- verdict: claim + 근거 → 판정 (허용오차·근거 톤 각인) ----
+    dict(task="verdict", claim_text="누적 고객 수는 150만 명입니다.", evidence_value=1500000, evidence_unit="명",
+         output='{"verdict": "match", "reason": "주장 150만 명이 공식 수치 1,500,000명과 정확히 일치합니다."}'),
+    dict(task="verdict", claim_text="건당 평균 주문 금액은 20만 달러입니다.", evidence_value=145274, evidence_unit="달러",
+         output='{"verdict": "mismatch", "reason": "주장 200,000달러는 실제 145,274달러와 약 37.7% 차이로 불일치합니다."}'),
+    dict(task="verdict", claim_text="유럽 순매출은 전체의 약 35%를 차지합니다.", evidence_value=20.05, evidence_unit="%",
+         output='{"verdict": "mismatch", "reason": "주장 35%는 실제 비율 20.05%와 크게 어긋나 불일치합니다."}'),
+    dict(task="verdict", claim_text="1997년 순매출은 3,304억 달러였습니다.", evidence_value=3304, evidence_unit="억 달러",
+         output='{"verdict": "match", "reason": "주장 3,304억 달러가 공식 수치와 0.0% 오차로 일치합니다."}'),
+    dict(task="verdict", claim_text="1998년 순매출은 3,300억 달러 수준을 유지했습니다.", evidence_value=1937, evidence_unit="억 달러",
+         output='{"verdict": "mismatch", "reason": "주장 3,300억 달러는 실제 1,937억 달러와 70% 차이로 불일치합니다."}'),
+]
+
+
+def build_seed_dataset(out: str = "seed_dataset.jsonl") -> int:
+    """SEED 예시를 chat 포맷 jsonl로 저장. 반환: 예시 수."""
+    rows = [build_example(**spec) for spec in _SEED_SPECS]
+    return write_jsonl(rows, out)
+
+
+def export_dataset(reports: Iterable[Any], out: str = "train.jsonl",
+                   include: tuple[str, ...] = ("verdict",)) -> int:
+    """실제 검증 결과(Report들) → 학습 예시. 확정된(=사람이 승인한) 결과만 넣는 것을 권장.
+
+    각 Result(claim/verdict/value/unit/reason)를 verdict 태스크 예시로 변환.
+    (schema/sql 예시는 파이프라인 중간 산출을 별도 수집해야 하므로 seed/수동 확장 권장.)
+    """
+    rows: list[dict] = []
+    for report in reports:
+        for r in report:
+            v = str(getattr(r, "verdict", "") or "")
+            if v not in ("match", "mismatch", "unverifiable"):
+                continue
+            if "verdict" in include:
+                reason = str(getattr(r, "reason", "") or "")[:200]
+                rows.append(build_example(
+                    "verdict",
+                    claim_text=str(getattr(r, "claim", "") or "").replace("\n", " ").strip(),
+                    evidence_value=getattr(r, "value", None),
+                    evidence_unit=getattr(r, "unit", "") or "",
+                    output=json.dumps({"verdict": v, "reason": reason}, ensure_ascii=False),
+                ))
+    return write_jsonl(rows, out)
+
+
+# ── jsonl I/O ────────────────────────────────────────────────────────────────
+def write_jsonl(rows: list[dict], path: str) -> int:
+    with open(path, "w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    return len(rows)
+
+
+def read_jsonl(path: str) -> list[dict]:
+    rows: list[dict] = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows