From dd8759edc52b87d19dd0ba20bd6c7ff8be088b64 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 16:02:20 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-E=202-E4=20=E3=89=AF-4=20=E2=91=A5?= =?UTF-8?q?):=20=EC=98=9B=20=EA=B3=84=EC=82=B0=20=EC=97=94=EC=A7=84=20?= =?UTF-8?q?=EB=AA=B8=20=EC=A7=80=EC=9B=80=20=E2=80=94=20master=5Fformula?= =?UTF-8?q?=20=EB=AC=B4=EB=A6=AC=20=EC=95=84=ED=99=89=20=C2=B7=20=EA=B3=84?= =?UTF-8?q?=EC=82=B0=EA=B8=B0=20=ED=95=98=EB=82=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - git rm(부르는 곳 0 다시 셈 — import · import_module 글 · getattr 별칭 cm.mf · store.mau · mtx 포함): master_formula · master_formula_check · master_formula_sum · master_text · master_text_item · master_sheet_line · master_gate · master_auto · master_copy(−2,625 줄) - master_cut = down · row · sums 만(일위대가 반영 끝수 · TS 짝) — engine · settle · plain · _line · _sub · kept(손님 0) 지움 · 바탕 = master_base - master_bundle = BUNDLES · BY_ITEM · BY_KIND · is_machine(M01 목록 묶음) — called · bundle · tag 지움 · master_combo = 조합 칸만(run 지움) - check_master · check_master_body · compare_estx: import master_formula → master_base(바탕 이름만) · compare_estx 기계 · 일위대가 대조 = 수식 문서 셈(옛 mf.run · 로직 줄 고르기 덧붙임 걷음 · 일위대가 28 · 기계 207 건 그대로 나옴) - M01 Store: 다시 내보냄 mau · mtx 지움(부르는 곳 0) · cm.mf = master_base - 죽은 주석: master_material · master_pick · master_base · Item_Prices · San_Emit · check_master - test_855_sk_layers: 옛 엔진 안 돎 = 엔진 모듈 없음 확인 - 검증: 관련 146 파일 1,135 통과 · test_855_golden 전수 지문 같음 · 모든 제품 · scripts 모듈 읽기 깨짐 0 · typecheck 0 · 8008 health 200 · 로그 오류 0 · 서버 길 469 → 469 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Store.py | 2 - M02_MasterTemplete/M02_Item_Prices.py | 2 +- M02_MasterTemplete/M02_San_Emit.py | 4 +- resources/master_data/scripts/check_master.py | 4 +- .../master_data/scripts/check_master_body.py | 2 +- resources/master_data/scripts/compare_estx.py | 45 +- resources/master_data/scripts/master_auto.py | 152 ---- resources/master_data/scripts/master_base.py | 4 +- .../master_data/scripts/master_bundle.py | 40 +- resources/master_data/scripts/master_combo.py | 45 +- resources/master_data/scripts/master_copy.py | 435 ------------ resources/master_data/scripts/master_cut.py | 187 +---- .../master_data/scripts/master_formula.py | 525 -------------- .../scripts/master_formula_check.py | 237 ------- .../master_data/scripts/master_formula_sum.py | 278 -------- resources/master_data/scripts/master_gate.py | 90 --- .../master_data/scripts/master_material.py | 2 +- resources/master_data/scripts/master_pick.py | 4 +- .../master_data/scripts/master_sheet_line.py | 199 ------ resources/master_data/scripts/master_text.py | 671 ------------------ .../master_data/scripts/master_text_item.py | 38 - resources/tester/test_855_sk_layers.py | 13 +- 22 files changed, 48 insertions(+), 2931 deletions(-) delete mode 100644 resources/master_data/scripts/master_auto.py delete mode 100644 resources/master_data/scripts/master_copy.py delete mode 100644 resources/master_data/scripts/master_formula.py delete mode 100644 resources/master_data/scripts/master_formula_check.py delete mode 100644 resources/master_data/scripts/master_formula_sum.py delete mode 100644 resources/master_data/scripts/master_gate.py delete mode 100644 resources/master_data/scripts/master_sheet_line.py delete mode 100644 resources/master_data/scripts/master_text.py delete mode 100644 resources/master_data/scripts/master_text_item.py diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index 7423f4a70..f085cf80f 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -19,10 +19,8 @@ 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_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀) import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀) import master_keys as mk # noqa: E402 -import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀) from M01_MasterData import M01_MasterData_Store_Cache as cache # noqa: E402 from M01_MasterData.M01_MasterData_Store_Find import hit as _hit # noqa: E402 diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index f85130025..2e4b57915 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -10,7 +10,7 @@ 일위대가 자재(MT · 39-1c)도 그 줄(+ 준용 · 연결)을 담음. -`단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_formula.Master` 가 +`단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_base.Master` 가 그대로 읽는 꼴. 계산(`calc`)은 이 묶음과 `입력값.json` · `고른자재.json` · `면적.json`(알약 칸 값) 만 씀 — 마스터 현재값을 읽지 않음. 셈은 층 일위대가 셈 한 벌(`M02_Labor_Doc.calc` · 142-1 · 빈 입력 = 자동값). diff --git a/M02_MasterTemplete/M02_San_Emit.py b/M02_MasterTemplete/M02_San_Emit.py index c218fee94..c8bfd67ca 100644 --- a/M02_MasterTemplete/M02_San_Emit.py +++ b/M02_MasterTemplete/M02_San_Emit.py @@ -1,8 +1,8 @@ """경쟁사 산근 → 우리 엔진 로직 줄 꼴 내보내기(PLAN 793-2a · 요구서_652 · eval 없음). 793-1 줄 나무(`M02_San_Stmate`) → `{로직, 원본}`(EST = 원파일 · 엑셀 둘 다 `M02_Doc_NativeEst` · 812-1) — 꼴 = 793-2 가져온 식 SK -만들기 몸(`M02_Sangeun_Imported.py` 머리) · 로직 = `_틀.md` 7 장 꼴(셈 = `master_formula.run` → -`master_cut.engine` · `요소` 는 SK 서버가 채움). +만들기 몸(`M02_Sangeun_Imported.py` 머리) · 로직 = `_틀.md` 7 장 꼴(셈 = 불러온 그대로 수식 문서 · +`M02_Doc_Import` · `요소` 는 SK 서버가 채움). - 로직 = {이름, 결과단위, 입력 [], 중간 [{이름, 식, 표시?}], 호표, 덧줄 [{이름, 식, 비목, 번지?, 합밖?, 자리?}], 단계? [{이름, 단, 줄, 제외?}], 끝전, 조정?} · STmate 변수 = 식(다시 대입 = `이름_2`) · EST 변수 = 얼린 값 · EST 는 블록 성분을 낸 줄만 합 diff --git a/resources/master_data/scripts/check_master.py b/resources/master_data/scripts/check_master.py index 7c982b7e2..4ddca015f 100644 --- a/resources/master_data/scripts/check_master.py +++ b/resources/master_data/scripts/check_master.py @@ -31,7 +31,7 @@ import master_basis as mbs # noqa: E402 import master_combo as mcb # noqa: E402 import master_doc_block as mb # noqa: E402 import master_doc_link as ml # noqa: E402 -import master_formula as mf # noqa: E402 +import master_base as mf # noqa: E402 import master_keys as mk # noqa: E402 import master_machine_crew as mcrew # noqa: E402 import master_machine_files as mmf # noqa: E402 @@ -426,7 +426,7 @@ def check_docs(files: dict[str, dict], whole: mf.Master, book: dict | None = Non def duplicate_keys(files: dict[str, dict], book: dict | None = None) -> list[str]: """키 겹침(전체) · 원문번호 겹침(인력·재료 — 번호가 곧 그 줄의 이름) · 대장 대조. 표·로직·기계의 원문번호는 절 번호·분류번호라 한 절에 여럿이 겹쳐도 됨 - (겹친 번호를 「ID:원문번호」 로 부르면 `master_formula` 가 잡음).""" + (겹친 번호를 「ID:원문번호」 로 부르면 `master_base.Master` 가 잡음).""" book = mk.load_book() if book is None else book first, numbers, out = {}, {}, [] for name, data in files.items(): diff --git a/resources/master_data/scripts/check_master_body.py b/resources/master_data/scripts/check_master_body.py index a6bab790d..098443cd0 100644 --- a/resources/master_data/scripts/check_master_body.py +++ b/resources/master_data/scripts/check_master_body.py @@ -17,7 +17,7 @@ COST = ROOT / "resources/knowledge/original/원가계산" sys.path.insert(0, str(HERE)) sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline")) -import master_formula as mf # noqa: E402 +import master_base as mf # noqa: E402 from pum_md_tool import _NUM, md_lines # noqa: E402 DIVISIONS = { diff --git a/resources/master_data/scripts/compare_estx.py b/resources/master_data/scripts/compare_estx.py index 1e5414c3c..67d870dbd 100644 --- a/resources/master_data/scripts/compare_estx.py +++ b/resources/master_data/scripts/compare_estx.py @@ -17,7 +17,9 @@ from pathlib import Path sys.path.insert(0, str(Path(__file__).parent)) import check_master as cm # noqa: E402 -import master_formula as mf # noqa: E402 +import master_base as mf # noqa: E402 +import master_doc_calc as mc # noqa: E402 +import master_doc_link as ml # noqa: E402 ROOT = Path(__file__).resolve().parents[3] ESTX = ROOT / "resources/knowledge/original/경쟁사 프로그램/EST Plus 2/다산소프트/2026-07-main.estx" @@ -244,23 +246,19 @@ def mach_key(name, size) -> str: return norm(n) + "|" + size +def _names(doc: dict) -> set[str]: + return {str(v.get("열쇠")) for v in doc.get("변수") or []} + + def machine_cost(master: mf.Master, mid: str, region="전국평균"): - """로직으로 계산 — 고르기 밖 기계는 메모리에서만 고르기에 더함.""" + """수식 문서로 계산(옛 엔진 = 855-E 2-E4 걷음) — 목록 밖 기계도 원문번호로 받음.""" + docs = ml.load_all() + links = ml.Links(master, docs) for key in LOGICS: - row = master.logic(key) - spec = next(i for i in row["입력"] if i["이름"] == "기계") - added = mid not in spec["고르기"] - if added: - spec["고르기"].append(mid) - try: - given = {"기계": mid, "지역": region} - given = {k: v for k, v in given.items() if any(i["이름"] == k for i in row["입력"])} - return key, mf.run(master, key, given) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError): - continue - finally: - if added: - spec["고르기"].remove(mid) + given = {k: v for k, v in {"기계": mid, "지역": region}.items() if k in _names(docs[key])} + res = mc.calc(docs[key], links, given) + if res.get("셈됨"): + return key, res return None, None @@ -449,15 +447,16 @@ def unit_price(estx: Estx, master: mf.Master): h = heads[code] k = Decimal(scale[0]) if scale else Decimal(1) temp, put = with_estx_materials(master, estx, code) - row = temp.logic(key) - given = {k: v for k, v in given.items() if any(i["이름"] == k for i in row.get("입력", []))} + docs = ml.load_all() + row = docs[key] # 수식 문서(옛 엔진 = 855-E 2-E4 걷음) + given = {k: v for k, v in given.items() if k in _names(row)} given = {k: Decimal(str(v)) if isinstance(v, (int, float)) else v for k, v in given.items()} - try: - res = mf.run(temp, key, given) - res = {c: res[c] * k for c in ("계", *mf.COST_ITEMS)} - except (mf.FormulaError, ArithmeticError, KeyError, TypeError) as e: - print(f" {code} {h['Name']} {h.get('Size')} | {key} | 멈춤: {str(e)[:120]}") + res = mc.calc(row, ml.Links(temp, docs), given) + if not res.get("셈됨"): + why = res.get("까닭") or res.get("표지") + print(f" {code} {h['Name']} {h.get('Size')} | {key} | 멈춤: {str(why)[:120]}") continue + res = {c: res[c] * k for c in ("계", *mf.COST_ITEMS)} r = rate(h["TC"], res["계"]) rates.append(r) print( diff --git a/resources/master_data/scripts/master_auto.py b/resources/master_data/scripts/master_auto.py deleted file mode 100644 index a4499faaa..000000000 --- a/resources/master_data/scripts/master_auto.py +++ /dev/null @@ -1,152 +0,0 @@ -# -*- coding: utf-8 -*- -"""견본 입력 — 마스터 화면 보기용 자동값(프로젝트 기본값 아님 · 저장 안 함). - -고르기 = 목록 첫째 · 범위 = 최솟값 · 찾기 조건 값으로 쓰이는 수 = 그 표 그 칸 가장 낮은 줄 값 -(범위 줄이면 그 줄에 드는 아래 끝) · 나누는 자리에 오는 수 = 1 · 그 밖 0 -(「만약(X > 0, X, 기본)」 의 X 는 나누는 자리여도 0 = 기본). -찾기·나누기 쓰임은 로직 식(중간 · 결과 · 호표 수량·요소 · 덧줄)을 풀어 알아냄. -""" - -from __future__ import annotations - -import re -from decimal import Decimal - -import master_formula as mf - - -def _texts(row: dict): - for step in row.get("중간", []): - yield step["식"] - if "결과" in row: - yield row["결과"]["식"] - for item in row.get("호표", []): - yield item["수량"] - if isinstance(item.get("요소"), str): - yield item["요소"] - for extra in row.get("덧줄", []): - yield extra["식"] - - -def _names(node) -> set: - return {part[1] for part in mf.walk(node) if part[0] == "name"} - - -def _uses(row: dict) -> tuple[dict, set]: - """(찾기 조건 값으로 바로 쓰인 이름 → [(표, 조건)], 나누는 자리에 든 이름) - — 나누는 자리에 든 중간의 식에 쓰인 이름도 나누는 자리로 봄.""" - finds, divs = {}, set() - for text in _texts(row): - try: - node = mf.parse(text) - except mf.FormulaError: - continue - for part in mf.walk(node): - if part[0] == "bin" and part[1] == "/": - divs |= _names(part[3]) - if part[0] == "find": - for cond, arg in part[2]: - if arg[0] == "name": - finds.setdefault(arg[1], []).append((part[1], cond)) - guard = guards(row) # 「0 = 기본」 칸은 나누는 자리로 안 퍼뜨림(자동값 0 = 기본) - for step in reversed(row.get("중간", [])): - if step["이름"] in divs: - divs |= _names(mf.parse(step["식"])) - guard - return finds, divs - - -_GUARD = re.compile(r"만약\(\s*(\w+)\s*>\s*0\s*,\s*\1\s*,") - - -def guards(row: dict) -> set: - """「만약(X > 0, X, 기본)」 꼴 중간 식의 X — 0 이면 원문 기본(25㎏ · 450분 · 식 · 표).""" - return {m for s in row.get("중간", []) for m in _GUARD.findall(s["식"])} - - -def _fits(master: mf.Master, ref: str, cond: str) -> list: - """표 `ref` 조건 칸 `cond` 에 드는 수 — 낮은 차례 · 범위 칸이면 줄마다 그 줄에 드는 끝 - (아래 끝이 열린 줄 「60 미만」 은 0).""" - try: - table = master.get(ref) - except mf.FormulaError: - return [] - ranged = table.get("조건", {}).get(cond) == "범위" - out = set() - for r in table.get("줄", []): - if r.get(cond) is None: # 빈 조건 칸은 무엇이든 맞음 — 값을 정하지 않음 - continue - low, high = r[cond] if ranged else (r[cond], None) - ends = [Decimal(0) if low is None else low, high] - out |= {v for v in ends if isinstance(v, Decimal) and mf._match(table, r, cond, v)} - return sorted(out) - - -def _lowest(master: mf.Master, uses: list): - """찾기 여럿이 같은 입력을 쓰면 모든 표에 드는 가장 낮은 수 · 없으면 첫 표의 가장 낮은 수.""" - sets = [_fits(master, ref, cond) for ref, cond in uses] - both = sorted(set.intersection(*map(set, sets))) if sets else [] - return (both or next((s for s in sets if s), [None]))[0] - - -def _first_row(master: mf.Master, uses: list): - """찾기 조건 칸의 표 첫 줄 값 — 범위 줄이면 아래 끝(열린 아래 끝 = 위 끝) · 빈 칸 줄은 건넘.""" - for ref, cond in uses: - try: - rows = master.get(ref).get("줄", []) - except mf.FormulaError: - continue - for r in rows: - got = r.get(cond) - if isinstance(got, list): - got = next((v for v in got if v is not None), None) - if got is not None: - return got - return None - - -def _holds_zero(span) -> bool: - low, high = span[0], span[1] - return (low is None or Decimal(str(low)) <= 0) and (high is None or Decimal(str(high)) >= 0) - - -def defaults(master: mf.Master, row: dict) -> dict: - """「기본」 제안(PLAN 785-2 · 639-1a) — 「기본」 칸 › 고르기 첫째 › 가드 0 › 0 을 품은 범위 0 › - 찾기 조건 표 첫 줄 › None(못 정함 = 사용자 입력). 1 을 지어 넣지 않음 · `values` 와 따로.""" - specs = mf.inputs_of(row) if isinstance(row.get("흐름"), dict) else row.get("입력", []) - finds = {} if isinstance(row.get("흐름"), dict) else _uses(row)[0] - guard = guards(row) - out = {} - for spec in specs: - name, span = spec["이름"], spec.get("범위") - if spec.get("기본") not in (None, ""): - out[name] = spec["기본"] - elif spec.get("고르기"): - out[name] = spec["고르기"][0] - elif name in guard: - out[name] = Decimal(0) - elif span and _holds_zero(span): - out[name] = Decimal(0) - else: - out[name] = _first_row(master, finds.get(name, [])) - return out - - -def values(master: mf.Master, row: dict) -> dict: - """로직 줄 하나의 입력마다 자동값 · 흐름 로직은 「설계 때 정할 것」 예시값.""" - if isinstance(row.get("흐름"), dict): - return {s["이름"]: s.get("예시") for s in mf.inputs_of(row)} - finds, divs = _uses(row) - out = {} - for spec in row.get("입력", []): - name = spec["이름"] - if spec.get("고르기"): - out[name] = spec["고르기"][0] - elif spec.get("범위"): - out[name] = spec["범위"][0] - else: - got = _lowest(master, finds.get(name, [])) - if got is None and "원" in str(spec.get("단위") or ""): - out[name] = None # 가격 입력 — 0 원처럼 보이지 않게 비워 둠 - else: - out[name] = got if got is not None else Decimal(1 if name in divs else 0) - return out diff --git a/resources/master_data/scripts/master_base.py b/resources/master_data/scripts/master_base.py index 0054acdf9..d35a96c34 100644 --- a/resources/master_data/scripts/master_base.py +++ b/resources/master_data/scripts/master_base.py @@ -1,8 +1,8 @@ # -*- coding: utf-8 -*- """마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음. -옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀. -`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음). +수식 문서 계산기(`master_doc_*`) · 불러오기 · 서고 · M01 · M02 가 같이 씀(옛 엔진 `master_formula` 는 +855-E 2-E4 에서 지움 — 이 이름들의 자리). """ from __future__ import annotations diff --git a/resources/master_data/scripts/master_bundle.py b/resources/master_data/scripts/master_bundle.py index 282e813cc..e5d3dd8e0 100644 --- a/resources/master_data/scripts/master_bundle.py +++ b/resources/master_data/scripts/master_bundle.py @@ -3,20 +3,15 @@ 규칙 한 줄: - 호표 · 덧줄 = `비목` 따라(노무비 → 인력 · 재료비 → 재료 · 경비 → 경비). -- 비목 없는 로직 줄 = 부르는 로직이 기계경비(`is_machine`)면 경비 + `장비` · 아니면 하위. - 두 줄 모두 엔진 줄 `비목` 에 노무비 · 재료비 · 경비 세 몫이 그대로 남음(한 줄 · 흩어 넣기 둘 다). +- 부르는 문서가 기계경비(`is_machine`)면 경비 · 아니면 하위(M01 목록 묶음 셈 `M01_MasterData_Store_List`). -기계경비 판별 = `is_machine` 한 곳 — M01 엔진 · M02 엑셀 맞춤(`M02_Hopyo_Ours`) · -B09 산근(`B09_Estimation_Sangeun` · `_Text`)이 같이 씀. -엔진 줄 덧칸 = `묶음`(출력 꼬리표만 · 입력 값 덧칸 `값묶음` 은 715-1b 몫) · 기계경비 줄 `장비` true. +기계경비 판별 = `is_machine` 한 곳. 옛 엔진 줄 꼬리표(`called` · `bundle` · `tag`)는 855-E 2-E4 에서 걷음. """ from __future__ import annotations import re -import master_formula as mf - BUNDLES = ("인력", "재료", "경비", "하위") BY_ITEM = {"노무비": "인력", "재료비": "재료", "경비": "경비"} BY_KIND = {"인력": "인력", "재료": "재료", "기계": "경비"} # 비목 빈 옛 줄 받침 @@ -27,34 +22,3 @@ def is_machine(row: dict | None) -> bool: if not row or "결과" in row or isinstance(row.get("흐름"), dict): return False return re.sub(r"\s", "", str(row.get("결과단위") or "")) == "원/시간" - - -def called(master, item: dict, env: dict | None = None) -> dict | None: - """로직 줄이 부르는 로직 줄(정본) — 못 찾으면 None.""" - try: - node = mf.parse(item.get("요소") or "") - if not node or node[0] != "logic": - return None - key = mf.fill(node[1], env) if env is not None and "{" in node[1] else node[1] - return master.logic(key) - except (mf.FormulaError, mf.EmptyInput, KeyError, TypeError): - return None - - -def bundle(master, item: dict, env: dict | None = None) -> tuple[str, bool]: - """줄 하나(호표 · 덧줄 정본 줄) → (묶음, 장비인가).""" - if item.get("비목") in BY_ITEM: - return BY_ITEM[item["비목"]], False - if item.get("종류") == "로직": - return ("경비", True) if is_machine(called(master, item, env)) else ("하위", False) - return BY_KIND.get(str(item.get("종류")), "하위"), False - - -def tag(master, row: dict, lines: list[dict], env: dict | None = None) -> list[dict]: - """엔진 `run` 줄에 `묶음`(+ 기계경비 줄 `장비`) — 줄 차례 = 호표 줄 하나씩 뒤 덧줄 하나씩.""" - for item, line in zip([*row.get("호표", []), *row.get("덧줄", [])], lines): - name, machine = bundle(master, item, env) - line["묶음"] = name - if machine: - line["장비"] = True - return lines diff --git a/resources/master_data/scripts/master_combo.py b/resources/master_data/scripts/master_combo.py index b9af86242..afd81efa7 100644 --- a/resources/master_data/scripts/master_combo.py +++ b/resources/master_data/scripts/master_combo.py @@ -2,16 +2,11 @@ """일위대가 조합 — 단가산출 로직을 골라 담은 묶음 (`_틀.md` 10장 · 계약 `_화면_계약.md` 9장). 조합은 **담은 로직 목록만** 지님 — 수량 · 비율 · 계산은 두지 않음(프로젝트 몫). -미리 보기(`run`)는 담은 로직마다 그 자리에서 받은 입력값으로 값을 뽑아 -비목별로 갈라 합침 — 저장하지 않음. +옛 엔진 미리 보기(`run`)는 855-E 2-E4 에서 걷음. """ from __future__ import annotations -from decimal import Decimal - -import master_formula as mf - GROUP = "일위대가조합" FILE = "일위대가조합.json" TID = "UA" @@ -63,41 +58,3 @@ def using(files: dict[str, dict], key: str) -> list[dict]: # ── 미리 보기 ───────────────────────────────────────────────────────── -def run(master: mf.Master, row: dict, given: dict[str, dict] | None = None) -> dict: - """담은 로직마다 그 자리의 입력값으로 값을 뽑아 비목별로 갈라 합침 — 저장하지 않음. - - `given` = {로직 키: {입력 이름: 값}} · 못 도는 줄은 까닭을 적고 합계에서 뺌(통째로 멈추지 않음). - 돈이 아닌 로직(결과 수 하나)은 비목이 없어 합계에 얹지 않고 결과만 보임. - """ - given = given or {} - sums = dict.fromkeys(mf.COST_ITEMS, Decimal(0)) - lines, stuck = [], [] - for at, one in enumerate(items(row), start=1): - key = str(one.get("로직") or "") if isinstance(one, dict) else "" - head = {"차례": at, "로직": key, "메모": one.get("메모") if isinstance(one, dict) else None} - try: - target = master.logic(key) - except mf.FormulaError as e: - lines.append({**head, "ok": False, "까닭": str(e)}) - stuck.append(f"{key} · {e}") - continue - head.update( - {k: target.get(k) for k in ("이름", "원문번호", "결과단위", "구분", "상세구분", "출처")} - ) - try: - import master_cut as mcut # 끝수(751-3) = 시험 계산(`check_master.calc`)과 같음 - - got = mcut.engine(master, key, mf.run(master, key, dict(given.get(key) or {}))) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: - reason = str(e) or type(e).__name__ - lines.append({**head, "ok": False, "까닭": reason}) - stuck.append(f"{key} {target.get('이름')} · {reason}") - continue - if "결과" in got: # 돈 아닌 로직 — 비목이 없어 합계에 안 얹음 - lines.append({**head, "ok": True, "갈래": "결과", "결과": got["결과"]}) - continue - part = {k: got[k] for k in mf.COST_ITEMS} - for k, v in part.items(): - sums[k] += v - lines.append({**head, "ok": True, "갈래": "돈", **part, "계": got["계"]}) - return {"줄": lines, **sums, "계": sum(sums.values()), "멈춤": stuck} diff --git a/resources/master_data/scripts/master_copy.py b/resources/master_data/scripts/master_copy.py deleted file mode 100644 index cf9148ed9..000000000 --- a/resources/master_data/scripts/master_copy.py +++ /dev/null @@ -1,435 +0,0 @@ -# -*- coding: utf-8 -*- -"""정본 로직을 식 줄로 펴 보이고, 고친 식을 되돌려 자체 로직으로 저장 (PLAN 3-4). - -규칙은 `resources/master_data/ref/_설계_식_복사.md` 그대로 — -`찾기(…)`·`로직(…)` 부르기 한 덩이를 이름 하나(별칭)로 바꿔 보이고 뒤에 원문을 둠. -별칭은 저장하지 않음(겉치레) — 되돌릴 때 별칭표의 원문으로 갈아 끼워 원래 식이 됨. -식 자르기는 `master_formula` 파서를 그대로 씀 — 정규식으로 괄호를 세지 않음. -""" - -from __future__ import annotations - -import copy -import re - -import master_formula as mf - -MAX_NAME = 12 # 짧은 이름의 길이 상한 -MAX_WORD = 8 # 별칭 꼬리(찾은 줄 값) 한 낱말의 길이 상한 -_DROP = re.compile(r"[^\w]", re.UNICODE) # 별칭에 못 쓰는 글자(빈칸 · 괄호 · 가운뎃점 …) -_SPACE = re.compile(r"\s+") -_PAREN = re.compile(r"\([^()]*\)") -_WORDS = re.compile(r"[\s·・,/:+×*~∼]+") -_QUOTED = re.compile(r"'[^']*'") -RESERVED = frozenset((*mf.FUNCS, *mf.COST_ITEMS, "찾기", "로직", "그리고", "또는", "계", "줄")) - - -# ── 부르기 자리 자르기 ───────────────────────────────────────────────── -class _Catch(mf._Parser): - """식을 읽으면서 `찾기(…)`·`로직(…)` 한 덩이의 자리를 적어 둠(겹친 것 포함).""" - - def __init__(self, text: str): - super().__init__(text) - self.spots: list[tuple[int, int, str, str]] = [] - - def primary(self): - self.ws() - at = self.i - node = super().primary() - if node[0] in ("find", "logic"): - self.spots.append((at, self.i, node[0], node[1])) - return node - - -def spots(text: str) -> list[tuple[int, int, str, str]]: - """식 글 안 부르기 한 덩이 — (처음, 끝, 종류, 참조). - - 겹친 것은 바깥만 · 못 읽는 글은 빈 목록. - """ - try: - found = _Catch(str(text)) - found.parse() - except (mf.FormulaError, RecursionError): - return [] - out = [ - one - for one in found.spots - if not any(o[0] <= one[0] and one[1] <= o[1] and o[:2] != one[:2] for o in found.spots) - ] - return sorted(out) - - -def _holes(text: str) -> list[tuple[int, int]]: - """별칭을 갈아 끼우면 안 되는 자리 — 이미 원문으로 적힌 부르기 안 · 작은따옴표 안.""" - return [(s, e) for s, e, _, _ in spots(text)] + [ - (m.start(), m.end()) for m in _QUOTED.finditer(text) - ] - - -# ── 식이 든 자리 ─────────────────────────────────────────────────────── -def slots(row: dict): - """(자리표, 갈래, 차례, 칸 이름, 그 칸을 담은 묶음) — 번호 매기는 차례(호표 → 중간 → 덧줄).""" - for i, one in enumerate(row.get("호표") or []): - for col in ("수량", "요소"): - if isinstance(one.get(col), str): - yield f"호표[{i}].{col}", "호표", i, col, one - for i, one in enumerate(row.get("중간") or []): - if isinstance(one.get("식"), str): - yield f"중간[{i}].식", "중간", i, "식", one - for i, one in enumerate(row.get("덧줄") or []): - if isinstance(one.get("식"), str): - yield f"덧줄[{i}].식", "덧줄", i, "식", one - end = row.get("결과") - if isinstance(end, dict) and isinstance(end.get("식"), str): - yield "결과.식", "결과", 0, "식", end - - -def _taken(row: dict) -> set[str]: - """이미 식에서 쓰는 이름 — 입력 · 중간 · 덧줄 · 비목 · 함수 이름.""" - out = set(RESERVED) - for part in ("입력", "중간", "덧줄"): - for one in row.get(part) or []: - name = str(one.get("이름") or "") - if name: - out.add(name) - return out - - -# ── 별칭 짓기 ───────────────────────────────────────────────────────── -def plain(text) -> str: - """이름에 쓸 수 있는 글자만 남김 — 별칭과 변수 이름이 같은 규칙을 씀.""" - return _DROP.sub("", str(text or "")) - - -def _unparen(text: str, keep: bool) -> str: - """괄호 묶음을 벗김 — `keep` 이면 숫자 없는 묶음(공기식 · 건설)만 글로 남김.""" - while True: - got = _PAREN.sub( - lambda m: f" {m.group()[1:-1]} " if keep and not re.search(r"\d", m.group()) else " ", - text, - ) - if got == text: - return got - text = got - - -def _core(text: str) -> list[str]: - """앞 핵심 낱말 — 머리 번호(1급 · 5-3)는 건너뛰고, 그 뒤 숫자 든 낱말(규격)에서 끊음.""" - out: list[str] = [] - for word in _WORDS.split(text): - word = plain(word) - if not word: - continue - if re.search(r"\d", word): - if out: - break - continue - out.append(word) - return out - - -def _fit(words: list[str], cap: int) -> str: - """낱말들을 이어 이름 하나로 — 길면 첫 낱말 + 끝 낱말 · 그래도 길면 첫 낱말을 자름.""" - tries = ["".join(words), *([words[0] + words[-1], words[0][:cap]] if words else [])] - return next((one for one in tries if one and len(one) <= cap), "") - - -def short(text, cap: int = MAX_NAME) -> str: - """사람이 읽는 짧은 이름 — 규격·코드를 떼고, 길면 괄호 속 · 가운데 낱말 순으로 버림. - 늘 같은 글이면 같은 이름 · 글자 · 숫자 · 밑줄만 · 숫자로 시작하지 않음(못 지으면 빈 글).""" - text = str(text or "") - kept = "".join(_core(_unparen(text, True))) - return kept if kept and len(kept) <= cap else _fit(_core(_unparen(text, False)), cap) - - -def _base(ref: str, master) -> str: - """별칭 밑이름 — 표·로직 이름을 짧게 · 이름이 없으면 공종 · 상세구분 · 그래도 없으면 키.""" - try: - row = master.get(ref) - except mf.FormulaError: - row = {} - use = row.get("용도") if isinstance(row.get("용도"), dict) else {} - for text in (row.get("이름"), use.get("공종"), row.get("상세구분")): - got = short(text) - if got: - return got - return _DROP.sub("", ref) or "표" - - -def _words(node, master) -> list[str]: - """부르기 인자 하나의 낱말 — 글은 그 값(요소 코드면 품명 + 규격) · 수 · 이름은 그대로.""" - kind = node[0] - if kind == "name": - return [node[1]] - if kind == "num": - return [plain(node[1])] - if kind != "str": # 만약(…) 따위 — 안에 적힌 글 가운데 처음 읽히는 것 - return next(filter(None, (_core(_unparen(one, False)) for one in _texts(node))), []) - for ref in (node[1], f"EQ:{node[1]}"): # 기계 입력은 원문번호(0201-0020) - try: - row = master.get(ref) - except mf.FormulaError: - continue - if row.get("이름"): - return [short(row["이름"]), *filter(None, [plain(row.get("규격"))])] - return _core(_unparen(str(node[1]), False)) or [plain(node[1])] - - -def _texts(node): - """마디 안의 글 값(작은따옴표) — 적힌 차례로.""" - if isinstance(node, tuple) and node[:1] == ("str",): - yield str(node[1]) - elif isinstance(node, (tuple, list)): - for one in node: - yield from _texts(one) - - -def _columns(signs: list[str], refs: list[str], master) -> list[dict[str, str]]: - """부르기마다 {칸: 꼬리 낱말} — 다른 표가 섞이면 표 제목도 한 칸(`""`). - 한 칸 값들이 모두 가진 낱말(`구체콘크리트`)은 떼어 서로 가르는 낱말만 남김.""" - rows: list[dict[str, list[str]]] = [{} for _ in signs] - if len(set(refs)) > 1: - for one, ref in zip(rows, refs): - try: - one[""] = _core(_unparen(str(master.get(ref).get("이름") or ""), False)) - except mf.FormulaError: - one[""] = [] - for one, sign in zip(rows, signs): - try: - args = mf.parse(sign)[2] - except (mf.FormulaError, IndexError, TypeError): - args = [] - one.update({key: _words(value, master) for key, value in args}) - out: list[dict[str, str]] = [{} for _ in signs] - for key in dict.fromkeys(key for one in rows for key in one): - lists = [one.get(key, []) for one in rows] - common = set.intersection(*map(set, lists)) - if not all(set(words) - common for words in lists): - common = set() - for got, words in zip(out, lists): - got[key] = _fit([w for w in words if w not in common], MAX_WORD) - return out - - -def _tails(signs: list[str], refs: list[str], master) -> list[str]: - """같은 밑이름의 부르기들 — 서로 가르는 인자 값만 이어 꼬리로(`철망` · `외업_고급기술자`). - 가르는 칸은 적게 — 가장 잘 가르는 칸부터 모두 갈릴 때까지 고르고, 줄마다 없어도 되는 칸은 뺌.""" - cols = _columns(signs, refs, master) - order = list(dict.fromkeys(key for one in cols for key in one)) - - def seen(one: dict, keys: list[str]) -> tuple: - return tuple(one.get(key, "") for key in keys) - - picked: list[str] = [] - left = list(order) - while len({seen(one, picked) for one in cols}) < len(cols) and left: - best = max(left, key=lambda key: len({seen(one, [*picked, key]) for one in cols})) - if len({seen(one, [*picked, best]) for one in cols}) == len( - {seen(o, picked) for o in cols} - ): - break - picked.append(best) - left.remove(best) - out = [] - for at, one in enumerate(cols): - mine = list(picked) - for key in reversed(picked): # 늦게 고른(덜 가르는) 칸부터 빼 봄 - rest = [k for k in mine if k != key] - others = (seen(o, rest) for j, o in enumerate(cols) if j != at) - if not rest or seen(one, rest) in set(others): - break - mine = rest - out.append("_".join(filter(None, seen(one, sorted(mine, key=order.index))))) - return out - - -def _free(want: str, taken: set[str]) -> str: - name, at = want, 1 - while name in taken: - at += 1 - name = f"{want}_{at}" - taken.add(name) - return name - - -def aliases(row: dict, master) -> list[dict]: - """부르기마다 별칭 하나 — 완전히 같은 부르기는 합치고, 갈리면 등장 차례로 번호.""" - order: list[str] = [] - seen: dict[str, tuple[str, str]] = {} # 서명 → (종류, 참조) - raw_of: dict[str, str] = {} # 서명 → 원문(처음 나온 글 그대로) - where_of: dict[str, list[str]] = {} - for where, _, _, col, box in slots(row): - text = box[col] - for start, end, kind, ref in spots(text): - raw = text[start:end] - sign = _SPACE.sub(" ", raw) - if sign not in seen: - order.append(sign) - seen[sign] = (kind, ref) - raw_of[sign] = raw - where_of.setdefault(sign, []).append(where) - - bunch: dict[str, list[str]] = {} - for sign in order: - bunch.setdefault(_base(seen[sign][1], master), []).append(sign) - taken, name_of = _taken(row), {} - for kind, ref in seen.values(): # 표의 값 칸 이름과 헷갈리지 않게 - if kind == "find": - taken |= set(_about(kind, ref, master)["값칸"]) - for base, signs in bunch.items(): - gap = "_" if base[-1:].isdigit() else "" # 키를 밑이름으로 쓴 자리 — 번호가 붙지 않게 - tails = _tails(signs, [seen[s][1] for s in signs], master) if len(signs) > 1 else [""] - for at, (sign, tail) in enumerate(zip(signs, tails)): - alone = len(signs) == 1 or any(tails) # 꼬리 없는 하나는 밑이름만 - want = f"{base}_{tail}" if tail else base if alone else f"{base}{gap}{at + 1}" - name_of[sign] = _free(want, taken) - - out = [] - for sign in order: - kind, ref = seen[sign] - out.append( - { - "이름": name_of[sign], - "종류": "찾기" if kind == "find" else "로직", - "참조": ref, - "원문": raw_of[sign], - **_about(kind, ref, master), - "자리": where_of[sign], - } - ) - return out - - -def _about(kind: str, ref: str, master) -> dict: - """모달에 보일 한 마디 — 표는 표 이름과 값 칸 · 로직은 로직 이름과 결과 단위.""" - try: - row = master.get(ref) - except mf.FormulaError: - return {"밑이름": "", "값칸": {}, "결과단위": ""} - if kind == "find": - return {"밑이름": row.get("이름") or "", "값칸": row.get("값칸") or {}, "결과단위": ""} - return {"밑이름": row.get("이름") or "", "값칸": {}, "결과단위": row.get("결과단위") or ""} - - -# ── 펴기 · 되돌리기 ──────────────────────────────────────────────────── -def names(marks: list[dict]) -> dict[str, str]: - """별칭 목록 → {원문 서명: 별칭 이름} — 식 글을 별칭으로 갈아 끼울 때 씀.""" - return {_SPACE.sub(" ", str(one["원문"])): str(one["이름"]) for one in marks} - - -def mask(text, name_of: dict[str, str]) -> str: - """부르기 한 덩이를 별칭 이름으로 — `spread` 와 같은 규칙(다른 모듈도 씀).""" - return _mask(str(text), name_of) - - -def _mask(text: str, name_of: dict[str, str]) -> str: - """부르기 한 덩이를 별칭 이름으로 — 뒤에서부터 갈아 끼움(자리가 밀리지 않게).""" - out = text - for start, end, _, _ in reversed(spots(text)): - name = name_of.get(_SPACE.sub(" ", text[start:end])) - if name: - out = out[:start] + name + out[end:] - return out - - -def _glued(text: str, m: re.Match) -> bool: - """앞뒤가 낱말 글자면 다른 이름의 한 토막 · 점 뒤면 표의 값 칸 이름 — 갈아 끼우지 않음.""" - side = text[m.start() - 1 : m.start()] + text[m.end() : m.end() + 1] - return any(ch.isalnum() or ch == "_" for ch in side) or text[: m.start()].rstrip().endswith(".") - - -def _unmask(text: str, raw_of: dict[str, str]) -> str: - """별칭 이름을 원문 부르기로 — 이미 원문인 부르기 안과 따옴표 안은 안 건드림.""" - if not raw_of: - return text - holes = _holes(text) - catch = re.compile("|".join(re.escape(n) for n in sorted(raw_of, key=len, reverse=True))) - out, at = [], 0 - for m in catch.finditer(text): - if any(s <= m.start() and m.end() <= e for s, e in holes) or _glued(text, m): - continue - out.append(text[at : m.start()]) - out.append(raw_of[m.group()]) - at = m.end() - out.append(text[at:]) - return "".join(out) - - -def spread(master, row: dict) -> dict: - """로직 한 줄 → 별칭 꼴 식 묶음. `로직` = 식만 별칭으로 바뀐 줄 통째 · `별칭` 에 원문.""" - marks = aliases(row, master) - name_of = names(marks) - shown = copy.deepcopy(row) - for _, _, _, col, box in slots(shown): - box[col] = _mask(box[col], name_of) - return {"로직": shown, "별칭": marks, "줄": lines(shown)} - - -def lines(row: dict) -> list[dict]: - """화면에 쌓을 식 줄 — 읽는 차례(중간 → 호표 → 덧줄 → 결과).""" - out = [] - for i, one in enumerate(row.get("중간") or []): - out.append(_line(f"중간[{i}].식", "중간", i, one, one.get("식"))) - for i, one in enumerate(row.get("호표") or []): - got = _line(f"호표[{i}].수량", "호표", i, one, one.get("수량")) - out.append({**got, "종류": one.get("종류") or "", "요소": one.get("요소")}) - for i, one in enumerate(row.get("덧줄") or []): - out.append(_line(f"덧줄[{i}].식", "덧줄", i, one, one.get("식"))) - end = row.get("결과") - if isinstance(end, dict): - out.append(_line("결과.식", "결과", 0, end, end.get("식"))) - return out - - -def _line(where: str, kind: str, at: int, one: dict, text) -> dict: - return { - "자리": where, - "갈래": kind, - "차례": at, - "이름": one.get("이름") or "", - "단위": one.get("단위") or "", - "비목": one.get("비목") or "", - "식": text, - "출처": one.get("출처") or "", - } - - -def gather(shown: dict, marks: list[dict]) -> dict: - """별칭 꼴 식 묶음 → 저장할 로직 한 줄. 별칭 원문은 부르기 하나여야 함(아무 글이나 못 넣음). - - 사용자가 편집 중 별칭과 같은 이름의 입력·중간·덧줄을 새로 만들면(예: `메쌓기인력 = 1`) - 그 뒤로는 식 글 속 그 이름이 사용자 것인지 별칭인지 가릴 수 없음(둘 다 같은 토큰) — - 자동으로 별칭 쪽만 다시 이름 지어 피하려 하면 사용자가 실제로 쓴 자리를 건드릴 위험이 - 있어(화면 개입 없이는 안전하게 못 가림) 조용히 바꾸지 않고 저장을 막음. - """ - raw_of: dict[str, str] = {} - taken = _taken(shown) # 지금 입력·중간·덧줄에 실제로 있는 이름(사용자 것이 우선) - for one in marks or []: - name, raw = str(one.get("이름") or ""), str(one.get("원문") or "") - if not name or not raw: - raise mf.FormulaError("별칭에 「이름」 과 「원문」 이 있어야 함") - if mf.parse(raw)[0] not in ("find", "logic"): - raise mf.FormulaError(f"별칭 「{name}」 의 원문이 찾기·로직 부르기가 아님 — 「{raw}」") - if name in raw_of and raw_of[name] != raw: - raise mf.FormulaError(f"별칭 「{name}」 이 두 가지 원문을 가리킴") - if name in taken: - raise mf.FormulaError( - f"「{name}」 을 입력·중간·덧줄 이름으로도 쓰고 별칭으로도 씀 — " - "어느 쪽 식이 그 이름을 가리키는지 가릴 수 없음 · 이름을 바꿀 것" - ) - raw_of[name] = raw - out = copy.deepcopy(shown) - for _, _, _, col, box in slots(out): - box[col] = _unmask(box[col], raw_of) - return out - - -def check(master, row: dict) -> list[str]: - """펴고 그대로 되돌리면 원래 식으로 돌아오는지 — 어긋난 자리 글 목록(비면 됨).""" - view = spread(master, row) - again = gather(view["로직"], view["별칭"]) - out = [] - for (where, _, _, col, box), (_, _, _, _, was) in zip(slots(again), slots(row)): - if box[col] != was[col]: - out.append(f"{row.get('키')} {where} — 「{was[col]}」 → 「{box[col]}」") - return out diff --git a/resources/master_data/scripts/master_cut.py b/resources/master_data/scripts/master_cut.py index 1dcf5c670..b776ffb44 100644 --- a/resources/master_data/scripts/master_cut.py +++ b/resources/master_data/scripts/master_cut.py @@ -3,16 +3,11 @@ (일위대가 금액란 0.1 원 · 계금 1 원 · 미만버림). 규칙 = B09 일위대가 · 산근과 같은 함수 `rounddown`(`B09_Estimation_Calc_Base` · 엑셀 ROUNDDOWN): - 줄 금액 = 비목마다 ROUNDDOWN(·, 1) · 금액 = 그 합 - 하위 로직 줄(값묶음 없음) = 하위 로직도 같은 끝수로 다시 셈한 노 · 재 · 경 × 수량 - 덧줄 = 버린 줄 합(노무비 · 재료비 · 경비 · `줄.'이름'`)으로 식을 다시 셈 → ROUNDDOWN 1 - 비목 합 = ROUNDDOWN(Σ 줄, 0)(+ 로직 `끝수` 묶음) · 계 = 셋 합 -엔진 줄 덧칸(단위 · 수량 · 단가 · 출처 · 까닭 · 묶음 · 옵션꺼짐 …) · 수량 · 품 자리는 그대로. -쓰는 곳 = M01 시험 계산(`check_master.calc`) · 읽는 식(`master_text.lines`) · M02 로직 줄 -(`M02_Labor_Doc.run_line` — 단가산출 · 일위대가 · 펼침이 모두 거침) · 일위대가 반영(`row` · `sums` · -TS 짝 `M02_MasterTemplete_Labor_Calc.ts` · 거울 시험 `test_m02_labor_calc_mirror.py`). -B09 는 제 단가로 다시 버리므로 엔진 날 값(`run_line(raw=True)`)을 받음. -ponytail: 흐름 로직 · 돈 결과 로직(결과 하나)은 끝수 없음 — 그 로직이 돈을 내면 여기에 더함. + 반영 한 줄 = 비목마다 ROUNDDOWN(·, 1) · 계 = 셋 합 · 비목 합 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합. +쓰는 곳 = 일위대가 반영(`M02_Labor_Doc` · `M02_Labor_Fixed` · `M02_Labor_Expand` · TS 짝 +`M02_MasterTemplete_Labor_Calc.ts` · 거울 시험 `test_m02_labor_calc_mirror.py`). +옛 엔진 답 끝수(`engine` · `settle` · `plain` · 줄 `자리`)는 855-E 2-E4 에서 걷음 — 단가산출 끝수 = 수식 문서 +계산기(`master_doc_calc`). """ from __future__ import annotations @@ -21,16 +16,14 @@ import sys from decimal import Decimal from pathlib import Path -import master_formula as mf -import master_formula_sum as ms +import master_base as mb _ROOT = str(Path(__file__).resolve().parents[3]) if _ROOT not in sys.path: # 스크립트 · 시험 길 — 서버는 이미 뿌리에서 돎 sys.path.insert(0, _ROOT) from B09_Estimation.B09_Estimation_Calc_Base import rounddown # noqa: E402 -COSTS = mf.COST_ITEMS -_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) +COSTS = mb.COST_ITEMS def down(value, places: int): @@ -40,49 +33,6 @@ def down(value, places: int): return Decimal(str(rounddown(float(value), places))) -def _line(value, rule: dict | None): - """줄 값 끝수 — 줄 `자리` {방법, 자리}(791-1) · 없으면 0.1 원 버림.""" - if value is None or not rule: - return down(value, 1) - way, places = rule.get("방법"), int(rule.get("자리") or 0) - if way == "버림": - return down(value, places) - return mf._round(Decimal(str(value)), places, mf.ROUND_WAYS[way]) - - -def _host(items: list[dict], n: int) -> int | None: - """부착 호표(848-4 · `부착: true`) → 같은 묶음 앞쪽 주 기계 로직 줄 차례 · 아님 = None.""" - item = items[n] if n < len(items) else {} - if not item.get("부착"): - return None - for j in range(n - 1, -1, -1): - x = items[j] - if not x.get("부착") and x.get("묶음") == item.get("묶음") and x.get("종류") == "로직": - return j - return None - - -def _joined(split: dict, rule, held: tuple) -> tuple[dict, Decimal | None]: - """부착 줄 끝수 = 묶음 한 덩이(주 기계 줄 + 이 줄) 끝수 − 주 기계 줄 끝수(848-4 · 계산기와 같음).""" - h, h_rule = held - zero = Decimal(0) - cut = { - k: None - if v is None - else _line((h.get(k) or zero) + v, rule) - _line(h.get(k) or zero, h_rule) - for k, v in split.items() - } - kept = [v for v in cut.values() if v is not None] - return cut, (sum(kept, zero) if kept else None) - - -def _parts(split: dict, rule: dict | None = None) -> tuple[dict, Decimal | None]: - """줄 비목 → (비목마다 0.1 원 버림 · 줄 `자리` 면 그것, 금액 = 그 합 · 모두 빈 = None).""" - cut = {k: _line(v, rule) for k, v in split.items()} - kept = [v for v in cut.values() if v is not None] - return cut, (sum(kept, Decimal(0)) if kept else None) - - def row(money: dict | None) -> dict | None: """반영 한 줄 `{노무비, 재료비, 경비, 계}` — 비목마다 0.1 원 버림 · 계 = 셋 합.""" if money is None: @@ -95,126 +45,3 @@ def sums(rows: list) -> dict: """비목 합 — 비목마다 ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합(빈 줄 = 뺌).""" cut = {k: down(sum((Decimal(str(r[k])) for r in rows if r), Decimal(0)), 0) for k in COSTS} return {**cut, "계": sum(cut.values(), Decimal(0))} - - -def _sub(master, item: dict, env: dict, depth: int) -> dict | None: - """하위 로직 줄 노 · 재 · 경 — 같은 끝수로 다시 셈 · 로직 부르기가 아니거나 못 셈 = None.""" - if item.get("값묶음") is not None or item.get("종류") != "로직": - return None - try: - node = mf.parse(item["요소"]) - if node[0] != "logic": - return None - given = {k: mf.evaluate(v, env, master, depth) for k, v in node[2]} - ref = mf.fill(node[1], env) - got = engine(master, ref, mf.run(master, ref, given, depth + 1), depth + 1) - except _ERRORS: - return None - return None if "결과" in got else got - - -def engine(master, ref: str, got: dict, depth: int = 0) -> dict: - """엔진 답(`mf.run` 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}`) → 끝수 입힌 답(새 묶음).""" - if "결과" in got or "줄" not in got: - return got - logic = master.logic(ref) - if isinstance(logic.get("흐름"), dict): - return got - items, adds = logic.get("호표") or [], logic.get("덧줄") or [] - rules = [x.get("자리") for x in (*items, *adds)] # 줄 자리(791-1) - new = ms.uses(logic) - skip = ms.skipped(logic) if new else set() - env = dict(got.get("중간") or {}) - total = dict.fromkeys(COSTS, Decimal(0)) - lines, raws = [], {} # raws = 줄 차례 → (끝수 전 비목, 줄 자리) — 848-4 부착 줄 묶음 끝수 - for n, line in enumerate(got["줄"]): - split, more = dict(line.get("비목") or {}), {} - if n == len(items): # 덧줄이 부르는 `줄.'이름'` = 버린 호표 줄 금액(엔진과 같이 한 번) - env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None} - if n < len(items): - sub = _sub(master, items[n], env, depth) if line.get("수량") is not None else None - if sub is not None: - qty, one = line["수량"], items[n].get("비목") - split = {one: qty * sub["계"]} if one else {k: qty * sub[k] for k in COSTS} - more = {"단가": sub["계"]} # 하위 로직 계(1 원 버림) = 이 줄 단가 - elif n - len(items) < len(adds) and line.get("금액") is not None: - add = adds[n - len(items)] - env.update(total) - if new: # 덧줄이 부르는 번지 · 단계 = 버린 줄로 - env.update(ms.scope(logic, lines)) - try: - value = mf.evaluate(mf.parse(add["식"]), env, master, depth) - except _ERRORS: - value = line["금액"] - env[add["이름"]] = _line(value, rules[n]) # 뒤 덧줄 · 중간 칸 = 버린 값 - split = {add["비목"]: value} - rule = rules[n] if n < len(rules) else None - host = _host(items, n) - cut, money = _joined(split, rule, raws[host]) if host in raws else _parts(split, rule) - raws[n] = (split, rule) - for k, v in cut.items(): - total[k] += 0 if n in skip else v or 0 - if n >= len(items) and money is not None: - more = {"단가": money} - out = {"합밖": True} if n in skip else {} # 합계에 안 드는 줄 표지(796-2d · 보이기만) - lines.append({**line, "비목": cut, "금액": money, **more, **out}) - if not new: - costs = {k: mf.cut(logic, down(v, 0), "계") for k, v in total.items()} - # 중간 = 덧줄이 본 값(버린 줄 합 · 덧줄 값 · `줄`) — 시험 계산 중간 칸 - return {**got, "줄": lines, **costs, "계": sum(costs.values()), "중간": env} - costs = settle(logic, total) - more = {"단계": ms.steps(logic, lines), "셈법": ms.rule(logic)} - return {**got, "줄": lines, **costs, "계": sum(costs.values()), "중간": env, **more} - - -def settle(logic: dict, total: dict) -> dict: - """블록 끝전(791-1) — `끝전` 비목버림(비목마다 원 버림 · 옛 규칙) · 큰나머지(계 원 버림 뒤 - 모자란 원을 소수 큰 비목부터 · 같으면 경 › 재 › 노) → 로직 `끝수` 묶음 → `조정` → 원 버림.""" - costs = {k: down(v, 0) for k, v in total.items()} - if logic.get("끝전") == "큰나머지": - rest = int(down(sum(total.values()), 0) - sum(costs.values())) - order = sorted(COSTS, key=lambda k: (costs[k] - total[k], COSTS[::-1].index(k))) - for k in order[:rest]: - costs[k] += 1 - costs = ms.adjust(logic, {k: mf.cut(logic, v, "계") for k, v in costs.items()}) - return {k: down(v, 0) for k, v in costs.items()} - - -def kept(got: dict) -> dict: - """`run_line` 이 엔진 답에서 그대로 넘기는 덧칸(792-3) — 단계 · 셈법.""" - return {k: got[k] for k in ("단계", "셈법") if k in got} - - -def plain(got: dict, gone=()) -> dict: - """로직 줄 답(`run_line` 꼴 `{기준, 줄, 재료}`)을 줄만 다시 버림 — - 켜쌓기율 곱 · 별도계상 뺀 뒤(`gone` = 뺄 줄 차례) · 기준 = 남은 줄 비목 합 ROUNDDOWN 0 · - 답 `셈법`(791-1 새 의미 로직) = 줄 자리 · 합밖 · 단계 · 블록 끝전 · 조정 그대로(`settle`).""" - if not got.get("기준"): - return got - rule = got.get("셈법") - places = [x.get("자리") for x in ms.items(rule)] if rule else [] - skip = set(gone) | (ms.skipped(rule) if rule else set()) - - def at(n): - return places[n] if isinstance(n, int) and 0 <= n < len(places) else None - - lines, total = [], dict.fromkeys(COSTS, Decimal(0)) - for n, line in enumerate(got.get("줄") or []): - cut, money = _parts(dict(line.get("비목") or {}), at(n)) - for k, v in cut.items(): - total[k] += 0 if n in skip else Decimal(str(v or 0)) - lines.append({**line, "비목": cut, "금액": money}) - mats = [{**m, "금액": _line(m.get("금액"), at(m.get("차례")))} for m in got.get("재료") or []] - kept = [x for n, x in enumerate(lines) if n not in gone] - if not rule: - base = {k: down(v, 0) for k, v in total.items()} - return {**got, "줄": kept, "재료": mats, "기준": {**base, "계": sum(base.values())}} - base = settle(rule, total) - steps = ms.steps(rule, [{} if n in gone else x for n, x in enumerate(lines)]) - return { - **got, - "줄": kept, - "재료": mats, - "기준": {**base, "계": sum(base.values())}, - "단계": steps, - } diff --git a/resources/master_data/scripts/master_formula.py b/resources/master_data/scripts/master_formula.py deleted file mode 100644 index a5e35281d..000000000 --- a/resources/master_data/scripts/master_formula.py +++ /dev/null @@ -1,525 +0,0 @@ -# -*- coding: utf-8 -*- -"""마스터 로직 식 — 읽기 · 검사 · 시험 계산 (`_틀.md` 6~7장). - -식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게). -`check_master.py` 가 부름. -바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄. -""" - -from __future__ import annotations - -import itertools -import re -from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal - -import master_keys as mk -from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로 - BUNDLE, - COST_ITEMS, - GROUPS, - TABLE_GROUPS, - TABLE_IDS, - EmptyInput, - FormulaError, - Master, - NoRow, - _match, - _name, - _plain, - find, -) - -FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대") -_NAME = re.compile(r"[\w가-힣]+") -_NUMBER = re.compile(r"\d+(?:\.\d+)?") -_HOLE = re.compile(r"\{([^{}]+)\}") -_OPS = ("<=", ">=", "==", "!=", "<", ">") -_ARITH = re.compile(r"[\d.\s+\-*/()]*\d[\d.\s+\-*/()]*") # 분수·식 값 칸(「1/1.30」) - - -CALC_FIELDS = ("중간", "호표", "결과", "덧줄") # 계산 칸 -FLOW_GONE = "흐름도 로직은 걷음 — M01 시트로 다시 만듦" # 794-1b · 저장된 흐름 로직 0 - - -def inputs_of(row: dict) -> list[dict]: - """옛 흐름 로직(줄에 「흐름」) 입력 — 흐름도를 걷어 늘 못 셈.""" - raise FormulaError(FLOW_GONE) - - -class Blank: - """못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움.""" - - def __init__(self, why: str): - self.why = why - - -# ── 읽기 ────────────────────────────────────────────────────────────── -class _Parser: - def __init__(self, text: str): - self.s, self.i = text, 0 - - def fail(self, why: str): - raise FormulaError(f"{why} — 「{self.s}」 {self.i}자") - - def ws(self): - while self.i < len(self.s) and self.s[self.i].isspace(): - self.i += 1 - - def peek(self, word: str) -> bool: - self.ws() - return self.s.startswith(word, self.i) - - def take(self, word: str) -> bool: - if self.peek(word): - self.i += len(word) - return True - return False - - def need(self, word: str): - if not self.take(word): - self.fail(f"「{word}」 없음") - - def parse(self): - node = self.expr() - self.ws() - if self.i != len(self.s): - self.fail("식 끝에 남은 글자") - return node - - def expr(self): - node = self.both() - while self.take("또는"): - node = ("bin", "또는", node, self.both()) - return node - - def both(self): - node = self.compare() - while self.take("그리고"): - node = ("bin", "그리고", node, self.compare()) - return node - - def compare(self): - node = self.add() - for op in _OPS: - if self.take(op): - return ("bin", op, node, self.add()) - return node - - def add(self): - node = self.mul() - while True: - if self.take("+"): - node = ("bin", "+", node, self.mul()) - elif self.take("-"): - node = ("bin", "-", node, self.mul()) - else: - return node - - def mul(self): - node = self.unary() - while True: - if self.take("*"): - node = ("bin", "*", node, self.unary()) - elif self.take("/"): - node = ("bin", "/", node, self.unary()) - else: - return node - - def unary(self): - if self.take("-"): - return ("neg", self.unary()) - node = self.primary() - while self.take("."): - node = ("field", node, self.quoted() if self.take("'") else self.name()) - return node - - def quoted(self) -> str: - end = self.s.find("'", self.i) - if end < 0: - self.fail("작은따옴표 안 닫힘") - text, self.i = self.s[self.i : end], end + 1 - return text - - def name(self) -> str: - self.ws() - m = _NAME.match(self.s, self.i) - if not m: - self.fail("이름 없음") - self.i = m.end() - return m.group() - - def ref(self, head: bool = False) -> str: - """키·원문번호 글자 — 괄호 밖의 `,` · `)` · `.칸` · ` 연산자 ` 앞에서 멈춤(원문번호에 빈칸·괄호가 들어감). - head = 찾기·로직 머리 — `,` · `)` 에서만 멈춤.""" - start, depth = self.i, 0 - while self.i < len(self.s): - ch = self.s[self.i] - if ch in "({": - depth += 1 - elif ch in ")}": - if depth == 0: - break - depth -= 1 - elif depth == 0 and ch == ",": - break - elif head: - pass - elif depth == 0 and ch == "." and not self.s[self.i + 1 : self.i + 2].isdigit(): - # 「K.P」「T.S」 처럼 영문자 사이 점은 원문번호 글자 - around = self.s[self.i - 1 : self.i + 2 : 2] - if not (len(around) == 2 and around.isascii() and around.isalpha()): - break - elif depth == 0 and re.match(r"\s[-+*/<>=!]", self.s[self.i : self.i + 2]): - break - self.i += 1 - return self.s[start : self.i].strip() - - def args(self) -> list[tuple[str, object]]: - out = [] - while self.take(","): - key = self.quoted() if self.take("'") else self.name() - self.need("=") - out.append((key, self.expr())) - self.need(")") - return out - - def primary(self): - self.ws() - if self.take("("): - node = self.expr() - self.need(")") - return node - if self.take("'"): - end = self.s.find("'", self.i) - if end < 0: - self.fail("작은따옴표 안 닫힘") - text, self.i = self.s[self.i : end], end + 1 - return ("str", text) - m = _NUMBER.match(self.s, self.i) - if m: - self.i = m.end() - return ("num", Decimal(m.group())) - word = self.name() - if word == "찾기": - self.need("(") - self.ws() - return ("find", self.ref(True), self.args()) - if word == "로직": - self.need("(") - self.ws() - return ("logic", self.ref(True), self.args()) - if word in FUNCS: - self.need("(") - items = [self.expr()] - while self.take(","): - items.append(self.expr()) - self.need(")") - return ("call", word, items) - if mk.KEY.fullmatch(word): - return ("ref", word) - if word in mk.IDS and self.s.startswith(":", self.i): # ID:원문번호 — {이름} 낀 원문번호 - self.i += 1 - return ("ref", f"{word}:{self.ref()}") - return ("name", word) - - -def parse(text) -> tuple: - if isinstance(text, (int, float, Decimal)): - return ("num", Decimal(str(text))) - return _Parser(str(text)).parse() - - -def walk(node): - """식 나무의 모든 마디.""" - yield node - kind = node[0] - if kind == "bin": - yield from walk(node[2]) - yield from walk(node[3]) - elif kind in ("neg",): - yield from walk(node[1]) - elif kind == "field": - yield from walk(node[1]) - elif kind == "call": - for item in node[2]: - yield from walk(item) - elif kind in ("find", "logic"): - for _, item in node[2]: - yield from walk(item) - - -def fill(template: str, env: dict) -> str: - def one(m): - if m.group(1) not in env: - raise FormulaError(f"원문번호의 {{{m.group(1)}}} 값 없음") - value = env[m.group(1)] - if isinstance(value, Blank): - raise EmptyInput(value.why) - return _plain(value) - - return _HOLE.sub(one, template) - - -# ── 계산 ────────────────────────────────────────────────────────────── -def _round(x: Decimal, places, mode) -> Decimal: - return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode) - - -def evaluate(node, env: dict, master: Master, depth: int = 0): - kind = node[0] - if kind in ("num", "str"): - return node[1] - if kind == "name": - if node[1] not in env: - raise FormulaError(f"모르는 이름 「{node[1]}」") - if env[node[1]] is None: - raise EmptyInput(f"입력 「{node[1]}」 비어 있음") - if isinstance(env[node[1]], Blank): - raise EmptyInput(env[node[1]].why) - return env[node[1]] - if kind == "ref": - value = element(master, fill(node[1], env), env)[0] - if value is None: - raise FormulaError(f"「{master.label(fill(node[1], env))}」 값 없음 — 관리자가 채울 값") - if isinstance(value, list): - raise FormulaError( - f"「{master.label(fill(node[1], env))}」 값이 범위 — 입력으로 받아야 함" - ) - return value - if kind == "field": - if node[1][0] == "find": - table = master.get(fill(node[1][1], env)) - conds = {k: evaluate(v, env, master, depth) for k, v in node[1][2]} - base = find(table, conds, node[2]) - else: - base = evaluate(node[1], env, master, depth) - if not isinstance(base, dict) or node[2] not in base: - raise FormulaError(f"칸 「{node[2]}」 없음") - value = base[node[2]] - if isinstance(value, list): - raise FormulaError(f"칸 「{node[2]}」 값이 범위 — 입력으로 받아야 함") - if isinstance(value, str) and _ARITH.fullmatch(value): - return evaluate(parse(value), env, master, depth) - return value - if kind == "neg": - return -evaluate(node[1], env, master, depth) - if kind == "bin": - op, a = node[1], evaluate(node[2], env, master, depth) - if op == "그리고": - return a and evaluate(node[3], env, master, depth) - if op == "또는": - return a or evaluate(node[3], env, master, depth) - b = evaluate(node[3], env, master, depth) - return { - "+": lambda: a + b, - "-": lambda: a - b, - "*": lambda: a * b, - "/": lambda: a / b, - "<": lambda: a < b, - "<=": lambda: a <= b, - ">": lambda: a > b, - ">=": lambda: a >= b, - "==": lambda: a == b, - "!=": lambda: a != b, - }[op]() - if kind == "call": - name, items = node[1], node[2] - if name == "만약": - test = evaluate(items[0], env, master, depth) - return evaluate(items[1] if test else items[2], env, master, depth) - values = [evaluate(x, env, master, depth) for x in items] - if name in ("최소", "최대"): - return (min if name == "최소" else max)(values) - mode = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP}[name] - return _round(values[0], values[1] if len(values) > 1 else 0, mode) - if kind == "find": - table = master.get(fill(node[1], env)) - return find(table, {k: evaluate(v, env, master, depth) for k, v in node[2]}) - if kind == "logic": - if depth > 20: - raise FormulaError("로직 부르기가 너무 깊음 — 돌고 도는 참조") - given = {k: evaluate(v, env, master, depth) for k, v in node[2]} - result = run(master, fill(node[1], env), given, depth + 1) - return result["결과"] if "결과" in result else {k: result[k] for k in BUNDLE} - raise FormulaError(f"모르는 마디 {kind}") - - -ROUND_WAYS = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP} -ROUND_ON = ("계", "결과") - - -def cut(row: dict, value: Decimal, on: str) -> Decimal: - """줄의 `끝수` 를 붙임 — 묶음 `{대상, 자리, 방법}` 만 · 글자 끝수는 원문 근거를 적은 설명.""" - rule = row.get("끝수") - if not isinstance(rule, dict) or rule.get("대상") != on: - return value - way = ROUND_WAYS.get(str(rule.get("방법"))) - if way is None: - raise FormulaError(f"「{_name(row)}」 끝수 방법 「{rule.get('방법')}」") - return _round(value, rule.get("자리") or 0, way) - - -def fill_empty(row: dict, given: dict) -> dict: - """화면이 안 보낸 가격 입력(단위에 「원」)은 null 로 채움 — 빈 입력과 같이 그 줄만 비움.""" - gap = { - s["이름"]: None - for s in row.get("입력", []) - if s["이름"] not in given and "원" in str(s.get("단위") or "") - } - return {**given, **gap} - - -def _inputs(row: dict, given: dict, master=None) -> dict: - env = {} - for spec in row.get("입력", []): - name = spec["이름"] - if name not in given: - raise FormulaError(f"「{_name(row)}」 입력 「{name}」 없음") - value = given[name] - if isinstance(value, str): # 화면이 글로 보낸 수 — 고르기 원래 값 · 아니면 수로 - if "고르기" in spec: - value = next((o for o in spec["고르기"] if str(o) == value.strip()), value) - else: - try: - value = Decimal(value.strip()) - except ArithmeticError: - pass - if isinstance(value, (int, float)): - value = Decimal(str(value)) - value = mp.resolve(spec, value, master) # 기계 EQ 키 → 원문 분류번호 - if "고르기" in spec and value not in spec["고르기"] and not mp.machine(spec, value, master): - raise FormulaError(f"입력 「{name}」={value} 고르기 밖") - if "범위" in spec: - low, high = spec["범위"] - if value is not None and not low <= value <= high: - raise FormulaError(f"입력 「{name}」={value} 범위 [{low}, {high}] 밖") - env[name] = value - unknown = set(given) - set(env) - if unknown: - raise FormulaError(f"「{_name(row)}」 모르는 입력 {sorted(unknown)}") - return env - - -def _shown(env: dict) -> dict: - """돌려줄 중간값 — 못 구한 값은 null.""" - return {k: None if isinstance(v, Blank) else v for k, v in env.items()} - - -def _blank_line(item: dict, why: str) -> dict: - """비어 있는 입력·못 구한 값을 쓰는 호표 줄 — 단가·금액만 비우고 까닭.""" - return { - "이름": item.get("이름", ""), - "단위": item.get("단위", ""), - "수량": None, - "단가": None, - "금액": None, - "비목": {item["비목"]: None} if "비목" in item else {}, - "까닭": why, - } - - -def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict: - """로직 한 줄 계산 — 돈 로직은 호표 줄 · 비목 합 · 계, 돈 아닌 로직은 결과 수 하나.""" - row = master.logic(ref) - if isinstance(row.get("흐름"), dict): - raise FormulaError(FLOW_GONE) - env = _inputs(row, given, master) - for step in row.get("중간", []): - try: - value = evaluate(parse(step["식"]), env, master, depth) - env[step["이름"]] = ms.shown(step, value) # `표시` 자리 반올림(791-1) - except EmptyInput as e: # 못 구한 중간값 — 쓰는 줄만 비움 - env[step["이름"]] = Blank(str(e)) - if "결과" in row: - value = evaluate(parse(row["결과"]["식"]), env, master, depth) - return {"결과": cut(row, value, "결과"), "중간": _shown(env)} - sums = dict.fromkeys(COST_ITEMS, Decimal(0)) - lines = [] - for n, item in enumerate(row.get("호표", [])): - source = why = extra = None - try: - qty = evaluate(parse(item["수량"]), env, master, depth) - except EmptyInput as e: # 비어 있는 입력을 쓰는 줄만 비움 - lines.append(_blank_line(item, str(e))) - continue - if item["종류"] == "로직": - try: - bundle = mp.bundled(item, lambda: evaluate(parse(item["요소"]), env, master, depth)) - except EmptyInput as e: - lines.append(_blank_line(item, str(e))) - continue - price = bundle["계"] - split = ( - {k: qty * bundle[k] for k in COST_ITEMS} - if "비목" not in item - else {item["비목"]: qty * price} - ) - else: - # 고르기 조건 묶음은 그대로 넘김 — `element` 가 대표 줄·첫 줄로 풂 - # 조건 값의 `{입력}`(관경 등)도 채움 — 규격이 입력 따라 바뀌는 관 줄 - try: - ref = ( - {k: fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()} - if isinstance(item["요소"], dict) - else fill(item["요소"], env) - ) - except EmptyInput as e: - lines.append(_blank_line(item, str(e))) - continue - # 후보 0 · 값 빈 품목은 그 줄만 단가·금액을 비우고 까닭을 닮 — 로직은 계속 · 합에서 뺌 - # (없는 키는 틀린 로직 — 지금처럼 멈춤) · 검색어 · 고름 · 단위 환산은 `master_pick` - if isinstance(ref, str) and qty != 0: - master.get(ref) - price, source, why, extra = mp.priced(master, item, ref, env, n if depth == 0 else None) - if price is None and qty == 0: - price, why = Decimal(0), None # 안 쓰는 재료 줄 — 값이 비어도 금액 0 - split = {item["비목"]: None if price is None else qty * price} - for k, v in split.items(): - sums[k] += v or 0 - lines.append( - { - "이름": item.get("이름", ""), - "단위": item.get("단위", ""), - "수량": qty, - "단가": price, - "금액": None if price is None else qty * price, - "비목": split, - **({"출처": source} if source else {}), - **({"까닭": why} if why else {}), - **(extra or {}), - } - ) - # 덧줄 · 비목 합 끊기 · 번지 · 단계 · 조정(791-1) = `master_formula_sum.extras` - sums, more = ms.extras(master, row, lines, env, sums, depth) - mb.tag(master, row, lines, env) # 줄마다 인력 · 재료 · 경비 · 하위 묶음(712-1) - mg.tag(master, row, lines, env) # 옵션으로 빠진 줄 `옵션꺼짐`(753-1) - return {"줄": lines, **sums, "계": sum(sums.values()), "중간": _shown(env), **more} - - -# 품셈재료 단가 — 서로 부르는 모듈이라 끝에서 읽음 -from master_material import ( # noqa: E402, F401 - LINKED, - PICK_KEYS, - REGION, - SLOTS, - TARIFF, - candidates, - check_pick, - check_unit, - static, - cond_text, - element, - pick, -) -import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위 -import master_bundle as mb # noqa: E402 — 인력 · 재료 · 경비 묶음 -import master_gate as mg # noqa: E402 — 옵션으로 빠진 줄 -import master_formula_sum as ms # noqa: E402 — 덧줄 · 번지 · 단계 · 조정 · 표시(791-1) -from master_formula_check import ( # noqa: E402, F401 — 검사는 나눈 파일 · 이름은 여기서 그대로 - _check_cut, - _check_node, - _choices, - _expand, - check_logic, - find_loops, -) diff --git a/resources/master_data/scripts/master_formula_check.py b/resources/master_data/scripts/master_formula_check.py deleted file mode 100644 index 5a4bdbaaf..000000000 --- a/resources/master_data/scripts/master_formula_check.py +++ /dev/null @@ -1,237 +0,0 @@ -# -*- coding: utf-8 -*- -"""마스터 로직 식 — 검사 (`master_formula` 에서 나눔 · 밖에서는 `master_formula` 로 부름). - -`master_formula` 끝에서만 읽힘 — 먼저 읽으면 서로 부르다 막힘. -""" - -from __future__ import annotations - -import itertools -from decimal import Decimal - -import master_formula_sum as ms -import master_keys as mk -import master_machine_crew as mcrew -from master_formula import ( - _HOLE, - BUNDLE, - COST_ITEMS, - ROUND_ON, - ROUND_WAYS, - TABLE_IDS, - FormulaError, - fill, - parse, - walk, -) -from master_material import REGION, TARIFF, check_pick - - -# ── 검사 ────────────────────────────────────────────────────────────── -def _vals(row: dict): - """줄 값 — 기계 = 인력 · 잡품 목록을 식이 읽는 칸으로(842-3 `master_machine_crew.view`).""" - value = row.get("값") - return mcrew.view(value) if str(row.get("키"))[:2] == "EQ" else value - - -def _choices(row: dict, name: str, master: Master): - """이름이 가질 수 있는 값 — 고르기 입력, 또는 고르기 입력만 끼운 요소 칸인 중간. 모르면 None.""" - for spec in row.get("입력", []): - if spec["이름"] == name: - return spec.get("고르기") - for step in row.get("중간", []): - if step["이름"] == name: - node = parse(step["식"]) - if node[0] == "field" and node[1][0] == "ref": - out = set() - for ref in _expand(row, node[1][1], master) or []: - try: - out.add(str(_vals(master.get(ref))[node[2]])) - except (FormulaError, KeyError, TypeError): - pass - return sorted(out) - return None - - -def _expand(row: dict, template: str, master: Master): - """원문번호 틀의 {이름} 을 고를 수 있는 값으로 모두 끼움 — 못 정하면 None.""" - holes = _HOLE.findall(template) - options = [_choices(row, h, master) for h in holes] - if any(o is None for o in options): - return None - return [ - fill(template, {h: v for h, v in zip(holes, combo)}) - for combo in itertools.product(*options) - ] - - -def _check_node(row, node, known: set, master: Master, where: str, out: list, calls: set): - for part in walk(node): - kind = part[0] - if kind == "name" and part[1] not in known: - out.append(f"{where} · 모르는 이름 「{part[1]}」") - if kind in ("ref", "find", "logic"): - for hole in _HOLE.findall(part[1]): - if hole not in known: - out.append(f"{where} · 원문번호 {{{hole}}} 가 입력·중간 아님") - if kind == "ref": - refs = _expand(row, part[1], master) or [] - for ref in refs: - try: - link = master.get(ref).get("연결") - except FormulaError as e: - out.append(f"{where} · {e}") - continue - if isinstance(link, dict) and link.get("지역") == "입력" and REGION not in known: - out.append(f"{where} · 「{master.label(ref)}」 는 입력 「{REGION}」 필요") - if ( - isinstance(link, dict) - and link.get("계약종별") == "입력" - and TARIFF not in known - ): - out.append(f"{where} · 「{master.label(ref)}」 는 입력 「{TARIFF}」 필요") - if kind == "field" and part[1][0] == "ref": - for ref in _expand(row, part[1][1], master) or []: - try: - value = _vals(master.get(ref)) - except FormulaError: - continue - if not isinstance(value, dict) or part[2] not in value: - out.append(f"{where} · 「{master.label(ref)}」 에 칸 「{part[2]}」 없음") - if kind == "find": - if mk.id_of(part[1]) not in TABLE_IDS: - out.append(f"{where} · 찾기 대상 「{part[1]}」 이 표 아님") - continue - try: - table = master.get(part[1]) - except FormulaError as e: - out.append(f"{where} · {e}") - continue - for cond, _ in part[2]: - if cond not in table.get("조건", {}): - out.append(f"{where} · 「{master.label(part[1])}」 에 조건 「{cond}」 없음") - if kind == "field" and part[1][0] == "find": - try: - table = master.get(part[1][1]) - except FormulaError: - continue - if part[2] not in table.get("값칸", {}): - out.append(f"{where} · 「{master.label(part[1][1])}」 에 값 칸 「{part[2]}」 없음") - if kind == "logic": - calls.add(part[1]) - try: - target = master.logic(part[1]) - except FormulaError as e: - out.append(f"{where} · {e}") - continue - names = {s["이름"] for s in target.get("입력", [])} - given = {k for k, _ in part[2]} - for extra in sorted(given - names): - out.append(f"{where} · 「{master.label(part[1])}」 에 입력 「{extra}」 없음") - for lack in sorted(names - given): - out.append(f"{where} · 「{master.label(part[1])}」 입력 「{lack}」 안 줌") - if kind == "field" and part[1][0] == "logic": - try: - target = master.logic(part[1][1]) - except FormulaError: - continue - if "결과" in target: - out.append( - f"{where} · 돈 아닌 로직 「{master.label(part[1][1])}」 은 수 하나 — 칸 「{part[2]}」 못 씀" - ) - elif part[2] not in BUNDLE: - out.append(f"{where} · 로직 결과 칸 「{part[2]}」 은 {BUNDLE} 가운데 하나여야 함") - - -def check_logic(master: Master, row: dict) -> tuple[list[str], set]: - """(문제 목록, 부르는 로직 키) — 변수 · 찾기 조건 · 로직 입력.""" - out, calls, key = [], set(), f"{row.get('키')} {row.get('원문번호')}" - known = {s["이름"] for s in row.get("입력", [])} - - def one(text, where, names): - try: - _check_node(row, parse(text), names, master, where, out, calls) - except FormulaError as e: - out.append(f"{where} · 식 못 읽음: {e}") - - for step in row.get("중간", []): - one(step["식"], f"{key} 중간 {step['이름']}", known) - known = known | {step["이름"]} - if "결과" in row: - one(row["결과"]["식"], f"{key} 결과", known) - for item in row.get("호표", []): - where = f"{key} 호표 {item.get('이름', '')}" - one(item["수량"], where + " 수량", known) - if item.get("종류") not in ("인력", "재료", "기계", "로직"): - out.append(f"{where} · 종류 「{item.get('종류')}」") - if item.get("비목") not in (*COST_ITEMS, None) or ( - item.get("종류") != "로직" and "비목" not in item - ): - out.append(f"{where} · 비목 「{item.get('비목')}」") - if isinstance(item["요소"], dict): # 재료 고르기 조건 - if item.get("종류") != "재료": - out.append(f"{where} · 고르기 조건은 종류 「재료」 만") - # 조건 칸의 {이름} 은 계산 때 채워짐 — 그 이름이 실제 입력·중간인지만 봄 - for value in item["요소"].values(): - for hole in _HOLE.findall(value) if isinstance(value, str) else []: - if hole not in known: - out.append(f"{where} 요소 · 고르기 조건 {{{hole}}} 가 입력·중간 아님") - out += check_pick(master, where + " 요소", item["요소"]) - continue - one(item["요소"], where + " 요소", known) - group = mk.GROUP_OF.get(mk.id_of(str(item["요소"]))) - if item.get("종류") != "로직" and group != item.get("종류"): - out.append(f"{where} · 요소 그룹이 종류와 다름") - names = known | set(COST_ITEMS) | {"줄"} # 「줄」 = 호표 줄 금액 묶음(덧줄에서만) - if ms.uses(row): # 금액번지 · 소계 단계(791-1) — 덧줄에서만 - names = names | {ms.ADDR, ms.STEP} - for extra in row.get("덧줄", []): - one(extra["식"], f"{key} 덧줄 {extra['이름']}", names) - names = names | {extra["이름"]} - if extra.get("비목") not in COST_ITEMS: - out.append(f"{key} 덧줄 {extra['이름']} · 비목 「{extra.get('비목')}」") - out += _check_cut(row, key) + ms.check(row, key) - return out, calls - - -def _check_cut(row: dict, key: str) -> list[str]: - """끝수 — 묶음이면 칸·대상·방법·자리 · 글자는 설명(검사 안 함).""" - rule = row.get("끝수") - if rule is None or isinstance(rule, str): - return [] - if not isinstance(rule, dict): - return [f"{key} 끝수 · 묶음도 글자도 아님"] - out = [] - unknown = set(rule) - {"대상", "자리", "방법", "출처", "비고"} - if unknown: - out.append(f"{key} 끝수 · 모르는 칸 {sorted(unknown)}") - on = rule.get("대상") - if on not in ROUND_ON: - out.append(f"{key} 끝수 · 대상 「{on}」 — {' · '.join(ROUND_ON)}") - elif ("결과" in row) != (on == "결과"): - out.append(f"{key} 끝수 · 대상 「{on}」 이 로직 갈래와 안 맞음") - if rule.get("방법") not in ROUND_WAYS: - out.append(f"{key} 끝수 · 방법 「{rule.get('방법')}」 — {' · '.join(ROUND_WAYS)}") - place = rule.get("자리", 0) - if not isinstance(place, (int, Decimal)) or place != int(place) or not 0 <= int(place) <= 6: - out.append(f"{key} 끝수 · 자리 「{place}」 — 0∼6 정수") - return out - - -def find_loops(graph: dict[str, set]) -> list[list[str]]: - """로직 부르기의 돌고 도는 길.""" - loops, state = [], {} - - def visit(node, path): - state[node] = 1 - for nxt in sorted(graph.get(node, ())): - if state.get(nxt) == 1: - loops.append(path[path.index(nxt) :] + [nxt]) - elif nxt not in state: - visit(nxt, path + [nxt]) - state[node] = 2 - - for node in sorted(graph): - if node not in state: - visit(node, [node]) - return loops diff --git a/resources/master_data/scripts/master_formula_sum.py b/resources/master_data/scripts/master_formula_sum.py deleted file mode 100644 index e0a11d373..000000000 --- a/resources/master_data/scripts/master_formula_sum.py +++ /dev/null @@ -1,278 +0,0 @@ -# -*- coding: utf-8 -*- -"""로직 셈 의미 넓힘(PLAN 791-1 · `_틀.md` 7장 「셈 의미」) — 덧줄 고리 · 금액번지 · 소계 단계 · -제외 · 결과금액 조정 · 변수 표시 반올림 · 검사. - -`master_formula.run` 이 부름(덧줄 고리를 여기로 옮김) · 끝전(줄 자리 · 블록 끝전)은 `master_cut`. -새 칸을 안 쓰는 로직은 옛 셈 그대로 — 지킴 = M01 로직 지문(`test_791_1_engine_semantics.py`). -eval 없음 · 수는 Decimal. -""" - -from __future__ import annotations - -from decimal import ROUND_HALF_UP, Decimal - -import master_formula as mf - -COSTS = mf.COST_ITEMS -ROW_KEYS = ("단계", "끝전", "조정") # 로직 줄 칸 -LINE_KEYS = ("번지", "합밖", "자리") # 호표 · 덧줄 칸 -ENDS = ("비목버림", "큰나머지") -MAX_PLACE = 3 # 줄 자리 0~3 -MAX_SHOW = 6 # 변수 표시 0~6 -MAX_STEP = 5 # 소계 단 1~5(STmate `(=)`~`(=====)`) -ADDR, STEP = "번지", "단계" # 덧줄 식 이름 — `번지.A01.재료비` · `단계.'소계'.계` - - -def items(row: dict) -> list[dict]: - """엔진 줄 차례 = 호표 하나씩 뒤 덧줄 하나씩.""" - return [*row.get("호표", []), *row.get("덧줄", [])] - - -def uses(row: dict) -> bool: - """새 의미(번지 · 단계 · 끝전 · 조정 · 합밖 · 줄 자리)를 쓰는 로직 — 아니면 옛 셈 그대로.""" - return any(k in row for k in ROW_KEYS) or any(k in x for x in items(row) for k in LINE_KEYS) - - -def rule(row: dict) -> dict: - """셈법(792-3) — 새 의미 칸만 뗀 작은 로직 꼴(이 모듈 · `master_cut.settle` 이 읽음) · - 엔진 답 `셈법` 으로 실어 켜쌓기율 · 별도계상 뒤 다시 버림(`master_cut.plain`)이 씀.""" - keep = ("이름", *LINE_KEYS) - lines = { - k: [{x: one[x] for x in keep if x in one} for one in row.get(k, [])] - for k in ("호표", "덧줄") - } - return {**lines, **{k: row[k] for k in (*ROW_KEYS, "끝수") if k in row}} - - -def shown(step: dict, value): - """중간 `표시` = 값을 n 자리 반올림해 뒤 줄에 넘김(STmate `X = 식 =`).""" - if step.get("표시") is None or not isinstance(value, Decimal): - return value - return mf._round(value, step["표시"], ROUND_HALF_UP) - - -def _add(acc: dict, money: dict | None) -> None: - for k, v in (money or {}).items(): - if k in acc: - acc[k] += v or 0 - - -def _bundle(acc: dict) -> dict: - return {**acc, "계": sum(acc[k] for k in COSTS)} - - -def _cover(row: dict) -> list[tuple[dict, set]]: - """단계마다 (단계, 담은 줄 차례) — 단 1 = 제 `줄` · 단 k = 제 `줄` + 아직 안 담긴 아래 단 단계. - 제외 단계는 위로 안 올라감.""" - where = {x.get("이름"): i for i, x in enumerate(items(row)) if x.get("이름")} - out, open_ = [], [] - for st in row.get(STEP) or []: - level, mine = int(st.get("단") or 1), {where[n] for n in st.get("줄") or [] if n in where} - keep = [] - for low, got in open_: - if low < level: - mine |= got - else: - keep.append((low, got)) - open_ = keep if st.get("제외") else [*keep, (level, mine)] - out.append((st, mine)) - return out - - -def skipped(row: dict) -> set: - """비목 합에서 빼는 줄 차례 — `합밖` 줄(번지엔 쌓음) · 제외 단계가 담은 줄.""" - out = {i for i, x in enumerate(items(row)) if x.get("합밖")} - for st, mine in _cover(row): - if st.get("제외"): - out |= mine - return out - - -def total(row: dict, lines: list[dict]) -> dict: - """비목 합 — 뺄 줄을 빼고 지금까지 줄.""" - skip, acc = skipped(row), dict.fromkeys(COSTS, Decimal(0)) - for i, line in enumerate(lines): - if i not in skip: - _add(acc, line.get("비목")) - return acc - - -def steps(row: dict, lines: list[dict]) -> list[dict]: - """단계 값 — 지금까지 셈한 줄만(뒤 줄은 0).""" - out = [] - for st, mine in _cover(row): - acc = dict.fromkeys(COSTS, Decimal(0)) - for i in sorted(mine): - if i < len(lines): - _add(acc, lines[i].get("비목")) - out.append( - {"이름": st.get("이름"), "단": st.get("단"), **_bundle(acc)} - | ({"제외": True} if st.get("제외") else {}) - ) - return out - - -def scope(row: dict, lines: list[dict]) -> dict: - """덧줄 식 이름 — `번지` {A01: 묶음} · `단계` {이름: 묶음} (지금까지 줄).""" - places = {} - for item, line in zip(items(row), lines): - if item.get(ADDR): - _add(places.setdefault(item[ADDR], dict.fromkeys(COSTS, Decimal(0))), line.get("비목")) - return { - ADDR: {k: _bundle(v) for k, v in places.items()}, - STEP: {x["이름"]: {k: x[k] for k in (*COSTS, "계")} for x in steps(row, lines)}, - } - - -def adjust(row: dict, sums: dict) -> dict: - """결과금액 조정 — `배율` {비목: 수} 곱 → `옮김` 비목으로 계 전부(STmate 「경비로 적용」).""" - rule = row.get("조정") - if not rule: - return sums - out = dict(sums) - for k, rate in (rule.get("배율") or {}).items(): - out[k] = out[k] * Decimal(str(rate)) - if rule.get("옮김"): - whole = sum(out.values()) - out = {k: whole if k == rule["옮김"] else Decimal(0) for k in COSTS} - return out - - -def extras(master, row: dict, lines: list[dict], env: dict, sums: dict, depth: int): - """덧줄 셈(옛 `run` 고리 그대로) + 새 의미 → (비목 합, 덧칸 `{단계}`).""" - new = uses(row) - # 덧줄이 호표 줄 금액 하나를 빼고 더할 수 있게 — `줄.'호표 줄 이름'`(빈 줄은 뺌) - env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None} - blank = {x["이름"]: x["까닭"] for x in lines if x.get("까닭")} - for extra in row.get("덧줄", []): - if new: - sums = total(row, lines) - env.update(scope(row, lines)) - env.update(sums) - try: # 덧줄도 값 빈 품목·빈 줄을 부르면 그 줄만 비움 - value, why = mf.evaluate(mf.parse(extra["식"]), env, master, depth), None - env[extra["이름"]] = value - except mf.FormulaError as e: - gone = next((n for n in blank if n in extra["식"]), None) - value, why = None, f"「{gone}」 줄 비어 못 셈 — {blank[gone]}" if gone else str(e) - blank[extra["이름"]] = why - sums[extra["비목"]] += value or 0 - lines.append( - { - "이름": extra["이름"], - "단위": "식", - "수량": Decimal(1), - "단가": value, - "금액": value, - "비목": {extra["비목"]: value}, - **({"까닭": why} if why else {}), - } - ) - if new: - sums = total(row, lines) - sums = {k: mf.cut(row, v, "계") for k, v in sums.items()} # 비목 합마다 끊고 계는 그 합 - if not new: - return sums, {} - return adjust(row, sums), {STEP: steps(row, lines)} - - -# ── 검사 ────────────────────────────────────────────────────────────── -def _whole(v, low: int, high: int) -> bool: - return isinstance(v, (int, Decimal)) and v == int(v) and low <= int(v) <= high - - -def _refs(node): - """식 안 `번지.X.칸` · `단계.'X'.칸` → (이름, X, 칸).""" - for part in mf.walk(node): - if part[0] == "field" and part[1][0] == "field" and part[1][1][0] == "name": - head = part[1][1][1] - if head in (ADDR, STEP): - yield head, part[1][2], part[2] - - -def check(row: dict, key: str) -> list[str]: - """새 의미 칸 — 끝전 · 조정 · 줄 자리 · 번지 · 표시 · 단계 · 덧줄이 부르는 번지 · 단계 차례.""" - out, lines = [], items(row) - end = row.get("끝전") - if end is not None and end not in ENDS: - out.append(f"{key} 끝전 「{end}」 — {' · '.join(ENDS)}") - rule = row.get("조정") - if rule is not None: - if not isinstance(rule, dict) or set(rule) - {"옮김", "배율"}: - out.append(f"{key} 조정 · 칸은 옮김 · 배율만") - else: - if rule.get("옮김") not in (None, *COSTS): - out.append(f"{key} 조정 옮김 「{rule['옮김']}」 — {' · '.join(COSTS)}") - for k, rate in (rule.get("배율") or {}).items(): - if k not in COSTS or not isinstance(rate, (int, Decimal)) or rate < 0: - out.append(f"{key} 조정 배율 「{k}」={rate}") - for step in row.get("중간", []): - if step.get("표시") is not None and not _whole(step["표시"], 0, MAX_SHOW): - out.append(f"{key} 중간 {step['이름']} · 표시 「{step['표시']}」 — 0∼{MAX_SHOW} 정수") - names = [x.get("이름") for x in lines] - for item in lines: - where = f"{key} 줄 {item.get('이름', '')}" - place = item.get("자리") - if place is not None and ( - not isinstance(place, dict) - or set(place) - {"방법", "자리"} - or place.get("방법") not in mf.ROUND_WAYS - or not _whole(place.get("자리", 0), 0, MAX_PLACE) - ): - out.append( - f"{where} · 자리 「{place}」 — {{방법: 버림·반올림·올림, 자리: 0∼{MAX_PLACE}}}" - ) - if ADDR in item and not (isinstance(item[ADDR], str) and mf._NAME.fullmatch(item[ADDR])): - out.append(f"{where} · 번지 「{item[ADDR]}」 — 글자 · 숫자만") - if "합밖" in item and not isinstance(item["합밖"], bool): - out.append(f"{where} · 합밖 「{item['합밖']}」 — 참 · 거짓") - out += _check_steps(row, key, names) - return out - - -def _check_steps(row: dict, key: str, names: list) -> list[str]: - out, seen, taken = [], set(), {} - for st in row.get(STEP) or []: - name = st.get("이름") if isinstance(st, dict) else None - where = f"{key} 단계 {name}" - if not isinstance(name, str) or not name.strip(): - out.append(f"{key} 단계 · 이름 없음") - continue - if name in seen: - out.append(f"{where} · 같은 이름") - seen.add(name) - if set(st) - {"이름", "단", "줄", "제외"}: - out.append(f"{where} · 모르는 칸 {sorted(set(st) - {'이름', '단', '줄', '제외'})}") - if not _whole(st.get("단"), 1, MAX_STEP): - out.append(f"{where} · 단 「{st.get('단')}」 — 1∼{MAX_STEP} 정수") - for line in st.get("줄") or []: - if line not in names: - out.append(f"{where} · 없는 줄 「{line}」") - elif names.count(line) > 1: - out.append(f"{where} · 줄 이름 「{line}」 겹침 — 줄 이름을 가를 것") - elif line in taken: - out.append(f"{where} · 줄 「{line}」 이 단계 「{taken[line]}」 에도 있음") - taken.setdefault(line, name) - if out: - return out - cover = {st["이름"]: mine for st, mine in _cover(row)} - places = {} - for i, item in enumerate(items(row)): - if item.get(ADDR): - places.setdefault(item[ADDR], set()).add(i) - first = len(row.get("호표", [])) - for n, extra in enumerate(row.get("덧줄", [])): - try: - node = mf.parse(extra["식"]) - except mf.FormulaError: - continue # 못 읽는 식은 `check_logic` 이 알림 - for head, name, slot in _refs(node): - where = f"{key} 덧줄 {extra.get('이름')}" - group = (places if head == ADDR else cover).get(name) - if group is None: - out.append(f"{where} · 없는 {head} 「{name}」") - elif any(i >= first + n for i in group): - out.append(f"{where} · {head} 「{name}」 에 이 줄이나 뒤 줄이 듦 — 단계 순서") - if slot not in mf.BUNDLE: - out.append(f"{where} · {head} 칸 「{slot}」 — {' · '.join(mf.BUNDLE)}") - return out diff --git a/resources/master_data/scripts/master_gate.py b/resources/master_data/scripts/master_gate.py deleted file mode 100644 index 15dc6548d..000000000 --- a/resources/master_data/scripts/master_gate.py +++ /dev/null @@ -1,90 +0,0 @@ -# -*- coding: utf-8 -*- -"""옵션으로 빠진 줄 — **셈 때 파생**(정본에 칸 없음 · PLAN 753-1 · 요구 588-4). - -엔진 `run` 호표 줄 덧칸 `옵션꺼짐` = True — 그 줄 수량 0 이 조건 `만약` 의 간 갈래(상수 0) 탓 -(폼타이 12.7 · 9.5 · 7.9 셋 중 고른 규격 아닌 줄 · 폼타이 「아님」 이면 셋 다 · -타설길이 문턱으로 고른 장비 아닌 줄). 화면이 숨김(753-2). -셈 · 금액 · 줄 차례 그대로 · 덧칸만. - -가름(0 을 낸 마디를 거슬러 감): -- `만약` = 간 갈래가 상수 0 → 꺼짐(조건 = 고르기 · 수 입력 문턱 · 중간값 모두) · - 아니면 간 갈래 안으로. -- 곱 = 0 인 인수 중 하나라도 꺼짐 · 나눗셈 = 분자 · 더하기 · 빼기 = 두 쪽 다 0 이고 하나라도 꺼짐 · - 끝수 함수 = 첫 인수 · 최소 · 최대 = 0 인 인수 중 꺼짐 · 중간값 이름 = 그 식으로. -- 입력 값 · 표 값 · 요소 · 로직 부름 · 원문 0 = 진짜 0(안 꺼짐 · 구멍땜 개소 0 · 표 칸 0 등). -""" - -from __future__ import annotations - -from decimal import Decimal - -import master_formula as mf - -KEY = "옵션꺼짐" -_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, RecursionError) -_SOURCES = ("name", "find", "field", "ref", "logic") # 값이 입력 · 표에서 오는 마디 - - -class _Trace: - def __init__(self, master, row: dict, env: dict): - self.master, self.env = master, env - self.steps = {s["이름"]: s["식"] for s in row.get("중간") or []} - self.memo: dict[str, bool] = {} - - def zero(self, node) -> bool: - value = mf.evaluate(node, self.env, self.master) - return not isinstance(value, bool) and value == 0 - - def off(self, node, depth: int = 0) -> bool: - """이 마디 값 0 이 옵션 갈래 탓인지.""" - kind = node[0] - if depth > 40: - return False - if kind == "name": - name = node[1] - if name not in self.steps: - return False - if name not in self.memo: - self.memo[name] = False # 돌고 도는 이름 막음 - self.memo[name] = self.off(mf.parse(self.steps[name]), depth + 1) - return self.memo[name] - if kind == "neg": - return self.off(node[1], depth + 1) - if kind == "bin": - sides = node[2:4] - if node[1] == "*": - return any(self.zero(x) and self.off(x, depth + 1) for x in sides) - if node[1] == "/": - return self.off(node[2], depth + 1) - if node[1] in ("+", "-"): - both = all(self.zero(x) for x in sides) - return both and any(self.off(x, depth + 1) for x in sides) - return False - if kind != "call" or not node[2]: - return False - items = node[2] - if node[1] == "만약": - taken = items[1] if mf.evaluate(items[0], self.env, self.master) else items[2] - fixed = not any(x[0] in _SOURCES for x in mf.walk(taken)) - if fixed and self.zero(taken): - return True - return self.off(taken, depth + 1) - if node[1] in ("최소", "최대"): - return any(self.zero(x) and self.off(x, depth + 1) for x in items) - return self.off(items[0], depth + 1) - - -def tag(master, row: dict, lines: list[dict], env: dict) -> list[dict]: - """엔진 `run` 호표 줄(덧줄 앞)에 `옵션꺼짐` — 수량 0 인 줄만 가름 · 못 가름 = 안 붙임.""" - trace = None - for item, line in zip(row.get("호표") or [], lines): - qty = line.get("수량") - if not isinstance(qty, Decimal) or qty != 0: - continue - trace = trace or _Trace(master, row, env) - try: - if trace.off(mf.parse(item["수량"])): - line[KEY] = True - except _ERRORS: - continue - return lines diff --git a/resources/master_data/scripts/master_material.py b/resources/master_data/scripts/master_material.py index b12cf25f7..b0a938059 100644 --- a/resources/master_data/scripts/master_material.py +++ b/resources/master_data/scripts/master_material.py @@ -3,7 +3,7 @@ ⚠ 낮은 값 고르기는 **시험 계산용**. 최저가·견적 고르기는 프로젝트 몫 — 마스터는 값을 모으기만 함. -`master_formula` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음. +수식 문서 계산기 · `master_base` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_base` 는 끝에서 읽음. """ from __future__ import annotations diff --git a/resources/master_data/scripts/master_pick.py b/resources/master_data/scripts/master_pick.py index e17db0c85..b39d927ca 100644 --- a/resources/master_data/scripts/master_pick.py +++ b/resources/master_data/scripts/master_pick.py @@ -1,8 +1,8 @@ # -*- coding: utf-8 -*- """재료 줄의 기본 검색어 찾기 · 고른 품목 · 단위 환산 · 단위 경고 (PLAN 8-1 계약). -`master_formula.run` 이 재료 줄 단가를 풀 때 부름 — 요소 객체에 `검색어` 가 있으면 여기서 찾고, -없으면 옛 길(`master_material` 조건 · 대표). 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음. +수식 문서 계산기가 재료 줄 단가를 풀 때 부름 — 요소 객체에 `검색어` 가 있으면 여기서 찾고, +없으면 옛 길(`master_material` 조건 · 대표). 서로 부르는 모듈이라 `master_base` 는 끝에서 읽음. """ from __future__ import annotations diff --git a/resources/master_data/scripts/master_sheet_line.py b/resources/master_data/scripts/master_sheet_line.py deleted file mode 100644 index 21a037592..000000000 --- a/resources/master_data/scripts/master_sheet_line.py +++ /dev/null @@ -1,199 +0,0 @@ -# -*- coding: utf-8 -*- -"""계산서 줄 덧칸 — 「쓰는 입력」 · 묶음 · 기준단위 · 환산 근거(PLAN 714-1 · 요구서 4장 5 · 8). - -`master_text.lines` 답(비목 묶음 줄)에 줄마다 덧칸을 얹음 — M01 `/text` 와 M02 `/logic-lib/sheet` -두 길이 같은 함수(`annotate`)를 거쳐 같은 줄 꼴(`KEYS`)을 냄. 셈은 `master_formula.run` 한 벌. -- `쓰는입력` = 그 줄 값(수량 식 · 요소 · 덧줄 식)에 쓰인 로직 입력 이름 — 중간값을 거슬러 감 · - 덧줄이 부르는 비목 합 · 줄 금액은 거스르지 않음(율 식에 직접 쓴 입력만). -- `묶음` · `장비` = 712-1 `master_bundle`(엔진 줄 덧칸 그대로). -- `펼침`(장비 줄만 · 714-1b) = 부른 기계경비 로직의 계산서 줄(조종원 · 주연료 · 잡재료비 · 기계손료 …) · - 시간당 비목 소계 · 계 · 부른 키 · 인자 — 셈 결과를 그대로 실음(환산 규칙을 여기 두지 않음). -- `옵션꺼짐` = 엔진 줄 덧칸 그대로(753-1 `master_gate` · 옵션 갈래로 0 인 줄 · 화면이 숨김). -- `기준단위` = 그 줄 수량 식이 찾는 표의 기준(「10㎡」 · 712-3 `master_basis.basis`) · 답 머리 - `기준단위` = 로직 결과단위 분모(「10㎡」 · 여럿이면 「㎡ · ㎥」). -- `환산근거` = 표 기준배 ↔ 결과단위 배(「10㎡당 → 1㎡당 ÷10」) · 재료 품목 단위 ↔ 줄 단위 - (712-2 `master_unit.note`) · 없으면 「」. -줄 차례 맞춤 = `master_text.lines` 와 같은 차례(호표 줄마다 `_shares` 비목 · 뒤 덧줄). -`files` 자리 = 파일 묶음 또는 Master(M02 SK 고친 줄 `_Over` · 750-1 · `_spread` 도 그대로 넘김). -""" - -from __future__ import annotations - -import re -from decimal import Decimal - -import master_basis as mbs -import master_bundle as mb -import master_formula as mf -import master_gate as mg -import master_text as mtx -import master_unit as mu - -KEYS = ("쓰는입력", "묶음", "장비", "기준단위", "환산근거", "펼침", "옵션꺼짐") -_HOLE = re.compile(r"\{([^{}]+)\}") -_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) - - -def _names(expr) -> tuple[set[str], set[str]]: - """식 하나의 (이름 · 찾는 표 키) — `{입력}` 구멍 이름도 셈.""" - if isinstance(expr, dict): # 재료 고르기 조건 묶음 — 값 글의 구멍만 - return {h for v in expr.values() for h in _HOLE.findall(str(v))}, set() - if expr in (None, ""): - return set(), set() - try: - tree = mf.parse(expr) - except mf.FormulaError: - return set(_HOLE.findall(str(expr))), set() - names, tables = set(), set() - for node in mf.walk(tree): - if node[0] == "name": - names.add(node[1]) - elif node[0] in ("find", "logic", "ref"): - names |= set(_HOLE.findall(node[1])) - if node[0] == "find": - tables.add(node[1]) - return names, tables - - -def _closure(row: dict, exprs: list) -> tuple[list[str], list[str]]: - """식들이 쓰는 (입력 이름 · 표 키) — 중간값은 그 식으로 거슬러 감 · 입력 차례대로.""" - steps = {s["이름"]: s["식"] for s in row.get("중간", [])} - inputs = [s["이름"] for s in row.get("입력", [])] - seen, tables, todo = set(), [], list(exprs) - while todo: - names, found = _names(todo.pop()) - tables += [t for t in sorted(found) if t not in tables] - for name in names - seen: - seen.add(name) - if name in steps: - todo.append(steps[name]) - return [n for n in inputs if n in seen], tables - - -def _times(x: Decimal) -> str: - return format(x.normalize(), "f") - - -def _per_text(per: list[tuple[Decimal, str]]) -> str: - return " · ".join(dict.fromkeys(f"{_times(n) if n != 1 else ''}{u}" for n, u in per)) - - -def _basis(master, tables: list[str], env: dict) -> dict | None: - for ref in tables: - try: - got = mbs.basis(master.get(mf.fill(ref, env) if "{" in ref else ref)) - except (*_ERRORS, mf.EmptyInput): - continue - if got["갈래"] == "단위": - return got - return None - - -def _note(basis: dict | None, per: list, line: dict) -> str: - notes = [] - if basis and len(per) == 1: - times, one = per[0] - if mu.plain(basis["기준단위"]) == mu.plain(mbs.unit(one)) and basis["기준배"] != times: - ratio = basis["기준배"] / times - how = f"÷{_times(ratio)}" if ratio > 1 else f"×{_times(1 / ratio)}" - notes.append( - f"{_times(basis['기준배'])}{basis['기준단위']}당 → {_times(times)}{one}당 {how}" - ) - goods = line.get("품목") or {} - if goods.get("단위") and line.get("단위"): - notes.append(mu.note(goods["단위"], line["단위"])) - return " · ".join(n for n in notes if n) - - -def _fields(master, row, exprs, env, per, line: dict, bundle: tuple[str, bool] | None) -> dict: - uses, tables = _closure(row, exprs) - basis = _basis(master, tables, env) - out = { - "쓰는입력": uses, - "기준단위": f"{_times(basis['기준배']) if basis['기준배'] != 1 else ''}{basis['기준단위']}" - if basis - else None, - "환산근거": _note(basis, per, line), - } - if bundle: - out["묶음"] = bundle[0] - if bundle[1]: - out["장비"] = True - return out - - -def _spread(files: dict, master, item: dict, env: dict) -> dict: - """장비 줄이 부른 기계경비 로직 한 장 — `{키, 이름, 단위, 입력, 줄, 소계, 계}` · 못 셈 = 까닭.""" - node = mf.parse(item["요소"]) - key = node[1] - try: - key = mf.fill(key, env) if "{" in key else key - given = {k: mf.evaluate(v, env, master, 1) for k, v in node[2]} - got = mtx.lines(files, key, given) - except (*_ERRORS, mf.EmptyInput) as e: - return {"키": key, "까닭": str(e) or type(e).__name__} - if not got.get("ok"): - return {"키": key, "입력": given, "까닭": got.get("reason")} - groups = got.get("groups") or [] - return { - "키": key, - "이름": master.logic(key).get("이름") or "", - "단위": _per_text(mbs.result_per(master.logic(key).get("결과단위"))) or None, - "입력": given, - "줄": [ - {"비목": g["비목"], **{k: one.get(k) for k in ("이름", "글", "금액")}} - for g in groups - for one in g["줄"] - ], - "소계": {g["비목"]: g.get("소계") for g in groups}, - "계": got.get("계"), - } - - -def annotate(files: dict, key: str, given: dict, answer: dict) -> dict: - """`master_text.lines` 답에 줄마다 `KEYS` 덧칸 · 머리 `기준단위` — 못 셈이면 답 그대로.""" - if not answer.get("ok") or "groups" not in answer: - return answer - master = files if hasattr(files, "logic") else mf.Master(files) - row = master.logic(key) - per = mbs.result_per(row.get("결과단위")) - answer["기준단위"] = _per_text(per) or None - try: - env = mtx._env_of(master, row, given) - except _ERRORS: - env = {} - if "결과" in row: - for line in answer["groups"][0]["줄"]: - line.update(_fields(master, row, [row["결과"]["식"]], env, per, {}, None)) - return answer - try: - result = mf.run(master, key, given) - except _ERRORS: - result = None - slots = {g["비목"]: iter(g["줄"]) for g in answer["groups"]} - items = row.get("호표") or [] - for n, item in enumerate(items): - line = result["줄"][n] if result else {} - if result: - parts = [p for p, _ in mtx._shares(line)] - elif item.get("종류") == "로직" and "비목" not in item: - parts = list(mf.COST_ITEMS) - else: - parts = [item.get("비목")] - exprs = [item.get("수량"), item.get("요소")] - got = _fields(master, row, exprs, env, per, line, mb.bundle(master, item, env)) - if line.get(mg.KEY): # 옵션으로 빠진 줄(753-1 · 엔진 줄 덧칸 그대로) - got[mg.KEY] = True - if got.get("장비"): - got["펼침"] = _spread(files, master, item, env) - for part in parts: - target = next(slots.get(part, iter(())), None) - if target is not None: - target.update(got) - for extra in row.get("덧줄") or []: - target = next(slots.get(extra["비목"], iter(())), None) - if target is not None: - target.update( - _fields(master, row, [extra["식"]], env, per, {}, mb.bundle(master, extra)) - ) - return answer diff --git a/resources/master_data/scripts/master_text.py b/resources/master_data/scripts/master_text.py deleted file mode 100644 index 789f310f9..000000000 --- a/resources/master_data/scripts/master_text.py +++ /dev/null @@ -1,671 +0,0 @@ -# -*- coding: utf-8 -*- -"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계. - -줄마다 글 두 꼴 — - · `글` 값 꼴: 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`· - 중간 값·요소는 글자로 내보내지 않고 그 자리에서 나온 수로 적음 - · `이름글` 이름 꼴: 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」 — 표 찾기·로직 - 부르기는 별칭 이름(`master_copy` 3-4 규칙) · 중간 값·입력은 그 이름 그대로 -두 꼴은 같은 줄에 나란히 있고 `짝` 번호가 붙음 — 화면 두 칸이 줄 맞춤으로 놓임. -줄마다 `조각`(PLAN 2-1 조각 계약) 도 같이 줌 — kind(요소·표·로직·값·기호·글) · 글 · 참조. -알약(요소·표·로직)이 될 자리는 구조만 보고 짓고, `만약()` 갈래만 골라야 해서 계산이 필요함 — -계산이 안 되면(FormulaError 따위) 갈래 양쪽을 다 내보내고 깊이를 적어 접을 수 있게 함. -호표 줄 계산 자체가 막혀도(재료 단가 없음 따위) 이름 식·조각은 `row` 구조만으로 그리고 -`글`·`금액`만 비움 — `만약() 과 무관` 인 그 60개 로직도 이름 식은 보이게. -금액 = 품셈 1-2-2 끝수 입힌 엔진 답(`master_cut.engine` · 줄 0.1 원 · 소계 1 원 버림) · 수 꼴 = -`common_util_money`(줄 금액 `fmt_line_money` · 단가 `fmt_price` · 수량 `fmt`). -계산은 `master_formula.run` 한 벌. -""" - -from __future__ import annotations - -from decimal import Decimal - -import master_copy as mc -import master_cut as mcut # 끝수(751-3) — 뿌리 길도 둠(아래 common_util) -import master_formula as mf -import master_text_item as mti - -from common_util.common_util_money import fmt, fmt_line_money, fmt_money, fmt_price # noqa: F401 - -PRICE_TAIL = {"인력": "노임", "기계": "손료"} # 단가 자리의 이름 꼬리(그 밖은 「단가」) -ELEM_KEYS = ("LB", "EQ", "MT", "MP", "MO") # 요소 테이블 — 그 밖의 열쇠(QC · QF …)는 별칭 이름 -ELEM_TAIL = {"LB": "노임", "EQ": "손료"} # 식 안 요소 키의 이름 꼬리(그 밖은 「단가」) -_PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3} -_PREC |= {"+": 4, "-": 4, "*": 5, "/": 5} -_RIGHT_TIGHT = ("-", "/") # 오른쪽 짝은 같은 세기라도 괄호가 필요함 -_CALC_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) # 계산 못 함 - - -# ── 식을 글로 — 값 꼴과 이름 꼴 ──────────────────────────────────────── -def render(node, env: dict, master, depth: int = 0) -> str: - """식 한 마디 → 값 꼴 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜.""" - return _draw(node, node, env, master, depth) - - -def _draw(show, real, env: dict, master, depth: int) -> str: - kind = show[0] - if kind == "num": - return fmt(show[1]) - if kind == "str": - return f"'{show[1]}'" - if kind == "neg": - return "-" + _draw(show[1], real[1], env, master, depth) - if kind == "bin": - return _bin(show, real, env, master, depth, _draw) - if kind == "call" and show[1] == "만약": # 걸린 쪽만 적음 - at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2 - return _draw(show[2][at], real[2][at], env, master, depth) - return _value(real, env, master, depth) - - -def named(show, real, env: dict, master, depth: int = 0) -> str: - """식 한 마디 → 이름 꼴 글. `show` = 부르기를 별칭으로 갈아 끼운 나무 · `real` = 원래 나무. - 이름·중간 값은 그대로 · 표 찾기·로직 부르기는 별칭 이름 · 요소는 그 이름.""" - kind = show[0] - if kind == "name": - return show[1] - if kind == "ref": - return _elem_name(master, show[1], env) - if kind == "field": - return f"{named(show[1], real[1], env, master, depth)}.{show[2]}" - if kind == "neg": - return "-" + named(show[1], real[1], env, master, depth) - if kind == "bin": - return _bin(show, real, env, master, depth, named) - if kind == "call": - if show[1] == "만약": # 값 꼴과 같은 쪽만 적어 두 칸이 짝이 되게 - try: - at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2 - except _CALC_ERRORS: # 조건 입력이 비면 식 그대로(아래 부르기 꼴) - at = 0 - if at: - return named(show[2][at], real[2][at], env, master, depth) - args = ", ".join(named(s, r, env, master, depth) for s, r in zip(show[2], real[2])) - return f"{show[1]}({args})" - if kind in ("num", "str"): - return _draw(show, real, env, master, depth) - return _value(real, env, master, depth) # 별칭이 안 붙은 부르기 — 값으로 - - -def _hole(master, ref: str, env: dict | None) -> tuple[list[str], dict | None]: - """자리 표시(`XX:품목:{입력}` · `XX:{입력}`) 든 참조 → (읽는 글 조각들, 입력으로 풀린 요소 줄). - 글 = 앞 글 + 지금 입력값(「휘발유 · 전국평균」) · 구멍뿐이면 입력 이름이 앞(「장비 · 굴착기」). - 입력이 비면 입력 이름만(「휘발유 · 지역」) · 못 풀면 줄은 None.""" - env = env or {} - tail = ref[3:] - holes = mf._HOLE.findall(tail) - words = [w.strip(": ") for w in mf._HOLE.split(tail)[::2] if w.strip(": ")] - try: - row = master.get(mf.fill(ref, env)) - except mf.FormulaError: - row = None - pure = not words and len(holes) == 1 - shown = [] - for name in holes: - value = env.get(name) - if value is None: - shown.append(name) - elif pure and row is not None: # 입력 하나가 요소 자리 전부 — 그 요소 이름 + 규격 - shown.append(f"{row.get('이름') or value} {row.get('규격') or ''}".strip()) - else: - shown.append(fmt(value) if isinstance(value, Decimal) else str(value)) - head = words or holes[:1] - return head + [one for one in shown if one not in head], row - - -def _elem_name(master, ref: str, env: dict | None = None) -> str: - """식 안 요소 한 줄의 이름 — 「석공노임」 꼴(같은 이름의 중간 값과 헷갈리지 않게).""" - if ( - str(ref)[:2] not in ELEM_KEYS - ): # 별칭 이름이 표 열쇠 그대로인 것(QC…) — 밑이름을 풀어쓰지 않음 - return ref - tail = ELEM_TAIL.get(str(ref)[:2], "단가") - try: - if "{" in str(ref): # 입력으로 풀린 요소 이름 · 못 풀면 입력 이름 - parts, row = _hole(master, ref, env) - name = mc.short(row.get("이름")) if row is not None else mc.plain("".join(parts)) - else: - name = mc.short(master.get(ref).get("이름")) - except mf.FormulaError: - name = "" - return f"{name}{tail}" if name else ref - - -def _value(node, env: dict, master, depth: int) -> str: - value = mf.evaluate(node, env, master, depth) - if isinstance(value, dict): # 로직 부르기 묶음 — 줄 금액에 쓰는 것은 「계」 - value = value.get("계") - return fmt(value) - - -def _bin(show, real, env: dict, master, depth: int, draw) -> str: - _, op, left, right = show - if op == "/" and right[0] == "num" and right[1] == 100: # 「… / 100」 은 퍼센트로 - return f"{_side(left, real[2], show, env, master, depth, draw, False)} %" - return ( - f"{_side(left, real[2], show, env, master, depth, draw, False)} {op} " - f"{_side(right, real[3], show, env, master, depth, draw, True)}" - ) - - -def _shown(show, real, env: dict, master, depth: int): - """만약() 은 걸린 갈래만 글이 됨 — 괄호를 정할 때는 그 갈래의 마디로 봄(못 가리면 그대로).""" - while show[0] == "call" and show[1] == "만약": - try: - at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2 - except _CALC_ERRORS: - break - show, real = show[2][at], real[2][at] - return show - - -def _side(show, real, parent, env: dict, master, depth: int, draw, right: bool) -> str: - text = draw(show, real, env, master, depth) - show = _shown(show, real, env, master, depth) - if show[0] != "bin": - return text - mine, up = _PREC[show[1]], _PREC[parent[1]] - if mine < up or (mine == up and right and parent[1] in _RIGHT_TIGHT): - return f"({text})" - return text - - -# ── 조각(알약) — PLAN 2-1 조각 계약 · 2-2 「이름 식을 계산 없이」 ────────── -_PIECE_SYM = {"+": "+", "-": "-", "*": "×", "/": "÷"} - - -def _p_val(text: str) -> dict: - return {"kind": "값", "글": text} - - -def _p_sym(text: str) -> dict: - return {"kind": "기호", "글": text} - - -def _alias_index(marks: list[dict]) -> dict[str, dict]: - """별칭 이름 → 별칭 한 줄(`master_copy.aliases` 결과) — 조각이 참조를 되찾을 때 씀.""" - return {m["이름"]: m for m in marks} - - -def _elem_piece(master, ref: str, env: dict | None = None) -> dict: - """요소 알약 — 글은 이름(못 찾아도 이름만). 자리 표시 든 참조는 글 = 이름 + 지금 입력값 · - 참조 = 입력으로 풀린 실제 키(못 풀면 참조 없음).""" - if "{" in str(ref): - parts, row = _hole(master, ref, env) - piece = {"kind": "요소", "글": " · ".join(parts)} - if row is not None: - key = str(row.get("키") or ref) - piece["참조"] = {"테이블": key[:2], "키": key} - return piece - piece = {"kind": "요소", "글": _elem_name(master, ref)} - try: - row = master.get(ref) - except mf.FormulaError: - return piece - key = str(row.get("키") or ref) - piece["참조"] = {"테이블": key[:2], "키": key} - return piece - - -def _row_label(table: dict, row: dict, conds: dict) -> list[str]: - """찾은 줄의 이름 — 조건마다 그 줄의 값(범위 칸은 찾은 범위).""" - out = [] - for cond, want in conds.items(): - have = row.get(cond, want) - if table.get("조건", {}).get(cond) == "범위" and isinstance(have, list): - low, high = ("" if x is None else fmt(x) for x in have) - out.append(f"{low}~{high}") - else: - out.append(fmt(have)) - return out - - -def _alias_piece(mark: dict, env: dict, master, column: str | None) -> dict: - """표 찾기·로직 부르기 알약 — 표는 글 = 「찾은 줄 · 칸」 · 참조.행 = 찾기 조건. - 다시 못 찾으면(입력이 비어서 따위) 별칭 이름만 남김.""" - piece = {"kind": "표" if mark["종류"] == "찾기" else "로직", "글": mark["이름"]} - try: - node = mf.parse(mark["원문"]) - ref = mf.fill(node[1], env) - if mark["종류"] == "찾기": - table = master.get(ref) - conds = {k: mf.evaluate(v, env, master, 0) for k, v in node[2]} - row = mf.find(table, conds, column) - tail = column.rpartition("_")[2] if column else "" - piece["글"] = " · ".join([*_row_label(table, row, conds), *([tail] if tail else [])]) - at = next(i for i, one in enumerate(table["줄"]) if one is row) # find 가 고른 줄 - piece["참조"] = {"테이블": ref[:2], "키": ref, "행": conds, "열": column, "줄": at} - else: - piece["글"] = str(master.logic(ref).get("이름") or ref) # 요소조각처럼 로직 이름 - piece["참조"] = {"테이블": ref[:2], "키": ref} - except _CALC_ERRORS: - pass # 다시 못 찾음 — 별칭 이름만 남김(값 자리 비움) - return piece - - -def _ga(word: str) -> str: - """받침이 없으면 「가」 · 있으면 「이」.""" - last = word[-1:] - return "이" if "가" <= last <= "힣" and (ord(last) - 0xAC00) % 28 else "가" - - -def _easy(show, real, env: dict, master) -> str: - if show[0] == "str": - return show[1] - try: - return named(show, real, env, master) - except _CALC_ERRORS: - return "" - - -def _cond_text(show, real, env: dict, master) -> str: - """만약 조건 → 쉬운 말 — 「폼타이 가 사용 이면」(같음) · 그 밖은 「식 이면」.""" - if show[0] == "bin" and show[1] == "==": - left = _easy(show[2], real[2], env, master) - return f"{left} {_ga(left)} {_easy(show[3], real[3], env, master)} 이면" - return f"{_easy(show, real, env, master)} 이면" - - -def _if_pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int) -> list[dict]: - """만약() 조각 — 「조건 이면 A · 아니면 B」 · 안 걸린 갈래는 흐림 · - 조건이 안 셈해지면(입력이 비어서 따위) 흐림 없이 두 갈래 다(깊이를 적어 접을 수 있게).""" - try: - taken = bool(mf.evaluate(real[2][0], env, master, 0)) - except _CALC_ERRORS: - taken = None - deeper = ifdepth if taken is not None else ifdepth + 1 - then = _pieces(show[2][1], real[2][1], env, master, alias_by_name, deeper) - other = _pieces(show[2][2], real[2][2], env, master, alias_by_name, deeper) - other.insert(0, {"kind": "글", "글": "· 아니면"}) - for one in then if taken is None else (): - one["깊이"] = deeper - for one in other if taken is None else (): - one["깊이"] = deeper - for one in then if taken is False else other if taken else (): - one["흐림"] = True - cond = {"kind": "글", "글": _cond_text(show[2][0], real[2][0], env, master)} - return [cond, *then, *other] - - -def _side_pieces( - show, real, parent_show, env: dict, master, alias_by_name: dict, ifdepth: int, right: bool -): - inner = _pieces(show, real, env, master, alias_by_name, ifdepth) - if show[0] != "bin": - return inner - mine, up = _PREC[show[1]], _PREC[parent_show[1]] - if mine < up or (mine == up and right and parent_show[1] in _RIGHT_TIGHT): - return [_p_sym("("), *inner, _p_sym(")")] - return inner - - -def _bin_pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int) -> list[dict]: - op = show[1] - if op == "/" and show[3][0] == "num" and show[3][1] == 100: # 「… / 100」 은 퍼센트로 - left = _side_pieces(show[2], real[2], show, env, master, alias_by_name, ifdepth, False) - return [*left, {"kind": "글", "글": "%"}] - left = _side_pieces(show[2], real[2], show, env, master, alias_by_name, ifdepth, False) - right = _side_pieces(show[3], real[3], show, env, master, alias_by_name, ifdepth, True) - return [*left, _p_sym(_PIECE_SYM.get(op, op)), *right] - - -def _pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int = 0) -> list[dict]: - """식 한 마디 → 조각 목록. 요소·표·로직 부르기는 알약(참조가 됨) · 나머지는 값·기호·글.""" - kind = show[0] - if kind == "num": - return [_p_val(fmt(show[1]))] - if kind == "str": - return [_p_val(f"'{show[1]}'")] - if kind == "neg": - return [_p_sym("-"), *_pieces(show[1], real[1], env, master, alias_by_name, ifdepth)] - if kind == "bin": - return _bin_pieces(show, real, env, master, alias_by_name, ifdepth) - if kind == "call" and show[1] == "만약": - return _if_pieces(show, real, env, master, alias_by_name, ifdepth) - if kind == "ref": - return [_elem_piece(master, show[1], env)] - if kind == "field" and show[1][0] == "name" and show[1][1] in alias_by_name: - return [_alias_piece(alias_by_name[show[1][1]], env, master, show[2])] - if kind == "name" and show[1] in alias_by_name: - return [_alias_piece(alias_by_name[show[1]], env, master, None)] - piece = _p_val(show[1] if kind == "name" else "") # 중간 값은 글에 그 이름 - if kind == "field" and show[1] == ("name", "줄"): # 덧줄이 부른 호표 줄 — 비면 그 줄 이름 - piece["글"] = show[2] - try: - value = _value(real, env, master, 0) - if value in ("None", ""): # 값이 빈 줄 — 빈 글 · 「None」 을 글로 안 찍음 - raise mf.FormulaError("값 없음") - piece.update({"값": value} if kind == "name" else {"글": value}) - except _CALC_ERRORS: - pass # 값 계산 자체가 막힘 — 이름만(그 밖은 빈 글) 남겨 줄이 안 죽게 - return [piece] - - -def _formula_pieces(text, env: dict, master, name_of: dict, alias_by_name: dict) -> list[dict]: - """식 글 한 줄의 조각 — 별칭을 씌운 나무와 원래 나무를 나란히 읽음(`_names` 와 짝).""" - real = mf.parse(text) - try: - show = mf.parse(mc.mask(text, name_of)) - except mf.FormulaError: - show = real - return _pieces(show, real, env, master, alias_by_name) - - -# ── 줄 세우기 ───────────────────────────────────────────────────────── -def _env_of(master, row: dict, given: dict, depth: int = 0) -> dict: - """입력 + 중간 — `run` 과 같은 차례로 다시 셈(덧줄 전 상태). - 아직 안 고른 입력이 있으면(값 넣기 전) 받은 것만 담아 돌려줌 — 이름 식은 값 없이도 지어짐 - (고른 값이 틀린 경우(고르기·범위 밖)는 지금처럼 그대로 막힘 — `mf._inputs` 가 걸러냄).""" - specs = row.get("입력", []) - if any(spec["이름"] not in given for spec in specs): - return {spec["이름"]: given[spec["이름"]] for spec in specs if spec["이름"] in given} - env = mf._inputs(row, given) - for step in row.get("중간", []): - try: - env[step["이름"]] = mf.evaluate(mf.parse(step["식"]), env, master, depth) - except mf.EmptyInput as e: # 못 구한 중간값 — `run` 과 같이 쓰는 줄만 비움 - env[step["이름"]] = mf.Blank(str(e)) - return env - - -def _why(item: dict, line: dict) -> str: - """단가를 못 구했거나 0 인 줄의 까닭 한 마디.""" - if line["수량"] == 0: - return "수량 0 — 이 조건에서는 안 쓰는 줄" - if line["단가"] not in (0, None): - return "" - where = item.get("요소") - where = "재료 고르기 조건" if isinstance(where, dict) else f"「{where}」" - return f"단가 0 — {where} 값이 아직 없음" - - -def _label(item: dict, line: dict) -> str: - spec = str(item.get("규격") or "").strip() - name = str(line.get("이름") or item.get("이름") or "") - return f"{name}({spec})" if spec else name - - -def _shares(line: dict) -> list[tuple[str, Decimal]]: - """글로 적을 (비목, 몫) — 비목이 나뉜 로직 줄은 몫이 없는 비목을 건너뜀. - 몫이 전부 0 이면 호표 줄이 사라지지 않게 첫 비목에 0 원 한 줄을 남김.""" - parts = list(line["비목"].items()) - if len(parts) <= 1: - return parts - return [(part, money) for part, money in parts if money != 0] or parts[:1] - - -def _loose(node, env: dict, master) -> bool: - """수량식 맨 위가 덧셈·뺄셈이면(곱 뒤에 오면 괄호가 필요함) · 만약은 걸린 갈래 기준.""" - if node[0] == "bin": - return _PREC[node[1]] < _PREC["*"] - if node[0] == "call" and node[1] == "만약": - try: - at = 1 if mf.evaluate(node[2][0], env, master, 0) else 2 - except _CALC_ERRORS: - return False # 이름 꼴은 「만약(…)」 부르기 그대로라 괄호 불필요 - return _loose(node[2][at], env, master) - return False - - -def _times(text: str, item: dict, env: dict, master) -> str: - """「단가 * 수량식」 의 수량식 — 덧셈·뺄셈 묶음이면 괄호.""" - return f"({text})" if _loose(mf.parse(item["수량"]), env, master) else text - - -def _line_text(item: dict, line: dict, env: dict, master, part: str | None) -> str: - """「단가 * 수량식 = 금액」 — 비목이 나뉜 로직 줄은 그 비목 몫만 · 빈 줄(금액 null)은 빈 글.""" - if line["금액"] is None: - return "" - qty = _times(render(mf.parse(item["수량"]), env, master), item, env, master) - money = line["비목"][part] if part else line["금액"] - price = line["단가"] if part is None or line["수량"] == 0 else money / line["수량"] - return f"{fmt_price(price)} * {qty} = {fmt_line_money(money)}" - - -def _item_names(items: list) -> list[tuple[str, str]]: - """호표 줄마다 (짧은 품명(규격·코드 뗌), 겹침 꼬리) — 한 로직 안에서 겹치면 꼬리 `_2`.""" - taken: set[str] = set() - out = [] - for item in items: - name = mc.short(item.get("이름")) or "값" - out.append((name, mc._free(name, taken)[len(name) :])) - return out - - -def _line_names( - item: dict, env: dict, master, part: str | None, name_of: dict, label: tuple[str, str] -) -> str: - """같은 줄을 변수 이름으로 — 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」.""" - name, dup = label - tail = PRICE_TAIL.get(str(item.get("종류") or ""), "단가") - price = f"{name}{part or ''}{tail}{dup}" - money = f"{name}{part}{dup}" if part else f"{name}비{dup}" - qty = _times(_names(item["수량"], env, master, name_of), item, env, master) - return f"{price} * {qty} = {money}" - - -def _extra_text(extra: dict, line: dict, env: dict, master) -> str: - if line["금액"] is None: # 빈 덧줄 — 식을 다시 셈하지 않음 - return "" - return f"{render(mf.parse(extra['식']), env, master)} = {fmt_line_money(line['금액'])}" - - -def _extra_names(extra: dict, env: dict, master, name_of: dict) -> str: - got = mc.short(extra.get("이름")) or "덧줄" - return f"{_names(extra['식'], env, master, name_of)} = {got}" - - -def _names(text, env: dict, master, name_of: dict) -> str: - """식 글 한 줄을 이름 꼴로 — 별칭을 씌운 나무와 원래 나무를 나란히 읽음.""" - real = mf.parse(text) - try: - show = mf.parse(mc.mask(text, name_of)) - except mf.FormulaError: # 별칭을 씌우면 못 읽는 글 — 값 꼴로 물러남 - show = real - return named(show, real, env, master) - - -def lines(files: dict, key: str, given: dict) -> dict: - """로직 한 줄의 읽는 식 — 비목 묶음마다 줄과 소계 · 돈 아닌 로직은 「결과」 묶음 하나. - 호표 줄 계산이 막히면(재료 단가 없음 따위) `row` 구조만으로 이름 식·조각을 짓고 - `글`·`금액`은 비움(입력 자체가 없는 경우는 지금처럼 그대로 막힘 — `_env_of` 에서 걸림).""" - master = files if hasattr(files, "logic") else mf.Master(files) # Master 째(750-1) - row = master.logic(key) - env = _env_of(master, row, given) - marks = mc.aliases(row, master) - name_of = mc.names(marks) - alias_by_name = _alias_index(marks) - try: - result = mcut.engine(master, key, mf.run(master, key, given)) - except _CALC_ERRORS: - result = None - - if "결과" in row: - 조각 = _formula_pieces(row["결과"]["식"], env, master, name_of, alias_by_name) - got = mc.short(row.get("이름")) or "결과" - shown = ( - fmt_money if str(row.get("결과단위") or "").startswith("원") else fmt - ) # 돈 결과만 정수 - 이름글 = f"{_names(row['결과']['식'], env, master, name_of)} = {got}" - if result is not None: - one = { - "이름": row.get("이름") or "", - "글": f"{render(mf.parse(row['결과']['식']), env, master)} = " - f"{shown(result['결과'])}", - "이름글": 이름글, - "금액": result["결과"], - "조각": 조각, - } - group = { - "비목": "결과", - "줄": [one], - "소계": result["결과"], - "끝수": _cut_note(row, "결과"), - } - 계 = result["결과"] - else: - one = { - "이름": row.get("이름") or "", - "글": "", - "이름글": 이름글, - "금액": None, - "조각": 조각, - } - group = {"비목": "결과", "줄": [one], "소계": None, "끝수": ""} - 계 = None - return _paired({"ok": True, "groups": [group], "계": 계, "별칭": marks}) - - made: dict[str, list] = {name: [] for name in mf.COST_ITEMS} - items = row.get("호표") or [] - labels = _item_names(items) - if result is not None: - shown = result["줄"] - env["줄"] = {r["이름"]: r["금액"] for r in shown if r["이름"]} - for n, (item, line, label) in enumerate(zip(items, shown, labels)): - 조각 = _formula_pieces(item["수량"], env, master, name_of, alias_by_name) - 요소 = _item_pieces(item, env, master, line, n) - for part, money in _shares(line): - split = part if len(line["비목"]) > 1 else None - one = { - "이름": _label(item, line), - "글": _line_text(item, line, env, master, split), - "이름글": _line_names(item, env, master, split, name_of, label), - "금액": money, - "조각": 조각, - "요소조각": 요소, - } - why = _why(item, line) - made[part].append({**one, "까닭": why} if why else one) - _extras(row, shown[len(items) :], made, env, master, name_of, alias_by_name) - 소계 = {name: result[name] for name in mf.COST_ITEMS} - 끝수 = _cut_note(row) - 계 = result["계"] - else: - for n, (item, label) in enumerate(zip(items, labels)): - parts = ( - list(mf.COST_ITEMS) - if item.get("종류") == "로직" and "비목" not in item - else [item.get("비목")] - ) - 조각 = _formula_pieces(item["수량"], env, master, name_of, alias_by_name) - 요소 = _item_pieces(item, env, master, None, n) - for part in parts: - if part not in mf.COST_ITEMS: - continue - split = part if len(parts) > 1 else None - made[part].append( - { - "이름": _label(item, {}), - "글": "", - "이름글": _line_names(item, env, master, split, name_of, label), - "금액": None, - "조각": 조각, - "요소조각": 요소, - } - ) - for extra in row.get("덧줄") or []: - made[extra["비목"]].append( - { - "이름": extra["이름"], - "글": "", - "이름글": ( - f"{_names(extra['식'], env, master, name_of)} = " - f"{mc.short(extra.get('이름')) or '덧줄'}" - ), - "금액": None, - "조각": _formula_pieces(extra["식"], env, master, name_of, alias_by_name), - } - ) - 소계 = dict.fromkeys(mf.COST_ITEMS, None) - 끝수 = "" - 계 = None - - groups = [ - {"비목": name, "줄": made[name], "소계": 소계[name], "끝수": 끝수} - for name in mf.COST_ITEMS - if made[name] - ] - return _paired({"ok": True, "groups": groups, "계": 계, "별칭": marks}) - - -def _arg_text(node, env: dict, master) -> str: - """로직 부르기 인자 값을 사람이 읽는 글로 — 요소 키는 이름 · 입력 자리는 지금 값.""" - try: - value = mf.evaluate(node, env, master, 0) - except _CALC_ERRORS: # 값 없는 입력 자리 — 이름만 - return str(node[1]) if node[0] in ("name", "str") else "" - if isinstance(value, str): - for ref in (value, f"EQ:{value}"): # 기계 입력은 원문번호(0602-0025) - try: - return mc.plain(master.get(ref).get("이름")) or value - except mf.FormulaError: - pass - return value - return fmt(value) - - -def _item_pieces( - item: dict, env: dict, master, line: dict | None = None, index: int = 0 -) -> list[dict]: - """줄의 단가 자리(요소 · 로직 부르기) 조각 — PLAN 3-1 요소조각.""" - ref = item.get("요소") - if item.get("종류") != "로직": - name = str(item.get("이름") or "") - if isinstance(ref, dict): # 재료 고르기 조건 — 잡힌 품목 이름 · 참조(고름 · 검색어 · 대표) - found = mti.piece(item, line, index, env, master) - return [found or {"kind": "요소", "글": name}] - piece = _elem_piece(master, ref, env) - return [{**piece, "글": name or piece["글"]}] - try: - node = mf.parse(ref) - key = mf.fill(node[1], env) - name = str(master.logic(key).get("이름") or key) - except _CALC_ERRORS: - return [{"kind": "로직", "글": str(item.get("이름") or "")}] - args = " · ".join(f"{k} {_arg_text(v, env, master)}" for k, v in node[2]) - out = [{"kind": "로직", "글": name, "참조": {"테이블": key[:2], "키": key}}] - return out + ([{"kind": "글", "글": args}] if args else []) - - -def _paired(answer: dict) -> dict: - """줄마다 짝 번호 — 두 칸(이름 꼴 · 값 꼴)이 같은 차례로 놓이게 1 부터.""" - at = 0 - for group in answer["groups"]: - for one in group["줄"]: - at += 1 - one["짝"] = at - one.setdefault("요소조각", []) - return answer - - -def _extras( - row: dict, shown: list, made: dict, env: dict, master, name_of: dict, alias_by_name: dict -) -> None: - """덧줄 — 앞선 줄까지의 비목 합을 넣고 한 줄씩(식 안의 비목 이름은 그 수로 바뀜).""" - sums = { - name: sum((one["금액"] or 0 for one in made[name]), Decimal(0)) for name in mf.COST_ITEMS - } - for extra, line in zip(row.get("덧줄") or [], shown): - env.update(sums) - one = { - "이름": extra["이름"], - "글": _extra_text(extra, line, env, master), - "이름글": _extra_names(extra, env, master, name_of), - "금액": line["금액"], - "조각": _formula_pieces(extra["식"], env, master, name_of, alias_by_name), - } - made[extra["비목"]].append(one) - if line["금액"] is not None: # 빈 덧줄은 합·이름 값에 안 넣음 - sums[extra["비목"]] += line["금액"] - env[extra["이름"]] = line["금액"] - - -def _cut_note(row: dict, on: str = "계") -> str: - """소계에 붙일 끝수 한 마디 — 끝수는 따로 줄로 보이지 않음.""" - rule = row.get("끝수") - if not isinstance(rule, dict) or rule.get("대상") != on: - return "" - place = int(rule.get("자리") or 0) - where = "원 미만" if place == 0 else f"소수 {place + 1}째 자리에서" - return f"{where} {rule.get('방법')}" diff --git a/resources/master_data/scripts/master_text_item.py b/resources/master_data/scripts/master_text_item.py deleted file mode 100644 index c58bc1654..000000000 --- a/resources/master_data/scripts/master_text_item.py +++ /dev/null @@ -1,38 +0,0 @@ -# -*- coding: utf-8 -*- -"""재료 줄 요소조각 — 잡힌 자재품목 이름 · 참조(PLAN 8-5). `master_text._item_pieces` 가 부름.""" - -from __future__ import annotations - -import re - -import master_formula as mf -import master_pick as mp - -_ERRORS = (mf.FormulaError, KeyError, TypeError) - - -def picked(item: dict, line: dict | None, index: int, env: dict, master) -> dict | None: - """재료 줄이 잡은 자재품목 줄 — 계산한 줄의 출처(`MT000018.거래가격`) 먼저 · - 빈 줄이면 고름 · 검색어 · 대표로 다시 찾음. 못 찾으면 None.""" - got = str((line or {}).get("출처") or "")[:8] - try: - if got[:2] == "MT": - return master.get(got) - cond = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()} - key = (mp.CHOSEN.get() or {}).get(str(index)) - if not key and cond.get("검색어"): - key = mp.pick(master, cond, env, item.get("단위")) - key = key or cond.get("대표") - return master.get(str(key)) if key and str(key)[:2] == "MT" else None - except _ERRORS: - return None - - -def piece(item: dict, line: dict | None, index: int, env: dict, master) -> dict | None: - """요소조각 — 글 = 품목 이름(지역 포함) · 참조 = 테이블 MT · 그 키. 못 찾으면 None.""" - row = picked(item, line, index, env, master) - if row is None: - return None - key = str(row["키"]) - name = re.sub(r"\s+", " ", str(row.get("이름") or "")).strip() - return {"kind": "요소", "글": name, "참조": {"테이블": key[:2], "키": key}} diff --git a/resources/tester/test_855_sk_layers.py b/resources/tester/test_855_sk_layers.py index f496cfd1e..f6e1ff305 100644 --- a/resources/tester/test_855_sk_layers.py +++ b/resources/tester/test_855_sk_layers.py @@ -85,19 +85,16 @@ def test_층_SK_한_길_줄_합_기준(world, body): _one_path(_run(me, _doc(me, key)), _screen(me, key)) -def test_옛_엔진_안_돎(world, monkeypatch): - """한 번 셈에 옛 엔진(`master_formula.run`) 부름 0 · 옛 줄 셈 함수 없음(855-E 2-E4).""" - import importlib +def test_옛_엔진_안_돎(world): + """옛 엔진 모듈(`master_formula` 무리) 없음 · 옛 줄 셈 함수 없음 · 한 번 셈 됨(855-E 2-E4).""" + import importlib.util me = world["personal"] key = _sk(me, 바탕={"로직": FORM}) - hits = [] - eng = importlib.import_module("master_formula") - real = eng.run - monkeypatch.setattr(eng, "run", lambda *a, **k: hits.append(1) or real(*a, **k)) + gone = ("master_formula", "master_formula_sum", "master_auto", "master_text", "master_equation") + assert [m for m in gone if importlib.util.find_spec(m)] == [] assert not hasattr(labor, "run_line") _one_path(_run(me, _doc(me, key))) - assert hits == [] @pytest.mark.parametrize(