"""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))