충돌 넷 풀이: - M02_Item_Sangeun: B9-5 새 사본 꼴(수식 따로 사본 · 굳힘 표지) 바탕 — 857-3b 의 「가져온 칸 그대로 · 가져온 식 값 사본 자원 키」 는 새 꼴에서 SK 문서 통째 실음 · bundle_keys(값 사본 · 문서 요소 키)가 이미 담음 → 옛 굳힘 쪽(GX9 · _imported_reach) 안 살림 - test_792_3 실무 가져온 식: 857-3b 뜻(가져온.로직 없음 · M02 셈 = 엑셀) + B9-5 뜻(B09 대가 블록 = 엑셀) 둘 다 — 사본 셈 1 단위 = B09 대가 블록 금액 = 엑셀 - test_793_2: 857-3b 단언(가져온.문서 · 옛 칸 덮개 줄 없음 · 우리 단가 = 셈 색인 값 따라옴 = 사본이면 단가.json) 살림 · 사본 꼴 단언 = 수식 따로 사본 · 가져온.로직 없음 · import json 되살림 - golden_855_b09: 브레인 중간 값(가져온 식 블록 줄 0) 대신 B9-5 값 — daega_inputs 가져온 식 블록 줄 6 · m02 금액 같음 (합친 코드로 다시 셈해 같은 지문 = 다시 뜨지 않음) - 검증: 855_b09_golden · 792_3 · 793_* · 795_4 · 719_* · 848_1 · 848_7 · 848_10 · 855_2d_frozen · 855_sk_layers · 857_import_golden · 858_shelf_golden · 143 · 145 · 핵심 넷 · 855_golden 통과 · typecheck 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
237 lines
10 KiB
Python
237 lines
10 KiB
Python
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
|
"""792-3 · 792-4 엔진 새 의미 다섯 길 지킴 시험 — 같은 로직 JSON 이
|
|
① 엔진 직접(`master_cut.engine`) ·
|
|
② M02 단가산출 SK 셈(`M02_Sangeun_Calc.run`) · ③ 일위대가 SC 한 줄(수량 1 · `M02_Labor_Doc.calc`) ·
|
|
④ B09 산근 풀이(`B09_Estimation_Sangeun.Solver` · 841-1 단가 = M02 엔진) ·
|
|
⑤ B09 일위대가 대가 블록(SC → 사본 SK 참조 수량 1 · `Labor_Source.Builder` → `Calc_Labor` 파이썬 ·
|
|
TS 짝 · 내역 단가 `daega_price`)에서 같은 금액.
|
|
실무 견본(봉화 D00102 · 북부청임도 18)은 793-2 길(가져온 식 SK · 임시 층)로 만들어 ⑤ = 엑셀.
|
|
|
|
견본 = 791-1 실무 손 옮김 넷(봉화 D00102 · 울진소광 D01489 · 동부청영월 D00003 · 북부청임도 18 =
|
|
엑셀 금액) + 합밖 · 제외 · 조정 단위 로직. 켜쌓기율 · 별도계상 뒤 다시 버림(`master_cut.plain`)도
|
|
엔진 셈법(줄 자리 · 끝전 · 조정)을 지킴. 옛 로직(새 칸 없음) 전후 같음 = `test_791_1` M01 지문.
|
|
"""
|
|
|
|
import copy
|
|
import importlib
|
|
import json
|
|
from decimal import Decimal
|
|
|
|
import pytest
|
|
|
|
import resources.tester.test_791_1_engine_semantics as t
|
|
from B09_Estimation import B09_Estimation_Calc_Labor as dcalc
|
|
from B09_Estimation import B09_Estimation_Labor_Source as dsrc
|
|
from B09_Estimation import B09_Estimation_Sangeun as sg
|
|
from M02_MasterTemplete import M02_Item_Sangeun as item_sk
|
|
from M02_MasterTemplete import M02_Labor_Doc as labor
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_Sangeun_Calc as sc
|
|
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
|
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 임시 층
|
|
|
|
mcut = importlib.import_module("master_cut")
|
|
D = Decimal
|
|
COSTS = ("노무비", "재료비", "경비", "계")
|
|
PART = {"labor": "노무비", "material": "재료비", "expense": "경비", "sum": "계"}
|
|
EQ = "EQ990001"
|
|
|
|
|
|
def ms_uses(row) -> bool:
|
|
return importlib.import_module("master_formula_sum").uses(row)
|
|
|
|
|
|
def _units():
|
|
"""합밖 · 제외 단계 · 조정 · 큰나머지 · 줄 자리를 한 로직에(791-1 단위 견본 바탕)."""
|
|
master = t._base(
|
|
덧줄=[
|
|
{"이름": "공구손료", "식": "단계.'인부 소계'.노무비 * 3 / 100", "비목": "경비"},
|
|
{"이름": "잡", "식": "번지.A01.재료비 * 1.5 / 100", "비목": "재료비"},
|
|
{"이름": "덧", "식": "0.6", "비목": "노무비", "자리": {"방법": "올림", "자리": 0}},
|
|
],
|
|
단계=[
|
|
{"이름": "자재 소계", "단": 1, "줄": ["갑", "을"]},
|
|
{"이름": "인부 소계", "단": 1, "줄": ["보통", "특별"]},
|
|
{"이름": "경비 소계", "단": 1, "줄": ["공구손료"], "제외": True},
|
|
],
|
|
끝전="큰나머지",
|
|
조정={"배율": {"재료비": D("0.9")}},
|
|
)
|
|
row = master.logic("GX990001")
|
|
row["호표"][1]["합밖"] = True
|
|
return master, row, None
|
|
|
|
|
|
CASES = {"봉화": t.봉화, "소광": t.소광, "영월": t.영월, "임도": t.임도, "단위": _units}
|
|
|
|
|
|
def _key(row) -> str:
|
|
return row["키"]
|
|
|
|
|
|
def _engine(master, row) -> dict:
|
|
got = t._calc(master, _key(row))
|
|
return {k: got[k] for k in COSTS}
|
|
|
|
|
|
def _sk(master, row) -> dict:
|
|
doc = {"키": "SK-990001", "이름": "시험", "단위": "식", "바탕": {"로직": _key(row)}}
|
|
got = sc.run(sd.clean(doc, None, master), master)
|
|
return {k: got["기준"][k] for k in COSTS}
|
|
|
|
|
|
def _sc(master, row) -> dict:
|
|
mats = {
|
|
str(n): {"별도계상": "직접계산"} for n, x in enumerate(row["호표"]) if x["종류"] == "재료"
|
|
}
|
|
line = {"로직": _key(row), "입력값": {}, "수량": {"손": 1}, "자재표시": mats}
|
|
got = labor.calc({"담은로직": [line], "자재": []}, {}, whole=master, pills=[])
|
|
return {k: got["반영합"][k] for k in COSTS}
|
|
|
|
|
|
def _b09_master(master, row):
|
|
"""B09 = 기계 줄 단가를 중기목록표에서 — 기계경비 로직이 부르는 EQ 키를 잡게
|
|
시간당 로직에 한 줄."""
|
|
hour = copy.deepcopy(master.index["GX"].get("GX990009") or {})
|
|
if hour:
|
|
hour["호표"] = [t._mat(EQ, "1", "기계", 비목="경비")]
|
|
master.index["GX"]["GX990009"] = hour
|
|
master.index["EQ"] = {EQ: {"키": EQ, "이름": "시험 기계", "값": D(0)}}
|
|
return master
|
|
|
|
|
|
def _b09(build, row) -> dict:
|
|
master, row, _ = build()
|
|
master = _b09_master(master, row)
|
|
block = sg.Solver().add(master, {"code": _key(row), "given": {}}, None) # 841-1 엔진 단가
|
|
assert block["why"] is None, block["why"]
|
|
texts = [x for ln in block["lines"] for x in ln.get("text") or []]
|
|
assert not [x for x in texts if "못" in x or "빈칸" in x], texts # 산근 글도 같은 셈
|
|
assert block["foot"].endswith(f"= {block['sum']:,.0f}"), block["foot"]
|
|
return {PART[p]: D(str(block[p])) for p in PART}
|
|
|
|
|
|
OWNER = "pipe@100.0" # `test_145_2._ts` 가 내역 단가를 읽는 구조물 id
|
|
|
|
|
|
def _daega(whole, sk: dict, sheets: dict) -> dict:
|
|
"""⑤ SC(사본 SK 참조 수량 1) → 대가 블록 → 파이썬 셈 = TS 짝 → 내역 단가."""
|
|
from resources.tester.test_145_2_b09_labor_calc import _same, _ts
|
|
|
|
sk_ref, sc_ref = {"층": "project", "키": "SK-990001"}, {"층": "project", "키": "SC-990001"}
|
|
sc = {"종류": refs.TITLE["precombo"], "이름": "SC", "단위": "식",
|
|
"담은로직": [{"참조": sk_ref, "수량": {"손": 1}}]} # fmt: skip
|
|
build = dsrc.Builder()
|
|
bid = build.precombo(whole, sc_ref, sc, {refs.ref_id(sk_ref): sk, refs.ref_id(sc_ref): sc})
|
|
daega = dsrc._plain({"blocks": list(build.blocks.values()), "owners": {OWNER: bid}})
|
|
py = dcalc.compute_labor(daega, sheets)
|
|
ts = _ts(daega, sheets, {})
|
|
assert _same(json.loads(json.dumps(py, ensure_ascii=False)), ts["out"]) # 거울
|
|
price = dcalc.daega_price(py, OWNER)
|
|
assert _same(price, ts["price"])
|
|
return {PART[p]: D(str(price[p])) for p in PART}
|
|
|
|
|
|
def _copy(doc: dict, master) -> dict:
|
|
"""사본 SK(855-F B9-5 · `Item_Sangeun.freeze` 꼴) = SK 문서 + 수식 따로 사본 — 견본 로직은
|
|
M01 문서 밖이라 문서 = 견본 줄 변환 · 값 사본 = 견본 줄 전부."""
|
|
from M02_MasterTemplete import M02_Doc_Copy as dc
|
|
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
|
from M02_MasterTemplete import M02_Item_Prices as prices
|
|
|
|
rows = [r for part in master.index.values() for r in part.values()]
|
|
logic = prices.to_json([r for r in rows if "호표" in r])
|
|
res = prices.to_json([r for r in rows if "호표" not in r])
|
|
values = {"판": sc.skc._fp(logic), "로직": logic, "단가판": sc.skc._fp(res), "단가": res}
|
|
key = doc["바탕"]["로직"]
|
|
docs = dc.closure(master, [key])
|
|
root = {**docs[key], "키": doc["키"]}
|
|
return {**doc, dsk.KEY: dsk.norm({**values, "따로": True, "문서": root, "부름": docs})}
|
|
|
|
|
|
def _b09_daega(build) -> dict:
|
|
master, row, _ = build()
|
|
doc = {"키": "SK-990001", "이름": "시험", "단위": "식", "바탕": {"로직": _key(row)}}
|
|
sk = _copy(sd.clean(doc, None, master), master)
|
|
files = master.index
|
|
sheets = {
|
|
"labor": [{"key": k, "price": float(r["값"])} for k, r in files.get("LB", {}).items()],
|
|
"material": [
|
|
{"key": k, "price": float(r["물가자료"])} for k, r in files.get("MT", {}).items()
|
|
],
|
|
"machine": [],
|
|
"gaps": [],
|
|
}
|
|
return _daega(master, sk, sheets)
|
|
|
|
|
|
@pytest.mark.parametrize("name", list(CASES))
|
|
def test_다섯_길_같은_금액(name):
|
|
build = CASES[name]
|
|
master, row, want = build()
|
|
one = _engine(master, row)
|
|
if want is not None:
|
|
assert one == want # 엑셀 금액
|
|
assert _sk(*build()[:2]) == one
|
|
assert _sc(*build()[:2]) == one
|
|
assert _b09(build, row) == one
|
|
assert _b09_daega(build) == one # ⑤ B09 일위대가 대가 블록(792-4)
|
|
|
|
|
|
REAL = [("봉화", "D00102"), ("북부청임도", 18)]
|
|
|
|
|
|
@pytest.mark.parametrize(("tag", "code"), REAL)
|
|
def test_실무_가져온_식_SK_대가_내역_엑셀(tag, code, world):
|
|
"""793-2 길 — 경쟁사 블록 → 가져온 식 SK(임시 층) → 사본(수식 따로) → SC 줄 → B09 대가 →
|
|
내역 단가 = 엑셀."""
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
|
from resources.tester.test_793_2_sangeun_imported import _emitted
|
|
|
|
out = _emitted(tag, code)
|
|
with store.at(world["personal"]):
|
|
made = imp.create(out["로직"], out["원본"], f"{tag} {code}")
|
|
doc = store.read("sangeun", made["이름"])["문서"]
|
|
whole = m01.loaded()[1]
|
|
rid = "project||SK-990001"
|
|
frozen = item_sk.freeze({rid: sd.clean(doc, None, whole)})[rid]
|
|
# 857-3b 가져온 식 = 수식 문서만(가져온 줄 없음) · 사본(855-F B9-5) = 수식 따로 사본
|
|
assert frozen["수식"]["따로"] and not (frozen.get("가져온") or {}).get("로직")
|
|
unit = sc.run(frozen, whole)["1단위"] # M02 사본 셈
|
|
books = {"labor": [], "material": [], "machine": [], "gaps": []} # 엑셀 단가 = 고정 줄
|
|
got = _daega(whole, frozen, books) # B09 대가 블록(문서 셈 줄)
|
|
assert got == {k: D(str(round(float(v)))) for k, v in unit.items()}
|
|
excel = {k: D(str(round(v))) for k, v in out["원본"]["엑셀금액"].items()}
|
|
assert got == excel
|
|
|
|
|
|
def test_단위_로직_새_의미가_금액을_바꿈():
|
|
master, row, _ = _units()
|
|
got = _engine(master, row)
|
|
plain = copy.deepcopy(row)
|
|
for k in ("끝전", "조정", "단계"):
|
|
plain.pop(k)
|
|
for x in (*plain["호표"], *plain["덧줄"]):
|
|
for k in ("합밖", "자리", "번지"):
|
|
x.pop(k, None)
|
|
assert got != _engine(t._master([plain], t.LAB, t.MAT), plain) # 시험이 새 길을 거침
|
|
|
|
|
|
@pytest.mark.parametrize("name", ["영월", "단위"])
|
|
def test_다시_버림도_셈법_지킴(name):
|
|
"""켜쌓기율 · 별도계상 뒤 다시 버림(`plain`) — 셈법이 있으면
|
|
줄 자리 · 합밖 · 끝전 · 조정 그대로."""
|
|
master, row, _ = CASES[name]()
|
|
out = labor.run_line(master, _key(row), {})
|
|
assert "셈법" in out and out["단계"]
|
|
again = mcut.plain(out)
|
|
assert again["기준"] == out["기준"]
|
|
assert [x["계"] for x in again["단계"]] == [x["계"] for x in out["단계"]]
|
|
old = mcut.plain({k: v for k, v in out.items() if k != "셈법"})
|
|
if name == "영월":
|
|
assert (
|
|
old["기준"]["계"] == 5470 and again["기준"]["계"] == 5471
|
|
) # 옛 다시 버림 = 1 원 모자람
|