Files
Aislo/M02_MasterTemplete/M02_Library_Flat.py
T
eomsangdonandClaude Opus 5.5 3a7320ac71 refactor(855-E L2ⓑ-3): 단가산출 줄 규칙 열쇠 = 「금액#n」(수식 문서 금액 줄 차례) — 로직 줄 cid 걷음
- Sangeun_Doc: 고름 · 자재표시 열쇠 「금액#n」(AMOUNT · amount_key · amount_at) · 옛 cid 꼴 받으면 400
- Doc_Sk.derive: 열쇠를 문서 금액 줄 차례로 바로 · 재료 줄 = Item_Prices._mat_lines · 입력 이름 = doc_row · 옛 cid 저장본 = 못 셈 + 까닭(RULE_WHY · 호환 없음)
- Labor_Patch.as_doc · Labor_SkRow.logic_doc([+ 줄]) · Library_Flat.sk_line: 일위대가 줄 차례 「n」 ↔ 「금액#n」 · 재료 줄 = 문서(로직 줄 안 읽음 · sub5 L2ⓑ-2 에서 넘겨받은 자리)
- Library_Flat.compose: cid 옮김 겹침 걷음 → 줄 규칙 · 입력값 사전 겹침 · 옛 칸 든 겹침 = 못 펼침 · 줄 덮개 있는 SK 참조 줄 = 못 펼침(patch.WHY)
- 저장본 줄 규칙 든 SK 0 · 셈 답 1,541(지은 파생 SK · [+ 줄] SK · SK → 일위대가 줄 열쇠 · 셈) 다름 0
- M01 로직 줄 읽힘(내 몫 + 넘겨받은 셋) 6,610 → 0
- 시험: test_715_sangeun_doc 둘(drop_keeps_pick · chain_moves_base_picks) · test_715_sangeun_store layer_copy_round_trip · test_778_4 겹침_율_열쇠 지움 — cid 고름 + 뺀줄 · 덮개 겹침(옛 칸 · 못 셈)만 붙듦 · test_715 lost_covers 고름 단언 걷음 · test_747_1 PLY 열쇠 금액#2 · 새 test_855_l2b3_rule_keys(별도계상 계 밖 · 옛 cid 400 · 못 셈 · 오감 금액 같음)

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

