Files
Aislo/M02_MasterTemplete/M02_Doc_Sk.py
T
eomsangdonandClaude Opus 5.5 badceff991 refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0)
- Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 ·
  labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움)
- M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 ·
  손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함)
- M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서)
- 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움
- 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 ·
  파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) ·
  848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음
- 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과

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

343 lines
19 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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, 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 != "따로"})}