Files
Aislo/B09_Estimation/B09_Estimation_Sangeun_Sum.py
T
eomsangdonandClaude Opus 5.5 d254b4b555 refactor(855-F B9-3): B09 산근 · 대가 · 수요 키가 옛 엔진 대신 문서 셈 답 + 셈 기록을 읽음
- 새 B09_Estimation_Doc_Run — 사본 수식 문서를 M02 와 같은 계산기로 셈 → 줄마다 수량 · 단가 · 비목 · 자원 키 · 품목 · 하위 부름 · % 율 · 끝수
- Sangeun 풀이(_solve · _line · _logic_line · _extras · call_of · line_calls · hand_resource_keys) · Labor_Source._poomsem · Linked.used_keys = 문서 셈 답 · 기록
- Sangeun_Sum doc_* = 답 끝수 · 합밖(새 계산기 cut · _settle) · 옛 함수와 _env · _captured 는 산출근거 글 몫(B9-4)
- Labor_Rule 식 꼴 읽기 = 새 계산기 파서 · 작업량 Q ROUND 2 · 빈 입력 멈춤 · 굳은 기계 단가 기계 키 살림
- master_doc_trace 감싼 색인 메서드 찾기 한 줄(굳힌 단가산출 대가 블록)
- test_855_trace 옛 하위 부름 기준 = helper_855_engine.old_line_calls(옛 함수 옮김)
- 골든 855_b09 다시 뜸 7 갈래 — 기계 시간당 단가 = M02 문서 셈 값(옛 = 엔진 날 값 · 줄 0.1 원 · 합 1 원 다를 수 있음) · 수요 키에서 재료 고르기 후보 빠짐 · 글 · 나머지 8 갈래 같음
- 옛 엔진 부름 B09(글 뺌) 19 → 6 · 719-1 · 719-2 실패 5 는 옛 칸 SK 견본(B9-5 몫 · 고치기 전에도 같음)

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

141 lines
6.6 KiB
Python

