feat(848-1): 겹쳐 덮는 층 — SK 수식.위덮음 · 칸 단위 합침 · 위 층 대조 지움 · M01 기초 덮음 저장 · 빌더 이어받기

- 층 셈(파이썬 · TS 짝 master_doc_cover ↔ common_util_formula_doc_cover): merge 에 작업량 칸 단위(merge_work) · merge_layers · layeredCover · upper_of · sources · prune(…, upper) · prune_work_layer
- prune_doc(…, upper): 작업량 · 굳은 기계를 얹고 정본 셈 · 문서 안(선택 목록 · 따옴표 글 · 변수 기호)에 든 열쇠 고침은 안 불려도 남김
- SK: 셈 cover = ① 위덮음 + ② 문서 기계덮음(사본 셈 · 빈틈 · 연결 기록) · 프로젝트 층 밖 = 지금 기초 것 · 저장 때 굳음 · 굳히기 = 그때 기초 것 · derive 는 기초 덮음을 떼고 복사 · 읽기 답에 위덮음
- M01 저장: 기계덮음 검사 · 정본과 같은 칸 지움 · 빌더 결과와 셈 칸이 다르면 손고침 표지
- 빌더: 저장본 기계덮음 이어받음 · 손고침 문서 저장본 그대로 + 목록
- 시험 test_848_1_cover_layers(거울 36 경우 · M01 · SK · 굳힘 · A→B)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:19:31 +09:00
co-authored by Claude Opus 5.5
parent f7df6e3ca1
commit c33d200a68
12 changed files with 906 additions and 52 deletions
@@ -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:
+189 -21
View File
@@ -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