diff --git a/M02_MasterTemplete/M02_Copy_Slim.py b/M02_MasterTemplete/M02_Copy_Slim.py index 1aa3dde11..2297a5826 100644 --- a/M02_MasterTemplete/M02_Copy_Slim.py +++ b/M02_MasterTemplete/M02_Copy_Slim.py @@ -7,6 +7,7 @@ 이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈). 파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음). 읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦. +층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌. """ from __future__ import annotations @@ -104,4 +105,26 @@ def saved(kind: str, make: Callable[[], Any]) -> Any: _record(kind, out) finally: skc.READS.reset(token) - return cut_doc(out, reads) + return trim(kind, cut_doc(out, reads)) + + +#: 단가산출 옛 칸 · 서버 칸 — 빈 값이면 층 파일에 안 씀(855 2-D · 셈 · 화면이 안 읽음 · 읽을 때 `sd.clean` 이 +#: 빈 값으로 채움) · `더한줄` = 서고 뼈대 표지(`layers.check_skeleton`)라 빈 목록도 씀 · +#: 값 든 옛 칸 = 그대로(못 셈 + 까닭 · 2-C1) +EMPTY_GONE = ( + "입력값", "열린입력", "고름", "자재표시", "켜쌓기율", "덮개", "뺀줄", "뺀더한줄", + "상수덮개", "표값덮개", "글줄", "까닭", "수식고침", "변수줄", "식덮개", +) # fmt: skip + + +def trim(kind: str, doc: Any) -> Any: + """층 저장 꼴 = 남는 칸만(855 2-D) — 값 사본 = `수식` 값 몫 한 벌(`사본` 은 셈 중 칸 · 파일엔 안 씀) · + 단가산출 빈 옛 칸 · `M01판`(읽는 곳 없음) 뺌 · 프로젝트 층은 이 길을 안 탐(`saved`).""" + if kind != "sangeun" or not isinstance(doc, dict): + return doc + out = {k: v for k, v in doc.items() if not (k in EMPTY_GONE and v in (None, {}, [], ""))} + out.pop("M01판", None) + form = out.get(dc.KEY) + if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list): + out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))} + return out diff --git a/M02_MasterTemplete/M02_Sangeun_Const.py b/M02_MasterTemplete/M02_Sangeun_Const.py index c9f02132e..b52f7c8db 100644 --- a/M02_MasterTemplete/M02_Sangeun_Const.py +++ b/M02_MasterTemplete/M02_Sangeun_Const.py @@ -8,8 +8,7 @@ 표값덮개 {자리: {n: 값}} 자리 식의 n 번째 표 찾기 값(`찾기(…).칸`) → 값 · 그 줄만 표 연결 끊김 글줄 [{자리, 글}] 셈 없는 글 줄(근거 · ※ 조건) · 자리 뒤에 찍힘("" = 맨 위) 까닭 {열쇠: 글} 덮개 · 더한줄 · 뺀줄 · 새 덮개마다(예정가격작성기준 제2조 ②) - M01판 {자리: 지문} 저장 때 서버가 바탕 줄마다 적음(`stamp` · `sd.clean` 은 버림 = - 바탕판처럼) · 셈 때 받은 값과 지금 바탕이 다르면 「M01바뀜」 + M01판 {자리: 지문} (옛 칸 — 읽던 시트를 2-C1 에서 걷어 855 2-D 부터 안 적음 · 옛 파일 칸은 `sd.clean` 이 버림) 자리 = 바탕 줄 cid(호표 · 덧줄 `kind:키#n`) · 중간 줄 `mid:이름` · 열쇠 = 자리 · `add:#k` · `add:#k/세부 cid` · 식 칸 = 중간 「식」 · 호표 「수량」 · 덧줄 「식」. 셈 = `M02_Sangeun_Doc.patched` 첫머리 `formulas`(바탕 줄 식을 바꾼 사본) → 모든 셈 길(화면 · 저장 @@ -21,8 +20,6 @@ from __future__ import annotations import functools -import hashlib -import json import re from typing import Any @@ -220,14 +217,9 @@ def clean_more(raw: Any, out: dict) -> dict: return imp.clean(raw, fx.clean(raw, out)) # 식 칸(792-1) · 가져온 식(793-2) -def _print(one: Any) -> str: - raw = json.dumps(one, ensure_ascii=False, sort_keys=True, default=str) - return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:12] - - def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: - """저장 때 서버 칸 — 바탕판(옛 칸 그대로) + M01판(자리마다 지문) · `doc` = 식 칸(792-1)을 - 엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`).""" + """저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · `doc` = 식 칸(792-1)을 + 엔진 식으로 바꿔 넣음(제자리 · 틀린 식 = `DocError`) · 옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc if doc is not None and fx.has(doc): @@ -236,9 +228,7 @@ def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: if doc is not None and imp.is_imported(doc): # 가져온 식 검산(793-2) = 서버가 다시 doc[imp.KEY]["검산"] = imp.check(doc) - lines = [*(row.get("중간") or []), *(row.get("호표") or []), *(row.get("덧줄") or [])] - spots = [f"mid:{s.get('이름')}" for s in row.get("중간") or []] + sd.line_ids(row) - return {"바탕판": calc.fingerprint(row), "M01판": dict(zip(spots, map(_print, lines)))} + return {"바탕판": calc.fingerprint(row)} # ── 고치기 ────────────────────────────────────── diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index b13faf544..1e7569c5c 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -1,6 +1,7 @@ """M02 단가산출(SK) 로직 사본(PLAN 795-1 · 요구 655 · 656 · 요구서_655 0 · 1 장) — 서버 단독. -사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 문서 칸 `사본`: +사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` · +층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로): {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?} 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등) 단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음. @@ -66,12 +67,36 @@ def has(doc: Any) -> bool: return isinstance(copy, dict) and isinstance(copy.get("로직"), list) +FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D) +VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가") + + +def held(doc: Any) -> dict | None: + """문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D · + 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None.""" + if has(doc): + return doc[KEY] + form = doc.get(FORM) if isinstance(doc, dict) else None + if isinstance(form, dict) and isinstance(form.get("로직"), list): + return {k: form[k] for k in VALUES if k in form} + return None + + # ── 셈 색인 ────────────────────────────────────────────────────────── class Copy: """M01 색인 위 사본 줄 — `get` · `logic` · `value` · `label` = 엔진 `Master` 한 벌 (사본 줄 먼저) · 그 밖 칸(자재 색인 · 찾기 답)은 속 M01 것을 읽음.""" - label, value, logic = _MASTER.label, _MASTER.value, _MASTER.logic + label, value = _MASTER.label, _MASTER.value + + def logic(self, key: str) -> dict: + """사본 줄 › M01 색인 · 둘 다 없으면 속 색인이 따로 내주는 줄(굳힌 사본 `_Over` 등 · 855 2-D).""" + try: + return _MASTER.logic(self, key) + except prices.mf.FormulaError: + if getattr(type(self._whole), "logic", None) is _MASTER.logic: + raise # 속 = 맨 M01 색인 — 없는 키 그대로 + return self._whole.logic(key) def __init__(self, whole: Any, rows: list[dict], tag: Any = None) -> None: self._whole, self._tag, self.twice = whole, tag, whole.twice @@ -134,10 +159,11 @@ def _auto(doc: Any, copy: dict) -> dict: def over(doc: Any, whole: Any) -> Any: - """사본 있는 문서 = 사본 색인 · 없으면 `whole` 그대로(옛 길).""" - if not has(doc): + """값 사본(`held`) 있는 문서 = 사본 색인 · 없으면 `whole` 그대로.""" + copy = held(doc) + if copy is None: return whole - copy = _auto(doc, doc[KEY]) + copy = _auto(doc, copy) tag = (copy.get("판"), copy.get("단가판")) if isinstance(whole, Copy) and whole._tag == tag: return whole @@ -279,8 +305,7 @@ def stored_doc(key: Any) -> dict | None: def _stored(key: Any) -> dict | None: - got = stored_doc(key) - return got[KEY] if has(got) else None + return held(stored_doc(key)) def settle(doc: Any, save: bool = False) -> Any: @@ -291,7 +316,7 @@ def settle(doc: Any, save: bool = False) -> Any: out = {k: v for k, v in doc.items() if k not in (KEY, JOB)} if "참조" in (doc.get("바탕") or {}): return out - copy = _stored(doc.get("키")) or taken(doc.get(KEY)) + copy = _stored(doc.get("키")) or taken(held(doc)) if job == REGEN or (copy is None and save): copy = stamp(out) elif job == PRICE and copy: @@ -354,9 +379,9 @@ def mark(ans: dict, doc: dict) -> dict: def same_part(doc: Any) -> str | None: """같은 내용 지문 몫 — 지금 M01 과 같은 사본 = None(새로 찍을 문서와 같음) · 다르면 판.""" - if not has(doc): + copy = held(doc) + if copy is None: return None - copy = doc[KEY] seen = state(copy, whole_()) fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"]) return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}" @@ -390,7 +415,7 @@ def preview(doc: Any, job: str, given: dict | None = None) -> dict[str, Any]: ]: out["끊은기초"] = cut # 줄은 그대로 · 자원 단가만(요구 656-1) if job == PRICE: - copy = _stored(doc.get("키")) or taken(doc.get(KEY)) + copy = _stored(doc.get("키")) or taken(held(doc)) out["바뀐자원"] = refresh(copy, whole_())[1] if copy else [] else: was = _lost(before) diff --git a/resources/tester/fixtures/m02_858_shelf_golden.json b/resources/tester/fixtures/m02_858_shelf_golden.json index a680c7260..4c4f06cd4 100644 --- a/resources/tester/fixtures/m02_858_shelf_golden.json +++ b/resources/tester/fixtures/m02_858_shelf_golden.json @@ -20,7 +20,7 @@ "sangeun.복사": "40edbd4d0644186f", "sangeun.붙여넣기": "57cfb7bb522a80d3", "sangeun.쓰는곳": "2c9ec1824709481f", - "sangeun.읽기": "2b7850af819535c2", + "sangeun.읽기": "19662ccd4c5ae0c0", "sangeun.중복": "2c9378c6e9c61251", "sangeun.지우기": "db8b1e8ad9bef9eb", "sangeun.합치기": "b8f7720e8a1e1bbb", diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 879d1cd2e..c6ed834dc 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -91,7 +91,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): """① · ④ 저장 때 사본(로직 · 단가 갈래) · M01 로직 바꿔도 금액 그대로 · 배지만.""" me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) - got = _doc(me, key)["사본"] + got = skc.held(_doc(me, key)) assert PCT in {r["키"] for r in got["로직"]} assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"]) assert not any(r["키"][:2] in skc.RES for r in got["로직"]) @@ -111,7 +111,7 @@ def test_price_refresh_only_on_press(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) - lb = next(r["키"] for r in _doc(me, key)["사본"]["단가"] if r["키"].startswith("LB")) + lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB")) row = copy.deepcopy(_live().get(lb)) row["값"] = row["값"] * 2 _fake(monkeypatch, [row]) @@ -126,7 +126,7 @@ def test_price_refresh_only_on_press(world, monkeypatch): _save(me, key, got["문서"]) # [저장] = 서버가 할일 적용 saved = _doc(me, key) assert skc.JOB not in saved and _sum(me, key) == fresh - assert saved["사본"]["단가시점"] >= saved["사본"]["시점"] + assert skc.held(saved)["단가시점"] >= skc.held(saved)["시점"] def test_deleted_keys_keep_last_value(world, monkeypatch): @@ -134,7 +134,7 @@ def test_deleted_keys_keep_last_value(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) - lb = next(r["키"] for r in _doc(me, key)["사본"]["단가"] if r["키"].startswith("LB")) + lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB")) _fake(monkeypatch, drop=[PCT, lb]) with pytest.raises(Exception): m01.loaded()[1].logic(PCT) @@ -186,7 +186,7 @@ def test_imported_same_rule(world, monkeypatch): with store.at(me): key = imp.create(_imported_row(), None, "sub2임시 가져온")["이름"] doc = _doc(me, key) - assert MAN in {r["키"] for r in doc["사본"]["단가"]} + assert MAN in {r["키"] for r in skc.held(doc)["단가"]} with store.at(me): ours = imp.to_price(doc, "우리")["문서"] _save(me, key, ours) diff --git a/resources/tester/test_821_1_my_machine.py b/resources/tester/test_821_1_my_machine.py index 813cd3f77..5e24d133c 100644 --- a/resources/tester/test_821_1_my_machine.py +++ b/resources/tester/test_821_1_my_machine.py @@ -137,7 +137,7 @@ def test_sk_copy_edit_refresh_delete(world): made = _at(me, mym.create, _easy()) key, no = made["줄"]["키"], made["줄"]["원문번호"] sk = _sk(me, no) - copy = _doc(me, sk)["사본"] + copy = skc.held(_doc(me, sk)) assert key in {r["키"] for r in copy["단가"]} was = _sum(me, sk) assert float(was) == made["시간당"]["계"] @@ -174,7 +174,7 @@ def test_m01_only_sk_same(world): plain = _at(other, lambda: refs.create("sangeun", base)["이름"]) _at(me, mym.create, _easy()) mine = _at(me, lambda: refs.create("sangeun", base)["이름"]) - a, b = _doc(other, plain)["사본"], _doc(me, mine)["사본"] + a, b = skc.held(_doc(other, plain)), skc.held(_doc(me, mine)) assert json.dumps(a["단가"], sort_keys=True) == json.dumps(b["단가"], sort_keys=True) assert a["판"] == b["판"] and _sum(other, plain) == _sum(me, mine) diff --git a/resources/tester/test_821_4_import_my_machine.py b/resources/tester/test_821_4_import_my_machine.py index 947923914..07ebd3a7f 100644 --- a/resources/tester/test_821_4_import_my_machine.py +++ b/resources/tester/test_821_4_import_my_machine.py @@ -168,7 +168,7 @@ def test_make_flow(world) -> None: ours = imp.to_price(doc, "우리") # [우리 단가로] = 내 기계 값 assert ours["후"]["계"] is not None and ours["후"] != ours["전"] assert not [u for u in ours["이음없음"] if "파워트로웰" in u["이름"]] - assert one["키"] in {r["키"] for r in (doc.get(skc.KEY) or {}).get("단가") or []} # 사본 + assert one["키"] in {r["키"] for r in (skc.held(doc) or {}).get("단가") or []} # 사본 conv = dim.derive(doc, None, imp._whole()) assert f"내 기계 {one['키']}" in json.dumps( conv["변수"], ensure_ascii=False, default=str diff --git a/resources/tester/test_826_3_copy_slim.py b/resources/tester/test_826_3_copy_slim.py index 3a67e8939..36e7f1c5b 100644 --- a/resources/tester/test_826_3_copy_slim.py +++ b/resources/tester/test_826_3_copy_slim.py @@ -70,7 +70,7 @@ def test_base_logic_read_rows_only(world): me = world["personal"] key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") doc = _file(me, key) - have = doc[skc.KEY] + have = skc.held(doc) assert _closed(doc) >= 3 * len(_keys(have)) assert len(_keys(have)) <= 12 and len(have["단가"]) < 10 assert _keys(have) == _keys(doc["수식"]) # 두 자리 같은 줄(꼴 그대로) @@ -89,7 +89,7 @@ def test_m01_change_kept_then_price(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") was = _sum(me, key) - read = set(_keys(_file(me, key)[skc.KEY])) + read = set(_keys(skc.held(_file(me, key)))) moved = [k for k in read if k[:2] in ("EQ", "LB", "MO")] assert moved _move(monkeypatch, *moved) @@ -97,7 +97,7 @@ def test_m01_change_kept_then_price(world, monkeypatch): assert _at(me, path.read, key)["사본"]["단가새값"] is True got = _price(me, key) assert set(got["바뀐"]) == set(moved) and got["후"] > was - assert set(_keys(_file(me, key)[skc.KEY])) == read + assert set(_keys(skc.held(_file(me, key)))) == read def test_machine_swap_preview_then_save(world, monkeypatch): @@ -146,11 +146,11 @@ def test_regen_slim(world, monkeypatch): """[재생성] — 지금 M01 로 다시 찍어도 읽은 줄만 · 그 뒤 M01 바뀌어도 그대로.""" me = world["personal"] key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") - read = [k for k in _keys(_file(me, key)[skc.KEY]) if k[:2] in ("EQ", "MO")] + read = [k for k in _keys(skc.held(_file(me, key))) if k[:2] in ("EQ", "MO")] _move(monkeypatch, *read) 판 = _at(me, path.read, key)["판"] _at(me, path.save, key, {"할일": skc.REGEN, "판": 판}) - after = _file(me, key)[skc.KEY] + after = skc.held(_file(me, key)) assert len(_keys(after)) <= 12 was = _sum(me, key) _move(monkeypatch, *read) @@ -162,13 +162,13 @@ def test_layer_copy_slim(world, monkeypatch): me, co = world["personal"], world["company"] key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") was = _sum(me, key) - _move(monkeypatch, DIG, *[k for k in _keys(_file(me, key)[skc.KEY]) if k[:2] == "EQ"]) + _move(monkeypatch, DIG, *[k for k in _keys(skc.held(_file(me, key))) if k[:2] == "EQ"]) ref = {"층": "personal", "주인": "7/42", "키": key} with store.at(co): doc = refs.read_ref(ref) new = refs.create("sangeun", refs.carry(refs.origin_mark(doc, ref), ("personal", "7/42"))) assert _sum(co, new["이름"]) == was - assert _keys(_file(co, new["이름"])[skc.KEY]) == _keys(_file(me, key)[skc.KEY]) + assert _keys(skc.held(_file(co, new["이름"]))) == _keys(skc.held(_file(me, key))) def test_labor_and_combo_slim(world, monkeypatch): @@ -206,7 +206,7 @@ def test_old_big_copy_reads_then_slims(world): with store.at(me): got = store.read("sangeun", key) store.write("sangeun", key, got["판"], got["문서"]) - assert len(_keys(_file(me, key)[skc.KEY])) * 3 <= len(big["로직"]) + len(big["단가"]) + assert len(_keys(skc.held(_file(me, key)))) * 3 <= len(big["로직"]) + len(big["단가"]) assert _sum(me, key) == was @@ -253,6 +253,6 @@ def test_doc_path_save_keeps_both_slots(world): assert look["사본"]["사본없음"] > 0 _at(me, path.save, key, {"문서": doc, "판": got["판"]}) after = _file(me, key) - assert set(_keys(after[skc.KEY])) == set(_keys(after["수식"])) - assert len(_keys(after[skc.KEY])) >= 6 + assert skc.KEY not in after # 층 파일 값 사본 = `수식` 한 벌(855 2-D) + assert len(_keys(skc.held(after))) >= 6 assert _sum(me, key) == look["셈"]["계"] != got["셈"]["계"]