Files
Aislo/B09_Estimation/B09_Estimation_Doc_Run.py
T

344 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.
"""B09 산근 · 대가 풀이의 셈 한 벌 — 수식 문서 셈 답 + 셈 기록(PLAN 855-F B9-3) · 서버 단독(짝 없음).
M02 와 같은 계산기(`master_doc_calc` · 기록 `master_doc_trace`)로 사본 문서(`수식.json` · 없는 키 =
그 자리 닫힌 묶음 · `M02_Item_Prices.line` 같은 길 · 줄 규칙 `line_doc`)를 셈 → B09 가 읽는 꼴:
줄 = 금액 줄마다 {이름, 단위, 수량, 단가, 비목(날 값 = 수량 × 단가 · 끝수 전), 금액(날 합), 까닭,
합밖, 키(노임 · 자재 · 기계 자원 키), 품목(고른 재료 줄), 부름(하위 산근 {code, given} |
기계경비 {machine})}
`pct(n)` = % 줄 (율, 밑 이름) · `rules` = 답 `끝수` · `settle` = 블록 비목 합 끝수(새 계산기 것)
B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수(옛 엔진 · 옛 식 풀이 안 부름).
"""
from __future__ import annotations
import importlib
from decimal import Decimal
from pathlib import Path
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc # scripts 길을 둠
from M02_MasterTemplete.M02_Item_Source import read_json
md = importlib.import_module("master_doc")
mc = importlib.import_module("master_doc_calc")
ml = importlib.import_module("master_doc_link")
mt = importlib.import_module("master_doc_trace")
FILE = "수식.json"
COSTS = ("노무비", "재료비", "경비")
INPUTS = ("입력", "선택", "숫자") # 입력 갈래 연결
def docs_of(folder: Path) -> dict[str, dict]:
"""사본 `수식.json` 문서 {키: 문서} — 없으면 빈 것(셈 때 그 자리 닫힌 묶음)."""
got = read_json(Path(folder) / FILE)
return dict((got or {}).get("문서") or {}) if isinstance(got, dict) else {}
def _num(value: Any) -> Decimal | None:
return value if isinstance(value, Decimal) else None
class Answer:
"""문서 셈 답 한 벌 — 옛 엔진 줄 꼴(`줄`)로 갈라 읽음."""
def __init__(self, whole: Any, doc: dict, ans: dict, docs: dict, given: dict) -> None:
self.whole, self.doc, self.ans, self.docs, self.given = whole, doc, ans, docs, given
self.vars = {md.var_id(v): v for v in doc.get("변수") or []}
self.rules = ans.get("끝수") or {}
self.lines = [
self._line(n, dl, out)
for n, (dl, out) in enumerate(zip(doc.get("금액") or [], ans.get("줄") or []))
]
@property
def stopped(self) -> str | None:
"""블록 통째로 못 셈 까닭 — 셈 멈춤(없는 요소 · 순환 …) · 빈 입력(옛 엔진도 입력에서 멈춤)."""
if not self.ans.get("셈됨") and "결과" not in self.ans:
marks = self.ans.get("표지") or []
if marks:
return str(marks[0].get("글") or marks[0].get("갈래"))
empty = self.ans.get("빈값") or {}
for i, v in self.vars.items():
if i in empty and (v.get("연결") or {}).get("갈래") in INPUTS:
return str(empty[i])
return None
@property
def resources(self) -> list[str]:
"""문서 전체(하위 포함)가 부른 자원 키 — 부른 차례 · 겹침 없음(표 뺌)."""
return list(self.ans.get("자원") or [])
@property
def env(self) -> dict[str, Any]:
"""입력 · 중간 값 {원래 이름: 값} — 표 틀(`{구분}`) 채우기 · 계산서 줄 덧칸이 읽음."""
values = self.ans.get("값") or {}
out = {
str(v.get("열쇠")): values[i]
for i, v in self.vars.items()
if v.get("열쇠") and values.get(i) is not None
}
for x in self.doc.get("식") or []:
if x.get("이름") and values.get(str(x.get("기호"))) is not None:
out.setdefault(str(x["이름"]), values[str(x["기호"])])
return out
def _call(self, n: int, dl: dict, out: dict) -> dict | None:
"""줄 단가 기호를 부른 기록(맨 위 깊이) — 단가가 기호 하나가 아니면 None."""
sym = str(dl.get("단가") or "")
calls = self.ans.get("부름") or []
return next((calls[i] for i in out.get("부름") or [] if calls[i]["이름"] == sym), None)
def _line(self, n: int, dl: dict, out: dict) -> dict[str, Any]:
qty, price = _num(out.get("수량")), out.get("단가")
kind = str(dl.get("비목") or "")
raw: dict[str, Decimal] = {}
if qty is not None and isinstance(price, dict):
raw = {k: qty * price[k] for k in COSTS if isinstance(price.get(k), Decimal)}
elif qty is not None and isinstance(price, Decimal) and kind in COSTS:
raw = {kind: qty * price}
call = self._call(n, dl, out)
line = {
"이름": dl.get("이름") or "",
"단위": dl.get("단위") or "",
"수량": qty,
"단가": price,
"비목": raw,
"금액": sum(raw.values()) if raw else None,
"까닭": out.get("까닭"),
"합밖": bool(out.get("합밖")),
"부름": None,
}
if call is None:
return line
if call["갈래"] == "단가산출":
p = call["부름"]
line["부름"] = (
{"machine": call.get("기계")}
if "기계" in call
else {"code": str(p.get("키") or ""), "given": dict(p.get("입력") or {})}
)
return line
keys = [x["키"] for x in call.get("자원") or [] if x["갈래"] != "표"]
asked = call["부름"].get("키") # 노임 「LB:직종」 꼴 = 부른 글 그대로(옛 키 · 글 단가 짝)
if isinstance(asked, str) and asked[:3] == "LB:" and "{" not in asked:
line["키"] = asked
return line
if price is None and (self.vars.get(str(dl.get("단가"))) or {}).get("연결", {}).get("재료"):
return line # 값 없는 재료 찾기 = 품목 없음(옛 `mp.priced` 와 같게 · 키 빈 글)
goods = call.get("품목") or (keys[0] if keys and keys[0][:2] == "MT" else None)
line["키"] = goods or (keys[0] if keys else "")
if goods:
try:
row = self.whole.get(goods) or {}
except Exception: # noqa: BLE001 — 없는 품목 = 키만
row = {}
line["품목"] = {"키": goods, **{k: row.get(k) for k in ("이름", "규격", "단위")}}
return line
def engine(self, items: list[dict]) -> list[dict[str, Any]]:
"""옛 엔진 줄 꼴(대가 품셈 블록) — 호표 줄 단위 = 로직 원문 표기(B9-5 에서 문서로) · % 줄 = 율."""
out = []
for n, x in enumerate(self.lines):
if n < len(items):
out.append({**x, "단위": items[n].get("단위") or x["단위"]})
else:
pct = self.pct(n)
out.append({**x, "율": pct[0], "밑": pct[1]} if pct else x)
return out
def pct(self, n: int) -> tuple[Decimal, str] | None:
"""% 줄(149-4) — 단가 식이 「X × Y%」 · 「X × Y ÷ 100」 이면 (율 Y, 밑 이름 「노무비의 %」 …)."""
try:
node = md.parse(str((self.doc.get("금액") or [])[n].get("단가") or ""))
except (md.DocError, IndexError):
return None
if node[0] == "bin" and node[1] == "*" and node[3][0] == "pct":
base, part = node[2], node[3][1]
elif (
node[0] == "bin"
and node[1] == "/"
and node[3] == ("num", Decimal(100))
and node[2][0] == "bin"
and node[2][1] == "*"
):
base, part = node[2][2], node[2][3]
else:
return None
rate = part[1] if part[0] == "num" else self._value(part)
return (rate, self._label(base)) if isinstance(rate, Decimal) else None
def _value(self, node: tuple) -> Any:
"""식 조각 값 — 같은 계산기(`master_doc_calc`)로 이 문서 · 입력 그대로."""
if node[0] == "var":
return (self.ans.get("값") or {}).get(str(node[1]))
try:
run = mc._Run(self.doc, ml.Links(self.whole, self.docs), self.given, (), {})
return run.ev(node, None, "율")
except Exception: # noqa: BLE001 — 못 셈 = % 줄 아님(식 그대로)
return None
def _label(self, node: tuple) -> str:
"""% 밑 이름 — `M02_Labor_Doc._pct_base` 같은 말(문서 기호 → 원래 이름)."""
if node[0] == "var":
name = str(node[1])
if name in COSTS:
return f"{name}의 %"
line = next((x for x in self.doc.get("금액") or [] if x.get("기호") == name), None)
if line is not None: # 앞 금액 줄 기호(옛 줄 이름)
return f"{line.get('이름') or name}의 %"
step = next((x for x in self.doc.get("식") or [] if x.get("기호") == name), None)
var = self.vars.get(name) or {}
if step is None and (var.get("연결") or {}).get("갈래") not in (*INPUTS, "식"):
return (
"인건비의 %" if str((var.get("연결") or {}).get("키", ""))[:2] == "LB" else ""
)
return f"{var.get('열쇠') or (step or {}).get('이름') or name}의 %"
if node[0] == "field" and node[1] == ("var", "줄"):
return f"{node[2]}의 %"
names = md.names(node)
labor = [
n
for n in names
if str(((self.vars.get(n) or {}).get("연결") or {}).get("키", ""))[:2] == "LB"
]
return "인건비의 %" if labor and not set(names) & set(COSTS) else ""
def settle(self, sums: dict[str, Decimal]) -> dict[str, Decimal]:
"""블록 비목 합 끝수(끝전 · 계 · 조정) — 새 계산기 `_settle` 그대로 · 규칙 = 답 `끝수`."""
return mc._settle(self.doc, self.rules, sums)
def doc(whole: Any, docs: dict[str, dict], code: str) -> dict | None:
"""키 하나의 수식 문서 — `docs`(사본 수식 문서) › 그 자리 닫힌 묶음(받은 묶음에 더함) ·
없음 = None."""
code = str(code)
if code not in docs:
docs.update(dc.closure(whole, [code], docs))
return docs.get(code)
def row_of(doc: dict) -> dict[str, Any]:
"""수식 문서 → B09 풀이가 읽는 줄 꼴(855-F B9-6 · 옛 로직 줄 대신 문서에서) — 이름 ·
결과단위 · 출처 · 입력(변수 열쇠) · 중간(식 변수 열쇠) · 호표 = 수량 있는 금액 줄(종류 = 단가
연결: 단가산출 → 로직 「로직(키)」 · 노임 요소 → 인력 · 그 밖 → 재료) · 덧줄 = 수량 없는 금액 줄
(식 = 단가 글 · 늘 끝) · 단계."""
ids = {md.var_id(v): v for v in doc.get("변수") or []}
heads: list[dict] = []
extras: list[dict] = []
for line in doc.get("금액") or []:
keep = {k: line[k] for k in ("이름", "단위", "비목", "자리", "번지", "합밖") if k in line}
if "수량" not in line:
extras.append({**keep, "식": str(line.get("단가") or "")})
continue
link = (ids.get(str(line.get("단가"))) or {}).get("연결") or {}
key = str(link.get("키") or "")
frozen = link.get("갈래") == "숫자" and isinstance(
link.get("값"), dict
) # 굳은 기계 묶음(847-1)
kind = (
"로직"
if link.get("갈래") == "단가산출" or frozen
else "인력"
if key[:2] == "LB"
else "재료"
)
elem = (
f"로직({key})" if kind == "로직" and key else key
) # 노임 · 요소 키(줄 정체 · 덮개 cid)
heads.append({**keep, "종류": kind, **({"요소": elem} if elem else {})})
out = {
**{k: doc.get(k) for k in ("키", "이름", "결과단위", "출처")},
"입력": [
{"이름": str(v["열쇠"])} for v in ids.values() if _kind(v) in INPUTS and v.get("열쇠")
],
"중간": [
{"이름": str(v["열쇠"])} for v in ids.values() if _kind(v) == "식" and v.get("열쇠")
],
"호표": heads,
"덧줄": extras,
**({"단계": doc["단계"]} if doc.get("단계") else {}),
}
return {**out, "결과": doc["결과"]} if "결과" in doc else out
def _kind(var: dict) -> str:
return str((var.get("연결") or {}).get("갈래") or "")
def row(whole: Any, docs: dict[str, dict], code: str) -> dict[str, Any] | None:
"""키 하나의 B09 풀이 줄 꼴(`row_of`) — 문서 없음 = None."""
got = doc(whole, docs, code)
return None if got is None else row_of(got)
def solve(
whole: Any,
docs: dict[str, dict],
code: str,
given: Any = None,
picks: Any = None,
rate: Any = None,
shown: dict[str, int] | None = None,
) -> Answer | None:
"""로직 하나 문서 셈 — `docs` 에 없는 키 = 그 자리 닫힌 묶음(받은 묶음에 더함) · 입력 = 자동값 ›
받은 값 · `rate` = 금액 줄 수량 × 율 ÷ 100(켜쌓기율 · 1 단위 몫) · `shown` = 중간값 표시 자리
{원래 이름: 자리}(그 식 줄 = 반올림(식, 자리) · B09 엑셀 자리) · 문서 없음 = None."""
code = str(code)
if code not in docs:
docs.update(dc.closure(whole, [code], docs))
base = docs.get(code)
if base is None:
return None
doc = _shown(dc.line_doc(base, rate, picks or None), shown or {})
copy, given = {"부름": docs}, dc.given_of(whole, code, given, docs)
try:
ans = mt.calc(doc, mt.Trace(whole, docs), given, dc.cover_of(copy, doc))
except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 남은 틈 = 못 셈
return None
return Answer(whole, doc, ans, docs, given)
def _shown(doc: dict, shown: dict[str, int]) -> dict:
"""중간값 표시 자리 — 열쇠가 `shown` 인 식 변수의 식 줄을 반올림(식, 자리)으로(새 문서)."""
syms = {
md.var_id(v): shown[str(v.get("열쇠"))]
for v in doc.get("변수") or []
if (v.get("연결") or {}).get("갈래") == "식" and str(v.get("열쇠")) in shown
}
if not syms:
return doc
doc = {**doc, "식": [dict(x) for x in doc.get("식") or []]}
for x in doc["식"]:
if str(x.get("기호")) in syms:
x["식"] = f"반올림({x.get('식')}, {syms[str(x['기호'])]})"
return doc
def load(bundle: dict[str, Any], docs: dict[str, dict]) -> Any:
"""사본 셈 색인 = 단가 묶음 + 문서 이름표(`M02_Item_Bundle.load` · 855-F B9-6)."""
from M02_MasterTemplete import M02_Item_Bundle as item_bundle
return item_bundle.load(bundle, docs)
class Shelf:
"""값 색인(`whole`) → 문서 묶음 — 같은 색인 = 같은 묶음(사본 `수식.json` · 없으면 셈 때 그 자리)."""
def __init__(self) -> None:
self._got: list[tuple[Any, dict[str, dict]]] = [] # 색인을 붙들어 둠(id 다시 쓰기 막음)
def put(self, whole: Any, docs: dict[str, dict]) -> dict[str, dict]:
self._got.append((whole, docs))
return docs
def put_whole(self, bundle: dict[str, Any], docs: dict[str, dict]) -> Any:
"""단가 묶음 + 문서 → 셈 색인(`load`)을 짓고 그 문서 묶음을 둠 — 색인."""
whole = load(bundle, docs)
self.put(whole, docs)
return whole
def of(self, whole: Any) -> dict[str, dict]:
got = next((d for w, d in self._got if w is whole), None)
return self.put(whole, {}) if got is None else got