Files
Aislo/resources/tester/test_848_4_machine_split.py
T
eomsangdonandClaude Opus 5.5 7b1985b693 feat(848-4): 기계 한 대 = 줄 하나 — 조합 줄 나눔 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더 모르는 문서 지킴
- 옛 로직 JSON(한 번 돌림 build_로직_기계줄나눔_848_4.py) → 빌더 → 수식 문서
  · 새 식 GC001202 굴착기(무한궤도) 부착 조합 시간당 기계경비(잡재료 16 % · 8-4 주⑤ · 부품 조합 = 기계 식 고름에서 뺌)
  · 조합 식 부름 69 줄(문서 67) → 같은 묶음 아래 주 기계 줄(GC001202) + 부착 손료 줄(GC000273 · 부착 true)
  · 치즐 소모재료 6 문서 = 두 식 값의 합 · GF000011 · 012 · 320 덧줄 두 기계 손료 = 줄 둘(GF000312 · 313 = 기종 고르기 한 대 — 안 나눔)
  · GC001147 K입력(0 = 표) · GX000004 부름에 K입력=0
- 엔진 짝(master_doc_work ↔ TS) 부착 줄 = 같은 묶음 주 기계 줄 수량 · 답 꼴 따름 · 부착 줄 작업량 고침 안 걸림(저장 정리에서 지움)
- 계산기 짝 · 옛 엔진(master_cut) 부착 줄 끝수 = 묶음 한 덩이 끝수 − 주 기계 줄 몫(줄 둘로 1 원 흔들림 없앰)
- 변환 호표 묶음 · 부착 칸 · 빌더 = 옛 로직 줄 없는 저장본 문서를 안 지우고 제 파일 그대로 · 목록 알림
- 불러오기 조합 첫 줄 = GC001202 부름 · 둘째 줄 값 0 분기 걷음(두 줄 각자 셈)
- 시험 test_848_4 새로 · test_848_1 바이트 비교 → 글 비교(CRLF 체크아웃)
- 금액 전후 = 수식 문서 15 파일 493 문서 9,018 대조 다름 0 · 빌더 1,521 같음(채택 3 그대로)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 22:02:37 +09:00

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]["꼴"] == mw.FOLLOW
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}")