Files
Aislo/M02_MasterTemplete/M02_Doc_Sk.py
T
eomsangdonandClaude Opus 5.5 35d3242711 refactor(855-E 2-E4): M02 로직 줄 옛 엔진 셈 걷음 — Labor_Doc.run_line · pct_extras · logic_mats · layered · drop_apart
- M02_Labor_Copy.line: 프로젝트 층 · `dsk.OLD` 옛 엔진 갈래 걷음(층 셈과 같은 문서 셈) · 재료 줄 `걸림`(재료 조건 ·
  요소 키 틀 구멍의 입력 이름 = 문서 몫 · 화면 `releaseTied` 가 읽음 — 옛 logic_mats 와 같은 뜻)
- M02_Labor_Doc: `run_line` · `pct_extras` · `_pct_base` · `logic_mats` · `layered` · `drop_apart` · `_specs`(mf.inputs_of) 지움
  (제품 부르는 곳 0) · 담기 검사 = 새 `_head`(문서 입력 이름 · 재료 금액 줄 차례 — M01 로직 줄 안 읽음)
- M02_Doc_Sk: 아무도 안 켜는 `OLD` ContextVar 지움
- 시험: 옛 날 답 자리 = 새 `helper_855_line.run_line`(층 문서 셈 · 재료 직접계산) — 175 · 222_1 · 715_3 ·
  715_sangeun_store · 727 · 742_1 · 747_1 · 795_1 · 795_2 · m02_labor_layer · m02_labor_logic_mats · m02_labor_ref ·
  옛 엔진만 붙든 것 걷음: test_149_4 통째(옛 % 덧줄 표기) · 751_3 다섯(run_line 끝수) · 792_3 다시 버림 ·
  802_4a 옛 길 대조(OLD · run_line) · 855_sk_layers 옛 엔진 안 돎 = master_formula.run 부름 0 으로 ·
  helper_855_old_engine_routes 의 % 덧줄 표기 = 그 도우미 안으로(옛 길 도우미 · 엔진 몸과 같이 지움)
- 222_1 시멘트 단위 글 kg → ㎏(문서 단위)
- 검증: 관련 82 파일 + 지킴 + 관문 776 통과 · 빌더 --check 같음 · typecheck 0

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

349 lines
19 KiB
Python

"""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()
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)}
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, 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 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 != "따로"})}