Files
Aislo/resources/tester/test_846_1_machine_work.py
T
eomsangdonandClaude Opus 5.5 a53fae747c feat(846-1): 기계 줄 시간당 작업량 — 기계 값 칸 작업량 · 덮음 일당 | 시간당 · 계산기 짝(금액 불변)
- 기계 자료: M01 기계 221 대 값 칸 `작업량` = [{식 · 단위 · 변수(규격에서 정해지는 칸)}] (건설 공통 8-2 장 작업량 틀 · 빌더 build_기계_작업량_846_1.py · --check 0 · 다른 칸 · 시간당 비용 그대로)
- 계산기 짝 master_doc_work.py ↔ common_util_formula_doc_work.ts: 기계 줄 수량에서 시간당 작업량 자리 읽기(일당 = 시공량 ÷ (8 × 대수) · 식 = …/hr 나눔 변수) · 셈 답 줄 칸 `작업량` · 덮음 `작업량: {방식 시간당, 식, 변수?}` = 그 자리를 1 ÷ Q(기계 작업량 식)로 바꿔 셈 · 부착 기계(브레이커 · 집게) 줄 따로 · 식 없는 기계 · 단위 안 맞음 = 시간당 거절
- 덮음 짝(master_doc_cover · common_util_formula_doc_cover): 작업량은 기계 식 문서에 안 얹음 · prune 이 작업량 정리(일당 · 기본과 같은 변수 = 지움) · 몸 검사 · CoverEntry · CoverBase 꼴
- 저장 길: 사본 부름 묶음에 시간당 식 키(M02_Doc_Copy.calls) · 내 기계 clean 이 작업량 받음 · 연결 읽기 작업량 칸(master_doc_link)
- 기계 보기: 작업량 칸 = 제어 구역 몫(ownedCols — 바탕 칸 숫자 입력으로 안 그림 · 그리기는 846-2)
- 지킴: 1,520 문서 · 기계 655 대 · 견본 SK 금액 전후 다름 0 · 빌더 802-2 --check 1,520 같음(옵션 표본 18,873) · 둘 다 가능 줄 전수 시간당 셈 멈춤 0
- 시험: test_846_1_machine_work(일당 · 시간당 손셈 · E · K 덮음 · 정리 · 거절 · 부착 · 거울 · 저장 길 · 내 기계) 신설 · test_816_1 기대값 고침(까닭 — 4륜 덤프 1톤 기계 줄에 작업량 칸이 생겨 값 칸 비교에서 뺌)

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

