Files
Aislo/M02_MasterTemplete/M02_Doc_Sk.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

309 lines
16 KiB
Python

"""M02 단가산출(SK) 수식 문서 사본(PLAN 802-4a · 요구 664 · 665) — 서버 단독.
SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 · 옵션 값 · 줄 규칙까지 든 정본) ·
`부름` = 부르는 단가산출 닫힌 묶음 · `끊음` = 이 사본에 굳힌 부름(고칠 수 있음) · 값 사본.
두 갈래:
파생(따로 없음) — 옛 칸(바탕 · 덮개 · 뺀줄 · 더한줄 · 수식고침 …)이 정함: 셈마다 옛 칸이 낸 줄
(`M02_Sangeun_Calc.run` 이 엔진에 넣는 고친 줄)을 문서로 옮겨(덮개 없는 바탕 = M01 문서 사본 ·
고친 줄 = `master_doc_convert`) 문서 셈 · 지금 화면(옛 칸 고침)이 그대로 돎.
따로 — 수식 길(`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 decimal import Decimal
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_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판", "끊음") # 서버가 적는 칸 — 옛 칸 대조에서 뺌
OLD: ContextVar[bool] = ContextVar("옛길", default=False) # 옛 셈 길(옮기기 전 금액 대조)
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["가져온"] = {k: doc["가져온"].get(k) for k in ("로직", "연결")}
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["열쇠"]]
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:
return cp.deepcopy(kept), True
if live is not None and live.get(mcv.HAND):
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
return m01.built(key), False
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)}
def derive(sk: dict, ctx: tuple) -> dict:
"""옛 칸이 낸 고친 줄(`ctx` = run 이 엔진에 넣은 (색인, 키, 입력, 바탕 답)) → 이 SK 문서.
덮개 없는 바탕(고친 줄 = 바탕 줄) = 기초 문서(`base_doc`) 사본 · 아니면 고친 줄 변환 ·
옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 옛 로직 줄 자동값이 기초 고침을 안 이김)."""
whole, key, values, got, mats = ctx
row = whole.logic(key)
given = dc.given_of(whole, key, values)
mine = {k: v for k, v in given.items() if k in (values or {})} # 내가 고른 값
base_key = str((sk.get("바탕") or {}).get("로직") or "")
plain, real = None, False
if base_key:
try:
frozen = whole.logic(base_key)
same = {**row, "키": base_key} == frozen
except dc._ERR:
same = False
plain, real = base_doc(sk, whole, base_key) if same else (None, False)
if plain is not None:
doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1)
_set_values(doc, mine if real else given)
elif not (row.get("호표") or row.get("덧줄") or row.get("결과")):
doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))
else:
live = dc.folder().get(base_key) if base_key and renew.on() else None
given = {**given, **renew._opts(live), **mine} if live else given
doc = dc.cv.convert(whole, row, given)[0]
apart = dc.apart_of(got.get("자재표시"), mats)
doc = dc.line_doc(doc, got.get("켜쌓기율"), got.get("고름") or None, apart)
return {**doc, "키": str(sk.get("키") or key), "이름": str(sk.get("이름") or doc.get("이름"))}
def seed(sk: dict) -> dict | None:
"""수식 사본 없는 SK(옮기기 전 · 새로)의 씨 — 로직 사본 값 + 빈 부름 · 빈 SK = 빈 문서 ·
가져온 식 = 빈 부름(문서는 셈마다 지음)."""
if dim.is_imported(sk):
return {"부름": {}}
if skc.has(sk):
return {**dc.values_of(sk[skc.KEY]), "부름": {}}
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):
return got
return with_upper(sk, got)
def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
"""셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 옛 칸으로 다시 지은 문서(부름은 있던 것 먼저) ·
`OLD` 켬(옮기기 대조 · 시험) = 옛 길."""
if OLD.get() or not own(sk):
return None
got = sk.get(KEY) if dc.has(sk) else seed(sk)
if got is None:
return None
got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1)
if got.get("따로") or ctx is None:
return got
if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎)
try:
same = dim.basis_of(sk) == "엑셀"
root = dim.derive(sk, ctx if same else None, dc.base(ctx[0]))
except dc._ERR as e:
root = {**dc.md.blank(str(sk.get("키"))), "_틀림": str(e)}
return {**got, "문서": root, "부름": {}}
try:
root = renew.carry(got, derive(sk, ctx)) # 맡긴 기계 덮음(836-2)
except dc._ERR as e:
root = {**dc.md.blank(str(sk.get("키"))), "_틀림": str(e)}
values = dc.values_of(sk[skc.KEY]) if skc.has(sk) else dc.values_of(got) # 서버가 정한 값
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 "")
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {}
return {**got, **values, "문서": root, "부름": calls, **origin}
def on_run(sk: dict, ans: dict, ctx: tuple | None) -> dict:
"""`M02_Sangeun_Calc.run` 끝 — 수식 사본 있는 SK 금액 = 문서 셈(기준 · 1 단위) + 덧칸 `수식셈`."""
copy = copy_of(sk, ctx)
if copy is None:
return ans
got = run(sk, copy, ctx[0] if ctx else None)
money = dc.money(got)
base = {k: Decimal(str(v)) for k, v in money.items()} if money else None
times = Decimal(str(ans.get("배") or 1))
unit = {k: v / times for k, v in base.items()} if base else None
mark = {"셈됨": bool(base), "따로": bool(copy.get("따로"))}
if not base:
mark["까닭"] = copy["문서"].get("_틀림") or dc.why(got) or "돈 아닌 문서"
return {**ans, "기준": base, "1단위": unit, "수식셈": mark}
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)
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 ·
단가갱신 = 값만 · 재생성 = 파생으로) · 그 밖 = 옛 칸으로 다시 지음(부름 = 있던 것 · 재생성 = 새로)."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
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, confirm=job == renew.CONFIRM)) 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)}
copy = dc.refresh(have)[0] if job == skc.PRICE else have
slim = skc.READS.get() is not None # 저장 관문이 셈 한 번으로 박음(826-3)
return {**out, KEY: norm(copy if slim else gap.fill(copy))} # 빈틈 = 지금 값(822-1)
# 빈 SK(바탕 · 줄 없음) = 빈 문서(요구서_664 0 장) · 수식 길로 고친 빈 SK = 위 따로(804-4)
if not skc.has(out) and not dim.is_imported(out):
empty = seed(out)
return {**out, KEY: norm(empty)} if empty else out
box: list = []
calc.run(out, whole, catch=box)
calls = {} if job == skc.REGEN else (have or {}).get("부름") or {}
first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": 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]
copy = copy_of({**out, KEY: first}, box[-1] if box else None)
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 != "따로"})}