- 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>
343 lines
19 KiB
Python
343 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()
|
||
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 != "따로"})}
|