Files
Aislo/resources/tester/test_792_3_engine_paths.py
T
eomsangdonandClaude Opus 5.5 ec761d0948 refactor(857-3b): 불러온 단가산출 정본 = 수식 문서 — 저장본 가져온.로직 걷음 · 고침 길 = 문서 연결 · 옛 꼴 = 까닭 하나
- 저장 꼴: SK `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 원본, 단가기준, 검산, 연결?} · 가져온 줄(옛 로직 줄 꼴) 안 둠 · 다시 열기 = 저장 문서(Doc_Import.derive) · 고침 = 수식 따로 사본 · [초기화] = 가져온.문서
- 짓기: 불러올 때 한 번(Doc_Import.build · San_ToDoc · 줄 검사 = 문서 파서) · 검산 = 불러올 때 한 번(check_row · 옛 변환기 안 부름) · 뒤 저장 = 저장 파일 검산(화면 값 안 받음)
- 고침 길: 이음 고침 = 그 가져온 줄 값 변수 연결(자리 = 호표:i · 엑셀 값 기억) · 소요량 고름 = 문서 그 수 → 표 연결 변수 · 풂 = 수 되돌림(자리 = 문서 머리 가져온.자리) · [저장] 처음 = 고친 미리 보기 문서 위에 안쪽 산근 참조 · 내 기계만 얹음(FromHopyo._onto) · 재료 고름 판 = 문서 머리 재료
- 둘레: 형제 SK 참조 = 문서 연결(Labor_Ref refs_in · _move_doc → imp.refs_of · move_refs) · 값 사본 닿을 것 = 문서 연결 + 기계 판정 키(Sangeun_Copy.stamp · reach_of) · B09 굳힌 사본 = 가져온 늘 실음 · 단가 묶음에 사본 요소(Item_Sangeun) · Doc_Sk old_only 가져온 식도 · frozen 가져온 식 빼고 · old_fp 옛 꼴만 · 우리 단가 색인 = 받은 색인 위(B09 사본 단가 전파)
- 옛 꼴 저장본(가져온.로직) = 읽지 않음 · 지우지 않음 · 셈 · 검산 · 고침 = 까닭 「옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장」 · 가져온 식 옛 칸 고침(덮개 · 더한줄 · 식 칸) = 못 셈(2-C1 과 같게)
- 857-3a 더한줄 갈래(San_ToDoc 요소 · 로직 부름) 걷음 · test_857_3a_import_adds 지움(가져온 식 옛 칸 = 죽은 길 · 대신 test_793_2 옛_칸_고침_못_셈 · 옛_꼴_저장본_까닭_하나)
- 화면: 가져온 식 판정 = 문서 | 옛 로직 · 옛 꼴 = 이음 · 소요량 안 부름(Hopyo_Imported_Model · Hopyo_Imported · Sangeun_Origin)
- 뜻한 바뀜: 불러온 문서 다듬기가 글줄 이름으로(저장 길에서도 지은 「율」 → 엑셀 글 머리 · 704 · test_809_1 · 812_3) · golden_855_b09 daega_inputs 다시 뜸 = 가져온 식 단가산출 = 수식 문서만 · 가져온.로직 없음 → 옛 굳힘 ROW 가 줄을 못 지음(B09 대가 블록 가져온 식 줄 0 · 금액 calc_user · 수요 · 산근 그대로 · B9-5 문서 셈 줄 뒤 다시 확인) · test_792_3 실무 가져온 식 대가 = 금액만(ROW 번지 · 단계 = 옛 굳힘 꼴)
- 시험 고침: 옛 꼴 SK 손으로 짓던 견본 → imp.new_doc(793_2 · 797_1 · 797_2 · 802_4b1 · 809_1 · 810_2 · 857 도우미) · 로직 줄 읽던 단언 → 문서 변수 · 머리(793_3b · 821_4 · 827_3 · 835_1) · 옛 엔진 대조 · 옛 식 칸 가져온 식 길 걷음(802_4b1 · 796_2b)
- 지킴: 857 골든 전수 같음(블록 3,241 두 판 · 검산 · 이음) · 812_1 전수 31 · 793 · 848_6 · 848_7 · 851_2 · 855 112 통과 · 관련 694 통과(실패 = 719_1 둘 · 719_2 셋 · 826_1 — 고치기 전에도 같음 · 나머지 = 이 커밋에서 고침) · typecheck 0 · 화면 8010 엑셀 · STC 저장 · 다시 열기 · 두 판 · 이음 고침 · 시간당 식 · 초기화 · 내 일위대가로(안쪽 SK 새 꼴) · 콘솔 0 · 서버 오류 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:44:45 +09:00

222 lines
9.7 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 _b09_daega(build) -> dict:
master, row, _ = build()
sk = {"종류": sd.TITLE, "키": "SK-990001", "이름": "시험", "단위": "식",
"바탕": {"로직": _key(row)}, "입력값": {}, "덮개": {}, "더한줄": [], "뺀줄": [],
item_sk.ROW: row, "정체": []} # fmt: skip
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 가져온 식 = 수식 문서만(가져온 줄 없음) → 굳힌 사본도 문서 셈(옛 굳힘 ROW 번지 · 단계 없음 ·
# B09 대가 블록 줄 = B9-5 문서 셈 줄 뒤 다시 확인)
from M02_MasterTemplete import M02_Sangeun_Calc as calc
over = sc._Over(whole, frozen["바탕"]["로직"], json.loads(json.dumps(frozen[item_sk.ROW])))
unit = calc.run(sd.clean(frozen, None, over), over)["1단위"]
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 원 모자람