test(855-E 2-E4 ㉮-5): test_793_2_san_emit 셈 = 불러온 그대로 수식 문서(옛 엔진 걷음)

- engine(out): 옛 master_formula.run → master_cut.engine 을 가져온 식 SK → Doc_Import.derive · run(단가기준 엑셀)으로 — STmate 233 블록 노 · 재 · 경 · 계 = 엑셀 = 참조 평가기 = 옛 엔진(전환 전 대조 다름 0)
- 글줄 · 단계 맞댐 = 제품 검산(Sangeun_Imported.check) — 줄 수 · 단계 수 옛과 같음(봉화 349 · 184 … 울진소광 208 · 112) · 틀림 0
- 옛 덧줄 검사 master_formula_sum.check 단언 지움(옛 엔진 칸 검사) · 단가 전파 · 이음 키 · 문법 견본 그대로

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 14:09:15 +09:00
co-authored by Claude Opus 5.5
parent e051fda8df
commit e554e2bc9c
+29 -49
View File
@@ -1,15 +1,17 @@
"""793-2a 지킴 — 경쟁사 산근 → 우리 엔진 로직 줄 꼴(`M02_San_Emit`) · 엔진 셈 = 엑셀.
"""793-2a 지킴 — 경쟁사 산근 → 가져온 줄 꼴(`M02_San_Emit`) · 불러온 그대로 수식 문서 셈 = 엑셀.
STmate 233 블록을 로직 JSON 으로(EST 엑셀 = 812-1 엑셀 읽기기 → 원파일 길 · `test_812_1` 이 지킴) 내보내 `master_formula.run` →
`master_cut.engine` 으로 셈 — 노 · 재 · 경 · 계 = 엑셀(STmate 계 꼬리 · EST 총괄표) =
STmate 233 블록을 가져온 줄로(EST 엑셀 = 812-1 엑셀 읽기기 → 원파일 길 · `test_812_1` 이 지킴)
내보내 가져온 식 SK → 수식 문서(`M02_Doc_Import.derive` · `run` · 단가기준 엑셀)로 셈 —
노 · 재 · 경 · 계 = 엑셀(STmate 계 꼬리 · EST 총괄표) =
참조 평가기(`M02_San_Eval`) · 줄마다(STmate 금액 줄 · EST 돈 · 값 줄) · 계표시(단계) 같음.
단가 전파 견본 = `_분석_649-G2` 4 장(보통인부 → 180,000) · 계약단가(낙찰률)는 B09 몫 — 엔진 계 ×
낙찰률 원 버림 = 엑셀 머리만 확인. 엑셀 = `helper_m02_hopyo_golden.FILES`(읽기만 · 없으면 skip).
옛 엔진(`master_formula.run` · `master_cut.engine`) 셈 · 덧줄 검사(`master_formula_sum.check`)는
855-E 2-E4 에서 문서 셈으로 바꿈.
"""
from __future__ import annotations
import importlib
import math
from functools import lru_cache
@@ -17,14 +19,13 @@ import helper_m02_hopyo_golden as golden
import pytest
from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠
from M02_MasterTemplete import M02_Doc_Import as dim
from M02_MasterTemplete import M02_San_Book as book
from M02_MasterTemplete import M02_San_Emit as em
from M02_MasterTemplete import M02_San_Eval as ev
from M02_MasterTemplete import M02_San_Stmate as stm
mf = importlib.import_module("master_formula")
mcut = importlib.import_module("master_cut")
ms = importlib.import_module("master_formula_sum")
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Imported as imp
def _nodes(rows):
@@ -44,19 +45,12 @@ LABOR = {"종류": "노임", "이름": "보통인부", "규격": "", "열쇠비
def engine(out: dict) -> dict:
"""내보낸 로직 → 엔진 셈 — 단가 줄은 SK 서버처럼 값을 얹음(요소 대신 값묶음 {비목: 단가})."""
logic = {**out["로직"], "키": "GX990001"}
items = []
for item in logic["호표"]:
one = {k: v for k, v in item.items() if k not in ("이음", "자원", "단가", "규격")}
if "단가" in item:
money = dict.fromkeys(K[:3], 0) | {item["비목"]: item["단가"]}
one |= {"종류": "로직", "값묶음": money}
del one["비목"]
items.append(one | {"요소": None})
logic["호표"] = items
master = mf.Master({"로직.json": {"그룹": "로직", "줄": [logic]}})
return mcut.engine(master, logic["키"], mf.run(master, logic["키"], {}))
"""내보낸 가져온 줄 → 가져온 식 SK → 불러온 그대로 수식 문서 셈(단가기준 = 엑셀 단가)."""
whole = imp._whole()
row = out["로직"]
sk = sd.clean({**imp.new_doc(row, out["원본"], row["이름"]), "키": "SK-999999"}, None, whole)
one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}}
return dim.run(dim.derive(one, None, whole), one, whole)
def hard(out: dict) -> list[str]:
@@ -82,31 +76,17 @@ def _stmate(tag: str, blk: dict) -> tuple[list, dict]:
return nodes, em.stmate(blk, nodes, _load(tag)["단가"], STMATE[tag][3])
def _lines_equal(out: dict, got: dict) -> tuple[list, int, int]:
"""원본 글줄마다 엔진 줄 금액(계) = 엑셀 · 단계 = 계표시 줄 → (틀린 것, 줄 수, 단계 수)."""
lines = {x["이름"]: x for x in got["줄"]}
steps = {x["이름"]: x for x in got.get("단계", [])}
bad, n_line, n_step = [], 0, 0
seen: dict[
tuple, list
] = {} # 814-1 세 줄 묶기 — 기계 노 · 재 · 경 글줄 셋 = 엔진 줄 하나(합으로 맞댐)
for g in out["원본"]["글줄"]:
if g.get("값") is None or not g.get("자리") or g["자리"].startswith("mid:"):
continue
if g["자리"].startswith("단계:"):
n_step += 1
have = float(steps[g["자리"][3:]]["계"])
if abs(have - g["값"]) >= 0.15:
bad.append((g["행"], g["글"].strip(), have, g["값"]))
else:
n_line += 1
seen.setdefault(tuple(g.get("자리들") or [g["자리"]]), []).append(g)
for names, group in seen.items():
have = sum(float(lines[n]["금액"] or 0) for n in names)
want = sum(g["값"] for g in group)
if abs(have - want) >= 0.05 * len(group):
bad.append((group[0]["행"], group[0]["글"].strip(), have, want))
return bad, n_line, n_step
def _lines_equal(out: dict) -> tuple[list, int, int]:
"""원본 글줄마다 문서 셈 줄 금액 · 단계 계 = 엑셀 — 불러올 때 검산(`Sangeun_Imported.check`) →
(틀린 것, 줄 수, 단계 수)."""
row = out["로직"]
sk = {**imp.new_doc(row, out["원본"], row["이름"]), "키": "SK-999999"}
got = imp.check(sk, imp._whole())
steps = sum(1 for x in got["줄"] if str(x.get("자리") or "").startswith("단계:"))
bad = [
(x.get("행"), x.get("자리"), x.get("셈"), x.get("엑셀")) for x in got["줄"] if not x["같음"]
]
return bad + ([got["까닭"]] if not got["같음"] else []), len(got["줄"]) - steps, steps
@pytest.mark.parametrize("tag", list(STMATE))
@@ -124,8 +104,8 @@ def test_stmate_engine_equals_excel(tag: str) -> None:
want = out["원본"]["엑셀금액"]
same = money(got) == tuple(round(want[k]) for k in K)
same &= money(got) == (ref["L"], ref["M"], ref["S"], ref["T"])
bad, a, b = _lines_equal(out, got)
bad += ms.check(out["로직"], blk["코드"]) + hard(out)
bad, a, b = _lines_equal(out)
bad += hard(out)
lines, steps = lines + a, steps + b
if deal := out["원본"].get("계약"): # B09 몫 — 엔진 계 × 낙찰률 원 버림 = 엑셀 머리
cut = [math.floor(round(int(got[k]) * deal["낙찰률"] / 100, 6)) for k in K[:3]]
@@ -222,7 +202,7 @@ def test_stmate_grammar_sample_engine() -> None:
{"이름": "q", "식": "(2.5 / 3)", "표시": 2},
{"이름": "q_2", "식": "(1 / 3)", "표시": 2}, # 다시 대입 = 새 이름
]
assert ms.check(logic, "견본") == [] and out["원본"]["표지"] == []
assert out["원본"]["표지"] == []
got = engine(out)
lines, tot = ev.run_stmate(nodes, prices)
want = ev.block_total(tot, "비목버림")