diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index dd37efe64..b4787a23f 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -178,7 +178,26 @@ def register(batch: list[dict]) -> Callable[[], None]: changes.append({"op": "edit", "key": logic["키"], "row": new}) if changes: batch.append({"file": name, "version": store.read(name)[1], "changes": changes}) - return lambda: _register_docs(add, drop) + after = lambda: _register_docs(add, drop) # noqa: E731 + after.lists = ( + add, + drop, + ) # 저장 검사가 문서 목록을 미리 같게 봄(`Store_Cache.picks` · 855 2-B3) + return after + + +def relist(doc: dict, add: dict[str, list[str]], drop: set[str]) -> bool: + """문서 하나의 「기계」 고르기 목록에 더함 · 뺌(제자리 고침) — 바뀌었으면 True.""" + hit = False + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "선택" or v.get("이름") != "기계": + continue + codes = [c for c in link.get("목록") or [] if str(c) not in drop] + codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] + if codes != link.get("목록"): + link["목록"], hit = codes, True + return hit def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None: @@ -192,14 +211,7 @@ def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None: for path in sorted(docs.folder().glob("수식_*.json")): data, hit = ml.load_file(path), False for doc in data.get("줄") or []: - for v in doc.get("변수") or []: - link = v.get("연결") or {} - if link.get("갈래") != "선택" or v.get("이름") != "기계": - continue - codes = [c for c in link.get("목록") or [] if str(c) not in drop] - codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] - if codes != link.get("목록"): - link["목록"], hit = codes, True + hit = relist(doc, add, drop) or hit if hit: docs.put(path, data) diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index ed3fd4390..ae828d019 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -387,7 +387,7 @@ def logic(key: str) -> dict: for name, data in _logic_files(files): for row in data.get("줄") or []: if str(row.get("키")) == key: - reasons = cm.mf.check_logic(whole, row)[0] + reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3) _, version = read(name) return { "file": name, diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py index abab84f0b..230240e04 100644 --- a/M01_MasterData/M01_MasterData_Store_Cache.py +++ b/M01_MasterData/M01_MasterData_Store_Cache.py @@ -12,6 +12,7 @@ from __future__ import annotations import contextlib import contextvars +import copy import json import sys import threading @@ -22,7 +23,7 @@ SCRIPTS = Path(__file__).resolve().parents[1] / "resources/master_data/scripts" sys.path.insert(0, str(SCRIPTS)) import check_master as cm # noqa: E402 -import master_material as mm # noqa: E402 (자재품목 테이블ID — 재료 고르기는 그 묶음을 훑음) +import master_doc_block as mb # noqa: E402 (막힘 · 저장 검사 = 수식 문서 기준 · 855 2-B3) _FRESH = threading.RLock() _READ: dict[str, tuple[tuple, dict]] = {} # 파일 이름 → (자국, 읽은 내용) @@ -72,34 +73,27 @@ def _logic_files(files: dict[str, dict]): yield name, data -class _Watch: - """`Master.get` 을 감싸 그 로직 줄이 본 요소·표를 적어 둠 — 저장 때 검사를 좁히는 지도.""" +def docs() -> dict[str, dict]: + """저장 수식 문서 전부 {키: 문서}(`M01_MasterData_Doc.docs` · 파일 시각이 같으면 같은 묶음).""" + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게 - def __init__(self, whole): - self._whole, self.seen = whole, set() + return doc_store.docs() - def get(self, ref): - self.seen.add(str(ref)) - return self._whole.get(ref) - def __getattr__(self, name): - return getattr(self._whole, name) - - def __setattr__(self, name, value): # 속에 적어 둠 — 미리 갈라 둔 것을 줄마다 다시 안 짜게 - if name in ("_whole", "seen"): - super().__setattr__(name, value) - else: - setattr(self._whole, name, value) +def reasons(key: str, whole) -> list[str]: + """로직 하나의 막힘 까닭 — 수식 문서 기준(`master_doc_block` · 요소 닫힘은 `whole` 색인).""" + have = docs() + return mb.reasons(key, have.get(key), have, whole) def _check(whole, row: dict) -> tuple[list[str], set, set]: - """(막힘 까닭, 부르는 로직, 본 요소·표) — 본 것은 키 · 「ID:원문번호」 · - 재료 고르기가 있으면 자재품목 묶음 통째(「#MT」 · 후보를 그 안에서 고름).""" - watch = _Watch(whole) - why, calls = cm.mf.check_logic(watch, row) - if any(isinstance(h.get("요소"), dict) for h in row.get("호표") or []): - watch.seen.add("#" + mm.MARKET) - return why, calls, watch.seen + """(막힘 까닭, 부르는 로직, 본 요소·표) — 그 로직의 수식 문서 기준(855 2-B3) · + 본 것 = 연결 요소 · 표 키 · 재료 고르기면 자재품목 묶음 통째(「#MT」).""" + have, key = docs(), str(row.get("키")) + doc = have.get(key) + if doc is None: + return mb.reasons(key, None, have, whole), set(), set() + return mb.reasons(key, doc, have, whole), mb.calls(doc), mb.seen(doc) def forget() -> None: @@ -180,6 +174,9 @@ def blocks(folder: Path) -> dict[str, list[str]]: with _FRESH: files, whole = loaded(folder) stamps = _INDEX["자국"] + if _INDEX.get("문서") is not (now := docs()): # 수식 문서가 바뀌면 통째로 다시 + _BLOCK.clear() + _INDEX["문서"] = now base = {n: s for n, s in stamps.items() if files[n].get("그룹") != "로직"} marks = None # 요소·표에서 흔들린 자리 — None 이면 무엇이 바뀐지 모름(통째로 다시) if _BASE != base: # 인력 · 재료 · 표가 바뀌면 바탕이 달라짐 @@ -236,7 +233,7 @@ def narrow(folder: Path, batch: list[dict], before: dict, after: dict): """(검사할 로직 키, 안 보는 줄이 부르는 키, 요소도 고쳤는지) — 저장이 흔드는 줄만. 로직 줄은 고친 줄과 **그 줄을 부르던 줄** · 요소·표 줄은 그 줄을 **보던 로직** - (키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_Watch` 가 적어 둔 지도). + (키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔 지도 · 855 2-B3 부터 수식 문서 연결). """ counts = counted(folder) calls = {key: got[1] for key, got in counts.items()} @@ -270,10 +267,55 @@ def check_saved(files: dict, changed: list[str], book: dict, narrowed=None) -> l """ whole = cm.mf.Master(files) out = [x for name in changed for x in cm.check_form(name, files[name])] - out += cm.check_logics(files, whole, book, narrowed and narrowed[:2]) + out += logic_errors(files, whole, book, narrowed and narrowed[:2]) if narrowed and narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로) out += cm.check_links(whole) - return out + cm.mcb.check_all(files, whole) + labor_errors(whole) + return out + combo_errors(files) + labor_errors(whole) + + +_PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None) + + +@contextlib.contextmanager +def picks(add: dict, drop: set): + """저장 중 — 저장 뒤 수식 문서 기계 고르기 목록에 할 더함 · 뺌(`Machine.register`)을 검사가 미리 봄.""" + token = _PICKS.set((add, drop)) + try: + yield + finally: + _PICKS.reset(token) + + +def _docs_of(files: dict) -> dict[str, dict]: + """`files` 에 로직 줄이 있는 키의 수식 문서만 — 지운 로직은 문서가 아직 있어도 없는 것으로 · + 저장 중 기계 목록 고침(`picks`)은 사본에 얹음.""" + keys = {str(r.get("키")) for _, data in _logic_files(files) for r in data.get("줄") or []} + out = {k: d for k, d in docs().items() if k in keys} + if pending := _PICKS.get(): + from M01_MasterData import ( + M01_MasterData_Machine as machine, + ) # Machine 이 Store 를 부름 — 늦게 + + for k, d in out.items(): + one = copy.deepcopy(d) + if machine.relist(one, *pending): + out[k] = one + return out + + +def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str]: + """저장 검사의 로직 몫 — 옛 로직 줄 검사(`check_master.check_logics` · 좁힌 줄 · 키 겹침 · 대장 · + 연결)가 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 문서 없는 새 줄은 안 봄 · + 요소 닫힘 · 문서 사이 순환) — 같은 흠을 두 번 안 적음. + ponytail: 로직 줄 몫 = 옛 `check_logic` 남음(로직 JSON 이 아직 옛 엔진 길에 쓰임) · L3 에서 걷음.""" + out = cm.check_logics(files, whole, book, narrow) + return out or mb.check_docs(_docs_of(files), narrow[0] if narrow else None, whole) + + +def combo_errors(files: dict) -> list[str]: + """일위대가 조합 전부(옛 `master_combo.check_all` 대신) — 로직이 있는지는 수식 문서로.""" + have = _docs_of(files) + return [f"{name} · {x}" for name, row in cm.mcb.rows(files) for x in mb.combo_row(row, have)] def _labor_files() -> list[tuple[str, Path]]: diff --git a/M01_MasterData/M01_MasterData_Store_Combo.py b/M01_MasterData/M01_MasterData_Store_Combo.py index f911fefbb..11ac9774f 100644 --- a/M01_MasterData/M01_MasterData_Store_Combo.py +++ b/M01_MasterData/M01_MasterData_Store_Combo.py @@ -17,6 +17,7 @@ from config import config_system from M01_MasterData import M01_MasterData_Store as store cm, mk, mcb = store.cm, store.mk, store.mcb +import master_doc_block as mcb_doc # noqa: E402 import master_unit as mu # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤(712-2) FILE = mcb.FILE @@ -86,6 +87,11 @@ def _write(changes: list[dict], version: str | None = None) -> dict: return out[0] +def problems_of(row: dict) -> list[str]: + """조합 한 줄 막힘 까닭 — 로직이 있는지는 수식 문서로(855 2-B3 · M02 조합 층도 씀).""" + return mcb_doc.combo_row(row, store.cache.docs()) + + # ── 읽기 ────────────────────────────────────────────────────────────── def _brief(whole, row: dict) -> list[dict]: """담은 로직 줄에 그 로직의 이름·단위를 붙여 보임 — 없는 키는 `ok` false.""" @@ -122,7 +128,7 @@ def combos(sub: str = "", detail: str = "", q: str = "", owner: str = "") -> lis continue if not store._hit(row, q): continue - problems = mcb.check_row(whole, row) + problems = problems_of(row) out.append( { "file": FILE, @@ -140,7 +146,7 @@ def combo(key: str) -> dict: data, version = _read() row = _find(data, key) whole = store.loaded()[1] - problems = mcb.check_row(whole, row) + problems = problems_of(row) return { "file": FILE, "version": version, diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index e60e3f328..17a1db71e 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -251,7 +251,8 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: part["version"] = part.get("version") or store.read(OWN)[1] before = {p["file"]: set(_file_keys(p["file"])) for p in batch} # 자재 3만 키 — 목록 찾기 금지 try: - files = store.save(batch) + with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))): + files = store.save(batch) except store.StoreError: if fresh: _own_path().unlink(missing_ok=True) diff --git a/M01_MasterData/M01_MasterData_Store_Save.py b/M01_MasterData/M01_MasterData_Store_Save.py index 877a96b9d..4222e3e69 100644 --- a/M01_MasterData/M01_MasterData_Store_Save.py +++ b/M01_MasterData/M01_MasterData_Store_Save.py @@ -67,11 +67,11 @@ def _index(files: dict, whole, moved: list[dict]): def _errors(files, whole, names, book, narrowed, keys, gone) -> list[str]: out = [x for name in names for x in cm.check_form(name, _only(name, files[name], keys[name]))] - out += cm.check_logics(files, whole, book, narrowed[:2]) + out += cache.logic_errors(files, whole, book, narrowed[:2]) # 수식 문서 기준(855 2-B3) if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로) out += cm.check_links(whole) if cm.mcb.FILE in names or gone: - out += cm.mcb.check_all(files, whole) + out += cache.combo_errors(files) return out diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py index 28847f8e0..083655225 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py @@ -147,7 +147,7 @@ def folders_of(doc: dict) -> list[list[str]]: # ── 읽기 ────────────────────────────────────────────────────────────── def _brief(whole, row: dict) -> dict[str, Any]: - problems = mcb.check_row(whole, row) + problems = combo_store.problems_of(row) return { **{k: row.get(k) for k in mcb.COLS if k != "담은로직"}, "count": len(mcb.items(row)), @@ -169,7 +169,7 @@ def one(key: str) -> dict[str, Any]: doc, version = _load() row = _find(doc, key) whole = m01.loaded()[1] - problems = mcb.check_row(whole, row) + problems = combo_store.problems_of(row) brief = combo_store._brief(whole, row) return { "판": version, @@ -214,7 +214,7 @@ def _name_errors(doc: dict, one: dict) -> list[str]: def _check(doc: dict, one: dict) -> None: """이름 길이 · 겹침 · 담은 로직(없는 키 · 두 번 · 빈 조합) — 막히면 422.""" - if errors := _name_errors(doc, one) + mcb.check_row(m01.loaded()[1], one): + if errors := _name_errors(doc, one) + combo_store.problems_of(one): raise store.StoreError(422, {"errors": errors}) diff --git a/resources/master_data/scripts/master_doc_block.py b/resources/master_data/scripts/master_doc_block.py new file mode 100644 index 000000000..fe466e96f --- /dev/null +++ b/resources/master_data/scripts/master_doc_block.py @@ -0,0 +1,168 @@ +# -*- 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 diff --git a/resources/tester/test_855_block.py b/resources/tester/test_855_block.py index 2de6a343a..f1cfba342 100644 --- a/resources/tester/test_855_block.py +++ b/resources/tester/test_855_block.py @@ -31,3 +31,76 @@ def test_틀린_식은_옛_새_모두_막힘(): bad_doc["금액"][0]["수량"] = "없는기호 × 2" assert h.mf.check_logic(whole, bad_row)[0] assert md.check(bad_doc) + + +def test_화면_답이_문서_막힘_길을_씀(monkeypatch): + """2-B3 뒤 — M01 `/logic` 막힘 · 목록 막힘 · 일위대가 조합 막힘이 수식 문서 기준(`master_doc_block`). + 문서 하나를 틀리게(사본) 하면 로직 줄은 그대로인데 화면 답이 막힘으로 바뀜 · 문서가 빠지면 조합도 막힘.""" + import copy + + from M01_MasterData import M01_MasterData_Doc as doc_store + from M01_MasterData import M01_MasterData_Store as store + from M01_MasterData import M01_MasterData_Store_Combo as combo_store + + real = doc_store.docs() + key = next(k for k, d in real.items() if d.get("금액")) + assert not store.logic(key)["blocked"] and not store.blocks()[key] + bad = copy.deepcopy(real[key]) + bad["금액"][0]["수량"] = "없는기호 × 2" + monkeypatch.setattr(doc_store, "docs", lambda: {**real, key: bad}) + got = store.logic(key) + assert got["blocked"] and any("없는기호" in x for x in got["reasons"]) + assert store.blocks()[key] == got["reasons"] + + row = {"키": "UA999999", "이름": "시험", "담은로직": [{"로직": key}]} + assert combo_store.problems_of(row) == [] + monkeypatch.setattr(doc_store, "docs", lambda: {k: d for k, d in real.items() if k != key}) + assert combo_store.problems_of(row) == [f"UA999999 시험 줄1 · 없는 요소 「{key}」"] + assert store.logic(key)["reasons"] == [] # 문서 없는 줄 = 막힘 아님(지금 그대로) + + +def test_저장_검사_부름_닫힘_순환(): + """저장 검사 로직 몫(`master_doc_block.check_docs`) — 부르는 단가산출이 빠지면 막힘 · 문서 사이 순환.""" + mb = importlib.import_module("master_doc_block") + _, _, docs, _ = h.world() + caller = next(k for k, d in docs.items() if mb.calls(d)) + called = sorted(mb.calls(docs[caller]))[0] + assert not mb.check_docs(docs, {caller}) + gone = {k: d for k, d in docs.items() if k != called} + assert any(f"「{called}」 없음" in x for x in mb.check_docs(gone, {caller})) + a = {"꼴": "수식문서", "키": "GX900001", "변수": [{"열쇠": "b", "기호": "b", "연결": {"갈래": "단가산출", "키": "GX900002"}}]} # fmt: skip + b = {**a, "키": "GX900002", "변수": [{"열쇠": "a", "기호": "a", "연결": {"갈래": "단가산출", "키": "GX900001"}}]} # fmt: skip + assert any("돌고 도는 참조" in x for x in mb.check_docs({"GX900001": a, "GX900002": b}, set())) + + +def test_요소_닫힘_쓰이는_요소가_없으면_막힘(): + """요소 닫힘 — 문서가 부르는 요소 · 표가 마스터에 없으면 막힘(쓰이는 요소를 지우면 저장이 막는 지금 동작 지킴) · + 단가산출에 넘기는 입력 이름이 부르는 문서에 없으면 막힘.""" + import copy + + mb = importlib.import_module("master_doc_block") + _, whole, docs, _ = h.world() + key, doc = next( + (k, d) + for k, d in docs.items() + if any( + (v.get("연결") or {}).get("갈래") == "요소" + and str((v.get("연결") or {}).get("키") or "").startswith("LB0") + for v in d.get("변수") or [] + ) + ) + assert not mb.reasons(key, doc, docs, whole) + gone = copy.deepcopy(doc) + link = next( + v["연결"] + for v in gone["변수"] + if str((v.get("연결") or {}).get("키") or "").startswith("LB0") + ) + link["키"] = "LB999999" + assert any("LB999999" in x for x in mb.reasons(key, gone, docs, whole)) + + caller = next(k for k, d in docs.items() if mb.calls(d)) + bad = copy.deepcopy(docs[caller]) + call = next(v["연결"] for v in bad["변수"] if (v.get("연결") or {}).get("갈래") == "단가산출") + call["입력"] = {**(call.get("입력") or {}), "없는입력": "1"} + assert any("없는입력" in x for x in mb.reasons(caller, bad, docs, whole)) diff --git a/resources/tester/test_m01_cache.py b/resources/tester/test_m01_cache.py index f0bfa7fdd..22887f2a0 100644 --- a/resources/tester/test_m01_cache.py +++ b/resources/tester/test_m01_cache.py @@ -107,16 +107,26 @@ def test_로직을_저장하면_목록에_바로_비친다(client: TestClient) - assert listed and listed[0]["이름"] == "저장 뒤 이름" -def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다(client: TestClient) -> None: +def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다( + client: TestClient, tmp_path: Path, monkeypatch +) -> None: + """목록 막힘 = 수식 문서 기준(855 2-B3) — 부른 쪽 문서가 깨지면(넘겨받던 입력 변수를 지움) + 다른 파일의 부르는 줄도 다시 세어 막힘.""" + from M01_MasterData import M01_MasterData_Doc as doc_store + + docs = tmp_path / "수식문서" + shutil.copytree(REAL / "수식문서", docs) + monkeypatch.setattr(doc_store.ml, "FOLDER", docs) + doc_store._memo.clear() assert [x for x in _logics(client) if x["키"] == CALLER][0]["blocked"] is False - def add_input(data: dict) -> None: - row = next(r for r in data["줄"] if r["키"] == CALLEE) - row["입력"] = [*row.get("입력", []), {"이름": "새입력", "종류": "수"}] - - _write("로직_건설품셈_08장_건설기계.json", add_input) # 부르는 쪽 파일은 그대로 + path = docs / "수식_건설품셈_08장_건설기계.json" # 부르는 쪽 문서 파일은 그대로 + data = json.loads(path.read_text(encoding="utf-8")) + callee = next(d for d in data["줄"] if d["키"] == CALLEE) + callee["변수"] = [v for v in callee["변수"] if v.get("열쇠") != "지역"] + path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") caller = [x for x in _logics(client) if x["키"] == CALLER][0] - assert caller["blocked"] is True and any("새입력" in x for x in caller["reasons"]) + assert caller["blocked"] is True and any("입력 「지역」" in x for x in caller["reasons"]) def _save(client: TestClient, key: str, spoil) -> object: diff --git a/resources/tester/test_m01_make.py b/resources/tester/test_m01_make.py index 59caaaf70..1544b66cb 100644 --- a/resources/tester/test_m01_make.py +++ b/resources/tester/test_m01_make.py @@ -13,6 +13,7 @@ import pytest from fastapi import FastAPI from fastapi.testclient import TestClient +from M01_MasterData import M01_MasterData_Doc as doc_store from M01_MasterData import M01_MasterData_Router as router_module from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Make as make @@ -28,7 +29,12 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: if not path.name.startswith("_") or path.name == store.mk.BOOK.name: shutil.copy(path, tmp_path / path.name) shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) + shutil.copytree( + REAL / "수식문서", tmp_path / "수식문서" + ) # 막힘 · 조합 검사 = 문서 기준(855 2-B3) monkeypatch.setattr(store, "FOLDER", tmp_path) + monkeypatch.setattr(doc_store.ml, "FOLDER", tmp_path / "수식문서") + doc_store._memo.clear() app = FastAPI() app.include_router(router_module.router) return TestClient(app)