Files
Aislo/M02_MasterTemplete/M02_San_Basis_Index.py
T
eomsangdonandClaude Opus 5.5 db375b67e6 refactor(857-3b): 소요량 · 계수 값 역색인 = M01 수식 문서 — 옛 로직 줄 · 옛 식 파서 안 읽음
- San_Basis_Index.load 로직 = 수식문서 폴더(master_doc_link.load_all) · scan = 문서 변수 연결(표 찾기 · 단가산출 부름 · 기계 요소 칸) · 식 줄 · 덧줄 식 · 금액 줄 수량 수(문서 파서) · 이름 인자 = 입력 이름(기호 → 열쇠) · 지문에 수식 문서 파일
- master_auto(ma._texts) · mf.parse · mf._OPS 안 씀 · trade 는 그대로(이미 Hopyo_ReadEst.trade 한 줄 감쌈 = 가벼운 자리 Hopyo_Shares 와 같은 것)
- 대조: 옛 역색인 대 새 역색인 — 3,241 블록 소요량 자리 10,671 후보 전부 같음(속 표 uses · inline 은 문서가 × 1 · ÷ 100 군더더기를 걷어 갈래 몇이 다름 · 후보에는 안 닿음)
- 세기: 불러오기 길(짓기 · 검산 · 열기 두 판 · 이음 고침 · 소요량 보기 · 단가기준) 옛 변환기 · 색인 .logic · 옛 식 파서 부름 0(전 = 역색인 짓기 mf.parse 14,102)
- 지킴: test_797_2 · 802_4b1 · 857 골든 전수 · 관련 시험

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:44:56 +09:00

