"""M02 단가산출(SK) 셈 — 수식 사본 문서 셈 한 길(PLAN 855 2-C1 · 715-1b · 715-2). 셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 · 기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 · 뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` · `resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀). 계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만). 저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `바탕판` · `M01판` 적음. SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` · 「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} · 없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`). 바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(「별도계상」 고른 줄만 문서 금액 줄 `합밖`). """ 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_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Block as blk from M02_MasterTemplete import M02_Sangeun_Const as const, M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd, M02_Sangeun_Equation as eqm 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: 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 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」) · 없으면 키.""" try: return str(whole.logic(code).get("원문번호") or code) except Exception: # noqa: BLE001 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: """배 · 바탕판이 읽는 바탕 줄(셈 아님) — 바탕 로직 = 그 줄 · 없음 = 빈 줄(가져온 식 = 그 줄).""" key = (doc.get("바탕") or {}).get("로직") try: return whole.logic(key) if key else sd.empty_row(doc) except Exception as e: # noqa: BLE001 — 없는 로직 raise sd.DocError(f"바탕 로직 · {e}") from e 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` — B09 · 구조물 사본) = 옛 길(`_frozen` · B9 걸음 몫). `given` · `_opts`(detail · line · seen) = 옛 길 손님 꼴 — 문서 셈은 안 씀(옛 길도 금액은 문서 답 · 2-E2 에서 부르는 쪽과 같이 걷음). 틀린 단위 환산 = `sd.DocError`.""" if dsk.frozen(doc): return _frozen(doc, whole, given, read, expand, trail) 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) if copy is None: why = 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, "바탕판": fingerprint(row), "줄": 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 _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("단위")} 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 head_of(doc: dict) -> str: """머리 띠 — 「1 본 당」 · 앞 수 있는 단위 = 「100본 당」.""" unit = str(doc.get("단위") or "") return f"{unit} 당" if unit[:1].isdigit() else f"1 {unit} 당" 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 clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: """저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `바탕판` · `M01판` · 옛 칸 덮개 · 둘째 기초 `원값` 적기는 걷음(옛 칸 셈 은퇴 · 855 2-C1).""" 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_) eqm.strict(base := _base_of(rough, whole, refs.read_ref, ())) # 수식 고침(796-2b) blk.strict(rough, whole) # 끊은 기초 수식 고침(796-2e) out = sd.clean(doc, base["줄"], whole) out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"] for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 one.setdefault("처음수량", one["수량"]) out |= const.stamp(base["줄"], out) # 바탕판 · M01판(790-2) · 식 칸 엔진 식(792-1) 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, seen: bool = True) -> dict[str, Any]: """셈 길(`M02_Sangeun_Router`) — 지금 층 문서 · 저장 전 화면 문서 · 틀림 400 · 순환 422 · `seen` = 옛 보기 덧칸 자리(856-1 뒤 안 지음 · 길 꼴만 · 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