Files
Aislo/M02_MasterTemplete/M02_Item_Prices.py
T
eomsangdonandClaude Opus 5.5 395c707280 refactor(855-E 2-E4): 바탕 이름만 쓰는 M02 · B09 import 를 master_base 로 — 엔진 몸 모듈 안 읽음
- M02 Item_Prices · Labor_Doc · Labor_Fixed · Logic_Standard · Hopyo_Match: `mf = m01.cm.mf` → `import master_base as mf`
  (쓰는 이름 FormulaError · COST_ITEMS · LINKED · Master · candidates · mp 만) · Hopyo_Fixed · Hopyo_Sangeun ·
  Machine_Hourly: `m01.cm.mf.*` → master_base(Machine_Hourly 는 master_machine_crew 를 scripts 길 뒤로 — 새 프로세스
  첫 import 가 멈추던 차례 고침)
- B09 Linked · Sangeun: 안 쓰는 `mf = item_prices.mf` 지움(Labor_Source · Sangeun_Copy 는 Item_Prices.mf = 바탕을 그대로)
- 남김(남의 몫): MyMachine(sub3 858) · San_Basis_Index 의 cm.mf 길 깔기 · Sangeun_Formula._eng(M01 Equation · L4)
- 검증: 바꾼 10 모듈 새 프로세스 단독 import 통과 · 관련 121 파일 + 지킴 + 관문 977 통과 · 빌더 --check 같음 · typecheck 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 11:33:12 +09:00

319 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""집계 항목 복사본의 단가 묶음 `단가.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 {}),
}