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:
@@ -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
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user