- 화면(줄 쌓기 머리 · 구조물 카드 › 사본 단가산출): 할일 단추 · 확인 창(askJob) · 바뀐 자원 줄 · 프로젝트 층 바뀜 배지 걷음 · 글 키 13 걷음 · 머리 띠의 프로젝트 「M01 새 판」 갈래 걷음 - 서버 수식 길: `할일` 단가갱신 · 재생성 받으면 400 · 미리 셈 답 바뀐자원 · 버림 · 사본없음 걷음 · `current` · `_settled` 할일 인자 걷음 - `M02_Doc_Sk.settle` · `M02_Sangeun_Copy.settle` · `_formula_job` 의 단가갱신 갈래 · `M02_Doc_Copy.refresh` 걷음 (서버 안 재생성 = 서고 합치기 · 불러온 식 초기화가 씀 → 남김 · `skc.refresh` = 일위대가 `M02_Labor_Copy` 가 씀 → 남김) - 사본 글: 「고침은 M02 에서 고친 뒤 구조물 다시 지정」 - 시험: 단가갱신 · 재생성 수식 길만 보던 줄 · 시험(802_4a ③ ④ · 822_1 · 826_3 재생성 · 795_1 · 804_4 · 821_1 · 821_3 · 827_1) 걷음 · 값 그대로 · 단가새값 단언은 남김 · 소스 글자 시험(804_6 · 804_7) 지움 · 856_0 프로젝트 「M01 새 판」 = 띠 없음 - 821_1: 층 SK 는 내 기계 고침을 안 따라감(시험 고정 renew off) — 고친 뒤 값 = 사본 값 그대로로 고쳐 씀 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
434 lines
19 KiB
Python
434 lines
19 KiB
Python
"""M02 수식 문서 사본(PLAN 802-4a · 요구 664 · 665 · 요구서_664 1 장 4) — 서버 단독.
|
||
|
||
단가산출 기초 정본 = 수식 문서(`resources/master_data/_수식문서_틀.md`) — M02 단가산출(SK) ·
|
||
일위대가 · 사전조합(SC) · B09 사본은 만들 때 M01 문서를 찍어 가짐(M01 이 바뀌어도 그대로).
|
||
문서 칸 `수식`(옛 로직 사본 `사본` 은 802-5 까지 옆에 둠):
|
||
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 자원 줄], ← 값 사본(`M02_Sangeun_Copy` 꼴)
|
||
부름 {키: 문서}(닫힌 묶음 — 연결 · [재생성] 때 새로) ·
|
||
SK 만: 문서(이 SK 문서 · 사용자 고침) · 끊음 {키: 문서}(이 사본 안에 굳힌 부름 · 고칠 수 있음) ·
|
||
따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) ·
|
||
위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)}
|
||
셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) ·
|
||
[재생성](서버 안 · 서고 합치기 등) = 지금 M01 문서로.
|
||
부름 문서 = 색인이 실어 온 사본 문서 › M01 문서(`수식문서/`).
|
||
줄 규칙(요구 664 · 브레인 802-4a ④) = 일위대가 줄 옵션을 문서 안에 드러냄(`line_doc`) —
|
||
켜쌓기율 = 변수 `r_켜쌓기`(입력) · 금액 줄 수량 × r ÷ 100 · 고른 자재 = 그 줄 단가 기호 연결
|
||
요소 키 · 별도계상 = 그 금액 줄 `합밖`.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import copy as cp
|
||
import hashlib
|
||
import json
|
||
import re
|
||
import sys
|
||
from decimal import Decimal
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
from M02_MasterTemplete import M02_Item_Prices as prices # noqa: F401 (`Doc_Sk` · `Labor_Copy` 가 `dc.prices` 로 씀)
|
||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||
|
||
_SCRIPTS = str(Path(__file__).resolve().parents[1] / "resources/master_data/scripts")
|
||
if _SCRIPTS not in sys.path:
|
||
sys.path.insert(0, _SCRIPTS)
|
||
|
||
import master_doc as md # noqa: E402
|
||
import master_doc_calc as mc # noqa: E402
|
||
import master_doc_cover as mcv # noqa: E402
|
||
import master_doc_link as ml # noqa: E402
|
||
import master_doc_work as mw # noqa: E402
|
||
|
||
KEY = "수식"
|
||
COSTS = ("노무비", "재료비", "경비", "계")
|
||
RATE = {"열쇠": "켜쌓기율", "기호": "r", "아래": "켜쌓기", "위": "", "이름": "켜쌓기율"}
|
||
RATE_ID = md.sym_id(RATE["기호"], RATE["아래"])
|
||
_ERR = (Exception,) # 변환 · 셈 틀림 = 그 문서 못 셈(까닭) — 셈 길은 멈추지 않음
|
||
|
||
|
||
def has(doc: Any) -> bool:
|
||
got = doc.get(KEY) if isinstance(doc, dict) else None
|
||
return isinstance(got, dict) and isinstance(got.get("부름"), dict)
|
||
|
||
|
||
def fp(value: Any) -> str:
|
||
raw = json.dumps(ml._norm(value), ensure_ascii=False, sort_keys=True, default=str)
|
||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||
|
||
|
||
#: 문서 셈 칸(848-2) — 덮음 · 손고침 · 쌓기 · 이름은 안 견줌
|
||
LOGIC = ("변수", "식", "금액", "끝수", "결과단위") # fmt: skip
|
||
#: 변수 · 식 · 금액 줄의 글 칸(연결 안 `단위` 는 셈 칸)
|
||
LABEL = ("이름", "규격", "단위", "비고", "출처") # fmt: skip
|
||
|
||
|
||
def _whole_num(v: Any) -> Any:
|
||
"""수 꼴 맞춤 — 정수 값 실수(4.0) = 정수(4)(저장본 · M01 문서 읽기 꼴이 달라도 같은 지문 · 855-E 2-E4)."""
|
||
if isinstance(v, dict):
|
||
return {k: _whole_num(x) for k, x in v.items()}
|
||
if isinstance(v, list):
|
||
return [_whole_num(x) for x in v]
|
||
if isinstance(v, float) and v.is_integer():
|
||
return int(v)
|
||
return v
|
||
|
||
|
||
def doc_fp(doc: Any, legacy: bool = False) -> str:
|
||
"""문서 계산 내용 지문(848-2) — 셈 칸(`LOGIC`)만 · 줄 · 변수의 글 칸 뺌 · 서버 표지 칸 뺌 ·
|
||
`기계덮음`(②) · `위덮음`(①) · `손고침` 은 셈 칸 밖 = 바뀌어도 같은 지문 · 수 꼴(4 · 4.0) 안 가림 ·
|
||
`legacy` = 수 꼴 가리던 옛 지문(저장본 `원본.판` 대조만)."""
|
||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||
|
||
doc = doc if isinstance(doc, dict) else {}
|
||
bare = lambda x: {k: v for k, v in x.items() if k not in LABEL} if isinstance(x, dict) else x # noqa: E731
|
||
got = {k: doc.get(k) for k in LOGIC}
|
||
for part in ("변수", "식", "금액"):
|
||
got[part] = [bare(x) for x in got[part] or []]
|
||
got = dsk._strip(got)
|
||
return fp(got) if legacy else fp(_whole_num(ml._norm(got)))
|
||
|
||
|
||
# ── M01 문서(정본 폴더) ────────────────────────────────────────────────
|
||
_FOLDER: dict[str, Any] = {"자국": None, "문서": {}}
|
||
|
||
|
||
def folder() -> dict[str, dict]:
|
||
"""M01 수식 문서 {키: 문서} — 폴더 파일 자국이 바뀌면 다시 읽음(M01 관리자 고침)."""
|
||
files = sorted(ml.FOLDER.glob("수식_*.json"))
|
||
mark = tuple((p.name, p.stat().st_mtime_ns, p.stat().st_size) for p in files)
|
||
if _FOLDER["자국"] != mark:
|
||
_FOLDER["문서"], _FOLDER["자국"] = ml.load_all(), mark
|
||
return _FOLDER["문서"]
|
||
|
||
|
||
def _carried(whole: Any, key: str) -> dict | None:
|
||
"""색인이 실어 온 문서(사본 셈 색인 `M02_Item_Bundle.Index.docs` · 감싼 색인 안쪽까지)."""
|
||
for _ in range(8):
|
||
own = vars(whole) if hasattr(whole, "__dict__") else {}
|
||
if key in (own.get("docs") or {}):
|
||
return own["docs"][key]
|
||
whole = own.get("_whole")
|
||
if whole is None:
|
||
return None
|
||
return None
|
||
|
||
|
||
def doc_of(whole: Any, key: str) -> dict | None:
|
||
"""키 하나의 문서 — 색인이 실어 온 사본 문서 › M01 문서 · 없으면 None(855-E L3 — 로직 줄 · 변환기 안 읽음)."""
|
||
if (got := _carried(whole, str(key))) is not None:
|
||
return cp.deepcopy(got)
|
||
live = folder().get(key)
|
||
return cp.deepcopy(live) if live is not None else None
|
||
|
||
|
||
def calls(doc: dict) -> list[str]:
|
||
"""문서가 부르는 단가산출 키 + 기계 덮음 시간당 작업량 식(846-1)."""
|
||
return [
|
||
*(
|
||
str(v["연결"]["키"])
|
||
for v in doc.get("변수") or []
|
||
if (v.get("연결") or {}).get("갈래") == "단가산출" and (v.get("연결") or {}).get("키")
|
||
),
|
||
*mw.cover_calls(doc),
|
||
]
|
||
|
||
|
||
def closure(whole: Any, keys: list[str], have: dict | None = None) -> dict[str, dict]:
|
||
"""키들과 그 문서가 부르는 단가산출 닫힌 묶음 {키: 문서} — `have`(만든 때 것) 먼저."""
|
||
have, out, todo = have or {}, {}, list(keys)
|
||
while todo:
|
||
key = str(todo.pop())
|
||
if key in out:
|
||
continue
|
||
doc = have.get(key) or doc_of(whole, key)
|
||
if doc is None:
|
||
continue
|
||
out[key] = doc
|
||
todo += [k for k in calls(doc) if k not in out]
|
||
return out
|
||
|
||
|
||
# ── 값 사본 색인 · 연결 ────────────────────────────────────────────────
|
||
def values_of(copy: dict) -> dict:
|
||
"""값 사본 몫만(`skc` 꼴) — 셈 색인 · [단가 갱신] 에 씀."""
|
||
return {k: copy[k] for k in ("판", "시점", "로직", "단가판", "단가시점", "단가") if k in copy}
|
||
|
||
|
||
def base(whole: Any) -> Any:
|
||
while isinstance(whole, skc.Copy):
|
||
whole = whole._whole
|
||
return whole
|
||
|
||
|
||
def over(copy: dict, whole: Any = None) -> Any:
|
||
"""값 사본 색인 — M01 색인 위 사본 줄(`skc.over` 같은 메모 · 같은 줄 = 같은 색인)."""
|
||
return skc.over({skc.KEY: values_of(copy)}, base(whole or skc.whole_()))
|
||
|
||
|
||
def docs_of(copy: dict) -> dict[str, dict]:
|
||
return {**(copy.get("부름") or {}), **(copy.get("끊음") or {})}
|
||
|
||
|
||
def cover_of(copy: dict, doc: dict | None = None) -> dict:
|
||
"""셈 cover(848-1) — ① `위덮음` 위에 ② 문서 `기계덮음` · ① 없음 = 문서 칸 그대로."""
|
||
return mcv.merge_layers(
|
||
copy.get(mcv.UPPER), mcv.cover_of(copy.get("문서") if doc is None else doc)
|
||
)
|
||
|
||
|
||
def upper_calls(copy: dict) -> list[str]:
|
||
"""① 위 층 덮음의 시간당 작업량 식 · 굳은 기계 식 문서 키(부름 닫힌 묶음에 더함 · 848-1)."""
|
||
return mw.cover_calls({mcv.COVER: copy.get(mcv.UPPER) or {}})
|
||
|
||
|
||
def run(doc: dict, copy: dict, given: dict | None = None, whole: Any = None) -> dict:
|
||
"""문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저) · cover = ① + ②(`cover_of`)."""
|
||
try:
|
||
links = ml.Links(whole or over(copy), docs_of(copy))
|
||
return mc.calc(doc, links, given, cover=cover_of(copy, doc))
|
||
except _ERR as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로
|
||
return {"셈됨": False, "표지": [{"갈래": "셈 틀림", "글": str(e)}], **dict.fromkeys(COSTS)}
|
||
|
||
|
||
def money(ans: dict) -> dict | None:
|
||
if not ans.get("셈됨") or "결과" in ans:
|
||
return None
|
||
return {k: ans.get(k) for k in COSTS}
|
||
|
||
|
||
def why(ans: dict) -> str:
|
||
marks = " · ".join(f"{m.get('갈래')} — {m.get('글')}" for m in ans.get("표지") or [])
|
||
return marks or str(ans.get("까닭") or "") or " · ".join((ans.get("빈값") or {}).values())
|
||
|
||
|
||
# ── 줄 규칙을 문서에(켜쌓기율 · 고른 자재 · 별도계상) ────────────────────
|
||
def _qty_scaled(line: dict) -> bool:
|
||
return line.get("수량") is not None or str(line.get("단위") or "") != "식"
|
||
|
||
|
||
def line_doc(doc: dict, rate: Any = None, picks: dict | None = None, apart=()) -> dict:
|
||
"""일위대가 줄 옵션을 문서 규칙으로 — 새 문서(원본 안 고침).
|
||
`picks` = {호표 차례: MT 키} · `apart` = 별도계상 금액 줄 차례."""
|
||
if rate in (None, 100) and not picks and not apart:
|
||
return doc
|
||
doc = cp.deepcopy(doc)
|
||
lines, by_id = doc.get("금액") or [], {md.var_id(v): v for v in doc.get("변수") or []}
|
||
if rate not in (None, 100):
|
||
doc["변수"].append({**RATE, "단위": "%", "연결": {"갈래": "입력", "값": rate}})
|
||
for line in lines:
|
||
if _qty_scaled(line):
|
||
line["수량"] = f"({line.get('수량') or 1}) × {RATE_ID} ÷ 100"
|
||
for at, key in (picks or {}).items():
|
||
n = int(at) if str(at).isdigit() else -1
|
||
var = by_id.get(str(lines[n].get("단가"))) if 0 <= n < len(lines) else None
|
||
link = (var or {}).get("연결") or {}
|
||
if link.get("갈래") == "요소":
|
||
keep = {k: link[k] for k in ("단위", "지역", "계약종별") if link.get(k)}
|
||
var["연결"] = {"갈래": "요소", "키": str(key), **keep}
|
||
for n in apart:
|
||
if 0 <= n < len(lines):
|
||
_apart(doc, lines, n)
|
||
return doc
|
||
|
||
|
||
def _plus(node, cost: str, sym: str):
|
||
"""식 나무 안 `cost`(앞 줄 누계) → (cost + sym)."""
|
||
kind = node[0]
|
||
if kind == "var":
|
||
return ("bin", "+", node, ("var", sym)) if node[1] == cost else node
|
||
if kind == "bin":
|
||
return ("bin", node[1], _plus(node[2], cost, sym), _plus(node[3], cost, sym))
|
||
if kind in ("neg", "pct"):
|
||
return (kind, _plus(node[1], cost, sym))
|
||
if kind == "field":
|
||
return ("field", _plus(node[1], cost, sym), node[2])
|
||
if kind == "call":
|
||
return ("call", node[1], [_plus(x, cost, sym) for x in node[2]])
|
||
return node
|
||
|
||
|
||
def _apart(doc: dict, lines: list[dict], n: int) -> None:
|
||
"""별도계상 = 그 줄 `합밖` · 뒤 줄이 그 비목 누계를 쓰면 그 줄 금액을 더해 씀
|
||
(옛 엔진 = 뺀 재료 몫도 「재료비의 %」 밑에 듦 — `M02_Labor_Doc.drop_apart`)."""
|
||
line, cost = lines[n], str(lines[n].get("비목") or "")
|
||
line["합밖"] = True
|
||
if cost not in md.COSTS:
|
||
return
|
||
taken = {md.var_id(v) for v in doc.get("변수") or []} | {str(x.get("기호")) for x in lines}
|
||
sym = str(line.get("기호") or "")
|
||
if not sym:
|
||
sym = next(
|
||
s for k in range(n + 1, n + 99) if (s := md.sym_id("S", f"별도{k}")) not in taken
|
||
)
|
||
line["기호"] = sym
|
||
for later in lines[n + 1 :]:
|
||
for slot in ("수량", "단가"):
|
||
try:
|
||
node = md.parse(later.get(slot))
|
||
except md.DocError:
|
||
continue
|
||
if later.get(slot) not in (None, "") and cost in md.names(node):
|
||
later[slot] = md.text_of(_plus(node, cost, sym))
|
||
|
||
|
||
def given_of(whole: Any, code: str, given: Any, docs: dict | None = None) -> dict:
|
||
"""옛 `run_line` 과 같은 입력 — 빈 입력 = 자동값(`auto_of` · 문서 = `docs` › 값 사본 줄 문서) ›
|
||
받은 값."""
|
||
from M01_MasterData import M01_MasterData_Store as m01
|
||
|
||
try:
|
||
doc = (docs or {}).get(code) or doc_of(whole, code)
|
||
auto = {k: v for k, v in auto_of(doc, whole).items() if v is not None} if doc else {}
|
||
except _ERR:
|
||
auto = {}
|
||
return {**auto, **m01._dec(given or {})}
|
||
|
||
|
||
# ── 자동값(옛 `master_auto.values` 같은 규칙 · 문서에서 · 855-F B9-6) ──────────
|
||
_GUARD = re.compile(r"만약\(\s*(\w+)\s*>\s*0\s*,\s*\1\s*,")
|
||
_INPUTS = ("입력", "선택")
|
||
|
||
|
||
def _num(v: Any) -> Any:
|
||
try:
|
||
return Decimal(str(v)) if not isinstance(v, Decimal) else v
|
||
except ArithmeticError:
|
||
return v
|
||
|
||
|
||
def _fits(whole: Any, ref: str, cond: str) -> list:
|
||
"""표 `ref` 조건 칸 `cond` 에 드는 수 — 낮은 차례 · 범위 칸 = 줄마다 그 줄에 드는 끝."""
|
||
try:
|
||
table = whole.get(ref)
|
||
except _ERR:
|
||
return []
|
||
ranged = (table.get("조건") or {}).get(cond) == "범위"
|
||
out = set()
|
||
for r in table.get("줄") or []:
|
||
if r.get(cond) is None:
|
||
continue
|
||
low, high = r[cond] if ranged else (r[cond], None)
|
||
ends = [Decimal(0) if low is None else low, high]
|
||
out |= {v for v in ends if isinstance(v, Decimal) and ml._match(table, r, cond, v)}
|
||
return sorted(out)
|
||
|
||
|
||
def _lowest(whole: Any, uses: list) -> Any:
|
||
"""같은 입력을 여러 표가 쓰면 모두에 드는 가장 낮은 수 · 없으면 첫 표의 가장 낮은 수."""
|
||
sets = [_fits(whole, ref, cond) for ref, cond in uses]
|
||
both = sorted(set.intersection(*map(set, sets))) if sets else []
|
||
return (both or next((s for s in sets if s), [None]))[0]
|
||
|
||
|
||
def _divisors(doc: dict, ids: dict) -> set[str]:
|
||
"""나누는 자리에 든 이름 — 그 이름이 쓰는 이름(식 · 표 조건 · 단가산출 넘긴 입력)까지 ·
|
||
「만약(X > 0, X, 기본)」 의 X 는 안 퍼뜨림."""
|
||
texts = [x.get("식") for x in doc.get("식") or []]
|
||
texts += [(doc.get("결과") or {}).get("식") if isinstance(doc.get("결과"), dict) else None]
|
||
texts += [x.get(k) for x in doc.get("금액") or [] for k in ("수량", "단가")]
|
||
divs, guard = set(), set()
|
||
for text in (x for x in texts if x not in (None, "")):
|
||
guard |= set(_GUARD.findall(str(text)))
|
||
try:
|
||
divs |= {
|
||
n for p in md.walk(md.parse(text)) if p[:2] == ("bin", "/") for n in md.names(p[3])
|
||
}
|
||
except md.DocError:
|
||
continue
|
||
feeds: dict[str, list] = {}
|
||
for x in doc.get("식") or []:
|
||
feeds.setdefault(md.var_id(x), []).append(x.get("식"))
|
||
for vid, v in ids.items():
|
||
link = v.get("연결") or {}
|
||
part = {"표": "조건", "단가산출": "입력"}.get(str(link.get("갈래")))
|
||
if part:
|
||
feeds.setdefault(vid, []).extend((link.get(part) or {}).values())
|
||
todo = list(divs)
|
||
while todo:
|
||
for text in feeds.get(todo.pop(), []):
|
||
try:
|
||
more = set(md.names(md.parse(text))) - guard - divs
|
||
except md.DocError:
|
||
continue
|
||
divs |= more
|
||
todo += list(more)
|
||
return divs
|
||
|
||
|
||
def auto_of(doc: dict, whole: Any) -> dict:
|
||
"""문서 입력마다 자동값 — 고르기 = 목록 첫째 · 범위 = 아래 끝 · 표 조건 값 = 그 표 가장 낮은
|
||
수 · 나누는 자리 = 1 · 그 밖 0 · 가격(원) 입력 = None(1,521 문서 옛 `master_auto` 와 같음)."""
|
||
ids = {md.var_id(v): v for v in doc.get("변수") or []}
|
||
finds: dict[str, list] = {}
|
||
for v in ids.values():
|
||
link = v.get("연결") or {}
|
||
if link.get("갈래") == "표":
|
||
for col, arg in (link.get("조건") or {}).items():
|
||
if isinstance(arg, str) and arg in ids:
|
||
finds.setdefault(arg, []).append((link.get("표"), col))
|
||
divs = _divisors(doc, ids)
|
||
out: dict[str, Any] = {}
|
||
for vid, v in ids.items():
|
||
link = v.get("연결") or {}
|
||
if link.get("갈래") not in _INPUTS or not v.get("열쇠"):
|
||
continue
|
||
name = str(v["열쇠"])
|
||
if link.get("목록"):
|
||
out[name] = link["목록"][0]
|
||
elif link.get("범위"):
|
||
out[name] = _num(link["범위"][0])
|
||
else:
|
||
got = _lowest(whole, finds.get(vid, []))
|
||
if got is None and "원" in str(v.get("단위") or ""):
|
||
out[name] = None
|
||
else:
|
||
out[name] = got if got is not None else Decimal(1 if vid in divs else 0)
|
||
return out
|
||
|
||
|
||
def apart_of(marks: Any, mats: Any) -> list[int]:
|
||
"""별도계상 금액 줄 차례 — 옛 `drop_apart` 와 같은 판정(엔진 답 `재료` 의 차례 · 자재표시)."""
|
||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||
|
||
marks = marks if isinstance(marks, dict) else {}
|
||
return [
|
||
n
|
||
for m in mats or []
|
||
if isinstance(n := m.get("차례"), int) and labor.apart(marks.get(str(n)))
|
||
]
|
||
|
||
|
||
# ── 찍기 · 갱신 ────────────────────────────────────────────────────────
|
||
def stamp(values: dict | None, keys: list[str], have: dict | None = None) -> dict | None:
|
||
"""값 사본(`skc.snap` 꼴) + 부름 닫힌 묶음 → `수식` 칸 · 값 사본 없음 = None."""
|
||
if not values:
|
||
return None
|
||
whole = over({**values, "부름": {}})
|
||
return {**values_of(values), "부름": closure(whole, keys, have)}
|
||
|
||
|
||
def grow(copy: dict, values: dict | None, keys: list[str]) -> dict:
|
||
"""저장 때 — 새 키(더한 기초 · 줄)만 지금 M01 에서 더함 · 있는 부름 · 값 줄 그대로."""
|
||
rows = skc.grow(values_of(copy), values)
|
||
whole = over({**rows, "부름": {}})
|
||
return {**copy, **rows, "부름": closure(whole, keys, copy.get("부름"))}
|
||
|
||
|
||
def state(copy: dict) -> dict[str, Any]:
|
||
"""{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조
|
||
(문서 = 계산 내용만 · 848-2 `doc_fp`)."""
|
||
got = skc.state(values_of(copy), skc.whole_())
|
||
live, base = folder(), copy.get("원본") or {}
|
||
new = {
|
||
k for k, d in (copy.get("부름") or {}).items() if k in live and doc_fp(d) != doc_fp(live[k])
|
||
}
|
||
if base.get("키") in live and not same_origin(base, live[base["키"]]):
|
||
new.add(base["키"]) # 이 SK 문서를 찍은 M01 문서의 계산 내용이 바뀜
|
||
return {**got, "문서새판": sorted(new)}
|
||
|
||
|
||
def same_origin(base: dict, live: Any) -> bool:
|
||
"""`원본.판` 대 지금 M01 문서 — 계산 내용 지문(`doc_fp`) · 옛 통째 지문(`fp`) 둘 다 받음."""
|
||
return base.get("판") in (doc_fp(live), doc_fp(live, True), fp(live))
|