|
|
|
@@ -2,8 +2,8 @@
|
|
|
|
|
|
|
|
|
|
셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 ·
|
|
|
|
|
기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 ·
|
|
|
|
|
뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` ·
|
|
|
|
|
`resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀).
|
|
|
|
|
뺀줄 · 더한줄 · 수식고침 · 식 칸) · 굳힌 옛 사본(수식 사본 없음 · 저장소 0) = 못 셈 + 까닭 하나(옛 엔진 길 ·
|
|
|
|
|
`resolve` 바탕 사슬 걷음 · 855-E 2-E4).
|
|
|
|
|
계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만).
|
|
|
|
|
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 · 바탕 머리 = 기초 문서(855 L2 ⓑ-3).
|
|
|
|
|
SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` ·
|
|
|
|
@@ -14,14 +14,11 @@ SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(
|
|
|
|
|
|
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
|
|
|
|
import hashlib
|
|
|
|
|
import json
|
|
|
|
|
import re
|
|
|
|
|
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, M02_Labor_Fixed as fixed
|
|
|
|
|
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_Block as blk
|
|
|
|
@@ -30,28 +27,6 @@ from M02_MasterTemplete import M02_Sangeun_Doc as sd, M02_Sangeun_Equation as eq
|
|
|
|
|
|
|
|
|
|
COSTS = labor.COSTS
|
|
|
|
|
Ref = dict[str, Any]
|
|
|
|
|
_SHARED = ("_market", "_by_class", "_found") # 마스터에만 따르는 자재 색인 · 찾기 답
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class _Over:
|
|
|
|
|
"""M01 색인 위에 고친 줄 하나 — `logic(키)` 만 가로챔(그 밖 그대로 · 색인 안 고침)."""
|
|
|
|
|
|
|
|
|
|
def __init__(self, whole: Any, key: str, row: dict) -> None:
|
|
|
|
|
self._whole, self._key, self._row = whole, key, row
|
|
|
|
|
|
|
|
|
|
def logic(self, ref: str) -> dict:
|
|
|
|
|
return self._row if ref == self._key else self._whole.logic(ref)
|
|
|
|
|
|
|
|
|
|
def __getattr__(self, name: str) -> Any:
|
|
|
|
|
return getattr(self._whole, name)
|
|
|
|
|
|
|
|
|
|
def __setattr__(self, name: str, value: Any) -> None:
|
|
|
|
|
"""자재 색인(`master_material`)은 속 M01 색인에 둠 — 셈마다 다시 안 지음(792-2) ·
|
|
|
|
|
M01 파일 자국이 바뀌면 새 색인 = 새로 지음 · 그 밖은 이 덮개에만."""
|
|
|
|
|
if name in _SHARED:
|
|
|
|
|
setattr(self._whole, name, value)
|
|
|
|
|
else:
|
|
|
|
|
super().__setattr__(name, value)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _fail(e: sd.DocError) -> store.StoreError:
|
|
|
|
@@ -99,153 +74,6 @@ def ratio_of(doc: dict, row: dict, whole: Any) -> Decimal:
|
|
|
|
|
return swap["배"]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def fingerprint(row: dict) -> str:
|
|
|
|
|
raw = json.dumps(row, ensure_ascii=False, sort_keys=True, default=str)
|
|
|
|
|
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# ── 바탕 사슬 → 고친 줄 ─────────────────────────────────────────────────
|
|
|
|
|
def _base_of(doc: dict, whole: Any, read: Any, trail: tuple[str, ...]) -> dict[str, Any]:
|
|
|
|
|
"""이 SK 가 얹힐 바탕 — {줄, 고름, 자재표시, 입력값, 켜쌓기율, 짝잃음}."""
|
|
|
|
|
base = doc.get("바탕")
|
|
|
|
|
empty = {"고름": {}, "자재표시": {}, "입력값": {}, "켜쌓기율": None, "짝잃음": []}
|
|
|
|
|
if not base or "로직" in base: # 사본(795-1) · 가져온 식 · 그 위 수식 고침(796-2b)
|
|
|
|
|
try:
|
|
|
|
|
row = skc.over(doc, whole).logic(base["로직"]) if base else sd.empty_row(doc)
|
|
|
|
|
except Exception as e: # noqa: BLE001 — 엔진 FormulaError
|
|
|
|
|
raise sd.DocError(f"바탕 로직 · {e}") from e
|
|
|
|
|
if any(x.get("참조") for x in row.get("호표") or []): # 가져온 식 안쪽 산근(797-1) 값 채움
|
|
|
|
|
from M02_MasterTemplete.M02_Labor_Expand import Expand
|
|
|
|
|
|
|
|
|
|
row = {**row, "호표": [dict(x) for x in row["호표"]]}
|
|
|
|
|
_bundles(row, whole, Expand(whole, read), trail)
|
|
|
|
|
row, lost = eqm.on(row, doc, skc.over(doc, whole))
|
|
|
|
|
return {**empty, "줄": row, "짝잃음": lost}
|
|
|
|
|
ref = base["참조"]
|
|
|
|
|
rid = refs.ref_id(ref)
|
|
|
|
|
if rid in trail:
|
|
|
|
|
keys = [t.rsplit("|", 1)[-1] for t in (*trail, rid)]
|
|
|
|
|
raise sd.DocError("순환 — " + " → ".join(keys), 422)
|
|
|
|
|
if len(trail) >= refs.DEPTH:
|
|
|
|
|
raise sd.DocError(f"바탕 사슬이 {refs.DEPTH}단을 넘음", 422)
|
|
|
|
|
parent = read(ref)
|
|
|
|
|
if not isinstance(parent, dict):
|
|
|
|
|
raise sd.DocError(f"없는 바탕 「{ref.get('키')}」")
|
|
|
|
|
up = resolve(parent, whole, read, (*trail, rid))
|
|
|
|
|
lost = [{**x, "바탕": ref.get("키")} for x in up["짝잃음"]]
|
|
|
|
|
return {**up, "짝잃음": lost}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def resolve(
|
|
|
|
|
doc: dict,
|
|
|
|
|
whole: Any,
|
|
|
|
|
read: Any = refs.read_ref,
|
|
|
|
|
trail: tuple = (),
|
|
|
|
|
given: dict | None = None,
|
|
|
|
|
line: bool = False,
|
|
|
|
|
) -> dict[str, Any]:
|
|
|
|
|
"""SK 문서 → 고친 줄 `{줄, 고름, 자재표시, 정체, 짝잃음, 입력값, 켜쌓기율, 배, 바탕판}` ·
|
|
|
|
|
`trail` = 지나온 참조 이름표(순환 · 깊이 422) · `given` = 공통 옵션(더한줄 로직 입력)."""
|
|
|
|
|
base = _base_of(doc, whole, read, trail)
|
|
|
|
|
common = {**base["입력값"], **(doc.get("입력값") or {}), **(given or {})}
|
|
|
|
|
doc, lack = _fill(doc, whole, common)
|
|
|
|
|
got = sd.patched(base["줄"], doc, base["고름"], base["자재표시"])
|
|
|
|
|
items = got["줄"]["호표"]
|
|
|
|
|
if not line:
|
|
|
|
|
_direct(got["자재표시"], items)
|
|
|
|
|
for at, cid in enumerate(got["정체"][: len(items)]):
|
|
|
|
|
hit = re.match(r"^add:#(\d+)$", cid)
|
|
|
|
|
if hit and int(hit[1]) in lack:
|
|
|
|
|
items[at] = _gap(items[at], lack[int(hit[1])])
|
|
|
|
|
elif hit and sd.sub_patched(doc["더한줄"][int(hit[1])]): # 고친 둘째 기초 = 셈한 값묶음
|
|
|
|
|
sub = sub_run(doc["더한줄"][int(hit[1])], whole)
|
|
|
|
|
got["짝잃음"] += [{**x, "cid": f"{cid}/{x['cid']}"} for x in sub["짝잃음"]]
|
|
|
|
|
items[at] = _bundled(items[at], sub)
|
|
|
|
|
rate = doc.get("켜쌓기율", base["켜쌓기율"])
|
|
|
|
|
return {
|
|
|
|
|
**got,
|
|
|
|
|
"채운더한줄": doc["더한줄"],
|
|
|
|
|
"짝잃음": base["짝잃음"] + got["짝잃음"],
|
|
|
|
|
"입력값": {**base["입력값"], **(doc.get("입력값") or {})},
|
|
|
|
|
"켜쌓기율": rate,
|
|
|
|
|
"배": ratio_of(doc, base["줄"], whole),
|
|
|
|
|
"바탕판": fingerprint(base["줄"]),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _direct(marks: dict, items: list) -> None:
|
|
|
|
|
"""SK 재료 줄 별도계상 빈 칸 = 직접계산(747-1 · 제자리) — 다른 두 칸은 그대로."""
|
|
|
|
|
for n, item in enumerate(items):
|
|
|
|
|
if item.get("종류") == "재료":
|
|
|
|
|
marks[str(n)] = {"별도계상": "직접계산", **labor.marks(marks.get(str(n)))}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# ── 못 셈 줄 = 그 줄만 빠짐(725-1 · 725-2) ─────────────────────────────────
|
|
|
|
|
NO_QTY = "수량 없음" # `M02_Labor_Expand.NO_QTY` 와 같은 글(가져오기 둘레 피함)
|
|
|
|
|
NO_QTY_WHY = "수량 없음 — 쓰는 자리에서 연결"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _defaults(whole: Any, code: str) -> dict:
|
|
|
|
|
"""로직 기본값 = M01 견본 입력(`/m01/logic/auto` 와 같은 길)."""
|
|
|
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
got = {"값": m01.mau.values(whole, whole.logic(code))}
|
|
|
|
|
except Exception: # noqa: BLE001 — 없는 로직 · 자동값 못 셈 = 기본값 없음
|
|
|
|
|
return {}
|
|
|
|
|
return got.get("값") or {}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _fill(doc: dict, whole: Any, common: dict) -> tuple[dict, dict[int, str]]:
|
|
|
|
|
"""더한줄 로직 입력 = 줄 값 › 공통 옵션 › 로직 기본값 — (채운 사본, {더한줄 차례: 까닭})."""
|
|
|
|
|
adds, lack = [], {}
|
|
|
|
|
for k, one in enumerate(doc.get("더한줄") or []):
|
|
|
|
|
if one.get("종류") != "로직":
|
|
|
|
|
adds.append(one)
|
|
|
|
|
continue
|
|
|
|
|
try:
|
|
|
|
|
names = [str(s.get("이름")) for s in whole.logic(one["로직"]).get("입력") or []]
|
|
|
|
|
except Exception: # noqa: BLE001 — 없는 로직 = 검사(`sd.clean`)가 먼저 막음
|
|
|
|
|
names = []
|
|
|
|
|
mine = dict(one.get("입력값") or {})
|
|
|
|
|
blank = [n for n in names if mine.get(n) is None or not str(mine[n]).strip()]
|
|
|
|
|
auto = _defaults(whole, one["로직"]) if blank else {}
|
|
|
|
|
for n in blank:
|
|
|
|
|
mine.pop(n, None)
|
|
|
|
|
for v in (common.get(n), auto.get(n)):
|
|
|
|
|
if v is not None and str(v).strip():
|
|
|
|
|
mine[n] = v
|
|
|
|
|
break
|
|
|
|
|
miss = [n for n in names if n not in mine]
|
|
|
|
|
if miss:
|
|
|
|
|
lack[k] = f"입력 「{miss[0]}」 없음"
|
|
|
|
|
adds.append({**one, "입력값": mine})
|
|
|
|
|
return {**doc, "더한줄": adds}, lack
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _gap(item: dict, why: str) -> dict:
|
|
|
|
|
"""못 셈 줄 → 0 값묶음 줄(차례 그대로 · 계에 안 듦) + `빠짐` 까닭."""
|
|
|
|
|
zero = dict.fromkeys(COSTS, Decimal(0))
|
|
|
|
|
head = {k: item.get(k) or "" for k in ("이름", "단위")}
|
|
|
|
|
return {**head, "종류": "로직", "요소": None, "수량": item["수량"], "값묶음": zero, "빠짐": why}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# ── 둘째 기초 세부(727-2) ─────────────────────────────────────────────────
|
|
|
|
|
def sub_run(one: dict, whole: Any, patched: bool = True) -> dict[str, Any]:
|
|
|
|
|
"""더한줄 로직 하나(둘째 기초 · 옛 칸) — 수식 사본 없음 = 못 셈 + 까닭(855 2-C1 · 옛 엔진 안 돎)."""
|
|
|
|
|
return {"기준": None, "까닭": dsk.OLD_WHY, "정체": [], "짝잃음": [], "바탕판": ""}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _bundled(item: dict, sub: dict) -> dict:
|
|
|
|
|
"""고친 둘째 기초 줄 → 셈한 1 기준단위 노 · 재 · 경 `값묶음` 줄(수량 그대로) ·
|
|
|
|
|
못 셈 = `_gap`."""
|
|
|
|
|
if not sub.get("기준"):
|
|
|
|
|
return _gap(item, str(sub.get("까닭") or "돈 아닌 로직"))
|
|
|
|
|
head = {k: item.get(k) or "" for k in ("이름", "단위")}
|
|
|
|
|
bundle = {k: Decimal(str(sub["기준"][k])) for k in COSTS}
|
|
|
|
|
return {**head, "종류": "로직", "요소": None, "수량": item["수량"], "값묶음": bundle}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def tag_of(whole: Any, code: str) -> str:
|
|
|
|
|
"""꼬리표 = 기초 원문번호(「9-12-1」 · 문서 이름표 855 L2 ⓑ-3) · 없으면 키."""
|
|
|
|
|
try:
|
|
|
|
@@ -254,30 +82,6 @@ def tag_of(whole: Any, code: str) -> str:
|
|
|
|
|
return code
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None:
|
|
|
|
|
"""더한줄 참조 · 고정 줄 `값묶음` = 1 단위 노 · 재 · 경 — 못 셈 줄 = `_gap`(나머지 셈 계속)."""
|
|
|
|
|
for at, item in enumerate(row["호표"]):
|
|
|
|
|
if item.get("값묶음") is not None or not ("참조" in item or "고정" in item):
|
|
|
|
|
continue
|
|
|
|
|
if "참조" in item and item.get(
|
|
|
|
|
"기준"
|
|
|
|
|
): # 가져온 식 산근 속 산근(797-1) — 부르는 쪽 단가기준
|
|
|
|
|
sub = expand(item["참조"], trail, item["기준"])
|
|
|
|
|
else:
|
|
|
|
|
sub = expand(item["참조"], trail) if "참조" in item else fixed.line(whole, item["고정"])
|
|
|
|
|
item["이름"] = item.get("이름") or sub.get("이름") or ""
|
|
|
|
|
item["단위"] = item.get("단위") or sub.get("단위") or ""
|
|
|
|
|
if sub.get("기준") is None:
|
|
|
|
|
why = str(sub.get("까닭") or "")
|
|
|
|
|
row["호표"][at] = _gap(item, NO_QTY_WHY if NO_QTY in why else why)
|
|
|
|
|
continue
|
|
|
|
|
item["값묶음"] = {k: Decimal(str(sub["기준"][k])) for k in COSTS}
|
|
|
|
|
if item.get("참조비목") in COSTS: # 안쪽 산근의 그 비목만(엑셀이 비목마다 한 줄로 부른 때)
|
|
|
|
|
item["값묶음"] = {
|
|
|
|
|
k: v if k == item["참조비목"] else Decimal(0) for k, v in item["값묶음"].items()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _row_of(doc: dict, whole: Any) -> dict:
|
|
|
|
|
"""배가 읽는 바탕 머리(셈 아님) — 바탕 로직 = 기초 문서 머리(`sd.doc_row` · 855 L2 ⓑ-3) ·
|
|
|
|
|
없음 = 빈 줄(가져온 식 = 그 줄)."""
|
|
|
|
@@ -288,6 +92,10 @@ def _row_of(doc: dict, whole: Any) -> dict:
|
|
|
|
|
raise sd.DocError(f"바탕 로직 · {e}") from e
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#: 굳힌 옛 사본 SK(수식 사본 없음 · 바탕 로직이 M01 문서에 없음 · 저장소 0) — 옛 엔진 셈 걷음(855-E 2-E4)
|
|
|
|
|
FROZEN_WHY = "굳힌 옛 사본 — 수식 사본 없음 · [재생성] 으로 새로 가져와야 셈"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def run(
|
|
|
|
|
doc: dict,
|
|
|
|
|
whole: Any,
|
|
|
|
@@ -300,18 +108,15 @@ def run(
|
|
|
|
|
"""SK 셈(저장 안 함 · 855 2-C1) = 수식 사본 문서 셈 한 길 — 기준 · 1 단위 · 줄 · 비목 · 끝수 모두
|
|
|
|
|
문서 답(`M02_Doc_Sk.run`) · 줄 `cid` = 「금액#n」(문서 금액 줄 차례) · 줄 `단위` = 문서 금액 줄 단위 ·
|
|
|
|
|
수식 사본 없음(바탕 참조 · 옛 칸 덮개 · 더한줄 …) = 못 셈 + 까닭 하나(옛 엔진 안 돎 · 올림 없음) ·
|
|
|
|
|
굳힌 사본(`M02_Doc_Sk.frozen` — B09 · 구조물 사본) = 옛 길(`_frozen` · B9 걸음 몫).
|
|
|
|
|
`given` · `_opts`(detail · line · seen) = 옛 길 손님 꼴 — 문서 셈은 안 씀(옛 길도 금액은 문서 답 ·
|
|
|
|
|
2-E2 에서 부르는 쪽과 같이 걷음). 틀린 단위 환산 = `sd.DocError`."""
|
|
|
|
|
if dsk.frozen(doc):
|
|
|
|
|
return _frozen(doc, whole, given, read, expand, trail)
|
|
|
|
|
굳힌 옛 사본(`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 = dsk.copy_of(doc, whole)
|
|
|
|
|
copy = None if dsk.frozen(doc) else dsk.copy_of(doc, whole)
|
|
|
|
|
if copy is None:
|
|
|
|
|
why = dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY
|
|
|
|
|
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)
|
|
|
|
@@ -341,91 +146,6 @@ def run(
|
|
|
|
|
return out | ({"결과": got["결과"]} if "결과" in got else {})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _frozen(doc: dict, whole: Any, given: Any, read: Any, expand: Any, trail: tuple) -> dict:
|
|
|
|
|
"""굳힌 사본 SK(수식 없음) 옛 엔진 셈 — 2-C1 전 `run` 그대로(굳힌 줄 = 덮개 · 더한줄 없음) · B9 몫."""
|
|
|
|
|
from M02_MasterTemplete.M02_Labor_Expand import Expand
|
|
|
|
|
|
|
|
|
|
got = resolve(doc, whole := skc.over(doc, whole), read, trail, given)
|
|
|
|
|
row = {**got["줄"], "호표": [dict(x) for x in got["줄"]["호표"]]}
|
|
|
|
|
_bundles(row, whole, expand or Expand(whole, read), trail)
|
|
|
|
|
gaps = {at: x for at, x in enumerate(row["호표"]) if x.get("빠짐")}
|
|
|
|
|
key = str(doc.get("키") or "SK-000000")
|
|
|
|
|
names = {str(i.get("이름")) for i in row.get("입력") or []}
|
|
|
|
|
values = {k: v for k, v in {**got["입력값"], **(given or {})}.items() if k in names}
|
|
|
|
|
args = (
|
|
|
|
|
_Over(whole, key, {**row, "키": key}),
|
|
|
|
|
key,
|
|
|
|
|
values,
|
|
|
|
|
got["켜쌓기율"],
|
|
|
|
|
got["고름"] or None,
|
|
|
|
|
)
|
|
|
|
|
out = labor.run_line(*args)
|
|
|
|
|
lost = _rated(row, out.get("줄") or [], got["정체"], got["자재표시"], got["켜쌓기율"])
|
|
|
|
|
if lost is not None: # 율 더한줄(778-4) — 밑을 넣고 다시
|
|
|
|
|
out = labor.run_line(*args)
|
|
|
|
|
gap = {"단가": None, "금액": None, "비목": {}}
|
|
|
|
|
lines = [
|
|
|
|
|
{**line, "cid": cid, **({**gap, "까닭": gaps[at]["빠짐"]} if at in gaps else {})}
|
|
|
|
|
for at, (cid, line) in enumerate(zip(got["정체"], out.get("줄") or []))
|
|
|
|
|
]
|
|
|
|
|
out = labor.drop_apart({**out, "줄": lines}, got["자재표시"])
|
|
|
|
|
base = out.get("기준")
|
|
|
|
|
gone = [
|
|
|
|
|
{"cid": got["정체"][at], "이름": x.get("이름") or "", "까닭": x["빠짐"]}
|
|
|
|
|
for at, x in gaps.items()
|
|
|
|
|
]
|
|
|
|
|
head = {k: got[k] for k in ("정체", "바탕판", "배")} | {"짝잃음": got["짝잃음"] + (lost or [])}
|
|
|
|
|
unit = {k: Decimal(str(v)) / got["배"] for k, v in base.items()} if base else None
|
|
|
|
|
tag = tag_of(whole, str((doc.get("바탕") or {}).get("로직") or ""))
|
|
|
|
|
return {**out, **head, "1단위": unit, "빠진줄": gone, "꼬리표": tag}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _group(item: dict, line: dict) -> str | None:
|
|
|
|
|
"""율 밑 묶음(778-4) — 인력 · 재료 · 장비(기계경비 로직 · 기계 이음 고정 · 기계 줄) · 그 밖 None."""
|
|
|
|
|
if isinstance(item.get("고정"), dict):
|
|
|
|
|
return fixed.group_of(item["고정"])
|
|
|
|
|
if line.get("장비"):
|
|
|
|
|
return "장비"
|
|
|
|
|
return {"인력": "인력", "재료": "재료", "기계": "장비"}.get(str(item.get("종류")))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _rated(row: dict, eng: list, ids: list, marks: dict, stack: Any = None) -> list[dict] | None:
|
|
|
|
|
"""율 더한줄(778-4) `값묶음` = {비목: 밑 ÷ 100} — 한 번 돈 엔진 줄(`eng` · 정체 `ids`)로
|
|
|
|
|
`fixed.rate_base`(별도계상 재료 뺌 · 앞 율 줄 차례로 · 켜쌓기율 몫 뗌) · 제자리 · 율 줄 없음 = None ·
|
|
|
|
|
돌려줌 = 짝잃음(없는 기준 줄)."""
|
|
|
|
|
items = row["호표"]
|
|
|
|
|
at = [i for i, x in enumerate(items) if (x.get("고정") or {}).get("비율")]
|
|
|
|
|
if not at:
|
|
|
|
|
return None
|
|
|
|
|
rows = [
|
|
|
|
|
{"키": cid, "묶음": _group(items[i] if i < len(items) else {}, x), "비목": x.get("비목")}
|
|
|
|
|
for i, (cid, x) in enumerate(zip(ids, eng))
|
|
|
|
|
if i not in at
|
|
|
|
|
and not (
|
|
|
|
|
i < len(items) and items[i].get("종류") == "재료" and labor.apart(marks.get(str(i)))
|
|
|
|
|
)
|
|
|
|
|
]
|
|
|
|
|
times = Decimal(str(stack)) / 100 if stack not in (None, 100) else Decimal(1)
|
|
|
|
|
lost = []
|
|
|
|
|
for i in at:
|
|
|
|
|
rate, qty = items[i]["고정"]["비율"], Decimal(str(items[i]["수량"]))
|
|
|
|
|
if isinstance(rate["기준"], list):
|
|
|
|
|
lost += [
|
|
|
|
|
{"cid": ids[i], "까닭": f"율 기준 줄 없음 「{k}」"}
|
|
|
|
|
for k in rate["기준"] or [""]
|
|
|
|
|
if fixed.split_key(k)[0] not in ids
|
|
|
|
|
]
|
|
|
|
|
base = fixed.rate_base(rate["기준"], rows) / times
|
|
|
|
|
items[i] = {
|
|
|
|
|
**items[i],
|
|
|
|
|
"값묶음": {**dict.fromkeys(COSTS, Decimal(0)), rate["비목"]: base / 100},
|
|
|
|
|
}
|
|
|
|
|
rows.append(
|
|
|
|
|
{"키": ids[i], "묶음": None, "비목": {rate["비목"]: base * qty / 100}, "율": True}
|
|
|
|
|
)
|
|
|
|
|
return lost
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def unit(doc: dict, whole: Any, expand: Any, trail: tuple) -> dict[str, Any]:
|
|
|
|
|
"""펼침(`Expand`) 한 칸 — `{이름, 단위, 기준(1 단위), 까닭, 줄, 짝잃음}` · 못 셈 = 까닭."""
|
|
|
|
|
head = {"이름": doc.get("이름"), "단위": doc.get("단위")}
|
|
|
|
@@ -496,15 +216,23 @@ def _check_refs(doc: dict, here_: refs.Here) -> None:
|
|
|
|
|
refs._no_loop(ref, [me, ref])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _head_of(doc: dict, whole: Any) -> dict[str, Any]:
|
|
|
|
|
"""저장 검사가 읽는 바탕 — 로직 바탕 · 옛 칸 고침 없음 = 기초 문서 머리(입력 이름 · 결과단위 ·
|
|
|
|
|
855 L2 ⓑ-3 로직 줄 안 읽음) · 그 밖(가져온 식 · 참조 · 옛 칸) = 바탕 사슬(`_base_of`)."""
|
|
|
|
|
if "로직" in (doc.get("바탕") or {}) and not dsk.patched(doc):
|
|
|
|
|
try:
|
|
|
|
|
return {"줄": sd.doc_row(whole, doc["바탕"]["로직"]), "짝잃음": []}
|
|
|
|
|
except Exception as e: # noqa: BLE001 — 엔진 FormulaError(없는 기초)
|
|
|
|
|
raise sd.DocError(f"바탕 로직 · {e}") from e
|
|
|
|
|
return _base_of(doc, whole, refs.read_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]:
|
|
|
|
|