refactor(855-2-D): 단가산출 층 저장 꼴 = 남는 칸만 — 값 사본 = 수식 한 벌(사본 안 씀) · 빈 옛 칸 · M01판 안 씀

- 저장 관문 `Copy_Slim.trim`(층 저장만 · 프로젝트 층은 안 탐) — `사본` 값을 `수식` 값 몫에 얹고 `사본` 뺌 · 빈 옛 칸(입력값 · 열린입력 · 고름 · 자재표시 · 켜쌓기율 · 덮개 · 뺀줄 · 뺀더한줄 · 상수덮개 · 표값덮개 · 글줄 · 까닭 · 수식고침 · 변수줄 · 식덮개) 뺌 · 값 든 옛 칸 = 그대로(못 셈 + 까닭) · `더한줄` = 서고 뼈대 표지라 남김
- `Sangeun_Copy.held` = 값 사본 한 곳(셈 중 `사본` › 층 파일 `수식` 값 몫) — `over` · `settle`(저장본 · 받은 문서) · `same_part` 가 씀 · `Copy.logic` = 사본 줄 › M01 › 속 색인이 따로 내주는 줄(굳힌 사본 `_Over`)
- `Sangeun_Const.stamp` = `바탕판` 만(화면 「기초가 바뀜」 이 읽음) · `M01판`(읽던 시트 2-C1 에서 걷음) 안 적음
- 층 서고 SK 14 + SC 6 다시 저장(임시 복사본 · `resave.py`): 셈 답 같음 20 / 20 · SK 칸 18 → 12(가져온 식 12 · 그 밖 11) · 크기 408 → 309 KB
- 시험: 파일 `사본` 을 읽던 줄 = `skc.held`(795_1 · 821_1 · 821_4 · 826_3 — 826_3 「두 칸 같음」 → `사본` 없음 + 수식 값 몫) · m02_858_shelf_golden 다시 뜸(SK 읽기 답 = 파일 칸 바뀜)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 02:46:38 +09:00
co-authored by Claude Opus 5.5
parent 149a4529ad
commit bfe29acf60
8 changed files with 83 additions and 45 deletions
+24 -1
View File
@@ -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
+4 -14
View File
@@ -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)}
# ── 고치기 ──────────────────────────────────────
+36 -11
View File
@@ -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)
@@ -20,7 +20,7 @@
"sangeun.복사": "40edbd4d0644186f",
"sangeun.붙여넣기": "57cfb7bb522a80d3",
"sangeun.쓰는곳": "2c9ec1824709481f",
"sangeun.읽기": "2b7850af819535c2",
"sangeun.읽기": "19662ccd4c5ae0c0",
"sangeun.중복": "2c9378c6e9c61251",
"sangeun.지우기": "db8b1e8ad9bef9eb",
"sangeun.합치기": "b8f7720e8a1e1bbb",
+5 -5
View File
@@ -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)
+2 -2
View File
@@ -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)
@@ -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
+10 -10
View File
@@ -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["셈"]["계"]