diff --git a/B09_Estimation/B09_Estimation_Bill_Library.py b/B09_Estimation/B09_Estimation_Bill_Library.py index a37e44a3f..f8c89b2a9 100644 --- a/B09_Estimation/B09_Estimation_Bill_Library.py +++ b/B09_Estimation/B09_Estimation_Bill_Library.py @@ -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: diff --git a/B09_Estimation/B09_Estimation_Doc_Run.py b/B09_Estimation/B09_Estimation_Doc_Run.py index c18511b22..e75b4a36e 100644 --- a/B09_Estimation/B09_Estimation_Doc_Run.py +++ b/B09_Estimation/B09_Estimation_Doc_Run.py @@ -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 — 계산기는 예외 없음이 원칙 · 남은 틈 = 못 셈 diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py index 8f3013c2f..b547f173a 100644 --- a/B09_Estimation/B09_Estimation_Labor_Source.py +++ b/B09_Estimation/B09_Estimation_Labor_Source.py @@ -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: diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py index 4de233051..1544dbb57 100644 --- a/B09_Estimation/B09_Estimation_Sangeun.py +++ b/B09_Estimation/B09_Estimation_Sangeun.py @@ -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]]]: diff --git a/B09_Estimation/B09_Estimation_Sheet.py b/B09_Estimation/B09_Estimation_Sheet.py new file mode 100644 index 000000000..7d99817f0 --- /dev/null +++ b/B09_Estimation/B09_Estimation_Sheet.py @@ -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)} diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index cb27f2b10..b053f1112 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -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 diff --git a/M02_MasterTemplete/M02_Item_Copy.py b/M02_MasterTemplete/M02_Item_Copy.py index 32940c06b..715a1a85d 100644 --- a/M02_MasterTemplete/M02_Item_Copy.py +++ b/M02_MasterTemplete/M02_Item_Copy.py @@ -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() diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 384b9fc01..83bd69728 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -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 {}), } diff --git a/resources/master_data/scripts/master_base.py b/resources/master_data/scripts/master_base.py new file mode 100644 index 000000000..8b405543e --- /dev/null +++ b/resources/master_data/scripts/master_base.py @@ -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 — 검색어 · 고름 · 단위 diff --git a/resources/master_data/scripts/master_doc_block.py b/resources/master_data/scripts/master_doc_block.py index fe466e96f..69ca054be 100644 --- a/resources/master_data/scripts/master_doc_block.py +++ b/resources/master_data/scripts/master_doc_block.py @@ -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`) diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 64d3d9b38..353c54126 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -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 diff --git a/resources/master_data/scripts/master_doc_record.py b/resources/master_data/scripts/master_doc_record.py index 49416118c..ee7b647b3 100644 --- a/resources/master_data/scripts/master_doc_record.py +++ b/resources/master_data/scripts/master_doc_record.py @@ -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: diff --git a/resources/master_data/scripts/master_formula.py b/resources/master_data/scripts/master_formula.py index 4cd540ecd..a5e35281d 100644 --- a/resources/master_data/scripts/master_formula.py +++ b/resources/master_data/scripts/master_formula.py @@ -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"): diff --git a/resources/master_data/scripts/master_material.py b/resources/master_data/scripts/master_material.py index c6e3b3f47..b12cf25f7 100644 --- a/resources/master_data/scripts/master_material.py +++ b/resources/master_data/scripts/master_material.py @@ -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 — 검색어 찾기 diff --git a/resources/master_data/scripts/master_pick.py b/resources/master_data/scripts/master_pick.py index ffc906650..e17db0c85 100644 --- a/resources/master_data/scripts/master_pick.py +++ b/resources/master_data/scripts/master_pick.py @@ -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 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 diff --git a/resources/tester/golden_855_b09.json b/resources/tester/golden_855_b09.json index 9e0b87e5f..9ba1b5615 100644 --- a/resources/tester/golden_855_b09.json +++ b/resources/tester/golden_855_b09.json @@ -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" } diff --git a/resources/tester/test_719_2_sk_project.py b/resources/tester/test_719_2_sk_project.py index c4edfbd4b..058ce82cb 100644 --- a/resources/tester/test_719_2_sk_project.py +++ b/resources/tester/test_719_2_sk_project.py @@ -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")]) diff --git a/resources/tester/test_855_e4a_base_only.py b/resources/tester/test_855_e4a_base_only.py new file mode 100644 index 000000000..4ff887b3a --- /dev/null +++ b/resources/tester/test_855_e4a_base_only.py @@ -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()