"""M02 단가산출(SK) 수식 문서 사본(PLAN 802-4a · 요구 664 · 665) — 서버 단독. SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 · 옵션 값 · 줄 규칙까지 든 정본) · `부름` = 부르는 단가산출 닫힌 묶음 · `끊음` = 이 사본에 굳힌 부름(고칠 수 있음) · 값 사본. 두 갈래: 파생(따로 없음) — 셈마다 바탕 로직의 기초 문서 사본 + 줄 규칙(입력값 · 켜쌓기율 · 고름 · 자재표시)으로 다시 지음(`derive` · 옛 엔진 안 돎 · 855 2-C1) · 옛 칸 고침(덮개 · 뺀줄 · 더한줄 · 수식고침 …) = 못 셈(올림 없음). 따로 — 수식 길(`M02_Doc_Router`)로 문서를 고침: 저장한 문서가 정본 · 옛 칸 고침 저장 = 409 · [재생성] = 지금 M01 로 다시 찍어 파생으로 돌아감(고친 문서 버림). SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 사전조합 · 구조물 조합이 이 값을 씀. 가져온 식 SK(807-1) = `M02_Doc_Import` 문서(파생 = 가져온 줄 + SK 고침에서 지음 · 따로 = 저장본) · 셈 = 단가기준(엑셀 = 엑셀 값 · 우리 = 연결 값) · 바탕 참조 SK = 옛 길(값 사본 없음). 위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) — 프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 · 파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임). 기초 문서(848-10) = 프로젝트 층 밖 = 지금 M01 문서 그대로(옵션 기본 포함 · 옛 로직 줄 자동값 안 씀 · 내가 고른 값만 얹음) · 굳힌 사본 · 프로젝트 층 = `수식.바탕문서`(굳힐 때 · 손고침 기초를 저장할 때 사본) › 옛 길(옛 사본 금액 그대로). """ from __future__ import annotations import copy as cp import json from contextvars import ContextVar from typing import Any from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Gap as gap from M02_MasterTemplete import M02_Doc_Import as dim from M02_MasterTemplete import M02_Doc_Import_Carry as carry from M02_MasterTemplete import M02_MyMachine_Draft as draft from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sk_AutoRenew as renew import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc KEY = dc.KEY UPPER = mcv.UPPER BASE_DOC = ( "바탕문서" # `수식` 칸(848-10) — 기초 문서 사본(손고침 기초 · 굳힌 사본) · 프로젝트 셈의 기초 ) OLD_FIELDS = ( "바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침", "고름", "자재표시", "켜쌓기율", ) # fmt: skip _STAMPED = ("원값", "바탕판", "처음수량", "M01판", "끊음") # 서버가 적는 칸 — 옛 칸 대조에서 뺌 SAVING: ContextVar[dict | None] = ContextVar("수식길저장", default=None) # {키, 사본} — 수식 길만 def own(doc: Any) -> bool: """수식 사본을 가질 SK — 바탕 참조 SK 빼고(가져온 식 = 가져온 줄 문서 · 807-1).""" if not isinstance(doc, dict) or (doc.get("가져온") and not dim.is_imported(doc)): return False return "참조" not in (doc.get("바탕") or {}) def _strip(v: Any) -> Any: if isinstance(v, dict): return {k: _strip(x) for k, x in v.items() if k not in _STAMPED} if isinstance(v, list): return [_strip(x) for x in v] if isinstance(v, float) and v.is_integer(): # 파일 24554.0 = 화면 왕복 24554(823-1) return int(v) return v def old_fp(doc: dict) -> str: """옛 칸 지문 — 따로 문서 위 옛 칸 고침 막음(가져온 식 = 가져온 줄 · 고른 칸 · 이음도).""" got = {k: doc.get(k) for k in OLD_FIELDS if doc.get(k) not in (None, {}, [])} if dim.is_imported(doc): got["가져온"] = {"로직": doc["가져온"].get("로직")} # 옛 꼴만(857-3b 문서 = 수식 고침) return dc.fp(_strip(got)) # ── 파생 — 엔진에 넣는 고친 줄 → 문서 ───────────────────────────────── def _set_values(doc: dict, given: dict) -> None: for var in doc.get("변수") or []: link = var.get("연결") or {} if link.get("갈래") in ("선택", "입력") and var.get("열쇠") in given: link["값"] = given[var["열쇠"]] have = list(link.get("목록") or []) mine = str(link["값"]).startswith("개인 ") # 내 기계 원문번호(821-1) if link["갈래"] == "선택" and link["값"] not in have and (mine or not have): link["목록"] = [*have, link["값"]] # 열린 목록 · 내 기계 = 고른 값을 목록에 def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: """기초 문서(848-10) → (문서, 옵션 기본을 문서에서 읽음) — 프로젝트 층 밖 = 지금 M01 문서 · 그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 지금 문서.""" live = dc.folder().get(key) if renew.on() and live is not None: return dc.doc_of(whole, key), True kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값) return cp.deepcopy(kept), renew.on() return dc.doc_of(whole, key), False _PATCH = ("덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침") def patched(sk: dict) -> bool: """옛 칸이 기초 줄을 고친 SK — 파생 문서 = 고친 줄 변환(기초 문서 사본 `바탕문서` 안 씀).""" return any(sk.get(k) not in (None, {}, []) for k in _PATCH) def _bare_doc(doc: dict) -> dict: return {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} OLD_PATCH = (*_PATCH, "변수줄", "식덮개") # 옛 칸 고침(덮개 · 더한줄 · 식 칸 …) — 셈 은퇴(855 2-C1) OLD_WHY = "옛 칸(덮개 · 뺀줄 · 더한줄 · 수식고침 …)으로 고친 단가산출 — 옛 칸 셈 은퇴 · 수식 문서로 다시 만들어야 셈" REF_WHY = "바탕 참조 단가산출 — 수식 문서 없음 · 못 셈" def frozen(sk: dict) -> bool: """굳힌 사본 SK(B09 · 구조물 사본 `GX9…` 굳힌 줄 · 수식 사본 없음) — 바탕 로직에 M01 수식 문서 없음 · 셈 = 옛 길(B9 걸음 몫 · 855 2-C1 은 안 건드림).""" key = str((sk.get("바탕") or {}).get("로직") or "") if dim.is_imported(sk): # 857-3b 가져온 식 굳힌 사본 = 불러온 그대로 문서 셈(굳힌 줄 없음) return False return bool(key) and not dc.has(sk) and key not in dc.folder() def old_only(sk: dict) -> bool: """옛 칸 고침이 든 파생 SK(가져온 식도 — 857-3b 문서 = 불러온 그대로 · 고침 = 줄 쌓기) — 셈 안 함.""" return any(sk.get(k) not in (None, {}, []) for k in OLD_PATCH) def derive(sk: dict, whole: Any) -> dict: """이 SK 문서(855 2-C1 · 옛 엔진 안 돎) — 바탕 로직 = 기초 문서(`base_doc`) 사본 · 바탕 없음 = 빈 문서 · 옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 손고침 · 프로젝트 층 = 옛 로직 줄 자동값) · 줄 규칙(켜쌓기율 · 고름 · 자재표시 · 일위대가 [+ 줄] 사본 811-1) = 문서 규칙(`dc.line_doc` · 열쇠 = 금액#n 기초 문서 금액 줄 · 로직 줄 안 읽음 855 L2 ⓑ-3 · SK 재료 빈 칸 = 직접계산 747-1). `whole` = 값 사본 색인. 옛 칸 고침 SK 는 부르는 쪽이 먼저 막음.""" key = str(sk.get("키") or "") base_key = str((sk.get("바탕") or {}).get("로직") or "") if not base_key: return {**dc.md.blank(key, str(sk.get("이름") or "")), "키": key} plain, real = base_doc(sk, whole, base_key) if plain is None: raise ValueError(f"기초 문서 없음 「{base_key}」") mats = {n for n, _, _ in dc.prices._mat_lines(plain)} # 재료 금액 줄(855 L2 ⓑ-3) picks = {n: mt for n, mt in _rules(sk, "고름").items() if n in mats} # 재료 줄만(옛과 같음) names = {str(i["이름"]) for i in sd.doc_row(whole, base_key)["입력"]} values = {k: v for k, v in (sk.get("입력값") or {}).items() if k in names} given = dc.given_of(whole, base_key, values) if values or not real else {} doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1) _set_values(doc, {k: v for k, v in given.items() if k in values} if real else given) apart = _apart(_rules(sk, "자재표시"), mats) doc = dc.line_doc(doc, sk.get("켜쌓기율"), picks or None, apart) return {**doc, "키": key or base_key, "이름": str(sk.get("이름") or doc.get("이름"))} RULE_WHY = "옛 줄 가리킴(kind:키#n) 단가산출 — 줄 규칙은 금액#n · 다시 만들어야 셈" def _rules(sk: dict, field: str) -> dict[int, Any]: """줄 규칙 칸(고름 · 자재표시) {금액#n: 값} → {n: 값} · 옛 cid 꼴 = 못 셈(855 L2 ⓑ-3 · 호환 없음).""" out = {} for key, value in (sk.get(field) or {}).items(): n = sd.amount_at(key) if n is None: raise ValueError(RULE_WHY) out[n] = value return out def _apart(marks: dict[int, Any], mats: set[int]) -> list[int]: """별도계상 재료 줄 차례 — SK 빈 칸 = 직접계산(747-1) · 「별도계상」 고른 재료 줄만.""" from M02_MasterTemplete import M02_Labor_Doc as labor # 늦게 — 일위대가 셈이 이 파일을 부름 return sorted( n for n, mark in marks.items() if n in mats and labor.apart({"별도계상": "직접계산", **labor.marks(mark)}) ) def seed(sk: dict) -> dict | None: """수식 사본 없는 SK(옮기기 전 · 새로)의 씨 — 로직 사본 값 + 빈 부름 · 빈 SK = 빈 문서 · 가져온 식 = 빈 부름(문서는 셈마다 지음).""" if dim.is_imported(sk): return {"부름": {}} if (held := skc.held(sk)) is not None: return {**dc.values_of(held), "부름": {}} if sk.get("바탕") or sk.get("더한줄"): return None empty = {"판": skc._fp([]), "로직": [], "단가판": skc._fp([]), "단가": [], "부름": {}} return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))} def with_upper(sk: dict, got: dict, keep: bool = False) -> dict: """① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 · ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함 · 기초 문서 사본 `바탕문서`(848-10) = 손고침 기초 · `keep`(굳히기) = 늘 · 옛 칸이 줄을 고친 SK 빼고 — 프로젝트 사본이 굳힐 때 기초 문서로 셈(`base_doc`).""" key = str((sk.get("바탕") or {}).get("로직") or "") live = dc.folder().get(key) if key else None if live is None: return got got = {k: v for k, v in got.items() if k != BASE_DOC} if (keep or live.get(mcv.HAND)) and not patched(sk): got[BASE_DOC] = norm(_bare_doc(live)) # JSON 꼴(굳힌 사본 · 저장 파일) cover = mcv.cover_of(live) if not cover: return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got out = {**got, UPPER: cp.deepcopy(cover)} have = dc.docs_of(out) if need := [k for k in dc.upper_calls(out) if k not in have]: out["부름"] = {**(out.get("부름") or {}), **dc.closure(dc.over(out), need, have)} return out def upper(sk: dict, got: Any) -> Any: """셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1).""" if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk) or renew.frozen(got): return got # 굳은 사본 = 실린 위덮음 그대로(855 2-D) return with_upper(sk, got) def copy_of(sk: dict, whole: Any = None) -> dict | None: """셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 다시 지은 문서(부름은 있던 것 먼저 · 옛 엔진 안 돎) · 사본 없음(바탕 참조) · 옛 칸 고침 파생 SK = None(못 셈 · 855 2-C1). `whole` = 셈 색인(없으면 SK 값 사본).""" if not own(sk): return None got = sk.get(KEY) if dc.has(sk) else seed(sk) if got is None and "로직" in (sk.get("바탕") or {}) and not frozen(sk): got = {"부름": {}} # 저장 전 새 SK = 지금 M01 값(값 사본은 [저장] 때 찍음) if got is None: return None got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1) if got.get("따로") or (renew.frozen(got) and isinstance(got.get("문서"), dict)): return carry.carry(sk, got) # 848-7 가져온 식 ① = 가져온 값 · 굳은 사본 = 실린 문서 그대로 if old_only(sk): return None whole = whole if whole is not None else skc.over(sk, skc.whole_()) if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(`Doc_Import._ctx`) try: root = dim.derive(sk, None, dc.base(whole)) except dc._ERR as e: root = {**dc.md.blank(str(sk.get("키"))), "_틀림": str(e)} return carry.carry(sk, {**got, "문서": root, "부름": {}}) try: root = renew.carry(got, derive(sk, whole)) # 맡긴 기계 덮음(836-2) except dc._ERR as e: root = {**dc.md.blank(str(sk.get("키"))), "_틀림": str(e)} values = dc.values_of(skc.held(sk) or got) # 서버가 정한 값(셈 중 사본 › 수식 값 몫 · 855 2-D) values = renew.rows(values) if renew.is_sk(sk) else values # 836-2 whole = dc.over(values) calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") # 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ) seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {} return {**got, **values, "문서": root, "부름": calls, **origin} def run(sk: dict, copy: dict, master: Any = None) -> dict: """문서 셈 — 가져온 식 = 단가기준 · 형제 SK(`dim.run`) · 그 밖 = 값 사본(`dc.run`).""" if dim.is_imported(sk): return dim.run( copy["문서"], sk, dc.base(master) if master is not None else None, upper=copy.get(UPPER) ) return dc.run(copy["문서"], copy) # ── 저장 첫머리(옛 길 `clean_doc` 끝) ────────────────────────────────── def stored(key: Any) -> dict | None: return skc.stored_doc(key) # 한 저장 안 한 번 읽음(826-3) def norm(copy: dict) -> dict: return json.loads(json.dumps(dc.ml._norm(copy), ensure_ascii=False, default=str)) def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: """저장 꼴에 `수식` 을 정함 — 수식 길 저장(`NEW`) = 그 사본 · 따로 = 저장본(옛 칸 고침 409 · 재생성 = 파생으로) · 그 밖 = 다시 지음(부름 = 있던 것 · 재생성 = 새로 · 옛 엔진 안 돎) · 옛 칸 고침 파생 SK = 문서 없이 값 사본 · 부름만(못 셈).""" out = {k: v for k, v in out.items() if k != KEY} if not own(out): return out raw = raw if isinstance(raw, dict) else {} mine = SAVING.get() if mine is not None and mine.get("키") == out.get("키"): # 수식 길 저장 — 서버가 지은 사본 if dim.is_imported(out): # 가져온 식 — 셈이 읽은 줄(바꿔 끼운 줄 등)을 로직 사본에(823-1) out = gap.fill_imported(out, mine["사본"].get("문서")) if skc.has(out): # 기계 창 초안으로 고친 내 기계 = 새 값(827-1) out = {**out, skc.KEY: draft.renew(out[skc.KEY])} return {**out, KEY: norm(mine["사본"])} file = stored(out.get("키")) or {} have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None) have = ( upper(out, renew.form(out, have)) if have else have ) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음 if have and have.get("따로") and job != skc.REGEN: if file and old_fp(file) != old_fp(out): raise sd.DocError( "수식 문서로 고친 단가산출 — 옛 칸(덮개 · 줄) 고침은 수식 탭에서 · 또는 [재생성]", 409, ) if dim.is_imported(out): return {**out, KEY: norm(have)} slim = skc.READS.get() is not None # 저장 관문이 셈 한 번으로 박음(826-3) return {**out, KEY: norm(have if slim else gap.fill(have))} # 빈틈 = 지금 값(822-1) # 빈 SK(바탕 · 줄 없음) = 빈 문서(요구서_664 0 장) · 수식 길로 고친 빈 SK = 위 따로(804-4) if skc.held(out) is None and not dim.is_imported(out): empty = seed(out) return {**out, KEY: norm(empty)} if empty else out calls = {} if job == skc.REGEN else (have or {}).get("부름") or {} first = {**dc.values_of(skc.held(out) or {}), "부름": calls} if job != skc.REGEN and (have or {}).get("끊음"): # 안 바뀐 항목 고침 = 그대로(836-2) first["끊음"] = have["끊음"] if job != skc.REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2) first |= {k: have[k] for k in renew.KEEP if (have or {}).get(k)} if (have or {}).get( UPPER ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) first[UPPER] = have[UPPER] if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣) kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC) key = str((out.get("바탕") or {}).get("로직") or "") if kept is None and key in dc.folder(): kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서 if kept: first[BASE_DOC] = norm(_bare_doc(kept)) copy = copy_of({**out, KEY: first}, whole) if ( copy and skc.READS.get() is not None ): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ) run({**out, KEY: copy}, copy, whole) if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) ): # 파생 — 옛 로직 사본에 박음(822-1) out = {**out, skc.KEY: skc.grow(out[skc.KEY], skc.snap([], keys))} copy = {**copy, **dc.values_of(out[skc.KEY])} return {**out, KEY: norm({k: v for k, v in (copy or first).items() if k != "따로"})}