400 lines
18 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""846-1 기계 줄 시간당 작업량 — 일당 읽기 · 시간당 방식 덮음 · 기계 작업량 칸 · 거울(파이썬 ↔ TS) 지킴 시험.
짝 = `resources/master_data/scripts/master_doc_work.py` ↔ `common_util/common_util_formula_doc_work.ts`
(계산기 부름 자리 = `master_doc_calc` ↔ `common_util_formula_doc_calc.ts` · 덮음 정리 = `master_doc_cover`).
① 터파기 보통토사 TypeⅠ(GC000088) 일당 = 지금 금액 · 시간당 작업량 = 560 ÷ 8 = 70 ㎥/hr.
② 시간당 방식 = 굴착기 1.0㎥ 8-2-3 식(GC001147) Q 로 나눈 금액 = 손셈 · E · K(버킷조건) 덮으면 그만큼.
③ 되돌리면(일당 · 기본과 같은 변수) 덮음 0 · 식 없는 기계 · 단위 안 맞음 = 시간당 거절.
④ 부착 기계(대형브레이커) 줄은 굴착기 시간당에 안 묶임 · 산림 문서(GF000099) 식 꼴도 바뀜.
⑤ 기계 작업량 칸(빌더 --check 0) · 사본 부름 묶음에 식 키 · 기계 식 문서는 그대로.
⑥ 거울 — 같은 연결 값으로 파이썬 · TS 금액 · 줄 · 작업량 답 · 자리 읽기 · 정리가 같음.
⑦ 저장 길(임시 층) — 시간당 저장 · 다시 열기 · 되돌리면 덮음 없음 · 거절 = 400.
"""
import copy as cp
import importlib
import json
import os
import subprocess
from decimal import Decimal as D
import pytest
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
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")
HERE = os.path.dirname(os.path.abspath(__file__))
NO = "0201-0100" # 굴착기(무한궤도) 1.0㎥
DIG = "GC000088" # 터파기(기계) 보통토사 — 건설 공통 3-2-4
TPL = "GC001147" # 굴착기 시간당 작업량 — 건설 공통 8-2-3
HOURLY = {NO: {mw.WORK: {"방식": "시간당", "식": TPL}}}
COSTS = ("노무비", "재료비", "경비")
@pytest.fixture(scope="module")
def links():
return ml.Links(m01.loaded()[1])
def _with(doc: dict, cover: dict | None) -> dict:
return {**doc, mcv.COVER: cover} if cover else doc
def _line(ans: dict, name: str) -> dict:
return next(x for x in ans["줄"] if x["이름"] == name)
def _cut(v: D) -> D:
return D(str(mc.rounddown(float(v), 1)))
def _q(links, *, e: D | None = None, bucket: str | None = None) -> D:
"""GC001147 손셈 — q 1.0 · 규격 1.0∼1.2 · 선회 135° · K(버킷조건) · E(흐트러진 · 보통 · 모래) · f 0.7."""
tpl = links.doc(TPL)
opts = {v["열쇠"]: v["연결"] for v in tpl["변수"]}
k = links.table(
{"표": "CC000042", "조건": {"현장조건": bucket or opts["버킷조건"]["값"]}, "칸": "K"}
)
if e is None:
e = links.table(
{"표": "CC000043", "칸": "E",
"조건": {"현장조건": "흐트러진 상태", "등급": "보통", "토질명": "모래, 사질토"}}
) # fmt: skip
cm = links.table({"표": "CC000045", "조건": {"규격": "1.0∼1.2", "각도": D(135)}, "칸": "시간"})
q = D(3600) * D(1) * D(str(k)) * D("0.7") * D(str(e)) / D(str(cm))
return q.quantize(D("0.001"), rounding="ROUND_HALF_UP")
# ── ① 일당 ─────────────────────────────────────────────────────────────
def test_터파기_일당_지금_금액_시간당_작업량_70(links):
ans = mc.calc(links.doc(DIG), links)
line = _line(ans, "굴착기")
work = line[mw.WORK]
assert work == {"기계": NO, "꼴": "일당", "율": "Q_시공 ÷ (8 × Q_굴착기^표)", "값": D(70),
"단위": "㎥/hr", "식들": [TPL]} # fmt: skip
price = line["단가"]
want = {k: _cut(price[k] * 1 * 8 / D(560)) for k in COSTS} # 대수 1 × 8 ÷ 560
assert line["비목"] == want and ans["셈됨"]
def test_덮음_없음_남의_기계_덮음_금액_같음(links):
doc = links.doc(DIG)
base = mc.calc(doc, links)
other = mc.calc(_with(doc, {"0201-0060": {mw.WORK: {"방식": "시간당", "식": TPL}}}), links)
assert [x["금액"] for x in base["줄"]] == [x["금액"] for x in other["줄"]]
assert base["계"] == other["계"]
# ── ② 시간당 ───────────────────────────────────────────────────────────
def test_시간당_식_Q_로_나눈_금액_손셈(links):
ans = mc.calc(_with(links.doc(DIG), HOURLY), links)
line = _line(ans, "굴착기")
q = _q(links)
assert line[mw.WORK]["꼴"] == "시간당" and line[mw.WORK]["값"] == q
assert line[mw.WORK]["변수"]["버킷용량"] == 1 and line[mw.WORK]["변수"]["f"] == D("0.7")
assert line["비목"] == {k: _cut(line["단가"][k] / q) for k in COSTS}
assert line["수량"] == 1 / q and ans["셈됨"]
def test_시간당_E_K_덮으면_그만큼(links):
tpl = links.doc(TPL)
first = next(v for v in tpl["변수"] if v["열쇠"] == "버킷조건")["연결"]["목록"][0]
want = {"방식": "시간당", "식": TPL, "변수": {"E입력": 0.5, "버킷조건": first}}
ans = mc.calc(_with(links.doc(DIG), {NO: {mw.WORK: want}}), links)
line = _line(ans, "굴착기")
q = _q(links, e=D("0.5"), bucket=first)
assert q != _q(links) and line[mw.WORK]["값"] == q
assert line["비목"] == {k: _cut(line["단가"][k] / q) for k in COSTS}
# ── ③ 정리 · 거절 ──────────────────────────────────────────────────────
def test_되돌리면_덮음_0(links):
doc = links.doc(DIG)
assert mcv.COVER not in mcv.prune_doc(_with(doc, {NO: {mw.WORK: {"방식": "일당"}}}), links)
same = {"방식": "시간당", "식": TPL, "변수": {"f": 0.7, "버킷용량": 1, "선회각도": 135}}
got = mcv.prune_doc(_with(doc, {NO: {mw.WORK: same}}), links)[mcv.COVER]
assert got == {NO: {mw.WORK: {"방식": "시간당", "식": TPL}}} # 기본과 같은 변수 = 뺌
moved = {**same, "변수": {"f": 0.8, "버킷용량": 1}}
got = mcv.prune_doc(_with(doc, {NO: {mw.WORK: moved}}), links)[mcv.COVER]
assert got[NO][mw.WORK]["변수"] == {"f": 0.8}
def _first_machine(links, key: str, name: str) -> str:
return _line(mc.calc(links.doc(key), links), name)[mw.WORK]["기계"]
@pytest.mark.parametrize(
("key", "name", "why"),
[
("GC000007", "크레인", "작업량 식 없는 기계"),
("GC000112", "굴착기 0.2㎥", "맞는 작업량 식 없음"),
],
)
def test_시간당_거절(links, key, name, why):
no = _first_machine(links, key, name)
want = {"방식": "시간당", "식": TPL}
ans = mc.calc(_with(links.doc(key), {no: {mw.WORK: want}}), links)
line = _line(ans, name)
assert line["금액"] is None and why in line[mw.WORK]["까닭"] and not ans["셈됨"]
assert any(m["갈래"] == "시간당 거절" for m in ans["표지"])
if why == "작업량 식 없는 기계":
with pytest.raises(ValueError):
mcv.prune_doc(_with(links.doc(key), {no: {mw.WORK: want}}), links)
@pytest.mark.parametrize(
"bad",
[{"방식": "주당"}, {"방식": "시간당"}, {"방식": "시간당", "식": 3},
{"방식": "시간당", "식": TPL, "변수": {"f": [1]}}],
) # fmt: skip
def test_몸_검사_틀림(bad):
with pytest.raises(ValueError):
mcv.clean({NO: {mw.WORK: bad}})
# ── ④ 부착 기계 · 산림 식 꼴 ────────────────────────────────────────────
def test_부착_브레이커_줄은_굴착기_시간당에_안_묶임(links):
doc = links.doc("GC000087")
base = mc.calc(doc, links)
got = mc.calc(_with(doc, HOURLY), links)
rows = {x["이름"]: (x, y) for x, y in zip(base["줄"], got["줄"])}
dig, brk = rows["굴착기 1.0㎥"], rows["대형브레이커 1.0㎥(굴착기 1.0㎥ 부착)"]
assert brk[0][mw.WORK]["기계"] != NO and brk[0][mw.WORK]["식들"] == []
assert brk[0]["금액"] == brk[1]["금액"] # 브레이커 = 일당 그대로
assert dig[1][mw.WORK]["꼴"] == "시간당" and dig[1]["금액"] != dig[0]["금액"]
def test_산림_식_꼴_시간당(links):
doc = links.doc("GF000099")
base = mc.calc(doc, links)
name = "굴착기(무한궤도) 0.7㎥"
old = _line(base, name)
assert old[mw.WORK]["꼴"] == "식" and old[mw.WORK]["율"] == "Q_작업"
no = old[mw.WORK]["기계"]
got = _line(mc.calc(_with(doc, {no: {mw.WORK: {"방식": "시간당", "식": TPL}}}), links), name)
q = got[mw.WORK]["값"]
assert got["수량"] == base["값"]["r_기계"] / 100 / q # 기계 비율(90%)은 곱에 남음
# ── ⑤ 기계 칸 · 부름 · 기계 식 문서 ────────────────────────────────────
def test_기계_작업량_칸(links):
row = links.master.get(f"EQ:{NO}")
assert row["값"][mw.WORK] == [{"식": TPL, "단위": "㎥/hr", "변수": {"버킷용량": 1, "규격구분": "1.0∼1.2"}}] # fmt: skip
assert row["출처"][mw.WORK] == "건설품셈 공통 8-2-3" and row["단위"][mw.WORK] == ""
build = importlib.import_module("build_기계_작업량_846_1")
seen = build.main("--check")
assert seen["어긋남(--check)"] == 0 and seen["작업량 칸 있음"] == 221
def test_사본_부름에_식_키_기계_식_문서_그대로(links):
from M02_MasterTemplete import M02_Doc_Copy as dc
doc = _with(links.doc(DIG), HOURLY)
assert TPL in dc.calls(doc) and TPL not in dc.calls(links.doc(DIG))
cost = links.doc("GC000267")
assert mcv.cover_doc(cost, {"기계": NO}, HOURLY) is cost
# ── ⑥ 거울 ────────────────────────────────────────────────────────────
def _canon(v):
if isinstance(v, (D, int, float)) and not isinstance(v, bool):
return mc.plain_text(D(str(v)))
if isinstance(v, list):
return [_canon(x) for x in v]
if isinstance(v, dict):
return {k: _canon(v[k]) for k in sorted(v)}
return v
class Rec:
def __init__(self, links):
self.links, self.log, self.docs = links, {}, {}
def _keep(self, kind, p, fn):
key = f"{kind}|{json.dumps(_canon(p), ensure_ascii=False, separators=(',', ':'))}"
try:
got = fn(p)
except mc.Gap as e:
self.log[key] = {"빈": str(e)}
raise
except mc.Broken as e:
self.log[key] = {"끊김": str(e)}
raise
self.log[key] = {"값": got}
return got
def element(self, p):
return self._keep("요소", p, self.links.element)
def table(self, p):
return self._keep("표", p, self.links.table)
def doc(self, key):
got = self.docs[key] = self.links.doc(key)
return got
def _same(a, b, where=""):
if isinstance(a, dict):
assert isinstance(b, dict) and set(a) == set(b), (where, sorted(a), sorted(b or {}))
for k in a:
_same(a[k], b[k], f"{where}.{k}")
elif isinstance(a, list):
assert isinstance(b, list) and len(a) == len(b), (where, a, b)
for i, (x, y) in enumerate(zip(a, b)):
_same(x, y, f"{where}[{i}]")
elif isinstance(a, (D, int, float)) and not isinstance(a, bool):
assert isinstance(b, (int, float)) and not isinstance(b, bool), (where, a, b)
assert float(a) == pytest.approx(b, rel=1e-9, abs=1e-9), (where, a, b)
else:
assert a == b, (where, a, b)
def _lines(ans: dict) -> list:
return [{k: x.get(k) for k in ("이름", "수량", "금액", mw.WORK)} for x in ans.get("줄") or []]
TEXTS = [
"Q_굴착기^표 × 8 ÷ Q_시공",
"만약(Type == 'TypeⅢ', 0, Q_굴착기^표 × 8 ÷ Q_시공)",
"r_기계 ÷ 100 × 8 ÷ Q_시공",
"2 × Q_굴착기^표 × 8 ÷ (Q_시공 × 1.1)",
"d_장비 × 8",
"",
]
def test_거울_파이썬_TS_같은_답(links):
rec = Rec(links)
no_spec = _first_machine(links, "GC000007", "크레인")
gf = _first_machine(links, "GF000099", "굴착기(무한궤도) 0.7㎥")
first = next(v for v in links.doc(TPL)["변수"] if v["열쇠"] == "버킷조건")["연결"]["목록"][0]
picks = [
(DIG, None),
(DIG, HOURLY),
(DIG, {NO: {mw.WORK: {"방식": "시간당", "식": TPL, "변수": {"E입력": 0.5, "버킷조건": first}}}}),
("GC000087", HOURLY),
("GC000090", HOURLY),
("GF000099", {gf: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
("GX000004", {"0201-0070": {mw.WORK: {"방식": "시간당", "식": TPL}}}),
("GC000007", {no_spec: {mw.WORK: {"방식": "시간당", "식": TPL}}}),
("GC000112", {_first_machine(links, "GC000112", "굴착기 0.2㎥"): {mw.WORK: {"방식": "시간당", "식": TPL}}}),
("GC000085", None),
] # fmt: skip
cases, want = [], []
for key, cover in picks:
doc = links.doc(key)
cases.append({"문서": doc, "덮음": cover})
want.append(mc.calc(_with(doc, cover), rec))
texts = [{"문서": links.doc(DIG), "수량": t} for t in TEXTS]
text_want = [
{"자리": [{"꼴": s["꼴"], "율": s["율"], "단위": s["단위"]} for s in mw.sites(x["문서"], x["수량"])],
"바꿈": mw.swap(x["문서"], x["수량"])}
for x in texts
] # fmt: skip
prunes = [
{
"덮음": {"방식": "시간당", "식": TPL, "변수": {"f": 0.7, "E입력": 0.4}},
"기본": {"f": 0.7},
},
{"덮음": {"방식": "일당"}, "기본": None},
{"덮음": {"방식": "시간당", "식": TPL}, "기본": {}},
]
prune_want = [mw.prune_work(x["덮음"], x["기본"]) for x in prunes]
payload = {"문서들": rec.docs, "대상": cases, "기록": rec.log, "글": texts, "정리": prunes}
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}")
assert [m["갈래"] for m in a["표지"]] == [m["갈래"] for m in b["표지"]], i
_same(text_want, got["글"], "글")
_same(ml._norm(prune_want), got["정리"], "정리")
_same([mw.cover_calls({mcv.COVER: c["덮음"]}) for c in cases], got["부름"], "부름")
assert text_want[0]["바꿈"] == "1 ÷ Q_시간당작업량"
assert text_want[2]["바꿈"] == "r_기계 ÷ 100 ÷ Q_시간당작업량"
assert text_want[4]["자리"] == []
# ── ⑦ 저장 길(임시 층 · 수식 길) ────────────────────────────────────────
@pytest.fixture
def world(tmp_path, monkeypatch):
from resources.tester.test_m02_labor_ref import world as make
return make.__wrapped__(tmp_path, monkeypatch)
def test_저장_다시_열기_되돌리면_덮음_없음(world, links):
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_MasterTemplete_Store as store
me = world["personal"]
def at(fn, *args):
with store.at(me):
return fn(*args)
key = at(
lambda: refs.create("sangeun", {"이름": "sub2임시 작업량", "단위": "㎥", "더한줄": []})
)
key = key["이름"]
got = at(path.read, key)
doc = cp.deepcopy(got["문서"])
doc.setdefault("변수", []).append(
{"기호": "P", "아래": "터파기", "위": "", "이름": "터파기", "단위": "",
"연결": {"갈래": "단가산출", "키": DIG, "입력": {}}}
) # fmt: skip
doc.setdefault("금액", []).append(
{"이름": "터파기", "단위": "㎥", "비목": "묶음", "수량": "1", "단가": "P_터파기"}
)
base = at(path.save, key, {"문서": doc, "판": got["판"]})
was = base["셈"]["계"]
assert was == mc.calc(links.doc(DIG), links)["계"]
doc = cp.deepcopy(base["문서"])
doc[mcv.COVER] = {**HOURLY, "9999-9999": {mw.WORK: {"방식": "시간당", "식": TPL}}}
after = at(path.save, key, {"문서": doc, "판": base["판"]})
assert after["문서"][mcv.COVER] == HOURLY # 안 부르는 기계 = 뺌
assert TPL in after["부름"]
hand = mc.calc(_with(links.doc(DIG), HOURLY), links)["계"]
assert after["셈"]["계"] == hand != was
again = at(path.read, key)
assert again["셈"]["계"] == hand and again["문서"][mcv.COVER] == HOURLY
doc = cp.deepcopy(again["문서"])
doc[mcv.COVER] = {NO: {mw.WORK: {"방식": "일당"}}}
back = at(path.save, key, {"문서": doc, "판": again["판"]})
assert mcv.COVER not in back["문서"] and back["셈"]["계"] == was
doc[mcv.COVER] = {NO: {mw.WORK: {"방식": "시간당"}}} # 식 키 없음 = 거절
with pytest.raises(store.StoreError):
at(path.save, key, {"문서": doc, "판": back["판"]})
def test_내_기계_작업량_칸_받음(world):
from M02_MasterTemplete import M02_Machine_Hourly as mh
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
me = world["personal"]
with store.at(me):
row = mym.create({"방식": "바로"}, "EQ000022")["줄"]
hour = mh.hourly(row["키"])
assert row["값"][mw.WORK] == [{"식": TPL, "단위": "㎥/hr", "변수": {"버킷용량": 1, "규격구분": "1.0∼1.2"}}] # fmt: skip
assert hour["계"] == mh.hourly("EQ000022")["계"] # 시간당 비용은 안 바뀜
for bad in ([{"식": DIG}], [{"식": TPL, "변수": {"f": [1]}}], "작업량"):
with pytest.raises(store.StoreError):
mym.create({"방식": "바로", "값": {mw.WORK: bad}}, "EQ000022")
none = mym.create({"방식": "바로", "값": {mw.WORK: []}}, "EQ000022")["줄"]
assert mw.WORK not in none["값"]