Files
Aislo/M02_MasterTemplete/M02_Sk_AutoRenew.py
T
eomsangdonandClaude Opus 5.5 d9326ddd38 feat(848-2): 갱신 칸 단위 — 위가 바뀐 칸의 내 고침 지킴 + 알림 · 계산 내용이 바뀐 문서만 다시 복사
- 기계 고침(②) 판정 = 줄 통째 지문 → 칸별(값 칸 · 인력 · 잡품 목록 · 작업량 방식 · 식 · 변수) 위 값(① 위덮음 › ⓪ 기계 줄) 바탕 대 지금
- 위가 바뀐 칸에 ② 있음 = ② 지킴 + 알림(처리 지킴 · 문서 · 열쇠 · 경로 · 칸 · 층 · 전 · 후 · 내값) · ② 없는 칸 = 조용히 따라옴 · 기계 줄 글(이름 · 출처 · 비고) = 판정 밖
- 바탕 = 수식.덮음바탕(지킨 칸만 · 알림 [확인] = confirm 때 걷음) › 저장 사본 기계 줄 · 저장 위덮음 · 고르지 않은 기계 = 바탕 모름(알림 없음 · ② 그대로)
- 문서 지문 = dc.doc_fp(셈 칸만 · 기계덮음 · 위덮음 · 손고침 · 글 칸 뺌) — 기초 고침(①) · 글만 바뀜 = 따로 문서 · 끊음 그대로
- 다시 복사 = 옵션 값(선택 · 입력 열쇠) · ② 다시 얹음(수식.맡긴값 · carry) · 못 얹은 것만 알림(처리 다시복사 · 지워짐 · 다시얹음)
- 옛 꼴 이행 예외 _same_new 걷음(칸 대조가 from_old_row 로 새 꼴로 견줌) · 재생성 = 맡긴 칸도 버림
- 시험: test_836_2 「기계 줄 바뀌면 덮음 지움」 기대 → 새 규칙(지킴 + 알림)으로 고침(요구서_889 3 절이 규칙을 바꿈) · test_848_2 새로(㉠ ~ ㉧ · Doc_Sk 세 줄 붙인 뒤 셋 = xfail strict)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 20:25:51 +09:00