521 lines
25 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) · 일위대가(SC) 펼침 · 초기화 · 옮기기(PLAN 740-1 · 요구 581 · 분석 579-2).
서로 독립 — 연결 고리 = M01 키만. M02 문서를 넣으면(저장 · 읽기 · 층 사이
복사) 그 문서 몸을 M01 키 줄 + 그 문서 덮개 사본으로 펼쳐 담음 → 원본이 나중에 바뀌어도
넣은 쪽 금액 그대로. 줄 `본뜬 {층, 주인, 키, 이름, 때}` = 출처 정보(셈에 안 씀).
SK 에 SK 더한줄 로직 한 줄 = 원본 몸 통째(바탕 기초 · 입력값 · 덮개 · 뺀줄 · 고름 · 자재표시 ·
켜쌓기율 · 더한줄 — `M02_Sangeun_Doc.BODY` · % 덧줄까지 같은 금액) ·
수량 = 넣은 수 ÷ 배(728 환산) · 바탕 없는 SK = 그 더한줄 × 넣은 수
SK 에 SC SC 줄마다 더한줄(로직 줄 = 로직 한 줄 + 패치 몸 · 고정 · 자재 = 재료) ·
수량 = 넣은 수 × 줄 수량(저장 `수량.손` › 실무수량 › 1 · 742-1) ÷ 배(물량 알약 배)
SC 에 SK 811-1 — 층 문서(저장 · 읽기 · 복사)는 참조 한 행 그대로(펼치지 않음 · 셈 = SK × 수량) ·
SK 에 SC 를 넣을 때 그 SC 안 SK 줄만 아래처럼 로직 줄 하나 + 패치(= SK 몸) · 별칭 = SK 이름 ·
바탕 없는 SK · 단위 환산 SK = 못 넣음(값 단위가 달라짐)
SC 에 SC 사본 블록 — 안쪽 SC 몸 통째(M01 키 줄 + 덮개 · 실무수량)를 그 줄 참조 꼴
`{층: 사본, 주인: 몸 지문, 키: 본 SC, 몸}` 에 담음(`M02_Labor_Ref.copy_ref` · 원본
연결 없음 · 하위 호표 끝수 단계 · B09 하위 대가 블록 그대로 · 같은 기초 겹침도
블록 안)
바탕 SK 참조 = 줄 규칙 · 입력값을 겹쳐 한 벌(`compose`) · 옛 칸 고침 든 겹침 · 패치 있는 SK 참조 줄 =
못 펼침(옛 칸 · 못 셈 855 L2 ⓑ-3)
율 줄(778-4) 있는 바탕 없는 SK = 한 줄로 못 펼침(율 · 기준 묶음이 넣는 쪽 줄로 번짐) → 참조 그대로
못 펼친 줄 = 저장 · 읽기 · 옮기기에선 옛 참조 그대로(값 그대로) · `strict` = 400 까닭(옛 찾아 넣기 `-flat` 길은 걷음 · 855 2-E2).
초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸 · 사본 블록까지) · 이음 기계 고정 줄
단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 ·
기본정보 남김 → 값 = 연결된 M01 키 값.
한 번용 옮기기(`migrate`)는 끝나 걷음(894).
기초 이름 · 결과단위 · 입력 이름 · 재료 줄 차례 = M01 수식 문서(855 L2 ⓑ · `_doc`) · SK 고름 · 자재표시
「금액#n」 ↔ 일위대가 줄 차례 「n」(`sk_line` · 로직 줄 안 읽음).
"""
from __future__ import annotations
import json
import time
from decimal import Decimal
from typing import Any
from M01_MasterData import M01_MasterData_Doc as m01doc
from M02_MasterTemplete import M02_Labor_Fixed as fixed
from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
FAIL = (ArithmeticError, KeyError, TypeError, ValueError) # 못 펼침(DocError · FormulaError 포함)
EMPTY = (None, {}, [], "")
Read = Any
def _whole() -> Any:
from M01_MasterData import M01_MasterData_Store as m01
return m01.loaded()[1]
def _doc(code: Any) -> dict:
"""기초 키 → 수식 문서 · 없거나 로직 아닌 키 = 옛 `Master.logic` 과 같은 `FormulaError`."""
m01doc.head(str(code))
return m01doc.docs()[str(code)]
def _names(doc: dict) -> set[str]:
return {s["이름"] for s in labor_inputs.specs(doc)}
def _d(value: Any) -> Decimal:
return Decimal(str(value))
def mark(ref: refs.Ref, doc: dict) -> dict[str, Any]:
"""줄 출처 — 펼친 원본 {층, 주인, 키, 이름, 때(UTC)}."""
when = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
return {
**{k: ref.get(k) for k in ("층", "주인", "키")},
"이름": doc.get("이름") or "",
"때": when,
}
def _read(ref: refs.Ref, read: Read, trail: tuple) -> tuple[dict, tuple]:
rid = refs.ref_id(ref)
if rid in trail:
raise sd.DocError("순환 — " + " → ".join(t.rsplit("|", 1)[-1] for t in (*trail, rid)), 422)
if len(trail) >= refs.DEPTH:
raise sd.DocError(f"참조가 {refs.DEPTH}단을 넘음", 422)
got = read(ref)
if not isinstance(got, dict):
raise sd.DocError(f"없는 참조 「{ref.get('키')}」")
const.no_flat(got) # 상수 · 표값 덮개 SK = 안 펼침(790-2)
return got, (*trail, rid)
# ── SK ────────────────────────────────────────────────────────────────
def flat_sk(doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool = True) -> dict:
"""SK 문서 → M01 키만(더한줄 참조 펼침 · 바탕 참조 겹침) · `strict` False = 못 펼친 줄
그대로."""
adds = []
for one in doc.get("더한줄") or []:
ref = one.get("참조") if isinstance(one, dict) else None
if not isinstance(ref, dict):
adds.append(one)
continue
try:
adds += into_sk(ref, one.get("수량", 1), read, whole, trail)
except FAIL as e:
if strict:
raise sd.DocError(f"「{ref.get('키')}」 · {e}") from e
adds.append(one)
out = {**doc, "더한줄": adds}
base = doc.get("바탕") or {}
if isinstance(base.get("참조"), dict):
try:
under, path = _read(base["참조"], read, trail)
under = flat_sk(sd.clean(under, None, whole), read, whole, path)
out = compose(under, out)
except FAIL:
if strict:
raise
return out
def into_sk(ref: refs.Ref, qty: Any, read: Read, whole: Any, trail: tuple = ()) -> list[dict]:
"""SK 에 넣을 더한줄 — 넣는 문서(SK · SC)를 M01 키 줄로(`qty` = 그 문서 단위 수)."""
src, path = _read(ref, read, trail)
kind, q, tag = refs.kind_of(ref.get("키")), _d(qty), mark(ref, src)
src = sd.clean(src, None, whole) if kind == "sangeun" else src
if kind == "sangeun":
return sk_adds(flat_sk(src, read, whole, path), q, whole, tag)
if kind == "precombo":
return sc_adds(flat_sc(src, read, whole, path), q, whole, tag)
raise sd.DocError("옛 단가승격은 펼치지 않음")
def filled_adds(doc: dict, whole: Any) -> list[dict]:
"""더한줄 로직 빈 입력 = 그 SK 입력값(셈 `_fill` 의 공통 옵션 몫) — 옮겨도 같은 옵션."""
common, out = doc.get("입력값") or {}, []
for one in doc.get("더한줄") or []:
if one.get("종류") == "로직":
try:
names = list(_names(_doc(one["로직"])))
except Exception: # noqa: BLE001 — 없는 로직 = 검사 · 셈이 까닭
names = []
mine = dict(one.get("입력값") or {})
for n in names:
if mine.get(n) in EMPTY and common.get(n) not in EMPTY:
mine[n] = common[n]
one = {**one, "입력값": mine}
out.append(one)
return out
def _scaled(one: dict, q: Decimal, tag: dict) -> dict:
return {**one, "수량": sd.plain(_d(one.get("수량") or 0) * q), "본뜬": tag}
def sk_adds(y: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]:
"""펼친 SK → 더한줄 — 바탕 기초 있으면 한 줄(몸 통째) · 없으면 그 더한줄 × q."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
adds = filled_adds(y, whole)
code = (y.get("바탕") or {}).get("로직")
if not code and any(sd.is_rate(one) for one in adds):
raise sd.DocError("율 줄 있는 바탕 없는 단가산출은 펼쳐 넣지 못함 — 참조로 둠")
if not code:
return [_scaled(one, q, tag) for one in adds]
row = _doc(code)
names = _names(row)
unit = calc.base_unit(row)
entry: dict[str, Any] = {
"종류": "로직",
"로직": code,
"이름": y.get("이름") or code,
"단위": unit[0] if unit else "",
"수량": sd.plain(q / calc.ratio_of(y, row, whole)),
"입력값": {k: v for k, v in (y.get("입력값") or {}).items() if k in names},
}
entry |= {
k: y[k] for k in ("덮개", "뺀줄", "고름", "자재표시", "켜쌓기율") if y.get(k) not in EMPTY
}
return [{**entry, **({"더한줄": adds} if adds else {}), "본뜬": tag}]
def _hand(one: dict, kept: Any) -> Decimal:
"""SC 안 줄 수량 — 저장 `수량.손`(742-1 사용자 입력) › 실무수량 › 1."""
raw = one.get("수량")
got = raw.get("손") if isinstance(raw, dict) else None
return _d(got if got not in EMPTY else kept if kept not in EMPTY else 1)
def sc_adds(z: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]:
"""펼친 SC → SK 더한줄 — 줄 수량 = q × `_hand` · 로직 줄 ÷ 물량 알약 배."""
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Sangeun_Calc as calc
hands = (z.get("본뜬") or {}).get("실무수량") or {}
lines, mats = hands.get("줄") or {}, hands.get("자재") or {}
out = []
for at, one in enumerate(z.get("담은로직") or []):
n = q * _hand(one, lines.get(str(at)))
if one.get("로직"):
row = _doc(one["로직"])
body = patch.as_doc(one, whole)
entry = {
"종류": "로직",
"로직": one["로직"],
"이름": one.get("별칭") or row.get("이름") or "",
}
entry |= {"수량": sd.plain(n / calc.times_of(row)), "입력값": body["입력값"]}
keep = ("덮개", "뺀줄", "고름", "자재표시", "켜쌓기율", "더한줄")
entry |= {k: body[k] for k in keep if body.get(k) not in EMPTY}
elif fixed.is_fixed(one) and not refs.is_rate(one):
entry = {
"고정": one["고정"],
"이름": one["고정"].get("이름") or "",
"수량": sd.plain(n),
}
elif refs.is_copy(one.get("참조")): # 하위 호표 사본 블록 = 그 줄들도 더한줄로
out += sc_adds(one["참조"]["몸"], n, whole, tag)
continue
else:
raise sd.DocError("비율 고정 줄 · 참조 줄은 단가산출에 못 담음")
out.append({**entry, "본뜬": tag})
for mat in z.get("자재") or []:
code = str(mat.get("코드") or "")
if not code.startswith("MT"):
raise sd.DocError(f"개인 자재 「{code}」 는 단가산출에 못 담음")
n = q * _hand(mat, mats.get(code))
one = {
"종류": "재료",
"요소": code,
"이름": mat.get("이름") or "",
"단위": mat.get("단위") or "",
}
apart = {"별도계상": True} if mat.get("별도계상") == "별도계상" else {}
out.append({**one, "수량": sd.plain(n), **apart, "본뜬": tag})
return out
# ── 겹침(바탕 SK 참조) ───────────────────────────────────────────────────
def compose(under: dict, over: dict) -> dict:
"""펼친 바탕 SK `under` 위에 `over` → 한 벌 — 줄 규칙(고름 · 자재표시 「금액#n」 = 같은 기초 문서
자리) · 입력값 = 위 것이 덮음 · 옛 칸 고침(덮개 · 뺀줄 · 더한줄 …) 든 쪽 = 못 펼침(855 L2 ⓑ-3 —
cid 옮김 겹침 걷음 · 로직 줄 안 읽음)."""
from M02_MasterTemplete import M02_Doc_Sk as dsk # 늦게 — dsk 가 이 파일을 거쳐 부름
const.no_flat(over) # 위 상수 · 표값 덮개 자리 = 못 겹침(790-2)
if dsk.patched(under) or dsk.patched(over):
raise sd.DocError(dsk.OLD_WHY)
out = {**over, "바탕": under.get("바탕")}
for name in ("고름", "자재표시", "입력값"):
out[name] = {**(under.get(name) or {}), **(over.get(name) or {})}
rate = over.get("켜쌓기율", under.get("켜쌓기율"))
return out | ({"켜쌓기율": rate} if rate is not None else {})
# ── SC ────────────────────────────────────────────────────────────────
def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict:
"""펼친 SK → 일위대가 로직 줄 하나(+ 패치) — 옛 참조 줄 `one` 의 별칭 · 메모 · 수량 · 패치
이어받음."""
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if one.get(patch.FIELD): # 줄 덮개(옛 칸) = 못 셈 · 겹침 걷음(855 L2 ⓑ-3)
raise sd.DocError(patch.WHY)
code = (y.get("바탕") or {}).get("로직")
if not code:
raise sd.DocError("바탕 기초 없는 단가산출은 일위대가 줄로 못 담음 — 그 안 줄을 따로 넣음")
doc = _doc(code)
if calc.ratio_of(y, doc, whole) != calc.times_of(doc):
raise sd.DocError("단위 환산 단가산출은 일위대가 줄로 못 담음(값 단위가 바뀜)")
names = _names(doc)
body = {k: y[k] for k in ("덮개", "뺀줄") if y.get(k) not in EMPTY}
body |= {"더한줄": adds} if (adds := filled_adds(y, whole)) else {}
line: dict[str, Any] = {
"로직": code,
"입력값": {k: v for k, v in (y.get("입력값") or {}).items() if k in names},
"별칭": one.get("별칭") or y.get("이름"),
"메모": one.get("메모"),
"수량": one.get("수량"),
}
for name in ("고름", "자재표시"): # SK 「금액#n」 → 일위대가 줄 차례 「n」(855 L2 ⓑ-3)
rules = ((sd.amount_at(c), v) for c, v in (y.get(name) or {}).items())
if got := {str(n): v for n, v in rules if n is not None}:
line[name] = got
shown = line.get("자재표시") or {}
for n, _, _ in prices._mat_lines(doc): # 747-1 SK 재료 빈 칸 = 직접계산 → 적어 둠
shown[str(n)] = {"별도계상": "직접계산", **labor.marks(shown.get(str(n)))}
line |= {"자재표시": shown} if shown else {}
if y.get("켜쌓기율") is not None:
line["켜쌓기율"] = y["켜쌓기율"]
return {**line, **({patch.FIELD: body} if body else {}), "본뜬": tag}
def _ids(doc: dict) -> list[Any]:
from M02_MasterTemplete import M02_Labor_Doc as labor
lines = [labor.line_id(x) for x in doc.get("담은로직") or [] if isinstance(x, dict)]
return lines + [f"자재|{m.get('코드')}" for m in doc.get("자재") or [] if isinstance(m, dict)]
def _twice(doc: dict) -> str | None:
seen: set[str] = set()
for one in _ids(doc):
key = json.dumps(one, ensure_ascii=False, sort_keys=True, default=str)
if key in seen:
return str(one)
seen.add(key)
return None
def flat_sc(
doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool = True, sk: bool = True
) -> dict:
"""SC 문서 → M01 키만 — SK 참조 = 로직 줄 + 패치(같은 자리) · SC 참조 = 사본 블록(같은 자리) ·
`strict` False = 못 펼친 줄 그대로(겹침 · 바탕 없음 · 환산 · 없는 참조) ·
`sk` False = SK 참조 줄은 참조 한 행 그대로(811-1 · 층 문서 저장 · 읽기 · 복사)."""
lines = []
for at, one in enumerate(doc.get("담은로직") or []):
ref = one.get("참조") if isinstance(one, dict) else None
kind = refs.kind_of(ref.get("키")) if isinstance(ref, dict) else None
keep = kind == "sangeun" and not sk
if kind not in ("sangeun", "precombo") or refs.is_copy(ref) or keep:
lines.append(one)
continue
try:
src, path = _read(ref, read, trail)
tag = mark(ref, src)
if kind == "sangeun":
y = flat_sk(sd.clean(src, None, whole), read, whole, path)
put = sk_line(y, one, whole, tag)
else:
body = flat_sc(src, read, whole, path)
put = {**one, "참조": refs.copy_ref(body, ref["키"]), "본뜬": tag}
rest = (doc.get("담은로직") or [])[at + 1 :]
trial = {"담은로직": [*lines, put, *rest], "자재": doc.get("자재") or []}
if twice := _twice(trial):
raise sd.DocError(f"같은 줄이 겹침 「{twice}」 — 펼쳐 넣지 못함")
except FAIL as e:
if strict:
raise sd.DocError(f"「{ref.get('키')}」 · {e}") from e
put = one
lines.append(put)
return {**doc, "담은로직": lines}
# ── 문 ────────────────────────────────────────────────────────────────
def flat_doc(
kind: str, doc: Any, read: Read = refs.read_ref, strict: bool = False, me: Any = None
) -> Any:
"""층 문서 하나 펼침(저장 · 읽기 · 복사 · 옮기기) — 참조 없으면 받은 그대로 · `me` = 이 문서
참조(자기 자신을 담은 줄 = 안 펼침 → 저장 검사가 422)."""
if not isinstance(doc, dict) or kind not in refs.PREFIX or not refs.refs_in(doc):
return doc
whole, trail = _whole(), (refs.ref_id(me),) if isinstance(me, dict) else ()
if kind == "sangeun":
return flat_sk(doc, read, whole, trail, strict)
return flat_sc(doc, read, whole, trail, strict, sk=False) # 811-1 SK 줄 = 참조 한 행
# ── 초기화 ────────────────────────────────────────────────────────────
def _reprice(fx: dict) -> tuple[dict, int]:
"""이음 기계 고정 줄(736-3) 단가 = M01 기계 한 시간 값 다시 받음 — (줄, 바뀐 수)."""
from M02_MasterTemplete import M02_Machine_Hourly as machine
key = (fx.get("이음") or {}).get("기계")
got = machine.hourly(str(key)) if key else {}
if not got.get("ok"):
return fx, 0
price = {k: got[k] for k in sd.PARTS.values()}
return {**fx, "단가": price}, int(price != fx.get("단가"))
def _reset_adds(adds: list) -> tuple[list, int]:
out, n = [], 0
for one in adds or []:
one = dict(one) if isinstance(one, dict) else one
if not isinstance(one, dict):
out.append(one)
continue
if "단가" in one:
one.pop("단가")
n += 1
n += len(one.pop("덮개", None) or {}) + len(one.pop("뺀줄", None) or [])
one.pop("바탕판", None)
if one.get("더한줄"):
one["더한줄"], k = _reset_adds(one["더한줄"])
n += k
if isinstance(one.get("고정"), dict):
one["고정"], k = _reprice(one["고정"])
n += k
out.append(one)
return out, n
def _reset_sc(doc: dict) -> tuple[dict, int]:
"""일위대가 초기화 — 줄 패치 · 사본 블록 몸 · 이음 기계 고정 줄."""
from M02_MasterTemplete import M02_Labor_Patch as patch
lines, n = [], 0
for one in doc.get("담은로직") or []:
if not isinstance(one, dict):
lines.append(one)
continue
ref, body = one.get("참조"), one.get(patch.FIELD)
if refs.is_copy(ref):
inner, k = _reset_sc(ref["몸"])
n += k
one = {**one, "참조": refs.copy_ref(inner, ref["키"])}
elif isinstance(one.get("고정"), dict):
fx, k = _reprice(one["고정"])
n += k
one = {**one, "고정": fx}
elif body:
adds, k = _reset_adds(body.get("더한줄") or [])
n += k + len(body.get("덮개") or {}) + len(body.get("뺀줄") or [])
keep = {x: v for x, v in body.items() if x not in ("덮개", "뺀줄", "더한줄")}
rest = {**keep, **({"더한줄": adds} if adds else {})}
one = {x: v for x, v in one.items() if x != patch.FIELD}
one = {**one, **({patch.FIELD: rest} if rest else {})}
lines.append(one)
return {**doc, "담은로직": lines}, n
_OPT_KINDS = ("입력", "선택")
def _options(mine: dict) -> dict:
"""수식 문서 옵션 값 {열쇠: 값}(입력 · 선택)."""
return {
v["열쇠"]: v["연결"]["값"]
for v in mine.get("변수") or []
if isinstance(v, dict) and v.get("열쇠") and (v.get("연결") or {}).get("갈래") in _OPT_KINDS
and "값" in (v.get("연결") or {})
} # fmt: skip
def formula_edits(doc: dict) -> list[str]:
"""수식 길 고침(889) — 줄 · 식 고친 문서 · 끊은 부름 · 기계 고침 목록(가져온 식 = 불러온 그대로 대비 · 848-7 ·
바탕 기초 없는 SK = 없음 · 같게 할 기초가 없어 줄을 지키고 기계 고침은 줄마다 되돌림) ·
줄 · 식 판정 = 셈 칸 지문(`doc_fp` · 이름 · 글 칸 뺌) · 옵션 값은 남기니 판정에서 뺌."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Import as imp
if imp.is_imported(doc): # 848-7 가져온 식 = 「불러온 그대로」 대비
from M02_MasterTemplete import M02_Doc_Import_Reset as imported
return imported.edits(doc)
got = doc.get(dc.KEY) if dc.has(doc) else None
if not got or not (doc.get("바탕") or {}).get("로직"):
return []
mine, first = got.get("문서") or {}, got.get("처음")
def calc_fp(d: dict) -> str:
rows = [
{**v, "연결": {k: x for k, x in v["연결"].items() if k != "값"}}
if isinstance(v, dict) and (v.get("연결") or {}).get("갈래") in _OPT_KINDS
else v
for v in d.get("변수") or []
]
return dc.doc_fp({**d, "변수": rows})
covers = {**(got.get("기계덮음") or {}), **(mine.get("기계덮음") or {})}
items = [f"기계 고침 — {k}" for k in sorted(covers)]
items += [f"끊은 부름 — {k}" for k in sorted(got.get("끊음") or {})]
if got.get("따로") and (not isinstance(first, dict) or calc_fp(mine) != calc_fp(first)):
items.insert(0, "수식 문서 고침(줄 · 식)")
return items
def _imported(doc: dict) -> bool:
from M02_MasterTemplete import M02_Doc_Import as imp
return imp.is_imported(doc)
def reset(kind: str, doc: dict) -> tuple[dict, int]:
"""[초기화] — (걷은 문서, 걷힌 고침 수) · 먼저 펼침(옛 참조 줄도 M01 키로) ·
SK 수식 길 고침(따로 문서 · 끊음 · 기계 고침 · 889) = 재생성 할일로 함께 걷음(그 기초와 같게) ·
수식 문서 옵션 값 = 입력값으로 옮겨 남김(옵션 · 기본정보 그대로)."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Doc_Import_Reset as imported
doc = flat_doc(kind, doc)
if kind == "sangeun" and _imported(doc): # 848-7 = 불러온 그대로(단가 기준 그대로)
return imported.reset(doc)
if kind == "sangeun":
adds, n = _reset_adds(doc.get("더한줄") or [])
n += const.covers_n(doc) # 덮개 · 뺀줄(까닭 같이)
items = formula_edits(doc)
out = {**const.restore(doc), "더한줄": adds}
if items:
opts = _options((doc.get(dc.KEY) or {}).get("문서") or {})
out |= {skc.JOB: skc.REGEN, "입력값": {**(doc.get("입력값") or {}), **opts}}
return out, n + len(items)
return _reset_sc(doc)
def reset_doc(kind: str, key: str | None, doc: Any, look: bool, version: str | None) -> dict:
"""`-reset` 길 — 미리 보기 = 걷힐 수 · 수식 길 목록 · 아니면 지금 층에 씀(판이 오면 그 판일 때만)."""
from M02_MasterTemplete import M02_MasterTemplete_Store as store
if doc is None:
if not key:
raise store.StoreError(400, "문서 또는 키")
found = store.read(kind, key)
doc, version = found["문서"], version or found["판"]
if not isinstance(doc, dict):
raise store.StoreError(400, "문서가 묶음 아님")
got, n = reset(kind, doc)
if look:
items = formula_edits(doc) if kind == "sangeun" else []
return {"걷힘": n, "목록": items, "문서": got}
name = str(got.get("키") or key or "")
if not version:
version = store.read(kind, name)["판"]
store.write(kind, name, version, got)
return {"걷힘": n, "문서": store.read(kind, name)["문서"]}