"""집계 항목 복사본의 단가 묶음 `단가.json` · 복사본만으로 계산 (PLAN 25-1b · 25-2b · 25-2e). 단가 묶음 = 그 항목 일위대가 조합이 담은 로직을 계산할 때 닿을 수 있는 마스터 줄 전부(닫힌 묶음): - 담은 로직 · 로직이 부르는 하위 로직(`로직(GC…)`) 끝까지 - 식이 가리키는 요소(인력 · 기계 · 재료 · 유가전력 · 요율 · 환율 …) · 준용 대상 - 찾기 표(`찾기(QC…)` · `찾기(QF…)` 소요량 · 계수) - 재료 고르기 조건의 후보 자재품목 줄 · 품셈재료 연결 · 지역 · 계약종별 후보 원문번호 틀의 `{입력}` 은 그 입력의 고르기 값으로 모두 끼워 모음(고르기가 없으면 그 테이블 전부 · 자재품목만은 너무 커서 뺌). 줄은 마스터 파일 차례 그대로 담음 — 고르기의 「첫 줄」 이 같게. 일위대가 자재(MT · 39-1c)도 그 줄(+ 준용 · 연결)을 담음. `단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_formula.Master` 가 그대로 읽는 꼴. 계산(`calc`)은 이 묶음과 `입력값.json` · `고른자재.json` · `면적.json`(알약 칸 값) 만 씀 — 마스터 현재값을 읽지 않음. 셈은 층 일위대가 셈 한 벌(`M02_Labor_Doc.calc` · 142-1 · 빈 입력 = 자동값). """ from __future__ import annotations import json from decimal import Decimal from typing import Any from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_MyMachine as mym # noqa: F401 — Item_Bundle.collect 가 씀 import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 mk = m01.mk mcb = m01.mcb mm = mf.mp.mm # 품셈재료 · 자재품목 후보(`master_material`) #: 틀을 못 풀었을 때 통째로 담지 않는 테이블 — 자재품목(3만 줄) _TOO_BIG = ("MT",) def master() -> tuple[dict[str, dict], Any]: """(마스터 파일 묶음, 색인) — 읽기 전용(시험은 `m01.FOLDER` 를 사본으로 바꿈).""" return m01.loaded() #: 재료 후보 찾기 답 — (마스터 색인, {조건 글: 키}) · 색인이 바뀌면(마스터 저장) 새로 · #: 복사본 목록이 복사본마다 단가 묶음을 다시 모아도 같은 조건은 한 번만 찾음(156-2) _FOUND: tuple[Any, dict[str, list[str]]] = (None, {}) def _candidates(whole: Any, cond: dict) -> list[str]: """`mf.candidates(whole, cond)` 를 마스터 색인 하나에 한 번만 — 답은 마스터와 조건만 따름.""" global _FOUND seen, found = _FOUND if seen is not whole: found = {} _FOUND = (whole, found) key = json.dumps(cond, ensure_ascii=False, sort_keys=True, default=str) if key not in found: found[key] = list(mf.candidates(whole, cond, None, None)) return found[key] class _Collector: def __init__(self, whole: Any): self.whole = whole self.keys: set[str] = set() self.missing: list[str] = [] def add(self, ref: str) -> None: try: row = self.whole.get(ref) except mf.FormulaError: return # 없는 요소 — 계산이 같은 까닭으로 멈춤(마스터와 같게) key = str(row.get("키")) if key in self.keys: return self.keys.add(key) if row.get("준용") not in (None, ""): self.add(str(row["준용"])) link = row.get("연결") if key[:2] == mf.LINKED else None if isinstance(link, str): self.add(link) elif isinstance(link, dict): self.widely(link, row.get("단위")) def widely(self, cond: dict, unit: Any) -> None: """지역 · 계약종별 「입력」 조건 — 입력값과 상관없이 닿을 수 있는 후보 전부.""" want = mm.plain(cond.get("이름")) if cond.get("계약종별") == "입력": for key, one in self.whole.index.get(mm.PRICED, {}).items(): if one.get("구분") == "전력" and mm.plain(one.get("이름")).startswith(want): self.keys.add(key) return spec, unit_p = mm.plain_spec(cond.get("규격")), mm.plain_unit(unit) for root, _, s, u, key in mm._market_index(self.whole): if root.endswith(want) and u == unit_p and (not spec or s == spec): self.keys.add(key) #: M01 에서 지워진 사본 줄(795-4) 자리 — `Master` 가 그룹 아닌 「줄」 로 읽음 COPY_FILE = "사본_남은줄.json" def collect( logic_keys: list[str], materials: list[str] | None = None, extra: list[dict] | None = None, over: list[dict] | None = None, ) -> dict[str, Any]: """담은 로직 + 자재(MT)의 닫힌 단가 묶음 — `{파일 이름: 파일(줄은 모은 것만 · 차례 그대로)}` · 닫힌 묶음 = 로직 키의 수식 문서 묶음(`M02_Doc_Copy.closure`)이 잇는 자원 · 표 줄(`M02_Item_Bundle.collect` · 로직 줄 · 옛 식 글 훑기 없음 · 855-E 2-E4) · `over` = M02 값 사본 줄(795-4 · 같은 키는 M01 줄 대신) · M01 수식 문서 없는 로직 키 = `_빠진` · `extra`(마스터 밖 로직 줄) = 받지 않음(부르는 곳 0).""" from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Item_Bundle as item_bundle keys = [str(k) for k in logic_keys] docs = dc.closure(master()[1], keys) out = item_bundle.collect(docs, materials, over) lost = sorted( set(out.pop("_빠진", [])) | {f"{k} · 수식 문서 없음" for k in keys if k not in docs} ) return out | ({"_빠진": lost} if lost else {}) def to_json(value: Any) -> Any: """Decimal 을 JSON 수로 — 정수는 int · 아니면 원래 자릿수 그대로(float 로 흔들지 않음).""" return json.loads(json.dumps(value, ensure_ascii=False, default=_number)) def _number(value: Any) -> Any: if isinstance(value, Decimal): text = str(value) # 「14480.0」 은 소수 그대로 — 끝수 · 표기가 마스터와 같게 return int(value) if "." not in text and "E" not in text.upper() else float(value) raise TypeError(type(value).__name__) def load_prices(prices: dict[str, Any]) -> Any: """`단가.json` → 계산 색인(수는 Decimal · 마스터 적재와 같게).""" raw = json.dumps({k: v for k, v in prices.items() if not k.startswith("_")}, ensure_ascii=False) files = json.loads(raw, parse_float=Decimal, parse_int=Decimal) return mf.Master(files) # ── 계산(25-2e) ───────────────────────────────────────────────────── def _logic_keys(labor: dict[str, Any]) -> list[str]: """담은 로직 키 — 참조 줄(로직 없음 · 50-3)은 뺌.""" lines = (labor.get("줄") or {}).get("담은로직") or [] return [str(one["로직"]) for one in lines if isinstance(one, dict) and one.get("로직")] def doc_inputs(doc: Any) -> list[str]: """수식 문서 입력 이름(입력 · 선택 변수 열쇠 · 옛 로직 줄 `입력` 이름 · 차례와 같음).""" return [ str(v["열쇠"]) for v in (doc or {}).get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("입력", "선택") and v.get("열쇠") ] def doc_specs(doc: Any) -> list[dict[str, Any]]: """수식 문서 입력 꼴(옛 로직 줄 `입력` 자리) — {이름(열쇠), 단위, 설명, 출처, 고르기, 범위}.""" out = [] for v in (doc or {}).get("변수") or []: link = v.get("연결") or {} if link.get("갈래") not in ("입력", "선택") or not v.get("열쇠"): continue spec = {"이름": str(v["열쇠"]), **{k: v[k] for k in ("단위", "설명", "출처") if v.get(k)}} spec |= {"고르기": list(link["목록"])} if link.get("목록") else {} out.append(spec | ({"범위": list(link["범위"])} if link.get("범위") else {})) return out def missing_inputs( docs: dict[str, dict], labor: dict[str, Any], values: dict[str, Any] ) -> list[dict]: """담은 로직마다 값이 없는(null · 안 적음) 입력 — `{로직, 입력}` · 입력 = 사본 수식 문서.""" out = [] for key in _logic_keys(labor): mine = values.get(key) or {} for name in doc_inputs(docs.get(key)): got = mine.get(name) if not isinstance(got, dict) or got.get("값") in (None, ""): out.append({"로직": key, "입력": name}) return out def with_values(doc: dict[str, Any], values: dict[str, Any], picks: dict[str, Any]) -> dict: """사본 문서에 사본 `입력값.json` · `고른자재.json` 을 줄 입력값 · 고름으로 얹음(142-1) — 빈 값은 안 얹음(= 자동값 · M02 층 셈과 같음).""" lines = [] for one in doc.get("담은로직") or []: code = one.get("로직") if isinstance(one, dict) else None if not code: lines.append(one) continue given = { name: got.get("값") for name, got in (values.get(code) or {}).items() if isinstance(got, dict) and got.get("값") not in (None, "") } line = {**one, "입력값": given} if isinstance((picks or {}).get(code), dict): line["고름"] = picks[code] lines.append(line) return {**doc, "담은로직": lines} def _mat_lines(doc: dict) -> list[tuple[int, dict, dict]]: """재료 금액 줄 `[(차례, 줄, 단가 연결)]` — 단가가 재료 요소(재료 조건 · MT · MO · PM 키)인 줄 (옛 로직 호표 「재료」 줄 자리 · 차례 = 호표 차례).""" import master_doc as md links = {md.var_id(v): v.get("연결") or {} for v in doc.get("변수") or []} out = [] for n, line in enumerate(doc.get("금액") or []): link = links.get(str(line.get("단가"))) or {} key = str(link.get("키") or "") if link.get("갈래") == "요소" and (link.get("재료") is not None or key[:2] in MAT_KEYS): out.append((n, line, link)) return out def _mats(doc: dict, ans: dict) -> list[dict[str, Any]]: """문서 셈 답의 재료 줄(옛 `logic_mats` 자리 · B08 단위수량) — 단위 = 연결 단위(로직 원문 표기) › 줄 단위 · 품목 = 기록의 고른 품목(`master_doc_trace`) › MT · PM 키(고른 재료 = `line_doc` 이 키로 바꿈) · MO = 없음.""" lines, out = ans.get("줄") or [], [] for n, line, link in _mat_lines(doc): got = lines[n] if n < len(lines) else {} calls = [ans["부름"][i] for i in got.get("부름") or []] key = str(link.get("키") or "") goods = next((c["품목"] for c in calls if c.get("품목")), None) goods = goods or (key if key[:2] in ("MT", "PM") else None) out.append( { "차례": n, "이름": line.get("이름") or "", "단위": link.get("단위") or line.get("단위") or "", "수량": got.get("수량"), "품목": {"키": goods} if goods else None, } ) return out #: 재료 요소 키 머리 — 자재품목 · 품셈재료 · 개인 자재 MAT_KEYS = ("MT", "MO", "PM") def line(whole: Any, docs: dict[str, dict] | None, one: dict[str, Any]) -> dict[str, Any]: """사본 로직 줄 기준 — 사본 `수식.json` 문서 셈 한 길(855-F B9-2 · 층 `M02_Labor_Copy.line` 과 같은 줄 규칙 `line_doc` · 입력 = 자동값 › 받은 값) · 값 = 사본 `단가.json` 색인 `whole` · `docs` 에 없는 키 = 값 사본 줄에서(`doc_of` · 만들 때와 같은 길 · `docs` 에 더함) · 답 `{기준, 줄, 재료, 까닭}` | 돈 아닌 문서 `{결과}`.""" import master_doc_trace as mt from M02_MasterTemplete import M02_Doc_Copy as dc code, docs = str(one.get("로직") or ""), {} if docs is None else docs if code not in docs: # 사본에 없는 키 — 닫힌 묶음을 그 자리에서(받은 묶음에 더해 다음 줄이 씀) docs.update(dc.closure(whole, [code], docs)) base = docs.get(code) if base is None: return {"기준": None, "줄": [], "재료": [], "까닭": f"수식 문서 없음 「{code}」"} apart = dc.apart_of(one.get("자재표시"), [{"차례": n} for n, _, _ in _mat_lines(base)]) doc = dc.line_doc(base, one.get("켜쌓기율"), one.get("고름"), apart) given = dc.given_of(whole, code, one.get("입력값"), docs) copy = {"부름": docs} try: ans = mt.calc(doc, mt.Trace(whole, docs), given, dc.cover_of(copy, doc)) except Exception as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로(`dc.run` 같음) return {"기준": None, "줄": [], "재료": [], "까닭": str(e) or type(e).__name__} if "결과" in ans: return {"결과": ans["결과"], "기준": None, "까닭": None} money = dc.money(ans) got = {k: Decimal(str(v)) for k, v in money.items()} if money else None return { "기준": got, "줄": ans.get("줄") or [], "재료": _mats(doc, ans), "까닭": None if got else dc.why(ans), } def calc( labor: dict[str, Any], prices: dict[str, Any], values: dict[str, Any], picks: dict[str, Any], area: Any = None, formula: dict[str, Any] | None = None, ) -> dict[str, Any]: """복사본만으로 계산 — 층 셈(`M02_Labor_Doc.calc`) 한 벌(142-1) · 로직 줄 = 사본 `수식.json` (`formula`) 문서 셈(`line` · 855-F B9-2) · 단가 = 사본 `단가.json` · 참조 = 굳힌 `참조사본` · 알약 = 가져온 때 것 · 수량 칸 = 사본 `면적.json` · 빈 입력 = 자동값. 답 = 층 셈 꼴(`줄` · `자재` · `기준합` · `반영합`) + `알약` + `빠진입력`(「빈 값 n」 표시).""" from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs docs = dict((formula or {}).get("문서") or {}) snapshot = item_bundle.load(prices, docs) # 단가 묶음 + 문서 이름표(855-F B9-6) doc = with_values(labor.get("줄") or {}, values or {}, picks or {}) copies = labor.get("참조사본") or {} saved = labor.get("알약") got = labor_doc.calc( doc, labor_doc.area_values(area), whole=snapshot, read=lambda ref: copies.get(refs.ref_id(ref)), pills=[p for p in saved if p.get("로직")] if isinstance(saved, list) else None, logic_line=lambda one: line(snapshot, docs, one), ) return { **got, "알약": saved if isinstance(saved, list) else labor_doc.pills(doc), "빠진입력": missing_inputs(docs, labor, values or {}), }