643 lines
26 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""근거 제안 1 — M01 값 역색인 · 숫자 정규화 한 벌(PLAN 793-3a · 요구 648 · 분석 648-D 1 장) ·
읽기만.
칸(`cells`) = 표 칸 하나 {v, 표, 줄, 칸, 단위, 종류 val(값칸) | cond(조건 수) | ratio(「a 인 / b」
몫) |
기준(「10㎡」 당) | eq(기계 요소 값)} · 쓰임(`uses`) = 표 → [(로직, 부름, 칸 | None, 글자 거름,
입력 묶음)]
(하위 로직 3 겹까지 펼침 · 인자 이름 바꿈) · 식 속 수(`inline`) · 호표 수량 속 수(`inline_trade` ·
직종 표지).
정규화(`lookup`) — N1 표시 자릿수 반올림 · N2 % ↔ 소수 · N3 t ↔ kg · N4 인/양 몫 · N5 직종 묶음 ·
N6 표 기준 · N7 식 속 수 · N8 단위 성격(N9 · N10 옛 근거 제안 몫은 809-1 에서 지움 ·
쓰는 곳 = 소요량 · 계수 이음 `M02_Sangeun_QtyLinks`).
우연 보정(`q_of` · `pb_sig`) = 보정 자료(실무 여덟 파일 상수 · `M02_San_Basis_corpus.json`) 몫 ·
포아송 이항 꼬리 −log10.
짓기 = M01 폴더 지문(`stamp`)마다 한 번(`get` · 프로세스 안 캐시 · 지문 바뀌면 다시) ·
로직 = M01 수식 문서(857-3b · 옛 로직 줄 · 옛 식 파서 안 읽음 · 문서 파서).
"""
from __future__ import annotations
import ast
import bisect
import glob
import json
import math
import re
import threading
import unicodedata
from collections import defaultdict
from functools import lru_cache
from pathlib import Path
from typing import Any
from common_util import common_util_derived_store as derived
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_ReadEst as est
m01.cm.mf # noqa: B018 — scripts 경로를 깖(M01 저장 모듈이 부름)
import master_doc as md # noqa: E402
import master_doc_link as ml # noqa: E402
DOCS = "수식문서" # M01 폴더 아래 수식 문서 폴더(`master_doc_link.FOLDER`)
CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자
CORPUS = Path(__file__).with_name("M02_San_Basis_corpus.json")
INLINE_MAX = 20 # 식 속 수가 이보다 많은 로직(표를 식으로 펼친 것)은 식 속 수 맞음을 안 셈
PERSON = ("인",)
# ── 단위 성격(N8) ─────────────────────────────────────────────────────
FAM = [
x.split(":")
for x in (
"인:사람 ㎡:넓이 m2:넓이 ㎥:부피 m3:부피 ℓ:부피 km:길이 ㎝:길이 cm:길이 ㎜:길이 mm:길이 "
"m:길이 ㎏:무게 kg:무게 ton:무게 톤:무게 t:무게 g:무게 %:율 hr:시간 h:시간 시간:시간 "
"분:시간 min:시간 초:시간 sec:시간 일:시간 회:수 본:수 개:수 매:수 조:수 대:수 ea:수"
).split()
]
def fam(unit: Any) -> str | None:
u = unicodedata.normalize("NFKC", str(unit or "")).strip().lower().split("/")[0].strip()
if "%" in u:
return "율"
for a, f in FAM:
if u == a or u.startswith(a) and a not in ("m", "t", "h", "g"):
return f
return None
def unit_ok(tu: Any, cu: Any) -> bool:
a, b = fam(tu), fam(cu)
return a is None or b is None or a == b
_OPS = {
ast.Add: float.__add__,
ast.Sub: float.__sub__,
ast.Mult: float.__mul__,
ast.Div: float.__truediv__,
}
def _calc(node: ast.AST) -> float:
"""수 · 사칙 · 부호만(그 밖 = ValueError) — eval 없음."""
if isinstance(node, ast.Expression):
return _calc(node.body)
if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
return float(node.value)
if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
x = _calc(node.operand)
return -x if isinstance(node.op, ast.USub) else x
if isinstance(node, ast.BinOp) and type(node.op) in _OPS:
return _OPS[type(node.op)](_calc(node.left), _calc(node.right))
raise ValueError(node)
def _arith(s: str) -> float | None:
"""「480 - 30」 · 「1/1.30」 → 수 · 못 셈 None."""
if not re.fullmatch(r"[\d.\s+\-*/()]+", s) or not re.search(r"\d", s):
return None
try:
return _calc(ast.parse(s.strip(), mode="eval"))
except (SyntaxError, ValueError, ZeroDivisionError):
return None
def nums_of(v: Any) -> list[float]:
"""칸 값 → [수] — 수 · [아래, 위] · 식 글자(셈 값 + 낱 수)."""
if isinstance(v, bool) or v is None:
return []
if isinstance(v, (int, float)):
return [float(v)]
if isinstance(v, list):
return [float(x) for x in v if isinstance(x, (int, float)) and not isinstance(x, bool)]
if isinstance(v, str):
got = _arith(v)
if got is None:
return []
parts = [float(x) for x in re.findall(r"\d+(?:\.\d+)?", v)]
return [got] + [p for p in parts if p != got]
return []
# ── 직종(N5) ─────────────────────────────────────────────────────────
@lru_cache(maxsize=None)
def trade(name: str) -> str | None:
return est.trade(name)
def _flat(t: Any) -> str:
return re.sub(r"[\s()()_\-·.]", "", re.sub(r"\(.*?\)|_.*$", "", str(t or "")))
def canon(t: str) -> str:
return trade(t) or trade(_flat(t)) or _flat(t)
def same_trade(a: str, b: str) -> bool:
x, y = canon(a), canon(b)
return bool(x and y) and (x == y or len(y) >= 2 and len(x) >= 2 and (x in y or y in x))
# ── M01 읽기 · 로직 훑기 ─────────────────────────────────────────────
def folder() -> Path:
return Path(m01.FOLDER)
def stamp() -> str:
"""M01 지문 — 첫 층 파일 내용(`M02_Hopyo_Judge._stamp` 와 같은 몫) + 보정 자료."""
files = {
p.name: derived.file_digest(p)
for p in sorted(folder().glob("*.json"))
if not p.name.startswith("_")
}
if m01.cm.mmf.here(folder()): # 기계 = 폴더(826-2)
files[m01.cm.mmf.NAME] = m01.version_of(m01.cm.mmf.raw(folder(), m01.cm.mmf.NAME))
for p in sorted((folder() / DOCS).glob("수식_*.json")): # 857-3b 로직 = 수식 문서
files[f"{DOCS}/{p.name}"] = derived.file_digest(p)
return derived.derived_key("san-basis-index", files, derived.file_digest(CORPUS))
def load(root: Path) -> tuple[dict, dict, dict, dict]:
tables, logic, eq = {}, {}, {}
for f in glob.glob(str(root / "소요량_*.json")) + glob.glob(str(root / "계수_*.json")):
for t in json.loads(Path(f).read_text(encoding="utf-8")).get("표", []):
tables[t["키"]] = t
if (root / DOCS).is_dir(): # 857-3b 로직 = 수식 문서(옛 로직 줄 안 읽음)
logic = ml.load_all(root / DOCS)
for r in m01.cm.mmf.table(root)[0]["줄"]: # 기계 = 폴더(826-2)
eq[r["키"]] = r
by_no: dict = {}
for k, t in tables.items():
by_no.setdefault((k[:2], str(t.get("원문번호"))), []).append(k)
return tables, logic, eq, by_no
def _resolve(ref: str, tables: dict, by_no: dict) -> str | None:
if "{" in ref:
return None
if ref in tables:
return ref
tid, _, no = ref.partition(":")
hit = by_no.get((tid, no)) or []
return hit[0] if len(hit) == 1 else None
def inputs_of(doc: dict) -> dict[str, str]:
"""문서 입력 · 선택 변수 {기호: 열쇠(입력 이름)}."""
return {
md.var_id(v): str(v.get("열쇠"))
for v in doc.get("변수") or []
if (v.get("연결") or {}).get("갈래") in ("입력", "선택")
}
def scan(doc: dict, tables: dict, by_no: dict) -> tuple:
"""수식 문서 하나 → (찾기 부름, 식 속 수, 하위 로직 부름, 기계 부름, 호표 수량 속 수) — 857-3b ·
옛 로직 줄 훑기와 같은 꼴(이름 = 입력 이름 · 표 · 하위 로직 · 기계 = 변수 연결)."""
names = inputs_of(doc)
finds, nums, calls, eqs = [], [], [], []
def parse(text: Any) -> Any:
try:
return md.parse(text)
except md.DocError:
return None
def arg_of(text: Any) -> tuple:
node = parse(text)
if node is None:
return ("expr", str(text)[:80])
if node[0] == "str":
return ("lit", node[1])
if node[0] == "num":
return ("lit", float(node[1]))
if node[0] == "var":
return ("name", names[node[1]]) if node[1] in names else ("expr", node[1])
visit(node)
return ("expr", str(node)[:80])
def visit(node: Any) -> None:
kind = node[0]
if kind == "num":
nums.append(float(node[1]))
elif kind == "bin":
for side in (node[2], node[3]): # 비교 글자(「SCH == 20」)는 셈 수가 아님
if node[1] in CMP and side[0] == "num":
continue
visit(side)
elif kind in ("neg", "pct", "field"):
visit(node[1])
elif kind == "call":
for a in node[2]:
visit(a)
def hole(key: str) -> str:
"""`EQ:{기호}` → `EQ:{입력 이름}`(옛 로직 줄 꼴)."""
return re.sub(r"\{([^{}]+)\}", lambda m: "{" + names.get(m.group(1), m.group(1)) + "}", key)
for var in doc.get("변수") or []:
link = var.get("연결") or {}
kind, key = link.get("갈래"), str(link.get("키") or link.get("표") or "")
if kind == "표" and (ref := _resolve(key, tables, by_no)):
args = {c: arg_of(a) for c, a in (link.get("조건") or {}).items()}
finds.append((ref, link.get("칸"), args))
elif kind == "단가산출" and key and "{" not in key and not key.startswith("SK-"):
calls.append((key, {c: arg_of(a) for c, a in (link.get("입력") or {}).items()}))
elif kind == "요소" and key.startswith("EQ") and link.get("칸"):
eqs.append((hole(key), link["칸"]))
texts = [x.get("식") for x in doc.get("식") or []]
texts += [x.get("단가") for x in doc.get("금액") or [] if "수량" not in x] # 덧줄 식
for text in texts:
if (node := parse(text)) is not None:
visit(node)
trade_nums = [] # (호표 이름, 수량 식 속 수)
for line in doc.get("금액") or []:
if "수량" not in line or (node := parse(line["수량"])) is None:
continue
before = len(nums)
visit(node)
trade_nums += [(line.get("이름") or "", x) for x in nums[before:]]
return finds, nums, calls, eqs, trade_nums
def _cells(tables: dict, eq: dict) -> list[dict]:
cells: list[dict] = []
for tk, t in tables.items():
vcols = t.get("값칸", {}) or {}
base = re.match(r"\s*(\d+(?:\.\d+)?)\s*(\S*)", str(t.get("기준") or ""))
if base and float(base.group(1)) not in (0, 1): # 「10㎡」 · 「100m」 당 — 표 기준 수(N6)
cells.append(
{
"v": float(base.group(1)),
"표": tk,
"줄": 0,
"칸": "기준",
"단위": base.group(2),
"종류": "기준",
}
)
for ri, row in enumerate(t.get("줄", [])):
got = {}
for col, unit in vcols.items():
for x in nums_of(row.get(col)):
cells.append(
{
"v": x,
"표": tk,
"줄": ri,
"칸": col,
"단위": row.get("단위") or unit,
"종류": "val",
}
)
got.setdefault(col, x)
for col, kind in (t.get("조건", {}) or {}).items():
x = row.get(col)
if kind == "수" and isinstance(x, (int, float)) and not isinstance(x, bool):
cells.append(
{"v": float(x), "표": tk, "줄": ri, "칸": col, "단위": "", "종류": "cond"}
)
for a, ua in vcols.items(): # 인/양 몫(N4 · 「5인 / 45㎡」 = 0.111)
if not str(row.get("단위") or ua).startswith(PERSON) or a not in got:
continue
for b, ub in vcols.items():
ub = str(row.get("단위") or ub)
if b == a or b not in got or ub.startswith(PERSON) or "%" in ub or not got[b]:
continue
cells.append(
{
"v": got[a] / got[b],
"표": tk,
"줄": ri,
"칸": f"{a}/{b}",
"단위": "인",
"종류": "ratio",
}
)
import master_machine_crew as mcrew # 인력 · 잡품 목록 → 조종원 수 · 잡재료율(842-3)
for ek, r in eq.items(): # 기계 요소 수(가격 · 글 · 목록 뺌)
for col, x in (mcrew.view(r.get("값") or {}) or {}).items():
if col in ("가격", "주연료종류", "조종원직종", *mcrew.LISTS) or col.endswith("가격"):
continue
unit = (r.get("단위") or {}).get(col, "") if isinstance(r.get("단위"), dict) else ""
cells += [
{"v": y, "표": ek, "줄": 0, "칸": col, "단위": unit or "", "종류": "eq"}
for y in nums_of(x)
]
return cells
# ── 역색인 ───────────────────────────────────────────────────────────
class Index:
def __init__(self, root: Path | None = None):
self.tables, self.logic, self.eq, by_no = load(root or folder())
self.cells = _cells(self.tables, self.eq)
self.scans = {k: scan(it, self.tables, by_no) for k, it in self.logic.items()}
order = sorted(range(len(self.cells)), key=lambda i: self.cells[i]["v"])
self.vals = [self.cells[i]["v"] for i in order]
self.ids = order
self.uses = defaultdict(list) # 표 → [(로직, 부름id, 칸 | None, 거름, 묶음)]
self.eq_uses = defaultdict(list) # 기계 칸 → [(로직, 부름id, (고정 | 입력, 값))]
self.inline = defaultdict(set)
self.inline_trade = defaultdict(set)
self.eq_no = {str(r.get("원문번호")): k for k, r in self.eq.items()} | {
k: k for k in self.eq
}
self.callers = defaultdict(set) # 하위 → 부르는 위 로직(어느 깊이든)
for k in self.logic:
self._expand(k, k, {}, {}, 0, k)
self.inl_index = defaultdict(set)
for k, xs in self.inline.items():
for x in xs:
self.inl_index[round(x, 9)].add(k)
self.trade_index = defaultdict(set)
for k, xs in self.inline_trade.items():
for _, x in xs:
self.trade_index[round(x, 9)].add(k)
self.cells_of_table = defaultdict(list)
for c in self.cells:
self.cells_of_table[c["표"]].append(c)
self.item_tables = defaultdict(set)
for t, us in self.uses.items():
for u in us:
self.item_tables[u[0]].add(t)
self._hits: dict = {}
self._look: dict = {}
self._df: dict = {}
self.prior()
def _expand(self, top, key, rename, lit, depth, path):
finds, nums, calls, eqs, tnums = self.scans[key]
for name, x in tnums:
self.inline_trade[top].add((name, x))
for ref, field, args in finds:
filt, bind = {}, {}
for col, (kind, val) in args.items():
if kind == "lit":
filt[col] = val
elif kind == "name" and depth == 0:
bind[col] = val
elif kind == "name" and val in rename:
bind[col] = rename[val]
elif kind == "name" and val in lit:
filt[col] = lit[val]
else: # 중간 · 식 · 안 넘긴 입력 — 같은 인자를 쓰는 부름끼리 같은 줄(가짜 입력 §)
bind[col] = f"§{path}:{val}"
if not filt and not bind: # 조건 없는 부름 — 같은 표 부름끼리 같은 줄
bind["#row"] = f"§{path}:{ref}"
gid = f"{path}|{ref}|{sorted(filt.items(), key=str)}|{sorted(bind.items())}"
self.uses[ref].append((top, gid, field, filt, bind))
self.inline[top].update(nums)
for ref, field in eqs:
m = re.match(r"EQ:\{(\w+)\}", ref)
if m:
arg = m.group(1)
inputs = set(inputs_of(self.logic[key]).values())
if depth == 0 and arg in inputs:
use = ("입력", arg)
elif depth > 0 and arg in rename:
use = ("입력", rename[arg])
elif depth > 0 and arg in lit and self.eq_no.get(str(lit[arg])):
use = ("고정", self.eq_no[str(lit[arg])])
else:
use = ("입력", f"§{path}:EQ:{arg}")
self.eq_uses[field].append((top, f"{path}@{ref}", use))
elif ref.startswith("EQ0"):
self.eq_uses[field].append((top, f"{path}@{ref}", ("고정", ref)))
if depth >= 3:
return
for j, (sub, args) in enumerate(calls):
if sub not in self.logic:
continue
self.callers[sub].add(top)
ren, lt = {}, {}
for name, (kind, val) in args.items():
if kind == "lit":
lt[name] = val
elif kind == "name":
if depth == 0:
ren[name] = val
elif val in rename:
ren[name] = rename[val]
elif val in lit:
lt[name] = lit[val]
self._expand(top, sub, ren, lt, depth + 1, f"{path}>{sub}.{j}")
@staticmethod
def _pass(row: dict, filt: dict) -> bool:
"""칸 하나가 줄 거름을 통과?"""
for col, want in filt.items():
have = row.get(col)
if have is None:
continue
if isinstance(have, list):
if isinstance(want, float) and len(have) == 2:
lo, hi = have
if (lo is not None and want < lo) or (hi is not None and want > hi):
return False
continue
if isinstance(want, float):
try:
if float(have) != want:
return False
except (TypeError, ValueError):
return False
elif str(have) != str(want):
return False
return True
@staticmethod
def _trade_ok(name: str, c: dict) -> bool:
if c["종류"] == "eq":
return False
if c["종류"] != "ratio" and fam(c["단위"]) not in (None, "사람"):
return False
return same_trade(name, c["칸"].split("/")[0])
def lookup(self, k: dict) -> list[tuple[int, str]]:
"""상수 → [(칸 id, 꼴 eq | pct | kgt)] — N1 · N2 · N3 · N4 · N5 · N8(캐시)."""
key = kkey(k)
if key not in self._look:
self._look[key] = self._lookup(k)
return self._look[key]
def _lookup(self, k: dict) -> list[tuple[int, str]]:
v, d, unit = k["v"], k["d"], k["단위"]
sig = len(re.sub(r"^0+|\.", "", f"{v:.{d}f}").lstrip("0"))
tol = 0.5 * 10 ** (-d) if d >= 1 and sig >= 2 else 1e-9
if k.get("몫"):
tol = abs(v) * 1e-6
forms = [(v, tol, "eq")]
tf = fam(unit)
if tf in (None, "율"):
forms += [(v * 100, tol * 100, "pct"), (v / 100, tol / 100, "pct")]
if tf == "무게":
forms += [(v * 1000, tol * 1000, "kgt"), (v / 1000, tol / 1000, "kgt")]
out = []
for x, t, how in forms:
t = max(t, abs(x) * 1e-9)
for j in range(
bisect.bisect_left(self.vals, x - t), bisect.bisect_right(self.vals, x + t)
):
cid = self.ids[j]
c = self.cells[cid]
if c["종류"] == "cond":
continue # 조건 칸(관경 · SCH)은 옵션 값 — 상수 설명에 안 씀
if k.get("직종") and not self._trade_ok(k["직종"], c):
continue
if c["종류"] == "ratio" and how != "eq":
continue
if how == "pct" and not (tf == "율" or "%" in str(c["단위"])):
continue
if how == "kgt" and not (tf == "무게" or fam(c["단위"]) == "무게"):
continue
if (
how == "eq"
and abs(c["v"] - v) > 1e-9
and c["종류"] != "ratio"
and tol < 1e-6
and not k.get("몫")
):
continue
if not unit_ok(unit, c["단위"]) and how == "eq":
continue
out.append((cid, how))
return out
def hits_of(self, cid: int) -> list[tuple]:
"""칸 → [(로직, 부름id, 줄, 묶음)](캐시)."""
got = self._hits.get(cid)
if got is None:
got = self._hits[cid] = self._hits_of(cid)
return got
def _hits_of(self, cid: int) -> list[tuple]:
c = self.cells[cid]
out = []
if c["종류"] == "기준":
return [(u[0], f"{u[1]}|기준", 0, {}) for u in self.uses.get(c["표"], [])]
if c["종류"] == "eq":
for item, callid, (kind, val) in self.eq_uses.get(c["칸"], []):
if kind == "고정" and val != c["표"]:
continue
out.append(
(
item,
callid,
c["표"],
{val: json.dumps(c["표"])} if kind == "입력" and val else {},
)
)
return out
row = self.tables[c["표"]]["줄"][c["줄"]]
cols = c["칸"].split("/") if c["종류"] == "ratio" else [c["칸"]]
for item, callid, field, filt, bind in self.uses.get(c["표"], []):
if field is not None and field not in cols and c["종류"] != "cond":
continue
if not self._pass(row, filt):
continue
b = {}
for col, name in bind.items():
if col == "#row":
b[name] = json.dumps(c["줄"])
elif row.get(col) is not None:
b[name] = json.dumps(row[col], ensure_ascii=False)
out.append((item, callid, c["줄"], b))
return out
def explain(self, k: dict) -> list[tuple]:
"""상수 하나 → [(로직, 부름id | None, 줄, 묶음, 꼴, 닻)] ·
닻 = 표 칸 · 직종 식 수로 맞음."""
out = []
for cid, how in self.lookup(k):
if self.cells[cid]["종류"] == "eq":
continue # 기계 요소 값(상각비계수 · 잡재료율 …)은 산근 글에 거의 안 나옴
out += [(item, call, row, bd, how, True) for item, call, row, bd in self.hits_of(cid)]
x = round(k["v"], 9)
if k.get("직종"):
for item in self.trade_index.get(x, ()):
if any(
same_trade(k["직종"], n) for n, y in self.inline_trade[item] if round(y, 9) == x
):
out.append((item, None, None, {}, "식", True))
else:
forms = (
(x, round(k["v"] * 100, 9), round(k["v"] / 100, 9))
if fam(k["단위"]) in (None, "율")
else (x,)
)
for form in forms:
for item in self.inl_index.get(form, ()):
if len(self.inline[item]) <= INLINE_MAX:
out.append((item, None, None, {}, "식", False))
return out
# ── 우연 보정 ────────────────────────────────────────────────────
def df(self, k: dict) -> int:
key = kkey(k)
if key not in self._df:
self._df[key] = max(1, len({x[0] for x in self.explain(k)}))
return self._df[key]
def prior(self) -> None:
"""보정 자료 상수마다 설명할 수 있는 로직 → 로직 몫 p · 평균 df."""
keys = [
dict(zip(("v", "d", "단위", "직종", "몫"), row))
for row in json.loads(CORPUS.read_text(encoding="utf-8"))
]
cnt: dict = defaultdict(int)
for k in keys:
for it in {x[0] for x in self.explain(k)}:
cnt[it] += 1
self.prom = {it: (cnt[it] + 1) / (len(keys) + 2) for it in self.logic}
self.mean_df = sum(self.df(k) for k in keys) / max(len(keys), 1)
def q_of(self, item: str, k: dict) -> float:
"""로직 item 이 상수 k 를 우연히 설명할 확률 ≈ df_k · p_item / 평균 df."""
p = self.prom.get(item, 1 / max(len(self.prom), 1))
return min(0.95, max(1e-6, self.df(k) * p / self.mean_df))
def kkey(k: dict) -> tuple:
return (k["v"], k["d"], k["단위"], k.get("직종"), bool(k.get("몫")))
def pb_sig(qs: list[float], c: int) -> float:
"""포아송 이항 꼬리 P(X ≥ c) 의 -log10."""
if c <= 0:
return 0.0
dp = [1.0] + [0.0] * len(qs)
for q in qs:
for j in range(len(dp) - 1, 0, -1):
dp[j] = dp[j] * (1 - q) + dp[j - 1] * q
dp[0] *= 1 - q
return round(-math.log10(max(sum(dp[c:]), 1e-300)), 2)
_LOCK = threading.Lock()
_CACHE: dict[str, Index] = {}
def get() -> Index:
"""M01 지문마다 한 번 지은 역색인(프로세스 안 · 지문 바뀌면 다시)."""
key = stamp()
with _LOCK:
got = _CACHE.get(key)
if got is None:
trade.cache_clear()
_CACHE.clear()
got = _CACHE[key] = Index()
return got
def warm() -> None:
"""서버 시작 때 한 번(뒤에서) — 실패 = 다음 부름에서 다시."""
try:
get()
except Exception: # noqa: BLE001
pass