Files
Aislo/resources/master_data/scripts/master_doc_block.py
T
eomsangdonandClaude Opus 5.5 11e91da39e feat(855-B): 막힘 · 저장 검사를 수식 문서 기준으로 — 2-B3 · 새 master_doc_block
- 새 master_doc_block — 문서 막힘 = 문서 검사 표지 + 단가산출 부름 닫힘 · 넘긴 입력 이름 + 요소 닫힘(요소 · 표 키 · 선택 구멍 펼친 키 · 재료 고르기 후보) · 저장 검사는 문서 사이 순환까지 · 문서 없는 새 줄 = 막힘 아님(지금 그대로)
- M01 /logic blocked · reasons · 목록 막힘(Store_Cache._check · 부름 · 본 요소 지도도 문서에서) · 일위대가 조합 막힘(M01 Store_Combo · M02 Combo_Store = problems_of) = 새 길 · 서버 답 꼴 그대로
- 저장 검사 로직 몫 = 옛 check_logics(좁힌 줄) 먼저 · 깨끗하면 문서 막힘 — 로직 줄은 아직 옛 엔진 길이 씀 · L3 에서 걷음 · 조합 몫 = 문서로
- 자체 기계 등록 · 뺌이 수식 문서 목록에 저장 뒤 들어가는 것을 저장 검사가 미리 봄(Store_Cache.picks · Machine.relist)
- 옛 검사 본체(mf.check_logic · mcb.check_all · check_row)는 그대로 · 쓰지 않게 된 _Watch 만 걷음
- 시험: test_855_block 에 화면 답 = 새 길 · 저장 부름 닫힘 · 순환 · 요소 닫힘 · 넘긴 입력 단언 · test_m01_make 준비 = 수식 문서도 사본(새 로직 문서가 생김) · test_m01_cache 부르는 줄 다시 셈 = 문서 기준으로 고침(목록 = 문서 기준이라 로직 JSON 만 고치면 목록은 안 막힘 — 뜻한 바뀜 · 저장 검사는 옛 check_logics 가 로직 줄을 지킴)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 21:29:58 +09:00

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_formula 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