diff --git a/resources/master_data/_수식문서_틀.md b/resources/master_data/_수식문서_틀.md index 4171ac42f..b96b58a6f 100644 --- a/resources/master_data/_수식문서_틀.md +++ b/resources/master_data/_수식문서_틀.md @@ -5,6 +5,7 @@ - 셈 = `scripts/master_doc_calc.py` ↔ `common_util/common_util_formula_doc_calc.ts`(짝) - 풀이 · 글 · 검사 = `scripts/master_doc.py` ↔ `common_util/common_util_formula_doc.ts`(짝) - 표 찾기 · M01 연결 풀이 = `scripts/master_doc_link.py` ↔ `common_util/common_util_formula_doc_table.ts`(표 찾기 짝) +- 셈 기록(줄마다 부른 자원 · 하위 문서 · 고른 품목 · 서버 단독) = `scripts/master_doc_trace.py`(B08 · B09 가 답을 갈라 합산) - 옛 로직 변환 = `scripts/master_doc_convert.py` · 빌더 `scripts/build_수식문서_802_2.py`(`--check`) - 거울 · 꼴 시험 = `resources/tester/test_802_1_formula_doc.py` · 변환 대조 = `test_802_2_convert.py` diff --git a/resources/master_data/scripts/master_doc_calc.py b/resources/master_data/scripts/master_doc_calc.py index 0f6f5be68..07de3aee1 100644 --- a/resources/master_data/scripts/master_doc_calc.py +++ b/resources/master_data/scripts/master_doc_calc.py @@ -275,6 +275,8 @@ class _Run: for k in ("칸", "단위"): if link.get(k): payload[k] = link[k] + if hasattr(self.links, "at"): # 855-F 셈 기록(`master_doc_trace`) — 기록 안 켬 = 안 탐 + self.links.at(self.stack, name, kind, payload) try: if kind == "요소": return number(self.links.element(payload)) @@ -407,6 +409,8 @@ def _money(run: _Run, doc: dict, rules: dict): for i, line in enumerate(lines): scope = _scope(doc, outs, dict(running), cover, syms) where = str(line.get("이름") or f"금액 {i + 1}") + if hasattr(run.links, "at"): # 855-F 셈 기록 — 이 줄 읽음(시간당 작업량) + run.links.at(run.stack, i, "금액", {}) swapped, more, work = mw.line_work(run, line, scope) # 846-1 시간당 작업량 text = line.get("수량") if swapped is None else swapped qty = ( diff --git a/resources/master_data/scripts/master_doc_trace.py b/resources/master_data/scripts/master_doc_trace.py new file mode 100644 index 000000000..07e0278b1 --- /dev/null +++ b/resources/master_data/scripts/master_doc_trace.py @@ -0,0 +1,175 @@ +# -*- coding: utf-8 -*- +"""수식 문서 셈 기록 — 줄마다 부른 것(PLAN 855-F B9-1 · 설계 855 보충 1-3). + +서버 단독(TS 짝 없음) — B08 · B09 가 문서 셈 답을 갈라 합산할 때 「이 줄이 어느 노임 · 자재 · +기계 · 표 · 하위 단가산출을 불렀나」 를 읽음. 셈은 그대로: `Trace` = `master_doc_link.Links` + +기록 · `master_doc_calc` 의 훅(`links.at`)이 연결마다 알림 — `Links` 에는 `at` 이 없어 기록을 안 +켜면 지금 길 그대로. + +`calc(doc, Trace(master, docs), given)` → 셈 답 + +- `부름` = 연결 부른 차례 [{문서, 깊이, 이름, 갈래(요소 · 표 · 단가산출), 부름(넘긴 꼴 — 키 · 표 · + 조건 · 입력 · 재료 …), 자원[{키, 갈래(인력 · 재료 · 기계 · 표)}], 품목?(고른 재료 키) · + 기계?(기계경비 부름 = 결과단위 원/시간 돈 문서의 기계 키)}] — + 하위 문서 안 부름도 깊이를 달고 같이(같은 하위 · 같은 입력 두 번째는 셈 답을 다시 씀 = 안 적음) +- `줄[i].부름` = 그 금액 줄 식(수량 · 단가 · 비목곱)이 닿는 이름의 맨 위 부름 차례 번호 + 그 줄 + 셈 중 읽음(갈래 「금액」 · 이름 = 줄 차례 · 시간당 작업량 기계 칸) +- `자원` = 문서 전체(하위 포함) 자원 키 차례 · 겹침 없음(표 빼고 · 단가 책 수요) +""" + +from __future__ import annotations + +import inspect +import re +import types +from itertools import takewhile + +import master_doc as md +import master_doc_calc as mc +import master_doc_link as ml + +CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"} # `master_equation_view.CAT` 같은 말 +_SLOTS = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별") + + +class _Seen: + """마스터 감쌈 — `get` 이 돌려준 줄을 알림 · + 마스터 메서드도 이 감쌈에 묶어 안쪽 `self.get` 까지 잡음.""" + + def __init__(self, master, note): + self._m, self._note = master, note + + def get(self, ref): + row = self._m.get(ref) + self._note(row) + return row + + def __setattr__(self, name, value): # 마스터 칸(찾기 색인 `_found` 등)은 마스터에 + if name in ("_m", "_note"): + object.__setattr__(self, name, value) + else: + setattr(self._m, name, value) + + def __getattr__(self, name): + raw = inspect.getattr_static(self._m, name) + if isinstance(raw, types.FunctionType): + return raw.__get__(self) + return getattr(self._m, name) + + +class Trace(ml.Links): + """기록 켠 연결 — `calls` 에 부른 차례대로 쌓임(여러 문서 셈에 다시 써도 됨).""" + + def __init__(self, master, docs: dict[str, dict] | None = None): + super().__init__(_Seen(master, self._note), docs) + self.calls: list[dict] = [] + self._now: dict | None = None + self._last: str | None = None + + def at( + self, stack: tuple, name, kind: str, payload: dict + ) -> None: # 셈 훅(이름 | 금액 줄 차례) + self._now = { + "문서": stack[-1] if stack else "", + "깊이": len(stack), + "이름": name, + "갈래": kind, + "부름": {k: payload[k] for k in _SLOTS if k in payload}, + "자원": [], + } + self.calls.append(self._now) + + def _note(self, row: dict) -> None: + key = self._last = str(row.get("키") or "") + kind = CAT.get(key[:2]) or ("표" if "줄" in row and "조건" in row else None) + if not kind: + return + if self._now is None: # 연결 밖 부름(이름 없는 기계 줄 읽기) — 이름 빈 기록 + self.at((), "", "", {}) + got = self._now["자원"] + if not any(x["키"] == key for x in got): + got.append({"키": key, "갈래": kind}) + + def element(self, p: dict): + if p.get("재료") is None or self._now is None: + return super().element(p) + got, before, self._last = self._now["자원"], len(self._now["자원"]), None + try: + return super().element(p) + finally: # 재료 찾기 = 고른 품목 하나 — 찾을 때 훑은 후보 · 색인 짓기 읽음은 뺌 + del got[before:] + if self._last and CAT.get(self._last[:2]) == "재료": # 마지막 읽음 = 고른 품목 + self._now["품목"] = self._last # (`mp.priced` 출처 · 값 없음 = 그 이름 글 읽음) + if not any(x["키"] == self._last for x in got): + got.append({"키": self._last, "갈래": "재료"}) + + +def _names(text) -> list[str]: + if text in (None, ""): + return [] + try: + return md.names(md.parse(str(text))) + except md.DocError: + return [] + + +def reach(doc: dict, texts: list) -> set[str]: + """식 글들이 닿는 이름 전부 — 식 줄 · 연결 구멍(`{이름}`) · 조건 · 입력 식 · 지역 칸을 + 따라감.""" + vars_ = {md.var_id(v): v for v in doc.get("변수") or []} + lines = {str(x.get("기호") or ""): x for x in doc.get("식") or []} + todo = [n for t in texts for n in _names(t)] + seen: set[str] = set() + while todo: + name = todo.pop() + if name in seen: + continue + seen.add(name) + if name in lines: + todo += _names(lines[name].get("식")) + link = (vars_.get(name) or {}).get("연결") or {} + for k in ("키", "표"): + todo += md.HOLE.findall(str(link.get(k) or "")) + for v in (link.get("재료") or {}).values() if isinstance(link.get("재료"), dict) else (): + todo += md.HOLE.findall(str(v)) + for k in ("조건", "입력"): + for v in (link.get(k) or {}).values() if isinstance(link.get(k), dict) else (): + todo += _names(v) + todo += [str(link[k]) for k in ("지역", "계약종별") if link.get(k)] + return seen + + +def _machines(trace: Trace, calls: list[dict]) -> None: + """기계경비 부름(결과단위 원/시간 돈 문서 · `master_bundle.is_machine` 같은 판별)에 「기계」 = + 그 부름 안에서 처음 읽은 기계 키(옛 `B09 call_of` 의 machine) · 같은 부름 두 번째 = 앞 답.""" + seen: dict[str, str | None] = {} + for i, c in enumerate(calls): + doc = trace.doc(str(c["부름"].get("키"))) if c["갈래"] == "단가산출" else None + unit = re.sub(r"\s", "", str((doc or {}).get("결과단위") or "")) + if not doc or doc.get("결과") or unit != "원/시간": + continue + tag = repr((c["부름"].get("키"), sorted((c["부름"].get("입력") or {}).items()))) + inner = [c, *takewhile(lambda x: x["깊이"] > c["깊이"], calls[i + 1 :])] + got = [x["키"] for one in inner for x in one["자원"] if x["갈래"] == "기계"] + c["기계"] = seen[tag] = got[0] if got else seen.get(tag) + + +def calc(doc: dict, trace: Trace, given: dict | None = None, cover: dict | None = None) -> dict: + """문서 셈(`master_doc_calc.calc` 그대로) + 기록 — 모듈 머리 꼴.""" + start = len(trace.calls) + trace._now = None + got = mc.calc(doc, trace, given, cover=cover) + calls = [c for c in trace.calls[start:] if c["갈래"] != "금액" or c["자원"]] # 빈 줄 읽음 뺌 + top = 1 if doc.get("키") else 0 + for i, (line, out) in enumerate(zip(doc.get("금액") or [], got.get("줄") or [])): + texts = [line.get("수량"), line.get("단가"), *(line.get(mc.TIMES) or {}).values()] + names = reach(doc, texts) | {i} # 이 줄 읽음(갈래 「금액」 · 이름 = 줄 차례) + out["부름"] = [ + j + for j, c in enumerate(calls) + if c["깊이"] == top and c["이름"] in names and (c["갈래"] == "금액") == (c["이름"] == i) + ] + _machines(trace, calls) + keys: list[str] = [] + for c in calls: + keys += [x["키"] for x in c["자원"] if x["갈래"] != "표" and x["키"] not in keys] + return {**got, "부름": calls, "자원": keys} diff --git a/resources/tester/test_855_trace.py b/resources/tester/test_855_trace.py new file mode 100644 index 000000000..1be8cbb9e --- /dev/null +++ b/resources/tester/test_855_trace.py @@ -0,0 +1,170 @@ +"""855-F B9-1 지킴 — 문서 셈 기록(`master_doc_trace`) · 로직 전수 기본 입력. + +- 기록을 켜도 셈 답 같음(줄 `부름` · 답 `부름` `자원` 칸만 더해짐). +- 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 · + 찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 · + 빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음). +- 하위 부름 = 옛 `B09 line_calls`(돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력 + 기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님. +- 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원. +- 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴. +""" + +from __future__ import annotations + +import importlib +import json +from functools import lru_cache + +import helper_855_engine as h + +mt = importlib.import_module("master_doc_trace") +mp = importlib.import_module("master_pick") +mm = importlib.import_module("master_material") + +MORE = { # 새 쪽에만 더 있는 자원 키 — 까닭 + "GC001200": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", + "GC001201": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈", + "GF000312": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000313": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000320": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈", + "GF000192": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000200": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000203": "옛은 수량 빈 줄의 재료 단가를 안 읽음", + "GF000209": "옛은 수량 빈 줄의 재료 단가를 안 읽음", +} + + +def sg(): + from B09_Estimation import B09_Estimation_Sangeun as mod + + return mod + + +def mc_calc(doc: dict, links) -> dict: + return importlib.import_module("master_doc_calc").calc(doc, links) + + +def _old_keys(whole, row: dict, given: dict) -> set[str]: + seen: set[str] = set() + base = whole.get + + def get(ref): + got = base(ref) + key = str(got.get("키") or "") + if key[:2] in mt.CAT: + seen.add(key) + return got + + whole.get = get + try: + h.old_run(row, given) + finally: + del whole.get + return seen + + +def _strip(got: dict) -> dict: + out = {k: v for k, v in got.items() if k not in ("부름", "자원")} + if "줄" in out: + out["줄"] = [{k: v for k, v in ln.items() if k != "부름"} for ln in out["줄"]] + return out + + +def _calls(old: dict, new: dict, docs: dict) -> tuple[set, set]: + a = {json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) for v in old.values()} + b = set() + for c in new["부름"]: + if c["깊이"] != 1 or c["갈래"] != "단가산출": + continue + if (docs.get(str(c["부름"].get("키"))) or {}).get("결과"): + continue # 결과 문서 = 중간 값 + one = ( + {"machine": c["기계"]} + if "기계" in c + else {"code": c["부름"]["키"], "given": sg()._clean_given(c["부름"].get("입력"))} + ) + b.add(json.dumps(one, ensure_ascii=False, sort_keys=True, default=str)) + return a, b + + +@lru_cache(maxsize=1) +def survey() -> dict: + rows, whole, docs, links = h.world() + rows = [r for r in rows if str(r["키"]) in docs] + for row in rows: # 재료 찾기 색인 데움(첫 찾기 때 훑은 후보 읽음 빼려고) + h.old_run(row, h.cases(row, False)[0][1]) + trace = mt.Trace(whole, docs) + out = {"답 다름": [], "자원": {}, "하위": {}, "품목": [], "줄": [], "옛 빈 답": set()} + for row in rows: + key = str(row["키"]) + doc, given = docs[key], h.cases(row, False)[0][1] + old = _old_keys(whole, row, given) + got = mt.calc(doc, trace) + if _strip(got) != mc_calc(doc, links): + out["답 다름"].append(key) + new = set(got["자원"]) + if old != new: + out["자원"][key] = (sorted(old - new), sorted(new - old)) + lines = sg().line_calls(whole, key, given) + a, b = _calls(lines, got, docs) + if a != b: + out["하위"][key] = (sorted(a), sorted(b)) + if not lines: + try: + sg()._env(whole, row, sg()._clean_given(given)) + except Exception: + out["옛 빈 답"].add(key) + for c in got["부름"]: + p = c["부름"] + if c["깊이"] == 1 and "품목" in c and p.get("재료") is not None: + env = {mm.REGION: p["지역"]} if p.get("지역") is not None else {} + if p.get("계약종별") is not None: + env[mm.TARIFF] = p["계약종별"] + want = mp.priced(whole, {"단위": p.get("단위")}, p["재료"], env, None)[3] + if want.get("품목") and want["품목"]["키"] != c["품목"]: + out["품목"].append((key, c["이름"], want["품목"]["키"], c["품목"])) + for ln in got.get("줄") or []: + for i in ln["부름"]: + if not (0 <= i < len(got["부름"])) or got["부름"][i]["깊이"] != 1: + out["줄"].append((key, ln["이름"], i)) + return out + + +def test_기록_켜도_셈_답_같음(): + assert survey()["답 다름"] == [] + + +def test_자원_키_옛_가로채기와_같음_다름은_까닭_목록뿐(): + got = survey()["자원"] + assert all(not old for old, _ in got.values()), {k: v for k, v in got.items() if v[0]} + assert sorted(got) == sorted(MORE), sorted(got) + + +def test_하위_부름_옛_call_of_와_같음_다름은_옛_빈_답뿐(): + s = survey() + assert set(s["하위"]) == s["옛 빈 답"], { + k: s["하위"][k] for k in set(s["하위"]) - s["옛 빈 답"] + } + assert all(not old for old, _ in s["하위"].values()) + + +def test_고른_품목_줄_부름(): + s = survey() + assert s["품목"] == [] + assert s["줄"] == [] + + +def test_기계경비_부름_기계_키_줄마다_부름(): + _, whole, docs, _ = h.world() + got = mt.calc( + docs["GC000337"], mt.Trace(whole, docs) + ) # 낙석방지망 — 인력 둘 · 크레인 · 재료 셋 + lines = {ln["이름"]: [got["부름"][i] for i in ln["부름"]] for ln in got["줄"]} + crane = [c for c in lines["크레인"] if c["갈래"] == "단가산출"] + assert [c["부름"]["키"] for c in crane] == ["GC000268"] and crane[0]["기계"][:2] == "EQ" + assert {x["키"][:2] for c in lines["특별인부"] for x in c["자원"]} == {"LB", "QC"} + assert [c["품목"] for c in lines["에폭시"] if "품목" in c] == [got["자원"][-1]] + assert set(got["자원"]) >= { + x["키"] for c in got["부름"] for x in c["자원"] if x["갈래"] != "표" + }