- 저장본 확인: 층 SK 14 · 문서 `수식고침` · 더한줄 `끊음` · `수식고침` 0 - M02_Sangeun_Equation: `apply` · `on`(M01 Equation edit_row 엔진 고침) · `strict` · `added_inputs` · 메모 지움 → `clean` = 옛 칸 있으면 400(WHY) - M02_Sangeun_Block: `own` · `row_of`(끊은 기초 `mine.logic`) · `strict` · `is_block` 지움 → `clean` = 끊음 · 수식고침 400 - M02_Sangeun_Calc.clean_doc: eqm · blk strict 부름 걷음(바탕 머리 = `_head_of`) · M02_Sangeun_Doc: 고침 더한 입력 거름 걷음 - 시험 test_796_2b: 옛 칸 고침 = 「수식고침」 400 · 화면 TS 파일 글자 보는 시험 걷음(소스 글자 시험 금지) - 검증: 관련 43 파일 + 지킴 + 관문 356 통과 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
273 lines
13 KiB
Python
273 lines
13 KiB
Python
"""M02 단가산출(SK) 셈 — 수식 사본 문서 셈 한 길(PLAN 855 2-C1 · 715-1b · 715-2).
|
|
|
|
셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 ·
|
|
기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 ·
|
|
뺀줄 · 더한줄 · 수식고침 · 식 칸) · 굳힌 옛 사본(수식 사본 없음 · 저장소 0) = 못 셈 + 까닭 하나(옛 엔진 길 ·
|
|
`resolve` 바탕 사슬 걷음 · 855-E 2-E4).
|
|
계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만).
|
|
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 · 바탕 머리 = 기초 문서(855 L2 ⓑ-3).
|
|
SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` ·
|
|
「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} ·
|
|
없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`).
|
|
바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(「별도계상」 고른 줄만 문서 금액 줄 `합밖`).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from decimal import Decimal
|
|
from typing import Any
|
|
|
|
from M02_MasterTemplete import M02_Doc_Sk as dsk # 수식 사본(802-4a)
|
|
from M02_MasterTemplete import M02_Labor_Doc as labor
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
|
from M02_MasterTemplete import M02_Sangeun_Const as const, M02_Sangeun_Copy as skc
|
|
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
|
|
|
COSTS = labor.COSTS
|
|
Ref = dict[str, Any]
|
|
|
|
|
|
def _fail(e: sd.DocError) -> store.StoreError:
|
|
return store.StoreError(e.status, str(e))
|
|
|
|
|
|
def times_of(row: dict) -> Decimal:
|
|
"""결과단위 분모 앞 수(원/10㎡ → 10) — 없으면 1."""
|
|
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
|
|
|
per = combo_store.mu.per(row.get("결과단위")) # 712-2 단위 한 벌
|
|
return per[0][0] if len(per) == 1 else Decimal(1)
|
|
|
|
|
|
def base_unit(row: dict) -> tuple[str, str] | None:
|
|
"""바탕 기준단위 — 「원/100본」 → (「100본」, 「본」) · 분모 없거나 여럿 = None."""
|
|
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
|
|
|
per = combo_store.mu.per(row.get("결과단위"))
|
|
if len(per) != 1:
|
|
return None
|
|
n, u = per[0]
|
|
return (u if n == 1 else f"{format(n, 'f')}{u}", u)
|
|
|
|
|
|
def ratio_of(doc: dict, row: dict, whole: Any) -> Decimal:
|
|
"""SK 배(728-2) — 바탕 기준단위 1 개 = SK 단위 몇 개 · 1 단위 = 기준 ÷ 배 ·
|
|
못 바꿈 = `DocError`."""
|
|
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
|
|
|
mu = combo_store.mu
|
|
got = base_unit(row)
|
|
if got is None:
|
|
return Decimal(1)
|
|
want = str(doc.get("단위") or "").strip()
|
|
want = (
|
|
got[1] if want in ("", "식") else want
|
|
) # 일위대가 줄 · 「식」 = 옛 셈(앞 수 뗀 바탕 단위)
|
|
how = doc.get("환산") or {}
|
|
pick = how.get("단위중량") or {}
|
|
rho = mu.unit_weight(whole, pick.get("종별"), pick.get("형상")) if pick else None
|
|
swap = mu.swap(got[0], want, rho, how.get("계수"))
|
|
if swap["배"] is None:
|
|
raise sd.DocError(f"단가산출 단위 · {swap['근거']}")
|
|
return swap["배"]
|
|
|
|
|
|
def tag_of(whole: Any, code: str) -> str:
|
|
"""꼬리표 = 기초 원문번호(「9-12-1」 · 문서 이름표 855 L2 ⓑ-3) · 없으면 키."""
|
|
try:
|
|
return str(sd.doc_row(whole, code).get("원문번호") or code)
|
|
except Exception: # noqa: BLE001
|
|
return code
|
|
|
|
|
|
def _row_of(doc: dict, whole: Any) -> dict:
|
|
"""배가 읽는 바탕 머리(셈 아님) — 바탕 로직 = 기초 문서 머리(`sd.doc_row` · 855 L2 ⓑ-3) ·
|
|
없음 = 빈 줄(가져온 식 = 그 줄)."""
|
|
key = (doc.get("바탕") or {}).get("로직")
|
|
try:
|
|
return sd.doc_row(whole, key) if key else sd.empty_row(doc)
|
|
except Exception as e: # noqa: BLE001 — 없는 로직
|
|
raise sd.DocError(f"바탕 로직 · {e}") from e
|
|
|
|
|
|
#: 굳힌 옛 사본 SK(수식 사본 없음 · 바탕 로직이 M01 문서에 없음 · 저장소 0) — 옛 엔진 셈 걷음(855-E 2-E4)
|
|
FROZEN_WHY = "굳힌 옛 사본 — 수식 사본 없음 · [재생성] 으로 새로 가져와야 셈"
|
|
|
|
|
|
def run(
|
|
doc: dict,
|
|
whole: Any,
|
|
given: dict | None = None,
|
|
read: Any = refs.read_ref,
|
|
expand: Any = None,
|
|
trail: tuple = (),
|
|
**_opts: Any,
|
|
) -> dict[str, Any]:
|
|
"""SK 셈(저장 안 함 · 855 2-C1) = 수식 사본 문서 셈 한 길 — 기준 · 1 단위 · 줄 · 비목 · 끝수 모두
|
|
문서 답(`M02_Doc_Sk.run`) · 줄 `cid` = 「금액#n」(문서 금액 줄 차례) · 줄 `단위` = 문서 금액 줄 단위 ·
|
|
수식 사본 없음(바탕 참조 · 옛 칸 덮개 · 더한줄 …) = 못 셈 + 까닭 하나(옛 엔진 안 돎 · 올림 없음) ·
|
|
굳힌 옛 사본(`M02_Doc_Sk.frozen`) = 못 셈 + `FROZEN_WHY`(옛 엔진 길 걷음 · 855-E 2-E4).
|
|
`given` · `read` · `expand` · `trail` · `_opts` = 부르는 쪽 꼴 — 문서 셈은 안 씀. 틀린 단위 환산 = `sd.DocError`."""
|
|
whole = skc.over(doc, whole)
|
|
base = doc.get("바탕") or {}
|
|
tag = tag_of(whole, base["로직"]) if "로직" in base else (base.get("참조") or {}).get("키")
|
|
head = {"짝잃음": [], "빠진줄": [], "꼬리표": tag}
|
|
copy = None if dsk.frozen(doc) else dsk.copy_of(doc, whole)
|
|
if copy is None:
|
|
why = FROZEN_WHY if dsk.frozen(doc) else dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY
|
|
none = {"기준": None, "1단위": None, "배": Decimal(1), "줄": [], "정체": []}
|
|
return {**head, **none, "까닭": why, "수식셈": {"셈됨": False, "따로": False, "까닭": why}}
|
|
row = _row_of(doc, whole)
|
|
times = ratio_of(doc, row, whole)
|
|
got = dsk.run(doc, copy, whole)
|
|
money = dsk.dc.money(got)
|
|
total = {k: Decimal(str(v)) for k, v in money.items()} if money else None
|
|
mark = {"셈됨": bool(total), "따로": bool(copy.get("따로"))}
|
|
if not total:
|
|
mark["까닭"] = copy["문서"].get("_틀림") or dsk.dc.why(got) or "돈 아닌 문서"
|
|
src = copy["문서"].get("금액") or []
|
|
lines = [
|
|
{**x, "단위": str((src[n] if n < len(src) else {}).get("단위") or ""), "cid": f"금액#{n}"}
|
|
for n, x in enumerate(got.get("줄") or [])
|
|
]
|
|
out = {
|
|
**head,
|
|
"기준": total,
|
|
"1단위": {k: v / times for k, v in total.items()} if total else None,
|
|
"배": times,
|
|
"줄": lines,
|
|
"정체": [x["cid"] for x in lines],
|
|
"끝수": got.get("끝수"),
|
|
"까닭": None if total or "결과" in got else mark["까닭"],
|
|
"수식셈": mark,
|
|
}
|
|
return out | ({"결과": got["결과"]} if "결과" in got else {})
|
|
|
|
|
|
def unit(doc: dict, whole: Any, expand: Any, trail: tuple) -> dict[str, Any]:
|
|
"""펼침(`Expand`) 한 칸 — `{이름, 단위, 기준(1 단위), 까닭, 줄, 짝잃음}` · 못 셈 = 까닭."""
|
|
head = {"이름": doc.get("이름"), "단위": doc.get("단위")}
|
|
try:
|
|
got = run(doc, whole, None, getattr(expand, "read", refs.read_ref), expand, trail)
|
|
except sd.DocError as e:
|
|
return {**head, "기준": None, "까닭": str(e)}
|
|
gone = got.get("빠진줄") or [] # 굳힌 사본 옛 길 — 빠진 줄 있으면 통째 기준 없음
|
|
why = got.get("까닭") or next((f"「{x['이름']}」 {x['까닭']}" for x in gone), None)
|
|
why = why or (None if got.get("1단위") else "돈 아닌 로직")
|
|
times = got["배"]
|
|
lines = [
|
|
{
|
|
**x,
|
|
"수량": None if x.get("수량") is None else Decimal(str(x["수량"])) / times,
|
|
"금액": None if x.get("금액") is None else Decimal(str(x["금액"])) / times,
|
|
}
|
|
for x in got.get("줄") or []
|
|
]
|
|
return {
|
|
**head,
|
|
"기준": None if gone else got["1단위"],
|
|
"까닭": why,
|
|
"줄": lines,
|
|
"짝잃음": got["짝잃음"],
|
|
}
|
|
|
|
|
|
def per_unit(got: dict, doc: dict) -> dict:
|
|
"""화면 셈 답 줄 · 계 = SK 1 단위 몫(728-2) — 수량 · 금액 · 비목 ÷배(율 · 단가 그대로) ·
|
|
「식」 · 빈 단위(일위대가 줄 모드) = 옛 바탕 몫 그대로."""
|
|
times = got.get("배") or Decimal(1)
|
|
if times == 1 or str(doc.get("단위") or "").strip() in ("", "식"):
|
|
return got
|
|
|
|
def cut(v: Any) -> Any:
|
|
return None if v is None else Decimal(str(v)) / times
|
|
|
|
def one(x: dict) -> dict:
|
|
out = {**x, "금액": cut(x.get("금액"))}
|
|
if "율" not in x:
|
|
out["수량"] = cut(x.get("수량"))
|
|
if x.get("비목"):
|
|
out["비목"] = {k: cut(v) for k, v in x["비목"].items()}
|
|
if x.get("펼침"):
|
|
out["펼침"] = [one(y) for y in x["펼침"]]
|
|
return out
|
|
|
|
lines = [one(x) for x in got.get("줄") or []]
|
|
goods = [one(x) for x in got.get("재료") or []]
|
|
return {**got, "줄": lines, "재료": goods, "기준": got.get("1단위"), "화면배": times}
|
|
|
|
|
|
# ── 저장 ──────────────────────────────────────────────────────────────
|
|
def _check_refs(doc: dict, here_: refs.Here) -> None:
|
|
me = {"층": here_[0], "주인": here_[1], "키": doc["키"]}
|
|
base = doc.get("바탕") or {}
|
|
if "참조" in base:
|
|
base["참조"] = refs.check_ref(base["참조"], "바탕", here_)
|
|
if refs.kind_of(base["참조"]["키"]) != sd.KIND:
|
|
raise store.StoreError(400, "바탕 참조는 단가산출(SK)만")
|
|
for at, one in enumerate(doc.get("더한줄") or [], 1):
|
|
if "참조" in one:
|
|
one["참조"] = refs.check_ref(one["참조"], f"더한줄 {at}째", here_)
|
|
for ref in refs.refs_in(doc):
|
|
if refs.ref_id(ref) == refs.ref_id(me):
|
|
raise store.StoreError(422, f"순환 — 자기 자신을 담음 「{doc['키']}」")
|
|
refs._no_loop(ref, [me, ref])
|
|
|
|
|
|
def _head_of(doc: dict, whole: Any, trail: tuple = ()) -> dict[str, Any]:
|
|
"""저장 검사가 읽는 바탕 머리(855 L2 ⓑ-3 · 로직 줄 안 읽음) — 로직 바탕 = 기초 문서 머리 · 가져온 식 ·
|
|
바탕 없음 = 그 줄(`_row_of`) · 바탕 참조 = 그 SK 의 바탕 머리(순환 · 깊이 422) · 옛 칸 고침을 바탕
|
|
줄에 얹던 사슬(`resolve`) 걷음(855-E 2-E4)."""
|
|
ref = (doc.get("바탕") or {}).get("참조")
|
|
if not isinstance(ref, dict):
|
|
return {"줄": _row_of(doc, whole), "짝잃음": []}
|
|
rid = refs.ref_id(ref)
|
|
if rid in trail:
|
|
keys = [x.rsplit("|", 1)[-1] for x in (*trail, rid)]
|
|
raise sd.DocError("순환 — " + " → ".join(keys), 422)
|
|
if len(trail) >= refs.DEPTH:
|
|
raise sd.DocError(f"바탕 사슬이 {refs.DEPTH}단을 넘음", 422)
|
|
parent = refs.read_ref(ref)
|
|
if not isinstance(parent, dict):
|
|
raise sd.DocError(f"없는 바탕 「{ref.get('키')}」")
|
|
return _head_of(parent, whole, (*trail, rid))
|
|
|
|
|
|
def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]:
|
|
"""저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 가져온 식 검산 · 서버가 적던
|
|
`바탕판` · `M01판` · 옛 칸 덮개 · 둘째 기초 `원값` 은 걷음(855 2-C1 · 2-D · L2 ⓑ-3)."""
|
|
raw, job = doc, doc.get(skc.JOB) if isinstance(doc, dict) else None # 수식 사본(802-4a)
|
|
whole = skc.over(doc := skc.settle(doc, True), skc.whole_()) # 사본(795-1) · 내 기계(821-1)
|
|
try:
|
|
rough = sd.clean(doc, None, whole)
|
|
_check_refs(rough, here_)
|
|
base = _head_of(rough, whole)
|
|
out = sd.clean(doc, base["줄"], whole)
|
|
out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"]
|
|
for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량
|
|
one.setdefault("처음수량", one["수량"])
|
|
const.stamp(out) # 가져온 식 검산(793-2)
|
|
ratio_of(out, base["줄"], whole) # 단위 못 바꿈(계수 없음) = 저장 막음(728-2)
|
|
out = dsk.settle(out, whole, job, raw)
|
|
except sd.DocError as e:
|
|
raise _fail(e) from e
|
|
return out
|
|
|
|
|
|
def calc_doc(doc: Any, given: dict | None = None) -> dict[str, Any]:
|
|
"""문서 셈 묶음(저장 안 함 · 지금 층) — 꼴 검사 · 위 층 참조 · 순환 422 → `run` → 1 단위 몫 · 사본 표지 ·
|
|
틀림 400(옛 화면 셈 길 `/sangeun/calc` 은 걷음 · 855 2-E2)."""
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
|
|
with m01.cache.steady(): # 한 셈 동안 M01 파일 자국 한 번(792-2)
|
|
whole = skc.over(doc := skc.settle(doc), skc.whole_()) # 사본(795-1) · 내 기계(821-1)
|
|
try:
|
|
clean = sd.clean(doc, None, whole)
|
|
_check_refs(clean, refs.here()) # 저장 전 문서도 위 층만 · 있는 문서 · 순환 422
|
|
me = refs.ref_id({"층": refs.here()[0], "주인": refs.here()[1], "키": clean["키"]})
|
|
got = run(clean, whole, given, trail=(me,))
|
|
except sd.DocError as e:
|
|
raise _fail(e) from e
|
|
return skc.mark(const.answer(got, clean), clean) # 795-1
|