"""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))