- git rm(부르는 곳 0 다시 셈 — import · import_module 글 · getattr 별칭 cm.mf · store.mau · mtx 포함): master_formula · master_formula_check · master_formula_sum · master_text · master_text_item · master_sheet_line · master_gate · master_auto · master_copy(−2,625 줄) - master_cut = down · row · sums 만(일위대가 반영 끝수 · TS 짝) — engine · settle · plain · _line · _sub · kept(손님 0) 지움 · 바탕 = master_base - master_bundle = BUNDLES · BY_ITEM · BY_KIND · is_machine(M01 목록 묶음) — called · bundle · tag 지움 · master_combo = 조합 칸만(run 지움) - check_master · check_master_body · compare_estx: import master_formula → master_base(바탕 이름만) · compare_estx 기계 · 일위대가 대조 = 수식 문서 셈(옛 mf.run · 로직 줄 고르기 덧붙임 걷음 · 일위대가 28 · 기계 207 건 그대로 나옴) - M01 Store: 다시 내보냄 mau · mtx 지움(부르는 곳 0) · cm.mf = master_base - 죽은 주석: master_material · master_pick · master_base · Item_Prices · San_Emit · check_master - test_855_sk_layers: 옛 엔진 안 돎 = 엔진 모듈 없음 확인 - 검증: 관련 146 파일 1,135 통과 · test_855_golden 전수 지문 같음 · 모든 제품 · scripts 모듈 읽기 깨짐 0 · typecheck 0 · 8008 health 200 · 로그 오류 0 · 서버 길 469 → 469 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
319 lines
15 KiB
Python
319 lines
15 KiB
Python
"""집계 항목 복사본의 단가 묶음 `단가.json` · 복사본만으로 계산 (PLAN 25-1b · 25-2b · 25-2e).
|
||
|
||
단가 묶음 = 그 항목 일위대가 조합이 담은 로직을 계산할 때 닿을 수 있는 마스터 줄 전부(닫힌 묶음):
|
||
- 담은 로직 · 로직이 부르는 하위 로직(`로직(GC…)`) 끝까지
|
||
- 식이 가리키는 요소(인력 · 기계 · 재료 · 유가전력 · 요율 · 환율 …) · 준용 대상
|
||
- 찾기 표(`찾기(QC…)` · `찾기(QF…)` 소요량 · 계수)
|
||
- 재료 고르기 조건의 후보 자재품목 줄 · 품셈재료 연결 · 지역 · 계약종별 후보
|
||
원문번호 틀의 `{입력}` 은 그 입력의 고르기 값으로 모두 끼워 모음(고르기가 없으면 그 테이블 전부 ·
|
||
자재품목만은 너무 커서 뺌). 줄은 마스터 파일 차례 그대로 담음 — 고르기의 「첫 줄」 이 같게.
|
||
|
||
일위대가 자재(MT · 39-1c)도 그 줄(+ 준용 · 연결)을 담음.
|
||
|
||
`단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_base.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 {}),
|
||
}
|