From 3a7320ac71edbe70135aa7296f1143931653f435 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 09:11:37 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-3):=20=EB=8B=A8?= =?UTF-8?q?=EA=B0=80=EC=82=B0=EC=B6=9C=20=EC=A4=84=20=EA=B7=9C=EC=B9=99=20?= =?UTF-8?q?=EC=97=B4=EC=87=A0=20=3D=20=E3=80=8C=EA=B8=88=EC=95=A1#n?= =?UTF-8?q?=E3=80=8D(=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EA=B8=88?= =?UTF-8?q?=EC=95=A1=20=EC=A4=84=20=EC=B0=A8=EB=A1=80)=20=E2=80=94=20?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20=EC=A4=84=20cid=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Sangeun_Doc: 고름 · 자재표시 열쇠 「금액#n」(AMOUNT · amount_key · amount_at) · 옛 cid 꼴 받으면 400 - Doc_Sk.derive: 열쇠를 문서 금액 줄 차례로 바로 · 재료 줄 = Item_Prices._mat_lines · 입력 이름 = doc_row · 옛 cid 저장본 = 못 셈 + 까닭(RULE_WHY · 호환 없음) - Labor_Patch.as_doc · Labor_SkRow.logic_doc([+ 줄]) · Library_Flat.sk_line: 일위대가 줄 차례 「n」 ↔ 「금액#n」 · 재료 줄 = 문서(로직 줄 안 읽음 · sub5 L2ⓑ-2 에서 넘겨받은 자리) - Library_Flat.compose: cid 옮김 겹침 걷음 → 줄 규칙 · 입력값 사전 겹침 · 옛 칸 든 겹침 = 못 펼침 · 줄 덮개 있는 SK 참조 줄 = 못 펼침(patch.WHY) - 저장본 줄 규칙 든 SK 0 · 셈 답 1,541(지은 파생 SK · [+ 줄] SK · SK → 일위대가 줄 열쇠 · 셈) 다름 0 - M01 로직 줄 읽힘(내 몫 + 넘겨받은 셋) 6,610 → 0 - 시험: test_715_sangeun_doc 둘(drop_keeps_pick · chain_moves_base_picks) · test_715_sangeun_store layer_copy_round_trip · test_778_4 겹침_율_열쇠 지움 — cid 고름 + 뺀줄 · 덮개 겹침(옛 칸 · 못 셈)만 붙듦 · test_715 lost_covers 고름 단언 걷음 · test_747_1 PLY 열쇠 금액#2 · 새 test_855_l2b3_rule_keys(별도계상 계 밖 · 옛 cid 400 · 못 셈 · 오감 금액 같음) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Sk.py | 41 ++++-- M02_MasterTemplete/M02_Labor_Patch.py | 24 ++-- M02_MasterTemplete/M02_Labor_SkRow.py | 9 +- M02_MasterTemplete/M02_Library_Flat.py | 146 ++++---------------- M02_MasterTemplete/M02_Sangeun_Doc.py | 27 +++- resources/tester/test_715_sangeun_doc.py | 28 +--- resources/tester/test_715_sangeun_store.py | 23 --- resources/tester/test_747_1_sk_material.py | 2 +- resources/tester/test_778_4_rate_line.py | 13 -- resources/tester/test_855_l2b3_rule_keys.py | 96 +++++++++++++ 10 files changed, 186 insertions(+), 223 deletions(-) create mode 100644 resources/tester/test_855_l2b3_rule_keys.py diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 8bcba8554..b3b31c6f6 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -141,7 +141,8 @@ def derive(sk: dict, whole: Any) -> dict: """이 SK 문서(855 2-C1 · 옛 엔진 안 돎) — 바탕 로직 = 기초 문서(`base_doc`) 사본 · 바탕 없음 = 빈 문서 · 옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 손고침 · 프로젝트 층 = 옛 로직 줄 자동값) · 줄 규칙(켜쌓기율 · 고름 · 자재표시 · 일위대가 [+ 줄] 사본 811-1) = 문서 규칙(`dc.line_doc` · - SK 재료 빈 칸 = 직접계산 747-1). `whole` = 값 사본 색인. 옛 칸 고침 SK 는 부르는 쪽이 먼저 막음.""" + 열쇠 = 금액#n 기초 문서 금액 줄 · 로직 줄 안 읽음 855 L2 ⓑ-3 · SK 재료 빈 칸 = 직접계산 747-1). + `whole` = 값 사본 색인. 옛 칸 고침 SK 는 부르는 쪽이 먼저 막음.""" key = str(sk.get("키") or "") base_key = str((sk.get("바탕") or {}).get("로직") or "") if not base_key: @@ -149,29 +150,41 @@ def derive(sk: dict, whole: Any) -> dict: plain, real = base_doc(sk, whole, base_key) if plain is None: raise ValueError(f"기초 문서 없음 「{base_key}」") - row = whole.logic(base_key) - got = sd.patched(row, sk) # 줄 규칙 칸 cid → 차례(옛 칸 고침 없음 = 바탕 줄 그대로) - names = {str(i.get("이름")) for i in row.get("입력") or []} + mats = {n for n, _, _ in dc.prices._mat_lines(plain)} # 재료 금액 줄(855 L2 ⓑ-3) + picks = {n: mt for n, mt in _rules(sk, "고름").items() if n in mats} # 재료 줄만(옛과 같음) + names = {str(i["이름"]) for i in sd.doc_row(whole, base_key)["입력"]} values = {k: v for k, v in (sk.get("입력값") or {}).items() if k in names} given = dc.given_of(whole, base_key, values) if values or not real else {} doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1) _set_values(doc, {k: v for k, v in given.items() if k in values} if real else given) - apart = [] if isinstance(row.get("흐름"), dict) else _apart(got) - doc = dc.line_doc(doc, sk.get("켜쌓기율"), got["고름"] or None, apart) + apart = _apart(_rules(sk, "자재표시"), mats) + doc = dc.line_doc(doc, sk.get("켜쌓기율"), picks or None, apart) return {**doc, "키": key or base_key, "이름": str(sk.get("이름") or doc.get("이름"))} -def _apart(got: dict) -> list[int]: - """별도계상 재료 줄 차례 — SK 빈 칸 = 직접계산(747-1) · 「별도계상」 고른 줄만.""" +RULE_WHY = "옛 줄 가리킴(kind:키#n) 단가산출 — 줄 규칙은 금액#n · 다시 만들어야 셈" + + +def _rules(sk: dict, field: str) -> dict[int, Any]: + """줄 규칙 칸(고름 · 자재표시) {금액#n: 값} → {n: 값} · 옛 cid 꼴 = 못 셈(855 L2 ⓑ-3 · 호환 없음).""" + out = {} + for key, value in (sk.get(field) or {}).items(): + n = sd.amount_at(key) + if n is None: + raise ValueError(RULE_WHY) + out[n] = value + return out + + +def _apart(marks: dict[int, Any], mats: set[int]) -> list[int]: + """별도계상 재료 줄 차례 — SK 빈 칸 = 직접계산(747-1) · 「별도계상」 고른 재료 줄만.""" from M02_MasterTemplete import M02_Labor_Doc as labor # 늦게 — 일위대가 셈이 이 파일을 부름 - marks = got["자재표시"] - return [ + return sorted( n - for n, item in enumerate(got["줄"].get("호표") or []) - if item.get("종류") == "재료" - and labor.apart({"별도계상": "직접계산", **labor.marks(marks.get(str(n)))}) - ] + for n, mark in marks.items() + if n in mats and labor.apart({"별도계상": "직접계산", **labor.marks(mark)}) + ) def seed(sk: dict) -> dict | None: diff --git a/M02_MasterTemplete/M02_Labor_Patch.py b/M02_MasterTemplete/M02_Labor_Patch.py index dbaddc886..f1558435a 100644 --- a/M02_MasterTemplete/M02_Labor_Patch.py +++ b/M02_MasterTemplete/M02_Labor_Patch.py @@ -2,7 +2,7 @@ 줄 칸 `패치` = 단가산출(SK) 문서 꼴 `{덮개, 뺀줄, 더한줄}`(한 벌 · `M02_Sangeun_Doc`) — 그 줄에만 · 로직 줄(`{로직, 입력값, 고름, 자재표시, 패치}`) · 단가산출 참조 줄(`{참조: SK, 패치}`)만 받음 · -줄 `고름` · `자재표시`(호표 차례 열쇠)는 바탕 줄 차례 그대로 — 셈 때 cid 로 바꿔 뺀줄 뒤에도 제자리. +줄 `고름` · `자재표시`(차례 열쇠 「n」 = 기초 문서 금액 줄 차례) → SK 줄 규칙 「금액#n」(855 L2 ⓑ-3). 더한줄은 인력 · 재료 · 기계 · 로직 · 고정만(참조는 일위대가에 참조 줄로). 셈 = 못 셈 + 까닭 하나(옛 칸 고침 셈 은퇴 · 855 2-C5) · [단가산출로 저장] = `as_doc` + 이름 · 단위 → 층 SK. """ @@ -61,34 +61,26 @@ def ref_clean(one: dict, ref: dict, where: str) -> dict: return clean(one, where, m01.loaded()[1], None, doc.get("열린입력")) -def _keyed(value: Any, ids: list[str]) -> dict: - """차례 열쇠 → cid 열쇠(바탕 줄 차례).""" - out = {} - for n, v in (value or {}).items() if isinstance(value, dict) else (): - at = int(n) if str(n).isdigit() else -1 - if 0 <= at < len(ids): - out[ids[at]] = v - return out +def _keyed(value: Any) -> dict: + """차례 열쇠 「n」 → SK 줄 규칙 열쇠 「금액#n」(같은 기초 문서 금액 줄 · 로직 줄 안 읽음).""" + items = value.items() if isinstance(value, dict) else () + return {sd.amount_key(n): v for n, v in items if str(n).isdigit()} def as_doc(one: dict, whole: Any, name: str = "줄", unit: str = "식") -> dict[str, Any]: - """일위대가 줄 → SK 문서(바탕 = 그 로직 · 그 SK) — 고름 · 자재표시는 cid 로.""" + """일위대가 줄 → SK 문서(바탕 = 그 로직 · 그 SK) — 고름 · 자재표시는 「금액#n」 으로.""" body = {k: (one.get(FIELD) or {}).get(k) or ([] if k != "덮개" else {}) for k in CALC} head = {"키": TEMP, "이름": name, "단위": unit, **body} if "참조" in one: return {**head, "바탕": {"참조": one["참조"]}} - try: - ids = sd.line_ids(whole.logic(one["로직"])) - except Exception: # noqa: BLE001 — 없는 로직 = 셈이 까닭 - ids = [] extra = {"켜쌓기율": one["켜쌓기율"]} if one.get("켜쌓기율") is not None else {} return { **head, **extra, "바탕": {"로직": one["로직"]}, "입력값": dict(one.get("입력값") or {}), - "고름": _keyed(one.get("고름"), ids), - "자재표시": _keyed(one.get("자재표시"), ids), + "고름": _keyed(one.get("고름")), + "자재표시": _keyed(one.get("자재표시")), } diff --git a/M02_MasterTemplete/M02_Labor_SkRow.py b/M02_MasterTemplete/M02_Labor_SkRow.py index 73672a86f..336192655 100644 --- a/M02_MasterTemplete/M02_Labor_SkRow.py +++ b/M02_MasterTemplete/M02_Labor_SkRow.py @@ -29,6 +29,7 @@ def _whole() -> Any: def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]: """로직 줄 `one`(일위대가 `doc` 안) → SK 문서 몸(키 없음 · 저장은 부르는 쪽).""" + from M02_MasterTemplete import M02_Item_Prices as prices from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Patch as patch from M02_MasterTemplete import M02_Sangeun_Calc as calc @@ -38,12 +39,10 @@ def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]: code = str(one["로직"]) m01doc.head(code) # 없는 기초 = 옛 `Master.logic` 과 같은 까닭 doc_ = m01doc.docs()[code] - row = whole.logic(code) # 호표 재료 차례 = 옛 자재표시 칸 몫(남김) shown = dict(one.get("자재표시") or {}) - for n, item in enumerate(row.get("호표") or []): - if item.get("종류") == "재료": - mine = shown.get(str(n)) - shown[str(n)] = {**labor.marks(mine), "별도계상": labor.mark_of(mine, "별도계상")} + for n, _, _ in prices._mat_lines(doc_): # 재료 금액 줄 차례(855 L2 ⓑ-3 · 로직 줄 안 읽음) + mine = shown.get(str(n)) + shown[str(n)] = {**labor.marks(mine), "별도계상": labor.mark_of(mine, "별도계상")} unit = calc.base_unit(doc_) name = str(one.get("별칭") or doc_.get("이름") or code) sk = patch.to_sangeun({**one, "자재표시": shown}, name, unit[1] if unit else "식", whole) diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index 4a87c9ecd..bea470c39 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -15,22 +15,21 @@ `{층: 사본, 주인: 몸 지문, 키: 본 SC, 몸}` 에 담음(`M02_Labor_Ref.copy_ref` · 원본 연결 없음 · 하위 호표 끝수 단계 · B09 하위 대가 블록 그대로 · 같은 기초 겹침도 블록 안) - 바탕 SK 참조 · 패치 있는 SK 참조 줄 = 위 덮개를 아래 덮개에 겹쳐 한 벌(`compose` · 율 기준 줄 열쇠 - `add:#k` 도 새 차례로 · 778-4) + 바탕 SK 참조 = 줄 규칙 · 입력값을 겹쳐 한 벌(`compose`) · 옛 칸 고침 든 겹침 · 패치 있는 SK 참조 줄 = + 못 펼침(옛 칸 · 못 셈 855 L2 ⓑ-3) 율 줄(778-4) 있는 바탕 없는 SK = 한 줄로 못 펼침(율 · 기준 묶음이 넣는 쪽 줄로 번짐) → 참조 그대로 못 펼친 줄 = 저장 · 읽기 · 옮기기에선 옛 참조 그대로(값 그대로) · `strict` = 400 까닭(옛 찾아 넣기 `-flat` 길은 걷음 · 855 2-E2). 초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸 · 사본 블록까지) · 이음 기계 고정 줄 단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 · 기본정보 남김 → 값 = 연결된 M01 키 값. 한 번용 옮기기(`migrate`)는 끝나 걷음(894). -기초 이름 · 결과단위 · 입력 이름 = M01 수식 문서(855 L2 ⓑ · `_doc`) · 줄 정체(cid) · 호표 재료 차례는 -옛 패치 칸(덮개 · 뺀줄 · 고름 · 자재표시) 몫이라 아직 로직 줄(`compose` · `sk_line` · 옛 패치 칸 걷기 때 같이). +기초 이름 · 결과단위 · 입력 이름 · 재료 줄 차례 = M01 수식 문서(855 L2 ⓑ · `_doc`) · SK 고름 · 자재표시 +「금액#n」 ↔ 일위대가 줄 차례 「n」(`sk_line` · 로직 줄 안 읽음). """ from __future__ import annotations import json -import re import time from decimal import Decimal from typing import Any @@ -42,7 +41,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Sangeun_Const as const from M02_MasterTemplete import M02_Sangeun_Doc as sd -ADD = re.compile(r"^add:#(\d+)$") FAIL = (ArithmeticError, KeyError, TypeError, ValueError) # 못 펼침(DocError · FormulaError 포함) EMPTY = (None, {}, [], "") Read = Any @@ -113,7 +111,7 @@ def flat_sk(doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool = try: under, path = _read(base["참조"], read, trail) under = flat_sk(sd.clean(under, None, whole), read, whole, path) - out = compose(under, out, whole) + out = compose(under, out) except FAIL: if strict: raise @@ -237,135 +235,41 @@ def sc_adds(z: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]: return out -# ── 겹침(바탕 SK · 패치 SK 참조) ───────────────────────────────────────── -def _merge(a: dict | None, b: dict) -> dict: - """아래 덮개 a 위에 위 덮개 b — 품 qty 바꿈 · 배율 곱 · 단가 위 것.""" - if not a: - return dict(b) - out = {k: v for x in (a, b) for k, v in x.items() if k in sd.PARTS} - if "qty" in b: - out["qty"] = b["qty"] - elif "배율" in b and "qty" in a: - out["qty"] = sd.plain(_d(a["qty"]) * _d(b["배율"])) - elif "배율" in b: - out["배율"] = sd.plain(_d(a.get("배율", 1)) * _d(b["배율"])) - else: - out |= {k: a[k] for k in ("qty", "배율") if k in a} - return out | ({"원값": a["원값"]} if "원값" in a else {}) +# ── 겹침(바탕 SK 참조) ─────────────────────────────────────────────────── +def compose(under: dict, over: dict) -> dict: + """펼친 바탕 SK `under` 위에 `over` → 한 벌 — 줄 규칙(고름 · 자재표시 「금액#n」 = 같은 기초 문서 + 자리) · 입력값 = 위 것이 덮음 · 옛 칸 고침(덮개 · 뺀줄 · 더한줄 …) 든 쪽 = 못 펼침(855 L2 ⓑ-3 — + cid 옮김 겹침 걷음 · 로직 줄 안 읽음).""" + from M02_MasterTemplete import M02_Doc_Sk as dsk # 늦게 — dsk 가 이 파일을 거쳐 부름 - -def _cover_add(add: dict, cover: dict) -> dict: - """위 덮개를 아래 더한줄 항목에 — 수량 · 그 비목 단가만(그 밖 = 못 겹침).""" - out = dict(add) - if "qty" in cover: - out["수량"] = cover["qty"] - elif "배율" in cover: - out["수량"] = sd.plain(_d(add.get("수량") or 0) * _d(cover["배율"])) - prices = {sd.PARTS[k]: cover[k] for k in sd.PARTS if k in cover} - if prices and (add.get("종류") not in sd.ADD_PART or set(prices) != {add.get("비목")}): - raise sd.DocError("더한줄 단가 덮개를 못 겹침") - if prices: - out["단가"] = prices[add["비목"]] - return out - - -def compose(under: dict, over: dict, whole: Any) -> dict: - """펼친 바탕 SK `under` 위에 `over`(덮개 · 뺀줄 · 고름 · 자재표시 · 더한줄 · 입력값) → 한 벌 — - 위 줄 정체를 아래 바탕 정체로 옮김(`patched` 의 `정체` 짝) · 짝 잃은 위 고침은 버림(값 없음).""" - const.no_flat(over) # 위 상수 · 표값 덮개 자리 = 아래 정체로 못 옮김(790-2) - base = under.get("바탕") - row = whole.logic(base["로직"]) if (base or {}).get("로직") else sd.empty_row(under) - got = sd.patched(row, under) - where = dict(zip(sd.line_ids(got["줄"]), got["정체"])) - covers = {c: dict(v) for c, v in (under.get("덮개") or {}).items()} - drop, picks = list(under.get("뺀줄") or []), dict(under.get("고름") or {}) - marks, adds, gone = ( - dict(under.get("자재표시") or {}), - [dict(x) for x in under.get("더한줄") or []], - set(), - ) - - def to(cid: str) -> tuple[str, Any] | None: - o = where.get(cid) - hit = ADD.match(o) if o else None - return None if o is None else ("add", int(hit[1])) if hit else ("base", o) - - for cid, cover in (over.get("덮개") or {}).items(): - if t := to(cid): - if t[0] == "base": - covers[t[1]] = _merge(covers.get(t[1]), cover) - else: - adds[t[1]] = _cover_add(adds[t[1]], cover) - for cid in over.get("뺀줄") or []: - if (t := to(cid)) and t[0] == "add": - gone.add(t[1]) - elif t and t[1] not in drop: - drop.append(t[1]) - for name, mine, into in ( - ("고름", over.get("고름"), picks), - ("자재표시", over.get("자재표시"), marks), - ): - for cid, value in (mine or {}).items(): - if (t := to(cid)) and t[0] == "add": - raise sd.DocError(f"더한줄 {name}를 못 겹침") - if t: - into[t[1]] = value + const.no_flat(over) # 위 상수 · 표값 덮개 자리 = 못 겹침(790-2) + if dsk.patched(under) or dsk.patched(over): + raise sd.DocError(dsk.OLD_WHY) + out = {**over, "바탕": under.get("바탕")} + for name in ("고름", "자재표시", "입력값"): + out[name] = {**(under.get(name) or {}), **(over.get(name) or {})} rate = over.get("켜쌓기율", under.get("켜쌓기율")) - out = {**over, "바탕": base, "덮개": covers, "뺀줄": drop, "고름": picks, "자재표시": marks} - kept = [k for k in range(len(adds)) if k not in gone] - new = {f"add:#{k}": f"add:#{n}" for n, k in enumerate(kept)} # 율 기준 열쇠(778-4) - mine = [ - _rekey(a, lambda x: new.get(x) if ADD.match(x) else x) - for k, a in enumerate(adds) - if k not in gone - ] - - def up(cid: str) -> str | None: # 위 문서 열쇠 → 한 벌 열쇠 - hit = ADD.match(cid) - if hit: - return f"add:#{len(kept) + int(hit[1])}" - t = to(cid) - return cid if t is None else t[1] if t[0] == "base" else new.get(f"add:#{t[1]}") - - out["더한줄"] = mine + [_rekey(dict(a), up) for a in over.get("더한줄") or []] - out["입력값"] = {**(under.get("입력값") or {}), **(over.get("입력값") or {})} return out | ({"켜쌓기율": rate} if rate is not None else {}) -def _rekey(one: dict, move: Any) -> dict: - """율 더한줄 기준 줄 목록 열쇠를 `move` 로(못 옮긴 열쇠 = 버림 · 778-4).""" - rate = ((one.get("고정") or {}).get("비율") or {}) if isinstance(one, dict) else {} - if not isinstance(rate.get("기준"), list): - return one - keys = [] - for x in rate["기준"]: - line, cost = fixed.split_key(x) # `열쇠@비목` = 비목 꼬리 그대로 - if got := move(line): - keys.append(f"{got}@{cost}" if cost else got) - fx = {**one["고정"], "비율": {**rate, "기준": keys}} - return {**one, "고정": fx} - - # ── SC ──────────────────────────────────────────────────────────────── def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict: """펼친 SK → 일위대가 로직 줄 하나(+ 패치) — 옛 참조 줄 `one` 의 별칭 · 메모 · 수량 · 패치 이어받음.""" + from M02_MasterTemplete import M02_Item_Prices as prices from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Patch as patch from M02_MasterTemplete import M02_Sangeun_Calc as calc - if one.get(patch.FIELD): - y = compose(y, {"입력값": {}, **one[patch.FIELD]}, whole) + if one.get(patch.FIELD): # 줄 덮개(옛 칸) = 못 셈 · 겹침 걷음(855 L2 ⓑ-3) + raise sd.DocError(patch.WHY) code = (y.get("바탕") or {}).get("로직") if not code: raise sd.DocError("바탕 기초 없는 단가산출은 일위대가 줄로 못 담음 — 그 안 줄을 따로 넣음") doc = _doc(code) if calc.ratio_of(y, doc, whole) != calc.times_of(doc): raise sd.DocError("단위 환산 단가산출은 일위대가 줄로 못 담음(값 단위가 바뀜)") - row = whole.logic(code) # 줄 정체 · 호표 재료 차례 = 옛 패치 칸 몫(남김) - ids = sd.line_ids(row) names = _names(doc) - at = {c: str(n) for n, c in enumerate(ids)} body = {k: y[k] for k in ("덮개", "뺀줄") if y.get(k) not in EMPTY} body |= {"더한줄": adds} if (adds := filled_adds(y, whole)) else {} line: dict[str, Any] = { @@ -375,13 +279,13 @@ def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict: "메모": one.get("메모"), "수량": one.get("수량"), } - for name in ("고름", "자재표시"): - if got := {at[c]: v for c, v in (y.get(name) or {}).items() if c in at}: + for name in ("고름", "자재표시"): # SK 「금액#n」 → 일위대가 줄 차례 「n」(855 L2 ⓑ-3) + rules = ((sd.amount_at(c), v) for c, v in (y.get(name) or {}).items()) + if got := {str(n): v for n, v in rules if n is not None}: line[name] = got shown = line.get("자재표시") or {} - for n, item in enumerate(row.get("호표") or []): # 747-1 SK 재료 빈 칸 = 직접계산 → 적어 둠 - if item.get("종류") == "재료": - shown[str(n)] = {"별도계상": "직접계산", **labor.marks(shown.get(str(n)))} + for n, _, _ in prices._mat_lines(doc): # 747-1 SK 재료 빈 칸 = 직접계산 → 적어 둠 + shown[str(n)] = {"별도계상": "직접계산", **labor.marks(shown.get(str(n)))} line |= {"자재표시": shown} if shown else {} if y.get("켜쌓기율") is not None: line["켜쌓기율"] = y["켜쌓기율"] diff --git a/M02_MasterTemplete/M02_Sangeun_Doc.py b/M02_MasterTemplete/M02_Sangeun_Doc.py index 1a427e6af..694331739 100644 --- a/M02_MasterTemplete/M02_Sangeun_Doc.py +++ b/M02_MasterTemplete/M02_Sangeun_Doc.py @@ -4,7 +4,7 @@ {종류: "단가산출", 키, 이름, 단위(필수), 구분, 상세구분, 본뜬, 바탕: {로직: GF…} | {참조: {층, 주인, 키: SK-…}} | null(바탕 없음 = 더한줄만), 입력값 {이름: 값}, 열린입력 [이름](설계 때 정함 · 그 SK 품 덮개 = 배율만), 켜쌓기율?, - 고름 {cid: MT키}, 자재표시 {cid: {세 칸}}, + 고름 {금액#n: MT키}, 자재표시 {금액#n: {세 칸}}, 덮개 {cid: {qty | 배율, labor, material, expense, 원값}}, 더한줄 [{종류: 인력|재료|기계, 요소, 이름, 단위, 수량, 비목?, 단가?, 별도계상?(재료 · 없음 = 계 안)} @@ -23,7 +23,8 @@ SK `입력값` = 바탕 입력 + 더한줄 로직 입력(727-3 · 넣은 뒤 고 줄 정체 cid = `kind:키#n`(B09 702 덮개 꼴) — kind = labor · material · machine · logic · pct(덧줄) · 키 = 요소 키(로직 줄 = 부르는 GC 키 · 조건 재료 = 이름 · 덧줄 = 이름 · 더한줄 참조 = 그 키) · n = 같은 머리 차례 · 바탕 줄(M01 로직 줄 · 바탕 SK 의 고친 줄)에서 셈 — 뺀줄 · 더한줄 뒤 같은 줄. -고름 · 자재표시도 cid 열쇠(호표 차례 열쇠면 뺀줄 뒤 엉뚱한 줄에 붙음) → `patched` 가 차례로 바꿈. +고름 · 자재표시 열쇠 = 「금액#n」(기초 수식 문서 금액 줄 차례 · 855 L2 ⓑ-3 · 옛 cid 꼴 = 400 · +저장본 옛 꼴 = 못 셈) · 일위대가 줄은 차례 「n」(`amount_key` · `amount_at` 로 오감). 덮개 = 숫자만(식 안 받음 · 4-1 확정 4) — qty = 품 수 · 배율 = 품 × 율 · labor · material · expense = 줄 단가(로직 줄 = 노 · 재 · 경 묶음) · 덧줄 = qty(율 %) · 배율만 · `원값` · `바탕판` = 저장 때 서버가 셈(브라우저 값 안 받음). 짝 잃은 덮개(M01 개정으로 줄이 사라짐) = 지우지 않고 `짝잃음` 알림. @@ -47,6 +48,7 @@ COVER_KEYS = ("qty", "배율", *PARTS) KINDS = {"인력": "labor", "재료": "material", "기계": "machine", "로직": "logic"} ADD_PART = {"인력": "노무비", "재료": "재료비", "기계": "경비"} _CID = re.compile(r"^(labor|material|machine|logic|pct):.*#\d+$") +AMOUNT = re.compile(r"^금액#(\d+)$") # 줄 규칙 열쇠 = 수식 문서 금액 줄 차례(855 L2 ⓑ-3) _CALL = re.compile(r"^\s*로직\(\s*([A-Z]{2}\d{6})") _PCT = re.compile(r"^(?P.+)\*(?P[^*]+)/\s*100\s*$", re.S) # 「X * Y / 100」 _NAME = re.compile(r"^[\w가-힣]+$") @@ -115,6 +117,23 @@ def _cid(raw: Any, where: str) -> str: return raw +def amount_key(n: Any) -> str: + """일위대가 줄 차례 열쇠 「n」 → 단가산출 줄 규칙 열쇠 「금액#n」.""" + return f"금액#{int(n)}" + + +def amount_at(key: Any) -> int | None: + """「금액#n」 → n · 다른 꼴(옛 cid 등) = None.""" + hit = AMOUNT.match(str(key)) + return int(hit[1]) if hit else None + + +def _amount(raw: Any, where: str) -> str: + if amount_at(raw) is None: + raise DocError(f"{where} · 줄 가리킴은 금액#n(수식 문서 금액 줄 차례) 「{raw}」") + return str(raw) + + def _base(raw: Any) -> dict | None: if raw is None: return None @@ -357,7 +376,7 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str mt = str(mt or "") if not mt.startswith("MT") or (whole is not None and _element(whole, mt, "고름") is None): raise DocError(f"고름 「{cid}」 · M01 자재품목 키 아님 「{mt}」") - picks[_cid(cid, "고름")] = mt + picks[_amount(cid, "고름")] = mt out["고름"] = picks out["자재표시"] = _marks(doc.get("자재표시")) out["덮개"] = { @@ -420,7 +439,7 @@ def _marks(raw: Any) -> dict[str, dict[str, str]]: for cid, one in (raw or {}).items() if isinstance(raw, dict) else (): got = labor.marks(one) if got: - out[_cid(cid, "자재표시")] = got + out[_amount(cid, "자재표시")] = got return out diff --git a/resources/tester/test_715_sangeun_doc.py b/resources/tester/test_715_sangeun_doc.py index dc66e4514..bd5d86cde 100644 --- a/resources/tester/test_715_sangeun_doc.py +++ b/resources/tester/test_715_sangeun_doc.py @@ -104,21 +104,6 @@ def test_patched_cover_qty_price_ratio(): assert got["짝잃음"] == [] and ROW["호표"][2]["수량"] == "0.2" # 바탕은 안 바뀜 -def test_drop_keeps_pick_on_its_line(): - """뺀줄 뒤 고름 제자리 — 자갈(바탕 3째) 고름이 뺀줄 뒤 새 2째로 옮겨 감 · 모래 줄에 안 붙음.""" - doc = sd.clean(_doc(뺀줄=["material:모래#0"], 고름={"material:자갈#0": "MT000010"}), ROW) - got = sd.patched(ROW, doc) - names = [x["이름"] for x in got["줄"]["호표"]] - assert names == ["석공", "석공", "자갈", "굴착기"] - assert got["고름"] == {"2": "MT000010"} - assert got["정체"][:4] == [ - "labor:LB000033#0", - "labor:LB000033#1", - "material:자갈#0", - "logic:GC000276#0", - ] - - def test_added_lines_before_extras(): doc = sd.clean( _doc( @@ -144,11 +129,10 @@ def test_added_lines_before_extras(): def test_lost_covers_kept_and_listed(): - """짝 잃은 덮개 = 문서에 남김 + 목록(지우지 않음) · 비목 다른 단가 · 재료 아닌 고름.""" + """짝 잃은 덮개 = 문서에 남김 + 목록(지우지 않음) · 비목 다른 단가.""" doc = sd.clean( _doc( 덮개={"labor:LB999999#0": {"qty": 1}, "labor:LB000033#0": {"material": 5}}, - 고름={"labor:LB000033#1": "MT000010"}, 뺀줄=["material:없음#0"], ), ROW, @@ -156,18 +140,10 @@ def test_lost_covers_kept_and_listed(): got = sd.patched(ROW, doc) why = {x["cid"]: x["까닭"] for x in got["짝잃음"]} assert why["labor:LB999999#0"].startswith("덮개") and "비목 다름" in why["labor:LB000033#0"] - assert why["labor:LB000033#1"].startswith("고름") and why["material:없음#0"].startswith("뺀줄") + assert why["material:없음#0"].startswith("뺀줄") assert "labor:LB999999#0" in doc["덮개"] -def test_chain_moves_base_picks(): - """바탕 SK 사슬 — 바탕 쪽 차례 고름이 아래 SK 뺀줄 뒤에도 그 줄에.""" - first = sd.patched(ROW, sd.clean(_doc(고름={"material:자갈#0": "MT000010"}), ROW)) - child = sd.clean({**_doc(뺀줄=["labor:LB000033#0"]), "바탕": None}, first["줄"]) - got = sd.patched(first["줄"], child, first["고름"]) - assert got["고름"] == {"2": "MT000010"} and got["줄"]["호표"][2]["이름"] == "자갈" - - def test_empty_base(): row = sd.empty_row({"키": "SK-000003", "이름": "자체", "단위": "식"}) doc = sd.clean( diff --git a/resources/tester/test_715_sangeun_store.py b/resources/tester/test_715_sangeun_store.py index 37a07efeb..9fc74dd75 100644 --- a/resources/tester/test_715_sangeun_store.py +++ b/resources/tester/test_715_sangeun_store.py @@ -44,29 +44,6 @@ def _bare(code): return labor.run_line(_whole(), code, {}) -def test_layer_copy_round_trip(world): - """개인 B(바탕 = 개인 A) → 회사로 복사 = 펼친 몸(바탕 = 기초 · 본뜬) → 개인으로 다시 = - 같은 값.""" - a = _sk(world["personal"], 바탕={"로직": PCT}, 덮개={"labor:LB000036#0": {"qty": 0.5}}) - b = _sk(world["personal"], 바탕={"참조": {**MINE, "키": a}}, 뺀줄=["labor:LB000002#0"]) - want = _calc(world["personal"], b)["기준"] - src = _doc(world["personal"], b) - with store.at(world["company"]): - made = refs.create( - "sangeun", refs.carry(refs.origin_mark(src, {**MINE, "키": b}), ("personal", "7/42")) - ) - assert not list((world["company"] / "sangeun").glob("*.json"))[1:] # A 따로 복사 안 함 - copy = _doc(world["company"], made["이름"]) - assert copy["바탕"] == {"로직": PCT} and copy["본뜬"]["키"] == b - assert _calc(world["company"], made["이름"])["기준"] == want - with store.at(world["personal"]): - back = refs.create( - "sangeun", - refs.carry(refs.origin_mark(copy, {**COMPANY, "키": made["이름"]}), ("company", "7")), - ) - assert _calc(world["personal"], back["이름"])["기준"] == want - - def test_refusals(world): with store.at(world["personal"]): for bad, status in ( diff --git a/resources/tester/test_747_1_sk_material.py b/resources/tester/test_747_1_sk_material.py index feca9a06f..50005d20b 100644 --- a/resources/tester/test_747_1_sk_material.py +++ b/resources/tester/test_747_1_sk_material.py @@ -9,7 +9,7 @@ from M02_MasterTemplete import M02_Sangeun_Calc as calc from M02_MasterTemplete import M02_Sangeun_Doc as sd FORM = "GC000211" # 6-3-1 합판거푸집 — 합판 1.03 · 각재 0.038 · 폼타이 0 · 소모자재 = 재료비 % -PLY = "material:합판(내수 12㎜)#0" +PLY = "금액#2" # 합판 = 기초 문서 금액 줄 2째(855 L2 ⓑ-3 줄 규칙 열쇠) def _whole(): diff --git a/resources/tester/test_778_4_rate_line.py b/resources/tester/test_778_4_rate_line.py index 6aa681008..8c0f257c2 100644 --- a/resources/tester/test_778_4_rate_line.py +++ b/resources/tester/test_778_4_rate_line.py @@ -257,17 +257,4 @@ def test_바탕_없는_SK_율_줄은_한_줄로_안_펼침(): assert flat.sk_adds(plain, Decimal(2), whole, {})[0]["수량"] == 1 # 율 없으면 그대로 -def test_겹침_율_열쇠_새_차례(): - whole = _whole() - under = sd.clean( - {**_doc([LABOR[0], _rate(["add:#0"])]), "바탕": {"로직": SUB}, "단위": "주"}, None, whole - ) - seen = sd.patched(whole.logic(SUB), under) - view = dict(zip(seen["정체"], sd.line_ids(seen["줄"]))) # 아래 차례 → 위 문서 cid - over = {"더한줄": [LABOR[1], _rate(["add:#0", view["add:#1"], view["add:#0"]], 3)]} - out = flat.compose(under, over, whole) - keys = [((a.get("고정") or {}).get("비율") or {}).get("기준") for a in out["더한줄"]] - assert keys == [None, ["add:#0"], None, ["add:#2", "add:#1", "add:#0"]] - - # ── 화면 — 더한줄 지움 · 되살림 때 율 기준 열쇠 옮김(`logic/M02_Sangeun_Undo.ts`) ────────── diff --git a/resources/tester/test_855_l2b3_rule_keys.py b/resources/tester/test_855_l2b3_rule_keys.py new file mode 100644 index 000000000..3555b049d --- /dev/null +++ b/resources/tester/test_855_l2b3_rule_keys.py @@ -0,0 +1,96 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855 L2 ⓑ-3 — 단가산출 줄 규칙(고름 · 자재표시) 열쇠 = 「금액#n」(기초 수식 문서 금액 줄 차례). + +- 별도계상 고른 재료 줄 = 그 줄 금액만 계 밖(셈 결과로 봄). +- 옛 cid 꼴(kind:키#n) — 받으면 400 · 저장본이면 못 셈 + 까닭(호환 없음). +- [+ 줄](일위대가 줄 → SK)과 SK → 일위대가 줄은 「n」 ↔ 「금액#n」 으로 오가고 금액 같음. +임시 storage · 개인 층. +""" + +from __future__ import annotations + +import json +from decimal import Decimal + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Copy as dc +from M02_MasterTemplete import M02_Doc_Sk as dsk +from M02_MasterTemplete import M02_Labor_Copy as lc +from M02_MasterTemplete import M02_Labor_SkRow as skrow +from M02_MasterTemplete import M02_Library_Flat as flat +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Doc as sd +from resources.tester.test_795_1_sk_copy import _doc, _sk +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +BASE = "GC000031" # 비계 낙하물방지망 — 재료 줄 다섯(금액 2 ~ 6) + + +def _run(folder, doc) -> dict: + with store.at(folder): + return calc.run(doc, m01.loaded()[1]) + + +def _mats() -> list[int]: + return [n for n, _, _ in dc.prices._mat_lines(dc.folder()[BASE])] + + +def test_별도계상_금액줄_차례로_계_밖(world): + me = world["personal"] + m = _mats()[0] + plain = _run(me, _doc(me, _sk(me, 바탕={"로직": BASE}))) + apart = _run( + me, _doc(me, _sk(me, 바탕={"로직": BASE}, 자재표시={f"금액#{m}": {"별도계상": "별도계상"}})) + ) + line = Decimal(str(plain["줄"][m]["금액"])) + assert line > 0 + total = Decimal(str(plain["기준"]["재료비"])) - Decimal(str(apart["기준"]["재료비"])) + assert abs(total - line) <= 1 # 그 재료 줄 금액만 빠짐(원 끝수) + + +def test_옛_cid_꼴_받으면_400_저장본이면_못셈(world): + me = world["personal"] + old = {"material:MT000001#0": {"별도계상": "별도계상"}} + with pytest.raises(sd.DocError, match="금액#n"): + sd.clean( + {"키": "SK-000001", "이름": "가", "단위": "㎡", "바탕": {"로직": BASE}, "자재표시": old} + ) + key = _sk(me, 바탕={"로직": BASE}) + doc = {**_doc(me, key), "자재표시": old} # 옛 꼴 저장본(검사 앞 파일) + _save_raw(me, key, doc) + got = _run(me, _doc(me, key)) + assert got["기준"] is None and dsk.RULE_WHY in str(got["수식셈"].get("까닭")) + + +def _save_raw(folder, key, doc): + """검사를 안 지나는 파일 쓰기 — 검사 앞에 저장된 옛 꼴 저장본 흉내.""" + with store.at(folder): + store._path("sangeun", key).write_text(json.dumps(doc, ensure_ascii=False), "utf-8") + + +def test_더한줄_오가도_열쇠_금액_같음(world): + me = world["personal"] + whole = m01.loaded()[1] + m, mt = _mats(), sorted(whole.index["MT"])[0] + line = { + "로직": BASE, + "입력값": {}, + "고름": {str(m[1]): mt}, + "자재표시": {str(m[0]): {"별도계상": "별도계상"}}, + "수량": {"손": 1}, + } + with store.at(me): + made = skrow.logic_doc(line, {}, whole) + assert set(made["고름"]) == {f"금액#{m[1]}"} and f"금액#{m[0]}" in made["자재표시"] + sk = _run(me, {**made, "키": "SK-900001"}) + back = flat.sk_line( + sd.clean({**made, "키": "SK-900001"}, None, whole), {"수량": {"손": 1}}, whole, {} + ) + assert back["고름"] == {str(m[1]): mt} + assert back["자재표시"][str(m[0])]["별도계상"] == "별도계상" + a = lc.line(whole, {"키": "SC-900001", "담은로직": [line]}, line) + b = lc.line(whole, {"키": "SC-900002", "담은로직": [back]}, back) + assert sk["기준"] is not None and a["기준"] == b["기준"]