Merge commit 'd880392e5feebe49e0b89541008959852a64d972' into main_laptop_1

This commit is contained in:
2026-11-18 07:07:27 +09:00
18 changed files with 703 additions and 271 deletions
@@ -40,7 +40,6 @@ from B08_Quantity.B08_Quantity_Haul_Cycle import FILL, cycle_inputs, cycle_time
from B09_Estimation.B09_Estimation_Store import folder as store_folder
from B09_Estimation.B09_Estimation_Store import ref_rows
from common_util.common_util_json import atomic_write_json
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Doc_B09 as doc_b09
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete.M02_Item_Snapshot import (
@@ -159,10 +158,12 @@ def refresh_copy(project_root: str | Path, one: tuple) -> None:
# ── 운반 값 사본(263-2) ────────────────────────────────────────────────
def _logic(code: str) -> dict[str, Any]:
try:
return dict(m01.loaded()[1].logic(code) or {})
except Exception: # noqa: BLE001 — 없는 로직 = 입력 없음
return {}
"""M01 기초 이름 · 입력 꼴 — 지금 수식 문서(855-F B9-6) · 없는 기초 = 입력 없음."""
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Item_Prices as item_prices
doc = dc.folder().get(str(code))
return {"이름": doc.get("이름"), "입력": item_prices.doc_specs(doc)} if doc else {}
def _line_at(labor: Any, lid: str) -> dict[str, Any] | None:
+65 -2
View File
@@ -144,7 +144,7 @@ class Answer:
out.append({**x, "단위": items[n].get("단위") or x["단위"]})
else:
pct = self.pct(n)
out.append({**x, "율": pct[0]} if pct else x)
out.append({**x, "율": pct[0], "밑": pct[1]} if pct else x)
return out
def pct(self, n: int) -> tuple[Decimal, str] | None:
@@ -209,6 +209,69 @@ class Answer:
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],
@@ -228,7 +291,7 @@ def solve(
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)
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 — 계산기는 예외 없음이 원칙 · 남은 틈 = 못 셈
+16 -23
View File
@@ -28,7 +28,6 @@ from __future__ import annotations
import hashlib
import json
import re
from decimal import Decimal
from pathlib import Path
from typing import Any
@@ -61,10 +60,6 @@ mf = item_prices.mf
#: 엔진 비목 → 블록 비목
PART = {"노무비": "labor", "재료비": "material", "경비": "expense"}
GROUP = {"인력": "labor", "재료": "material", "장비": "machine"} # 율 기준 묶음(778-4)
#: % 덧줄 밑수 — `노무비 * …` · `줄.'이름' * …` · `(석공 * LB… + …) * …`(인력 줄)
BASE_PART = re.compile(r"^\s*(노무비|재료비|경비)\s*\*")
BASE_LINE = re.compile(r"^\s*줄\.'([^']+)'\s*\*")
BASE_LABOR = re.compile(r"^\s*\(.*\*\s*LB\d+")
AREA_FILE = "면적.json"
ASK = "수량 없음 — 이 공사에서 입력" # 723-4 SC 안 줄 수량 빈칸(펼침 품 · 수량 칸)
@@ -140,9 +135,8 @@ class Builder:
(금액 줄 차례 · 단가산출 블록이 씀)."""
code = str(one.get("로직") or "")
given, rate, picks = one.get("입력값") or {}, one.get("켜쌓기율"), one.get("고름")
try:
logic = whole.logic(code)
except mf.FormulaError:
logic = dr.row(whole, self.shelf.of(whole), code) # 수식 문서 줄 꼴(855-F B9-6)
if logic is None:
return None
got = dr.solve(
whole, self.shelf.of(whole), code, given, picks, rate
@@ -228,9 +222,9 @@ class Builder:
out["place"] = dict(place) # 줄 자리(792-4) = 문서 금액 줄 칸
if pct := got.pct(n):
word = pct[1].removesuffix("의 %")
base = {"노무비": "part:labor", "재료비": "part:material", "경비": "part:expense",
"인건비": "lines:labor"}.get(word, f"line:{word}") # fmt: skip
base = base if word else _doc_base(got.doc, n) # 번지 · 단계 밑(792-4)
base = (
_BASE.get(word, f"line:{word}") if word else _doc_base(got.doc, n)
) # 번지 · 단계 밑(792-4)
if base is None: # 밑을 모르는 덧줄 — 옛 길과 같게 빈 줄
why = "덧줄 — 대가 단가로 못 셈"
return {**head, **out, "kind": "blank", "qty": qty, "why": why}
@@ -265,7 +259,8 @@ class Builder:
goods = x.get("품목") or {}
if item is None: # 덧줄 — 밑수 × % / 100(% = 엔진 값 ÷ 엔진 밑수)
add = (logic.get("덧줄") or [])[extra]
base, label = _base_of(str(add.get("식") or ""))
label = str(x.get("밑") or "").removesuffix("의 %") # 문서 셈 % 밑 이름(855-F B9-6)
base = _BASE.get(label, f"line:{label}") if label else None
value, under = _f(x.get("금액")), bases.get(base) if base else None
if value is None or not under:
# ponytail: 밑수 없는 덧줄(손료 식 등)은 B09 단가로 못 셈 — 줄만 두고 빈칸
@@ -288,6 +283,10 @@ class Builder:
if call and call.get("code"):
key = sg.sangeun_key(call["code"], call["given"])
return {**head, "kind": "sangeun", "key": key, "qty": qty}
if (
call is not None and "machine" in call and own is not None
): # 키 모르는 굳은 기계 = M02 값
return {**head, "kind": "fixed", "qty": qty, "own": own, "link": {}}
return {**head, "kind": "blank", "qty": qty, "why": "하위 로직 줄 — 못 펼침"}
# ── 조합 · 사전조합 줄 ──────────────────────────────────────────────
@@ -347,11 +346,11 @@ class Builder:
"unit": doc.get("단위") or "", "qty": each} # fmt: skip
code = str(one.get("로직") or "")
if one.get("승격") is not True: # 단가산출 줄 = 산근
if not sg.is_money(whole, code):
if not sg.is_money(whole, code, self.shelf.of(whole)):
return {"kind": "blank", "name": name or code, "qty": q, "why": "돈 아닌 로직"}
key = sangeun_ref(code, one.get("입력값"), one.get("켜쌓기율"), one.get("고름"))
return {"kind": "sangeun", "key": key, "name": name or code,
"unit": sg.unit_of(whole, code), "qty": q} # fmt: skip
"unit": sg.unit_of(whole, code, self.shelf.of(whole)), "qty": q} # fmt: skip
bid = self.poomsem(whole, one, str(one.get("별칭") or "") or name)
if bid is None:
return {
@@ -624,15 +623,9 @@ def _engine_bases(engine: list[dict], items: list[dict]) -> dict[str, float]:
return out
def _base_of(formula: str) -> tuple[str | None, str]:
"""덧줄 식 → (밑수 갈래, 이름) — 모르는 꼴이면 (None, "")."""
if hit := BASE_PART.match(formula):
return f"part:{PART[hit.group(1)]}", hit.group(1)
if hit := BASE_LINE.match(formula):
return f"line:{hit.group(1)}", hit.group(1)
if BASE_LABOR.match(formula):
return "lines:labor", "인건비"
return None, ""
#: % 밑 이름(`Doc_Run.Answer.pct`) → 밑수 갈래(옛 덧줄 식 글 풀이 대신 · 855-F B9-6)
_BASE = {"노무비": "part:labor", "재료비": "part:material", "경비": "part:expense",
"인건비": "lines:labor"} # fmt: skip
def _plain(value: Any) -> Any:
+27 -49
View File
@@ -10,7 +10,8 @@
로직 줄이 부르는 다른 돈 로직(기계경비 밖) = 하위 산근(그 산근도 목록에 · 산근 → 산근).
풀이 = 사본 수식 문서(`수식.json`)를 M02 와 같은 계산기로 셈한 답 + 셈 기록(`B09_Estimation_Doc_Run` ·
855-F B9-3)에서 줄마다 수량 · 단가 · 자원 키 · 하위 산근 · % 줄 율 · 끝수를 읽음(옛 엔진 안 부름) ·
줄 이름 · 단위 · 종류 = 사본 로직 줄 글(B9-5 에서 문서로) · 산출근거 글 = 풀이 블록 + 문서 셈 답(B9-4) ·
줄 이름 · 단위 · 종류 = 수식 문서(`Doc_Run.row_of` · B9-6) · 산출근거 글 = 풀이 블록 + 문서
셈 답(B9-4) ·
단가 = B09 프로젝트 한 벌 굳힌 단가(144 · `compute_base` 표) — 노무 = 노무비목록표 ·
중기 = 중기목록표 노 · 재 · 경 · 재료 = 자재단가대비표 적용 단가 ·
% 줄(덧줄) = 엔진 식에 B09 비목 합.
@@ -46,10 +47,10 @@ from B08_Quantity.B08_Quantity_Haul_Cycle import fill_given
from B09_Estimation import B09_Estimation_Doc_Run as dr
from B09_Estimation import B09_Estimation_Sangeun_Sum as ss
from B09_Estimation import B09_Estimation_Sangeun_Text as st
from B09_Estimation import B09_Estimation_Sheet as sheet
from B09_Estimation.B09_Estimation_Calc_Base import SUPPLY, gap, num, rounddown, total
from B09_Estimation.B09_Estimation_Copy_Prices import bundle
from B09_Estimation.B09_Estimation_Store import ref_rows
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
from M02_MasterTemplete import M02_Item_Prices as item_prices
from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
@@ -62,7 +63,6 @@ from M02_MasterTemplete.M02_Item_Snapshot import (
from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, read_json
mf = item_prices.mf
import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠
PARTS = ("labor", "material", "expense")
COST_PART = {"노무비": "labor", "재료비": "material", "경비": "expense"}
@@ -122,7 +122,7 @@ def rows_of(folder: Path, whole: Any = None, docs: dict | None = None) -> list[d
out: list[dict[str, Any]] = []
def logic_line(code: str, given: Any, rate: Any, chosen: Any, promoted: bool) -> None:
if not is_money(whole, code):
if not is_money(whole, code, docs):
return
if not promoted:
out.append({"code": code, "given": _clean_given(given), "rate": rate, "picks": chosen})
@@ -181,21 +181,16 @@ def _unit(row: dict) -> tuple[str, Decimal]:
return unit, Decimal(per[0][0]) if len(per) == 1 else Decimal(1)
def unit_of(whole: Any, code: str) -> str:
"""산근 1 단위 이름(「원/10㎡」 = ㎡) — `whole` = 사본 단가 묶음."""
try:
return _unit(whole.logic(code))[0]
except mf.FormulaError:
return ""
def unit_of(whole: Any, code: str, docs: dict | None = None) -> str:
"""산근 1 단위 이름(「원/10㎡」 = ㎡) — 수식 문서 결과단위(`docs` = 사본 수식 문서)."""
row = dr.row(whole, {} if docs is None else docs, code)
return _unit(row)[0] if row else ""
def is_money(whole: Any, code: str) -> bool:
"""돈 로직(호표 줄 꼴)인지 — 없는 로직 · 흐름 · 결과 로직 = 아님."""
try:
row = whole.logic(code)
except mf.FormulaError:
return False
return not (isinstance(row.get("흐름"), dict) or "결과" in row)
def is_money(whole: Any, code: str, docs: dict | None = None) -> bool:
"""돈 문서(금액 줄 꼴)인지 — 없는 문서 · 결과 문서 = 아님(수식 문서 · 855-F B9-6)."""
row = dr.row(whole, {} if docs is None else docs, code)
return row is not None and "결과" not in row
def call_of(line: dict) -> dict[str, Any] | None:
@@ -236,11 +231,10 @@ def line_calls(
) -> dict[int, dict | None]:
"""로직 하나의 로직 호표 줄마다 `call_of`(호표 차례 n → 부른 것) — 못 셈 줄 = None ·
셈 = 문서 셈 답(`Doc_Run` · `docs` = 사본 수식 문서 · 없으면 그 자리 닫힌 묶음)."""
try:
row = whole.logic(code)
except mf.FormulaError:
return {}
docs = {} if docs is None else docs
row = dr.row(whole, docs, code)
if row is None:
return {}
got = dr.solve(
whole,
docs,
@@ -311,18 +305,18 @@ class Solver:
def _solve(self, whole: Any, src: dict[str, Any], depth: int) -> dict[str, Any]:
code = src["code"]
try:
row = whole.logic(code)
except mf.FormulaError as e:
return self._stop(code, code, f"로직 없음 — {e}")
docs = self.shelf.of(whole)
doc = dr.doc(whole, docs, code) # 수식 문서(855-F B9-6 · 옛 로직 줄 안 읽음)
if doc is None:
return self._stop(code, code, f"수식 문서 없음 「{code}」")
row = dr.row_of(doc)
name = str(row.get("이름") or code)
if isinstance(row.get("흐름"), dict) or "결과" in row:
if "결과" in row:
return self._stop(code, name, "돈 로직 아님(흐름 · 결과 로직) — 산근 풀이 꼴 없음")
unit, times = _unit(row)
rate = Decimal(str(src["rate"])) / 100 if src.get("rate") not in (None, 100) else None
lines: list[dict[str, Any]] = []
# 841-1 단가 = M02 셈(문서 셈) 줄 금액 ÷ 수량(켜쌓기율 없이 · 날 값 · B09 단가 책 안 읽음)
docs = self.shelf.of(whole)
shown = ss.doc_shown(row) # 작업량 Q = ROUND 2(엑셀 자리)
eng = dr.solve(whole, docs, code, src["given"], src.get("picks"), None, shown)
if eng is None:
@@ -340,7 +334,7 @@ class Solver:
self._extras(row, per or eng, lines)
head = self._text(whole, eng, lines, times, src.get("rate"))
self._aside(lines)
_annotate(whole, row, eng.env, lines)
sheet.annotate(whole, doc, lines) # 계산서 줄 덧칸(719-4) = 문서
except (ArithmeticError, KeyError, TypeError, ValueError) as e:
return self._stop(code, name, str(e) or type(e).__name__)
sums = ss.doc_totals(eng, lines) # 끝수 · 끝전 · 조정 = 문서 답 끝수(792-3)
@@ -362,7 +356,7 @@ class Solver:
"why": why,
"head": head,
"foot": foot,
"기준단위": msl._per_text(msl.mbs.result_per(row.get("결과단위"))) or None,
"기준단위": sheet.base_unit(doc),
}
@staticmethod
@@ -488,31 +482,15 @@ class Solver:
lines.append({**line, "price": {part: value}, part: money, "why": None})
def _annotate(whole: Any, row: dict, env: dict, lines: list[dict[str, Any]]) -> None:
"""719-4 계산서 줄 덧칸 `sheet`{쓰는입력 · 기준단위 · 환산근거} — `master_sheet_line` 한 벌
(M01 `/text` · M02 `/logic-lib/sheet` 와 같은 뜻) · 묶음 · 장비 = 줄 `kind` 로 화면이 가름."""
per = msl.mbs.result_per(row.get("결과단위"))
items = [*row.get("호표", []), *row.get("덧줄", [])]
for item, ln in zip(items, lines):
goods = ln.pop("_goods", None) or {}
exprs = [item["식"]] if "식" in item else [item.get("수량"), item.get("요소")]
seen = {"품목": goods, "단위": item.get("단위")}
try:
got = msl._fields(whole, row, exprs, dict(env), per, seen, None)
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
got = {}
ln["sheet"] = got
# ── 모음 ──────────────────────────────────────────────────────────────
LISTED = ("no", "key", "logic", "name", "spec", "spec_raw", "unit", "sum", *PARTS, "uses")
def _input_names(code: str) -> list[str]:
try:
return [str(i.get("이름")) for i in m01.loaded()[1].logic(code).get("입력") or []]
except mf.FormulaError:
return []
"""M01 기초 입력 이름 — 지금 수식 문서(855-F B9-6)."""
from M02_MasterTemplete import M02_Doc_Copy as dc
return item_prices.doc_inputs(dc.folder().get(str(code)))
def hand_sources(user: dict[str, Any] | None) -> list[tuple[str, str, dict[str, Any]]]:
+115
View File
@@ -0,0 +1,115 @@
"""B09 산근 계산서 줄 덧칸 `sheet`{쓰는입력 · 기준단위 · 환산근거}(719-4) — 수식 문서에서
(855-F B9-6) · 서버 단독(짝 없음).
옛 `master_sheet_line._fields`(옛 로직 줄 식 풀이)와 같은 뜻:
- `쓰는입력` = 그 줄 값(수량 · 단가 식)이 쓰는 문서 입력 변수 열쇠 — 식 변수 · 표 조건 ·
단가산출 넘긴 입력 · 요소 키 틀 · 재료 조건 글 구멍을 거슬러 감 · 문서 변수 차례.
- `기준단위` = 그 줄이 찾는 표의 기준(「10㎡」 · `master_basis.basis`) · 없으면 None.
- `환산근거` = 표 기준배 ↔ 결과단위 배 · 재료 품목 단위 ↔ 줄 단위(`master_unit.note`) · 없으면 「」.
"""
from __future__ import annotations
import re
from decimal import Decimal
from typing import Any
import master_basis as mbs # noqa: E402
import master_doc as md # noqa: E402
import master_unit as mu # noqa: E402
from B09_Estimation import B09_Estimation_Doc_Run as dr
from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠
_HOLE = re.compile(r"\{([^{}]+)\}")
def _times(x: Decimal) -> str:
return format(x.normalize(), "f")
def per_text(per: list[tuple[Decimal, str]]) -> str:
"""결과단위 분모 글(「10㎡」 · 여럿 = 「㎡ · ㎥」)."""
return " · ".join(dict.fromkeys(f"{_times(n) if n != 1 else ''}{u}" for n, u in per))
def base_unit(doc: dict) -> str | None:
"""답 머리 `기준단위` = 결과단위 분모."""
return per_text(mbs.result_per(doc.get("결과단위"))) or None
def _reach(doc: dict, texts: list) -> tuple[list[str], list[str]]:
"""식들이 쓰는 (입력 열쇠 · 표 키) — 식 변수 · 표 조건 · 단가산출 넘긴 입력을 거슬러 감."""
ids = {md.var_id(v): v for v in doc.get("변수") or []}
steps = {md.var_id(x): x.get("식") for x in doc.get("식") or []}
seen: set[str] = set()
tables: list[str] = []
todo = [t for t in texts if t not in (None, "")]
while todo:
try:
names = set(md.names(md.parse(todo.pop())))
except md.DocError:
continue
for name in names - seen:
seen.add(name)
link = (ids.get(name) or {}).get("연결") or {}
if name in steps:
todo.append(steps[name])
if link.get("갈래") == "표":
tables += [str(link["표"])] if link.get("표") and link["표"] not in tables else []
todo += [str(x) for x in (link.get("조건") or {}).values()]
elif link.get("갈래") == "단가산출":
todo += [str(x) for x in (link.get("입력") or {}).values()]
elif (
link.get("갈래") == "요소"
): # 키 틀 · 재료 조건 글 구멍(「LB:{S_직종}」 · 「{D_관}」)
cond = link.get("재료") if isinstance(link.get("재료"), dict) else {}
for text in [str(link.get("키") or ""), *(str(x) for x in cond.values())]:
todo += _HOLE.findall(text)
inputs = [
str(v["열쇠"])
for vid, v in ids.items()
if vid in seen and dr._kind(v) in dr.INPUTS and v.get("열쇠")
]
return inputs, tables
def _basis(whole: Any, tables: list[str]) -> dict | None:
for ref in tables:
try:
got = mbs.basis(whole.get(ref))
except Exception: # noqa: BLE001 — 없는 표 · 기준 없음 = 다음
continue
if got["갈래"] == "단위":
return got
return None
def _note(basis: dict | None, per: list, line: dict) -> str:
notes = []
if basis and len(per) == 1:
times, one = per[0]
if mu.plain(basis["기준단위"]) == mu.plain(mbs.unit(one)) and basis["기준배"] != times:
ratio = basis["기준배"] / times
how = f"÷{_times(ratio)}" if ratio > 1 else f"×{_times(1 / ratio)}"
notes.append(
f"{_times(basis['기준배'])}{basis['기준단위']}당 → {_times(times)}{one}당 {how}"
)
goods = line.get("품목") or {}
if goods.get("단위") and line.get("단위"):
notes.append(mu.note(goods["단위"], line["단위"]))
return " · ".join(n for n in notes if n)
def annotate(whole: Any, doc: dict, lines: list[dict[str, Any]]) -> None:
"""블록 줄마다 `sheet` — 줄 차례 = 문서 금액 줄 차례(호표 · 뒤 덧줄) · 제자리."""
per = mbs.result_per(doc.get("결과단위"))
for dl, ln in zip(doc.get("금액") or [], lines):
goods = ln.pop("_goods", None) or {}
inputs, tables = _reach(doc, [dl.get("수량"), dl.get("단가")])
basis = _basis(whole, tables)
unit = None
if basis:
unit = f"{_times(basis['기준배']) if basis['기준배'] != 1 else ''}{basis['기준단위']}"
seen = {"품목": goods, "단위": dl.get("단위")}
ln["sheet"] = {"쓰는입력": inputs, "기준단위": unit, "환산근거": _note(basis, per, seen)}
+109 -4
View File
@@ -22,7 +22,9 @@ from __future__ import annotations
import copy as cp
import hashlib
import json
import re
import sys
from decimal import Decimal
from pathlib import Path
from typing import Any
@@ -33,7 +35,6 @@ _SCRIPTS = str(Path(__file__).resolve().parents[1] / "resources/master_data/scri
if _SCRIPTS not in sys.path:
sys.path.insert(0, _SCRIPTS)
import master_auto as mau # noqa: E402
import master_doc as md # noqa: E402
import master_doc_calc as mc # noqa: E402
import master_doc_convert as cv # noqa: E402
@@ -262,17 +263,121 @@ def _apart(doc: dict, lines: list[dict], n: int) -> None:
later[slot] = md.text_of(_plus(node, cost, sym))
def given_of(whole: Any, code: str, given: Any) -> dict:
"""옛 `run_line` 과 같은 입력 — 빈 입력 = 자동값(M01 줄) › 받은 값."""
def given_of(whole: Any, code: str, given: Any, docs: dict | None = None) -> dict:
"""옛 `run_line` 과 같은 입력 — 빈 입력 = 자동값(`auto_of` · 문서 = `docs` › 값 사본 줄 문서) ›
받은 값."""
from M01_MasterData import M01_MasterData_Store as m01
try:
auto = {k: v for k, v in mau.values(whole, whole.logic(code)).items() if v is not None}
doc = (docs or {}).get(code) or doc_of(whole, code)
auto = {k: v for k, v in auto_of(doc, whole).items() if v is not None} if doc else {}
except _ERR:
auto = {}
return {**auto, **m01._dec(given or {})}
# ── 자동값(옛 `master_auto.values` 같은 규칙 · 문서에서 · 855-F B9-6) ──────────
_GUARD = re.compile(r"만약\(\s*(\w+)\s*>\s*0\s*,\s*\1\s*,")
_INPUTS = ("입력", "선택")
def _num(v: Any) -> Any:
try:
return Decimal(str(v)) if not isinstance(v, Decimal) else v
except ArithmeticError:
return v
def _fits(whole: Any, ref: str, cond: str) -> list:
"""표 `ref` 조건 칸 `cond` 에 드는 수 — 낮은 차례 · 범위 칸 = 줄마다 그 줄에 드는 끝."""
try:
table = whole.get(ref)
except _ERR:
return []
ranged = (table.get("조건") or {}).get(cond) == "범위"
out = set()
for r in table.get("줄") or []:
if r.get(cond) is None:
continue
low, high = r[cond] if ranged else (r[cond], None)
ends = [Decimal(0) if low is None else low, high]
out |= {v for v in ends if isinstance(v, Decimal) and ml._match(table, r, cond, v)}
return sorted(out)
def _lowest(whole: Any, uses: list) -> Any:
"""같은 입력을 여러 표가 쓰면 모두에 드는 가장 낮은 수 · 없으면 첫 표의 가장 낮은 수."""
sets = [_fits(whole, ref, cond) for ref, cond in uses]
both = sorted(set.intersection(*map(set, sets))) if sets else []
return (both or next((s for s in sets if s), [None]))[0]
def _divisors(doc: dict, ids: dict) -> set[str]:
"""나누는 자리에 든 이름 — 그 이름이 쓰는 이름(식 · 표 조건 · 단가산출 넘긴 입력)까지 ·
「만약(X > 0, X, 기본)」 의 X 는 안 퍼뜨림."""
texts = [x.get("식") for x in doc.get("식") or []]
texts += [(doc.get("결과") or {}).get("식") if isinstance(doc.get("결과"), dict) else None]
texts += [x.get(k) for x in doc.get("금액") or [] for k in ("수량", "단가")]
divs, guard = set(), set()
for text in (x for x in texts if x not in (None, "")):
guard |= set(_GUARD.findall(str(text)))
try:
divs |= {
n for p in md.walk(md.parse(text)) if p[:2] == ("bin", "/") for n in md.names(p[3])
}
except md.DocError:
continue
feeds: dict[str, list] = {}
for x in doc.get("식") or []:
feeds.setdefault(md.var_id(x), []).append(x.get("식"))
for vid, v in ids.items():
link = v.get("연결") or {}
part = {"표": "조건", "단가산출": "입력"}.get(str(link.get("갈래")))
if part:
feeds.setdefault(vid, []).extend((link.get(part) or {}).values())
todo = list(divs)
while todo:
for text in feeds.get(todo.pop(), []):
try:
more = set(md.names(md.parse(text))) - guard - divs
except md.DocError:
continue
divs |= more
todo += list(more)
return divs
def auto_of(doc: dict, whole: Any) -> dict:
"""문서 입력마다 자동값 — 고르기 = 목록 첫째 · 범위 = 아래 끝 · 표 조건 값 = 그 표 가장 낮은
수 · 나누는 자리 = 1 · 그 밖 0 · 가격(원) 입력 = None(1,521 문서 옛 `master_auto` 와 같음)."""
ids = {md.var_id(v): v for v in doc.get("변수") or []}
finds: dict[str, list] = {}
for v in ids.values():
link = v.get("연결") or {}
if link.get("갈래") == "표":
for col, arg in (link.get("조건") or {}).items():
if isinstance(arg, str) and arg in ids:
finds.setdefault(arg, []).append((link.get("표"), col))
divs = _divisors(doc, ids)
out: dict[str, Any] = {}
for vid, v in ids.items():
link = v.get("연결") or {}
if link.get("갈래") not in _INPUTS or not v.get("열쇠"):
continue
name = str(v["열쇠"])
if link.get("목록"):
out[name] = link["목록"][0]
elif link.get("범위"):
out[name] = _num(link["범위"][0])
else:
got = _lowest(whole, finds.get(vid, []))
if got is None and "원" in str(v.get("단위") or ""):
out[name] = None
else:
out[name] = got if got is not None else Decimal(1 if vid in divs else 0)
return out
def apart_of(marks: Any, mats: Any) -> list[int]:
"""별도계상 금액 줄 차례 — 옛 `drop_apart` 와 같은 판정(엔진 답 `재료` 의 차례 · 자재표시)."""
from M02_MasterTemplete import M02_Labor_Doc as labor
+11 -17
View File
@@ -22,6 +22,7 @@ from common_util.common_util_summary_item import GROUP_JOIN
from M02_MasterTemplete import M02_Item_Personal as personal
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Template_Layers as layers
from M02_MasterTemplete.M02_Doc_B09 import FILE as FORMULA_FILE
from M02_MasterTemplete.M02_Item_Snapshot import (
FOLDER_PATTERN,
LOCAL_FILES,
@@ -191,12 +192,9 @@ def write_file(
# ── 새로 가져오기 · 미리 가져오기 ─────────────────────────────────────
def _kept_values(values: Any, labor: dict[str, Any]) -> dict[str, Any]:
"""같은 로직 · 같은 입력 이름만 살림."""
names = {
str(row.get("키")): {spec["이름"] for spec in row.get("입력", [])}
for row in labor.get("로직", [])
}
def _kept_values(values: Any, docs: dict[str, dict]) -> dict[str, Any]:
"""같은 로직 · 같은 입력 이름만 살림(입력 = 새 사본 수식 문서 · 855-F B9-6)."""
names = {key: set(prices.doc_inputs(doc)) for key, doc in docs.items()}
out: dict[str, Any] = {}
for logic, inputs in (values or {}).items():
kept = {k: v for k, v in (inputs or {}).items() if k in names.get(logic, set())}
@@ -205,14 +203,10 @@ def _kept_values(values: Any, labor: dict[str, Any]) -> dict[str, Any]:
return out
def _kept_picks(picks: Any, labor: dict[str, Any]) -> dict[str, Any]:
"""같은 로직 · 있는 호표 차례만 살림."""
lines = {str(row.get("키")): len(row.get("호표", [])) for row in labor.get("로직", [])}
slots = { # 흐름 로직 — 고른 자재는 재료 자리 이름(= 입력 이름)
str(row.get("키")): {s["이름"] for s in row.get("입력", [])}
for row in labor.get("로직", [])
if isinstance(row.get("흐름"), dict)
}
def _kept_picks(picks: Any, docs: dict[str, dict]) -> dict[str, Any]:
"""같은 로직 · 있는 줄 차례(문서 금액 줄) · 흐름 로직 재료 자리 이름(= 입력 이름)만 살림."""
lines = {key: len(doc.get("금액") or []) for key, doc in docs.items()}
slots = {key: set(prices.doc_inputs(doc)) for key, doc in docs.items()}
out: dict[str, Any] = {}
for logic, chosen in (picks or {}).items():
kept = {
@@ -238,12 +232,12 @@ def reapply(
picks = read_json(target / PICKS_FILE)
before = {name: read_json(target / file) for name, file in KINDS.items()}
files = build_snapshot(manifest["원본"])
labor = files.get(LABOR_FILE) or {}
docs = (files.get(FORMULA_FILE) or {}).get("문서") or {} # 새 사본 수식 문서
seeded = files[VALUES_FILE] # 새 원본의 첫 값 — 프로젝트에서 넣은 값이 같은 키면 이김
kept_values = _kept_values(values, labor)
kept_values = _kept_values(values, docs)
for logic, inputs in kept_values.items():
seeded[logic] = {**seeded.get(logic, {}), **inputs}
files[PICKS_FILE] = _kept_picks(picks, labor)
files[PICKS_FILE] = _kept_picks(picks, docs)
for old in target.glob("*.json"): # 원본에서 빠진 파일(도면 없앰 등)은 지움
if old.name != MANIFEST_NAME and old.name not in files:
old.unlink()
+33 -12
View File
@@ -303,22 +303,43 @@ def load_prices(prices: dict[str, Any]) -> Any:
def _logic_keys(labor: dict[str, Any]) -> list[str]:
"""담은 로직 키 — 참조 줄(로직 없음 · 50-3)은 뺌."""
return [key for key in mcb.logic_keys(labor.get("줄") or {}) if key]
lines = (labor.get("줄") or {}).get("담은로직") or []
return [str(one["로직"]) for one in lines if isinstance(one, dict) and one.get("로직")]
def missing_inputs(snapshot: Any, labor: dict[str, Any], values: dict[str, Any]) -> list[dict]:
"""담은 로직마다 값이 없는(null · 안 적음) 입력 — `{로직, 입력}`."""
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):
try:
row = snapshot.logic(key)
except mf.FormulaError:
continue
mine = values.get(key) or {}
for spec in row.get("입력", []):
got = mine.get(spec["이름"])
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, "입력": spec["이름"]})
out.append({"로직": key, "입력": name})
return out
@@ -401,7 +422,7 @@ def line(whole: Any, docs: dict[str, dict] | None, one: dict[str, Any]) -> dict[
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("입력값"))
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))
@@ -450,5 +471,5 @@ def calc(
return {
**got,
"알약": saved if isinstance(saved, list) else labor_doc.pills(doc),
"빠진입력": missing_inputs(snapshot, labor, values or {}),
"빠진입력": missing_inputs(docs, labor, values or {}),
}
@@ -0,0 +1,175 @@
# -*- coding: utf-8 -*-
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
"""
from __future__ import annotations
from decimal import Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
from master_material import ( # noqa: E402, F401
LINKED,
PICK_KEYS,
REGION,
SLOTS,
TARIFF,
candidates,
check_pick,
check_unit,
static,
cond_text,
element,
pick,
)
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
@@ -11,7 +11,7 @@
from __future__ import annotations
import master_doc as md
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_keys as mk
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
@@ -20,7 +20,7 @@ from pathlib import Path
import master_doc as md
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
import master_machine_crew as mcrew
import master_material as mm
import master_pick as mp
@@ -13,7 +13,7 @@
from __future__ import annotations
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
class Rec:
+16 -143
View File
@@ -3,6 +3,7 @@
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
@@ -12,15 +13,22 @@ import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
BUNDLE,
COST_ITEMS,
GROUPS,
TABLE_GROUPS,
TABLE_IDS,
EmptyInput,
FormulaError,
Master,
NoRow,
_match,
_name,
_plain,
find,
)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
raise FormulaError(FLOW_GONE)
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
@@ -57,11 +53,6 @@ class Blank:
self.why = why
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
@@ -257,70 +248,6 @@ def walk(node):
yield from walk(item)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
@@ -284,5 +284,5 @@ def element(
return min(offers, key=lambda x: x[0]) if offers else (None, None)
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_pick as mp # noqa: E402 — 검색어 찾기
+1 -1
View File
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
return []
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
+3 -3
View File
@@ -5,15 +5,15 @@
"calc_user": "6d74551273d6735f",
"daega_inputs": "8b605fa95c5b9db4",
"수요": "23b0132a8a7f46f7",
"산근 값": "38455c2edce885ff",
"산근 값": "6072e1180a1b81e7",
"산근 글": "f5b884a2c49c91c6",
"산근 관급 값": "d154925ee64c985c",
"산근 관급 값": "6568e5cf9322b81c",
"산근 관급 글": "9397c1d1a5fe0dcd",
"미리보기 hand:rate 값": "091690571b7dc54b",
"미리보기 hand:rate 글": "d17615784f25e4f5",
"미리보기 hand:pick 값": "6c7f426d37e31998",
"미리보기 hand:pick 글": "7836022de46b3072",
"미리보기 hand:net 값": "b1c2c650567a14ae",
"미리보기 hand:net 값": "e2809bd3259438b0",
"미리보기 hand:net 글": "0254ea22d7a23e43",
"B08 단위수량": "896710398b04b4fd"
}
+11 -8
View File
@@ -103,15 +103,18 @@ def test_구조물_사본_SK_줄_재생성_덮개_입력값_고른자재_그대
}
)
def build(_item_): # 원본 층 → 사본 파일(구조물 원본 대신 이 일위대가 문서)
def build(
_item_,
): # 원본 층 → 사본 파일(구조물 원본 대신 이 일위대가 문서 · 수식.json 도 실제 길처럼)
from M02_MasterTemplete import M02_Doc_B09 as doc_b09
rows = source.labor_doc_rows(doc)
return _json(
{
source.LABOR_FILE: rows,
source.PRICE_FILE: source.price_bundle(rows, world["personal"]),
snapshots.VALUES_FILE: {},
}
)
files = {
source.LABOR_FILE: rows,
source.PRICE_FILE: source.price_bundle(rows, world["personal"]),
snapshots.VALUES_FILE: {},
}
return _json(doc_b09.attach(files))
monkeypatch.setattr(item_copy, "build_snapshot", build)
root = _project(tmp_path / "proj", [(100, "SS000901")])
+111
View File
@@ -0,0 +1,111 @@
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
"""
from __future__ import annotations
import hashlib
import json
import os
import subprocess
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
N = 24 # 견본 로직 수(키 차례 고르게)
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
"master_formula",
"master_formula_check",
"master_formula_sum",
"master_cut",
"master_text",
"master_text_item",
"master_auto",
"master_combo",
"master_sheet_line",
"master_gate",
"master_equation",
"check_master",
)
def _enc(v):
if isinstance(v, Decimal):
return {"$d": str(v)}
raise TypeError(type(v).__name__)
def _dec(d: dict):
return Decimal(d["$d"]) if set(d) == {"$d"} else d
def _child() -> None:
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
sys.path.insert(0, str(SCRIPTS))
import master_base as mb
import master_doc_calc as mc
import master_doc_link as ml
import master_machine_files as mmf
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
files = {}
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
if name == mmf.NAME and mmf.here(folder):
files[name] = mmf.table(folder)[0]
elif not name.startswith("_"):
raw = (folder / name).read_bytes()
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
docs = ml.load_all()
links = ml.Links(mb.Master(files), docs)
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
out = {}
for key, cases in want.items():
rows = []
for label, changed in cases:
try:
got = mc.calc(docs[key], links, changed)
except Exception:
got = None
rows.append([label, got if got and got.get("셈됨") else None])
out[key] = rows
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
import helper_855_engine as h
from helper_test_all import spread
rows, _, docs, _ = h.world()
rows = spread([r for r in rows if str(r["키"]) in docs], N)
want = {
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
}
run = subprocess.run(
[sys.executable, str(Path(__file__)), "--child"],
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
capture_output=True,
cwd=str(ROOT),
timeout=600,
)
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
body = json.loads(run.stdout.decode("utf-8"))
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
diff = []
for key, cases in body["답"].items():
got = [[label, h.answer(g)] for label, g in cases]
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
diff.append(key)
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
if __name__ == "__main__" and "--child" in sys.argv:
_child()