"""B09 산근 풀이 셈 의미(PLAN 792-3) — 791-1 엔진 새 의미(줄 자리 · 합밖 · 번지 · 단계 · 블록 끝전 ·
결과 조정 · 변수 표시)를 쓰는 로직만 엔진 규칙(`master_cut` · `master_formula_sum`) 그대로 ·
새 칸 없는 로직 = 옛 B09 규칙(작업량 Q = ROUND 2 · 줄 ROUNDDOWN 1 · 총계 비목마다 ROUNDDOWN 0).
쓰는 곳 = 산출근거 글(`B09_Estimation_Sangeun_Text` · B9-4 에서 걷음) · 풀이 금액(`Sangeun.Solver`) =
아래 `doc_*`(855-F B9-3 · 문서 셈 답 `끝수` · `합밖` · 새 계산기 `master_doc_calc.cut` · `_settle`) · 지킴 시험 = `test_792_3_engine_paths.py`(엔진 · M02 SK ·
SC · B09 산근 네 길 같은 금액).
"""
from __future__ import annotations
import importlib
import re
from decimal import Decimal
from typing import Any
from B09_Estimation.B09_Estimation_Calc_Base import round_half, rounddown, total
from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠
mcut = importlib.import_module("master_cut")
mc = importlib.import_module("master_doc_calc")
ms = importlib.import_module("master_formula_sum")
PARTS = ("labor", "material", "expense")
COST_PART = {"노무비": "labor", "재료비": "material", "경비": "expense"}
_Q = re.compile(r"Q\d*") # 작업량 중간값 이름(산림품셈 09장 토공 · 07장 집재 …)
def shown(row: dict, step: dict, value: Any) -> Any:
"""중간값 — `표시` 칸 · 새 의미 로직 = 엔진 그대로(`표시` 자리 반올림) · 옛 = Q ROUND 2."""
if step.get("표시") is not None or ms.uses(row):
return ms.shown(step, value)
if _Q.fullmatch(step["이름"]) and isinstance(value, (Decimal, int, float)):
return Decimal(str(round_half(float(value), 2)))
return value
def _cut(value: float, rule: dict | None) -> float:
return float(mcut._line(value, rule)) if rule else rounddown(value, 1)
def places(row: dict, lines: list[dict]) -> None:
"""호표 줄 `자리`(줄 자리) — 그 줄 금액만 단가 × 수량을 그 규칙으로 다시 버림(제자리)."""
for item, ln in zip(row.get("호표", []), lines):
rule = item.get("자리")
if not rule or ln.get("qty") is None:
continue
for part, price in (ln.get("price") or {}).items():
if part in PARTS and price is not None:
ln[part] = _cut(price * ln["qty"], rule)
def _engine(lines: list[dict]) -> list[dict]:
"""B09 줄 → 엔진 줄 꼴 `{비목}`(번지 · 단계 셈)."""
return [
{"비목": {k: Decimal(str(ln.get(p) or 0)) for k, p in COST_PART.items()}} for ln in lines
]
def sums(row: dict, lines: list[dict]) -> dict[str, float | None]:
"""덧줄 밑 비목 합 — 새 의미 로직은 합밖 · 제외 단계 줄을 뺌."""
skip = ms.skipped(row) if ms.uses(row) else set()
kept = [ln for n, ln in enumerate(lines) if n not in skip]
return {name: total([ln[p] for ln in kept]) for name, p in COST_PART.items()}
def scope(row: dict, lines: list[dict], env: dict) -> None:
"""덧줄 식 이름 `번지` · `단계`(지금까지 줄) — 새 의미 로직만."""
if ms.uses(row):
env.update(ms.scope(row, _engine(lines)))
def extra(row: dict, item: dict, value: float, env: dict) -> float:
"""덧줄 금액 — 줄 `자리` 면 그 규칙 · 아니면 ROUNDDOWN 1 ·
새 의미 로직은 뒤 덧줄이 그 값을 부름."""
money = _cut(value, item.get("자리"))
if ms.uses(row):
env[item["이름"]] = Decimal(str(money))
return money
def totals(row: dict, lines: list[dict]) -> dict[str, float | None] | None:
"""총계 — 새 의미 로직 = 합밖 · 제외 빼고 블록 끝전 · `끝수` · 조정(`master_cut.settle`) ·
옛 로직 · 빈칸 비목 있음 = None(옛 `block_totals`)."""
if not ms.uses(row):
return None
got = sums(row, lines)
if any(v is None for v in got.values()):
return None
costs = mcut.settle(row, {k: Decimal(str(v)) for k, v in got.items()})
out = {COST_PART[k]: float(v) for k, v in costs.items()}
return {**out, "sum": sum(out.values())}
# ── 문서 셈 답 길(855-F B9-3 · `Sangeun.Solver`) — 위 옛 길 = 산출근거 글 몫 ──────────
def doc_cut(value: float, rule: dict | None) -> float:
"""줄 끝수 — 줄 `자리` 면 그 규칙(새 계산기 `master_doc_calc.cut`) · 없으면 ROUNDDOWN 1."""
return float(mc.cut(Decimal(str(value)), rule)) if rule else rounddown(value, 1)
def doc_places(row: dict, lines: list[dict]) -> None:
"""호표 줄 `자리`(줄 자리) — 그 줄 금액만 단가 × 수량을 그 규칙으로 다시 버림(제자리)."""
for item, ln in zip(row.get("호표", []), lines):
rule = item.get("자리")
if not rule or ln.get("qty") is None:
continue
for part, price in (ln.get("price") or {}).items():
if part in PARTS and price is not None:
ln[part] = doc_cut(price * ln["qty"], rule)
def doc_sums(skip: set[int], lines: list[dict]) -> dict[str, float | None]:
"""덧줄 밑 비목 합 — 합밖 · 제외 단계 줄(문서 셈 답 `합밖`)을 뺌."""
kept = [ln for n, ln in enumerate(lines) if n not in skip]
return {name: total([ln[p] for ln in kept]) for name, p in COST_PART.items()}
def doc_totals(answer: Any, lines: list[dict]) -> dict[str, float | None]:
"""총계 — 합밖 · 제외 줄 빼고 B09 줄 금액 비목 합 → 문서 답 `끝수`(끝전 · 계 · 조정 · 새 계산기
`settle`) · 빈칸 비목 있으면 그 비목 · 합계 빈칸(옛 `block_totals`)."""
skip = {n for n, x in enumerate(answer.lines) if x.get("합밖")}
got = doc_sums(skip, lines)
if any(v is None for v in got.values()):
out = {COST_PART[k]: None if v is None else rounddown(v, 0) for k, v in got.items()}
return {**out, "sum": total(list(out.values()))}
costs = answer.settle({k: Decimal(str(v)) for k, v in got.items()})
out = {COST_PART[k]: float(v) for k, v in costs.items()}
return {**out, "sum": sum(out.values())}
def doc_shown(row: dict) -> dict[str, int]:
"""중간값 표시 자리 {이름: 자리} — `shown` 과 같은 뜻(`표시` · 옛 로직 작업량 Q = ROUND 2 · 엑셀 자리) ·
문서 셈에 그 식 줄을 반올림으로 씌워 셈(`Doc_Run.solve` `shown`)."""
new = ms.uses(row)
out: dict[str, int] = {}
for step in row.get("중간", []):
if step.get("표시") is not None:
out[step["이름"]] = int(step["표시"])
elif not new and _Q.fullmatch(step["이름"]):
out[step["이름"]] = 2
return out