- 부착 줄 작업량 답 = 주 기계 줄 답 꼴 · 율 · 값 · 단위 그대로 + 따름 {기호, 이름, 꼴} · 식들 [] (파이썬 · TS 짝)
- 시험 고침 — test_846_1 부착 줄 = 주 줄 따름 · test_814_1 조합 첫 줄 GC001202 · 둘째 줄 GC000273 ·
test_masterdata_check 치즐 = 두 줄 합 · test_782_3 GC001147 K입력 · 782-3 몫 키 범위 ·
test_813_2 기계경비식 17 · 문서 1,521(GC001202) ·
test_799_1 굴착기 블록 = 고정 금액 대신 엔진 줄 값(노임 갱신으로 낡음 · 848-4 와 무관한 문서 GF000089)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
251 lines
12 KiB
Python
251 lines
12 KiB
Python
"""848-4 기계 한 대 = 줄 하나 — 조합 줄 나눔 금액 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더가 모르는 문서 지킴.
|
|
|
|
① 216 짝(굴착기 × 집게 · 브레이커 × 보정작업) — 부착 조합 굴착기 식(GC001202) + 부착 손료(GC000273) = 옛 조합 식
|
|
(GC000270 · 271) 노 · 재 · 경 같음(8-4 주⑤ 잡재료 16 % 가 식 안).
|
|
② 부착 줄 끝수 = 묶음 한 덩이 끝수 − 주 기계 줄 몫(GC000339 · 줄 둘로 1 원 흔들리던 문서) · 옛 엔진도 같음.
|
|
③ 부착 줄 수량 = 주 기계 줄 수량 — 주 줄을 시간당으로 · 변수 고침 · 되돌림에 같이 · 부착 줄 고침은 안 걸림 ·
|
|
저장 정리에서 지움 · 답 꼴 「따름」.
|
|
④ 굴착기 작업량 식 `K입력` — 넣으면 그 값 · 0 = 표(버킷조건).
|
|
⑤ 빌더 — 옛 로직 줄 없는 저장본 문서(자체 로직 · 화면에서 만든 문서)를 안 지우고 제 파일 그대로 · 빠짐 목록에 안 듦.
|
|
⑥ 불러오기 조합 첫 줄 = 부착 조합 굴착기 식 · 기계 식 고름은 GC001202 를 안 고름.
|
|
⑦ 거울 — 부착 줄 따름 · 묶음 끝수를 파이썬 · TS 가 같게.
|
|
"""
|
|
|
|
import importlib
|
|
import itertools
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
from decimal import Decimal as D
|
|
|
|
import pytest
|
|
|
|
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
|
from resources.tester.test_846_1_machine_work import Rec, _lines, _same, _with
|
|
|
|
mc = importlib.import_module("master_doc_calc")
|
|
ml = importlib.import_module("master_doc_link")
|
|
mcv = importlib.import_module("master_doc_cover")
|
|
mw = importlib.import_module("master_doc_work")
|
|
mcut = importlib.import_module("master_cut")
|
|
mf = importlib.import_module("master_formula")
|
|
meq = importlib.import_module("master_equation")
|
|
build = importlib.import_module("build_수식문서_802_2")
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
COSTS = ("노무비", "재료비", "경비")
|
|
MAIN, LOSS, TPL = "GC001202", "GC000273", "GC001147"
|
|
ROCK = ("해당 없음", "암석작업(연암・보통암・경암)", "전석섞인토사")
|
|
DOC = "GC000087" # 흙깎기(기계) 암 — 굴착기 1.0㎥ + 대형브레이커 묶음(주 줄 일당)
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def links():
|
|
return ml.Links(m01.loaded()[1])
|
|
|
|
|
|
def _pick(doc: dict, name: str) -> list:
|
|
return next(v for v in doc["변수"] if v["열쇠"] == name)["연결"]["목록"]
|
|
|
|
|
|
def _money(links, key: str, given: dict) -> dict:
|
|
got = mc.calc(links.doc(key), links, given)
|
|
assert got["셈됨"], (key, given, got["표지"])
|
|
return {k: got[k] for k in COSTS}
|
|
|
|
|
|
# ── ① 216 짝 ───────────────────────────────────────────────────────────
|
|
def test_216_짝_나눈_두_식_합_조합_식과_같음(links):
|
|
n = 0
|
|
for combo, part in (("GC000270", "집게"), ("GC000271", "브레이커")):
|
|
doc = links.doc(combo)
|
|
for mach, tool, rock in itertools.product(_pick(doc, "기계"), _pick(doc, part), ROCK):
|
|
whole = _money(links, combo, {"기계": mach, part: tool, "보정작업": rock})
|
|
main = _money(links, MAIN, {"기계": mach, "보정작업": rock})
|
|
loss = _money(links, LOSS, {"기계": tool})
|
|
assert {k: main[k] + loss[k] for k in COSTS} == whole, (combo, mach, tool, rock)
|
|
n += 1
|
|
assert n == 216
|
|
|
|
|
|
def test_부착_조합_굴착기_식_잡재료_16(links):
|
|
got = mc.calc(links.doc(MAIN), links, {"기계": "0201-0100"})
|
|
assert got["값"]["r_조합잡재료"] == 16
|
|
plain = mc.calc(links.doc("GC000267"), links, {"기계": "0201-0100"})
|
|
assert plain["값"]["r_기계잡재료"] != 16 and got["노무비"] == plain["노무비"]
|
|
|
|
|
|
# ── ② 묶음 끝수 ────────────────────────────────────────────────────────
|
|
def _group(doc: dict, ans: dict):
|
|
"""(주 줄 답, 부착 줄 답) 첫 묶음."""
|
|
lines = doc["금액"]
|
|
at = next(i for i, x in enumerate(lines) if x.get(mw.ATTACH))
|
|
host = max(i for i in range(at) if lines[i].get("묶음") == lines[at]["묶음"])
|
|
return ans["줄"][host], ans["줄"][at]
|
|
|
|
|
|
@pytest.mark.parametrize("key", ["GC000339", "GF000289", "GC000260"])
|
|
def test_부착_줄_끝수_묶음_한_덩이(links, key):
|
|
doc = links.doc(key)
|
|
ans = mc.calc(doc, links)
|
|
main, part = _group(doc, ans)
|
|
assert main["수량"] == part["수량"]
|
|
for k in COSTS: # 묶음 금액 = (주 + 부착 단가) × 수량 을 한 번 0.1 원 버림
|
|
whole = mc.cut(
|
|
main["수량"] * (main["단가"][k] + part["단가"][k]), {"방법": "버림", "자리": 1}
|
|
)
|
|
assert main["비목"][k] + part["비목"][k] == whole, (key, k)
|
|
whole = m01.loaded()[1]
|
|
row = whole.logic(key)
|
|
old = mcut.engine(whole, key, mf.run(whole, key, mf.fill_empty(row, meq.given_of(whole, row))))
|
|
old = {k: old[k] for k in COSTS} # 옛 엔진(M02 로직 줄 · 빌더 대조)도 같음
|
|
assert old == {k: ans[k] for k in COSTS}
|
|
|
|
|
|
# ── ③ 부착 줄 따름 ─────────────────────────────────────────────────────
|
|
def _rows(links, doc, cover=None):
|
|
ans = mc.calc(_with(doc, cover), links)
|
|
assert ans["셈됨"], ans["표지"]
|
|
return _group(doc, ans), ans
|
|
|
|
|
|
def test_부착_줄_수량_주_기계_줄을_따름(links):
|
|
doc = links.doc(DOC)
|
|
(main, part), base = _rows(links, doc)
|
|
sym = main[mw.WORK]["기호"]
|
|
assert main[mw.WORK]["꼴"] == "일당" and part[mw.WORK]["꼴"] == "일당"
|
|
assert part[mw.WORK][mw.FOLLOW] == {"기호": sym, "이름": main["이름"], "꼴": "일당"}
|
|
assert part[mw.WORK]["식들"] == []
|
|
hourly = {sym: {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
|
(m2, p2), got = _rows(links, doc, hourly)
|
|
assert m2[mw.WORK]["꼴"] == "시간당" and m2["수량"] != main["수량"]
|
|
assert p2["수량"] == m2["수량"] and p2[mw.WORK][mw.FOLLOW]["꼴"] == "시간당"
|
|
assert got["계"] != base["계"]
|
|
tuned = {sym: {mw.WORK: {"방식": "시간당", "식": TPL, "변수": {"f": 0.5}}}}
|
|
(m3, p3), _ = _rows(links, doc, tuned) # 변수 고침 = 둘 다
|
|
assert m3["수량"] != m2["수량"] and p3["수량"] == m3["수량"]
|
|
(m4, p4), back = _rows(links, doc, {sym: {mw.WORK: {"방식": "일당"}}}) # 되돌림
|
|
assert (m4["수량"], p4["수량"], back["계"]) == (main["수량"], part["수량"], base["계"])
|
|
mine = {part[mw.WORK]["기호"]: {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
|
(m5, p5), alone = _rows(links, doc, mine) # 부착 줄 고침 = 안 걸림
|
|
assert (p5["수량"], alone["계"]) == (part["수량"], base["계"])
|
|
|
|
|
|
def test_부착_줄_작업량_고침_저장_때_지움(links):
|
|
doc = links.doc(DOC)
|
|
(main, part), _ = _rows(links, doc)
|
|
keep = {main[mw.WORK]["기호"]: {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
|
drop = {part[mw.WORK]["기호"]: {mw.WORK: {"방식": "시간당", "식": TPL}}}
|
|
got = mcv.prune_doc({**doc, mcv.COVER: {**keep, **drop}}, links)
|
|
assert got[mcv.COVER] == keep
|
|
|
|
|
|
# ── ④ 버킷계수 직접 칸 ─────────────────────────────────────────────────
|
|
def test_버킷계수_직접_칸(links):
|
|
tpl = links.doc(TPL)
|
|
base = mc.calc(tpl, links)
|
|
assert base["값"]["K_입력"] == 0 # 기본 = 표
|
|
k = base["값"]["K"]
|
|
got = mc.calc(tpl, links, {"K입력": D("0.28")})
|
|
assert got["값"]["K"] == D("0.28")
|
|
assert abs(got["결과"] / base["결과"] - D("0.28") / k) < D("0.001")
|
|
assert mc.calc(tpl, links, {"K입력": 0})["결과"] == base["결과"]
|
|
|
|
|
|
# ── ⑤ 빌더가 모르는 문서 ───────────────────────────────────────────────
|
|
@pytest.fixture
|
|
def docs_tmp(tmp_path, monkeypatch):
|
|
dst = tmp_path / "수식문서"
|
|
dst.mkdir()
|
|
name = "로직_건설품셈_08장_건설기계.json"
|
|
shutil.copy(ml.FOLDER / ml.file_of(name), dst)
|
|
shutil.copy(ml.FOLDER / "수식_자체.json", dst)
|
|
monkeypatch.setattr(ml, "FOLDER", dst)
|
|
return dst, name
|
|
|
|
|
|
def test_빌더_모르는_문서_안_지움_그대로(docs_tmp):
|
|
dst, name = docs_tmp
|
|
files, whole = m01.loaded()
|
|
rows = files[name]["줄"]
|
|
own = dst / "수식_자체.json"
|
|
data = ml.load_file(own)
|
|
data["줄"].append(ml._norm({**data["줄"][0], "키": "GX999999", "이름": "sub2임시 화면 자체"}))
|
|
own.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
|
loose = dst / "수식_손.json" # 빌더 모르는 파일
|
|
loose.write_text(ml.dump({"그룹": "수식문서", "로직파일": "", "줄": [{**data["줄"][0], "키": "GX999998"}]}),
|
|
encoding="utf-8", newline="\n") # fmt: skip
|
|
before = {p.name: p.read_text(encoding="utf-8") for p in dst.iterdir()}
|
|
keys = [str(r["키"]) for r in rows]
|
|
result = {
|
|
"문서": {str(r["키"]): build.cv.convert(whole, r)[0] for r in rows},
|
|
"파일": {name: keys},
|
|
"저장": set(keys),
|
|
"저장본": build.carried(),
|
|
"대조": [],
|
|
"알림": {},
|
|
"요약": {},
|
|
}
|
|
want = build.files_of(result)
|
|
assert want["수식_손.json"] == before["수식_손.json"]
|
|
assert want["수식_자체.json"] == before["수식_자체.json"] # GX 자체 문서 · 화면 문서 그대로
|
|
assert want[ml.file_of(name)] == before[ml.file_of(name)]
|
|
assert build.lost(result) == []
|
|
assert {"GX000004", "GX999999", "GX999998"} <= set(build.foreign_keys(result))
|
|
assert [x for x in build.check(result) if not x.startswith("다른 목록")] == []
|
|
|
|
|
|
# ── ⑥ 불러오기 조합 · 기계 식 고름 ────────────────────────────────────
|
|
def test_불러오기_조합_첫_줄_부착_조합_식(monkeypatch):
|
|
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
|
from M02_MasterTemplete import M02_San_Link as sl
|
|
|
|
eq = m01.loaded()[1].numbers["EQ"]
|
|
main, brk = eq["0201-0100"]["키"], eq["0230-0010"]["키"]
|
|
key, text = mh.combo(main, brk)
|
|
assert (
|
|
key == MAIN and text.startswith(f"로직({MAIN}, 기계='0201-0100'") and "브레이커" not in text
|
|
)
|
|
one = {"자원": {}}
|
|
assert sl.combo_link(one, [{"키": main}, {"키": brk}]) == text and "조합식" not in one["자원"]
|
|
assert mh.combo(main, eq["0101-0032"]["키"]) is None # 부착 기계 아님
|
|
assert mh.pick(eq["0201-0100"])["키"] == "GC000267" # 기계 식 고름 = 그대로
|
|
assert MAIN not in {r["키"] for r in mh._family()}
|
|
|
|
|
|
# ── ⑦ 거울 ─────────────────────────────────────────────────────────────
|
|
def test_거울_부착_따름_묶음_끝수(links):
|
|
rec = Rec(links)
|
|
doc = links.doc(DOC)
|
|
(main, part), _ = _rows(links, doc)
|
|
sym = main[mw.WORK]["기호"]
|
|
picks = [
|
|
("GC000339", None),
|
|
("GF000289", None),
|
|
(DOC, None),
|
|
(DOC, {sym: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
|
(DOC, {sym: {mw.WORK: {"방식": "시간당", "식": TPL, "변수": {"f": 0.5, "K입력": 0.8}}}}),
|
|
(DOC, {part[mw.WORK]["기호"]: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
|
|
("GC000098", None),
|
|
]
|
|
cases, want = [], []
|
|
for key, cover in picks:
|
|
d = links.doc(key)
|
|
cases.append({"문서": d, "덮음": cover})
|
|
want.append(mc.calc(_with(d, cover), rec))
|
|
payload = {"문서들": rec.docs, "대상": cases, "기록": rec.log, "글": [], "정리": []}
|
|
proc = subprocess.run(
|
|
["node", os.path.join(HERE, "helper_846_1_machine_work.cjs")],
|
|
input=json.dumps(ml._norm(payload), ensure_ascii=False),
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
check=True,
|
|
)
|
|
got = json.loads(proc.stdout)["답"]
|
|
for i, (a, b) in enumerate(zip(want, got)):
|
|
_same(ml._norm({k: a.get(k) for k in (*COSTS, "계", "셈됨")}),
|
|
{k: b.get(k) for k in (*COSTS, "계", "셈됨")}, f"답{i}") # fmt: skip
|
|
_same(ml._norm(_lines(a)), _lines(b), f"줄{i}")
|