Files
Aislo/M02_MasterTemplete/M02_Sk_AutoRenew.py
T
eomsangdonandClaude Opus 5.5 2216951c65 fix(848-10): M01 기초 고침이 M02 단가산출로 빠짐없이 — 옵션 기본 · 따로 문서 옵션 · 글 · 굳힌 사본 · 되살림 제 그룹
- 파생 문서 = 기초 문서 옵션 기본 위에 내가 고른 값만(옛 로직 줄 자동값이 기초 고침을 안 이김) · 층바탕 위 = 같은 기초 문서
- 따로 문서 · 끊음 — 기초가 옵션 기본 · 글만 바꿈 = 다시 복사 없음 · 안 고른 옵션 · 안 고친 줄 글 따라옴 · 고른 옵션 = 내 값 지킴 + 알림([확인] 까지)
- 손고침 기초 · 굳히기 = `수식.바탕문서` 사본 → 굳힌 사본이 굳힐 때 단가산출 금액 · 프로젝트 층 = 굳은 뒤 기초 고침 안 받음(옛 칸 줄 고친 SK 빼고)
- M01 옵션 가로 = 고칠 권한이면 기초 옵션 기본값(읽기 = 미리 보기 값)
- 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목) · 제 자리
- 새 시험 test_848_10_upper_down(결과 — 새 · 있던 SK · 지킴 알림 · 글 · 굳힘 · 손고침 빌더 · 층바탕 · 되살림)
- 옛 로직 줄 자동값 ≠ 기초 옵션 기본 200 장(금액 다름 109) = 새 SK 가 M01 기초와 같은 금액 · 저장된 SK 해당 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 00:47:46 +09:00

481 lines
23 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
LABEL = dc.LABEL # 변수 · 식 · 금액 줄 글 칸 — 위가 바꾸면 안 고친 줄은 따라옴(848-10)
_ROWS = (("변수", dc.md.var_id), ("식", lambda x: str(x.get("기호") or "")))
def _relabel(mine: dict, first: dict, live: dict) -> None:
"""글만 바뀐 줄 = 안 고친 줄(원본 줄 그대로)만 새 글로 — `mine` · `first` 제자리.
금액 = 차례(셈 같음 = 같은 차례) · 변수 = 기호 · 식 = 기호."""
pairs: list[tuple[dict, dict]] = []
a, b = first.get("금액") or [], live.get("금액") or []
pairs += list(zip(a, b)) if len(a) == len(b) else []
for part, key in _ROWS:
now = {key(x): x for x in live.get(part) or []}
pairs += [(x, now[key(x)]) for x in first.get(part) or [] if key(x) in now]
for old, new in pairs:
if all(old.get(k) == new.get(k) for k in LABEL):
continue
fresh = {
**{k: v for k, v in old.items() if k not in LABEL},
**{k: new[k] for k in LABEL if k in new},
}
for part in ("금액", "변수", "식"):
rows = mine.get(part) or []
for n, x in enumerate(rows):
if x == old:
rows[n] = cp.deepcopy(fresh)
old.clear()
old.update(fresh)
def _soft(mine: dict, first: dict, live: dict, held: set, opts: bool, confirm: bool):
"""따로 문서 — 위 기초가 옵션 기본 · 글만 바꿈(848-10) → (새 문서, 새 원본,
지킨 옵션 [(열쇠, 전, 후, 내값)]) · 계산 구조가 바뀜 = None(다시 복사).
옵션: 안 고른 열쇠 = 새 기본 따라옴(원본도) · 고른 열쇠 = 내 값 지킴 + 알림(원본 그대로 =
[확인] 까지 · 옛 칸 `입력값` 고름 = 알림 없이 지킴) · 글: 안 고친 줄만 새 글 ·
`opts` 거짓 = 계산 내용 그대로(글만 봄)."""
was, have, now = _opts(first), _opts(mine), _opts(live)
if opts and dc.doc_fp(put_opts(live, was)) != dc.doc_fp(first):
return None
mine, first = cp.deepcopy(mine), cp.deepcopy(first)
_relabel(mine, first, live)
follow, kept, ack = {}, [], {}
for k, v in now.items() if opts else ():
if k not in was or mcv._canon(v) == mcv._canon(was[k]):
continue
if k in held or (k in have and mcv._canon(have[k]) != mcv._canon(was[k])):
kept += [] if k in held else [(k, was[k], v, have.get(k))]
ack[k] = v
else:
follow[k] = v
mine, first = put_opts(mine, follow), put_opts(first, {**follow, **(ack if confirm else {})})
return mine, first, [] if confirm else kept
def _opt_note(key: str, doc: dict, kept: list) -> dict:
return {
"키": key, "이름": str(doc.get("이름") or key), "갈래": "문서", "처리": "지킴",
"M01": [f"{k} {_txt(a)} → {_txt(b)}" for k, a, b, _ in kept],
"내고침": [f"{k} {_txt(m)}" for k, _, _, m in kept], "다시얹음": [],
} # fmt: skip
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(moved & set(cut)):
was = (got.get("부름") or {}).get(k)
if k in redo and dc.doc_fp(cut[k]) == dc.doc_fp(was):
cut.pop(k)
continue # 안 고친 끊음 = 조용히 따라옴
soft = _soft(cut[k], was, live[k], set(), k in redo, False) if was else None
if soft is not None: # 옵션 기본 · 글만 바뀜 = 끊음 지킴 · 고른 옵션 알림(848-10)
cut[k] = soft[0]
if soft[2] and notes is not None:
notes.append(_opt_note(k, live[k], soft[2]))
continue
if k not in redo:
continue
mine = cut.pop(k)
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 "")
moved_doc = out.get("따로") and key in live and not dc.same_origin(base, live[key])
if out.get("따로") and key in live and out.get(FIRST) is not None:
held = set((sk.get("입력값") or {}) if isinstance(sk.get("입력값"), dict) else ())
soft = _soft(out["문서"], out[FIRST], live[key], held, bool(moved_doc), confirm)
if soft is not None: # 옵션 기본 · 글만 바뀜 = 다시 복사 없이 얹음(848-10)
mine, first, kept = soft
out |= {"문서": mine, FIRST: first}
if moved_doc and (confirm or not kept):
out["원본"] = {**base, "판": dc.doc_fp(live[key])}
if kept and notes is not None:
notes.append(_opt_note(key, mine, kept))
moved_doc = False
if moved_doc:
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))