- 파생 문서 = 기초 문서 옵션 기본 위에 내가 고른 값만(옛 로직 줄 자동값이 기초 고침을 안 이김) · 층바탕 위 = 같은 기초 문서 - 따로 문서 · 끊음 — 기초가 옵션 기본 · 글만 바꿈 = 다시 복사 없음 · 안 고른 옵션 · 안 고친 줄 글 따라옴 · 고른 옵션 = 내 값 지킴 + 알림([확인] 까지) - 손고침 기초 · 굳히기 = `수식.바탕문서` 사본 → 굳힌 사본이 굳힐 때 단가산출 금액 · 프로젝트 층 = 굳은 뒤 기초 고침 안 받음(옛 칸 줄 고친 SK 빼고) - M01 옵션 가로 = 고칠 권한이면 기초 옵션 기본값(읽기 = 미리 보기 값) - 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목) · 제 자리 - 새 시험 test_848_10_upper_down(결과 — 새 · 있던 SK · 지킴 알림 · 글 · 굳힘 · 손고침 빌더 · 층바탕 · 되살림) - 옛 로직 줄 자동값 ≠ 기초 옵션 기본 200 장(금액 다름 109) = 새 SK 가 M01 기초와 같은 금액 · 저장된 SK 해당 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
481 lines
23 KiB
Python
481 lines
23 KiB
Python
"""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))
|