From 055bcfa9d523f8ccb884ad5377985e9c102efe75 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 09:37:53 +0900 Subject: [PATCH 1/3] =?UTF-8?q?refactor(855-E=202-E4):=20=EB=8B=A8?= =?UTF-8?q?=EA=B0=80=EC=82=B0=EC=B6=9C=20=EA=B5=B3=ED=9E=8C=20=EC=98=9B=20?= =?UTF-8?q?=EC=82=AC=EB=B3=B8=20=EC=85=88=20=EA=B8=B8=20=EA=B1=B7=EC=9D=8C?= =?UTF-8?q?=20=E2=80=94=20Sangeun=5FCalc=20resolve=20=EB=AC=B4=EB=A6=AC=20?= =?UTF-8?q?=C2=B7=20Labor=5FExpand=20=EC=98=9B=20run=5Fline=20=EA=B0=88?= =?UTF-8?q?=EB=9E=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Sangeun_Calc: 굳힌 옛 사본(수식 사본 없음 · 바탕 로직 M01 문서 밖) 옛 엔진 셈 `_frozen` · 바탕 사슬 `resolve` · `_base_of` · `_fill` · `_defaults`(m01.mau) · `_gap` · `sub_run` · `_bundled` · `_bundles` · `_rated` · `_group` · `_direct` · `_Over` · `fingerprint` 지움 → 못 셈 + FROZEN_WHY(저장소 굳힌 SK 0 · 참조사본 든 층 파일 0) · 저장 검사 `_head_of` = 문서 머리(`_row_of`) · 바탕 참조 = 그 SK 바탕 머리(순환 · 깊이 422 그대로) - M02_Labor_Expand: 옛 단가승격 사본 갈래 · SC 굳힌 덮개 줄 갈래(run_line) 걷음 · 승격 재료 직접계산 표지 = 문서 금액 줄(재료비 · M01 로직 줄 안 읽음) - 시험: test_792_3 다섯 길의 ② SK 갈래(견본 로직 줄 = M01 문서 밖 → 굳힌 옛 사본 길만 붙듦) 걷음 · test_792_2 `_Over` 단언 걷음(지운 덮개만 봄) - 검증: 관련 + 지킴(855 golden · parity · b09 golden · 2d_frozen · sk_layers · trace · e4a · 857 · 858) + 관문 묶음 ①③⑤ 함께 506 + 고친 시험 24 통과 · 빌더 --check 같음 · typecheck 0 · 실제 B09 답 해시 같음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Labor_Expand.py | 40 +-- M02_MasterTemplete/M02_Sangeun_Calc.py | 328 ++------------------ resources/tester/test_792_2_calc_speed.py | 4 - resources/tester/test_792_3_engine_paths.py | 9 +- 4 files changed, 42 insertions(+), 339 deletions(-) diff --git a/M02_MasterTemplete/M02_Labor_Expand.py b/M02_MasterTemplete/M02_Labor_Expand.py index bddcd185c..e1032791e 100644 --- a/M02_MasterTemplete/M02_Labor_Expand.py +++ b/M02_MasterTemplete/M02_Labor_Expand.py @@ -13,6 +13,7 @@ from collections.abc import Callable from decimal import Decimal from typing import Any +from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Labor_Copy as lc from M02_MasterTemplete import M02_Labor_Fixed as fixed from M02_MasterTemplete import M02_Labor_Patch as patch @@ -86,28 +87,18 @@ class Expand: return {"이름": ref["키"], "단위": None, "기준": None, "까닭": why} def _promote(self, doc: dict) -> dict[str, Any]: - """옛 단가승격(SP · 134-2 앞 꼴) — 층 = 로직 줄과 같은 문서 셈(`Labor_Copy.line` · 옛 엔진 안 돎 · - 855 2-C5) · 프로젝트 사본 = 옛 길(B9 걸음 몫).""" + """옛 단가승격(SP · 134-2 앞 꼴 · 저장소 0) — 로직 줄과 같은 문서 셈(`Labor_Copy.line` · 855 2-C5) · + 로직 재료 = 직접계산(별도계상 안 뺌 · 옛 셈과 같음) · 사본 옛 엔진 갈래 걷음(855-E 2-E4).""" from M02_MasterTemplete import M02_Labor_Doc as labor line = (doc.get("담은로직") or [{}])[0] - if lc._project() or self.hands: - got = labor.run_line( - self.whole, - str(line.get("로직") or ""), - line.get("입력값"), - line.get("켜쌓기율"), - line.get("고름"), - ) - else: # 옛 승격 = 로직 자재 직접계산(별도계상 안 뺌 · 옛 셈과 같음) - code = str(line.get("로직") or "") - try: - items = self.whole.logic(code).get("호표") or [] - except Exception: # noqa: BLE001 — 없는 로직 = 셈이 까닭 - items = [] - direct = {"별도계상": "직접계산"} - marks = {str(n): direct for n, x in enumerate(items) if x.get("종류") == "재료"} - got = lc.line(self.whole, {}, {**line, "로직": code, "자재표시": marks}) + code = str(line.get("로직") or "") + money = (dc.doc_of(self.whole, code) or {}).get( + "금액" + ) or [] # 문서 금액 줄 차례 = 호표 차례 + direct = {"별도계상": "직접계산"} + marks = {str(n): direct for n, x in enumerate(money) if x.get("비목") == "재료비"} + got = lc.line(self.whole, {}, {**line, "로직": code, "자재표시": marks}) times = labor._number(doc.get("배")) or Decimal(1) base = got.get("기준") why = got.get("까닭") or (None if base else "돈 아닌 로직") @@ -133,16 +124,11 @@ class Expand: def _logic(self, one: dict, pill: dict | None, doc: dict | None = None) -> dict[str, Any]: """사전조합 안 로직 줄 — 일위대가 로직 줄과 같은 `Labor_Copy.line`(문서 셈) · 배는 물량 알약 것 · - 굳힌 덮개 줄(프로젝트 사본) = 옛 길(B9 걸음 몫).""" + 사본 굳힌 덮개 줄(`굳힌` · B9-5 뒤 0) 옛 엔진 갈래 걷음(855-E 2-E4).""" from M02_MasterTemplete import M02_Labor_Doc as labor - pill, fz = pill or {}, one.get("굳힌") - if isinstance(fz, dict) and fz.get("키"): # 사본 굳힌 덮개 줄(740-1 · `Item_Sangeun`) - got = labor.run_line( - self.whole, fz["키"], fz.get("입력값"), fz.get("켜쌓기율"), fz.get("고름") or None - ) - got = labor.drop_apart(got, fz.get("자재표시")) - elif one.get(patch.FIELD): # 줄 덮개(715-3) = 이름 없는 단가산출 · 별도계상까지 + pill = pill or {} + if one.get(patch.FIELD): # 줄 덮개(715-3) = 이름 없는 단가산출 · 별도계상까지 got = patch.run(self.whole, one, self.read) else: # 별도계상 로직 자재 뺌(222-1) · 수식 사본 SC = 문서 셈(802-4a) got = lc.line(self.whole, doc or {}, one) diff --git a/M02_MasterTemplete/M02_Sangeun_Calc.py b/M02_MasterTemplete/M02_Sangeun_Calc.py index 17212c7ce..a4a6ee5a2 100644 --- a/M02_MasterTemplete/M02_Sangeun_Calc.py +++ b/M02_MasterTemplete/M02_Sangeun_Calc.py @@ -2,8 +2,8 @@ 셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 · 기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 · -뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` · -`resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀). +뺀줄 · 더한줄 · 수식고침 · 식 칸) · 굳힌 옛 사본(수식 사본 없음 · 저장소 0) = 못 셈 + 까닭 하나(옛 엔진 길 · +`resolve` 바탕 사슬 걷음 · 855-E 2-E4). 계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만). 저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 · 바탕 머리 = 기초 문서(855 L2 ⓑ-3). SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` · @@ -14,14 +14,11 @@ SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위( from __future__ import annotations -import hashlib -import json -import re from decimal import Decimal from typing import Any from M02_MasterTemplete import M02_Doc_Sk as dsk # 수식 사본(802-4a) -from M02_MasterTemplete import M02_Labor_Doc as labor, M02_Labor_Fixed as fixed +from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Block as blk @@ -30,28 +27,6 @@ from M02_MasterTemplete import M02_Sangeun_Doc as sd, M02_Sangeun_Equation as eq COSTS = labor.COSTS Ref = dict[str, Any] -_SHARED = ("_market", "_by_class", "_found") # 마스터에만 따르는 자재 색인 · 찾기 답 - - -class _Over: - """M01 색인 위에 고친 줄 하나 — `logic(키)` 만 가로챔(그 밖 그대로 · 색인 안 고침).""" - - def __init__(self, whole: Any, key: str, row: dict) -> None: - self._whole, self._key, self._row = whole, key, row - - def logic(self, ref: str) -> dict: - return self._row if ref == self._key else self._whole.logic(ref) - - def __getattr__(self, name: str) -> Any: - return getattr(self._whole, name) - - def __setattr__(self, name: str, value: Any) -> None: - """자재 색인(`master_material`)은 속 M01 색인에 둠 — 셈마다 다시 안 지음(792-2) · - M01 파일 자국이 바뀌면 새 색인 = 새로 지음 · 그 밖은 이 덮개에만.""" - if name in _SHARED: - setattr(self._whole, name, value) - else: - super().__setattr__(name, value) def _fail(e: sd.DocError) -> store.StoreError: @@ -99,153 +74,6 @@ def ratio_of(doc: dict, row: dict, whole: Any) -> Decimal: return swap["배"] -def fingerprint(row: dict) -> str: - raw = json.dumps(row, ensure_ascii=False, sort_keys=True, default=str) - return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] - - -# ── 바탕 사슬 → 고친 줄 ───────────────────────────────────────────────── -def _base_of(doc: dict, whole: Any, read: Any, trail: tuple[str, ...]) -> dict[str, Any]: - """이 SK 가 얹힐 바탕 — {줄, 고름, 자재표시, 입력값, 켜쌓기율, 짝잃음}.""" - base = doc.get("바탕") - empty = {"고름": {}, "자재표시": {}, "입력값": {}, "켜쌓기율": None, "짝잃음": []} - if not base or "로직" in base: # 사본(795-1) · 가져온 식 · 그 위 수식 고침(796-2b) - try: - row = skc.over(doc, whole).logic(base["로직"]) if base else sd.empty_row(doc) - except Exception as e: # noqa: BLE001 — 엔진 FormulaError - raise sd.DocError(f"바탕 로직 · {e}") from e - if any(x.get("참조") for x in row.get("호표") or []): # 가져온 식 안쪽 산근(797-1) 값 채움 - from M02_MasterTemplete.M02_Labor_Expand import Expand - - row = {**row, "호표": [dict(x) for x in row["호표"]]} - _bundles(row, whole, Expand(whole, read), trail) - row, lost = eqm.on(row, doc, skc.over(doc, whole)) - return {**empty, "줄": row, "짝잃음": lost} - ref = base["참조"] - rid = refs.ref_id(ref) - if rid in trail: - keys = [t.rsplit("|", 1)[-1] for t in (*trail, rid)] - raise sd.DocError("순환 — " + " → ".join(keys), 422) - if len(trail) >= refs.DEPTH: - raise sd.DocError(f"바탕 사슬이 {refs.DEPTH}단을 넘음", 422) - parent = read(ref) - if not isinstance(parent, dict): - raise sd.DocError(f"없는 바탕 「{ref.get('키')}」") - up = resolve(parent, whole, read, (*trail, rid)) - lost = [{**x, "바탕": ref.get("키")} for x in up["짝잃음"]] - return {**up, "짝잃음": lost} - - -def resolve( - doc: dict, - whole: Any, - read: Any = refs.read_ref, - trail: tuple = (), - given: dict | None = None, - line: bool = False, -) -> dict[str, Any]: - """SK 문서 → 고친 줄 `{줄, 고름, 자재표시, 정체, 짝잃음, 입력값, 켜쌓기율, 배, 바탕판}` · - `trail` = 지나온 참조 이름표(순환 · 깊이 422) · `given` = 공통 옵션(더한줄 로직 입력).""" - base = _base_of(doc, whole, read, trail) - common = {**base["입력값"], **(doc.get("입력값") or {}), **(given or {})} - doc, lack = _fill(doc, whole, common) - got = sd.patched(base["줄"], doc, base["고름"], base["자재표시"]) - items = got["줄"]["호표"] - if not line: - _direct(got["자재표시"], items) - for at, cid in enumerate(got["정체"][: len(items)]): - hit = re.match(r"^add:#(\d+)$", cid) - if hit and int(hit[1]) in lack: - items[at] = _gap(items[at], lack[int(hit[1])]) - elif hit and sd.sub_patched(doc["더한줄"][int(hit[1])]): # 고친 둘째 기초 = 셈한 값묶음 - sub = sub_run(doc["더한줄"][int(hit[1])], whole) - got["짝잃음"] += [{**x, "cid": f"{cid}/{x['cid']}"} for x in sub["짝잃음"]] - items[at] = _bundled(items[at], sub) - rate = doc.get("켜쌓기율", base["켜쌓기율"]) - return { - **got, - "채운더한줄": doc["더한줄"], - "짝잃음": base["짝잃음"] + got["짝잃음"], - "입력값": {**base["입력값"], **(doc.get("입력값") or {})}, - "켜쌓기율": rate, - "배": ratio_of(doc, base["줄"], whole), - "바탕판": fingerprint(base["줄"]), - } - - -def _direct(marks: dict, items: list) -> None: - """SK 재료 줄 별도계상 빈 칸 = 직접계산(747-1 · 제자리) — 다른 두 칸은 그대로.""" - for n, item in enumerate(items): - if item.get("종류") == "재료": - marks[str(n)] = {"별도계상": "직접계산", **labor.marks(marks.get(str(n)))} - - -# ── 못 셈 줄 = 그 줄만 빠짐(725-1 · 725-2) ───────────────────────────────── -NO_QTY = "수량 없음" # `M02_Labor_Expand.NO_QTY` 와 같은 글(가져오기 둘레 피함) -NO_QTY_WHY = "수량 없음 — 쓰는 자리에서 연결" - - -def _defaults(whole: Any, code: str) -> dict: - """로직 기본값 = M01 견본 입력(`/m01/logic/auto` 와 같은 길).""" - from M01_MasterData import M01_MasterData_Store as m01 - - try: - got = {"값": m01.mau.values(whole, whole.logic(code))} - except Exception: # noqa: BLE001 — 없는 로직 · 자동값 못 셈 = 기본값 없음 - return {} - return got.get("값") or {} - - -def _fill(doc: dict, whole: Any, common: dict) -> tuple[dict, dict[int, str]]: - """더한줄 로직 입력 = 줄 값 › 공통 옵션 › 로직 기본값 — (채운 사본, {더한줄 차례: 까닭}).""" - adds, lack = [], {} - for k, one in enumerate(doc.get("더한줄") or []): - if one.get("종류") != "로직": - adds.append(one) - continue - try: - names = [str(s.get("이름")) for s in whole.logic(one["로직"]).get("입력") or []] - except Exception: # noqa: BLE001 — 없는 로직 = 검사(`sd.clean`)가 먼저 막음 - names = [] - mine = dict(one.get("입력값") or {}) - blank = [n for n in names if mine.get(n) is None or not str(mine[n]).strip()] - auto = _defaults(whole, one["로직"]) if blank else {} - for n in blank: - mine.pop(n, None) - for v in (common.get(n), auto.get(n)): - if v is not None and str(v).strip(): - mine[n] = v - break - miss = [n for n in names if n not in mine] - if miss: - lack[k] = f"입력 「{miss[0]}」 없음" - adds.append({**one, "입력값": mine}) - return {**doc, "더한줄": adds}, lack - - -def _gap(item: dict, why: str) -> dict: - """못 셈 줄 → 0 값묶음 줄(차례 그대로 · 계에 안 듦) + `빠짐` 까닭.""" - zero = dict.fromkeys(COSTS, Decimal(0)) - head = {k: item.get(k) or "" for k in ("이름", "단위")} - return {**head, "종류": "로직", "요소": None, "수량": item["수량"], "값묶음": zero, "빠짐": why} - - -# ── 둘째 기초 세부(727-2) ───────────────────────────────────────────────── -def sub_run(one: dict, whole: Any, patched: bool = True) -> dict[str, Any]: - """더한줄 로직 하나(둘째 기초 · 옛 칸) — 수식 사본 없음 = 못 셈 + 까닭(855 2-C1 · 옛 엔진 안 돎).""" - return {"기준": None, "까닭": dsk.OLD_WHY, "정체": [], "짝잃음": [], "바탕판": ""} - - -def _bundled(item: dict, sub: dict) -> dict: - """고친 둘째 기초 줄 → 셈한 1 기준단위 노 · 재 · 경 `값묶음` 줄(수량 그대로) · - 못 셈 = `_gap`.""" - if not sub.get("기준"): - return _gap(item, str(sub.get("까닭") or "돈 아닌 로직")) - head = {k: item.get(k) or "" for k in ("이름", "단위")} - bundle = {k: Decimal(str(sub["기준"][k])) for k in COSTS} - return {**head, "종류": "로직", "요소": None, "수량": item["수량"], "값묶음": bundle} - - def tag_of(whole: Any, code: str) -> str: """꼬리표 = 기초 원문번호(「9-12-1」 · 문서 이름표 855 L2 ⓑ-3) · 없으면 키.""" try: @@ -254,30 +82,6 @@ def tag_of(whole: Any, code: str) -> str: return code -def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None: - """더한줄 참조 · 고정 줄 `값묶음` = 1 단위 노 · 재 · 경 — 못 셈 줄 = `_gap`(나머지 셈 계속).""" - for at, item in enumerate(row["호표"]): - if item.get("값묶음") is not None or not ("참조" in item or "고정" in item): - continue - if "참조" in item and item.get( - "기준" - ): # 가져온 식 산근 속 산근(797-1) — 부르는 쪽 단가기준 - sub = expand(item["참조"], trail, item["기준"]) - else: - sub = expand(item["참조"], trail) if "참조" in item else fixed.line(whole, item["고정"]) - item["이름"] = item.get("이름") or sub.get("이름") or "" - item["단위"] = item.get("단위") or sub.get("단위") or "" - if sub.get("기준") is None: - why = str(sub.get("까닭") or "") - row["호표"][at] = _gap(item, NO_QTY_WHY if NO_QTY in why else why) - continue - item["값묶음"] = {k: Decimal(str(sub["기준"][k])) for k in COSTS} - if item.get("참조비목") in COSTS: # 안쪽 산근의 그 비목만(엑셀이 비목마다 한 줄로 부른 때) - item["값묶음"] = { - k: v if k == item["참조비목"] else Decimal(0) for k, v in item["값묶음"].items() - } - - def _row_of(doc: dict, whole: Any) -> dict: """배가 읽는 바탕 머리(셈 아님) — 바탕 로직 = 기초 문서 머리(`sd.doc_row` · 855 L2 ⓑ-3) · 없음 = 빈 줄(가져온 식 = 그 줄).""" @@ -288,6 +92,10 @@ def _row_of(doc: dict, whole: Any) -> dict: raise sd.DocError(f"바탕 로직 · {e}") from e +#: 굳힌 옛 사본 SK(수식 사본 없음 · 바탕 로직이 M01 문서에 없음 · 저장소 0) — 옛 엔진 셈 걷음(855-E 2-E4) +FROZEN_WHY = "굳힌 옛 사본 — 수식 사본 없음 · [재생성] 으로 새로 가져와야 셈" + + def run( doc: dict, whole: Any, @@ -300,18 +108,15 @@ def run( """SK 셈(저장 안 함 · 855 2-C1) = 수식 사본 문서 셈 한 길 — 기준 · 1 단위 · 줄 · 비목 · 끝수 모두 문서 답(`M02_Doc_Sk.run`) · 줄 `cid` = 「금액#n」(문서 금액 줄 차례) · 줄 `단위` = 문서 금액 줄 단위 · 수식 사본 없음(바탕 참조 · 옛 칸 덮개 · 더한줄 …) = 못 셈 + 까닭 하나(옛 엔진 안 돎 · 올림 없음) · - 굳힌 사본(`M02_Doc_Sk.frozen` — B09 · 구조물 사본) = 옛 길(`_frozen` · B9 걸음 몫). - `given` · `_opts`(detail · line · seen) = 옛 길 손님 꼴 — 문서 셈은 안 씀(옛 길도 금액은 문서 답 · - 2-E2 에서 부르는 쪽과 같이 걷음). 틀린 단위 환산 = `sd.DocError`.""" - if dsk.frozen(doc): - return _frozen(doc, whole, given, read, expand, trail) + 굳힌 옛 사본(`M02_Doc_Sk.frozen`) = 못 셈 + `FROZEN_WHY`(옛 엔진 길 걷음 · 855-E 2-E4). + `given` · `read` · `expand` · `trail` · `_opts` = 부르는 쪽 꼴 — 문서 셈은 안 씀. 틀린 단위 환산 = `sd.DocError`.""" whole = skc.over(doc, whole) base = doc.get("바탕") or {} tag = tag_of(whole, base["로직"]) if "로직" in base else (base.get("참조") or {}).get("키") head = {"짝잃음": [], "빠진줄": [], "꼬리표": tag} - copy = dsk.copy_of(doc, whole) + copy = None if dsk.frozen(doc) else dsk.copy_of(doc, whole) if copy is None: - why = dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY + why = FROZEN_WHY if dsk.frozen(doc) else dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY none = {"기준": None, "1단위": None, "배": Decimal(1), "줄": [], "정체": []} return {**head, **none, "까닭": why, "수식셈": {"셈됨": False, "따로": False, "까닭": why}} row = _row_of(doc, whole) @@ -341,91 +146,6 @@ def run( return out | ({"결과": got["결과"]} if "결과" in got else {}) -def _frozen(doc: dict, whole: Any, given: Any, read: Any, expand: Any, trail: tuple) -> dict: - """굳힌 사본 SK(수식 없음) 옛 엔진 셈 — 2-C1 전 `run` 그대로(굳힌 줄 = 덮개 · 더한줄 없음) · B9 몫.""" - from M02_MasterTemplete.M02_Labor_Expand import Expand - - got = resolve(doc, whole := skc.over(doc, whole), read, trail, given) - row = {**got["줄"], "호표": [dict(x) for x in got["줄"]["호표"]]} - _bundles(row, whole, expand or Expand(whole, read), trail) - gaps = {at: x for at, x in enumerate(row["호표"]) if x.get("빠짐")} - key = str(doc.get("키") or "SK-000000") - names = {str(i.get("이름")) for i in row.get("입력") or []} - values = {k: v for k, v in {**got["입력값"], **(given or {})}.items() if k in names} - args = ( - _Over(whole, key, {**row, "키": key}), - key, - values, - got["켜쌓기율"], - got["고름"] or None, - ) - out = labor.run_line(*args) - lost = _rated(row, out.get("줄") or [], got["정체"], got["자재표시"], got["켜쌓기율"]) - if lost is not None: # 율 더한줄(778-4) — 밑을 넣고 다시 - out = labor.run_line(*args) - gap = {"단가": None, "금액": None, "비목": {}} - lines = [ - {**line, "cid": cid, **({**gap, "까닭": gaps[at]["빠짐"]} if at in gaps else {})} - for at, (cid, line) in enumerate(zip(got["정체"], out.get("줄") or [])) - ] - out = labor.drop_apart({**out, "줄": lines}, got["자재표시"]) - base = out.get("기준") - gone = [ - {"cid": got["정체"][at], "이름": x.get("이름") or "", "까닭": x["빠짐"]} - for at, x in gaps.items() - ] - head = {k: got[k] for k in ("정체", "바탕판", "배")} | {"짝잃음": got["짝잃음"] + (lost or [])} - unit = {k: Decimal(str(v)) / got["배"] for k, v in base.items()} if base else None - tag = tag_of(whole, str((doc.get("바탕") or {}).get("로직") or "")) - return {**out, **head, "1단위": unit, "빠진줄": gone, "꼬리표": tag} - - -def _group(item: dict, line: dict) -> str | None: - """율 밑 묶음(778-4) — 인력 · 재료 · 장비(기계경비 로직 · 기계 이음 고정 · 기계 줄) · 그 밖 None.""" - if isinstance(item.get("고정"), dict): - return fixed.group_of(item["고정"]) - if line.get("장비"): - return "장비" - return {"인력": "인력", "재료": "재료", "기계": "장비"}.get(str(item.get("종류"))) - - -def _rated(row: dict, eng: list, ids: list, marks: dict, stack: Any = None) -> list[dict] | None: - """율 더한줄(778-4) `값묶음` = {비목: 밑 ÷ 100} — 한 번 돈 엔진 줄(`eng` · 정체 `ids`)로 - `fixed.rate_base`(별도계상 재료 뺌 · 앞 율 줄 차례로 · 켜쌓기율 몫 뗌) · 제자리 · 율 줄 없음 = None · - 돌려줌 = 짝잃음(없는 기준 줄).""" - items = row["호표"] - at = [i for i, x in enumerate(items) if (x.get("고정") or {}).get("비율")] - if not at: - return None - rows = [ - {"키": cid, "묶음": _group(items[i] if i < len(items) else {}, x), "비목": x.get("비목")} - for i, (cid, x) in enumerate(zip(ids, eng)) - if i not in at - and not ( - i < len(items) and items[i].get("종류") == "재료" and labor.apart(marks.get(str(i))) - ) - ] - times = Decimal(str(stack)) / 100 if stack not in (None, 100) else Decimal(1) - lost = [] - for i in at: - rate, qty = items[i]["고정"]["비율"], Decimal(str(items[i]["수량"])) - if isinstance(rate["기준"], list): - lost += [ - {"cid": ids[i], "까닭": f"율 기준 줄 없음 「{k}」"} - for k in rate["기준"] or [""] - if fixed.split_key(k)[0] not in ids - ] - base = fixed.rate_base(rate["기준"], rows) / times - items[i] = { - **items[i], - "값묶음": {**dict.fromkeys(COSTS, Decimal(0)), rate["비목"]: base / 100}, - } - rows.append( - {"키": ids[i], "묶음": None, "비목": {rate["비목"]: base * qty / 100}, "율": True} - ) - return lost - - def unit(doc: dict, whole: Any, expand: Any, trail: tuple) -> dict[str, Any]: """펼침(`Expand`) 한 칸 — `{이름, 단위, 기준(1 단위), 까닭, 줄, 짝잃음}` · 못 셈 = 까닭.""" head = {"이름": doc.get("이름"), "단위": doc.get("단위")} @@ -496,15 +216,23 @@ def _check_refs(doc: dict, here_: refs.Here) -> None: refs._no_loop(ref, [me, ref]) -def _head_of(doc: dict, whole: Any) -> dict[str, Any]: - """저장 검사가 읽는 바탕 — 로직 바탕 · 옛 칸 고침 없음 = 기초 문서 머리(입력 이름 · 결과단위 · - 855 L2 ⓑ-3 로직 줄 안 읽음) · 그 밖(가져온 식 · 참조 · 옛 칸) = 바탕 사슬(`_base_of`).""" - if "로직" in (doc.get("바탕") or {}) and not dsk.patched(doc): - try: - return {"줄": sd.doc_row(whole, doc["바탕"]["로직"]), "짝잃음": []} - except Exception as e: # noqa: BLE001 — 엔진 FormulaError(없는 기초) - raise sd.DocError(f"바탕 로직 · {e}") from e - return _base_of(doc, whole, refs.read_ref, ()) +def _head_of(doc: dict, whole: Any, trail: tuple = ()) -> dict[str, Any]: + """저장 검사가 읽는 바탕 머리(855 L2 ⓑ-3 · 로직 줄 안 읽음) — 로직 바탕 = 기초 문서 머리 · 가져온 식 · + 바탕 없음 = 그 줄(`_row_of`) · 바탕 참조 = 그 SK 의 바탕 머리(순환 · 깊이 422) · 옛 칸 고침을 바탕 + 줄에 얹던 사슬(`resolve`) 걷음(855-E 2-E4).""" + ref = (doc.get("바탕") or {}).get("참조") + if not isinstance(ref, dict): + return {"줄": _row_of(doc, whole), "짝잃음": []} + rid = refs.ref_id(ref) + if rid in trail: + keys = [x.rsplit("|", 1)[-1] for x in (*trail, rid)] + raise sd.DocError("순환 — " + " → ".join(keys), 422) + if len(trail) >= refs.DEPTH: + raise sd.DocError(f"바탕 사슬이 {refs.DEPTH}단을 넘음", 422) + parent = refs.read_ref(ref) + if not isinstance(parent, dict): + raise sd.DocError(f"없는 바탕 「{ref.get('키')}」") + return _head_of(parent, whole, (*trail, rid)) def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: diff --git a/resources/tester/test_792_2_calc_speed.py b/resources/tester/test_792_2_calc_speed.py index 3373d4901..9f438e8d9 100644 --- a/resources/tester/test_792_2_calc_speed.py +++ b/resources/tester/test_792_2_calc_speed.py @@ -53,10 +53,6 @@ def test_색인은_M01_색인에_한_번_두번째_셈은_안_지음(monkeypatch assert again["기준"] == first["기준"] and first["기준"]["계"] == 51419 assert all(vars(whole)[n] is v for n, v in held.items()) assert found == [] # 같은 조건 찾기 = 기억한 답(자재품목 3만 줄을 안 훑음) - over = calc._Over(whole, "SK-000001", {}) - assert over._market is whole._market and "_market" not in vars(over) - over.mine = 1 # 그 밖 칸은 덮개에만 - assert "mine" not in vars(whole) def test_M01_파일이_바뀌면_새_색인_새로_지음(tmp_path): diff --git a/resources/tester/test_792_3_engine_paths.py b/resources/tester/test_792_3_engine_paths.py index e071b0fb7..d04b71b21 100644 --- a/resources/tester/test_792_3_engine_paths.py +++ b/resources/tester/test_792_3_engine_paths.py @@ -1,7 +1,7 @@ # ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 """792-3 · 792-4 엔진 새 의미 다섯 길 지킴 시험 — 같은 로직 JSON 이 ① 엔진 직접(`master_cut.engine`) · -② M02 단가산출 SK 셈(`M02_Sangeun_Calc.run`) · ③ 일위대가 SC 한 줄(수량 1 · `M02_Labor_Doc.calc`) · +② M02 단가산출 SK 셈(견본 로직 줄 = M01 문서 밖 → 굳힌 옛 사본 = 못 셈 · 855-E 2-E4 에서 뺌) · ③ 일위대가 SC 한 줄(수량 1 · `M02_Labor_Doc.calc`) · ④ B09 산근 풀이(`B09_Estimation_Sangeun.Solver` · 841-1 단가 = M02 엔진) · ⑤ B09 일위대가 대가 블록(SC → 사본 SK 참조 수량 1 · `Labor_Source.Builder` → `Calc_Labor` 파이썬 · TS 짝 · 내역 단가 `daega_price`)에서 같은 금액. @@ -74,12 +74,6 @@ def _engine(master, row) -> dict: return {k: got[k] for k in COSTS} -def _sk(master, row) -> dict: - doc = {"키": "SK-990001", "이름": "시험", "단위": "식", "바탕": {"로직": _key(row)}} - got = sc.run(sd.clean(doc, None, master), master) - return {k: got["기준"][k] for k in COSTS} - - def _sc(master, row) -> dict: mats = { str(n): {"별도계상": "직접계산"} for n, x in enumerate(row["호표"]) if x["종류"] == "재료" @@ -172,7 +166,6 @@ def test_다섯_길_같은_금액(name): one = _engine(master, row) if want is not None: assert one == want # 엑셀 금액 - assert _sk(*build()[:2]) == one assert _sc(*build()[:2]) == one assert _b09(build, row) == one assert _b09_daega(build) == one # ⑤ B09 일위대가 대가 블록(792-4) From 5522aeab8de622c0da3b2a0a2e31609ad5aefb45 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 09:37:53 +0900 Subject: [PATCH 2/3] =?UTF-8?q?refactor(855-E=202-E4):=20=EA=B0=92=20?= =?UTF-8?q?=EC=82=AC=EB=B3=B8=20=EB=8B=AB=ED=9E=8C=20=EB=AC=B6=EC=9D=8C=20?= =?UTF-8?q?=3D=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EB=AC=B6?= =?UTF-8?q?=EC=9D=8C=20=E2=80=94=20Item=5FPrices.collect=20=EC=98=9B=20?= =?UTF-8?q?=EC=8B=9D=20=EA=B8=80=20=ED=9B=91=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_Item_Prices.collect: 로직 키 → `Doc_Copy.closure` 문서 묶음 → `Item_Bundle.collect`(자원 · 표 줄 · 로직 줄 없음) · M01 문서 없는 키 = `_빠진` · `extra`(마스터 밖 로직 줄) 안 받음(부르는 곳 0) · `_Collector` 옛 훑기 (refs · pick · flow · element · logic · row · `_texts`) 지움 — 옛 엔진 몸 부름 mf.parse · walk · fill · _HOLE · _expand · static 7 → 0 - M02_Item_Bundle: 구멍 값 후보 = 고르기 목록 · 빈 목록 = 끼울 값 없음 · 요소 칸을 읽는 변수(「EQ:{기계}」 의 조종원직종 · 주연료종류) = 그 줄 값(옛 `_choices` 와 같은 뜻 · 기계 = 인력 · 잡품 보기) - 대조: 값 사본(`skc.snap` → 로직 줄 뺀 꼴) 표본 로직 150 옛 = 새 같음(전엔 테이블 통째 20,227 줄 더 담김) - 시험: test_155_5 견본 = 문서 묶음 색인(고친 로직 줄 = 값 사본 줄 → 그 줄 문서) · test_item_copy_complete 닫힌 묶음 = 문서 셈 대조(옛 엔진 run 대조 걷음) - 검증: 묶음 ① 커밋 글과 같음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Item_Bundle.py | 59 +++++-- M02_MasterTemplete/M02_Item_Prices.py | 185 ++------------------ resources/tester/test_155_5_sangeun_text.py | 32 ++-- resources/tester/test_item_copy_complete.py | 38 ++-- 4 files changed, 97 insertions(+), 217 deletions(-) diff --git a/M02_MasterTemplete/M02_Item_Bundle.py b/M02_MasterTemplete/M02_Item_Bundle.py index 674440550..aedad2c82 100644 --- a/M02_MasterTemplete/M02_Item_Bundle.py +++ b/M02_MasterTemplete/M02_Item_Bundle.py @@ -17,18 +17,48 @@ from typing import Any from M02_MasterTemplete import M02_Item_Prices as prices import master_doc as md # noqa: E402 — scripts 길 = prices(m01) 뒤에 +import master_machine_crew as crew # noqa: E402 _HOLE = re.compile(r"\{([^{}]+)\}") -def _options(ids: dict, hole: str) -> list | None: - opts = ((ids.get(hole) or {}).get("연결") or {}).get("목록") - return [str(x).strip("'") for x in opts] if opts else None - - class _Docs(prices._Collector): """수식 문서가 잇는 자원 · 표 줄 키 모음.""" + def options(self, ids: dict, hole: str, depth: int = 0) -> list | None: + """구멍 변수의 값 후보 — 고르기 목록 · 요소 칸을 읽는 변수(「EQ:{기계}」 의 조종원직종 등) = 그 틀을 + 끼운 줄마다 그 칸 값(옛 식 글 훑기 `_expand` 와 같은 뜻) · 모름 = None.""" + link = (ids.get(hole) or {}).get("연결") or {} + if isinstance(link.get("목록"), list): # 빈 목록 = 끼울 값 없음(옛 `_choices` 와 같음) + return [str(x).strip("'") for x in link["목록"]] + if link.get("갈래") != "요소" or not link.get("키") or not link.get("칸") or depth > 3: + return None + keys = self._filled(str(link["키"]), ids, depth + 1) + if keys is None: + return None + out = [] + for key in keys: + try: + row = self.whole.get(key) + except prices.mf.FormulaError: + continue + vals = row.get("값") or {} # 줄 값 — 기계 = 인력 · 잡품 목록을 칸으로(842-3) + vals = crew.view(vals) if str(row.get("키"))[:2] == "EQ" else vals + value = vals.get(link["칸"]) if isinstance(vals, dict) else None + if value not in (None, ""): + out.append(str(value)) + return list(dict.fromkeys(out)) + + def _filled(self, text: str, ids: dict, depth: int = 0) -> list[str] | None: + """틀 글 → 끼운 글들 · 못 끼움 = None.""" + out = [text] + for hole in sorted(set(_HOLE.findall(text))): + opts = self.options(ids, hole, depth) + if opts is None: + return None + out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts] + return out + def doc(self, doc: dict) -> None: ids = {md.var_id(v): v for v in doc.get("변수") or []} for v in ids.values(): @@ -42,16 +72,13 @@ class _Docs(prices._Collector): self.add(ref) def fill(self, text: str, ids: dict) -> list[str]: - """틀 글 `{변수}` 구멍 → 고르기 목록으로 끼운 글들 · 목록 없는 구멍 = 그 테이블 전부(빈 목록).""" - out = [text] - for hole in sorted(set(_HOLE.findall(text))): - opts = _options(ids, hole) - if opts is None: - tid = prices.mk.id_of(text) - if tid and tid not in prices._TOO_BIG: - self.keys.update(self.whole.index.get(tid, {})) - return [] - out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts] + """틀 글 `{변수}` 구멍 → 값 후보로 끼운 글들(`options`) · 못 끼움 = 그 테이블 전부(빈 목록).""" + out = self._filled(text, ids) + if out is None: + tid = prices.mk.id_of(text) + if tid and tid not in prices._TOO_BIG: + self.keys.update(self.whole.index.get(tid, {})) + return [] return out def cond(self, cond: dict, unit: Any, ids: dict) -> None: @@ -61,7 +88,7 @@ class _Docs(prices._Collector): variants = [cond] holes = {h for v in cond.values() if isinstance(v, str) for h in _HOLE.findall(v)} for hole in sorted(holes): - opts = _options(ids, hole) + opts = self.options(ids, hole) if opts is None: variants = [prices.mm.static(cond)] break diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 263c05b4e..5581e0dda 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -23,7 +23,7 @@ from decimal import Decimal from typing import Any from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_MyMachine as mym +from M02_MasterTemplete import M02_MyMachine as mym # noqa: F401 — Item_Bundle.collect 가 씀 mf = m01.cm.mf mk = m01.mk @@ -39,18 +39,6 @@ def master() -> tuple[dict[str, dict], Any]: return m01.loaded() -def _texts(row: dict) -> list[str]: - out = [step["식"] for step in row.get("중간", [])] - if "결과" in row: - out.append(row["결과"]["식"]) - for item in row.get("호표", []): - out.append(item["수량"]) - if isinstance(item.get("요소"), str): # 단가산출 참조 · 고정 더한줄 = 요소 없음(719-1) - out.append(item["요소"]) - out += [extra["식"] for extra in row.get("덧줄", [])] - return out - - #: 재료 후보 찾기 답 — (마스터 색인, {조건 글: 키}) · 색인이 바뀌면(마스터 저장) 새로 · #: 복사본 목록이 복사본마다 단가 묶음을 다시 모아도 같은 조건은 한 번만 찾음(156-2) _FOUND: tuple[Any, dict[str, list[str]]] = (None, {}) @@ -73,22 +61,8 @@ class _Collector: def __init__(self, whole: Any): self.whole = whole self.keys: set[str] = set() - self.logics: set[str] = set() self.missing: list[str] = [] - def refs(self, row: dict, template: str) -> list[str]: - """원문번호 틀 → 닿을 수 있는 요소 참조 — 고르기로 끼우고, 못 풀면 그 테이블 전부.""" - if "{" not in template: - return [template] - expanded = mf._expand(row, template, self.whole) - if expanded is not None: - return expanded - tid = mk.id_of(template) - if not tid or tid in _TOO_BIG: - self.missing.append(f"{row.get('키')} 「{template}」 틀을 못 풂") - return [] - return list(self.whole.index.get(tid, {})) - def add(self, ref: str) -> None: try: row = self.whole.get(ref) @@ -119,113 +93,6 @@ class _Collector: if root.endswith(want) and u == unit_p and (not spec or s == spec): self.keys.add(key) - def pick(self, row: dict, cond: dict, unit: Any) -> None: - """재료 고르기 조건 — 대표 줄 · 후보 줄(`{입력}` 은 고르기 값으로 끼움).""" - if cond.get("지역") == "입력" or cond.get("계약종별") == "입력": - self.widely(cond, unit) - return - holes = sorted( - {h for v in cond.values() if isinstance(v, str) for h in mf._HOLE.findall(v)} - ) - variants = [cond] - if holes: - env_sets = mf._expand(row, "|".join(f"{{{h}}}" for h in holes), self.whole) - if env_sets is None: - variants = [mf.static(cond)] - else: - variants = [] - for filled in env_sets: - env = dict(zip(holes, filled.split("|"))) - variants.append( - {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in cond.items()} - ) - for one in variants: - if one.get("대표"): - self.add(str(one["대표"])) - if not one.get("구분") and not one.get("검색어"): - continue - for key in _candidates(self.whole, one): - self.add(key) - - def flow(self, row: dict) -> None: - """흐름 입력 상자 — 요소(고정 · 기본 · 검색어 묶음 · 조건 찾기 후보) · 표 · 다른 로직 · - 기계 시간당 경비 로직.""" - from M02_MasterTemplete.DataFlow import M02_DF_Values as dv # 흐름 값 찾기와 같은 뜻 - - for box in row["흐름"].get("boxes") or []: - inp = (box.get("input") or {}) if box.get("kind") == "input" else {} - if inp.get("mode") == "logic": - self.logic(str((inp.get("logic") or {}).get("key") or "")) - if inp.get("table"): - self.add(str(inp["table"].get("key") or "")) - for el in inp.get("elements") or []: - ref, unit = str(el.get("ref") or ""), el.get("unit") - for one in (ref, str(el.get("default") or "")): - cond = dv._pick(one) - if cond is not None: - self.pick(row, cond, unit) - elif one and not one.startswith("UE-"): - self.element(one) - if el.get("mode") != "rule": - continue - if inp.get("group") in dv.GROUP_RULE: # 인력 · 기계 · 유가전력 찾기 = 그 그룹 전부 - self.keys.update(str(r.get("키")) for r in dv._group_rows(inp["group"])) - elif dv._pick(ref) is None: # 재료 범위 찾기 — 범위(구분 · 상세구분) 후보 - scope = el.get("scope") or {} - self.pick( - row, {k: scope[k] for k in ("구분", "상세구분") if scope.get(k)}, unit - ) - - def element(self, ref: str) -> None: - """요소 키 · 「EQ키#칸」(시간당 경비면 그 기계경비 로직까지) · 「ID:원문번호{…}」 틀.""" - from M02_MasterTemplete.DataFlow import M02_DF_Values as dv - - base, _, field = ref.partition(dv.MACHINE_SEP) - if "{" in base: # 「EQ:{기계}」 같은 틀 — 그 테이블 전부 - self.keys.update(self.whole.index.get(mk.id_of(base) or "", {})) - return - self.add(base) - if field == dv.HOURLY: - from M02_MasterTemplete import M02_Machine_Hourly as mh - - row = self.whole.index.get(base[:2], {}).get(base) or {} - if got := mh.pick(row): # 식 고름 한 곳(822-2) - self.logic(str(got.get("키"))) - - def logic(self, key: str) -> None: - if key in self.logics: - return - try: - row = self.whole.logic(key) - except mf.FormulaError as error: - self.missing.append(f"{key} · {error}") - return - self.logics.add(key) - self.keys.add(key) - self.row(row) - - def row(self, row: dict) -> None: - """로직 줄 하나가 닿는 것 — 마스터 로직 · 굳힌 단가산출 줄(719-1 · 마스터 밖 줄).""" - if isinstance(row.get("흐름"), dict): # 흐름 로직 — 옛 칸 대신 흐름이 쓰는 것을 모음 - self.flow(row) - return - for text in _texts(row): - try: - node = mf.parse(text) - except mf.FormulaError: - continue # 못 읽는 식 — 계산도 같은 까닭으로 멈춤 - for part in mf.walk(node): - kind = part[0] - if kind == "ref" or kind == "find": - for ref in self.refs(row, part[1]): - self.add(ref) - elif kind == "logic": - for ref in self.refs(row, part[1]): - self.logic(ref) - for item in row.get("호표", []): - if isinstance(item.get("요소"), dict): - self.pick(row, item["요소"], item.get("단위")) - #: M01 에서 지워진 사본 줄(795-4) 자리 — `Master` 가 그룹 아닌 「줄」 로 읽음 COPY_FILE = "사본_남은줄.json" @@ -238,45 +105,19 @@ def collect( over: list[dict] | None = None, ) -> dict[str, Any]: """담은 로직 + 자재(MT)의 닫힌 단가 묶음 — `{파일 이름: 파일(줄은 모은 것만 · 차례 그대로)}` · - `extra` = 마스터 밖 로직 줄(굳힌 단가산출 719-1) — 그 줄이 닿는 것만 모음(줄은 안 담음) · - `over` = M02 로직 사본 줄(795-4) — 같은 키는 M01 줄 대신 · M01 에 없는 키 = `COPY_FILE`.""" - files, whole = master() - from M02_MasterTemplete import M02_Material_Own as mat + 닫힌 묶음 = 로직 키의 수식 문서 묶음(`M02_Doc_Copy.closure`)이 잇는 자원 · 표 줄(`M02_Item_Bundle.collect` + · 로직 줄 · 옛 식 글 훑기 없음 · 855-E 2-E4) · `over` = M02 값 사본 줄(795-4 · 같은 키는 M01 줄 대신) · + M01 수식 문서 없는 로직 키 = `_빠진` · `extra`(마스터 밖 로직 줄) = 받지 않음(부르는 곳 0).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle - whole = mat.whole( - mym.whole(whole) - ) # 지금 층 내 기계(821-1) · 내 재료(840-4) — 없으면 M01 그대로 - own = {str(r.get("키")): r for r in (*mym.added(whole), *mat.added(whole))} - mine = {str(r.get("키")): r for r in over or []} - if mine: - from M02_MasterTemplete import M02_Sangeun_Copy as skc - - whole = skc.Copy(whole, skc._rows({"로직": list(mine.values())})) - collector = _Collector(whole) - for key in logic_keys: - collector.logic(key) - for row in extra or []: - collector.row(row) - for code in materials or []: - collector.add(code) - out: dict[str, Any] = {} - seen: set[str] = set() - for name, data in files.items(): - slot = m01.items_key(data) - rows = [ - mine.get(str(row.get("키")), row) - for row in data.get(slot) or [] - if str(row.get("키")) in collector.keys - ] - seen.update(str(row.get("키")) for row in rows) - if rows: - out[name] = {**{k: v for k, v in data.items() if k != slot}, slot: rows} - left = [r for k, r in {**own, **mine}.items() if k in collector.keys and k not in seen] - if left: - out[COPY_FILE] = {"그룹": "사본", "줄": left} - if collector.missing: - out["_빠진"] = sorted(set(collector.missing)) - return out + keys = [str(k) for k in logic_keys] + docs = dc.closure(master()[1], keys) + out = item_bundle.collect(docs, materials, over) + lost = sorted( + set(out.pop("_빠진", [])) | {f"{k} · 수식 문서 없음" for k in keys if k not in docs} + ) + return out | ({"_빠진": lost} if lost else {}) def to_json(value: Any) -> Any: diff --git a/resources/tester/test_155_5_sangeun_text.py b/resources/tester/test_155_5_sangeun_text.py index 5fa3f51f4..c5e4f517a 100644 --- a/resources/tester/test_155_5_sangeun_text.py +++ b/resources/tester/test_155_5_sangeun_text.py @@ -22,15 +22,27 @@ BASE = "GF000218" # 기초다짐 및 뒷채움(기계) — 보통인부 + 굴 GIVEN = {"규격": 150, "지역": "전국평균", "보정작업": "해당 없음"} +def _copy(codes, over=None): + """사본 셈 색인(855-E 2-E4) = 수식 문서 묶음 + 그 문서가 잇는 자원 · 표 줄(`Item_Bundle.load`) · + `over` = 견본 값 사본 색인(고친 로직 줄 → 그 줄 문서).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure(over or item_prices.master()[1], codes) + return item_bundle.load(item_prices.to_json(item_bundle.collect(docs)), docs) + + def _whole(edit=None): - """사본 단가 묶음 — `edit(로직 줄)` 로 GF000218 을 엑셀 견본 꼴로 바꿈(수량 · 중간 · 덧줄).""" - files = copy.deepcopy(item_prices.to_json(item_prices.collect([BASE]))) - if edit: - for data in files.values(): - for row in data.get("줄") or []: - if isinstance(row, dict) and row.get("키") == BASE: - edit(row) - return item_prices.load_prices(files) + """사본 셈 색인 — `edit(로직 줄)` 로 GF000218 을 엑셀 견본 꼴로 바꿈(수량 · 중간 · 덧줄 · 고친 줄 = + 값 사본 줄 → 그 줄 문서).""" + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + if not edit: + return _copy([BASE]) + master = item_prices.master()[1] + row = copy.deepcopy(item_prices.to_json(master.logic(BASE))) + edit(row) + return _copy([BASE], skc.Copy(master, skc._rows({"로직": [row]}))) def _excel(qty_labor: str, qty_eq: str, mids=(), extras=()): @@ -102,7 +114,7 @@ def test_켜쌓기율_꼬리(): def test_글_속_금액은_산근_풀이_값과_같음(): for code, given in ((BASE, GIVEN), ("GF000288", {})): # 중기 · 노무 · % 덧줄 · 배 1,000 - whole = item_prices.load_prices(item_prices.to_json(item_prices.collect([code]))) + whole = _copy([code]) block = sg.Solver().add(whole, {"code": code, "given": given}, "s1") assert block["foot"] == _foot(block), code for ln in block["lines"]: @@ -115,7 +127,7 @@ def test_글_속_금액은_산근_풀이_값과_같음(): def test_자재_자리표시_키는_실제_키로(): """「MO:휘발유:{지역}」 자리표시 = 대비표 키(MO…) · 수집량 공식 줄 · 「× (6.5 × 0.125)」 · % 덧줄.""" - whole = item_prices.load_prices(item_prices.to_json(item_prices.collect(["GF000062"]))) + whole = _copy(["GF000062"]) block = sg.Solver().add(whole, {"code": "GF000062", "given": {}}, "s1") fuel = next(ln for ln in block["lines"] if ln["name"].startswith("휘발유")) assert fuel["ref"]["key"].startswith("MO") and ":" not in fuel["ref"]["key"] diff --git a/resources/tester/test_item_copy_complete.py b/resources/tester/test_item_copy_complete.py index 5a657b2f2..de8f9a718 100644 --- a/resources/tester/test_item_copy_complete.py +++ b/resources/tester/test_item_copy_complete.py @@ -148,37 +148,37 @@ def test_지정하면_새_파일까지_복사(world): def test_단가_묶음은_닫혀_있음(world): - """조합마다 복사본 단가 묶음만으로 돌린 값 = 마스터로 돌린 값(자동값 · 고르기 끝값).""" + """조합마다 복사본 단가 묶음 + 수식 문서만으로 셈한 값 = 마스터로 셈한 값(자동값 · 고르기 첫 · 끝값 · + 문서 셈 · 855-E 2-E4 — 옛 엔진 대조 걷음).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + files, whole = prices.master() combos = [r for d in files.values() if d.get("그룹") == "일위대가조합" for r in d["줄"]] runs = 0 for ua in combos: keys = prices.mcb.logic_keys(ua) - snapshot = prices.load_prices(prices.to_json(prices.collect(keys))) + docs = dc.closure(whole, keys) + snapshot = item_bundle.load(prices.to_json(prices.collect(keys)), docs) for key in keys: - try: - row = whole.logic(key) - except prices.mf.FormulaError: + doc = docs.get(key) + if doc is None: continue + picks = [ + v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") == "선택" + ] for pick in (0, -1): - values = m01.mau.values(whole, row) - for spec in row.get("입력", []): - if spec.get("고르기"): - values[spec["이름"]] = spec["고르기"][pick] - assert _run(whole, key, values) == _run(snapshot, key, values), (ua["키"], key) + given = {v["열쇠"]: v["연결"]["목록"][pick] for v in picks if v["연결"].get("목록")} + one = {"로직": key, "입력값": given} + want = prices.line(whole, dict(docs), one) + got = prices.line(snapshot, dict(docs), one) + assert _money(got) == _money(want), (ua["키"], key) runs += 1 assert len(combos) >= 30 and runs >= 300 -def _run(master: Any, key: str, values: dict) -> str: - try: - got = prices.mf.run(master, key, dict(values)) - except Exception as error: # 까닭도 같아야 함 - return f"멈춤 {error}" - return str(got.get("계", got.get("결과"))) - - -# ── 계산 · 마스터 바뀜 · 새로 가져오기 ─────────────────── +def _money(got: dict) -> str: + return str(got.get("기준") or got.get("결과") or got.get("까닭")) def test_입력이_없으면_빠진_입력_목록_셈은_자동값(world): From 063549df54caab95a267daa27d6ea767718d94f2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 09:37:53 +0900 Subject: [PATCH 3/3] =?UTF-8?q?refactor(855-E=202-E4):=20B09=20=EB=B8=94?= =?UTF-8?q?=EB=A1=9D=20=EC=A4=84=20=EA=BC=B4=20=EC=9D=BD=EA=B8=B0=EB=A5=BC?= =?UTF-8?q?=20master=5Fformula=5Fsum=20=EB=8C=80=EC=8B=A0=20B09=20?= =?UTF-8?q?=EC=95=88=EC=97=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - B09_Estimation_Labor_Rule: `ms`(items · uses · _cover · skipped · ADDR · STEP — 줄 꼴만 읽는 작은 함수 · 셈 몸 없음)를 이 파일로 옮김 · master_formula_sum import 0 · B09_Estimation_Sangeun_Sum 도 이것을 씀 - 검증: 묶음 ① 커밋 글과 같음(B09 골든 · 792_3 · 실제 B09 해시 같음) Co-Authored-By: Claude Opus 5.5 --- B09_Estimation/B09_Estimation_Labor_Rule.py | 51 +++++++++++++++++++- B09_Estimation/B09_Estimation_Sangeun_Sum.py | 3 +- 2 files changed, 52 insertions(+), 2 deletions(-) diff --git a/B09_Estimation/B09_Estimation_Labor_Rule.py b/B09_Estimation/B09_Estimation_Labor_Rule.py index 023e9e5af..9cc10d4a1 100644 --- a/B09_Estimation/B09_Estimation_Labor_Rule.py +++ b/B09_Estimation/B09_Estimation_Labor_Rule.py @@ -22,13 +22,62 @@ from typing import Any from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠 md = importlib.import_module("master_doc") # 식 꼴 읽기 = 새 계산기 파서(855-F B9-3) -ms = importlib.import_module("master_formula_sum") PART = {"노무비": "labor", "재료비": "material", "경비": "expense"} FLAGS = ("place", "out") # 블록 줄 덧칸 — 단가산출 블록이 줄을 바꿔도 이어 받음 Refs = list[tuple[int, str | None]] # (줄 차례, 비목 | None = 줄 전체) +# ── 블록 줄 꼴 읽기(옛 `master_formula_sum` 의 줄 꼴 함수 · 셈 아님 · 855-E 2-E4 에서 옮김) ────────── +class ms: # noqa: N801 — 부르는 쪽 이름(`ms.items` …) 그대로 + """줄 꼴(`Doc_Run.row` — 호표 · 덧줄 · 단계)만 읽는 작은 함수 — 엔진 셈 몸 없음.""" + + ROW_KEYS = ("단계", "끝전", "조정") # 블록 칸 + LINE_KEYS = ("번지", "합밖", "자리") # 호표 · 덧줄 칸 + ADDR, STEP = "번지", "단계" # 덧줄 식 이름 — `번지.A01.재료비` · `단계.'소계'.계` + + @staticmethod + def items(row: dict) -> list[dict]: + """줄 차례 = 호표 하나씩 뒤 덧줄 하나씩.""" + return [*row.get("호표", []), *row.get("덧줄", [])] + + @staticmethod + def uses(row: dict) -> bool: + """새 의미(번지 · 단계 · 끝전 · 조정 · 합밖 · 줄 자리)를 쓰는 블록.""" + lines = ms.items(row) + return any(k in row for k in ms.ROW_KEYS) or any( + k in x for x in lines for k in ms.LINE_KEYS + ) + + @staticmethod + def _cover(row: dict) -> list[tuple[dict, set]]: + """단계마다 (단계, 담은 줄 차례) — 단 1 = 제 `줄` · 단 k = 제 `줄` + 아직 안 담긴 아래 단 단계 · + 제외 단계는 위로 안 올라감.""" + where = {x.get("이름"): i for i, x in enumerate(ms.items(row)) if x.get("이름")} + out, open_ = [], [] + for st in row.get(ms.STEP) or []: + level = int(st.get("단") or 1) + mine = {where[n] for n in st.get("줄") or [] if n in where} + keep = [] + for low, got in open_: + if low < level: + mine |= got + else: + keep.append((low, got)) + open_ = keep if st.get("제외") else [*keep, (level, mine)] + out.append((st, mine)) + return out + + @staticmethod + def skipped(row: dict) -> set: + """비목 합에서 빼는 줄 차례 — `합밖` 줄(번지엔 쌓음) · 제외 단계가 담은 줄.""" + out = {i for i, x in enumerate(ms.items(row)) if x.get("합밖")} + for st, mine in ms._cover(row): + if st.get("제외"): + out |= mine + return out + + def _f(value: Any) -> float | None: try: return None if value is None else float(value) diff --git a/B09_Estimation/B09_Estimation_Sangeun_Sum.py b/B09_Estimation/B09_Estimation_Sangeun_Sum.py index 4b2af7432..98a66ddad 100644 --- a/B09_Estimation/B09_Estimation_Sangeun_Sum.py +++ b/B09_Estimation/B09_Estimation_Sangeun_Sum.py @@ -16,7 +16,6 @@ from B09_Estimation.B09_Estimation_Calc_Base import rounddown, total from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠 mc = importlib.import_module("master_doc_calc") -ms = importlib.import_module("master_formula_sum") PARTS = ("labor", "material", "expense") COST_PART = {"노무비": "labor", "재료비": "material", "경비": "expense"} @@ -61,6 +60,8 @@ def doc_totals(answer: Any, lines: list[dict]) -> dict[str, float | None]: def doc_shown(row: dict) -> dict[str, int]: """중간값 표시 자리 {이름: 자리} — `shown` 과 같은 뜻(`표시` · 옛 로직 작업량 Q = ROUND 2 · 엑셀 자리) · 문서 셈에 그 식 줄을 반올림으로 씌워 셈(`Doc_Run.solve` `shown`).""" + from B09_Estimation.B09_Estimation_Labor_Rule import ms # 줄 꼴 읽기(855-E 2-E4) + new = ms.uses(row) out: dict[str, int] = {} for step in row.get("중간", []):