# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 """848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음. ① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조). ㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 · 문서 밖 기계 고침 뺌 · 줄 식 고침 = 받은 문서 그대로(손고침 표지 없음) · ㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전. ㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 · ㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 · ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도). ㉧ 기초 A 가 B 를 부를 때 A 의 고침만 A 셈에. 정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage. """ import copy as cp import importlib import json import os import shutil import subprocess from decimal import Decimal as D import pytest from M01_MasterData import M01_MasterData_Doc as m01doc from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Item_Prices as item_prices from M02_MasterTemplete import M02_Item_Source as source from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Labor_SkRow as skrow from M02_MasterTemplete import M02_MasterTemplete_Store as store from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 mc = importlib.import_module("master_doc_calc") ml = importlib.import_module("master_doc_link") mcv = importlib.import_module("master_doc_cover") HERE = os.path.dirname(os.path.abspath(__file__)) COVER = mcv.COVER BASE = "GC000088" # 터파기(기계) 보통토사 — 굴착기 줄 하나(TypeⅠ = 1.0㎥ · TypeⅢ = 0.6㎥) NO, NO3 = "0201-0100", "0201-0060" SYM = "P_굴착기무한궤" # 그 줄 단가 기호 = 작업량 덮음 열쇠(847-1) TPL = "GC001147" # 굴착기 시간당 작업량 식 # ── ① 거울 ──────────────────────────────────────────────────────────── BASE0 = {"값": {"가격": 100, "주연료": 10}, "조종원": [{"키": "LB:1", "인": 1}], "잡품": [{"줄": "주연료", "율": 22}], "작업량": {"f": 0.7, "E": 0.5}} # fmt: skip U1 = {"값": {"가격": 150}, "조종원": [{"키": "LB:1", "인": 2}], "작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8}}} # fmt: skip U2 = {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}} MINES = [ None, {"값": {"가격": 150, "주연료": 20}}, {"값": {"가격": 100}}, {"조종원": [{"키": "LB:1", "인": 2}]}, {"조종원": [{"키": "LB:1", "인": 1}]}, {"잡품": []}, {"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, {"작업량": {"방식": "일당"}}, {"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, {"작업량": {"변수": {"E": 0.6}}}, {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}}, {"작업량": {"방식": "시간당", "식": "T1", "기계": NO, "이름": "굴착기 1.0㎥"}}, ] def test_층_합침_정리_출처_손셈(): p = mcv.prune assert p({"값": {"가격": 150, "주연료": 20}}, BASE0, U1) == {"값": {"주연료": 20}} assert p({"값": {"가격": 100}}, BASE0, U1) == {"값": {"가격": 100}} # 정본 값 = 위 층과 다름 assert p({"값": {"가격": 100}}, BASE0) is None # 위 층 없음 = 지금과 같음 assert p({"조종원": [{"키": "LB:1", "인": 2}]}, BASE0, U1) is None assert ( p({"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, BASE0, U1) is None ) assert p({"작업량": {"방식": "일당"}}, BASE0, U1) == {"작업량": {"방식": "일당"}} assert p({"작업량": {"방식": "일당"}}, BASE0) is None want = {"작업량": {"식": "T2", "변수": {"f": 0.8}}} # 식 바꿈 = 위 층 변수 안 물려받음 assert p({"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, BASE0, U1) == want assert p({"작업량": {"변수": {"E": 0.6}}}, BASE0, U1) == {"작업량": {"변수": {"E": 0.6}}} assert p(U2, BASE0, U2) is None and p(U2, BASE0) == U2 assert mcv.merge(U1, {"작업량": {"식": "T2"}})["작업량"] == {"방식": "시간당", "식": "T2"} assert mcv.merge(U1, {"작업량": {"방식": "일당"}})["작업량"]["방식"] == "일당" assert mcv.merge(U2, {"작업량": {"기계": NO}})["작업량"] == { "방식": "시간당", "식": "T1", "기계": NO, } got = mcv.sources(U1, {"값": {"주연료": 20}, "작업량": {"변수": {"E": 0.6}}}) assert got == {"값.가격": "위", "조종원": "위", "작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "위", "값.주연료": "나", "작업량.변수.E": "나"} # fmt: skip assert mcv.sources(U1, {"작업량": {"식": "T2"}})["작업량.식"] == "나" assert "작업량.변수.f" not in mcv.sources(U1, {"작업량": {"식": "T2"}}) assert mcv.upper_of(BASE0, U1) == {"값": {"가격": 150, "주연료": 10}, "조종원": U1["조종원"], "잡품": BASE0["잡품"], "작업량": U1["작업량"]} # fmt: skip mine = {"개인 EQP000001": {"값": {"가격": 1}}} # 내 기계 열쇠 = 같은 꼴 assert mcv.merge_layers(None, mine) is mine and mcv.merge_layers(mine, {}) is mine assert mcv.merge_layers({"개인 EQP000001": U1}, mine)["개인 EQP000001"]["값"] == {"가격": 1} def _same(a, b, where=""): if isinstance(a, dict): assert isinstance(b, dict) and set(a) == set(b), (where, a, b) 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, (int, float)) and not isinstance(a, bool): assert float(a) == pytest.approx(b), (where, a, b) else: assert a == b, (where, a, b) def test_거울_파이썬_TS_같은_답(): cases = [{"위": u, "나": m, "기본": BASE0} for u in (None, U1, U2) for m in MINES] want = [ { "합침": mcv.merge(c["위"], c["나"]), "층": mcv.merge_layers( {"K": c["위"]} if c["위"] else None, {"K": c["나"]} if c["나"] else None ), "정리": mcv.prune(c["나"], BASE0, c["위"]) if c["나"] else None, "위값": mcv.upper_of(BASE0, c["위"]), "출처": mcv.sources(c["위"], c["나"]), } for c in cases ] proc = subprocess.run( ["node", os.path.join(HERE, "helper_848_1_cover_layers.cjs")], input=json.dumps({"경우": cases}, ensure_ascii=False), capture_output=True, text=True, encoding="utf-8", check=True, ) got = json.loads(proc.stdout)["답"] assert len(got) == len(want) == 36 for i, (a, b) in enumerate(zip(want, got)): _same(a, b, f"경우{i}") # ── 임시 수식 문서 폴더(정본 파일 안 고침) ────────────────────────────── @pytest.fixture def docs_tmp(tmp_path, monkeypatch): dst = tmp_path / "수식문서" shutil.copytree(ml.FOLDER, dst) load = ml.load_all monkeypatch.setattr(ml, "FOLDER", dst) monkeypatch.setattr(ml, "load_all", lambda folder=dst: load(folder)) m01doc._memo.clear() dc._FOLDER["자국"] = None yield dst m01doc._memo.clear() dc._FOLDER["자국"] = None def _json(v): """화면 왕복(JSON 수).""" return json.loads(json.dumps(ml._norm(v), ensure_ascii=False)) def _norm(v): return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, sort_keys=True)) def _defaults() -> dict: """정본 — BASE 기본 옵션 굴착기(NO)의 덮음 없는 기본값.""" links = ml.Links(m01.loaded()[1]) memo: dict = {} doc = {k: v for k, v in links.doc(BASE).items() if k != COVER} mc.calc(doc, links, None, (), memo) for (key, given), ans in memo.items(): if mcv.is_machine(sub := links.doc(key)) and mcv.machine_key(dict(given)) == NO: lists = mcv.lists_of(links, dict(given)) return mcv.defaults_of(sub, ans["값"], mcv.row_entry(sub, lists)) raise AssertionError("굴착기 부름 없음") def _upper(d: dict, rate=D("1.5")) -> dict: """기초 고침 ① — 가격 · 조종원 · 작업량(시간당 + 변수 f).""" return {NO: {"값": {"가격": float(D(str(d["값"]["가격"])) * rate)}, "조종원": [{"키": d["조종원"][0]["키"], "인": 2}]}, SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip def _save_m01(cover: dict | None, edit=None) -> dict: doc = _json(m01doc.read(BASE)["문서"]) doc.pop(COVER, None) if cover: doc[COVER] = _json(cover) if edit: edit(doc) return m01doc.save(doc) def _calls(key: str) -> bool: return any( (v.get("연결") or {}).get("키") == "GC000267" for v in m01doc.docs()[key].get("변수") or [] ) def test_M01_기초_고침_되돌림(docs_tmp): d = _defaults() file = ml.FOLDER / m01doc._where(BASE) orig = file.read_text(encoding="utf-8") # 글(줄 끝 맞춤) — CRLF 체크아웃도 같게 other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k)) before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"] price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] # ㉠ 고침 저장 — 문서 밖 기계(9999) = 뺌 want = _upper(d) got = _save_m01({**want, "9999-9999": {"값": {"가격": 1}}}) saved = ml.load_all()[BASE] assert _norm(saved[COVER]) == _norm(want) and mcv.HAND not in saved assert got["셈"]["계"] != before and m01doc.read(BASE)["셈"]["계"] == got["셈"]["계"] assert m01doc.read(other)["셈"]["계"] == other_before # 다른 기초 그대로 assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로 line = next(x for x in got["셈"]["줄"] if x.get("작업량")) assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8" # ㉣ 정본 값으로 되돌림 = 고침 0 · 글 = 고침 전 back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]}, SYM: {"작업량": {"방식": "일당"}}} # fmt: skip got = _save_m01(back) assert COVER not in got["문서"] and file.read_text(encoding="utf-8") == orig assert got["셈"]["계"] == before # 줄 식을 고친 문서 = 받은 문서 그대로 + 손고침 표지(한 번 붙으면 남음 · 855-E L4) first = m01doc.read(BASE)["문서"]["금액"][0]["수량"] got = _save_m01(None, lambda doc: doc["금액"][0].update({"수량": "Q_굴착기^표 × 9 ÷ Q_시공"})) assert got["문서"]["금액"][0]["수량"] == "Q_굴착기^표 × 9 ÷ Q_시공" assert ml.load_all()[BASE].get(mcv.HAND) is True _save_m01(None, lambda doc: doc["금액"][0].update({"수량": first})) assert ml.load_all()[BASE].get(mcv.HAND) is True def _sk(me) -> str: with store.at(me): body = skrow.logic_doc({"로직": BASE, "입력값": {}}, {}, m01.loaded()[1]) return refs.create("sangeun", {**body, "이름": "sub2임시 848"})["이름"] def _at(me, fn, *args): with store.at(me): return fn(*args) def _mixed_sum(cover: dict) -> float: """기초 문서(덮음 뗌)에 cover 를 얹은 셈 계 — SK 금액 대조.""" links = ml.Links(m01.loaded()[1]) doc = {k: v for k, v in links.doc(BASE).items() if k != COVER} return float(mc.calc(doc, links, None, (), None, cover)["계"]) def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world): me = world["personal"] d = _defaults() upper = _upper(d) _save_m01(upper) base_sum = float(m01doc.read(BASE)["셈"]["계"]) key = _sk(me) got = _at(me, path.read, key) # ㉡ ① = 위덮음 · 금액 = 기초 금액 · 파일에 굳음 assert _norm(got["위덮음"]) == _norm(upper) and COVER not in got["문서"] assert float(got["셈"]["계"]) == base_sum with store.at(me): file = store.read("sangeun", key)["문서"]["수식"] assert _norm(file[mcv.UPPER]) == _norm(upper) # SK 에서 한 칸 더 고침 → ② 에만(① 과 같은 가격 = 지움 · 작업량 = 바꾼 변수만) doc = cp.deepcopy(got["문서"]) doc[COVER] = {NO: {"값": {"가격": upper[NO]["값"]["가격"], "주연료": 20}}, SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.9}}}} # fmt: skip after = _at(me, path.save, key, {"문서": doc, "판": got["판"]}) mine = {NO: {"값": {"주연료": 20}}, SYM: {"작업량": {"변수": {"f": 0.9}}}} assert _norm(after["문서"][COVER]) == _norm(mine) and _norm(after["위덮음"]) == _norm(upper) assert float(after["셈"]["계"]) == _mixed_sum(mcv.merge_layers(upper, mine)) != base_sum assert mcv.sources(upper[NO], mine[NO]) == {"값.가격": "위", "조종원": "위", "값.주연료": "나"} assert mcv.sources(upper[SYM], mine[SYM]) == { "작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "나" } # fmt: skip # ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도) with store.at(me): here = refs.here() ref = {"층": here[0], "주인": here[1], "키": key} rows = source.labor_doc_rows( {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} ) bundle = source.price_bundle(rows, me) formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6) frozen = rows["참조사본"][refs.ref_id(ref)]["수식"] assert _norm(frozen[mcv.UPPER]) == _norm(upper) was = float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) assert was == float(after["셈"]["계"]) _save_m01(_upper(d, D(2))) # 기초 고침이 바뀜 now = _at(me, path.read, key) assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것 assert ( float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) == was ) # 사본 = 굳은 것 _save_m01(upper) # ㉢ ② 를 위 층 값으로 = ② 0 now = _at(me, path.read, key) doc = cp.deepcopy(now["문서"]) doc[COVER] = {NO: {"값": {"주연료": d["값"]["주연료"]}}, SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip back = _at(me, path.save, key, {"문서": doc, "판": now["판"]}) assert COVER not in back["문서"] and float(back["셈"]["계"]) == base_sum with store.at(me): assert COVER not in store.read("sangeun", key)["문서"]["수식"]["문서"] # ㉤ 옵션으로 기계를 바꿔 저장 = 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 doc = cp.deepcopy(back["문서"]) next(v for v in doc["변수"] if v["열쇠"] == "Type")["연결"]["값"] = "TypeⅢ" doc[COVER] = {NO: {"값": {"주연료": 20}}, "9999-9999": {"값": {"가격": 1}}} moved = _at(me, path.save, key, {"문서": doc, "판": back["판"]}) assert moved["문서"][COVER] == {NO: {"값": {"주연료": 20}}} line = next(x for x in moved["셈"]["줄"] if x.get("작업량")) assert line["작업량"]["기계"] == NO3 # 셈은 바꾼 기계(앞 기계 고침은 안 걸림) def test_A_가_B_를_부를_때_A_고침만(): links = ml.Links(m01.loaded()[1]) a, b, no = "GF000177", "GF000168", "0201-0070" price = float(m01.loaded()[1].numbers["EQ"][no]["값"]["가격"]) cover = {no: {"값": {"가격": price * 2}}} given = {"기초잡석량": D(1)} # A(날개벽) 기초잡석 1 ㎥ = B(기초잡석) 부름 plain_a = mc.calc(links.doc(a), links, given)["계"] plain_b = mc.calc(links.doc(b), links)["계"] assert plain_a > 0 with_b = ml.Links(m01.loaded()[1], {**links.docs, b: {**links.doc(b), COVER: cover}}) assert mc.calc(with_b.doc(a), with_b, given)["계"] == plain_a # B 의 고침 = A 셈에 안 걸림 assert mc.calc(with_b.doc(b), with_b)["계"] != plain_b # B 를 맨 위로 열면 걸림 mine = mc.calc({**links.doc(a), COVER: cover}, links, given)["계"] assert mine > plain_a # A 고침 = B 안 기계 줄까지