From 70d058492df481cf42af49bd54a34e0ac4f17206 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 05:16:36 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-F=20B9-6):=20=EC=9E=90=EB=8F=99?= =?UTF-8?q?=EA=B0=92=20=C2=B7=20=EB=B9=88=20=EC=9E=85=EB=A0=A5=20=C2=B7=20?= =?UTF-8?q?=EC=9E=AC=EC=A0=81=EC=9A=A9=20=EC=9E=85=EB=A0=A5=20=EC=9D=B4?= =?UTF-8?q?=EB=A6=84=EC=9D=84=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C?= =?UTF-8?q?=EC=97=90=EC=84=9C=20=E2=80=94=20master=5Fauto=20=C2=B7=20?= =?UTF-8?q?=EC=82=AC=EB=B3=B8=20=EB=A1=9C=EC=A7=81=20=EC=A4=84=20=EC=9D=BD?= =?UTF-8?q?=EA=B8=B0=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Doc_Copy.given_of: 빈 입력 자동값 = 새 auto_of(문서 · 옛 master_auto 와 같은 규칙: 고르기 첫째 · 범위 아래 끝 · 표 조건 값 = 그 표 가장 낮은 수 · 나누는 자리 = 1(식 · 표 조건 · 단가산출 넘긴 입력까지 퍼뜨림) · 0 · 가격 입력 = 빈칸) · docs 인자(사본 수식 문서 먼저) · master_auto import 걷음 — 1,521 문서 옛 given_of 와 값 · 꼴 다름 0 - M02_Item_Prices.missing_inputs = 사본 수식 문서 입력 · doc_inputs 더함 · _logic_keys 에서 master_combo 걷음 · line 이 given_of 에 사본 문서를 넘김 - M02_Item_Copy 재적용 _kept_values · _kept_picks = 새 사본 수식.json 문서(입력 이름 · 금액 줄 수) — 일위대가.json 로직 사본 안 읽음 - B09_Estimation_Doc_Run.solve: given_of 에 사본 문서를 넘김 - 시험 test_719_2 재적용 견본이 사본에 수식.json 도 싣게(실제 build_snapshot 길과 같게 Doc_B09.attach) - 검증: 관련 + 핵심 + 855_golden + 855_2d_frozen 513 통과 · 실제 B09 프로젝트 답 해시 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- B09_Estimation/B09_Estimation_Doc_Run.py | 2 +- M02_MasterTemplete/M02_Doc_Copy.py | 113 +++++++++++++++++++++- M02_MasterTemplete/M02_Item_Copy.py | 28 +++--- M02_MasterTemplete/M02_Item_Prices.py | 32 +++--- resources/tester/test_719_2_sk_project.py | 19 ++-- 5 files changed, 152 insertions(+), 42 deletions(-) diff --git a/B09_Estimation/B09_Estimation_Doc_Run.py b/B09_Estimation/B09_Estimation_Doc_Run.py index c18511b22..61e4c9580 100644 --- a/B09_Estimation/B09_Estimation_Doc_Run.py +++ b/B09_Estimation/B09_Estimation_Doc_Run.py @@ -228,7 +228,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/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..0ad7bf1f4 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -303,22 +303,30 @@ 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 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 +409,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 +458,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/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")])