test(855-E 2-E4 ㉮-4): test_791_1 옛 엔진 의미 시험 은퇴 · 기대던 시험 가름

- test_791_1_engine_semantics · fixtures/m01_791_1_logic_fingerprint.json git rm — 옛 엔진(master_formula.run · master_cut.engine) 지문 · 791 새 칸(덧줄 · 단계 · 조정 · 끝전) 의미 · 견본 로직 줄 셈 — 문서 셈 금액은 test_855_golden(전수 1,521) · test_855_b09_golden 이 지킴
- test_792_3: 791 견본에서 출발한 옛 엔진 다섯 길 대조 · 단위 로직 새 의미 시험 지움 · 살아 있는 「가져온 식 SK → 사본 → SC → B09 대가 블록(파이썬 = TS) = M02 사본 셈 = 엑셀」(봉화 · 북부청임도) 그대로
- test_794_2b: 791 지문 건너뜀 시험 지움 · 개정 칸 · 잔토처리 그대로
- test_802_2 ⑤ 791 실무 견본 대조가 791_1 을 읽음 — 빌더 대조(sub7 L3 둘째 박자 은퇴 몫)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 14:04:28 +09:00
co-authored by Claude Opus 5.5
parent 120e47570e
commit e051fda8df
4 changed files with 6 additions and 2199 deletions
File diff suppressed because it is too large Load Diff
@@ -1,520 +0,0 @@
"""791-1 엔진 셈 의미 지킴 시험 — 금액번지 · 소계 단계 · 제외 · 줄 자리 · 블록 끝전 · 결과 조정 ·
특수 % · 변수 표시.
① 전후 같음 — M01 로직 전부(입력 = 자동값 + 기본값)의 날 셈 · 끝수 셈 지문 = 고치기 전 뜬 지문
(`fixtures/m01_791_1_logic_fingerprint.json` · 마스터 데이터가 바뀌면 건너뜀 → 이 파일을
바로 돌려 다시 뜸).
② 새 의미 단위 시험 · 검사.
③ 실무 손 옮김 견본 넷 — 원문 글(STmate 숨은 G 열 · EST 보이는 글)을 사람이 로직 꼴로 옮김 ·
단가 = 그 엑셀 목록표 값 · 노 · 재 · 경 · 계 = 엑셀(`helper_m02_hopyo_golden.FILES` · 649-G2).
"""
import hashlib
import importlib
import json
import sys
from decimal import Decimal
from pathlib import Path
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
mcut = importlib.import_module("master_cut")
mf = importlib.import_module("master_formula")
ms = importlib.import_module("master_formula_sum")
ROOT = Path(__file__).resolve().parents[2]
FINGER = Path(__file__).resolve().parent / "fixtures" / "m01_791_1_logic_fingerprint.json"
COSTS = ("노무비", "재료비", "경비", "계")
D = Decimal
# ── ① 전후 같음 ────────────────────────────────────────────────────────
def _master_hash() -> str:
h = hashlib.sha256()
for path in sorted((ROOT / "resources" / "master_data").glob("*.json")):
if not path.name.startswith("_"):
raw = path.read_bytes().replace(b"\r\n", b"\n") # 줄바꿈(CRLF/LF) 무관
h.update(path.name.encode() + raw)
return h.hexdigest()[:16]
def _given(whole, row) -> dict:
import master_auto as ma
given = ma.values(whole, row)
given.update({k: v for k, v in ma.defaults(whole, row).items() if v is not None})
return given
def _print(whole, row) -> str:
key = str(row["키"])
try:
raw = mf.run(whole, key, _given(whole, row))
text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False)
cut = mcut.engine(whole, key, raw)
text += json.dumps(cut, default=str, sort_keys=True, ensure_ascii=False)
except Exception as e: # 멈춤도 지문 — 멈춤 까닭이 바뀌어도 잡음
text = f"ERR {type(e).__name__} {e}"
return hashlib.sha256(text.encode()).hexdigest()[:16]
def fingerprints() -> dict:
files, whole = m01.loaded()
rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄", [])]
return {str(r["키"]): _print(whole, r) for r in rows}
def test_M01_로직_전부_전후_같음():
saved = json.loads(FINGER.read_text(encoding="utf-8"))
now = fingerprints()
diff = sorted(
set(now) ^ set(saved["결과"]) | {k for k in now if now[k] != saved["결과"].get(k)}
)
# 자료가 바뀌어도 건너뛰지 않음 — 셈 결과가 같으면 통과 · 다르면 실패(자료 탓이면 지문 다시 뜸)
why = "마스터 데이터 바뀜" if saved["마스터"] != _master_hash() else "엔진만 바뀜"
assert not diff, (
f"셈 결과 바뀐 로직 {len(diff)} 개({why}): {diff[:10]} — 자료를 뜻대로 고쳤으면 "
"엔진 고치기 전 커밋에서 지문 다시 뜸: python test_791_1_engine_semantics.py"
)
# ── 시험 마스터 ───────────────────────────────────────────────────────
def _master(logics: list[dict], labor: dict, mats: dict | None = None) -> mf.Master:
"""시험 전용 색인 — 인력 LB99 · 자재품목 MT99(물가자료) · 로직 GX99."""
files = {
"인력.json": {
"그룹": "인력",
"줄": [
{"키": k, "이름": n, "단위": "원/일", "값": D(v)} for k, (n, v) in labor.items()
],
},
"재료_자재품목.json": {
"그룹": "재료",
"줄": [
{"키": k, "이름": n, "단위": u, "물가자료": D(v)}
for k, (n, u, v) in (mats or {}).items()
],
},
"로직_시험.json": {"그룹": "로직", "줄": logics},
}
return mf.Master(files)
def _calc(master, key: str, given: dict | None = None) -> dict:
return mcut.engine(master, key, mf.run(master, key, given or {}))
def _money(got: dict) -> dict:
return {k: got[k] for k in COSTS}
def _line(got: dict, name: str) -> dict:
return next(x for x in got["줄"] if x["이름"] == name)
def _step(got: dict, name: str) -> dict:
return next(x for x in got["단계"] if x["이름"] == name)
def _man(key, qty, name, **more):
return {
"종류": "인력",
"요소": key,
"이름": name,
"단위": "인",
"수량": qty,
"비목": "노무비",
**more,
}
def _mat(key, qty, name, **more):
return {
"종류": "재료",
"요소": key,
"이름": name,
"단위": "식",
"수량": qty,
"비목": "재료비",
**more,
}
def _machine(qty, name, bundle):
"""기계 시간당 노 · 재 · 경 = 엑셀 중기목록표 값 그대로(M02 `값묶음` 길)."""
return {
"종류": "로직",
"요소": "로직(GX990009)",
"이름": name,
"단위": "hr",
"수량": qty,
"값묶음": dict(zip(("노무비", "재료비", "경비"), map(D, bundle))),
}
_HOUR = {
"키": "GX990009",
"이름": "시간당 기계경비(시험)",
"결과단위": "원/시간",
"입력": [],
"호표": [],
}
def _logic(key: str, **body) -> dict:
return {"키": key, "이름": key, "결과단위": "원/식", "입력": [], **body}
# ── ② 새 의미 단위 시험 ────────────────────────────────────────────────
LAB = {"LB990001": ("보통인부", 100000), "LB990002": ("특별인부", 200000)}
MAT = {"MT990001": ("자재 갑", "식", 1000), "MT990002": ("자재 을", "식", 3000)}
def _base(**body) -> mf.Master:
row = _logic(
"GX990001",
호표=[
_mat("MT990001", "1.23", "갑", 번지="A01"),
_mat("MT990002", "0.5", "을", 번지="A01"),
_man("LB990001", "0.0123", "보통", 번지="A02"),
_man("LB990002", "0.01", "특별", 번지="A02"),
],
**body,
)
return _master([row], LAB, MAT)
def test_옛_로직은_새_칸_없음():
master = _base()
for item in master.logic("GX990001")["호표"]:
del item["번지"]
got = _calc(master, "GX990001")
assert "단계" not in got and not ms.uses(master.logic("GX990001"))
assert _money(got) == {"노무비": 3230, "재료비": 2730, "경비": 0, "계": 5960}
def test_번지_율_밑():
master = _base(덧줄=[{"이름": "잡재료", "식": "번지.A01.재료비 * 10 / 100", "비목": "재료비"}])
got = _calc(master, "GX990001")
assert _line(got, "잡재료")["금액"] == D("273.0")
assert got["재료비"] == 3003
def test_단계_누계_제외_합밖():
master = _base(
덧줄=[{"이름": "공구손료", "식": "단계.'인부 소계'.노무비 * 3 / 100", "비목": "경비"}],
단계=[
{"이름": "자재 소계", "단": 1, "줄": ["갑", "을"]},
{"이름": "인부 소계", "단": 1, "줄": ["보통", "특별"]},
{"이름": "경비 소계", "단": 1, "줄": ["공구손료"], "제외": True},
{"이름": "계", "단": 2},
],
)
got = _calc(master, "GX990001")
assert _step(got, "인부 소계")["계"] == D("3230.0")
assert _line(got, "공구손료")["금액"] == D("96.9")
assert _step(got, "경비 소계") == {
"이름": "경비 소계",
"단": 1,
"노무비": 0,
"재료비": 0,
"경비": D("96.9"),
"계": D("96.9"),
"제외": True,
}
assert _step(got, "계")["계"] == D("5960.0") # 제외 단계는 위로 안 올라감
assert _money(got) == {"노무비": 3230, "재료비": 2730, "경비": 0, "계": 5960}
# 합밖 = 번지엔 쌓되 합에서 뺌
row = master.logic("GX990001")
row["호표"][1]["합밖"] = True
got = _calc(master, "GX990001")
assert got["재료비"] == 1230 and _step(got, "자재 소계")["재료비"] == D("2730.0")
def test_줄_자리_셋():
for way, want in (("반올림", 124), ("올림", 124), ("버림", 123)): # 123.5
master = _base(
덧줄=[{"이름": "덧", "식": "123.5", "비목": "경비", "자리": {"방법": way, "자리": 0}}]
)
assert _line(_calc(master, "GX990001"), "덧")["금액"] == want
master = _base(
덧줄=[
{"이름": "덧", "식": "123.456", "비목": "경비", "자리": {"방법": "반올림", "자리": 2}}
]
)
assert _line(_calc(master, "GX990001"), "덧")["금액"] == D("123.46")
def test_블록_끝전_둘():
body = {"덧줄": [{"이름": "경", "식": "0.6", "비목": "경비"}]} # 노 3230.0 · 재 2730.0 · 경 0.6
assert _calc(_base(**body), "GX990001")["계"] == 5960
got = _calc(_base(끝전="큰나머지", **body), "GX990001")
assert _money(got) == {"노무비": 3230, "재료비": 2730, "경비": 0, "계": 5960}
# 원 미만이 모여 1 원이 되면 큰 나머지 비목에 · 같으면 경 › 재 › 노
body = {
"덧줄": [
{"이름": "노", "식": "0.6", "비목": "노무비"},
{"이름": "경", "식": "0.6", "비목": "경비"},
]
}
assert _calc(_base(**body), "GX990001")["계"] == 5960
got = _calc(_base(끝전="큰나머지", **body), "GX990001")
assert _money(got) == {"노무비": 3230, "재료비": 2730, "경비": 1, "계": 5961}
def test_결과금액_조정():
got = _calc(_base(조정={"옮김": "경비"}), "GX990001")
assert _money(got) == {"노무비": 0, "재료비": 0, "경비": 5960, "계": 5960}
got = _calc(_base(조정={"배율": {"노무비": D("0.5")}}), "GX990001")
assert _money(got) == {"노무비": 1615, "재료비": 2730, "경비": 0, "계": 4345}
assert mf.run(_base(조정={"옮김": "재료비"}), "GX990001", {})["재료비"] == D("5960.0")
def test_특수_퍼센트_누계와_앞_소계():
master = _base(
덧줄=[
{"이름": "L%", "식": "노무비 * 2 / 100", "비목": "경비"}, # 처음부터 노무비 누계
{"이름": "T%", "식": "단계.'소계'.계 * 0.8", "비목": "경비"}, # 바로 앞 소계 × 수량
],
단계=[{"이름": "소계", "단": 1, "줄": ["갑", "을"]}],
)
got = _calc(master, "GX990001")
assert _line(got, "L%")["금액"] == D("64.6")
assert _line(got, "T%")["금액"] == D("2184.0")
def test_변수_표시_반올림():
row = _logic(
"GX990002",
중간=[{"이름": "f", "식": "1 / 1.3", "표시": 2}, {"이름": "g", "식": "1 / 1.3"}],
결과={"식": "f * 100"},
)
got = mf.run(_master([row], LAB), "GX990002", {})
assert got["결과"] == D("77.00") and got["중간"]["g"] != D("0.77")
def test_검사():
def problems(**body) -> list[str]:
master = _base(**body)
return mf.check_logic(master, master.logic("GX990001"))[0]
assert problems(덧줄=[{"이름": "덧", "식": "번지.A01.재료비 * 1", "비목": "경비"}]) == []
assert any(
"없는 번지" in x
for x in problems(덧줄=[{"이름": "덧", "식": "번지.B09.계", "비목": "경비"}])
)
order = problems(
덧줄=[{"이름": "덧", "식": "단계.'소'.계", "비목": "경비"}],
단계=[{"이름": "소", "단": 1, "줄": ["갑", "덧"]}],
)
assert any("단계 순서" in x for x in order)
assert any(
"자리" in x
for x in problems(
덧줄=[{"이름": "덧", "식": "1", "비목": "경비", "자리": {"방법": "버림", "자리": 4}}]
)
)
assert any("끝전" in x for x in problems(끝전="합버림"))
assert any("단 「6」" in x for x in problems(단계=[{"이름": "소", "단": 6, "줄": ["갑"]}]))
assert any("없는 줄" in x for x in problems(단계=[{"이름": "소", "단": 1, "줄": ["없음"]}]))
assert any("조정 옮김" in x for x in problems(조정={"옮김": "계"}))
assert any(
"이 단계" in x
for x in problems(
단계=[{"이름": "가", "단": 1, "줄": ["갑"]}, {"이름": "나", "단": 1, "줄": ["갑"]}]
)
)
# ── ③ 실무 손 옮김 견본 넷 ─────────────────────────────────────────────
def 봉화():
"""봉화 단가산출근거 2909~2943 행 — `&M00081& * 1.03 * 0.327 :=A01` · `&PA01M:M& * 11'%'` ·
`&PA02L:S& * 1'%'` · `(=)` · `(==)` · 총계 45,652 · 34,119 · 11,192 · 341."""
row = _logic(
"GX990101",
호표=[
_mat("MT990101", "1.03 * 0.327", "합판(내수)", 번지="A01"),
_mat("MT990102", "0.038 * 0.327", "각재", 번지="A01"),
_man("LB990101", "5 / 50", "형틀목공", 번지="A02"),
_man("LB990102", "2 / 50", "보통인부", 번지="A02"),
],
덧줄=[
{"이름": "소모자재(박리재 등)", "식": "번지.A01.재료비 * 11 / 100", "비목": "재료비"},
{
"이름": "공구손료 및 경장비 기계경비",
"식": "번지.A02.노무비 * 1 / 100",
"비목": "경비",
},
],
단계=[
{"이름": "자재비 소계", "단": 1, "줄": ["합판(내수)", "각재", "소모자재(박리재 등)"]},
{
"이름": "설치 소계",
"단": 1,
"줄": ["형틀목공", "보통인부", "공구손료 및 경장비 기계경비"],
},
{"이름": "계", "단": 2},
],
)
master = _master(
[row],
{"LB990101": ("형틀목공", 274978), "LB990102": ("보통인부", 165545)},
{"MT990101": ("합판(내수)", "㎡", 11468), "MT990102": ("각재", "㎥", 500661)},
)
return master, row, {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652}
def test_봉화_D00102_합판거푸집_STmate_번지_율():
master, row, want = 봉화()
assert mf.check_logic(master, row)[0] == []
got = _calc(master, "GX990101")
assert _money(got) == want
assert [x["금액"] for x in got["줄"]] == [
D(x) for x in ("3862.5", "6221.2", "27497.8", "6621.8", "1109.2", "341.1")
]
assert [x["계"] for x in got["단계"]] == [D("11192.9"), D("34460.7"), D("45653.6")]
def 소광():
"""울진소광 32 호표(D01489) — `'공구손료 :'&S01045& * 2'%'`(S01045 단위 L% = 처음부터
노무비 누계) · `L = Q/10 =` 표시 2 · 계 줄 420,734 · 182,223 · 230,359 · 8,152
(계약단가 87.745 % 는 B09 몫)."""
row = _logic(
"GX990102",
중간=[
{"이름": "N", "식": "40"},
{"이름": "Q", "식": "200"},
{"이름": "L", "식": "Q / 10", "표시": 2},
{"이름": "Q1", "식": "360"},
{"이름": "A", "식": "5.2"},
],
호표=[
_mat("MT990103", "1", "낙석방지책"),
_man("LB990103", "1 / N", "용접공"),
_man("LB990104", "3 / N", "특별인부(지주)"),
_man("LB990105", "2 / N", "보통인부(지주)"),
_machine("1 / N * 8", "트럭탑재형 크레인 10톤", (49479, 16797, 22539)),
_man("LB990104", "4 / Q * L", "특별인부(와이어)"),
_man("LB990105", "2 / Q * L", "보통인부(와이어)"),
_man("LB990104", "4 / Q1 * A", "특별인부(철망)"),
_man("LB990105", "2 / Q1 * A", "보통인부(철망)"),
],
덧줄=[{"이름": "공구손료", "식": "노무비 * 2 / 100", "비목": "경비"}],
단계=[
{"이름": "재료비 계", "단": 2, "줄": ["낙석방지책"]},
{"이름": "인건비 소계", "단": 1, "줄": ["용접공", "특별인부(지주)", "보통인부(지주)"]},
{"이름": "크레인 소계", "단": 1, "줄": ["트럭탑재형 크레인 10톤"]},
{"이름": "지주 계", "단": 2},
{"이름": "와이어 계", "단": 2, "줄": ["특별인부(와이어)", "보통인부(와이어)"]},
{"이름": "철망 계", "단": 2, "줄": ["특별인부(철망)", "보통인부(철망)"]},
{"이름": "공구손료 계", "단": 2, "줄": ["공구손료"]},
{"이름": "합계", "단": 3},
],
)
master = _master(
[row, _HOUR],
{
"LB990103": ("용접공", 278326),
"LB990104": ("특별인부", 221506),
"LB990105": ("보통인부", 169804),
},
{"MT990103": ("낙석방지책", "경간", 227000)},
)
return master, row, {"노무비": 182223, "재료비": 230359, "경비": 8152, "계": 420734}
def test_울진소광_D01489_낙석방지책_STmate_L퍼센트():
master, row, want = 소광()
assert mf.check_logic(master, row)[0] == []
got = _calc(master, "GX990102")
assert _money(got) == want
assert _line(got, "공구손료")["금액"] == D("3644.4")
assert _step(got, "지주 계")["계"] == D("49824.2")
assert _step(got, "합계")["계"] == D("420735.3")
def 영월():
"""동부청영월 단가산출근거 54~103 행(D00003) — `f = 1/1.3 =` · `E=…=` ·
`Q = 3600*q*K*f*E/Cm =`(표시 2) · `&X00205L/M/S& / Q * 0.9` · 계 원 버림 + 큰 나머지
5,471 · 4,764 · 310 · 397."""
row = _logic(
"GX990103",
중간=[
{"이름": "q", "식": "0.7"},
{"이름": "f", "식": "1 / 1.3", "표시": 2},
{"이름": "K", "식": "0.9"},
{"이름": "Cm", "식": "20"},
{"이름": "E", "식": "(0.7 + 0.6) / 2 - 0.05", "표시": 2},
{"이름": "Q", "식": "3600 * q * K * f * E / Cm", "표시": 2},
],
호표=[
_man("LB990106", "(0.2 + 0.26) / 2 * 0.1", "인부"),
_machine("1 / Q * 0.9", "유압식 백호우 0.7㎥", (55700, 18015, 23128)),
],
단계=[
{"이름": "인력 소계", "단": 1, "줄": ["인부"]},
{"이름": "기계 소계", "단": 1, "줄": ["유압식 백호우 0.7㎥"]},
{"이름": "계", "단": 2},
],
끝전="큰나머지",
)
master = _master([row, _HOUR], {"LB990106": ("보통인부", 165545)})
return master, row, {"노무비": 4764, "재료비": 310, "경비": 397, "계": 5471}
def test_동부청영월_D00003_터파기_STmate_큰나머지_끝전():
master, row, want = 영월()
assert mf.check_logic(master, row)[0] == []
got = _calc(master, "GX990103")
assert got["중간"]["Q"] == D("52.39")
assert _money(got) == want
assert _step(got, "계")["계"] == D("5471.0")
row["끝전"] = "비목버림" # 비목 원 버림이면 1 원 모자람
assert _calc(master, "GX990103")["계"] == 5470
def 임도():
"""북부청임도 단가산출 18 번(문양거푸집) — `5,786.1 × 2% = 116`(그 줄만 반올림 0) ·
`인부소계 : 24,467.3` · 노무비 24,467 · 재료비 5,902 · 계 30,369."""
row = _logic(
"GX990104",
호표=[
_mat("MT990104", "1 * (1 / 0.72)", "문양거푸집(ABS코팅폼)"),
_man("LB990107", "0.07", "형틀목공"),
_man("LB990108", "0.03", "보통인부"),
],
덧줄=[
{
"이름": "잡재료비",
"식": "재료비 * 2 / 100",
"비목": "재료비",
"자리": {"방법": "반올림", "자리": 0},
}
],
단계=[{"이름": "인부소계", "단": 1, "줄": ["형틀목공", "보통인부"]}],
)
master = _master(
[row],
{"LB990107": ("형틀목공", 275790), "LB990108": ("보통인부", 172068)},
{"MT990104": ("문양거푸집(ABS코팅폼)", "㎡", 4166)},
)
return master, row, {"노무비": 24467, "재료비": 5902, "경비": 0, "계": 30369}
def test_북부청임도_18_문양거푸집_EST_줄_자리():
master, row, want = 임도()
assert mf.check_logic(master, row)[0] == []
got = _calc(master, "GX990104")
assert _line(got, "잡재료비")["금액"] == 116
assert _step(got, "인부소계")["계"] == D("24467.3")
assert _money(got) == want
del row["덧줄"][0]["자리"] # 기본 0.1 버림이면 엑셀과 1 원 다름
assert _calc(master, "GX990104")["계"] == 30368
if __name__ == "__main__": # 지문 다시 뜸 — 마스터 데이터가 바뀐 뒤 · 엔진 고치기 전 커밋에서만
data = {"마스터": _master_hash(), "결과": fingerprints()}
FINGER.write_text(
json.dumps(data, ensure_ascii=False, indent=1, sort_keys=True) + "\n", encoding="utf-8"
)
print(len(data["결과"]), "개 지문", FINGER, file=sys.stderr)
+5 -143
View File
@@ -1,108 +1,27 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""792-3 · 792-4 엔진 새 의미 다섯 길 지킴 시험 — 같은 로직 JSON 이
① 엔진 직접(`master_cut.engine`) ·
② M02 단가산출 SK 셈(견본 로직 줄 = M01 문서 밖 → 굳힌 옛 사본 = 못 셈 · 855-E 2-E4 에서 뺌) · ③ 일위대가 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 · 임시 층)로 만들어 ⑤ = 엑셀.
"""792-3 · 792-4 지킴 — 실무 견본(봉화 D00102 · 북부청임도 18)을 793-2 길(가져온 식 SK · 임시 층)로
만들어 사본 SK(수식 따로) → SC 줄 → B09 일위대가 대가 블록(`Labor_Source.Builder` → `Calc_Labor`
파이썬 · TS 짝 · 내역 단가 `daega_price`) = M02 사본 셈 = 엑셀.
견본 = 791-1 실무 손 옮김 넷(봉화 D00102 · 울진소광 D01489 · 동부청영월 D00003 · 북부청임도 18 =
엑셀 금액) + 합밖 · 제외 · 조정 단위 로직. 켜쌓기율 · 별도계상 뒤 다시 버림(`master_cut.plain`)도
엔진 셈법(줄 자리 · 끝전 · 조정)을 지킴. 옛 로직(새 칸 없음) 전후 같음 = `test_791_1` M01 지문.
옛 엔진 다섯 길 대조(791-1 견본 로직 줄 · `master_cut.engine` · 단위 로직 새 의미)는 855-E 2-E4 에서
은퇴 — 문서 셈 금액은 `test_855_golden` · `test_855_b09_golden` 이 지킴.
"""
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 _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
@@ -126,51 +45,6 @@ def _daega(whole, sk: dict, sheets: dict) -> dict:
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 _sc(*build()[:2]) == one
assert _b09(build, row) == one
assert _b09_daega(build) == one # ⑤ B09 일위대가 대가 블록(792-4)
REAL = [("봉화", "D00102"), ("북부청임도", 18)]
@@ -198,15 +72,3 @@ def test_실무_가져온_식_SK_대가_내역_엑셀(tag, code, world):
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) # 시험이 새 길을 거침
+1 -10
View File
@@ -2,21 +2,18 @@
① 로직 줄 칸 「개정」 = 빌더(`build_로직_개정.py`)가 원문 절 머리에서 뽑은 값과 같음 · 채움 수 ·
수식 문서 머리 「개정」 값(855 L1 이름표).
② 셈 값 그대로 — 791-1 지문 fixture 가 지금 마스터 지문(건너뜀 없이 1,515 전후 같음을 돎).
② 셈 값 그대로 — 791-1 옛 엔진 지문은 855-E 2-E4 에서 은퇴(문서 셈 = `test_855_golden`).
③ 근거 제안 까닭 판 번호 시험은 809-1 에서 지움(근거 → 기초 제안 길 걷음 · 요구 703).
④ 잔토처리(인력) GC001194 = ㎥당 보통인부 0.2 인(건설 공통 3-2-1 비고).
"""
import importlib
import json
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
rev = importlib.import_module("build_로직_개정")
mc = importlib.import_module("master_doc_calc")
ml = importlib.import_module("master_doc_link")
fp = importlib.import_module("test_791_1_engine_semantics")
def _rows() -> dict:
@@ -39,12 +36,6 @@ def test_개정_칸_문서():
assert docs["GF000123"]["개정"] == [2026] # 산림 2026-01-01 제정
def test_셈_지문_건너뜀_없음():
saved = json.loads(fp.FINGER.read_text(encoding="utf-8"))
assert saved["마스터"] == fp._master_hash()
assert len(saved["결과"]) >= 1516
def test_잔토처리_단독():
_, whole = m01.loaded()
links = ml.Links(whole)