- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0) - Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 · labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움) - M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 · 손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함) - M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서) - 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움 - 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 · 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) · 848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음 - 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
336 lines
17 KiB
Python
336 lines
17 KiB
Python
# 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 안 기계 줄까지
|