398 lines
19 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""M02 단가산출(SK) M01 자동 따라옴(PLAN 836-2 · 848-2 · 요구 854 · 요구서_889 3 절) — 서버 단독.
프로젝트 층 밖 SK(마스터 · 회사 · 개인) = 셈 · 열기 · 목록 · 일위대가 펼침이 모두
사본 줄 = 지금 M01(+ 층 내 기계) 줄(`rows` · 지운 키 = 사본 마지막 줄) ·
부름 문서 = 지금 M01 수식 문서(`form`)로 봄 — 묻지 않음 · [단가 갱신] · [재생성] 없음.
파일(작업본)은 [저장] · 알림 [확인](= 저장 · `confirm`) 때만 새 것으로 씀 — 읽기 길은 안 씀.
판정 = 칸 단위(848-2):
기계 고침(② `문서.기계덮음`) — 칸마다 「위 값」(① `위덮음` 그 칸 › ⓪ 기계 줄 그 칸)
바탕 대 지금 · 위가 바뀐 칸에 ② 가 있으면 ② 지킴 + 알림(처리 「지킴」) ·
② 없는 칸 = 조용히 따라옴(셈이 지금 줄 · 지금 ① 을 읽음) · 기계 줄 글 = 칸 아님.
바탕 = `덮음바탕`(지킨 칸만 · 알림 [확인] 까지) › 저장 사본 기계 줄 · 저장 `위덮음` ·
둘 다 없음(고르지 않아 사본 줄 없는 기계) = 바탕 모름 → 알림 없음 · ② 그대로
(다음 저장 때 지금 값이 바탕).
문서(따로 문서 · 끊음) — 계산 내용(`dc.doc_fp`)이 바뀐 것만 다시 복사 · 고쳐 둔 문서 =
옵션 값(선택 · 입력 열쇠) · ② 다시 얹고 못 얹은 것만 알림(처리 「다시복사」 · 「지워짐」).
알림 한 줄 `갱신` = {키, 이름, 갈래(기계 · 문서 · 부름), 처리(지킴 · 다시복사 · 지워짐),
M01 [전 → 후 글], 내고침 [글]} + 지킴 = {문서, 열쇠, 경로, 칸, 층(기계 · 기초), 전, 후, 내값} ·
다시복사 · 지워짐 = {다시얹음 [글]}.
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 그대로) · 기계 고침 판정 같음(① = 저장 `위덮음`).
프로젝트 층 · B09 사본 = 그대로(사용자가 고르는 [단가 갱신] · [재생성]).
"""
from __future__ import annotations
import copy as cp
import json
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Imported as imp
import master_doc_cover as mcv # noqa: E402 — 기계 덮음(836-1 · scripts 길 = dc)
mw, mcrew = mcv.mw, mcv.mcrew # 작업량 · 인력 잡품 목록(같은 scripts 길)
COVER = mcv.COVER # 문서 칸 기계덮음(② · 836-1) — 따로 문서를 다시 복사할 때 `수식` 머리에 맡겨 둠
UPPER = getattr(mcv, "UPPER", "위덮음") # `수식` 칸 — ① 위 층 고침(848-1)
FIRST = "처음" # `수식` 칸 — 따로가 된 때의 문서(고침 판정 원본)
OPTS = (
"맡긴값" # `수식` 칸 — 다시 복사한 따로 문서의 옵션 값 {변수 열쇠: 값}(파생 문서에 다시 얹음)
)
BASE = "덮음바탕" # `수식` 칸 — 지킨 ② 칸의 바탕 {열쇠: {경로: 위 값}} · 알림 [확인] 때 걷음
KEEP = (COVER, OPTS, BASE) # 파생 저장 때 `수식` 에 이어 실을 칸(`M02_Doc_Sk.settle`)
CONFIRM = "갱신확인" # 알림 [확인] 저장 할일
PICK = ("선택", "입력") # 옵션 변수 갈래
MAX_LINES = 8
_MEMO: dict[tuple, dict] = {}
_LIVE: list[Any] = [None]
_NO = object() # 바탕 모름
def on() -> bool:
"""자동 따라옴 — 프로젝트 층 밖."""
from M02_MasterTemplete import M02_Labor_Ref as refs
return refs.here()[0] != "project"
def is_sk(doc: Any) -> bool:
return isinstance(doc, dict) and doc.get("종류") == sd.TITLE
# ── 값 줄 ──────────────────────────────────────────────────────────────
def _fresh(row: dict, live: Any) -> dict:
key = str(row.get("키"))
got = live.index.get(key[:2], {}).get(key)
if got is None:
return row # M01 에서 지운 키 = 마지막 값
new = prices.to_json(got)
return row if skc._fp(new) == skc._fp(row) else new
def rows(copy: Any) -> Any:
"""값 사본(`skc` 꼴) → 줄마다 지금 M01(+ 층 내 기계) · 바뀐 몫만 판 다시 ·
프로젝트 층 = 그대로."""
if not (isinstance(copy, dict) and isinstance(copy.get("로직"), list)) or not on():
return copy
live = skc.whole_()
if live is not _LIVE[0]:
_MEMO.clear()
_LIVE[0] = live
tag = (copy.get("판"), copy.get("단가판"), len(copy["로직"]), len(copy.get("단가") or []))
hit = _MEMO.get(tag)
if hit is not None:
return {**copy, **hit}
got: dict = {}
for part, mark in (("로직", "판"), ("단가", "단가판")):
old = copy.get(part) or []
new = [_fresh(r, live) if isinstance(r, dict) else r for r in old]
if any(a is not b for a, b in zip(old, new)):
got |= {part: new, mark: skc._fp(new)}
if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로
_MEMO.clear()
_MEMO[tag] = got
return {**copy, **got}
# ── 수식 사본(부름 · 끊음 · 따로 문서) ──────────────────────────────────
def _say(v: dict) -> str:
link = v.get("연결") or {}
for slot in ("값", "식", "키"):
if link.get(slot) not in (None, ""):
return str(link[slot])
return json.dumps(link, ensure_ascii=False, default=str)[:60]
def _name(v: dict) -> str:
return str(v.get("이름") or f"{v.get('기호') or ''}{v.get('아래') or ''}")
def diff(a: Any, b: Any) -> list[str]:
"""두 문서의 셈 칸 다른 곳 — 「이름 전 → 후」(변수 · 금액 줄) · 많으면 앞 몇 줄."""
a, b = (x if isinstance(x, dict) else {} for x in (a, b))
out: list[str] = []
va = {dc.md.var_id(v): v for v in a.get("변수") or []}
vb = {dc.md.var_id(v): v for v in b.get("변수") or []}
for vid in [*va, *(k for k in vb if k not in va)]:
x, y = va.get(vid), vb.get(vid)
if x and y and _say(x) == _say(y):
continue
name = _name(y or x)
out.append(f"{name} {_say(x) if x else '—'} → {_say(y) if y else '—'}")
la, lb = a.get("금액") or [], b.get("금액") or []
for n in range(max(len(la), len(lb))):
x, y = (la[n] if n < len(la) else None), (lb[n] if n < len(lb) else None)
if dc.fp(x) == dc.fp(y):
continue
name = str((y or x or {}).get("이름") or f"금액 {n + 1}")
show = lambda z: " × ".join(str(z[k]) for k in ("수량", "단가") if z and z.get(k)) or "—" # noqa: E731
out.append(f"{name} {show(x)} → {show(y)}")
for slot in ("식", "끝수", "결과단위"):
if dc.fp(a.get(slot)) != dc.fp(b.get(slot)):
out.append(slot)
return out[:MAX_LINES] + ([f"… {len(out) - MAX_LINES}"] if len(out) > MAX_LINES else [])
def _opts(doc: Any) -> dict[str, Any]:
"""옵션 변수 {열쇠: 값}(선택 · 입력)."""
out = {}
for v in (doc or {}).get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") in PICK and v.get("열쇠"):
out[str(v["열쇠"])] = link.get("값")
return out
def put_opts(doc: dict, vals: dict) -> dict:
"""옵션 값을 얹은 새 문서(열쇠 · 갈래가 있는 변수만)."""
if not vals:
return doc
doc = cp.deepcopy(doc)
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") in PICK and str(v.get("열쇠")) in vals:
link["값"] = vals[str(v["열쇠"])]
return doc
def _replay(mine: dict, first: Any, live: Any) -> tuple[dict, list[str], list[str]]:
"""고친 문서(`mine` · 원본 `first`)를 새 문서(`live`)에 다시 얹기 —
(얹을 옵션 값, 다시 얹음 글, 못 얹은 고침 글). 옵션 값 = 열쇠가 새 문서에 살아 있으면 얹음."""
was, have, now = _opts(first), _opts(mine), _opts(live)
edits = {k: v for k, v in have.items() if k in was and mcv._canon(v) != mcv._canon(was[k])}
put = {k: v for k, v in edits.items() if k in now}
rest = put_opts(mine, {k: was[k] for k in edits}) # 옵션 고침 뺀 나머지 고침
lost = diff(first, rest) if dc.doc_fp(rest) != dc.doc_fp(first) else []
lost += [f"{k} {edits[k]}(새 문서에 없음)" for k in edits if k not in put]
return put, [f"{k} {v}" for k, v in put.items()], lost
def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any:
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
프로젝트 층 = 그대로 · `confirm` = 알림 [확인] 저장(바탕 걷음)."""
if not isinstance(got, dict) or not on() or not is_sk(sk):
return got
out = rows(got) if "로직" in got else dict(got)
out = _covers(sk, got, out, notes, confirm)
if imp.is_imported(sk):
return out # 가져온 식 = 값만(식 · 가져온 줄 그대로)
live = dc.folder()
calls = dict(out.get("부름") or {})
moved = {k for k, d in calls.items() if k in live and dc.fp(d) != dc.fp(live[k])}
if not moved and not out.get("따로"):
return out
for k in moved: # 글 · 덮음만 바뀜 = 조용히 따라옴(끊음 그대로)
calls[k] = cp.deepcopy(live[k])
redo = {k for k in moved if dc.doc_fp((got.get("부름") or {}).get(k)) != dc.doc_fp(live[k])}
cut = dict(out.get("끊음") or {})
for k in sorted(redo & set(cut)):
mine, was = cut.pop(k), (got.get("부름") or {}).get(k)
if dc.doc_fp(mine) == dc.doc_fp(was):
continue # 안 고친 끊음 = 조용히 따라옴
put, again, lost = _replay(mine, was, live[k])
if put:
cut[k] = put_opts(cp.deepcopy(live[k]), put)
if notes is not None:
notes.append(_note(k, was, live[k], lost, "부름", again=again))
out |= {"부름": calls, "끊음": cut}
base = out.get("원본") or {}
key = str(base.get("키") or "")
if out.get("따로") and key in live and not dc.same_origin(base, live[key]):
first = out.get(FIRST)
mine = out.get("문서") or {}
put: dict = {}
if first is None:
again, lost = [], ["수식 문서 고침(옛 저장본 — 원본 없음)"]
elif dc.doc_fp(mine) != dc.doc_fp(first):
put, again, lost = _replay(mine, first, live[key])
else:
again, lost = [], []
if (again or lost) and notes is not None:
notes.append(_note(key, first, live[key], lost, "문서", mine.get("이름"), again))
keep = {COVER: mine[COVER]} if mine.get(COVER) else {} # 기계 고침 = 다시 얹음(`carry`)
if put := {**(out.get(OPTS) or {}), **put}:
keep[OPTS] = put
out = {k: v for k, v in out.items() if k not in ("따로", "문서", FIRST, COVER, OPTS)} | keep
if moved and "문서" in out: # 새 문서가 부르는 키 = 닫힌 묶음
keys = [*dc.calls(out["문서"]), *(c for d in cut.values() for c in dc.calls(d))]
out["부름"] = dc.closure(dc.over(out), keys, calls)
return out
# ── 기계 고침(②) — 칸 단위 지킴 ─────────────────────────────────────────
def _eq_rows(copy: dict) -> dict[str, dict]:
"""사본의 기계 줄 {원문번호 · 키: 줄}."""
out: dict[str, dict] = {}
for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]:
if isinstance(r, dict) and str(r.get("키"))[:2] == "EQ":
out[str(r.get("키"))] = r
if r.get("원문번호"):
out[str(r["원문번호"])] = r
return out
def _live_row(text: str) -> dict | None:
whole = skc.whole_()
got = (whole.numbers.get("EQ") or {}).get(text) or (whole.index.get("EQ") or {}).get(text)
return prices.to_json(got) if got else None
def paths(entry: Any) -> dict[str, Any]:
"""덮음 한 열쇠 → {칸 경로: 값}(848-1 계약 경로 · 조종원 · 잡품 = 목록 통째 한 칸)."""
e = entry if isinstance(entry, dict) else {}
out = {f"값.{k}": v for k, v in (e.get("값") or {}).items()}
for part in ("조종원", "잡품"):
if e.get(part) is not None:
out[part] = e[part]
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
for k in ("방식", "식"):
if w.get(k) not in (None, ""):
out[f"작업량.{k}"] = w[k]
for k, v in (w.get("변수") or {}).items():
out[f"작업량.변수.{k}"] = v
if w.get("기계"):
out["작업량.기계"] = {k: w[k] for k in mw.FIXED if w.get(k)}
return out
def _machine(text: str, path: str, *layers: Any) -> str:
"""그 칸의 기계 열쇠 — 작업량 = 굳은 기계(② › ①) · 그 밖 = 덮음 열쇠."""
if path.startswith("작업량."):
for e in layers:
w = (e or {}).get(mw.WORK) if isinstance(e, dict) else None
if isinstance(w, dict) and w.get("기계"):
return str(w["기계"])
return text
def _up(path: str, row: dict | None, one: Any, mine: dict) -> Any:
"""그 칸 위 값 = ① 그 칸 › ⓪ 기계 줄 그 칸 · 기계 줄 없음 = `_NO`."""
have = paths(one)
if path in have:
return have[path]
if row is None:
return _NO
vals = mcrew.from_old_row(row).get("값") # 옛 꼴 사본 줄 = 새 꼴로 견줌(842-3)
vals = vals if isinstance(vals, dict) else {}
if path.startswith("값."):
return vals.get(path[2:])
if path in ("조종원", "잡품"):
return vals.get(mcrew.CREW if path == "조종원" else mcrew.MISC)
if path.startswith("작업량.변수."):
want = (mine.get(mw.WORK) or {}).get("식") or ((one or {}).get(mw.WORK) or {}).get("식")
specs = mw.specs_of(vals.get(mw.WORK))
spec = next((s for s in specs if s["식"] == want), None) if want else None
spec = spec or (specs[0] if specs and not want else None)
return ((spec or {}).get("변수") or {}).get(path[len("작업량.변수.") :])
return None # 작업량 방식 · 식 · 기계 = 기계 줄에 없음(위 층 없음 = 빈 값)
def _upper_now(sk: dict, got: dict) -> dict:
"""지금 ① — 가져온 식 = 저장본 · 그 밖 = 지금 기초(`바탕.로직`) 문서 `기계덮음` ·
기초 문서 없음 = 저장본."""
if imp.is_imported(sk):
return got.get(UPPER) or {}
key = str((sk.get("바탕") or {}).get("로직") or "")
live = dc.folder().get(key) if key else None
return mcv.cover_of(live) if live is not None else got.get(UPPER) or {}
def _same(a: Any, b: Any) -> bool:
return mcv._canon(a) == mcv._canon(b)
def _covers(sk: dict, got: dict, out: dict, notes: list | None, confirm: bool) -> dict:
"""② 칸마다 위 값 바탕 대 지금 — 바뀐 칸 = ② 지킴 + 알림 · 바탕(`덮음바탕`)은 지킨 칸만 남김 ·
`confirm` = 바탕 걷음(알림 없음)."""
doc = out.get("문서") if isinstance(out.get("문서"), dict) else None
cover = mcv.cover_of(doc) if doc is not None else out.get(COVER) or {}
held: dict = {} if confirm else got.get(BASE) or {}
keep: dict = {}
if cover and not confirm:
was, here = _eq_rows(got), _eq_rows(out)
up0, up1 = got.get(UPPER) or {}, _upper_now(sk, got)
for text, mine in cover.items():
for path, val in paths(mine).items():
m0 = _machine(text, path, mine, up0.get(text))
m1 = _machine(text, path, mine, up1.get(text))
before = (held.get(text) or {}).get(path, _NO)
if before is _NO:
before = _up(path, was.get(m0), up0.get(text), mine)
now = _up(path, _live_row(m1) or here.get(m1), up1.get(text), mine)
if before is _NO or now is _NO or _same(before, now) or _same(val, now):
continue
keep.setdefault(text, {})[path] = before
if notes is not None:
above = path in paths(up1.get(text))
notes.append(_kept(sk, text, path, m1, before, now, val, above))
rest = {k: v for k, v in out.items() if k != BASE}
return rest | ({BASE: keep} if keep else {})
def _txt(v: Any) -> str:
"""칸 값 글 — 인력 · 잡품 목록 = 줄 글 · 빈 값 = —."""
if isinstance(v, list):
return (
" · ".join(
f"{x.get('키') or '직종'} {x.get('인')}인"
if "인" in x
else f"{x.get('이름') or x.get('키') or x.get('줄')} {x.get('율')}%"
for x in v
if isinstance(x, dict)
)
or "없음"
)
if isinstance(v, dict):
return str(v.get("이름") or v.get("기계") or json.dumps(v, ensure_ascii=False))
return "—" if v in (None, "") else str(v)
def _label(path: str) -> str:
return {"조종원": "인력", "잡품": "잡품"}.get(path) or path.removeprefix("값.").replace(
".", " "
)
def _kept(sk, text, path, machine, before, now, mine, upper) -> dict:
row = _live_row(machine) or {}
name = f"{row.get('이름') or ''} {row.get('규격') or ''}".strip() or text
label = _label(path)
return {
"키": str(row.get("키") or text), "이름": name, "갈래": "기계", "처리": "지킴",
"문서": str(sk.get("키") or ""), "열쇠": text, "경로": path, "칸": label,
"층": "기초" if upper else "기계", "전": before, "후": now, "내값": mine,
"M01": [f"{label} {_txt(before)} → {_txt(now)}"], "내고침": [f"{label} {_txt(mine)}"],
} # fmt: skip
def carry(got: dict, root: dict) -> dict:
"""파생 문서에 맡긴 기계 고침 · 옵션 값을 다시 얹음(따로 문서를 다시 복사한 뒤)."""
root = put_opts(root, got.get(OPTS) or {}) if isinstance(got.get(OPTS), dict) else root
return {**root, COVER: got[COVER]} if isinstance(got.get(COVER), dict) and got[COVER] else root
def _note(key, was, now, lost, kind, name=None, again=()) -> dict:
return {
"키": key,
"이름": str(name or now.get("이름") or key),
"갈래": kind,
"처리": "지워짐" if lost else "다시복사",
"M01": diff(was, now) or ["바뀜"],
"내고침": list(lost),
"다시얹음": list(again),
}
def notes(sk: Any) -> list[dict]:
"""열 때 알림 — 이 SK 저장본의 지킨 칸 · 다시 복사 · 지울 고침(없으면 []) · 프로젝트 층 = []."""
if not is_sk(sk) or not dc.has(sk):
return []
out: list[dict] = []
form(sk, sk[dc.KEY], out)
return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str))