eomsangdonandClaude Sonnet 5.5
43e061ba2a
폴더마다 체크아웃 줄바꿈이 달라 메인 폴더에서 test_794_2b 셈 지문 시험이 깨짐. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
519 lines
21 KiB
Python
519 lines
21 KiB
Python
"""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
|
||
|
||
import pytest
|
||
|
||
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"))
|
||
if saved["마스터"] != _master_hash():
|
||
pytest.skip("마스터 데이터 바뀜 — 지문 다시 뜸: python resources/tester/test_791_1_…py")
|
||
now = fingerprints()
|
||
assert len(now) == len(saved["결과"]) >= 1515
|
||
diff = sorted(k for k in now if now[k] != saved["결과"].get(k))
|
||
assert not diff, f"셈 결과 바뀐 로직 {len(diff)} 개: {diff[:10]}"
|
||
|
||
|
||
# ── 시험 마스터 ───────────────────────────────────────────────────────
|
||
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)
|