- 새 master_base.py: master_formula 의 바탕 기반(Master 색인 · find · FormulaError · EmptyInput · NoRow · _plain · GROUPS · TABLE_GROUPS · TABLE_IDS · COST_ITEMS · BUNDLE)을 글자 그대로 옮김 · 재료 이음 이름 · mp 다시 내보냄 - master_formula: 같은 이름을 master_base 에서 그대로 다시 내보냄(부르는 쪽 고침 0) · 파서 · 엔진 몸은 그대로(불러오기가 옛 파서를 더는 안 씀 → 2-E4 에서 지움) - 새 계산기 쪽 scripts 다섯(master_material · master_pick · master_doc_link · master_doc_block · master_doc_record) import 를 master_base 로 — 새 계산기 셈에 엔진 몸 모듈 0 - 새 지킴 시험 test_855_e4a_base_only: 자식 해석기에서 master_base + 새 계산기만으로 견본 24 로직 셈 · 엔진 몸 읽힘 0 · 지문 = golden_855_engine - 검증: 관련 + 관문 670 통과 · 빌더 --check 같음 · typecheck 0 · 서버 health 200 · M02 단가산출 셈 전후 같음 · 자료 변경 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
169 lines
7.7 KiB
Python
169 lines
7.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""수식 문서 막힘 검사(PLAN 855 · 걸음 2-B3) — 옛 `master_formula.check_logic` 대신 문서 기준.
|
|
|
|
막힘 = 문서 검사 표지(`master_doc.check`) + 부름 닫힘(단가산출 연결 키가 저장 문서에 있음) +
|
|
요소 닫힘(요소 · 표 키 · `{선택}` 구멍을 그 목록으로 편 키 · 재료 고르기 후보 — 마스터 색인) ·
|
|
저장 검사는 문서 사이 부름 순환까지. 기본 입력으로 셈이 안 되는 것은 막힘 아님(사용자 확정 · 지금 그대로).
|
|
문서 없는 로직 = 막힘 아님(지금 그대로 · 로직 줄 뒤에 문서를 지음) · 저장 검사도 문서 없는 키를 안 봄.
|
|
일위대가 조합 줄 검사(`combo_row`) = 옛 `master_combo.check_row` 와 같은 글 · 로직이 있는지는 문서로.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import master_doc as md
|
|
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
|
|
import master_keys as mk
|
|
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
|
|
|
|
COMBO = "UA" # 일위대가 조합 키 머리(`master_combo.TID`)
|
|
COMBO_ITEM = ("로직", "메모") # 조합 담은 로직 줄 칸(`master_combo.ITEM_COLS`)
|
|
|
|
|
|
def calls(doc: dict) -> set[str]:
|
|
"""문서가 부르는 단가산출 키(키 구멍 `{…}` 부름은 셈 때 정해져 뺌)."""
|
|
out = set()
|
|
for v in doc.get("변수") or []:
|
|
link = v.get("연결") or {}
|
|
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
|
out.add(str(link["키"]))
|
|
return out
|
|
|
|
|
|
def _refs(doc: dict, text) -> list[str] | None:
|
|
"""요소 · 표 키 글 → 실제 키 — `{구멍}` 은 그 선택 변수 목록으로 폄 · 못 펴면 None."""
|
|
out = [str(text)]
|
|
for hole in dict.fromkeys(md.holes(text)):
|
|
var = next(
|
|
(
|
|
v
|
|
for v in doc.get("변수") or []
|
|
if hole in (v.get("이름"), v.get("열쇠"), md.var_id(v))
|
|
),
|
|
None,
|
|
)
|
|
link = (var or {}).get("연결") or {}
|
|
if link.get("갈래") != "선택" or not isinstance(link.get("목록"), list):
|
|
return None
|
|
out = [t.replace("{" + hole + "}", str(c)) for t in out for c in link["목록"]]
|
|
return out
|
|
|
|
|
|
def _element_links(doc: dict):
|
|
"""(변수, 연결, 키 글) — 요소 · 표 연결의 키 자리."""
|
|
for v in doc.get("변수") or []:
|
|
link = v.get("연결") or {}
|
|
slot = {"요소": "키", "표": "표"}.get(link.get("갈래"))
|
|
if slot and link.get(slot):
|
|
yield v, link, link[slot]
|
|
|
|
|
|
def seen(doc: dict) -> set[str]:
|
|
"""문서가 보는 요소 · 표 키(구멍은 편 키 · 못 펴면 그 묶음 「#ID」) ·
|
|
재료 고르기 조건이면 자재품목 묶음 통째(「#MT」)."""
|
|
out = set()
|
|
for _, _, text in _element_links(doc):
|
|
refs = _refs(doc, text)
|
|
out |= set(refs) if refs is not None else {"#" + str(text)[:2]}
|
|
if any((v.get("연결") or {}).get("재료") for v in doc.get("변수") or []):
|
|
out.add("#" + mm.MARKET)
|
|
return out
|
|
|
|
|
|
def closure(key: str, doc: dict, whole) -> list[str]:
|
|
"""요소 닫힘 — 연결이 부르는 요소 · 표가 마스터에 있음 · 재료 고르기 후보가 있음."""
|
|
out = []
|
|
for v, link, text in _element_links(doc):
|
|
for ref in _refs(doc, text) or []:
|
|
try:
|
|
whole.get(ref)
|
|
except mf.FormulaError as e:
|
|
out.append(f"{key} 연결 {md.var_id(v)} · {e}")
|
|
for v in doc.get("변수") or []:
|
|
cond = (v.get("연결") or {}).get("재료")
|
|
if isinstance(cond, dict):
|
|
out += mm.check_pick(whole, f"{key} 연결 {md.var_id(v)}", cond)
|
|
return out
|
|
|
|
|
|
def _text(key: str, mark: dict) -> str:
|
|
where = f" {mark['자리']}" if mark.get("자리") else ""
|
|
return f"{key}{where} · {mark['갈래']} — {mark['글']}"
|
|
|
|
|
|
def reasons(key: str, doc: dict | None, have, whole=None) -> list[str]:
|
|
"""그 로직의 막힘 까닭 — 표지 + 부름 닫힘(`have` = 있는 문서 키 묶음) + 요소 닫힘(`whole` 을 주면)."""
|
|
if doc is None: # 막힘 기준 = 지금 그대로(사용자 확정) — 문서 없는 새 줄은 막힘 아님
|
|
return []
|
|
out = [_text(key, m) for m in md.check(doc)]
|
|
out += [f"{key} · 부르는 단가산출 「{k}」 없음" for k in sorted(calls(doc) - set(have))]
|
|
out += _passed(key, doc, have)
|
|
return out + (closure(key, doc, whole) if whole is not None else [])
|
|
|
|
|
|
def _passed(key: str, doc: dict, have) -> list[str]:
|
|
"""단가산출 부름이 넘기는 입력 이름 = 부르는 문서의 입력 변수 열쇠(옛 「입력 이름」 검사 몫)."""
|
|
out = []
|
|
for v in doc.get("변수") or []:
|
|
link = v.get("연결") or {}
|
|
callee = have.get(str(link.get("키"))) if link.get("갈래") == "단가산출" else None
|
|
if callee is None or not isinstance(have, dict):
|
|
continue
|
|
ins = {
|
|
x.get("열쇠")
|
|
for x in callee.get("변수") or []
|
|
if (x.get("연결") or {}).get("갈래") in ("입력", "선택", "숫자")
|
|
}
|
|
for name in sorted(set(link.get("입력") or {}) - ins):
|
|
out.append(f"{key} 연결 {md.var_id(v)} · 「{link['키']}」 에 입력 「{name}」 없음")
|
|
return out
|
|
|
|
|
|
def check_docs(docs: dict[str, dict], keys=None, whole=None) -> list[str]:
|
|
"""저장 검사 몫 — `keys`(없으면 전부)의 막힘 까닭 + 문서 사이 부름 순환(전체)."""
|
|
out = [
|
|
x
|
|
for k in sorted(docs if keys is None else set(keys) & set(docs))
|
|
for x in reasons(k, docs[k], docs, whole)
|
|
]
|
|
graph = {k: sorted(calls(d)) for k, d in docs.items()}
|
|
out += [f"돌고 도는 참조 · {' → '.join([*loop, loop[0]])}" for loop in md.loops(graph)]
|
|
return out
|
|
|
|
|
|
def combo_row(row: dict, docs) -> list[str]:
|
|
"""일위대가 조합 한 줄 — 빈 조합 · 없는 로직 · 같은 로직 두 번 · 조합을 담음 · 메모 모양."""
|
|
where = f"{row.get('키')} {row.get('이름') or ''}".strip()
|
|
got = row.get("담은로직")
|
|
items = got if isinstance(got, list) else []
|
|
out = [] if items else [f"{where} · 빈 조합 — 담은 로직이 없음"]
|
|
if got is not None and not isinstance(got, list):
|
|
out.append(f"{where} · 「담은로직」 이 목록 아님")
|
|
picked: set[str] = set()
|
|
for at, one in enumerate(items, start=1):
|
|
if not isinstance(one, dict):
|
|
out.append(f"{where} 줄{at} · 담은 로직 줄이 묶음 아님 「{one}」")
|
|
continue
|
|
extra = set(one) - set(COMBO_ITEM)
|
|
if extra:
|
|
out.append(f"{where} 줄{at} · 모르는 칸 {sorted(extra)}")
|
|
memo = one.get("메모")
|
|
if memo is not None and not isinstance(memo, str):
|
|
out.append(f"{where} 줄{at} · 「메모」 가 글자 아님 「{memo}」 — 수량·계산은 두지 않음")
|
|
key = str(one.get("로직") or "")
|
|
if not mk.KEY.fullmatch(key):
|
|
out.append(f"{where} 줄{at} · 로직 키 모양 아님 「{key}」")
|
|
continue
|
|
if mk.id_of(key) == COMBO:
|
|
out.append(f"{where} 줄{at} · 조합은 조합을 담지 못함 「{key}」 — 단가산출 로직만")
|
|
continue
|
|
if mk.GROUP_OF.get(mk.id_of(key)) != "로직":
|
|
out.append(f"{where} 줄{at} · 로직 아님 「{key}」")
|
|
continue
|
|
if key not in docs:
|
|
out.append(f"{where} 줄{at} · 없는 요소 「{key}」")
|
|
continue
|
|
if key in picked:
|
|
out.append(f"{where} 줄{at} · 같은 로직을 두 번 담음 「{key}」")
|
|
picked.add(key)
|
|
return out
|