diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 747e295e4..62c84cb3e 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -7,6 +7,8 @@ - 읽기 {키} → {문서, 셈, 연결, 파일, 새} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) - 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음 - 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음) + · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면 + 빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐) 권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4). """ @@ -20,6 +22,7 @@ from M01_MasterData import M01_MasterData_Store as store import master_doc as md # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤 import master_doc_calc as mc # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_doc_record as mr # noqa: E402 import master_equation_link as link # noqa: E402 @@ -103,9 +106,47 @@ def _file_for(key: str) -> str: return OWN_FILE +def built(key: str) -> dict | None: + """빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None.""" + import master_doc_convert as cv + + files, whole = store.loaded() + for data in files.values(): + if data.get("그룹") != "로직": + continue + for row in data.get("줄") or []: + if str(row.get("키")) == key: + try: + return cv.convert(whole, row)[0] + except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담) + return None + return None + + +def layered(doc: dict, key: str) -> dict: + """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · + 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" + links = ml.Links(store.loaded()[1], {**docs(), key: doc}) + try: + doc = mcv.prune_doc(doc, links) + except ValueError as e: + raise store.StoreError(400, str(e)) from e + cover = doc.get(mcv.COVER) + bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} + base = built(key) + hand = base is not None and ml._norm(bare) != ml._norm(base) + if base is not None and not hand: + bare = base + out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})} + if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례) + out["쌓기"] = out.pop("쌓기") + return out + + def save(doc: dict) -> dict: doc = _check(doc) key = str(doc["키"]).strip() + doc = layered(doc, key) name = _file_for(key) path = folder() / name data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index 4db3e3f5f..ecd5a19a1 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -6,7 +6,8 @@ {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 자원 줄], ← 값 사본(`M02_Sangeun_Copy` 꼴) 부름 {키: 문서}(닫힌 묶음 — 연결 · [재생성] 때 새로) · SK 만: 문서(이 SK 문서 · 사용자 고침) · 끊음 {키: 문서}(이 사본 안에 굳힌 부름 · 고칠 수 있음) · - 따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음)} + 따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) · + 위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)} 셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) · [단가 갱신] = 자원 단가 줄만 지금 M01(`skc.refresh`) · 문서 그대로 · [재생성] = 지금 M01 문서로. 부름 문서 = 값 사본 줄이 지금 M01 줄과 같으면 M01 문서(`수식문서/`) · 다르면(만든 때 옛 줄) 그 줄을 @@ -36,6 +37,7 @@ import master_auto as mau # noqa: E402 import master_doc as md # noqa: E402 import master_doc_calc as mc # noqa: E402 import master_doc_convert as cv # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_doc_work as mw # noqa: E402 @@ -139,10 +141,23 @@ def docs_of(copy: dict) -> dict[str, dict]: return {**(copy.get("부름") or {}), **(copy.get("끊음") or {})} +def cover_of(copy: dict, doc: dict | None = None) -> dict: + """셈 cover(848-1) — ① `위덮음` 위에 ② 문서 `기계덮음` · ① 없음 = 문서 칸 그대로.""" + return mcv.merge_layers( + copy.get(mcv.UPPER), mcv.cover_of(copy.get("문서") if doc is None else doc) + ) + + +def upper_calls(copy: dict) -> list[str]: + """① 위 층 덮음의 시간당 작업량 식 · 굳은 기계 식 문서 키(부름 닫힌 묶음에 더함 · 848-1).""" + return mw.cover_calls({mcv.COVER: copy.get(mcv.UPPER) or {}}) + + def run(doc: dict, copy: dict, given: dict | None = None, whole: Any = None) -> dict: - """문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저).""" + """문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저) · cover = ① + ②(`cover_of`).""" try: - return mc.calc(doc, ml.Links(whole or over(copy), docs_of(copy)), given) + links = ml.Links(whole or over(copy), docs_of(copy)) + return mc.calc(doc, links, given, cover=cover_of(copy, doc)) except _ERR as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로 return {"셈됨": False, "표지": [{"갈래": "셈 틀림", "글": str(e)}], **dict.fromkeys(COSTS)} diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index 1e20667d3..fbe8b4653 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -52,7 +52,7 @@ def gaps(copy: dict) -> list[str]: return [] seen = _Seen(dc.over(copy)) try: - dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy))) + dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)), cover=dc.cover_of(copy)) except dc._ERR: pass have = _have(copy) diff --git a/M02_MasterTemplete/M02_Doc_Screen.py b/M02_MasterTemplete/M02_Doc_Screen.py index c1801479e..58b0a4357 100644 --- a/M02_MasterTemplete/M02_Doc_Screen.py +++ b/M02_MasterTemplete/M02_Doc_Screen.py @@ -32,7 +32,7 @@ def record(copy: dict) -> dict[str, Any]: rec = mr.Rec(dc.ml.Links(dc.over(copy), dc.docs_of(copy))) try: rec.prefetch(copy["문서"]) - dc.mc.calc(copy["문서"], rec) + dc.mc.calc(copy["문서"], rec, cover=dc.cover_of(copy)) # ① + ②(848-1) except dc._ERR: # 셈 틀림 = 셈 답 표지(`dc.run`) — 기록은 모은 데까지 pass return rec.out() diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index d971df7f3..295590e3c 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -11,6 +11,9 @@ SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 · SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 사전조합 · 구조물 조합이 이 값을 씀. 가져온 식 SK(807-1) = `M02_Doc_Import` 문서(파생 = 가져온 줄 + SK 고침에서 지음 · 따로 = 저장본) · 셈 = 단가기준(엑셀 = 엑셀 값 · 우리 = 연결 값) · 바탕 참조 SK = 옛 길(값 사본 없음). +위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) — + 프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 · + 파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임). """ from __future__ import annotations @@ -29,7 +32,10 @@ from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sk_AutoRenew as renew +import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc + KEY = dc.KEY +UPPER = mcv.UPPER OLD_FIELDS = ( "바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침", "고름", "자재표시", "켜쌓기율", @@ -88,7 +94,7 @@ def derive(sk: dict, ctx: tuple) -> dict: same = False plain = dc.doc_of(whole, base_key) if same else None if plain is not None: - doc = cp.deepcopy(plain) + doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1) _set_values(doc, given) elif not (row.get("호표") or row.get("덧줄") or row.get("결과")): doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or "")) @@ -112,6 +118,30 @@ def seed(sk: dict) -> dict | None: return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))} +def with_upper(sk: dict, got: dict) -> dict: + """① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 · + ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함.""" + key = str((sk.get("바탕") or {}).get("로직") or "") + live = dc.folder().get(key) if key else None + if live is None: + return got + cover = mcv.cover_of(live) + if not cover: + return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got + out = {**got, UPPER: cp.deepcopy(cover)} + have = dc.docs_of(out) + if need := [k for k in dc.upper_calls(out) if k not in have]: + out["부름"] = {**(out.get("부름") or {}), **dc.closure(dc.over(out), need, have)} + return out + + +def upper(sk: dict, got: Any) -> Any: + """셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1).""" + if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk): + return got + return with_upper(sk, got) + + def copy_of(sk: dict, ctx: tuple | None) -> dict | None: """셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 옛 칸으로 다시 지은 문서(부름은 있던 것 먼저) · `OLD` 켬(옮기기 대조 · 시험) = 옛 길.""" @@ -120,7 +150,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None: got = sk.get(KEY) if dc.has(sk) else seed(sk) if got is None: return None - got = renew.form(sk, got) # M01 자동 따라옴(836-2) + got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1) if got.get("따로") or ctx is None: return got if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎) @@ -137,7 +167,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None: values = dc.values_of(sk[skc.KEY]) if skc.has(sk) else dc.values_of(got) # 서버가 정한 값 values = renew.rows(values) if renew.is_sk(sk) else values # 836-2 whole = dc.over(values) - calls = dc.closure(whole, dc.calls(root), got.get("부름")) + calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지) origin = {"원본": {"키": base, "판": dc.fp(seen)}} if seen else {} @@ -194,7 +224,9 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: return {**out, KEY: norm(mine["사본"])} file = stored(out.get("키")) or {} have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None) - have = renew.form(out, have) if have else have # 836-2 — 바뀐 항목 고침 지움 · 저장 때 굳음 + have = ( + upper(out, renew.form(out, have)) if have else have + ) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음 if have and have.get("따로") and job != skc.REGEN: if file and old_fp(file) != old_fp(out): raise sd.DocError( @@ -216,6 +248,10 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": calls} if job != skc.REGEN and (have or {}).get("끊음"): # 안 바뀐 항목 고침 = 그대로(836-2) first["끊음"] = have["끊음"] + if (have or {}).get( + UPPER + ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) + first[UPPER] = have[UPPER] copy = copy_of({**out, KEY: first}, box[-1] if box else None) if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 398f34b4e..79a0f516c 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -10,6 +10,8 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} 가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음 (형제 SK 는 셈 때 읽음) · 단가갱신 = 문서 그대로 · 바탕 참조 SK = 값 사본 없음(400). 저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`). +위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② · + 저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`). """ from __future__ import annotations @@ -89,6 +91,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: ) body = { "문서": copy["문서"], + "위덮음": copy.get(dsk.UPPER) or {}, "부름": copy.get("부름") or {}, "끊음": copy.get("끊음") or {}, "셈": got, @@ -152,8 +155,9 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: calls = [ *dc.calls(out["문서"]), *(c for d in out.get("끊음", {}).values() for c in dc.calls(d)), + *dc.upper_calls(out), # ① 위 층 덮음 식(848-1) ] - try: # 기계 덮음(836-1) — 몸 검사 · 원본과 같은 칸 · 안 부르는 기계 뺌(가져온 식 = 검사만) + try: # 기계 덮음(836-1) — 몸 검사 · 위 층과 같은 칸 · 문서 밖 기계 뺌(가져온 식 = 검사만) if dim.is_imported(sk): got = mcv.clean(out["문서"].get(mcv.COVER)) rest = {k: v for k, v in out["문서"].items() if k != mcv.COVER} @@ -163,7 +167,8 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: if not dim.is_imported(sk): out["부름"] = dc.closure(dc.over(out), calls, copy.get("부름")) try: - out["문서"] = mcv.prune_doc(out["문서"], dc.ml.Links(dc.over(out), dc.docs_of(out))) + links = dc.ml.Links(dc.over(out), dc.docs_of(out)) + out["문서"] = mcv.prune_doc(out["문서"], links, out.get(dsk.UPPER)) # ② 대 ① + 정본 except ValueError as e: raise _bad(str(e)) from e out = gap.fill(out) # 셈이 읽은 줄 가운데 사본 없는 것 = 지금 값으로 박음(822-1) diff --git a/M02_MasterTemplete/M02_Item_Sangeun.py b/M02_MasterTemplete/M02_Item_Sangeun.py index 5aec58da5..9d5b7e2d1 100644 --- a/M02_MasterTemplete/M02_Item_Sangeun.py +++ b/M02_MasterTemplete/M02_Item_Sangeun.py @@ -86,13 +86,21 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]: if got["켜쌓기율"] is not None: frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"]) if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02 - frozen["수식"] = doc["수식"] + frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것 out[rid] = frozen for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)): out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken) return out +def _upper(doc: dict) -> dict: + """SK `수식` — ① 위 층 덮음을 굳힐 때 기초 것으로(848-1 · 가져온 식 · 기초 문서 없음 = 저장본).""" + from M02_MasterTemplete import M02_Doc_Import as dim + from M02_MasterTemplete import M02_Doc_Sk as dsk + + return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"]) + + def _patched(doc: Any) -> list[int]: """일위대가(SC) 사본의 덮개 줄(로직 줄 + `패치` · 740-1 SK 넣기 꼴) 차례.""" if not isinstance(doc, dict) or doc.get("종류") != refs.TITLE["precombo"]: diff --git a/common_util/common_util_formula_doc_cover.ts b/common_util/common_util_formula_doc_cover.ts index ffed83f1b..23fb406f8 100644 --- a/common_util/common_util_formula_doc_cover.ts +++ b/common_util/common_util_formula_doc_cover.ts @@ -8,8 +8,12 @@ * 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음) * 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) · * 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째) + * 겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) → + * ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`mergeCover` · `mergeLayers` · `layeredCover` — 작업량 = 방식 · + * 식 · 변수 열쇠 · 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `putCover` 의 `upper`) · 위 층 값(`upperOf`) · + * 출처(`sourcesOf`) * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py · - * test_842_3_machine_crew.py + * test_842_3_machine_crew.py · test_848_1_cover_layers.py * · 화면 · DOM · fetch 없음 * ========================================================================== */ @@ -22,10 +26,18 @@ import { type FormulaDoc, type MoneyLine, } from "./common_util_formula_doc"; -import { WORK, pruneWork, type WorkCover } from "./common_util_formula_doc_work"; +import { DAILY, HOURLY, WORK, type WorkCover } from "./common_util_formula_doc_work"; import { CREW, MISC, code as jobOf } from "./common_util_machine_crew"; export const COVER = "기계덮음"; +/** SK `수식` 칸 — ① 위 층 고침(848-1 · 꼴 = `기계덮음`) */ +export const UPPER = "위덮음"; +/** M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) */ +export const HAND = "손고침"; +/** 출처(`sourcesOf`) — 없는 칸 = 정본 */ +export const MINE = "나"; +export const ABOVE = "위"; +export type Source = typeof MINE | typeof ABOVE; /** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */ export const NOT_VALUE = ["조종원", "조종원직종", "잡재료율"]; const HOUR = "Q_시간환산"; @@ -224,36 +236,174 @@ const sameVal = (a: unknown, b: unknown): boolean => ? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b)) : String(a) === String(b); -/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) */ +/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) · + * 848-1 한 층의 작업량은 바꾼 칸만 담을 수 있음(`방식` 없음 = 위 층 방식) — 읽을 때는 `mergeLayers` 답을 봄 */ export type CoverEntry = MachineCover & { [WORK]?: WorkCover }; /** 원본 기본값 + 작업량 기본 변수(`workDefaults` · 없으면 변수 그대로) */ export type CoverBase = Required & { [WORK]?: Record }; +/** 위 층 값(`upperOf`) — 정본 기본 위에 ① · 작업량 = ① 층 그대로 */ +export type UpperValue = Required & { [WORK]?: WorkCover }; +/** 작업량 한 층(848-1) — 바꾼 칸만(방식 없음 = 위 층 방식) */ +export type WorkLayer = Partial; -/** 원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null */ -export function prune(entry: CoverEntry, base: CoverBase): CoverEntry | null { +/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null — + * `base` = 정본 기본(`defaultsOf` · 작업량 = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위) */ +export function prune( + entry: CoverEntry, + base: CoverBase, + upper?: CoverEntry | null, +): CoverEntry | null { + const up = upperOf(base, upper); const out: CoverEntry = {}; const vals = Object.entries(entry.값 ?? {}).filter( - ([k, v]) => - v !== null && v !== undefined && v !== "" && !(k in base.값 && sameVal(v, base.값[k])), + ([k, v]) => v !== null && v !== undefined && v !== "" && !(k in up.값 && sameVal(v, up.값[k])), ); if (vals.length) out.값 = Object.fromEntries(vals); - if (entry.조종원 && canon(entry.조종원) !== canon(base.조종원)) out.조종원 = entry.조종원; - if (entry.잡품 && canon(entry.잡품) !== canon(base.잡품)) out.잡품 = entry.잡품; - const work = pruneWork(entry[WORK], base[WORK] ?? null); - if (work) out[WORK] = work; + if (entry.조종원 && canon(entry.조종원) !== canon(up.조종원)) out.조종원 = entry.조종원; + if (entry.잡품 && canon(entry.잡품) !== canon(up.잡품)) out.잡품 = entry.잡품; + const work = pruneWorkLayer(entry[WORK], base[WORK] ?? null, upper?.[WORK] ?? null); + if (work) out[WORK] = work as WorkCover; return Object.keys(out).length ? out : null; } -/** 덮음 한 기계 고침 → 문서 칸(원본 대조로 정리 · 비면 칸 지움) */ +// ── 층(848-1) ───────────────────────────────────────────────────────── +const FIXED = ["기계", "키", "이름"] as const; +const fixedOf = (w: WorkLayer): WorkLayer => { + const out: WorkLayer = {}; + for (const k of FIXED) if (w[k]) out[k] = String(w[k]); + return out; +}; +const sameNum = (a: unknown, b: unknown): boolean => { + const x = Number(a); + const y = Number(b); + return a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y) + ? Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x)) + : String(a) === String(b); +}; + +/** 작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · `base` = 그 식 기본 변수 + * (`workDefaults`) · 일당 = 방식만 · 남는 것 없음 = null(위 층 없음 = `pruneWork` 와 같음) */ +export function pruneWorkLayer( + want: WorkLayer | null | undefined, + base: Record | null = null, + upper: WorkLayer | null = null, +): WorkLayer | null { + if (!want || typeof want !== "object") return null; + const up = upper ?? {}; + const upWay = up.방식 || DAILY; + const way = want.방식 || upWay; + const out: WorkLayer = way !== upWay ? { 방식: way } : {}; + if (way !== HOURLY) return Object.keys(out).length ? out : null; + const upForm = upWay === HOURLY ? String(up.식 ?? "") : ""; + const form = String(want.식 ?? "") || upForm; + if (form !== upForm) out.식 = form; + const held = { ...(base ?? {}), ...(form === upForm ? (up.변수 ?? {}) : {}) }; + const got = Object.entries(want.변수 ?? {}).filter( + ([k, v]) => v !== null && v !== undefined && v !== "" && !(k in held && sameNum(v, held[k])), + ); + if (got.length) out.변수 = Object.fromEntries(got); + const fix = fixedOf(want); + const upFix = upWay === HOURLY ? fixedOf(up) : {}; + if ( + Object.keys(fix).length && + (!Object.keys(upFix).length || fix.기계 !== upFix.기계 || fix.키 !== upFix.키) + ) + Object.assign(out, fix); + return Object.keys(out).length ? out : null; +} + +/** 작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) · + * 식을 바꾼 아래 층 = 위 층 변수 안 물려받음 */ +export function mergeWork( + top: WorkLayer | null | undefined, + low: WorkLayer | null | undefined, +): WorkLayer | null { + if (!top || !Object.keys(top).length) return low && Object.keys(low).length ? low : null; + if (!low || !Object.keys(low).length) return top; + let out: WorkLayer = { ...top }; + if (low.방식) out.방식 = low.방식; + if (low.식 && String(low.식) !== String(top.식 ?? "")) { + out.식 = low.식; + delete out.변수; + } + const vals = { ...(out.변수 ?? {}), ...(low.변수 ?? {}) }; + if (Object.keys(vals).length) out.변수 = vals; + if (low.기계) { + out = Object.fromEntries( + Object.entries(out).filter(([k]) => !(FIXED as readonly string[]).includes(k)), + ) as WorkLayer; + Object.assign(out, fixedOf(low)); + } + return out; +} + +/** ① 위 층 고침 위에 ② 내 고침(열쇠마다 `mergeCover`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로 */ +export function mergeLayers( + upper: Cover | null | undefined, + mine: Cover | null | undefined, +): Cover { + if (!upper || !Object.keys(upper).length) return mine ?? {}; + if (!mine || !Object.keys(mine).length) return upper; + const out: Cover = {}; + for (const k of [...Object.keys(upper), ...Object.keys(mine).filter((k) => !(k in upper))]) { + const got = mergeCover(upper[k], mine[k]); + if (got) out[k] = got; + } + return out; +} + +/** 화면 셈 cover — 문서 칸 `기계덮음`(②) 을 ① 위에 얹음(SK = 읽기 답 `위덮음` · M01 = 없음) */ +export const layeredCover = (doc: FormulaDoc, upper?: Cover | null): Cover => + mergeLayers(upper, coverOf(doc)); + +/** 위 층 값 — 정본 기본(`defaultsOf`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `workDefaults`) */ +export function upperOf(base: CoverBase, upper?: CoverEntry | null): UpperValue { + const { [WORK]: _, ...rest } = base; + const out: UpperValue = { ...rest }; + if (!upper) return out; + out.값 = { ...base.값, ...(upper.값 ?? {}) }; + if (upper.조종원) out.조종원 = upper.조종원; + if (upper.잡품) out.잡품 = upper.잡품; + if (upper[WORK]) out[WORK] = upper[WORK]; + return out; +} + +/** 칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · `작업량.방식` · + * `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계` */ +export function sourcesOf( + upper: CoverEntry | null | undefined, + mine: CoverEntry | null | undefined, +): Record { + let out: Record = {}; + const upForm = String((upper?.[WORK] as WorkLayer | undefined)?.식 ?? ""); + for (const [layer, tag] of [ + [upper, ABOVE], + [mine, MINE], + ] as const) { + const e = layer ?? {}; + for (const k of Object.keys(e.값 ?? {})) out[`값.${k}`] = tag; + if (e.조종원) out.조종원 = tag; + if (e.잡품) out.잡품 = tag; + const w = (e[WORK] ?? {}) as WorkLayer; + if (tag === MINE && w.식 && String(w.식) !== upForm) + out = Object.fromEntries(Object.entries(out).filter(([k]) => !k.startsWith("작업량.변수."))); + for (const k of ["방식", "식", "기계"] as const) if (w[k]) out[`작업량.${k}`] = tag; + for (const k of Object.keys(w.변수 ?? {})) out[`작업량.변수.${k}`] = tag; + } + return out; +} + +/** 덮음 한 기계 고침 → 문서 칸(위 층 대조로 정리 · 비면 칸 지움) — `upper` = ① 그 열쇠 칸(848-1 · SK) */ export function putCover( doc: FormulaDoc, machine: string, entry: CoverEntry, base: CoverBase, + upper?: CoverEntry | null, ): void { const box = doc as Holder; const all = { ...coverOf(doc) }; - const kept = prune(entry, base); + const kept = prune(entry, base, upper); if (kept) all[machine] = kept; else delete all[machine]; if (Object.keys(all).length) box[COVER] = all; @@ -388,17 +538,21 @@ export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): Machin return Object.keys(out).length ? out : null; } -/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */ +/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) · + * 작업량 = `mergeWork`(848-1) */ export function mergeCover( - base: MachineCover | null | undefined, - top: MachineCover | null | undefined, -): MachineCover | null { + base: CoverEntry | null | undefined, + top: CoverEntry | null | undefined, +): CoverEntry | null { if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null; if (!top || !Object.keys(top).length) return base; - const out: MachineCover = { ...base, ...top }; + const out: CoverEntry = { ...base, ...top }; const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) }; if (Object.keys(값).length) out.값 = 값; else delete out.값; + const work = mergeWork(base[WORK], top[WORK]); + if (work) out[WORK] = work as WorkCover; + else delete out[WORK]; return out; } diff --git a/resources/master_data/_수식문서_틀.md b/resources/master_data/_수식문서_틀.md index 299537c29..588c1261b 100644 --- a/resources/master_data/_수식문서_틀.md +++ b/resources/master_data/_수식문서_틀.md @@ -13,7 +13,7 @@ - 자리 = `수식문서/수식_<옛 로직 파일 꼬리>.json` — 옛 로직 파일마다 한 벌(`로직_건설품셈_08장_건설기계.json` → `수식_건설품셈_08장_건설기계.json`). - 머리 = `그룹`(「수식문서」) · `로직파일`(옛 로직 파일 이름) · `줄`(문서 목록 · 옛 로직 차례). - UTF-8 · LF · 들여쓰기 2칸 · 변수 · 식 · 금액 줄 하나 = 한 줄. -- 옛 로직 JSON 과 따로 — 빌더만 씀(옛 로직 JSON 은 안 씀). +- 옛 로직 JSON 과 따로 — 빌더가 씀(옛 로직 JSON 은 안 씀) · M01 화면 저장은 10 절(기계덮음 · 손고침). ## 2. 문서 @@ -129,3 +129,21 @@ | 기계경비식 | 기계 시간당 경비 셈 방식(기계 줄이 부름) | — | M01 「기계」 기종 아래 | | 작업량 틀 | 기종 공식(Q = 3,600 × q × K × f × E ÷ Cm 등) | `기종` = 기계표 상세구분 목록 · `규격` = 기계 규격 수를 받는 변수 열쇠 | M01 「기계」 기종 아래 | | 계수식 | 기계 무관 · 돈 아닌 식 | — | M01 「계수」 아래 | + +## 10. 겹쳐 덮는 층(848-1) — 기계 고침 + +| 층 | 자리 | 주인 | +| --- | --- | --- | +| ⓪ 정본 | M01 기계 한 대 파일 · 내 기계 | 시스템 관리자 · 사용자(내 기계) | +| ① 위 층 고침 | M01 문서 칸 `기계덮음` · SK `수식.위덮음`(그 사본 · 가져온 식 = 가져온 값) | 시스템 관리자 · 불러오기 | +| ② 내 고침 | SK `수식.문서.기계덮음` | 사용자 | + +- 꼴 = `{열쇠: {값?: {칸: 값}, 조종원?: [줄], 잡품?: [줄], 작업량?: {방식?, 식?, 변수?, 기계?, 키?, 이름?}}}` · 열쇠 = 기계 입력 글 · 작업량은 그 줄 단가 기호. +- 칸 단위 = 값 칸 하나 · 작업량 방식 · 식 · 변수 하나 · 기계 고정(기계 · 키 · 이름 한 덩이) · 조종원 목록 통째 · 잡품 목록 통째. +- 합침 = ⓪ 위에 ① · 그 위에 ②(칸마다 아래 층이 이김 · 식을 바꾼 층은 위 층 변수를 안 물려받음) — `master_doc_cover.merge` · `merge_layers` ↔ `mergeCover` · `mergeLayers` · `layeredCover`. +- 셈 = 계산기 `cover` 인자에 합친 것(맨 위 문서 하나만 · 부르는 문서의 덮음은 안 읽음). +- 지움 = 층마다 위 층과 같은 칸을 뺌(`prune` · `prune_doc` 의 `upper`) · 문서 안(선택 목록 · 따옴표 글 · 변수 기호) · 굳은 기계에 든 열쇠의 고침은 이번 셈이 안 불러도 남김. +- 위 층 값 = `upper_of` ↔ `upperOf` · 출처 = `sources` ↔ `sourcesOf`(칸 경로 → 「나」 · 「위」 · 없으면 정본). +- SK `수식.위덮음` = 프로젝트 층 밖은 셈마다 지금 기초(`바탕.로직`) 문서 것 · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본. +- M01 저장(`/logic/doc/save`) = `기계덮음` 검사 · 지움 뒤 씀 · 셈 칸이 빌더 결과와 다른 문서 = 칸 `손고침: true`. +- 빌더 = 저장본 `기계덮음` 을 키별로 이어받음 · `손고침` 문서는 저장본 그대로(실행 때 목록) · `--check` 도 같은 규칙. diff --git a/resources/master_data/scripts/build_수식문서_802_2.py b/resources/master_data/scripts/build_수식문서_802_2.py index 42bf0dc92..5db158161 100644 --- a/resources/master_data/scripts/build_수식문서_802_2.py +++ b/resources/master_data/scripts/build_수식문서_802_2.py @@ -19,6 +19,8 @@ · 옛 로직 JSON 은 안 씀). - 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약). - 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`). +- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 · + `손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림. """ from __future__ import annotations @@ -36,6 +38,7 @@ import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만) import master_doc as md # noqa: E402 import master_doc_calc as mc # noqa: E402 import master_doc_convert as cv # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_equation as meq # noqa: E402 import master_formula as mf # noqa: E402 @@ -184,9 +187,33 @@ def build(log=print) -> dict: "대조": runs, "저장": keep, "요약": summary, + "저장본": carried(), } +def carried() -> dict[str, dict]: + """이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}.""" + if not ml.FOLDER.exists(): + return {} + return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)} + + +def hand_kept(result: dict) -> list[str]: + """저장본 그대로 둔 `손고침` 문서 키(저장되는 것만).""" + have = result.get("저장본") or {} + return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"]) + + +def _out_doc(result: dict, key: str) -> dict: + """쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서.""" + have = (result.get("저장본") or {}).get(key) + if have and have.get(mcv.HAND): + return have + if have and have.get(mcv.COVER): + return {**result["문서"][key], mcv.COVER: have[mcv.COVER]} + return result["문서"][key] + + def _calls(doc: dict) -> set[str]: out = set() for v in doc.get("변수") or []: @@ -229,7 +256,7 @@ def files_of(result: dict) -> dict[str, str]: """저장 파일 이름 → 글.""" out = {} for name, keys in result["파일"].items(): - kept = [result["문서"][k] for k in keys if k in result["저장"]] + kept = [_out_doc(result, k) for k in keys if k in result["저장"]] body = {"그룹": "수식문서", "로직파일": name, "줄": kept} out[ml.file_of(name)] = ml.dump(body) return out @@ -323,6 +350,8 @@ def main() -> int: parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만") args = parser.parse_args() result = build() + if hand := hand_kept(result): + print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}") if args.check: bad = check(result) for line in bad: diff --git a/resources/master_data/scripts/master_doc_cover.py b/resources/master_data/scripts/master_doc_cover.py index 4fd71bfe3..d751f46b5 100644 --- a/resources/master_data/scripts/master_doc_cover.py +++ b/resources/master_data/scripts/master_doc_cover.py @@ -7,8 +7,11 @@ 덮음 없음 = 문서 그대로(금액 전후 같음). 기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) · 단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째). +겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) → + ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`merge` · `merge_layers` — 작업량 = 방식 · 식 · 변수 열쇠 · + 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `prune_doc` 의 `upper`) · 위 층 값(`upper_of`) · 출처(`sources`). 파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험 -`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py`. +`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py` · `test_848_1_cover_layers.py`. """ from __future__ import annotations @@ -23,6 +26,9 @@ import master_doc_work as mw import master_machine_crew as mcrew COVER = "기계덮음" +UPPER = "위덮음" # SK `수식` 칸 — ① 위 층 고침(848-1) +HAND = "손고침" # M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) +MINE, ABOVE = "나", "위" # 출처(`sources`) — 없는 칸 = 정본 NOT_VALUE = ( "조종원", "조종원직종", @@ -192,24 +198,136 @@ def _same(a, b) -> bool: return str(a) == str(b) -def prune(entry: dict, base: dict) -> dict | None: - """원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None.""" +def prune(entry: dict, base: dict, upper: dict | None = None) -> dict | None: + """위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None — + `base` = 정본 기본(`defaults_of` · `작업량` = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위).""" + up = upper_of(base, upper) out: dict = {} vals = { k: v for k, v in (entry.get("값") or {}).items() - if v not in (None, "") and not (k in base["값"] and _same(v, base["값"][k])) + if v not in (None, "") and not (k in up["값"] and _same(v, up["값"][k])) } if vals: out["값"] = vals for part in ("조종원", "잡품"): - if entry.get(part) is not None and _canon(entry[part]) != _canon(base[part]): + if entry.get(part) is not None and _canon(entry[part]) != _canon(up[part]): out[part] = entry[part] - if work := mw.prune_work(entry.get(mw.WORK), base.get(mw.WORK)): # 846-1 시간당 작업량 + work = prune_work_layer(entry.get(mw.WORK), base.get(mw.WORK), (upper or {}).get(mw.WORK)) + if work: # 846-1 시간당 작업량 out[mw.WORK] = work return out or None +# ── 층(848-1) ───────────────────────────────────────────────────────── +def _fixed(w: dict) -> dict: + return {k: str(w[k]) for k in mw.FIXED if w.get(k)} + + +def prune_work_layer(want, base: dict | None = None, upper: dict | None = None) -> dict | None: + """작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · + `base` = 그 식 기본 변수(`mw.defaults`) · 일당 = 방식만 · 남는 것 없음 = None(위 층 없음 = `mw.prune_work` 와 같음).""" + if not isinstance(want, dict): + return None + up = upper if isinstance(upper, dict) else {} + up_way = up.get("방식") or mw.DAILY + way = want.get("방식") or up_way + out: dict = {"방식": way} if way != up_way else {} + if way != mw.HOURLY: + return out or None + up_form = str(up.get("식") or "") if up_way == mw.HOURLY else "" + form = str(want.get("식") or "") or up_form + if form != up_form: + out["식"] = form + held = {**(base or {}), **((up.get("변수") or {}) if form == up_form else {})} + got = { + k: v + for k, v in (want.get("변수") or {}).items() + if v not in (None, "") and not (k in held and mw._same(v, held[k])) + } + if got: + out["변수"] = got + fix, up_fix = _fixed(want), (_fixed(up) if up_way == mw.HOURLY else {}) + if fix and ( + not up_fix + or [fix.get(k) for k in ("기계", "키")] != [up_fix.get(k) for k in ("기계", "키")] + ): + out |= fix + return out or None + + +def merge_work(top: dict | None, low: dict | None) -> dict | None: + """작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) · + 식을 바꾼 아래 층 = 위 층 변수 안 물려받음.""" + if not isinstance(top, dict) or not top: + return low if isinstance(low, dict) and low else None + if not isinstance(low, dict) or not low: + return top + out = dict(top) + if low.get("방식"): + out["방식"] = low["방식"] + if low.get("식") and str(low["식"]) != str(top.get("식") or ""): + out["식"] = low["식"] + out.pop("변수", None) + if vals := {**(out.get("변수") or {}), **(low.get("변수") or {})}: + out["변수"] = vals + if low.get("기계"): + out = {k: v for k, v in out.items() if k not in mw.FIXED} | _fixed(low) + return out + + +def merge_layers(upper: dict | None, mine: dict | None) -> dict: + """① 위 층 고침 위에 ② 내 고침(열쇠마다 `merge`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로.""" + if not isinstance(upper, dict) or not upper: + return mine if isinstance(mine, dict) else {} + if not isinstance(mine, dict) or not mine: + return upper + out = {} + for k in [*upper, *(k for k in mine if k not in upper)]: + if got := merge(upper.get(k), mine.get(k)): + out[k] = got + return out + + +def upper_of(base: dict, upper: dict | None) -> dict: + """위 층 값 — 정본 기본(`defaults_of`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `mw.defaults`).""" + out = {k: v for k, v in base.items() if k != mw.WORK} + if not upper: + return out + out["값"] = {**(base.get("값") or {}), **(upper.get("값") or {})} + for part in ("조종원", "잡품"): + if upper.get(part) is not None: + out[part] = upper[part] + if upper.get(mw.WORK): + out[mw.WORK] = upper[mw.WORK] + return out + + +def sources(upper: dict | None, mine: dict | None) -> dict[str, str]: + """칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · + `작업량.방식` · `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계`.""" + out: dict[str, str] = {} + up_form = str(((upper or {}).get(mw.WORK) or {}).get("식") or "") + for layer, tag in ((upper, ABOVE), (mine, MINE)): + e = layer if isinstance(layer, dict) else {} + for k in e.get("값") or {}: + out[f"값.{k}"] = tag + for part in ("조종원", "잡품"): + if e.get(part) is not None: + out[part] = tag + w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {} + if ( + tag == MINE and w.get("식") and str(w["식"]) != up_form + ): # 식을 바꿈 = 위 층 변수 안 물려받음 + out = {k: v for k, v in out.items() if not k.startswith("작업량.변수.")} + for k in ("방식", "식", "기계"): + if w.get(k): + out[f"작업량.{k}"] = tag + for k in w.get("변수") or {}: + out[f"작업량.변수.{k}"] = tag + return out + + # ── 셈 규칙 ─────────────────────────────────────────────────────────── def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str: have = {md.var_id(v) for v in doc.get("변수") or []} | { @@ -354,14 +472,17 @@ def row_entry(doc: dict, vals) -> dict | None: def merge(base: dict | None, top: dict | None) -> dict | None: - """바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만).""" + """바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) · + 작업량 = `merge_work`(848-1).""" if not base: return top or None if not top: return base - out = {**base, **{k: v for k, v in top.items() if k != "값"}} + out = {**base, **{k: v for k, v in top.items() if k not in ("값", mw.WORK)}} vals = {**(base.get("값") or {}), **(top.get("값") or {})} - return {**out, "값": vals} if vals else out + out = {**out, "값": vals} if vals else out + work = merge_work(base.get(mw.WORK), top.get(mw.WORK)) + return {**out, mw.WORK: work} if work else out def lists_of(links, given) -> dict: @@ -425,32 +546,66 @@ def clean(raw) -> dict: if part == "잡품" and not (r.get("줄") or r.get("키")): raise ValueError(f"{COVER} 「{key}」 잡품 줄 — 재료(키) 또는 줄 필요") one[part] = rows - if entry.get(mw.WORK) is not None: - one[mw.WORK] = mw.clean_work(entry[mw.WORK], f"{COVER} 「{key}」") + w = entry.get(mw.WORK) + if isinstance(w, dict) and not w.get("방식"): # 848-1 바꾼 칸만 담은 층(방식 = 위 층) + got = mw.clean_work({**w, "방식": mw.DAILY}, f"{COVER} 「{key}」") + got.pop("방식") + if got: + one[mw.WORK] = got + elif w is not None: + one[mw.WORK] = mw.clean_work(w, f"{COVER} 「{key}」") if one: out[str(key)] = one return out -def prune_doc(doc: dict, links) -> dict: - """서버 정리 — 덮음을 검사하고 원본과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로). - 원본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답).""" +def _quoted(text) -> set[str]: + return set(re.findall(r"'([^']*)'", str(text or ""))) + + +def listed(doc: dict) -> set[str]: + """문서 안 덮음 열쇠 후보(848-1) — 선택 목록 · 입력 값 · 따옴표 글(식 · 부름 입력 · 금액) · 변수 기호.""" + out: set[str] = set() + for v in doc.get("변수") or []: + out.add(md.var_id(v)) + link = v.get("연결") or {} + out |= {str(x) for x in link.get("목록") or []} + if isinstance(link.get("값"), str): + out.add(link["값"]) + for x in (link.get("입력") or {}).values(): + out |= _quoted(x) + for x in doc.get("식") or []: + out |= _quoted(x.get("식")) + for x in doc.get("금액") or []: + out |= _quoted(x.get("수량")) | _quoted(x.get("단가")) + return out + + +def prune_doc(doc: dict, links, upper: dict | None = None) -> dict: + """서버 정리 — 덮음을 검사하고 위 층과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로). + 정본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답 · 작업량 · 굳은 기계는 얹고 셈) · + `upper` = ① 위 층 고침(SK `수식.위덮음` · 848-1) · 이번 셈이 안 부른 열쇠 = 문서 안에 들면(`listed`) 그대로 남김.""" import master_doc_calc as mc cover = clean(doc.get(COVER)) rest = {k: v for k, v in doc.items() if k != COVER} if not cover: return rest + upper = upper if isinstance(upper, dict) else {} + both = merge_layers(upper, cover) + steer = {k: {mw.WORK: e[mw.WORK]} for k, e in both.items() if (e or {}).get(mw.WORK)} memo: dict = {} - top = mc.calc(rest, links, None, (), memo) - kept: dict = {} # 문서가 안 부르는 기계 덮음 = 뺌 + top = mc.calc(rest, links, None, (), memo, steer) + kept: dict = {} + seen: set[str] = set() # 값 · 조종원 · 잡품을 견준 열쇠 for (key, given), ans in memo.items(): m = machine_key(dict(given)) sub = links.doc(key) if m in cover and m not in kept else None if not sub or not is_machine(sub): continue + seen.add(m) base = defaults_of(sub, ans.get("값") or {}, row_entry(sub, lists_of(links, dict(given)))) - if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base): + if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base, upper.get(m)): kept[m] = one works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도 for a in (top, *memo.values()): @@ -460,11 +615,24 @@ def prune_doc(doc: dict, links) -> dict: if w.get("기호"): works.setdefault(w["기호"], w["기계"]) for m in sorted(set(works) & set(cover)): - want = cover[m].get(mw.WORK) - if want and ( - one := mw.prune_work(want, _work_base(links, want.get("기계") or works[m], want)) - ): + if not (want := cover[m].get(mw.WORK)): + continue + seen.add(f"{m}\n{mw.WORK}") + up = (upper.get(m) or {}).get(mw.WORK) or {} + eff = merge_work(up, want) or {} + if eff.get("방식") == mw.HOURLY and not eff.get("식"): + raise ValueError(f"{COVER} 「{m}」 작업량 — 시간당은 식 키 필요") + base = _work_base(links, eff.get("기계") or works[m], eff) + if one := prune_work_layer(want, base, up): kept[m] = {**kept.get(m, {}), mw.WORK: one} + names = listed(rest) | { + str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계") + } + for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로 + if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}): + kept[m] = {**vals, **kept.get(m, {})} + if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK): + kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]} return {**rest, COVER: kept} if kept else rest diff --git a/resources/tester/helper_848_1_cover_layers.cjs b/resources/tester/helper_848_1_cover_layers.cjs new file mode 100644 index 000000000..63f49b8e3 --- /dev/null +++ b/resources/tester/helper_848_1_cover_layers.cjs @@ -0,0 +1,36 @@ +/* 848-1 겹쳐 덮는 층 거울 헬퍼 — common_util_formula_doc_cover.ts 를 그 자리에서 트랜스파일해 Node 로 돌림. + * stdin = {경우: [{위, 나, 기본}]} + * stdout = {답: [{합침: mergeCover, 층: mergeLayers, 정리: prune, 위값: upperOf, 출처: sourcesOf}]} */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); + +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(at, box.exports); + const need = (p) => + p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p); + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const cover = load(path.join(__dirname, "..", "..", "common_util", "common_util_formula_doc_cover.ts")); + +const input = JSON.parse(fs.readFileSync(0, "utf8")); +const out = { 답: [] }; +for (const one of input.경우 || []) { + const up = one.위 ?? null; + const me = one.나 ?? null; + out.답.push({ + 합침: cover.mergeCover(up, me), + 층: cover.mergeLayers(up ? { K: up } : null, me ? { K: me } : null), + 정리: me ? cover.prune(me, one.기본, up) : null, + 위값: cover.upperOf(one.기본, up), + 출처: cover.sourcesOf(up, me), + }); +} +process.stdout.write(JSON.stringify(out)); diff --git a/resources/tester/test_848_1_cover_layers.py b/resources/tester/test_848_1_cover_layers.py new file mode 100644 index 000000000..6d900a91f --- /dev/null +++ b/resources/tester/test_848_1_cover_layers.py @@ -0,0 +1,362 @@ +# 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") +cv = importlib.import_module("master_doc_convert") +build = importlib.import_module("build_수식문서_802_2") + +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 _mini(): + """빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}.""" + files, whole = m01.loaded() + name = next( + n + for n, d in files.items() + if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or []) + ) + rows = files[name]["줄"] + keys = [str(r["키"]) for r in rows] + result = { + "문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows}, + "파일": {name: keys}, + "저장": set(keys) & build.saved_keys(), + "저장본": build.carried(), + } + return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name) + + +def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp): + d = _defaults() + result, text, file = _mini() + orig = file.read_bytes() + assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본 + 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" + # ㉥ 빌더 — 덮음 얹음(글 = 저장본) + result, text, _ = _mini() + assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [] + + # ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음 + def qty(text_): + return lambda doc: doc["금액"][0].update({"수량": text_}) + + first = m01doc.read(BASE)["문서"]["금액"][0]["수량"] + _save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공")) + assert ml.load_all()[BASE].get(mcv.HAND) is True + result, text, _ = _mini() + assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE] + _save_m01(want, qty(first)) + assert mcv.HAND not in ml.load_all()[BASE] + # ㉣ 정본 값으로 되돌림 = 고침 0 · 바이트 = 고침 전 + back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]}, + SYM: {"작업량": {"방식": "일당"}}} # fmt: skip + got = _save_m01(back) + assert COVER not in got["문서"] and file.read_bytes() == orig + assert got["셈"]["계"] == before + + +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) + frozen = rows["참조사본"][refs.ref_id(ref)]["수식"] + assert _norm(frozen[mcv.UPPER]) == _norm(upper) + was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) + 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, {}, {})["반영합"]["계"]) == 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 안 기계 줄까지