From 0308333e719c42a7a271dd5e8c022c8320f5fe3f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:03:36 +0900 Subject: [PATCH 1/7] =?UTF-8?q?refactor(855-2-C5):=20=EB=82=98=EB=A8=B8?= =?UTF-8?q?=EC=A7=80=20=EC=98=9B=20=EC=97=94=EC=A7=84=20=EC=85=88=20?= =?UTF-8?q?=EC=9E=90=EB=A6=AC=20=E2=80=94=20=EB=A1=9C=EC=A7=81=20=EC=A4=84?= =?UTF-8?q?=20=C2=B7=20=EC=98=9B=20=EB=8B=A8=EA=B0=80=EC=8A=B9=EA=B2=A9=20?= =?UTF-8?q?=C2=B7=20=ED=98=B8=ED=91=9C=20=EB=93=A4=EC=9D=B4=EA=B8=B0=20?= =?UTF-8?q?=EC=9E=AC=EB=A3=8C=20=C2=B7=20=EC=A4=84=20=EB=8D=AE=EA=B0=9C=20?= =?UTF-8?q?=C2=B7=20=EB=B3=B5=EC=82=AC=20=EB=B0=B0=EB=A5=BC=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C=20=EC=85=88=EC=9C=BC=EB=A1=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `Labor_Copy.line` = 층 셈 문서 한 길 — 사본 있음 = 사본 · 없음(저장 전 새 문서) = 지금 M01 문서 · 셈 기록(`master_doc_trace`)으로 로직 자재 차례 · 품목 키(`재료`) · 줄 단위 · 별도계상 줄은 상세에서 뺌 · 프로젝트 층 · OLD 시험 = 옛 길(B9) - `Labor_Expand._promote`(옛 단가승격) = 층 = 같은 문서 셈(로직 자재 직접계산 = 옛 셈 꼴) · 프로젝트 사본 = 옛 길(B9) · `_logic` 굳힌 덮개 줄 = 옛 길(B9) - `Hopyo_Build._inside`(호표 들이기 로직 자재 같은 품목) = `Labor_Copy.line` 재료(옛 엔진 안 돎) - `Labor_Patch.run` · `ref`(일위대가 줄 덮개) = 못 셈 + 까닭 하나(옛 칸 고침 · 저장소 0 · 올림 없음) - `Doc_Take._sk` 복사 펼침 배 = `ratio_of`(문서 셈 안 돎) - M02 옛 엔진 셈 부르는 자리(정적 · census_calls) 13 → 10 · 층 길 0 — 남은 것 = `Labor_Doc.run_line` 몸 · 프로젝트 사본 길(`_frozen` · `Labor_Copy.line` · `_promote` · `_logic` 굳힌 줄 — B9) · `Logic_Settle`(B09 짝) - 로직 1,521 사본 없는 길 옛 대 새: 기준 같음 1,420 · 둘 다 못 셈 68 · 옛만 못 셈 → 새 셈 31 · 다름 2(GC000001 · GC000939 = 값 없는 자재(27 년 보강) + 일위대가 기본 별도계상 — 사본 길과 같은 규칙) · 재료 품목 키 같음 1,313 · 새 쪽이 더 찾음 140 - 시험: 802_4a ⑥ 문서 셈 확인 = `Labor_Copy._traced` · 747_1 줄 덮개 시험 지움(못 셈) · m02_858_shelf_golden 다시 뜸(서고 SK 견본 = 더한줄 고정 = 옛 칸 → 2-C1 뒤 기준금액 없음 · 2-C1 때 놓침) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Take.py | 2 +- M02_MasterTemplete/M02_Hopyo_Build.py | 8 ++- M02_MasterTemplete/M02_Labor_Copy.py | 65 ++++++++++++++++--- M02_MasterTemplete/M02_Labor_Expand.py | 32 +++++++-- M02_MasterTemplete/M02_Labor_Patch.py | 25 +++---- .../tester/fixtures/m02_858_shelf_golden.json | 12 ++-- resources/tester/test_747_1_sk_material.py | 10 +-- resources/tester/test_802_4a_m02_doc.py | 5 +- 8 files changed, 105 insertions(+), 54 deletions(-) diff --git a/M02_MasterTemplete/M02_Doc_Take.py b/M02_MasterTemplete/M02_Doc_Take.py index e3a29d2a8..5e5b5de6f 100644 --- a/M02_MasterTemplete/M02_Doc_Take.py +++ b/M02_MasterTemplete/M02_Doc_Take.py @@ -94,7 +94,7 @@ def _sk(ref: dict, factor: str | None = None, per_unit: bool = False) -> list[di copy = sp.current(raw) if per_unit: # 일위대가 안 SK = 1 단위(기준 ÷ 배) clean, whole = sp._settled(raw) - times = Decimal(str(calc.run(clean, whole).get("배") or 1)) + times = calc.ratio_of(clean, calc._row_of(clean, whole), whole) # 배만(셈 안 돎) if times != 1: factor = _times(factor, f"1 ÷ {_text(times)}") except Exception as e: # noqa: BLE001 — 가져온 식 · 바탕 참조 SK 등 = 못 복사(까닭 글) diff --git a/M02_MasterTemplete/M02_Hopyo_Build.py b/M02_MasterTemplete/M02_Hopyo_Build.py index 512b04f50..1fb644fb9 100644 --- a/M02_MasterTemplete/M02_Hopyo_Build.py +++ b/M02_MasterTemplete/M02_Hopyo_Build.py @@ -328,9 +328,13 @@ class Builder: def _inside(self, lines: list[dict[str, Any]], mats: dict[str, dict[str, Any]]) -> list[str]: """로직 자재와 같은 품목(Labor_Doc `no_twice` 400 막음) — 사용자 자재에서 빼고 세 칸을 그 로직 줄 `자재표시 {재료 줄 차례: 세 칸}` 으로(수량 = 로직 셈) → 옮긴 코드.""" + from M02_MasterTemplete import M02_Labor_Copy as lc # 늦게 — 사본 셈 묶음 둘레 피함 + whole, moved = m01.loaded()[1], [] - for row in (r for r in lines if r.get("로직")): - got = labor.run_line(whole, row["로직"], row.get("입력값"), None, None) + for row in ( + r for r in lines if r.get("로직") + ): # 재료 = 문서 셈 기록 품목(855 2-C5 · 옛 엔진 안 돎) + got = lc.line(whole, {}, {"로직": row["로직"], "입력값": row.get("입력값")}) for m in got.get("재료") or []: code = (m.get("품목") or {}).get("키") if code in mats and code not in moved: diff --git a/M02_MasterTemplete/M02_Labor_Copy.py b/M02_MasterTemplete/M02_Labor_Copy.py index 39e435bde..a13b9918c 100644 --- a/M02_MasterTemplete/M02_Labor_Copy.py +++ b/M02_MasterTemplete/M02_Labor_Copy.py @@ -10,7 +10,7 @@ SK 사본(`M02_Sangeun_Copy` · 795-1) 한 벌 — 문서 칸 `사본` 꼴 · 프로젝트 층 · B09(단가 책 · 굳힌 참조사본) = 옛 길(795-4). 사본 정함(`settle` · 셈 · 저장 첫머리) = 받은 사본 먼저(열 복사 · 층 복사 = 원본 사본 그대로 · 판은 서버가 다시 셈) → 없으면 저장본(일위대가 = labor/<열> · SC = precombo/<키>) → [저장] 때 없으면 새로 -찍음 · 사본에 없는 새 줄만 지금 M01 에서 더함 · 사본 없는 옛 문서 = 셈은 옛 길. +찍음 · 사본에 없는 새 줄만 지금 M01 에서 더함 · 사본 없는 문서(저장 전 새 문서) = 지금 M01 문서 셈. 짝(CLAUDE.md 5장 ①) `M02_MasterTemplete_Labor_Calc.ts` = 서버 기준 값을 받아 수량 · 반영 · 합만 — 사본은 기준 값에만 닿음(짝 안 고침 · 거울 시험 `test_795_2_sc_copy`). """ @@ -26,6 +26,8 @@ from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Sk as dsk from M02_MasterTemplete import M02_Sangeun_Copy as skc +import master_doc_trace as mt # noqa: E402 — scripts 길 = dc(855-F 셈 기록) + KEY, JOB, PRICE, REGEN = skc.KEY, skc.JOB, skc.PRICE, skc.REGEN _SC = re.compile(r"^SC-\d{6}$") @@ -132,17 +134,21 @@ def _formula_of(doc: dict) -> dict | None: def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]: - """로직 줄 기준 — 수식 사본 있는 층 셈 = 문서 셈 한 길(줄 옵션 = 문서 규칙 · `dc.line_doc` · 줄 = 문서 - 답 줄 · 옛 엔진 안 돎 · 855 2-C1) · 프로젝트 층 · B09(단가 책) · 사본 없음 = 옛 길(옛 로직 줄 · - 저장소 0 · B9 · 2-E 걸음 몫).""" + """로직 줄 기준 — 층 셈 = 수식 문서 셈 한 길(줄 옵션 = 문서 규칙 · `dc.line_doc` · 줄 = 문서 답 줄 · + 재료 = 셈 기록이 읽은 품목 · 옛 엔진 안 돎 · 855 2-C1 · 2-C5) · 수식 사본 있음 = 사본 · 없음(저장 전 새 문서) = + 지금 M01 문서(저장 때 사본 찍음) · 프로젝트 층 · B09(단가 책) · `OLD` 시험 = 옛 길(B9 걸음 몫).""" from M02_MasterTemplete import M02_Labor_Doc as labor code, rate, picks = one["로직"], one.get("켜쌓기율"), one.get("고름") - copy = None if _project() or dsk.OLD.get() else _formula_of(doc) - if not copy or getattr(whole, "_tag", None) != (copy.get("판"), copy.get("단가판")): + if _project() or dsk.OLD.get(): got = labor.run_line(whole, code, one.get("입력값"), rate, picks) return labor.drop_apart(got, one.get("자재표시")) - base = copy["부름"].get(code) + copy = _formula_of(doc) + if copy and getattr(whole, "_tag", None) == (copy.get("판"), copy.get("단가판")): + base, docs = copy["부름"].get(code), dc.docs_of(copy) + else: + copy, base = {}, dc.doc_of(whole, code) + docs = dc.closure(whole, dc.calls(base), None) if base else {} if base is None: return {"기준": None, "줄": [], "재료": [], "까닭": f"수식 문서 없음 「{code}」"} row = whole.logic(code) @@ -151,13 +157,52 @@ def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]: one.get("자재표시"), [{"차례": n} for n, x in enumerate(mats) if x.get("종류") == "재료"] ) given = dc.given_of(whole, code, one.get("입력값")) - ans = dc.run(dc.line_doc(base, rate, picks, apart), copy, given, whole) + body = dc.line_doc(base, rate, picks, apart) + ans = _traced(body, whole, docs, given, copy) if "결과" in ans: return {"결과": ans["결과"], "기준": None, "까닭": None} money = dc.money(ans) got = {k: Decimal(str(v)) for k, v in money.items()} if money else None - lines = ans.get("줄") or [] - return {"기준": got, "줄": lines, "재료": [], "까닭": None if got else dc.why(ans)} + src = body.get("금액") or [] + lines = [ # 별도계상 = 상세 줄에서 뺌 · 단위 = 문서 금액 줄 + {**x, "단위": str(src[n].get("단위") or "") if n < len(src) else ""} + for n, x in enumerate(ans.get("줄") or []) + if n not in apart + ] + found = _mats(mats, ans, picks) + return {"기준": got, "줄": lines, "재료": found, "까닭": None if got else dc.why(ans)} + + +def _traced(doc: dict, whole: Any, docs: dict, given: dict, copy: dict) -> dict: + """문서 셈 + 셈 기록(`master_doc_trace` — 셈 답 같음 · 줄마다 부름 · 자원) · 틀림 = 못 셈 표지.""" + try: + return mt.calc(doc, mt.Trace(whole, docs), given, dc.cover_of(copy, doc)) + except dc._ERR as e: + return { + "셈됨": False, + "표지": [{"갈래": "셈 틀림", "글": str(e)}], + **dict.fromkeys(dc.COSTS), + } + + +def _mats(items: list, ans: dict, picks: Any) -> list[dict[str, Any]]: + """로직 자재(103-1) — 맨 위 재료 줄(호표 차례 = 문서 금액 줄 차례)마다 셈 기록이 읽은 품목 키 · + 수량 · 단가 · 금액(별도계상 · 같은 품목 400 · 호표 들이기 `_inside` 가 읽음).""" + calls, lines, out = ans.get("부름") or [], ans.get("줄") or [], [] + for n, item in enumerate(items): + if item.get("종류") != "재료" or n >= len(lines): + continue + read = [calls[j] for j in lines[n].get("부름") or [] if j < len(calls)] + keys = [c.get("품목") for c in read] + [ + x["키"] for c in read for x in c.get("자원") or [] if x.get("갈래") == "재료" + ] + key = next((k for k in keys if k), None) + head = {k: lines[n].get(k) for k in ("수량", "단가", "금액", "까닭")} + out.append( + {"차례": n, "이름": item.get("이름") or "", "단위": item.get("단위") or "", **head} + | {"품목": {"키": key} if key else None, "고름": str(n) in (picks or {})} + ) + return out def combo(expand: Any, doc: dict, trail: tuple[str, ...]) -> dict[str, Any]: diff --git a/M02_MasterTemplete/M02_Labor_Expand.py b/M02_MasterTemplete/M02_Labor_Expand.py index 903bce54f..de58e151a 100644 --- a/M02_MasterTemplete/M02_Labor_Expand.py +++ b/M02_MasterTemplete/M02_Labor_Expand.py @@ -84,13 +84,28 @@ 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 걸음 몫).""" from M02_MasterTemplete import M02_Labor_Doc as labor line = (doc.get("담은로직") or [{}])[0] - code = str(line.get("로직") or "") - got = labor.run_line( - self.whole, code, line.get("입력값"), line.get("켜쌓기율"), line.get("고름") - ) + 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}) times = labor._number(doc.get("배")) or Decimal(1) base = got.get("기준") why = got.get("까닭") or (None if base else "돈 아닌 로직") @@ -104,8 +119,10 @@ class Expand: "줄": [ { **x, - "수량": Decimal(str(x["수량"])) / times, - "금액": Decimal(str(x["금액"])) / times, + **{ + k: None if x.get(k) is None else Decimal(str(x[k])) / times + for k in ("수량", "금액") + }, # 문서 줄 = 빈 값 있음 "비목": {k: Decimal(str(v)) / times for k, v in (x.get("비목") or {}).items()}, } for x in got.get("줄") or [] @@ -113,7 +130,8 @@ class Expand: } def _logic(self, one: dict, pill: dict | None, doc: dict | None = None) -> dict[str, Any]: - """사전조합 안 로직 줄 — 일위대가 로직 줄과 같은 `run_line` · 배는 물량 알약 것.""" + """사전조합 안 로직 줄 — 일위대가 로직 줄과 같은 `Labor_Copy.line`(문서 셈) · 배는 물량 알약 것 · + 굳힌 덮개 줄(프로젝트 사본) = 옛 길(B9 걸음 몫).""" from M02_MasterTemplete import M02_Labor_Doc as labor pill, fz = pill or {}, one.get("굳힌") diff --git a/M02_MasterTemplete/M02_Labor_Patch.py b/M02_MasterTemplete/M02_Labor_Patch.py index f5fdf899f..dbaddc886 100644 --- a/M02_MasterTemplete/M02_Labor_Patch.py +++ b/M02_MasterTemplete/M02_Labor_Patch.py @@ -4,8 +4,7 @@ 로직 줄(`{로직, 입력값, 고름, 자재표시, 패치}`) · 단가산출 참조 줄(`{참조: SK, 패치}`)만 받음 · 줄 `고름` · `자재표시`(호표 차례 열쇠)는 바탕 줄 차례 그대로 — 셈 때 cid 로 바꿔 뺀줄 뒤에도 제자리. 더한줄은 인력 · 재료 · 기계 · 로직 · 고정만(참조는 일위대가에 참조 줄로). -셈 = 줄을 이름 없는 SK 문서로(`as_doc`) → `M02_Sangeun_Calc` 한 벌 · 로직 줄 기준 = 결과단위 값(배는 -알약 · `settle` 그대로) · 참조 줄 = 1 단위 값. [단가산출로 저장] = `as_doc` + 이름 · 단위 → 층 SK. +셈 = 못 셈 + 까닭 하나(옛 칸 고침 셈 은퇴 · 855 2-C5) · [단가산출로 저장] = `as_doc` + 이름 · 단위 → 층 SK. """ from __future__ import annotations @@ -93,28 +92,20 @@ def as_doc(one: dict, whole: Any, name: str = "줄", unit: str = "식") -> dict[ } -def run(whole: Any, one: dict, read: Any = None) -> dict[str, Any]: - """패치 있는 로직 줄 기준(`run_line` 꼴 · 별도계상 뺀 뒤 · 기준 = 결과단위 값).""" - from M02_MasterTemplete import M02_Labor_Ref as refs - from M02_MasterTemplete import M02_Sangeun_Calc as calc +WHY = "일위대가 줄 덮개(패치) — 옛 칸 셈 은퇴 · 단가산출(SK) 수식 문서로 고쳐야 셈" - try: - doc = sd.clean(as_doc(one, whole), None, whole) - return calc.run(doc, whole, None, read or refs.read_ref, line=True) - except sd.DocError as e: - return {"기준": None, "까닭": str(e)} + +def run(whole: Any, one: dict, read: Any = None) -> dict[str, Any]: + """패치 있는 로직 줄 = 못 셈 + 까닭(줄 덮개 = 옛 칸 고침 · 옛 엔진 셈 은퇴 · 855 2-C5 · 올림 없음).""" + return {"기준": None, "까닭": WHY} def ref(one: dict, expand: Any) -> dict[str, Any]: - """참조 줄 펼침 — 패치 있는 SK 참조는 그 줄만 다시 셈(캐시 안 씀) · 그 밖 `expand` 그대로.""" - from M02_MasterTemplete import M02_Sangeun_Calc as calc - + """참조 줄 펼침 — 패치 있는 SK 참조 = 못 셈 + 까닭 · 그 밖 `expand` 그대로.""" if not one.get(FIELD): return expand(one["참조"]) - doc = as_doc(one, expand.whole) base = expand.read(one["참조"]) or {} - doc = {**doc, "이름": base.get("이름") or doc["이름"], "단위": base.get("단위") or doc["단위"]} - return calc.unit(doc, expand.whole, expand, ()) + return {"이름": base.get("이름"), "단위": base.get("단위"), "기준": None, "까닭": WHY} def to_sangeun(one: dict, name: str, unit: str, whole: Any) -> dict[str, Any]: diff --git a/resources/tester/fixtures/m02_858_shelf_golden.json b/resources/tester/fixtures/m02_858_shelf_golden.json index 811c7eaee..6306882b4 100644 --- a/resources/tester/fixtures/m02_858_shelf_golden.json +++ b/resources/tester/fixtures/m02_858_shelf_golden.json @@ -4,7 +4,7 @@ "precombo.나무": "d08cff9db9575c99", "precombo.되돌림": "ce11ade1bd96129c", "precombo.만들기": "e53ad45acbf386bc", - "precombo.목록": "20bd9f3f0803cb91", + "precombo.목록": "a4dc7166ec93ee0e", "precombo.복사": "ea957146cf361b70", "precombo.붙여넣기": "236bf55301ef9045", "precombo.쓰는곳": "8f68c3d2501f7a53", @@ -14,9 +14,9 @@ "precombo.합치기": "2010fbd1ab774d86", "sangeun.고치기": "e47e5593c71f5a56", "sangeun.나무": "991823a8c1fe1913", - "sangeun.되돌림": "6ca25af01d1d38ab", + "sangeun.되돌림": "d9d8086b6750e098", "sangeun.만들기": "2155d280fd6d97ae", - "sangeun.목록": "a75cf0387e16ed84", + "sangeun.목록": "6674d6856ba3a1dc", "sangeun.복사": "40edbd4d0644186f", "sangeun.붙여넣기": "57cfb7bb522a80d3", "sangeun.쓰는곳": "2c9ec1824709481f", @@ -31,9 +31,9 @@ "공유.요청": "762ba10d5af57643", "권한.같은회사남": "2d3d50a90583497d", "권한.남의회사관리": "a1213c908c70528f", - "권한.시스템": "ee1c88a183b2740f", - "권한.일반": "9a05899de41301f2", - "권한.회사관리": "d6da88af7fe80323", + "권한.시스템": "c483315729829096", + "권한.일반": "bb672c1ae51f52ba", + "권한.회사관리": "4a86951c93b6f56e", "내기계.고치기": "3f00365dbfb77cee", "내기계.만들기": "20f5562f02c276f8", "내기계.목록": "064102da4c9740d6", diff --git a/resources/tester/test_747_1_sk_material.py b/resources/tester/test_747_1_sk_material.py index a24344197..feca9a06f 100644 --- a/resources/tester/test_747_1_sk_material.py +++ b/resources/tester/test_747_1_sk_material.py @@ -1,11 +1,10 @@ """SK 바탕 재료 = M01 기초 그대로 셈(PLAN 747-1) — 별도계상 빈 칸 = 직접계산 · 고른 줄만 밖 · -일위대가 덮개 줄(`M02_Labor_Patch.run`)은 일위대가 기본(별도계상) 그대로.""" +(일위대가 줄 덮개 = 옛 칸 셈 은퇴 · 855 2-C5).""" import pytest from M01_MasterData import M01_MasterData_Store as m01 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 from M02_MasterTemplete import M02_Sangeun_Doc as sd @@ -40,10 +39,3 @@ def test_explicit_apart(): out = _run(바탕={"로직": FORM}, 자재표시={PLY: {"별도계상": "별도계상"}}) assert next(x for x in out["줄"] if x["이름"] == "합판(내수 12㎜)")["합밖"] is True assert out["기준"]["재료비"] < base["기준"]["재료비"] - ply["금액"] + 1 - - -def test_hopyo_line_keeps_line_default(): - whole = _whole() - line = {"로직": FORM, "입력값": {}, "패치": {"덮개": {PLY: {"qty": 2}}}} - got = labor._json(patch.run(whole, line)) - assert all(x["cid"] != PLY for x in got["줄"]) # 일위대가 기본 = 별도계상(222-1) diff --git a/resources/tester/test_802_4a_m02_doc.py b/resources/tester/test_802_4a_m02_doc.py index bf8c60b74..73bc230ad 100644 --- a/resources/tester/test_802_4a_m02_doc.py +++ b/resources/tester/test_802_4a_m02_doc.py @@ -21,6 +21,7 @@ from M02_MasterTemplete import M02_Doc_Sk as dsk from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Item_Snapshot as snap from M02_MasterTemplete import M02_Item_Source as source +from M02_MasterTemplete import M02_Labor_Copy as lc from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_MasterTemplete_Store as store from resources.tester.test_795_1_sk_copy import _calc, _changed, _doc, _fake, _live, _save, _sk @@ -176,8 +177,8 @@ def test_sc_and_labor_use_doc(world, monkeypatch): stored = _at(me, store.read, "precombo", sc)["문서"] assert dc.has(stored) and PCT in stored[dc.KEY]["부름"] runs = [] - real = dc.run - monkeypatch.setattr(dc, "run", lambda *a, **k: runs.append(1) or real(*a, **k)) + real = lc._traced # 로직 줄 문서 셈(855 2-C5 — 셈 기록 같이) + monkeypatch.setattr(lc, "_traced", lambda *a, **k: runs.append(1) or real(*a, **k)) new = (_sc_calc(me, sc)["기준합"], _sc_calc(me, "sub2임시")["반영합"]) assert runs token = dsk.OLD.set(True) From 35bde65aaaf728c4af0095bad81f7883b0558de7 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:10:39 +0900 Subject: [PATCH 2/7] =?UTF-8?q?refactor(856-2):=20=EB=8B=A8=EA=B0=80?= =?UTF-8?q?=EC=82=B0=EC=B6=9C=20=ED=99=94=EB=A9=B4=20=EB=A8=B8=EB=A6=AC=20?= =?UTF-8?q?=EB=9D=A0=EB=A5=BC=20=EC=A4=84=20=EC=8C=93=EA=B8=B0=20=EC=85=88?= =?UTF-8?q?=20=EB=8B=B5=20=C2=B7=20=EC=82=AC=EB=B3=B8=20=ED=91=9C=EC=A7=80?= =?UTF-8?q?=EB=A1=9C=20=E2=80=94=20=ED=99=94=EB=A9=B4=20/sangeun/calc=20?= =?UTF-8?q?=EB=B6=80=EB=A6=84=201=20=E2=86=92=200?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 머리 띠 근거 = 줄 쌓기 onAnswer(브라우저 셈 답 · 문서 읽기 사본 표지 · 못 읽은 까닭) - 까닭(빨강) = 못 읽음 · 못 셈(서버 run 까닭과 같은 차례 — 틀림 › 표지 › 까닭 › 빈값) - 빠진 줄 = 금액 없는 줄 · M01 개정 = 자동 따라옴 알림(갱신) · 프로젝트 층 M01 새 판 - 짝 잃음 · 셈 머리 배지 걷음(덮개 없음 · 2-C1 뒤 서버 답이 늘 비어 지금도 안 뜸) - Sangeun_Cover.ts 지움(calcSangeun · 부르는 곳 Detail 하나) · CSS 불러오기 · SkDoc 꼴은 Detail 로 - getDoc 의 바탕판 적기 걷음(서버가 저장 때 다시 적고 화면 값 버림) - 줄 쌓기 못 읽음 두 자리를 한 함수로(머리 글 + 알림) - setLogicApiPaths 전역 남김 — M02 새 재료 찾기 · 단위 환산 표가 그 길에 기댐(몫 밖 파일) - 서버 길 /sangeun/calc · 본체 그대로(2-E2 몫) - 시험 test_856_0: 부름 수 단언 1 → 0 · 띠 견본을 줄 쌓기 답 꼴로(옛 서버 답 견본은 그 길이 화면에서 빠져 낡음) Co-Authored-By: Claude Opus 5.5 --- A00_Common/line_stack_screen.ts | 34 +++--- .../M02_MasterTemplete_Sangeun_Cover.ts | 50 -------- .../M02_MasterTemplete_Sangeun_Detail.ts | 111 +++++++++--------- .../M02_MasterTemplete_Sangeun_Tabs.ts | 5 +- resources/tester/helper_856_0_sk_screen.cjs | 85 ++++++++------ resources/tester/test_856_0_sk_screen.py | 31 +++-- 6 files changed, 151 insertions(+), 165 deletions(-) delete mode 100644 M02_MasterTemplete/M02_MasterTemplete_Sangeun_Cover.ts diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 3db308cc7..89abd4681 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -97,6 +97,16 @@ export interface StackScreenOptions { memory?: () => Record | null; /** 856-4 찾아 넣기 창(M01 · M02 = M02 `openFindPicker`) — 공용 화면은 M02 를 부르지 않음 */ find: StackFind; + /** 856-2 그릴 때마다 · 못 읽음 — 셈 답 · 사본 표지(M02 단가산출 머리 띠) */ + onAnswer?: (got: StackAnswer) => void; +} + +/** 856-2 머리 띠 재료 — 브라우저 셈 답 · 문서 읽기 사본 표지 · 못 읽은 까닭 */ +export interface StackAnswer { + doc: StackDoc | null; + answer: DocAnswer | null; + mark?: CopyMark; + fail: string; } type Docs = Record; @@ -338,7 +348,15 @@ export function createStackScreen(opt: StackScreenOptions) { if (cache.takeMissing()) ask(); return got; }; + /** 못 읽음 — 머리에 까닭 · 페이지에 알림(856-2) */ + const failed = (e: unknown): void => { + const fail = e instanceof Error ? e.message : ""; + const text = `${ft("Load_Failed")} — ${fail}`; + head.replaceChildren(el("p", { className: "ui-text ui-text--muted", text })); + opt.onAnswer?.({ doc, answer, mark, fail }); + }; const draw = (): void => { + opt.onAnswer?.({ doc, answer, mark, fail: "" }); if (!doc || !answer) { [head, left, right, foot].forEach((x) => x.replaceChildren()); opt.tools?.replaceChildren(); @@ -602,13 +620,7 @@ export function createStackScreen(opt: StackScreenOptions) { recalc(); return draw(); } catch (e) { - if (mine === seq) - head.replaceChildren( - el("p", { - className: "ui-text ui-text--muted", - text: `${ft("Load_Failed")} — ${e instanceof Error ? e.message : ""}`, - }), - ); + if (mine === seq) failed(e); return; } } @@ -645,13 +657,7 @@ export function createStackScreen(opt: StackScreenOptions) { }); } } catch (e) { - if (mine === seq) - head.replaceChildren( - el("p", { - className: "ui-text ui-text--muted", - text: `${ft("Load_Failed")} — ${e instanceof Error ? e.message : ""}`, - }), - ); + if (mine === seq) failed(e); } }; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Cover.ts b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Cover.ts deleted file mode 100644 index 0bf9ad8da..000000000 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Cover.ts +++ /dev/null @@ -1,50 +0,0 @@ -/* ============================================================================= - * M02_MasterTemplete_Sangeun_Cover.ts - * 단가산출(SK) 셈 길 부름(PLAN 717-2b · 856-1) — 머리 띠 · 배지용(856-2 에서 문서 답으로 바꾸고 이 파일 지움) - * · 셈 = `calcSangeun`(`POST /layers/{층}/sangeun/calc` · 저장 안 함 · 부르는 쪽이 최신 응답만 받음) - * ========================================================================== */ - -import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch"; -import "./M02_MasterTemplete_Sangeun.css"; - -export interface SkScope { - layer: Layer; - owner: string | null; -} - -/** SK 문서 중 화면 머리가 만지는 칸 */ -export interface SkDoc { - 키?: string; - 이름?: string; - 단위?: string; - 바탕?: { 로직?: string; 참조?: { 층?: string; 주인?: string | null; 키?: string } } | null; - 입력값?: Record; - 바탕판?: string; - [k: string]: unknown; -} - -/** 셈 답 중 머리 띠 · 배지가 읽는 칸 */ -export interface SkAnswer { - 까닭?: string | null; - /** 못 셈 줄(725) — 그 줄만 빠지고 나머지 셈 */ - 빠진줄?: { cid: string; 이름: string; 까닭: string }[]; - 짝잃음?: { cid: string; 까닭: string }[]; - 바탕판: string; - 머리?: string; -} - -const q = (scope: SkScope): string => - scope.owner && scope.layer !== "system" ? `?owner=${encodeURIComponent(scope.owner)}` : ""; - -/** 셈(저장 안 함) — 문서 = 화면 문서 · `given` = 시험 입력(빈 칸 뺌) */ -export function calcSangeun( - scope: SkScope, - doc: Record, - given: Record = {}, -): Promise { - const 입력값 = Object.fromEntries(Object.entries(given).filter(([, v]) => String(v).trim())); - return call(`/layers/${scope.layer}/sangeun/calc${q(scope)}`, { - method: "POST", - body: JSON.stringify({ 문서: doc, 입력값, 보기: false }), // 보기 false = 글 · 중간 덧칸 안 지음(몸 걷음 · 856-1) - }); -} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts index 7f02bbaef..357579531 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts @@ -3,7 +3,9 @@ * M02 단가산출(SK) 화면(PLAN 717-2b · 804-8 · 856-1) — 머리(이름 · 단위 · 단위 환산 · 바탕) · 머리 띠 · 줄 쌓기(`_Sangeun_Tabs`). * 모드(856-1 · 옛 키 글자 약속 `SK-000000` 대신) = page(단가산출 화면 · 일위대가 SK 모달 — 원문 패널 · 페이지 [저장] 한 번 · * 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만) - * 머리 띠(까닭 · M01 개정 · 빠진 줄 · 짝 잃음) · 머리 배지 = 서버 셈 길 최신 응답(856-2 에서 문서 답으로) + * 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) — + * 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 · + * M01 개정 = 자동 따라옴 알림(`갱신`) · 프로젝트 층 「M01 새 판」 · 짝 잃음 = 덮개 없음([재생성] 답이 알림) * 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌 * ========================================================================== */ @@ -18,15 +20,26 @@ import { setLogicApiPaths, type LogicOne, } from "../M01_MasterData/M01_MasterData_UI_Logic_Api"; +import { isStale } from "../A00_Common/formula_doc_copy"; +import type { StackAnswer } from "../A00_Common/line_stack_screen"; import { readTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch"; -import { calcSangeun, type SkAnswer, type SkDoc } from "./M02_MasterTemplete_Sangeun_Cover"; import { createSangeunTabs } from "./M02_MasterTemplete_Sangeun_Tabs"; import { tl } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Text"; import { createSangeunSide, tabOf } from "./M02_MasterTemplete_Sangeun_Side"; import { buildUnitSwap, type SwapHow } from "./M02_MasterTemplete_Sangeun_Unit"; +import "./M02_MasterTemplete_Sangeun.css"; export type SangeunMode = "page" | "ref" | "memory"; +/** SK 문서 중 화면 머리가 만지는 칸 */ +export interface SkDoc { + 키?: string; + 이름?: string; + 단위?: string; + 바탕?: { 로직?: string; 참조?: { 층?: string; 주인?: string | null; 키?: string } } | null; + [k: string]: unknown; +} + export interface SangeunDetailOptions { layer: Layer; owner: string | null; @@ -42,6 +55,31 @@ export interface SangeunDetailOptions { const LIB = { read: "/m02/logic-lib", calc: "/m02/logic-lib" }; const clone = (v: T): T => JSON.parse(JSON.stringify(v)) as T; +/** 머리 띠 재료(856-2) — 못 셈 까닭 · 금액 없는 줄 · M01 개정 */ +export function bandsOf(got: StackAnswer | null): { + why: string; + gaps: { 이름: string; 까닭: string }[]; + revised: boolean; +} { + const a = got?.answer; + const m = got?.mark; + const marks = (a?.표지 ?? []).map((x) => `${x.갈래} — ${x.글}`).join(" · "); + const why = + got?.fail || + (!a || a.셈됨 || "결과" in a + ? "" + : String((got?.doc as { _틀림?: string } | null)?._틀림 ?? "") || + marks || + a.까닭 || + Object.values(a.빈값 ?? {}).join(" · ") || + "돈 아닌 문서"); + const gaps = (a?.셈됨 ? (a.줄 ?? []) : []) + .filter((r) => r.까닭 && r.금액 == null) + .map((r) => ({ 이름: String(r.이름 ?? ""), 까닭: String(r.까닭) })); + const revised = !!m?.갱신?.length || (!m?.자동 && isStale(m)); + return { why, gaps, revised }; +} + export function mountSangeunDetail( host: HTMLElement, doc0: unknown, @@ -58,18 +96,15 @@ export function mountSangeunDetail( const edit = !opt.readOnly; const page = opt.mode === "page"; const scope = { layer: opt.layer, owner: opt.owner }; - const values: Record = Object.fromEntries( - Object.entries(doc.입력값 ?? {}).map(([k, v]) => [k, String(v)]), - ); let base: LogicOne | null = null; - let ans: SkAnswer | null = null; + let got: StackAnswer | null = null; // 줄 쌓기 셈 답 · 사본 표지(856-2) let fail = ""; const side = page ? createSangeunSide() : null; - let seq = 0; let alive = true; const head = el("div", { className: "m02-sk__head", attrs: { "data-sk-head": "" } }); const notes = el("div"); + const flag = el("span"); // M01 개정 배지 자리(856-2 — 줄 쌓기가 그릴 때마다 머리 칸은 그대로) let refreshing: Promise = Promise.resolve(); const tabs = createSangeunTabs({ edit, @@ -78,6 +113,10 @@ export function mountSangeunDetail( page: page ? () => report() : undefined, // 804-8 페이지 [저장] · [되돌림] // 836-5 저장 전 가져온 식(불러오기 미리 보기) = 그 문서째 수식 보기 memory: opt.mode === "memory" ? () => doc as Record : undefined, + onAnswer: (next) => { + got = next; + if (alive) drawNotes(); + }, }); /** 수식 저장 = 파일 판 · `수식` 칸이 바뀜 — 페이지 판 · 이 화면 문서 `수식` 을 새로 */ async function formulaSaved(version: string): Promise { @@ -110,35 +149,17 @@ export function mountSangeunDetail( ); tabs.draw(opt.mode === "memory" ? "" : (doc.키 ?? "")); - // 바탕 없는 SK 의 지문 = 이름 · 단위 따라 바뀜 — 바탕이 있을 때만 M01 개정으로 봄(725-3) - const revisedBase = (): boolean => - !!(doc.바탕 && doc.바탕판 && ans?.바탕판 && doc.바탕판 !== ans.바탕판); const baseKey = (): string | null => doc.바탕?.로직 ?? null; /** 고침 알림 — 기본(이름 · 단위 · 환산) + 수식 */ function report(): void { if (alive) opt.onChanged(edit && (JSON.stringify(doc) !== saved || tabs.dirty())); } - const touch = (again = true): void => { + const touch = (): void => { report(); - if (again) void recalc(); - else drawHead(); + drawHead(); }; - /** 머리 띠 · 배지 = 서버 셈 한 번(최신 응답만) */ - async function recalc(): Promise { - const mine = ++seq; - try { - const got = await calcSangeun(scope, doc, values); - if (mine !== seq || !alive) return; // 늦게 온 답 — 버림 - [ans, fail] = [got, ""]; - } catch (error) { - if (mine !== seq || !alive) return; - [ans, fail] = [null, error instanceof Error ? error.message : String(error)]; - } - draw(); - } - function drawHead(): void { const field = (label: string, key: "이름" | "단위"): HTMLElement => { const box = createInputField({ label, value: doc[key] ?? "", compact: true, size: 28 }); @@ -147,7 +168,7 @@ export function mountSangeunDetail( box.input.addEventListener("change", () => { doc[key] = box.input.value.trim(); box.setError(doc[key] ? undefined : L("M02_SangeunNeed")); - touch(key === "단위"); + touch(); }); return box.root; }; @@ -173,44 +194,27 @@ export function mountSangeunDetail( el("div", { className: "m02-sk__tags", attrs: { "data-sk-base": baseKey() ?? "" }, - children: [ - createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14), - ...(ans?.머리 ? [createBadge(ans.머리, "info")] : []), - ...(revisedBase() ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []), - ], + children: [createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14), flag], }), ); } function drawNotes(): void { - const lost = ans?.짝잃음 ?? []; - const gaps = ans?.빠진줄 ?? []; + const { why, gaps, revised } = bandsOf(got); notes.replaceChildren( - ...(fail || ans?.까닭 - ? [createBanner({ tone: "danger", text: fail || String(ans?.까닭) })] - : []), - ...(revisedBase() - ? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })] - : []), + ...(fail || why ? [createBanner({ tone: "danger", text: fail || why })] : []), + ...(revised ? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })] : []), ...(gaps.length ? [ createBanner({ tone: "warning", - text: `${L("M02_SangeunGap")} — ${gaps.map((x) => x.이름 || x.cid).join(" · ")}`, - details: gaps.map((x) => `${x.이름 || x.cid} — ${x.까닭}`).join("\n"), - }), - ] - : []), - ...(lost.length - ? [ - createBanner({ - tone: "warning", - text: L("M02_SangeunLost"), - details: lost.map((x) => `${x.cid} — ${x.까닭}`).join("\n"), + text: `${L("M02_SangeunGap")} — ${gaps.map((x) => x.이름).join(" · ")}`, + details: gaps.map((x) => `${x.이름} — ${x.까닭}`).join("\n"), }), ] : []), ); + flag.replaceChildren(...(revised ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : [])); } function draw(): void { @@ -229,15 +233,12 @@ export function mountSangeunDetail( fail = error instanceof Error ? error.message : String(error); } } - if (!alive) return; draw(); - await recalc(); } void loadBase(); return { getDoc: () => { - if (ans?.바탕판 && doc.바탕) doc.바탕판 = ans.바탕판; // 저장 = 지금 바탕 확인(서버가 다시 적음) saved = JSON.stringify(doc); return clone(doc); }, diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Tabs.ts b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Tabs.ts index 47b618ffd..23c154bb1 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Tabs.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Tabs.ts @@ -7,7 +7,7 @@ * [단가 갱신] · [재생성](808-1 · 요구 701-3) = `tools` — 머리 줄 * ========================================================================== */ -import { createStackScreen } from "../A00_Common/line_stack_screen"; +import { createStackScreen, type StackAnswer } from "../A00_Common/line_stack_screen"; import { el } from "@ui/ui_template_elements"; import type { Layer } from "./M02_MasterTemplete_Api_Fetch"; import { openFindPicker } from "./M02_MasterTemplete_Find_Pick"; @@ -21,6 +21,8 @@ export interface SkEquationOptions { page?: () => void; /** 저장 전 불러온 단가산출 문서(836-5 · 미리 보기 835-1) — 그 문서째 수식 보기 */ memory?: () => Record | null; + /** 856-2 셈 답 · 사본 표지 — 머리 띠 */ + onAnswer?: (got: StackAnswer) => void; } /** SK 수식 길 — 꼬리 물음(`/table?key=…`)에 주인 물음을 이어 붙임 */ @@ -58,6 +60,7 @@ export function createSangeunTabs(opt: SkEquationOptions): { page: opt.page, tools, memory: opt.memory, + onAnswer: opt.onAnswer, }); return { tools, diff --git a/resources/tester/helper_856_0_sk_screen.cjs b/resources/tester/helper_856_0_sk_screen.cjs index 3cb4c1ce2..17feca269 100644 --- a/resources/tester/helper_856_0_sk_screen.cjs +++ b/resources/tester/helper_856_0_sk_screen.cjs @@ -134,15 +134,19 @@ const ui = { }; const grid = { onRowClick: null }; -// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음 +// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음 · 그릴 때 견본 셈 답 · 사본 표지를 알림(856-2) const stacks = []; +let stackAns = () => ({ doc: {}, answer: plainAns(), mark: { 자동: true }, fail: "" }); const screen = { createStackScreen: (opt) => { const s = { root: box("div", { "data-stack": "" }), draws: [], opt }; stacks.push(s); return { root: s.root, - draw: (k) => s.draws.push({ key: k, memory: !k && !!opt.memory?.() }), + draw: (k) => { + s.draws.push({ key: k, memory: !k && !!opt.memory?.() }); + setTimeout(() => opt.onAnswer?.(stackAns()), 0); + }, dirty: () => false, save: async () => true, discard: async () => {}, @@ -154,11 +158,9 @@ const screen = { // 서버 부름 — 길 · 몸을 적고 견본 답 const calls = []; -let skAnswer = () => ({}); const api = { call: async (p, init) => { calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null }); - if (p.includes("/sangeun/calc")) return skAnswer(); if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] }; return {}; }, @@ -207,7 +209,7 @@ const stubs = { const real = new Set([ "M02_MasterTemplete_Sangeun_Detail", "M02_MasterTemplete_Sangeun_Tabs", - "M02_MasterTemplete_Sangeun_Cover", + "formula_doc_copy", "M02_MasterTemplete_Sangeun_BaseHead", "M02_Sangeun_Cover_Model", "M02_Sangeun_Undo", @@ -266,17 +268,18 @@ const shown = (n) => { return true; }; const skCalls = () => calls.filter((c) => c.path.includes("/sangeun/calc")); -const plainAns = (o = {}) => ({ - 기준: null, - 줄: [ - { 이름: "보통인부", cid: "labor:LB1#0", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } }, - ], - 정체: ["labor:LB1#0"], - 짝잃음: [], - 빠진줄: [], - 바탕판: "v1", - ...o, -}); +/** 브라우저 셈 답(`calcDoc` 꼴) */ +function plainAns(o = {}) { + return { + 셈됨: true, + 표지: [], + 빈값: {}, + 줄: [{ 이름: "보통인부", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } }], + 계: 100, + 머리: "계", + ...o, + }; +} /** 단가산출 화면 한 벌 열기 — 부름 수 · 숨은 몸 · 줄 쌓기 그림 · 띠 */ async function openSk(doc, opt = {}) { @@ -299,6 +302,7 @@ async function openSk(doc, opt = {}) { bodyShown: all(host, (n) => "skCover" in n.dataset && shown(n)).length, stack: s ? { shown: shown(s.root), draws: s.draws } : null, banners: all(host, (n) => "banner" in n.dataset).map((n) => n.dataset.banner), + texts: all(host, (n) => "banner" in n.dataset).map((n) => n.textContent), badges: all(host, (n) => "badge" in n.dataset).map((n) => [n.dataset.badge, n.textContent]), }; h.destroy(); @@ -307,7 +311,6 @@ async function openSk(doc, opt = {}) { (async () => { const out = {}; - skAnswer = () => plainAns(); // ① 단가산출 화면(페이지) — 바탕 있음 · 없음 out.page_base = await openSk( { 키: "SK-000001", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } }, @@ -315,26 +318,38 @@ async function openSk(doc, opt = {}) { ); out.page_nobase = await openSk({ 키: "SK-000002", 이름: "견본", 단위: "㎡" }, { mode: "page" }); // 불러오기 미리 보기(저장 전 가져온 식) - out.memory = await openSk({ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } }, { mode: "memory" }); - - // ③ 머리 띠 넷(견본 답) — 까닭 · M01 개정 · 빠진 줄 · 짝 잃음 + 머리 배지 - skAnswer = () => - plainAns({ - 까닭: "못 셈", - 빠진줄: [{ cid: "labor:LB2#1", 이름: "특별인부", 까닭: "입력 없음" }], - 짝잃음: [{ cid: "labor:LB9#0", 까닭: "줄 없음" }], - 바탕판: "v2", - 머리: "계", - }); - out.bands = await openSk( - { 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" }, 바탕판: "v1" }, - { mode: "page" }, + out.memory = await openSk( + { 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } }, + { mode: "memory" }, ); - skAnswer = () => { - throw new Error("서버 못 닿음"); + + // ③ 머리 띠(856-2 — 줄 쌓기 셈 답 · 사본 표지) — 빠진 줄 · M01 개정(자동 따라옴 알림) · 못 셈 까닭 · 프로젝트 층 새 판 · 못 읽음 + const gapLine = { 이름: "특별인부", 금액: null, 까닭: "입력 없음", 비목: {} }; + const sk3 = { 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" } }; + const bandCase = async (ans, key) => { + stackAns = () => ans; + const r = await openSk({ ...sk3, 키: key }, { mode: "page" }); + stackAns = () => ({ doc: {}, answer: plainAns(), mark: { 자동: true }, fail: "" }); + return r; }; - out.bands_fail = await openSk({ 키: "SK-000004", 이름: "띠", 단위: "㎡" }, { mode: "page" }); - skAnswer = () => plainAns(); + const ans = (a, mark = { 자동: true }, doc = {}) => ({ doc, answer: a, mark, fail: "" }); + out.bands = await bandCase( + ans(plainAns({ 줄: [...plainAns().줄, gapLine] }), { 자동: true, 갱신: [{ 키: "M1" }] }), + "SK-000003", + ); + out.bands_why = await bandCase( + ans( + plainAns({ 셈됨: false, 계: null, 표지: [{ 갈래: "빈 문서", 글: "금액 줄 · 결과 없음" }] }), + ), + "SK-000005", + ); + out.bands_broken = await bandCase(ans(plainAns({ 셈됨: false }), {}, { _틀림: "틀린 문서" }), "SK-000006"); // prettier-ignore + out.bands_stale = await bandCase(ans(plainAns(), { 자동: false, M01새판: true }), "SK-000007"); + out.bands_auto_stale = await bandCase( + ans(plainAns(), { 자동: true, M01새판: true }), + "SK-000008", + ); + out.bands_fail = await bandCase({ doc: null, answer: null, fail: "서버 못 닿음" }, "SK-000004"); // ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄 const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts"); diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py index a46c65b0d..3ad647446 100644 --- a/resources/tester/test_856_0_sk_screen.py +++ b/resources/tester/test_856_0_sk_screen.py @@ -1,9 +1,9 @@ # -*- coding: utf-8 -*- """PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`). -① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 수 · 숨은 상세 몸 DOM · 줄 쌓기 그림 +① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 0(856-2) · 숨은 상세 몸 DOM · 줄 쌓기 그림 ② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄 -③ 머리 띠 넷(까닭 · M01 개정 · 빠진 줄 · 짝 잃음)이 뜨는 경우 — 견본 답 +③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음) ④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기 """ @@ -31,9 +31,9 @@ def _run() -> dict: def test_sk_page_open_calls_and_hidden_body() -> None: got = _run() - # 856-1 — 셈 한 번(머리 띠용 · 바탕 원값 bare 셈 걷음) · 숨은 상세 몸 DOM 0 · 줄 쌓기 한 번 그림 + # 856-2 — 서버 셈 길 안 부름(머리 띠 = 줄 쌓기 답) · 숨은 상세 몸 DOM 0 · 줄 쌓기 한 번 그림 for k in ("page_base", "page_nobase", "memory"): - assert got[k]["calc"] == 1, k + assert got[k]["calc"] == 0, k assert got[k]["body"] == 0, k assert got[k]["stack"]["shown"] is True, k assert got["page_base"]["stack"]["draws"] == [{"key": "SK-000001", "memory": False}] @@ -45,7 +45,7 @@ def test_labor_row_click() -> None: sk, logic = _run()["labor"] # 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 assert sk["skModal"] == 1 and sk["stack"]["shown"] is True - assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 1 + assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 0 # M01 로직 줄 = 줄 모달(안내 한 줄) · 상세 몸 · 줄 쌓기 · 셈 없음(856-1) assert logic["skModal"] == 0 and logic["stack"] is None assert logic["body"] == 0 and logic["banners"] == ["info"] and logic["calc"] == 0 @@ -59,13 +59,24 @@ def test_labor_row_click_inject() -> None: assert row["body"] == 0 and row["banners"] == ["info"] and row["calc"] == 0 -def test_head_bands_four() -> None: +def test_head_bands() -> None: got = _run() - # 까닭(빨강) · M01 개정 · 빠진 줄 · 짝 잃음(노랑) + 머리 배지 · 개정 배지 - assert got["bands"]["banners"] == ["danger", "warning", "warning", "warning"] - assert got["bands"]["badges"] == [["info", "계"], ["danger", "M02_SangeunRevisedBase"]] - # 서버 못 닿음 = 빨강 하나 + # 자동 따라옴 알림 = M01 개정(노랑 + 빨강 배지) · 금액 없는 줄 = 빠진 줄(노랑) + b = got["bands"] + assert b["banners"] == ["warning", "warning"] and b["calc"] == 0 + assert b["badges"] == [["danger", "M02_SangeunRevisedBase"]] + assert b["texts"][0] == "M02_SangeunRevisedNote" + assert b["texts"][1] == "M02_SangeunGap — 특별인부" + # 못 셈 = 빨강 하나 · 글 = 서버 `까닭` 과 같은 차례(틀림 › 표지 › 까닭 › 빈값) + assert got["bands_why"]["banners"] == ["danger"] + assert got["bands_why"]["texts"] == ["빈 문서 — 금액 줄 · 결과 없음"] + assert got["bands_broken"]["texts"] == ["틀린 문서"] + # 프로젝트 층(자동 아님) 「M01 새 판」 = M01 개정 · 자동 따라옴 층은 알림 없으면 띠 없음 + assert got["bands_stale"]["banners"] == ["warning"] + assert got["bands_auto_stale"]["banners"] == [] and got["bands_auto_stale"]["badges"] == [] + # 못 읽음 = 빨강 하나(그 까닭) assert got["bands_fail"]["banners"] == ["danger"] + assert got["bands_fail"]["texts"] == ["서버 못 닿음"] assert got["page_base"]["banners"] == [] and got["page_base"]["badges"] == [] From eeda873035abf9a64ebb1a275c7913498b8c24ad Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:20:24 +0900 Subject: [PATCH 3/7] =?UTF-8?q?fix(857-3a):=20=EA=B0=80=EC=A0=B8=EC=98=A8?= =?UTF-8?q?=20=EC=8B=9D=20=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20=EB=8D=94?= =?UTF-8?q?=ED=95=9C=EC=A4=84=20=EA=B0=88=EB=9E=98=20=EB=AC=B8=EC=84=9C=20?= =?UTF-8?q?=EC=A7=93=EA=B8=B0=20=E2=80=94=20=EC=9A=94=EC=86=8C=20=C2=B7=20?= =?UTF-8?q?=EA=B8=B0=EA=B3=84=20=C2=B7=20=EB=A1=9C=EC=A7=81=20=EB=B6=80?= =?UTF-8?q?=EB=A6=84=20=C2=B7=20=ED=98=95=EC=A0=9C=20SK=20=EC=A4=84?= =?UTF-8?q?=EC=9D=B4=20=EC=85=88=EB=90=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 흠: 857-3a 뒤 M02_San_ToDoc 이 손 값 줄만 지어 요소 더한줄(인력 · 재료 · 기계 키)이 KeyError 「단가」 로 못 셈(test_793_2 덮개 시험 끝 단언 · sub3 찾음) - San_ToDoc: 요소 키 줄 = 요소 연결(M01 값 · 품셈재료 = 줄 단위) · 기계 키 줄 = 시간당 기계경비 단가산출의 그 비목(가져온 기계 줄과 같은 짝 · hourly_link) · 로직 부름 줄 = 단가산출 연결(이름 · 결과단위 = M01 수식 문서 머리 · 색인 .logic 안 부름) · 「로직(…)」 글 읽기 logic_call 한 벌(Doc_Import._logic_link 도 이것을 씀) - Doc_Import: 형제 SK 더한줄 = 0 자리값 + 단가산출 연결(바탕 안쪽 산근과 같은 길 · 엑셀 값 없음) · 율 · 고친 둘째 기초 더한줄만 못 셈(855 2-C1 그대로) - 새 지킴 test_857_3a_import_adds — 갈래마다 금액(인력 = 수량 × M01 노임 두 판 · 재료 · 기계 그 비목 · 손 단가 · 고정 줄 · 로직 부름 · 형제 SK = 수량 × 그 SK · 율 = 못 셈 까닭) - 지킴: test_793_* · test_855_sk_layers · 새 시험 58 통과 · test_857_import_golden 전수 2 통과(지문 같음) · 관련 시험 172 · typecheck 0 · 화면(8010 · 봉화 단산21 저장 → 줄 더함 보통인부 → 2,346 → 174,414 · 저장 · 다시 열기 같음 · 지움 · 콘솔 0) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import.py | 36 +++--- M02_MasterTemplete/M02_San_ToDoc.py | 101 +++++++++++++-- resources/tester/test_857_3a_import_adds.py | 129 ++++++++++++++++++++ 3 files changed, 233 insertions(+), 33 deletions(-) create mode 100644 resources/tester/test_857_3a_import_adds.py diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index 33d9ad5b8..feab50912 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -74,10 +74,9 @@ def _index(sk: dict, master: Any = None, doc: Any = None) -> Any: # ── 엑셀 단가 그대로 고친 줄(가져온 로직 줄 + SK 고침 · 엔진 셈 없음) ───────── def _engine_adds(doc: dict) -> bool: - """값을 엔진 셈으로만 얻는 더한줄(형제 SK · 율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴).""" - return any( - one.get("참조") or sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or [] - ) + """값을 엔진 셈으로만 얻는 더한줄(율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴) · + 형제 SK 더한줄 = 단가산출 연결(`_attach`).""" + return any(sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or []) def _ctx(sk: dict, whole: Any) -> tuple: @@ -92,7 +91,7 @@ def _ctx(sk: dict, whole: Any) -> tuple: raw = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}} doc = sd.clean(raw, None, whole) if _engine_adds(doc): - raise ValueError("형제 SK · 율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈") + raise ValueError("율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈") w = skc.over(doc, whole) base = sd.empty_row(doc) base = {**base, "호표": [dict(x) for x in base.get("호표") or []]} @@ -103,6 +102,9 @@ def _ctx(sk: dict, whole: Any) -> tuple: filled, lack = calc._fill(doc, w, dict(doc.get("입력값") or {})) got = sd.patched(base, filled, {}, {}) items = got["줄"]["호표"] + for item in items: # 더한 형제 SK 줄도 0 자리값(`_attach` 가 단가산출 연결로 갈음) + if "참조" in item and item.get("값묶음") is None: + item["값묶음"] = dict.fromkeys(imp.COSTS, Decimal(0)) calc._direct(got["자재표시"], items) for at, cid in enumerate(got["정체"][: len(items)]): if cid.startswith("add:#") and int(cid[5:]) in lack: @@ -258,24 +260,13 @@ def hourly_link(eq: str, part: str) -> dict | None: return {"갈래": "단가산출", "키": str(logic["키"]), "입력": given, "칸": part} -_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") -_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") - - def _logic_link(text: str) -> dict | None: - """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(불러오기가 짓는 글 꼴).""" - s = str(text) - head = _HEAD.match(s) - if head is None: + """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(`San_ToDoc.logic_call`).""" + got = todoc.logic_call(text) + if got is None: return None - at, given = head.end(), {} - while arg := _ARG.match(s, at): - name = arg[1] if arg[1] is not None else arg[2] - given[name] = f"'{arg[3]}'" if arg[3] is not None else _lit(Decimal(arg[4])) - at = arg.end() - if not re.fullmatch(r"\s*\)\s*", s[at:]): - return None - return {"갈래": "단가산출", "키": head[1], "입력": given} + given = {k: f"'{v[1]}'" if v[0] == "str" else _lit(v[1]) for k, v in got[1]} + return {"갈래": "단가산출", "키": got[0], "입력": given} def _link_of(item: dict) -> tuple[dict | None, str]: @@ -466,6 +457,9 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: bare = imp.row_of({**sk, imp.KEY: {**meta, "단가기준": "엑셀"}}) or {} base = sd.line_ids(bare) src = dict(zip(base, meta["로직"].get("호표") or [])) + src |= { # 더한 형제 SK 줄 = 그 줄 스스로(연결 · 엑셀 값 없음) + cid: one for cid, one in zip(ids, row["호표"]) if cid.startswith("add:#") and one.get("참조") + } keep = _picks(row, ids, base, meta, master) doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름) _attach(doc, row, ids, src) diff --git a/M02_MasterTemplete/M02_San_ToDoc.py b/M02_MasterTemplete/M02_San_ToDoc.py index a4acf2a37..47b890d7a 100644 --- a/M02_MasterTemplete/M02_San_ToDoc.py +++ b/M02_MasterTemplete/M02_San_ToDoc.py @@ -3,7 +3,8 @@ 불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 `가져온.로직` 줄(+ SK 고침 · 고른 칸 중간)을 불러오기 자기 모듈에서 문서로 지음 — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · 옛 식 파서 (`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`). -가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · +가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · 사람이 더한 줄 = + 요소 키(인력 · 재료 · 기계 — 요소 연결 · M01 값) · 로직 부름(단가산출 연결) · 중간 = 식 줄(표시 = 반올림) · 고른 칸 중간(`연결` 든 줄) = 그 기호에 바로 연결 · 덧줄 = 금액 줄(단가 = 식) · `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 · 끝전 · 단계 · 조정 그대로. @@ -85,10 +86,30 @@ class _Reg: return self.ids.get(key, "?") +_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") +_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") +_CODE = re.compile(r"^(?:EQ|MT|LB)\d") # 요소 키가 아래첨자로 샌 것(804-7) +LINKED = "MP" # 품셈재료 — 줄 단위로 값이 갈림(`master_material.LINKED`) + + +def logic_call(text: Any) -> tuple[str, list[tuple[str, tuple]]] | None: + """「로직(GC…, 이름='값', 이름=수)」 → (키, [(이름, ('str' | 'num', 값))]) · 그 밖 꼴 = None.""" + s = str(text) + head = _HEAD.match(s) + if head is None: + return None + at, args = head.end(), [] + while arg := _ARG.match(s, at): + name = arg[1] if arg[1] is not None else arg[2] + args.append((name, ("str", arg[3]) if arg[3] is not None else ("num", Decimal(arg[4])))) + at = arg.end() + return (head[1], args) if re.fullmatch(r"\s*\)\s*", s[at:]) else None + + class _Doc: - def __init__(self, row: dict) -> None: - self.row, self.reg = row, _Reg() - self.links: dict[tuple, dict] = {} # 손 값 열쇠 → 변수 칸(이름 · 단위 · 연결) + def __init__(self, row: dict, master: Any = None) -> None: + self.row, self.reg, self.master = row, _Reg(), master + self.links: dict[tuple, dict] = {} # 값 변수 열쇠 → 변수 칸(이름 · 단위 · 연결) self.order: list[tuple] = [] self.kinds = {s["이름"]: "입력" for s in row.get("입력") or []} self.kinds |= {s["이름"]: "중간" for s in row.get("중간") or []} @@ -140,18 +161,62 @@ class _Doc: value: Any = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS} else: value = Decimal(str(item["단가"])) - key = ("손", at) + return self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value}) + + def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str: + """값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙.""" if key not in self.links: - self.reg.want(key, msym.lookup(f"{name}단가", "요소")) + sign, low, up = msym.lookup(label, "요소") + self.reg.want(key, (sign, self._low(link, low), up)) self.order.append(key) - self.links[key] = {"이름": f"{name}단가", "단위": "", "연결": {}} - self.links[key]["연결"] = {"갈래": "숫자", "값": value} + self.links[key] = {"이름": label, "단위": unit, "연결": link} + self.links[key]["연결"] = link return self.reg.id(key) + def _low(self, link: dict, low: str) -> str: + """요소 키가 아래첨자로 샌 것(`k_EQ0006`) → 자원 이름 끝 낱말.""" + if not _CODE.match(low or "") or link.get("갈래") != "요소": + return low + try: + row = self.master.get(str(link.get("키") or "")) + except Exception: # noqa: BLE001 — 없는 키 = 그대로 + return low + name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0] + words = [w for w in name.split() if not w[:1].isdigit()] + got = msym.short(words[-1]) if words else "" + return got if got and got != "·" else low + + def element(self, ref: str, unit: str | None, part: str = "") -> str: + """사람이 더한 요소 줄(인력 · 재료 · 기계 키) — 요소 연결(M01 값 · 품셈재료 = 줄 단위) · + 기계 = 시간당 기계경비 단가산출의 그 비목(가져온 기계 줄과 같은 짝 · 자료 없음 = 요소).""" + from M02_MasterTemplete.M02_Doc_Import import hourly_link # 서로 부름 — 늦게 + + link = {"갈래": "요소", "키": ref} | ({"단위": unit} if unit is not None else {}) + try: + label = self.master.label(ref) + except Exception: # noqa: BLE001 — 없는 키 = 셈이 끊김 표지 + label = ref + if ref[:2] == "EQ" and (hourly := hourly_link(ref, part)): + return self.var(("기계", ref, part), label, hourly) + return self.var(("요소", ref, unit), label, link) + + def logic(self, text: str) -> str | None: + """사람이 더한 로직 부름 줄 — 단가산출 연결(이름 · 결과단위 = M01 수식 문서 머리).""" + got = logic_call(text) + if got is None: + return None + from M02_MasterTemplete import M02_Doc_Copy as dc + + code, args = got + link = {"갈래": "단가산출", "키": code, "입력": {k: md.text_of(v) for k, v in args}} + head = dc.folder().get(code) or {} + label = str(head.get("이름") or code) + return self.var(("블록", text), label, link, str(head.get("결과단위") or "")) + def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]: """가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값.""" - c = _Doc(row) + c = _Doc(row, master) for kind in ("입력", "중간"): for spec in row.get(kind) or []: c.reg.want((kind, spec["이름"]), _merge(str(spec["이름"]), "", "")) @@ -250,9 +315,21 @@ def _money(c: _Doc, row: dict) -> list[dict]: except md.DocError as e: c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}") qty = str(item["수량"]) - price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음" - if line["비목"] != "묶음" and item.get("값묶음"): - price = f"{price}.계" + if item.get("값묶음") or item.get("단가") is not None: # 손 값(가져온 줄 · 고정 줄) + price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음" + if line["비목"] != "묶음" and item.get("값묶음"): + price = f"{price}.계" + elif item.get("종류") == "로직": + price = c.logic(str(item.get("요소") or "")) + if price is None: + raise ValueError(f"호표 「{name}」 로직 부름 꼴 아님 「{item.get('요소')}」") + line["비목"] = item.get("비목") or "묶음" + price = f"{price}.계" if "비목" in item else price + else: + ref = str(item["요소"]) + line["비목"] = item["비목"] + unit = str(item.get("단위") or "") if ref[:2] == LINKED else None + price = c.element(ref, unit, str(line["비목"])) line |= {"수량": qty, "단가": price} line |= {k: item[k] for k in LINE_KEYS if k in item} out.append(line) diff --git a/resources/tester/test_857_3a_import_adds.py b/resources/tester/test_857_3a_import_adds.py new file mode 100644 index 000000000..56ec2c674 --- /dev/null +++ b/resources/tester/test_857_3a_import_adds.py @@ -0,0 +1,129 @@ +"""857-3a 지킴 — 가져온 식 단가산출에 사람이 더한 줄(`더한줄`) 갈래마다 문서로 지어지고 셈됨. + +- 요소 줄(인력 · 재료 · 기계 키) = 요소 연결 · 금액 = 수량 × M01 값(두 판 같음). +- 손 단가 요소 줄 = 그 단가 · 고정 줄 = 줄 단가 · 로직 부름 = 그 단가산출 값. +- 형제 SK 부름 = 단가산출 연결 · 금액 = 수량 × 그 SK 값. +- 율 줄 = 옛 엔진 셈 은퇴(855 2-C1) — 못 셈 까닭이 남음. +""" + +from __future__ import annotations + +from decimal import Decimal + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Import as dim +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Doc as sd +from M02_MasterTemplete import M02_Sangeun_Imported as imp +from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층 + +MAN = "LB000002" # 보통인부 + + +def _whole(): + return m01.loaded()[1] + + +def _sk(adds: list | None = None, key: str = "SK-000001") -> dict: + row = { + "이름": "더한줄 sub8임시", + "결과단위": "원/식", + "호표": [ + {"종류": "인력", "이름": "작업반장", "단위": "인", "수량": "0.1"} + | {"비목": "노무비", "단가": 200000}, + { + "종류": "재료", + "이름": "모래", + "단위": "㎥", + "수량": "2", + "비목": "재료비", + "단가": 30000, + }, + ], + } + meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}}} + doc = {"키": key, "이름": "더한줄", "단위": "식", "바탕": None, imp.KEY: meta} + return sd.clean({**doc, "더한줄": adds or []}, None, _whole()) + + +def _total(sk: dict, basis: str = "엑셀") -> Decimal: + one = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": basis}} + got = dim.run(dim.derive(one, None, _whole()), one) + assert got["셈됨"], got.get("표지") + return Decimal(str(got["계"])) + + +def _m01(code: str, unit: str | None = None) -> Decimal: + import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둠 + + return Decimal(str(mm.element(_whole(), code, {}, unit)[0])) + + +BASE = Decimal(20000 + 60000) + + +def test_바탕_엑셀_값(): + assert _total(_sk()) == BASE + + +@pytest.mark.parametrize("basis", ["엑셀", "우리"]) +def test_인력_요소_줄_수량x_M01_노임(basis): + got = _total(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), basis) + assert got - BASE == pytest.approx(Decimal("0.5") * _m01(MAN), abs=1) + doc = dim.derive(_sk([{"종류": "인력", "요소": MAN, "수량": 0.5}]), None, _whole()) + var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == MAN) + assert var["연결"]["갈래"] == "요소" + + +def _first(head: str) -> str: + return next(iter(_whole().index[head])) + + +def test_재료_요소_줄_수량x_M01_값(): + code = _first("MT") + got = _total(_sk([{"종류": "재료", "요소": code, "수량": 3}])) + assert got - BASE == pytest.approx(3 * _m01(code), abs=1) + + +def test_기계_요소_줄_시간당_경비_그_비목(): + code = next(k for k in _whole().index["EQ"] if imp.hourly_of(k).get("ok")) + sk = _sk([{"종류": "기계", "요소": code, "수량": 2, "비목": "경비"}]) + var = next(v for v in dim.derive(sk, None, _whole())["변수"] if "기계" in str(v["연결"])) + assert var["연결"]["갈래"] == "단가산출" and var["연결"]["칸"] == "경비" + assert _total(sk) > BASE + + +def test_손_단가_요소_줄_그_단가(): + adds = [{"종류": "인력", "요소": MAN, "수량": 2, "단가": 1000}] + assert _total(_sk(adds)) == BASE + 2000 + + +def test_고정_줄_줄_단가(): + fixed = {"이름": "잡비 sub8임시", "단위": "식", "단가": {"노무비": 0, "재료비": 700, "경비": 0}} + assert _total(_sk([{"고정": fixed, "수량": 3}])) == BASE + 2100 + + +def test_로직_부름_줄_단가산출_값(): + code = "GC000206" + alone = _sk([{"종류": "로직", "로직": code, "입력값": {}, "수량": 1}]) + doc = dim.derive(alone, None, _whole()) + var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("키") == code) + assert var["연결"]["갈래"] == "단가산출" + assert _total(alone) > BASE + + +def test_형제_SK_부름_수량x_그_SK(world): # noqa: F811 — 같은 임시 층 fixture + with store.at(world["personal"]): + store.write("sangeun", "SK-000002", "", _sk(key="SK-000002")) + ref = {"층": MINE["층"], "주인": MINE["주인"], "키": "SK-000002"} + got = _total(_sk([{"참조": ref, "수량": 2}])) + assert got == BASE * 3 + + +def test_율_줄_못_셈_까닭(): + rate = {"이름": "공구손료", "단위": "%", "단가": {}, "비율": {"기준": "노무비", "비목": "경비"}} + sk = _sk([{"고정": rate, "수량": 3}]) + with pytest.raises(ValueError, match="율"): + dim.derive(sk, None, _whole()) From d2989c757020577fcad60a810523a1540d7f61ca Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:20:31 +0900 Subject: [PATCH 4/7] =?UTF-8?q?style(857-3a):=20Doc=5FImport=20ruff=20form?= =?UTF-8?q?at(=ED=98=95=EC=A0=9C=20SK=20=EB=8D=94=ED=95=9C=EC=A4=84=20?= =?UTF-8?q?=EC=A4=84=20=EB=B0=94=EA=BF=88=EB=A7=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index feab50912..f885b0117 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -458,7 +458,9 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: base = sd.line_ids(bare) src = dict(zip(base, meta["로직"].get("호표") or [])) src |= { # 더한 형제 SK 줄 = 그 줄 스스로(연결 · 엑셀 값 없음) - cid: one for cid, one in zip(ids, row["호표"]) if cid.startswith("add:#") and one.get("참조") + cid: one + for cid, one in zip(ids, row["호표"]) + if cid.startswith("add:#") and one.get("참조") } keep = _picks(row, ids, base, meta, master) doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름) From cb729416a31b1bf2ec3f8722e336100ad099f510 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:42:27 +0900 Subject: [PATCH 5/7] =?UTF-8?q?refactor(855-E=20L2a):=20M01=20=EB=A1=9C?= =?UTF-8?q?=EC=A7=81=20=EB=AA=A9=EB=A1=9D=20=C2=B7=20=ED=8C=8C=EC=9D=BC=20?= =?UTF-8?q?=C2=B7=20=EB=B6=84=EB=A5=98=20=C2=B7=20=EC=83=81=EC=84=B8=20?= =?UTF-8?q?=EC=9D=B4=EB=A6=84=ED=91=9C=20=C2=B7=20=EB=B3=84=EC=B9=AD?= =?UTF-8?q?=ED=8C=90=20=C2=B7=20=EC=A1=B0=ED=95=A9=20=EC=95=8C=EC=95=BD?= =?UTF-8?q?=EC=9D=84=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=EC=97=90?= =?UTF-8?q?=EC=84=9C=20=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 관문 `M01_MasterData_Doc.logic_files` — 수식 문서 파일을 옛 로직 파일 이름으로(머리 원문 · 부문 · 차례 · 줄 = 문서) · docs() 도 같은 읽기 - /logics · /groups/로직/files · /subs?group=로직 · /elements?group=로직 · /logic 이름표 · 목록 덧칸(인재경 = 문서 금액 줄 · 작업량 = 문서 결과) · /alias 로직 줄 · 조합 알약 · 담은 로직 요약 = 문서 - 남김(쓰기 짝 · L3) — /logic 셈 칸 · prices(옛 상세 몸) · 파일 판(해) · version(저장 409) - 쓰기 마무리 — 더한 로직 줄은 문서부터(Doc.ensure · 못 지으면 빈 문서 + 머리) · 새 문서 파일 머리 = 짝 로직 파일 머리 · sync_tags 가 이름 · 결과단위 · 출처 · 부품도 같게 - 서버 답 전후 243 건 다름 0 · 조합 알약 1,558 건 다름 0 - 시험 6 파일: 마스터만 임시 사본으로 바꾸던 준비에 수식 문서 사본도(목록이 문서에서 읽으므로 사본 저장이 보이게) · test_m01_cache 한 시험의 겹친 사본 걷음 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Alias.py | 7 +- M01_MasterData/M01_MasterData_Doc.py | 121 ++++++++++++++++--- M01_MasterData/M01_MasterData_Store.py | 60 +++++---- M01_MasterData/M01_MasterData_Store_Combo.py | 5 +- M01_MasterData/M01_MasterData_Store_List.py | 30 +++-- M01_MasterData/M01_MasterData_Store_Make.py | 9 +- resources/tester/test_208_1_logic_alias.py | 2 + resources/tester/test_713_1_revise.py | 2 + resources/tester/test_794_1b_flow_gone.py | 2 + resources/tester/test_m01_api.py | 2 + resources/tester/test_m01_cache.py | 6 +- resources/tester/test_m01_copy.py | 2 + 12 files changed, 184 insertions(+), 64 deletions(-) diff --git a/M01_MasterData/M01_MasterData_Alias.py b/M01_MasterData/M01_MasterData_Alias.py index f474c0db4..69c2514e8 100644 --- a/M01_MasterData/M01_MasterData_Alias.py +++ b/M01_MasterData/M01_MasterData_Alias.py @@ -109,8 +109,11 @@ def board() -> dict[str, Any]: (str(v.get("키")), ma.norm(v.get(ALIAS))) for v in book.values() if v.get("상태") == "승인" } rows = [] - loaded, _ = store.loaded() - for file, data in loaded.items(): + logic = ( + store._docs().logic_files() + ) # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ) · 파일 차례는 그대로 + for file, data in store.loaded()[0].items(): + data = logic.get(file, {}) if data.get("그룹") == "로직" else data kind = kind_of(file, str(data.get("그룹") or "")) for row in data.get("줄") or []: if not str(row.get(ALIAS) or "").strip(): diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index b9310e1e8..1b7c086fd 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -63,14 +63,56 @@ def _stamp() -> tuple: return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json"))) -def docs() -> dict[str, dict]: - """저장 문서 전부 {키: 문서} — 파일 시각이 같으면 다시 안 읽음.""" +def logic_files() -> dict[str, dict]: + """로직 그룹 관문(855 L2 ⓐ) — 수식 문서 파일을 옛 로직 파일 이름으로 + {로직 파일: {그룹 로직 · 원문 · 부문 · 차례 · 줄 = 문서}} · 파일 시각이 같으면 다시 안 읽음(읽기 전용).""" stamp = (str(folder()), _stamp()) if _memo.get("stamp") != stamp: - _memo.update(stamp=stamp, docs=ml.load_all(folder())) + files = {} + for path in sorted(folder().glob("수식_*.json")): + data = ml.load_file(path) + name = data.get("로직파일") or "로직_" + path.name.split("_", 1)[1] + head = {k: data[k] for k in md.FILE_TAGS if k in data} + files[name] = {"그룹": "로직", **head, "줄": data.get("줄") or []} + every = {str(d.get("키")): d for f in files.values() for d in f["줄"]} + _memo.update(stamp=stamp, files=files, docs=every) + return _memo["files"] + + +def docs() -> dict[str, dict]: + """저장 문서 전부 {키: 문서} — 파일 시각이 같으면 다시 안 읽음.""" + logic_files() return _memo["docs"] +#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) — 로직 줄 고침도 같게(`sync_tags`) +HEAD = ("이름", "결과단위", "출처", "부품") + + +def head_of(doc: dict) -> dict: + """문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 로직 목록 · 상세의 이름표 정본.""" + return {k: doc[k] for k in ("키", *md.TAGS, *HEAD) if k in doc} + + +def find(key: str) -> tuple[str, dict]: + """(옛 로직 파일 이름, 문서) — 없는 키 = 404.""" + for name, data in logic_files().items(): + for doc in data["줄"]: + if str(doc.get("키")) == key: + return name, doc + raise store.StoreError(404, f"없는 로직 「{key}」") + + +def head(ref: str) -> dict: + """`Master.logic` 과 같은 거름 · 같은 까닭 글 — 로직 키 → 문서 머리(조합 알약 · 담은 로직 요약).""" + if store.mk.GROUP_OF.get(store.mk.id_of(ref)) != "로직": + raise store.cm.mf.FormulaError(f"로직 아님 「{ref}」") + doc = docs().get(ref) + if doc is None: + raise store.cm.mf.FormulaError(f"없는 요소 「{ref}」") + return head_of(doc) + + def _dec(doc) -> dict: """화면 JSON(float) → Decimal 문서 — 저장 문서와 같은 수 꼴로 셈.""" return json.loads(json.dumps(doc, ensure_ascii=False), parse_float=Decimal, parse_int=Decimal) @@ -112,8 +154,10 @@ def _check(doc) -> dict: def read(key: str) -> dict: found = docs().get(key) fresh = found is None - if fresh: - row = store.logic(key)["logic"] # 없는 키 = 404 + if fresh: # 로직 줄은 있고 문서가 없는 키(옛 자료 받침 — 새 로직은 `ensure` 가 문서를 둠) + row = _row(key) + if row is None: + raise store.StoreError(404, f"없는 로직 「{key}」") found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) out = _run(found) up = None if fresh else built(key) @@ -127,14 +171,24 @@ def preview(doc: dict, given: dict | None = None) -> dict: def _file_for(key: str) -> str: - """문서 파일 — 있던 파일 › 로직 파일 짝 › 자체.""" + """문서 파일 — 있던 파일 › 로직 줄이 든 로직 파일 짝(쓰기 짝 · L3 에서 걷음) › 자체.""" have = _where(key) if have: return have - try: - return ml.file_of(store.logic(key)["file"]) - except store.StoreError: - return OWN_FILE + for name, data in store.loaded()[0].items(): + if data.get("그룹") == "로직" and any( + str(r.get("키")) == key for r in data.get("줄") or [] + ): + return ml.file_of(name) + return OWN_FILE + + +def _new_file(name: str) -> dict: + """새 문서 파일 머리 — 짝 로직 파일의 이름 · 머리(원문 · 부문 · 차례)를 그대로(목록 분류 정본).""" + logic = "로직_" + name.split("_", 1)[1] + head = store.loaded()[0].get(logic) or {} + tags = {k: head[k] for k in md.FILE_TAGS if k in head} + return {"그룹": "수식문서", "로직파일": logic if head else "", **tags, "줄": []} def _row(key: str) -> dict | None: @@ -160,14 +214,49 @@ def sync_tags(keys) -> int: rows = data.get("줄") or [] for at, doc in enumerate(rows): row = want.get(str(doc.get("키"))) - if row is not None and md.tags_of(doc) != md.tags_of(row): - rows[at], hit = md.tag(doc, row), True + if row is not None and _headed(doc, row) != doc: + rows[at], hit = _headed(doc, row), True n += 1 if hit: put(path, data) return n +def _headed(doc: dict, row: dict) -> dict: + """문서 머리를 로직 줄 것과 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 줄에 없는 칸은 뺌).""" + out = md.tag(doc, row) + for k in HEAD: + if k in row: + out[k] = row[k] + else: + out.pop(k, None) + return out + + +def ensure(key: str) -> bool: + """새 로직 줄의 수식 문서 — 빌더와 같은 문서(`make`) · 못 지으면 빈 문서 + 머리(목록이 문서에서 읽으므로 + 문서 없는 로직 0 · 열면 빈 문서는 그대로) · 지어 넣었거나 이미 있음 = True.""" + if make(key): + return True + row = _row(key) + if row is None: + return False + blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) + blank = { + **dict(list(blank.items())[:5]), + "출처": row.get("출처"), + **dict(list(blank.items())[5:]), + } + with _LOCK: + if key in docs(): + return True + path = folder() / _file_for(key) + data = ml.load_file(path) if path.exists() else _new_file(path.name) + data.setdefault("줄", []).append(_headed(blank, row)) + put(path, data) + return False + + def built(key: str) -> dict | None: """빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None.""" for data in store.loaded()[0].values(): @@ -225,9 +314,7 @@ def make(key: str) -> bool: ): return False path = folder() / _file_for(key) - data = ( - ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} - ) + data = ml.load_file(path) if path.exists() else _new_file(path.name) data.setdefault("줄", []).append(doc) put(path, data) return True @@ -263,9 +350,7 @@ def save(doc: dict, 판: str | None = None) -> dict: doc = layered(doc, key) name = _file_for(key) path = folder() / name - data = ( - ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} - ) + data = ml.load_file(path) if path.exists() else _new_file(path.name) rows = data.setdefault("줄", []) at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) if 판 is not None and version_of(None if at is None else rows[at]) != 판: diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index ae828d019..0324711a8 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -110,23 +110,32 @@ def chapter_order(data: dict) -> int: return data.get("차례") or 9999 +def _docs(): + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 부름 — 늦게 + + return doc_store + + def files_of(group: str) -> list[dict]: + """로직 = 수식 문서 파일(855 L2 ⓐ) · 판(해) · version 은 로직 파일(저장 409 짝 · L3 에서 문서로).""" if group not in cm.mf.GROUPS: raise StoreError(404, f"없는 그룹 「{group}」") + logic = _docs().logic_files() if group == "로직" else None out = [] - for name in cm.mmf.names(FOLDER): + for name in sorted(logic) if logic is not None else cm.mmf.names(FOLDER): if name != f"{group}.json" and not name.startswith(f"{group}_"): continue data, version = read(name) + head = data if logic is None else logic[name] out.append( { "file": name, - "book": _book(data), - "chapter": chapter_of(name, data), + "book": _book(head), + "chapter": chapter_of(name, head), "edition": data.get("판"), - "rows": len(data.get(items_key(data)) or []), + "rows": len(head.get(items_key(head)) or []), "version": version, - "order": chapter_order(data), + "order": chapter_order(head), } ) return sorted(out, key=lambda f: (f["order"], f["file"])) @@ -173,7 +182,7 @@ def subs(file: str = "", group: str = "") -> dict: name = mk.CHAPTER.match(info["file"]) if not name: continue - data = read(info["file"])[0] + data = _docs().logic_files()[info["file"]] if group == "로직" else read(info["file"])[0] kind = " ".join(x for x in (data.get("원문"), data.get("부문")) if x) slot = found.setdefault(kind, {"name": kind, "book": data.get("원문"), "details": []}) slot["details"].append(mk.detail_of(info["file"])) @@ -335,6 +344,7 @@ def table(file: str, key: str) -> dict: def _logic_files(files: dict[str, dict]): + """로직 파일 줄(옛 엔진 시험 셈 `_swap` 몫 · L3 에서 걷음).""" for name, data in files.items(): if data.get("그룹") == "로직": yield name, data @@ -342,11 +352,10 @@ def _logic_files(files: dict[str, dict]): def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "") -> list[dict]: """로직 목록 — 구분 · 상세구분 · 소유 · 찾기로 거름(장 차례대로 · 파일을 가로지름). - 막힘은 미리 세어 둔 값(`blocks`) — 목록에서 줄마다 검사를 돌리지 않음.""" - files, _ = loaded() + 줄 = 수식 문서 머리(855 L2 ⓐ) · 막힘은 미리 세어 둔 값(`blocks`) — 목록에서 줄마다 검사를 돌리지 않음.""" why_of = blocks() out = [] - for name, data in sorted(_logic_files(files), key=lambda f: chapter_order(f[1])): + for name, data in sorted(_docs().logic_files().items(), key=lambda f: chapter_order(f[1])): for row in data.get("줄") or []: if (sub and row.get("구분") != sub) or (detail and row.get("상세구분") != detail): continue @@ -382,22 +391,22 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "") def logic(key: str) -> dict: - """로직 하나 — 키는 전체에서 하나.""" + """로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · 셈 칸(입력 · 호표 …) + · `prices` · `version` = 로직 파일(옛 상세 몸 · 저장 짝 — 856 · L3 에서 걷음).""" files, whole = loaded() - for name, data in _logic_files(files): - for row in data.get("줄") or []: - if str(row.get("키")) == key: - reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3) - _, version = read(name) - return { - "file": name, - "version": version, - "logic": row, - "blocked": bool(reasons), - "reasons": reasons, - "prices": _prices(whole, row), - } - raise StoreError(404, f"없는 로직 「{key}」") + name, doc = _docs().find(key) + row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {}) + head, named = _docs().head_of(doc), (*_docs().md.TAGS, *_docs().HEAD) + row = {k: head.get(k, v) for k, v in row.items() if k in head or k not in named} | head + reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3) + return { + "file": name, + "version": read(name)[1], + "logic": row, + "blocked": bool(reasons), + "reasons": reasons, + "prices": _prices(whole, row), + } def _brief(ref: str, row: dict) -> dict: @@ -451,7 +460,8 @@ def elements(group: str, q: str, limit: int) -> dict: if group not in cm.mf.GROUPS: raise StoreError(404, f"없는 그룹 「{group}」") hits = [] - for name, data in loaded()[0].items(): + every = _docs().logic_files() if group == "로직" else loaded()[0] # 로직 = 수식 문서(855 L2 ⓐ) + for name, data in every.items(): if data.get("그룹") != group: continue for row in data.get(items_key(data)) or []: diff --git a/M01_MasterData/M01_MasterData_Store_Combo.py b/M01_MasterData/M01_MasterData_Store_Combo.py index 11ac9774f..7145c0b70 100644 --- a/M01_MasterData/M01_MasterData_Store_Combo.py +++ b/M01_MasterData/M01_MasterData_Store_Combo.py @@ -100,7 +100,7 @@ def _brief(whole, row: dict) -> list[dict]: key = str(one.get("로직") or "") if isinstance(one, dict) else "" head = {"차례": at, "로직": key, "메모": one.get("메모") if isinstance(one, dict) else None} try: - got = whole.logic(key) + got = store._docs().head(key) # 수식 문서 머리(855 L2 ⓐ) except cm.mf.FormulaError as e: out.append({**head, "ok": False, "까닭": str(e)}) continue @@ -173,12 +173,11 @@ def combo_inputs(key: str) -> dict: def combo_pills(row: dict) -> dict: """조합 줄 하나(어느 층이든 · M02 조합 층 저장소가 부름)의 알약 — 규칙은 `combo_inputs`.""" - whole = store.loaded()[1] pills: dict[tuple[str, str], dict] = {} for one in mcb.items(row): code = str(one.get("로직") or "") if isinstance(one, dict) else "" try: - got = whole.logic(code) + got = store._docs().head(code) # 수식 문서 머리(855 L2 ⓐ) except cm.mf.FormulaError: continue per = mu.per(got.get("결과단위")) # 결과단위 배 읽기 한 벌(712-2) diff --git a/M01_MasterData/M01_MasterData_Store_List.py b/M01_MasterData/M01_MasterData_Store_List.py index fdcc738e0..093a8470f 100644 --- a/M01_MasterData/M01_MasterData_Store_List.py +++ b/M01_MasterData/M01_MasterData_Store_List.py @@ -5,7 +5,9 @@ - `작업량` = 돈 아닌 로직(`결과` 칸) · `부모` = 그 작업량을 부르는 로직(목록에서 그 밑으로 접음). - `부르는수` · `불리는수` = 로직끼리 부르기(기계경비 포함 · `Store_Cache.counted`). - `관련` = 비고 글의 절 번호(「1-5-6(주③)」 · 「별도」 참조)가 가리키는 로직 — 계산 밖 링크. -- `인재경` = 호표 · 덧줄 줄 수 `{인력, 재료, 경비, 하위}`(712-1 `master_bundle.bundle` 한 벌). +- `인재경` = 수식 문서 금액 줄 수 `{인력, 재료, 경비, 하위}` — 비목(`master_bundle.BY_ITEM`) · + 「묶음」 줄은 단가가 부르는 문서가 기계경비(`is_machine`)면 경비 · 아니면 하위(옛 호표 · 덧줄 셈과 1,521 같음). +줄 = 수식 문서(855 L2 ⓐ · `M01_MasterData_Doc.logic_files`). """ from __future__ import annotations @@ -45,20 +47,26 @@ def _related(row: dict, book: tuple[str, str], by_section: dict) -> list[str]: return list(out) -def _bundles(whole, row: dict) -> dict[str, int]: - got = Counter(mbd.bundle(whole, x)[0] for x in [*row.get("호표", []), *row.get("덧줄", [])]) +def _bundles(doc: dict, docs: dict[str, dict]) -> dict[str, int]: + got: Counter = Counter() + links = {} + for v in doc.get("변수") or []: + for k in ("열쇠", "기호", "이름"): + links.setdefault(v.get(k), v.get("연결") or {}) + for line in doc.get("금액") or []: + if line.get("비목") in mbd.BY_ITEM: + got[mbd.BY_ITEM[line["비목"]]] += 1 + continue + called = docs.get(str((links.get(str(line.get("단가") or "")) or {}).get("키") or "")) + got["경비" if mbd.is_machine(called) else "하위"] += 1 return {name: got.get(name, 0) for name in mbd.BUNDLES} def extras() -> dict[str, dict]: """로직 키 → 덧칸 — 목록 전체로 셈(거른 목록이어도 묶음 수 · 부르는 수는 전체 기준).""" - files, whole = store.loaded() - rows = [ - (name, data, row) - for name, data in files.items() - if data.get("그룹") == "로직" - for row in data.get("줄") or [] - ] + docs = store._docs() + every = docs.docs() + rows = [(name, data, row) for name, data in docs.logic_files().items() for row in data["줄"]] calls = {key: got[1] for key, got in cache.counted(store.FOLDER).items()} called = Counter(k for got in calls.values() for k in got) parents: dict[str, list[str]] = defaultdict(list) @@ -86,7 +94,7 @@ def extras() -> dict[str, dict]: "부르는수": len(calls.get(key, ())), "불리는수": called.get(key, 0), "관련": _related(row, _book(data), by_section), - "인재경": _bundles(whole, row), + "인재경": _bundles(row, every), } return out diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index cc2df9cfa..5f1dec18d 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -267,9 +267,14 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: def _sync_tags(batch: list[dict], added: list[dict]) -> None: - """고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게).""" + """고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게) · + 더한 로직 줄은 문서부터 둠(`Doc.ensure` — 목록이 문서에서 읽음 · 855 L2 ⓐ).""" from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 + files = store.loaded()[0] + for a in added: + if (files.get(a["file"]) or {}).get("그룹") == "로직": + doc_store.ensure(a["key"]) keys = {a["key"] for a in added} | { str(c.get("key")) for p in batch @@ -375,7 +380,7 @@ def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict: before = set(_keys()) done = _write([{"op": "add", "row": _clean(logic, owner)}]) key = next((k for k in reversed(_keys()) if k not in before), "") - made = doc_store.make(key) if key else False + made = doc_store.ensure(key) if key else False return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made} diff --git a/resources/tester/test_208_1_logic_alias.py b/resources/tester/test_208_1_logic_alias.py index dbc235399..47f022a47 100644 --- a/resources/tester/test_208_1_logic_alias.py +++ b/resources/tester/test_208_1_logic_alias.py @@ -101,6 +101,8 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: shutil.copy(path, tmp_path / path.name) shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) monkeypatch.setattr(store, "FOLDER", tmp_path) + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서") app = FastAPI() app.include_router(router_module.router) return TestClient(app) diff --git a/resources/tester/test_713_1_revise.py b/resources/tester/test_713_1_revise.py index bac3deeed..837b0b9fd 100644 --- a/resources/tester/test_713_1_revise.py +++ b/resources/tester/test_713_1_revise.py @@ -28,6 +28,8 @@ def client(tmp_path_factory) -> TestClient: shutil.copytree(REAL / "기계", folder / "기계") # 기계 = 폴더(826-2) patch = pytest.MonkeyPatch() patch.setattr(store, "FOLDER", folder) + shutil.copytree(REAL / "수식문서", folder / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + patch.setattr(store._docs().ml, "FOLDER", folder / "수식문서") app = FastAPI() app.include_router(router_module.router) yield TestClient(app) diff --git a/resources/tester/test_794_1b_flow_gone.py b/resources/tester/test_794_1b_flow_gone.py index 8aa8515c8..7a038a109 100644 --- a/resources/tester/test_794_1b_flow_gone.py +++ b/resources/tester/test_794_1b_flow_gone.py @@ -31,6 +31,8 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: shutil.copy(path, master / path.name) shutil.copytree(REAL / "기계", master / "기계") # 기계 = 폴더(826-2) monkeypatch.setattr(store, "FOLDER", master) + shutil.copytree(REAL / "수식문서", master / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + monkeypatch.setattr(store._docs().ml, "FOLDER", master / "수식문서") app = FastAPI() app.include_router(m01_router.router) app.include_router(df.router) diff --git a/resources/tester/test_m01_api.py b/resources/tester/test_m01_api.py index b8f38cfdc..b08113d5e 100644 --- a/resources/tester/test_m01_api.py +++ b/resources/tester/test_m01_api.py @@ -47,6 +47,8 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: shutil.copy(path, tmp_path / path.name) shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) monkeypatch.setattr(store, "FOLDER", tmp_path) + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서") app = FastAPI() app.include_router(router_module.router) return TestClient(app) diff --git a/resources/tester/test_m01_cache.py b/resources/tester/test_m01_cache.py index 22887f2a0..6c4501158 100644 --- a/resources/tester/test_m01_cache.py +++ b/resources/tester/test_m01_cache.py @@ -33,6 +33,8 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: shutil.copy(path, tmp_path / path.name) shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) monkeypatch.setattr(store, "FOLDER", tmp_path) + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서") app = FastAPI() app.include_router(router_module.router) return TestClient(app) @@ -114,9 +116,7 @@ def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다( 다른 파일의 부르는 줄도 다시 세어 막힘.""" from M01_MasterData import M01_MasterData_Doc as doc_store - docs = tmp_path / "수식문서" - shutil.copytree(REAL / "수식문서", docs) - monkeypatch.setattr(doc_store.ml, "FOLDER", docs) + docs = tmp_path / "수식문서" # 사본 = 준비(`client`)가 둠 doc_store._memo.clear() assert [x for x in _logics(client) if x["키"] == CALLER][0]["blocked"] is False diff --git a/resources/tester/test_m01_copy.py b/resources/tester/test_m01_copy.py index fdb47e085..4729f3a42 100644 --- a/resources/tester/test_m01_copy.py +++ b/resources/tester/test_m01_copy.py @@ -37,6 +37,8 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: shutil.copy(path, tmp_path / path.name) shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) monkeypatch.setattr(store, "FOLDER", tmp_path) + shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) + monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서") app = FastAPI() app.include_router(router_module.router) return TestClient(app) From 5ec6443873a4e1583201385566785bf344418095 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 01:59:08 +0900 Subject: [PATCH 6/7] =?UTF-8?q?fix(856-F):=20=EC=A4=84=20=EC=8C=93?= =?UTF-8?q?=EA=B8=B0=20[+=20=EC=A4=84]=20=EC=9E=AC=EB=A3=8C=20=EC=B0=BE?= =?UTF-8?q?=EC=95=84=20=EB=84=A3=EA=B8=B0=20=EB=B9=88=20=EB=AA=A9=EB=A1=9D?= =?UTF-8?q?=20=E2=80=94=20=EB=B9=88=20=EB=82=B1=EB=A7=90=EB=8F=84=20?= =?UTF-8?q?=EC=84=9C=EB=B2=84=20=EC=9E=AC=EB=A3=8C=20=EC=B0=BE=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 까닭: 찾아 넣기 창이 재료만 낱말 있을 때 서버를 부름(721-2 처음부터 · 걸음 3 주입과 무관) → 빈 검색어로 연 줄 쌓기 재료 창 「찾은 로직 없음」 - 고침: 인력과 같이 빈 낱말 = 앞 200 줄(서버 상한 그대로 · 0.3 초) - 화면: M01 단가산출 기초 · M02 보통 · 불러온 단가산출 · 일위대가 [항목 추가] 네 군데 재료 200 줄 · 불러온 SK 재료 줄 더함 5,323 → 8,323 원 저장 · 다시 열기 같음 - 시험: test_856_0_sk_screen ⑤ 찾아 넣기 종류마다 부른 주소 · 그린 줄(M01 · M02) Co-Authored-By: Claude Opus 5.5 --- .../M02_MasterTemplete_Find_Pick.ts | 4 +- resources/tester/helper_856_0_sk_screen.cjs | 37 +++++++++++++++++++ resources/tester/test_856_0_sk_screen.py | 17 +++++++++ 3 files changed, 56 insertions(+), 2 deletions(-) diff --git a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts index 70a6874b3..0965708ec 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts @@ -363,7 +363,7 @@ export function openFindPicker(opt: FindPickOptions): void { table.setRows(shown.map(({ go: _go, dim: _dim, ...row }) => row)); } - /** 인력 · 재료 = 서버 찾기(친 낱말) — 재료는 낱말 있을 때만 · 늦게 온 답은 버림 */ + /** 인력 · 재료 = 서버 찾기(친 낱말 · 빈 낱말 = 앞 200 줄) · 늦게 온 답은 버림 */ async function findElements(): Promise { const mine = ++seq; const q = search.input.value.trim(); @@ -383,7 +383,7 @@ export function openFindPicker(opt: FindPickOptions): void { try { const [p, g, m, o] = await Promise.all([ ok("labor") ? get("job") : Promise.resolve([]), - q && ok("material") ? get("price") : Promise.resolve([]), + ok("material") ? get("price") : Promise.resolve([]), // 856-F 빈 낱말도(상한 200 · 인력과 같이) opt.machine && ok("machine") ? getMachine() : Promise.resolve([]), opt.oil && ok("oil") ? getOil() : Promise.resolve([]), ]); diff --git a/resources/tester/helper_856_0_sk_screen.cjs b/resources/tester/helper_856_0_sk_screen.cjs index 17feca269..85ff67f65 100644 --- a/resources/tester/helper_856_0_sk_screen.cjs +++ b/resources/tester/helper_856_0_sk_screen.cjs @@ -162,6 +162,8 @@ const api = { call: async (p, init) => { calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null }); if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] }; + if (p.includes("/logic-lib/")) + return { items: [{ ref: "X1", 이름: "견본", 단위: "EA", 값: 1 }] }; // 찾아 넣기(⑤) return {}; }, readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }), @@ -205,7 +207,18 @@ const stubs = { M02_MasterTemplete_Labor_Text: { tc: (k) => k }, M02_MasterTemplete_Labor_LibMeta: { libMeta: () => [] }, M02_MasterTemplete_Labor_National: { nationalRows: () => [] }, + // ⑤ 찾아 넣기 창 — 표 = 그린 줄 수 · 탭 · 찾기 맞춤 · 위 층 서고 + ui_template_data_table: { + createDataTable: () => ({ root: box("table"), setRows: (r) => (picked.rows = r.length) }), + }, + ui_template_tabs: { createTabs: () => ({ root: box("div"), setBadge() {} }) }, + ui_template_logic_find: { matchLogic: () => ({ ok: true }), aliasNote: () => "" }, + M02_MasterTemplete_Sangeun_Pick: { + SANGEUN_KIND: "sangeun", + listLayerDocs: async () => [{ ref: { 층: "system", 주인: null, 키: "SK-9" }, 이름: "s" }], + }, }; +const picked = { rows: 0 }; const real = new Set([ "M02_MasterTemplete_Sangeun_Detail", "M02_MasterTemplete_Sangeun_Tabs", @@ -221,6 +234,8 @@ const real = new Set([ "M02_MasterTemplete_Labor_RowSk", "M02_MasterTemplete_Labor_Api", "M02_MasterTemplete_Labor_Calc", + "M02_MasterTemplete_Find_Pick", + "line_stack_pick", ]); const empty = () => @@ -423,6 +438,28 @@ async function openSk(doc, opt = {}) { stack, }); out.m01 = host.children.map((n) => n.tagName + (n.dataset.stack !== undefined ? ":stack" : "")); + + // ⑤ 줄 쌓기 [+ 줄] 찾아 넣기(856-F) — 빈 낱말로 연 창 · 종류마다 부른 주소 · 그린 줄 수(M01 · M02) + const { openStackPick } = M("A00_Common/line_stack_pick.ts"); + const { openFindPicker } = M("M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts"); + const fetch0 = globalThis.fetch; + globalThis.fetch = async () => ({ + ok: true, + json: async () => ({ logics: [{ 키: "GC1", 이름: "기초", 결과단위: "원/㎡" }], 줄: [] }), + }); + out.find = {}; + for (const m02 of [null, { layer: "system", owner: null, me: "SK-1", take() {} }]) + for (const kind of ["인력", "재료", "기계", "단가산출"]) { + calls.length = 0; + picked.rows = 0; + openStackPick(openFindPicker, kind, () => {}, m02 ?? undefined); + await settle(); + out.find[`${m02 ? "m02" : "m01"}_${kind}`] = { + paths: calls.map((c) => c.path.replace("/logic-lib/", "").replace(/&.*/, "")), + rows: picked.rows, + }; + } + globalThis.fetch = fetch0; console.log(JSON.stringify(out)); })().catch((e) => { console.error(e.stack || String(e)); diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py index 3ad647446..1287c9e5d 100644 --- a/resources/tester/test_856_0_sk_screen.py +++ b/resources/tester/test_856_0_sk_screen.py @@ -5,6 +5,7 @@ ② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄 ③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음) ④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기 +⑤ 줄 쌓기 [+ 줄] 찾아 넣기 — 빈 낱말로 열어도 종류마다 서버 찾기 · 목록이 그려짐(856-F) """ from __future__ import annotations @@ -83,3 +84,19 @@ def test_head_bands() -> None: def test_m01_logic_detail_shape() -> None: # 기본정보 접힘 · 막힘 까닭 · 줄 쌓기 — 단가산출 상세 몸 칸 없음 assert _run()["m01"] == ["DETAILS", "DIV", "DIV:stack"] + + +def test_stack_find_lists_each_kind() -> None: + # 856-F — 빈 낱말 재료도 서버 찾기(전엔 낱말 있을 때만 → 빈 목록) · M01 · M02 줄 쌓기 같음 + find = _run()["find"] + want = { + "인력": ["pick?kind=job"], + "재료": ["pick?kind=price"], + "기계": ["elements?group=%EA%B8%B0%EA%B3%84"], + "단가산출": [], # 로직 목록 = 일위대가 길(`/m02/logic-lib/logics`) + } + for side in ("m01", "m02"): + for kind, paths in want.items(): + got = find[f"{side}_{kind}"] + assert got["paths"] == paths, (side, kind, got) + assert got["rows"] >= 1, (side, kind, got) From d254b4b555325a5b5c329709d37f127b1e9db2fd Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 02:01:29 +0900 Subject: [PATCH 7/7] =?UTF-8?q?refactor(855-F=20B9-3):=20B09=20=EC=82=B0?= =?UTF-8?q?=EA=B7=BC=20=C2=B7=20=EB=8C=80=EA=B0=80=20=C2=B7=20=EC=88=98?= =?UTF-8?q?=EC=9A=94=20=ED=82=A4=EA=B0=80=20=EC=98=9B=20=EC=97=94=EC=A7=84?= =?UTF-8?q?=20=EB=8C=80=EC=8B=A0=20=EB=AC=B8=EC=84=9C=20=EC=85=88=20?= =?UTF-8?q?=EB=8B=B5=20+=20=EC=85=88=20=EA=B8=B0=EB=A1=9D=EC=9D=84=20?= =?UTF-8?q?=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 B09_Estimation_Doc_Run — 사본 수식 문서를 M02 와 같은 계산기로 셈 → 줄마다 수량 · 단가 · 비목 · 자원 키 · 품목 · 하위 부름 · % 율 · 끝수 - Sangeun 풀이(_solve · _line · _logic_line · _extras · call_of · line_calls · hand_resource_keys) · Labor_Source._poomsem · Linked.used_keys = 문서 셈 답 · 기록 - Sangeun_Sum doc_* = 답 끝수 · 합밖(새 계산기 cut · _settle) · 옛 함수와 _env · _captured 는 산출근거 글 몫(B9-4) - Labor_Rule 식 꼴 읽기 = 새 계산기 파서 · 작업량 Q ROUND 2 · 빈 입력 멈춤 · 굳은 기계 단가 기계 키 살림 - master_doc_trace 감싼 색인 메서드 찾기 한 줄(굳힌 단가산출 대가 블록) - test_855_trace 옛 하위 부름 기준 = helper_855_engine.old_line_calls(옛 함수 옮김) - 골든 855_b09 다시 뜸 7 갈래 — 기계 시간당 단가 = M02 문서 셈 값(옛 = 엔진 날 값 · 줄 0.1 원 · 합 1 원 다를 수 있음) · 수요 키에서 재료 고르기 후보 빠짐 · 글 · 나머지 8 갈래 같음 - 옛 엔진 부름 B09(글 뺌) 19 → 6 · 719-1 · 719-2 실패 5 는 옛 칸 SK 견본(B9-5 몫 · 고치기 전에도 같음) Co-Authored-By: Claude Opus 5.5 --- B09_Estimation/B09_Estimation_Doc_Run.py | 267 ++++++++++++++++++ B09_Estimation/B09_Estimation_Labor_Rule.py | 18 +- B09_Estimation/B09_Estimation_Labor_Source.py | 25 +- B09_Estimation/B09_Estimation_Linked.py | 25 +- B09_Estimation/B09_Estimation_Sangeun.py | 238 ++++++++-------- B09_Estimation/B09_Estimation_Sangeun_Sum.py | 53 +++- .../master_data/scripts/master_doc_trace.py | 10 +- resources/tester/golden_855_b09.json | 14 +- resources/tester/helper_855_engine.py | 31 ++ resources/tester/test_855_trace.py | 4 +- 10 files changed, 529 insertions(+), 156 deletions(-) create mode 100644 B09_Estimation/B09_Estimation_Doc_Run.py diff --git a/B09_Estimation/B09_Estimation_Doc_Run.py b/B09_Estimation/B09_Estimation_Doc_Run.py new file mode 100644 index 000000000..c18511b22 --- /dev/null +++ b/B09_Estimation/B09_Estimation_Doc_Run.py @@ -0,0 +1,267 @@ +"""B09 산근 · 대가 풀이의 셈 한 벌 — 수식 문서 셈 답 + 셈 기록(PLAN 855-F B9-3) · 서버 단독(짝 없음). + +M02 와 같은 계산기(`master_doc_calc` · 기록 `master_doc_trace`)로 사본 문서(`수식.json` · 없는 키 = +그 자리 닫힌 묶음 · `M02_Item_Prices.line` 같은 길 · 줄 규칙 `line_doc`)를 셈 → B09 가 읽는 꼴: + 줄 = 금액 줄마다 {이름, 단위, 수량, 단가, 비목(날 값 = 수량 × 단가 · 끝수 전), 금액(날 합), 까닭, + 합밖, 키(노임 · 자재 · 기계 자원 키), 품목(고른 재료 줄), 부름(하위 산근 {code, given} | + 기계경비 {machine})} + `pct(n)` = % 줄 (율, 밑 이름) · `rules` = 답 `끝수` · `settle` = 블록 비목 합 끝수(새 계산기 것) +B09 고유 셈 = 비목 합 · 끝수 · 관급 0 원 · % 밑수(옛 엔진 · 옛 식 풀이 안 부름). +""" + +from __future__ import annotations + +import importlib +from decimal import Decimal +from pathlib import Path +from typing import Any + +from M02_MasterTemplete import M02_Doc_Copy as dc # scripts 길을 둠 +from M02_MasterTemplete.M02_Item_Source import read_json + +md = importlib.import_module("master_doc") +mc = importlib.import_module("master_doc_calc") +ml = importlib.import_module("master_doc_link") +mt = importlib.import_module("master_doc_trace") + +FILE = "수식.json" +COSTS = ("노무비", "재료비", "경비") +INPUTS = ("입력", "선택", "숫자") # 입력 갈래 연결 + + +def docs_of(folder: Path) -> dict[str, dict]: + """사본 `수식.json` 문서 {키: 문서} — 없으면 빈 것(셈 때 그 자리 닫힌 묶음).""" + got = read_json(Path(folder) / FILE) + return dict((got or {}).get("문서") or {}) if isinstance(got, dict) else {} + + +def _num(value: Any) -> Decimal | None: + return value if isinstance(value, Decimal) else None + + +class Answer: + """문서 셈 답 한 벌 — 옛 엔진 줄 꼴(`줄`)로 갈라 읽음.""" + + def __init__(self, whole: Any, doc: dict, ans: dict, docs: dict, given: dict) -> None: + self.whole, self.doc, self.ans, self.docs, self.given = whole, doc, ans, docs, given + self.vars = {md.var_id(v): v for v in doc.get("변수") or []} + self.rules = ans.get("끝수") or {} + self.lines = [ + self._line(n, dl, out) + for n, (dl, out) in enumerate(zip(doc.get("금액") or [], ans.get("줄") or [])) + ] + + @property + def stopped(self) -> str | None: + """블록 통째로 못 셈 까닭 — 셈 멈춤(없는 요소 · 순환 …) · 빈 입력(옛 엔진도 입력에서 멈춤).""" + if not self.ans.get("셈됨") and "결과" not in self.ans: + marks = self.ans.get("표지") or [] + if marks: + return str(marks[0].get("글") or marks[0].get("갈래")) + empty = self.ans.get("빈값") or {} + for i, v in self.vars.items(): + if i in empty and (v.get("연결") or {}).get("갈래") in INPUTS: + return str(empty[i]) + return None + + @property + def resources(self) -> list[str]: + """문서 전체(하위 포함)가 부른 자원 키 — 부른 차례 · 겹침 없음(표 뺌).""" + return list(self.ans.get("자원") or []) + + @property + def env(self) -> dict[str, Any]: + """입력 · 중간 값 {원래 이름: 값} — 표 틀(`{구분}`) 채우기 · 계산서 줄 덧칸이 읽음.""" + values = self.ans.get("값") or {} + out = { + str(v.get("열쇠")): values[i] + for i, v in self.vars.items() + if v.get("열쇠") and values.get(i) is not None + } + for x in self.doc.get("식") or []: + if x.get("이름") and values.get(str(x.get("기호"))) is not None: + out.setdefault(str(x["이름"]), values[str(x["기호"])]) + return out + + def _call(self, n: int, dl: dict, out: dict) -> dict | None: + """줄 단가 기호를 부른 기록(맨 위 깊이) — 단가가 기호 하나가 아니면 None.""" + sym = str(dl.get("단가") or "") + calls = self.ans.get("부름") or [] + return next((calls[i] for i in out.get("부름") or [] if calls[i]["이름"] == sym), None) + + def _line(self, n: int, dl: dict, out: dict) -> dict[str, Any]: + qty, price = _num(out.get("수량")), out.get("단가") + kind = str(dl.get("비목") or "") + raw: dict[str, Decimal] = {} + if qty is not None and isinstance(price, dict): + raw = {k: qty * price[k] for k in COSTS if isinstance(price.get(k), Decimal)} + elif qty is not None and isinstance(price, Decimal) and kind in COSTS: + raw = {kind: qty * price} + call = self._call(n, dl, out) + line = { + "이름": dl.get("이름") or "", + "단위": dl.get("단위") or "", + "수량": qty, + "단가": price, + "비목": raw, + "금액": sum(raw.values()) if raw else None, + "까닭": out.get("까닭"), + "합밖": bool(out.get("합밖")), + "부름": None, + } + if call is None: + return line + if call["갈래"] == "단가산출": + p = call["부름"] + line["부름"] = ( + {"machine": call.get("기계")} + if "기계" in call + else {"code": str(p.get("키") or ""), "given": dict(p.get("입력") or {})} + ) + return line + keys = [x["키"] for x in call.get("자원") or [] if x["갈래"] != "표"] + asked = call["부름"].get("키") # 노임 「LB:직종」 꼴 = 부른 글 그대로(옛 키 · 글 단가 짝) + if isinstance(asked, str) and asked[:3] == "LB:" and "{" not in asked: + line["키"] = asked + return line + if price is None and (self.vars.get(str(dl.get("단가"))) or {}).get("연결", {}).get("재료"): + return line # 값 없는 재료 찾기 = 품목 없음(옛 `mp.priced` 와 같게 · 키 빈 글) + goods = call.get("품목") or (keys[0] if keys and keys[0][:2] == "MT" else None) + line["키"] = goods or (keys[0] if keys else "") + if goods: + try: + row = self.whole.get(goods) or {} + except Exception: # noqa: BLE001 — 없는 품목 = 키만 + row = {} + line["품목"] = {"키": goods, **{k: row.get(k) for k in ("이름", "규격", "단위")}} + return line + + def engine(self, items: list[dict]) -> list[dict[str, Any]]: + """옛 엔진 줄 꼴(대가 품셈 블록) — 호표 줄 단위 = 로직 원문 표기(B9-5 에서 문서로) · % 줄 = 율.""" + out = [] + for n, x in enumerate(self.lines): + if n < len(items): + out.append({**x, "단위": items[n].get("단위") or x["단위"]}) + else: + pct = self.pct(n) + out.append({**x, "율": pct[0]} if pct else x) + return out + + def pct(self, n: int) -> tuple[Decimal, str] | None: + """% 줄(149-4) — 단가 식이 「X × Y%」 · 「X × Y ÷ 100」 이면 (율 Y, 밑 이름 「노무비의 %」 …).""" + try: + node = md.parse(str((self.doc.get("금액") or [])[n].get("단가") or "")) + except (md.DocError, IndexError): + return None + if node[0] == "bin" and node[1] == "*" and node[3][0] == "pct": + base, part = node[2], node[3][1] + elif ( + node[0] == "bin" + and node[1] == "/" + and node[3] == ("num", Decimal(100)) + and node[2][0] == "bin" + and node[2][1] == "*" + ): + base, part = node[2][2], node[2][3] + else: + return None + rate = part[1] if part[0] == "num" else self._value(part) + return (rate, self._label(base)) if isinstance(rate, Decimal) else None + + def _value(self, node: tuple) -> Any: + """식 조각 값 — 같은 계산기(`master_doc_calc`)로 이 문서 · 입력 그대로.""" + if node[0] == "var": + return (self.ans.get("값") or {}).get(str(node[1])) + try: + run = mc._Run(self.doc, ml.Links(self.whole, self.docs), self.given, (), {}) + return run.ev(node, None, "율") + except Exception: # noqa: BLE001 — 못 셈 = % 줄 아님(식 그대로) + return None + + def _label(self, node: tuple) -> str: + """% 밑 이름 — `M02_Labor_Doc._pct_base` 같은 말(문서 기호 → 원래 이름).""" + if node[0] == "var": + name = str(node[1]) + if name in COSTS: + return f"{name}의 %" + line = next((x for x in self.doc.get("금액") or [] if x.get("기호") == name), None) + if line is not None: # 앞 금액 줄 기호(옛 줄 이름) + return f"{line.get('이름') or name}의 %" + step = next((x for x in self.doc.get("식") or [] if x.get("기호") == name), None) + var = self.vars.get(name) or {} + if step is None and (var.get("연결") or {}).get("갈래") not in (*INPUTS, "식"): + return ( + "인건비의 %" if str((var.get("연결") or {}).get("키", ""))[:2] == "LB" else "" + ) + return f"{var.get('열쇠') or (step or {}).get('이름') or name}의 %" + if node[0] == "field" and node[1] == ("var", "줄"): + return f"{node[2]}의 %" + names = md.names(node) + labor = [ + n + for n in names + if str(((self.vars.get(n) or {}).get("연결") or {}).get("키", ""))[:2] == "LB" + ] + return "인건비의 %" if labor and not set(names) & set(COSTS) else "" + + def settle(self, sums: dict[str, Decimal]) -> dict[str, Decimal]: + """블록 비목 합 끝수(끝전 · 계 · 조정) — 새 계산기 `_settle` 그대로 · 규칙 = 답 `끝수`.""" + return mc._settle(self.doc, self.rules, sums) + + +def solve( + whole: Any, + docs: dict[str, dict], + code: str, + given: Any = None, + picks: Any = None, + rate: Any = None, + shown: dict[str, int] | None = None, +) -> Answer | None: + """로직 하나 문서 셈 — `docs` 에 없는 키 = 그 자리 닫힌 묶음(받은 묶음에 더함) · 입력 = 자동값 › + 받은 값 · `rate` = 금액 줄 수량 × 율 ÷ 100(켜쌓기율 · 1 단위 몫) · `shown` = 중간값 표시 자리 + {원래 이름: 자리}(그 식 줄 = 반올림(식, 자리) · B09 엑셀 자리) · 문서 없음 = None.""" + code = str(code) + if code not in docs: + docs.update(dc.closure(whole, [code], docs)) + base = docs.get(code) + 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) + try: + ans = mt.calc(doc, mt.Trace(whole, docs), given, dc.cover_of(copy, doc)) + except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 남은 틈 = 못 셈 + return None + return Answer(whole, doc, ans, docs, given) + + +def _shown(doc: dict, shown: dict[str, int]) -> dict: + """중간값 표시 자리 — 열쇠가 `shown` 인 식 변수의 식 줄을 반올림(식, 자리)으로(새 문서).""" + syms = { + md.var_id(v): shown[str(v.get("열쇠"))] + for v in doc.get("변수") or [] + if (v.get("연결") or {}).get("갈래") == "식" and str(v.get("열쇠")) in shown + } + if not syms: + return doc + doc = {**doc, "식": [dict(x) for x in doc.get("식") or []]} + for x in doc["식"]: + if str(x.get("기호")) in syms: + x["식"] = f"반올림({x.get('식')}, {syms[str(x['기호'])]})" + return doc + + +class Shelf: + """값 색인(`whole`) → 문서 묶음 — 같은 색인 = 같은 묶음(사본 `수식.json` · 없으면 셈 때 그 자리).""" + + def __init__(self) -> None: + self._got: list[tuple[Any, dict[str, dict]]] = [] # 색인을 붙들어 둠(id 다시 쓰기 막음) + + def put(self, whole: Any, docs: dict[str, dict]) -> dict[str, dict]: + self._got.append((whole, docs)) + return docs + + def of(self, whole: Any) -> dict[str, dict]: + got = next((d for w, d in self._got if w is whole), None) + return self.put(whole, {}) if got is None else got diff --git a/B09_Estimation/B09_Estimation_Labor_Rule.py b/B09_Estimation/B09_Estimation_Labor_Rule.py index 0d92c2089..023e9e5af 100644 --- a/B09_Estimation/B09_Estimation_Labor_Rule.py +++ b/B09_Estimation/B09_Estimation_Labor_Rule.py @@ -21,7 +21,7 @@ from typing import Any from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠 -mf = importlib.import_module("master_formula") +md = importlib.import_module("master_doc") # 식 꼴 읽기 = 새 계산기 파서(855-F B9-3) ms = importlib.import_module("master_formula_sum") PART = {"노무비": "labor", "재료비": "material", "경비": "expense"} @@ -46,7 +46,7 @@ def _ref(row: dict, node: tuple, n: int) -> Refs | None: """밑 이름 하나 → 줄 차례(n 앞만) · 모름 = None.""" lines = ms.items(row) names = {x.get("이름"): i for i, x in reversed(list(enumerate(lines[:n]))) if x.get("이름")} - if node[0] == "name": + if node[0] == "var": if node[1] in PART: # 비목 합 = 앞 줄 중 합에 드는 줄 skip = ms.skipped(row) return [(i, PART[node[1]]) for i in range(n) if i not in skip] @@ -54,9 +54,9 @@ def _ref(row: dict, node: tuple, n: int) -> Refs | None: if node[0] != "field": return None head, name = node[1], node[2] - if head == ("name", "줄"): + if head == ("var", "줄"): return [(names[name], None)] if name in names else None - if head[0] != "field" or head[1][0] != "name": + if head[0] != "field" or head[1][0] != "var": return None group, key = head[1][1], head[2] if group == ms.ADDR: @@ -69,7 +69,7 @@ def _ref(row: dict, node: tuple, n: int) -> Refs | None: def _linear(row: dict, node: tuple, n: int) -> tuple[Refs, Decimal] | None: """식 = 수 하나 × 밑 합 → (밑, 수) · 다른 꼴 = None.""" - if node[0] in ("name", "field"): + if node[0] in ("var", "field"): got = _ref(row, node, n) return None if got is None else (got, Decimal(1)) if node[0] != "bin": @@ -87,8 +87,8 @@ def _linear(row: dict, node: tuple, n: int) -> tuple[Refs, Decimal] | None: def _pct(row: dict, formula: str, n: int) -> tuple[str, float] | None: """덧줄 식 → (`rows:` 밑, %) · 못 바꿈 = None(밑 없음 · 겹친 밑 포함).""" try: - got = _linear(row, mf.parse(formula), n) - except mf.FormulaError: + got = _linear(row, md.parse(formula), n) + except md.DocError: return None if not got or not got[0] or len(set(got[0])) != len(got[0]): return None @@ -112,8 +112,8 @@ def mark(row: dict, lines: list[dict], engine: list[dict]) -> dict | None: formula = str(item.get("식") or "") part = PART.get(str(item.get("비목")), "expense") try: - plain = _plain(mf.parse(formula)) - except mf.FormulaError: + plain = _plain(md.parse(formula)) + except md.DocError: continue value = _f(engine[n].get("금액")) if n < len(engine) else None if plain and value is not None: # 이름 없는 수 식 = 고정 줄(수량 1) diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py index 953efb10e..99d4c6205 100644 --- a/B09_Estimation/B09_Estimation_Labor_Source.py +++ b/B09_Estimation/B09_Estimation_Labor_Source.py @@ -34,6 +34,7 @@ from pathlib import Path from typing import Any from B09_Estimation import B09_Estimation_Bill_Library as library +from B09_Estimation import B09_Estimation_Doc_Run as dr from B09_Estimation import B09_Estimation_Labor_Rule as rule from B09_Estimation import B09_Estimation_Sangeun as sg from B09_Estimation import B09_Estimation_Sangeun_Text as st @@ -91,6 +92,9 @@ class Builder: def __init__(self) -> None: self.blocks: dict[str, dict[str, Any]] = {} self.gaps: list[dict[str, str]] = [] + self.shelf = ( + dr.Shelf() + ) # 값 색인 → 사본 수식 문서(855-F B9-3 · 사본마다 `combo` · `library`) def put(self, block: dict[str, Any], cover: str | None = None) -> str: bid = f"DG:{_digest([block['kind'], block['origin'], block['lines']])}" @@ -130,24 +134,27 @@ class Builder: return self.put(got) def _poomsem(self, whole: Any, one: dict[str, Any], title: str = "") -> dict | None: - """품셈 블록 꼴(넣기 전) — 엔진 줄 · 줄마다 `_n`(엔진 차례 · 단가산출 블록이 씀).""" + """품셈 블록 꼴(넣기 전) — 문서 셈 줄(`Doc_Run` · 옛 엔진 줄 꼴 · 855-F B9-3) · 줄마다 `_n` + (금액 줄 차례 · 단가산출 블록이 씀).""" code = str(one.get("로직") or "") given, rate, picks = one.get("입력값") or {}, one.get("켜쌓기율"), one.get("고름") try: logic = whole.logic(code) except mf.FormulaError: return None - got = labor_doc.run_line(whole, code, given, rate, picks, raw=True) # B09 끝수는 제 단가로 - if got.get("기준") is None: + got = dr.solve( + whole, self.shelf.of(whole), code, given, picks, rate + ) # B09 끝수는 제 단가로 + if got is None or got.stopped or "결과" in got.ans: return None # 돈 아닌 로직 · 못 돈 로직 — 조합 줄이 까닭을 냄 items = logic.get("호표") or [] lines = [] - engine = got.get("줄") or [] + engine = got.engine(items) # 옛 엔진 줄 꼴(단위 = 원문 · % 줄 율) bases = _engine_bases(engine[: len(items)], items) - calls = sg.line_calls(whole, code, given, picks) for n, x in enumerate(engine): item = items[n] if n < len(items) else None - lines.append(self._engine_line(item, x, logic, n - len(items), bases, calls.get(n))) + call = sg.logic_call(whole, self.shelf.of(whole), item, x) + lines.append(self._engine_line(item, x, logic, n - len(items), bases, call)) eq = {str(r.get("키")): r for r in (whole.numbers.get("EQ") or {}).values()} for line in lines: if line["kind"] == "machine": @@ -251,7 +258,7 @@ class Builder: return {**head, "kind": "blank", "qty": qty, "why": "덧줄 — 대가 단가로 못 셈"} part = PART.get(str(add.get("비목")), "expense") return {**head, "kind": "pct", "part": part, "base": base, "spec": f"{label}의 %", - "unit": "%", "qty": round(value / under * 100, 6)} # fmt: skip + "unit": "%", "qty": round(float(x["율"]) if "율" in x else value / under * 100, 6)} # fmt: skip kind, own = item.get("종류"), _own(x, qty) if kind == "인력": key = goods.get("키") or str(item.get("요소") or "") @@ -421,8 +428,9 @@ class Builder: values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} whole = item_prices.load_prices(prices) + docs = self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) area = read_json(folder / AREA_FILE) - result = item_prices.calc(labor, prices, values, picks, area) + result = item_prices.calc(labor, prices, values, picks, area, {"문서": docs}) use = (labor_doc.area_values(area), cover or f"S:{folder.name}") # SC 안 줄 알약(723-4) doc = item_prices.with_values(labor.get("줄") or {}, values, picks) copies = labor.get("참조사본") or {} @@ -476,6 +484,7 @@ class Builder: if not isinstance(doc, dict): return None whole = item_prices.load_prices(bundle(folder)) + self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) if manifest["종류"] == "sangeun": # 내 자료집 단가산출(719-2) return self.sangeun(whole, ref, doc, copies, 1) return self.precombo(whole, ref, doc, copies, 1) diff --git a/B09_Estimation/B09_Estimation_Linked.py b/B09_Estimation/B09_Estimation_Linked.py index 13549a6e7..d813e6e21 100644 --- a/B09_Estimation/B09_Estimation_Linked.py +++ b/B09_Estimation/B09_Estimation_Linked.py @@ -2,7 +2,8 @@ 연결된 사본 = `M02_Item_Snapshot.linked_snapshots`(지정 ∩ 같은 항목 사본 · B08 · B09 공용). 사본마다 `일위대가.json` 담은 로직을 그 사본 단가 묶음(`단가.json`) · 입력값 · 고른자재로 돌리며 -실제로 부른 자원 줄(인력 LB · 기계 EQ · 자재 MT · 유가 MO)만 모음 — 단가 묶음 통째 +실제로 부른 자원 줄(인력 LB · 기계 EQ · 자재 MT · 유가 MO · 문서 셈 기록 `Doc_Run.resources` · +855-F B9-3)만 모음 — 단가 묶음 통째 (고르기 후보 전부)는 안 씀 · 값은 쓰지 않음(단가는 원가 한 벌 `price_book.json` 이 맡음) · 사본 일위대가 자재 · 굳힌 사전조합 자재 코드 · 고정 줄 이음 키도(183-1 · 705-1 · 로직을 안 돌아 `get` 에 안 걸림). 굳힌 SK(719-2) = 굳힌 키 로직 줄로 돌림(사본 `단가.json` · M01 안 읽음). @@ -15,9 +16,9 @@ from __future__ import annotations from pathlib import Path from typing import Any +from B09_Estimation import B09_Estimation_Doc_Run as dr from B09_Estimation.B09_Estimation_Copy_Prices import bundle from M02_MasterTemplete import M02_Item_Prices as item_prices -from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Fixed as fixed from M02_MasterTemplete.M02_Item_Snapshot import ( PICKS_FILE, @@ -42,16 +43,7 @@ def used_keys(folder: Path) -> list[str]: values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} seen: list[str] = [] - base_get = snapshot.get - - def get(ref: str) -> dict[str, Any]: - row = base_get(ref) - key = str(row.get("키") or "") - if key[:2] in RESOURCE_TABLES and key not in seen: - seen.append(key) - return row - - snapshot.get = get # 이 사본 묶음 한 벌에만 — 마스터 캐시는 안 건드림 + docs = dr.docs_of(folder) # 사본 수식 문서 — 셈 기록의 자원 키(855-F B9-3) # 사본 셈 한 벌(142-1)과 같은 길 — 빈 입력 = 자동값 · 켜쌓기율 · 고름 · # 굳힌 참조사본 안 로직까지 doc = item_prices.with_values(labor.get("줄") or {}, values, picks) @@ -61,9 +53,14 @@ def used_keys(folder: Path) -> list[str]: for one in [*lines, *sks]: # 못 돈 로직 — 부른 데까지만(까닭은 안 봄) if isinstance(one, dict) and one.get("로직"): - labor_doc.run_line( - snapshot, one["로직"], one.get("입력값"), one.get("켜쌓기율"), one.get("고름") + got = dr.solve( + snapshot, docs, one["로직"], one.get("입력값"), one.get("고름"), one.get("켜쌓기율") ) + seen += [ + k + for k in (got.resources if got else []) + if k[:2] in RESOURCE_TABLES and k not in seen + ] mats = [*(doc.get("자재") or []), *(m for d in inner for m in d.get("자재") or [])] codes = [str(mat.get("코드") or "") if isinstance(mat, dict) else "" for mat in mats] codes += [k for d in [doc, *inner] for k in fixed.link_keys(d)] # 705-1 고정 줄 이음 diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py index ee6ef1017..2f0bbc4fa 100644 --- a/B09_Estimation/B09_Estimation_Sangeun.py +++ b/B09_Estimation/B09_Estimation_Sangeun.py @@ -8,8 +8,9 @@ 같은 로직 + 같은 입력값(+ 켜쌓기율 · 고른 자재) = 산근 하나(`sangeun_key`) · 번호 = 첫 등장 차례 · 로직 줄이 부르는 다른 돈 로직(기계경비 밖) = 하위 산근(그 산근도 목록에 · 산근 → 산근). -풀이 = 로직 호표 줄을 사본 단가 묶음(`단가.json`)으로 펼쳐 수량 · 자원 키만 얻고 - (M01 엔진 식 그대로) · +풀이 = 사본 수식 문서(`수식.json`)를 M02 와 같은 계산기로 셈한 답 + 셈 기록(`B09_Estimation_Doc_Run` · + 855-F B9-3)에서 줄마다 수량 · 단가 · 자원 키 · 하위 산근 · % 줄 율 · 끝수를 읽음(옛 엔진 안 부름) · + 줄 이름 · 단위 · 종류 = 사본 로직 줄 글(B9-5 에서 문서로) · 산출근거 글 = 옛 길(B9-4 · `_env` · `_captured`) · 단가 = B09 프로젝트 한 벌 굳힌 단가(144 · `compute_base` 표) — 노무 = 노무비목록표 · 중기 = 중기목록표 노 · 재 · 경 · 재료 = 자재단가대비표 적용 단가 · % 줄(덧줄) = 엔진 식에 B09 비목 합. @@ -36,11 +37,13 @@ from __future__ import annotations import copy import hashlib import json +import re from decimal import Decimal from pathlib import Path from typing import Any 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.B09_Estimation_Calc_Base import SUPPLY, gap, num, rounddown, total from B09_Estimation.B09_Estimation_Copy_Prices import bundle @@ -48,7 +51,6 @@ 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_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete.M02_Item_Snapshot import ( PICKS_FILE, @@ -102,9 +104,10 @@ def _values(values: dict[str, Any], code: str) -> dict[str, Any]: return {name: (one or {}).get("값") for name, one in (values.get(code) or {}).items()} -def rows_of(folder: Path, whole: Any = None) -> list[dict[str, Any]]: +def rows_of(folder: Path, whole: Any = None, docs: dict | None = None) -> list[dict[str, Any]]: """사본 하나의 산근 원천 줄(차례대로) — 단가산출 줄 · 사전조합 안 단가산출 줄 · - 일위대가화 줄(승격 · 옛 SP)의 하위 로직 줄. 키 = 대가 블록 산근 줄 키(`Labor_Source`)와 같음.""" + 일위대가화 줄(승격 · 옛 SP)의 하위 로직 줄. 키 = 대가 블록 산근 줄 키(`Labor_Source`)와 같음 · + `docs` = 사본 수식 문서(없으면 `수식.json`).""" from M02_MasterTemplete import M02_Labor_Ref as refs labor = read_json(folder / LABOR_FILE) @@ -112,6 +115,7 @@ def rows_of(folder: Path, whole: Any = None) -> list[dict[str, Any]]: return [] if whole is None: whole = item_prices.load_prices(bundle(folder)) + docs = dr.docs_of(folder) if docs is None else docs values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} copies = labor.get("참조사본") or {} @@ -123,7 +127,7 @@ def rows_of(folder: Path, whole: Any = None) -> list[dict[str, Any]]: if not promoted: out.append({"code": code, "given": _clean_given(given), "rate": rate, "picks": chosen}) return - for call in line_calls(whole, code, given, chosen).values(): + for call in line_calls(whole, code, given, chosen, docs).values(): if call and call.get("code"): out.append({"code": call["code"], "given": call["given"], "rate": None, "picks": None}) # fmt: skip @@ -198,7 +202,8 @@ def unit_of(whole: Any, code: str) -> str: def _env(whole: Any, row: dict, given: dict) -> dict: - """입력(빈 입력 = 자동값) + 중간값 · 작업량 Q = ROUND(식, 2)(엑셀 자리).""" + """입력(빈 입력 = 자동값) + 중간값 · 작업량 Q = ROUND(식, 2)(엑셀 자리) — 산출근거 글 몫만 + (`B09_Estimation_Sangeun_Text` · B9-4 에서 걷음 · 풀이 금액은 `Doc_Run`).""" auto = {k: v for k, v in m01.mau.values(whole, row).items() if v is not None} env = mf._inputs(row, {**auto, **m01._dec(given or {})}) for step in row.get("중간", []): @@ -220,46 +225,69 @@ def is_money(whole: Any, code: str) -> bool: return not (isinstance(row.get("흐름"), dict) or "결과" in row) -def call_of(whole: Any, item: dict, env: dict) -> dict[str, Any] | None: - """로직 호표 줄(종류 로직) → 부른 것 — 기계경비 로직 `{machine: EQ 키 | None}` · - 다른 돈 로직 `{code, given}`(하위 산근) · 못 펼치면 None. +def call_of(line: dict) -> dict[str, Any] | None: + """문서 셈 줄(`Doc_Run` 줄) → 부른 것 — 기계경비 `{machine: EQ 키 | None}` · 다른 돈 문서 + `{code, given}`(하위 산근) · 단가가 단가산출 부름 아님 = None. 대가 품셈 줄(`B09_Estimation_Labor_Source`)과 산근 풀이가 같은 판정을 씀.""" - node = mf.parse(item["요소"]) - called = node[1] if node and node[0] == "logic" else None - try: - target = whole.logic(called) if called else None - except mf.FormulaError: - target = None - if not target: + call = line.get("부름") + if not call: return None - if mf.mb.is_machine(target): # 기계경비 판별 한 곳(712-1) - keys = _captured(whole, node, env) - return {"machine": keys[0] if keys else None} - given = {name: mf.evaluate(expr, env, whole, 1) for name, expr in node[2]} - return {"code": called, "given": _clean_given(given)} + if "machine" in call: + return {"machine": call["machine"]} + return {"code": call["code"], "given": _clean_given(call["given"])} -def line_calls(whole: Any, code: str, given: Any, picks: Any = None) -> dict[int, dict | None]: - """로직 하나의 로직 호표 줄마다 `call_of`(호표 차례 n → 부른 것) — 못 셈 줄 = None.""" +_LOGIC = re.compile(r"\s*로직\(\s*([A-Z]{2}\d+)") # 호표 요소 「로직(키, …)」 의 키 + + +def frozen_machine(whole: Any, docs: dict, item: dict, line: dict) -> dict[str, Any] | None: + """굳은 기계 단가 줄(847-1 · 문서 = 숫자 묶음 · 셈 기록에 하위 부름 없음) → `{machine}` — 기계 키 = + 로직 원문 요소 「로직(키 …)」 문서의 셈 기록 첫 기계 · 묶음 단가 아님 = None.""" + if not isinstance(line.get("단가"), dict): + return None + hit = _LOGIC.match(str(item.get("요소") or "")) + got = dr.solve(whole, docs, hit.group(1)) if hit else None + keys = [k for k in (got.resources if got else []) if k[:2] == "EQ"] + return {"machine": keys[0] if keys else None} + + +def logic_call(whole: Any, docs: dict, item: dict | None, line: dict) -> dict[str, Any] | None: + """로직 호표 줄의 부른 것 — 하위 부름(`call_of`) · 굳은 기계 단가(`frozen_machine`) · 로직 줄 아님 = None.""" + if not item or item.get("종류") != "로직": + return None + return call_of(line) or frozen_machine(whole, docs, item, line) + + +def line_calls( + whole: Any, code: str, given: Any, picks: Any = None, docs: dict | None = None +) -> dict[int, dict | None]: + """로직 하나의 로직 호표 줄마다 `call_of`(호표 차례 n → 부른 것) — 못 셈 줄 = None · + 셈 = 문서 셈 답(`Doc_Run` · `docs` = 사본 수식 문서 · 없으면 그 자리 닫힌 묶음).""" try: row = whole.logic(code) - env = _env(whole, row, _clean_given(given)) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + except mf.FormulaError: return {} - out: dict[int, dict | None] = {} - with mf.mp.choosing(picks): - for n, item in enumerate(row.get("호표", [])): - if item.get("종류") != "로직": - continue - try: - out[n] = call_of(whole, item, env) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): - out[n] = None - return out + docs = {} if docs is None else docs + got = dr.solve( + whole, + docs, + code, + _clean_given(given), + picks, + None, + ss.doc_shown(row), + ) + if got is None: + return {} + return { + n: logic_call(whole, docs, item, got.lines[n]) if n < len(got.lines) else None + for n, item in enumerate(row.get("호표", [])) + if item.get("종류") == "로직" + } def _captured(whole: Any, node: Any, env: dict) -> list[str]: - """식을 돌리며 부른 기계 키(EQ) — 기계경비 로직 줄의 기계.""" + """식을 돌리며 부른 기계 키(EQ) — 기계경비 로직 줄의 기계 · 산출근거 글 몫만(B9-4).""" seen: list[str] = [] base = whole.get @@ -316,8 +344,9 @@ class Solver: def __init__(self, supply: Any = None) -> None: self.supply = supply or (lambda key: None) # 자재 키 → 관급 · 별도 · None(841-1) self.prices = _Prices() - self.eng: list[dict[str, Any]] = [] # 지금 푸는 로직의 엔진 줄(호표 차례 · 841-1) + self.eng: list[dict[str, Any]] = [] # 지금 푸는 로직의 문서 셈 줄(금액 줄 차례 · 841-1) self.blocks: dict[str, dict[str, Any]] = {} + self.shelf = dr.Shelf() # 값 색인 → 사본 수식 문서(`collect` 가 사본마다 둠) def add( self, whole: Any, src: dict[str, Any], owner: str | None, depth: int = 0 @@ -342,21 +371,28 @@ class Solver: 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 단가 책 안 읽음) - eng = labor_doc.run_line(whole, code, src["given"], None, src.get("picks"), raw=True) + # 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: + return self._stop(code, name, f"수식 문서 없음 「{code}」") + if why := eng.stopped: # 빈 입력 · 셈 멈춤 = 블록 통째 빈칸(옛 엔진과 같게) + return self._stop(code, name, why) + scale = (rate or 1) * 100 / times # % 줄 밑 = 1 단위 몫 줄 합(켜쌓기율 · 배 반영) + per = eng if scale == 100 else dr.solve(whole, docs, code, src["given"], + src.get("picks"), scale, shown) # fmt: skip try: - env = _env(whole, row, src["given"]) - with mf.mp.choosing(src.get("picks")): - for n, item in enumerate(row.get("호표", [])): - self.eng = eng.get("줄") or [] # 하위 산근 풀이가 바꿔 놓아도 되돌림 - lines.append(self._line(whole, item, n, env, times, rate, depth)) - ss.places(row, lines) # 줄 자리(792-3) - self._extras(whole, row, env, lines) - self._aside(lines) - _annotate(whole, row, env, lines) - except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: + for n, item in enumerate(row.get("호표", [])): + self.eng = eng.lines # 하위 산근 풀이가 바꿔 놓아도 되돌림 + lines.append(self._line(whole, item, n, times, rate, depth)) + ss.doc_places(row, lines) # 줄 자리(792-3) + self._extras(row, per or eng, lines) + self._aside(lines) + _annotate(whole, row, eng.env, lines) + except (ArithmeticError, KeyError, TypeError, ValueError) as e: return self._stop(code, name, str(e) or type(e).__name__) - sums = ss.totals(row, lines) or block_totals(lines) # 끝전 · 조정(792-3) + sums = ss.doc_totals(eng, lines) # 끝수 · 끝전 · 조정 = 문서 답 끝수(792-3) why = next((ln["why"] for ln in lines if ln.get("why")), None) head, foot = self._text(whole, src, times, lines) for ln in lines: # 글 = 엔진 단가 셈 그대로 · 별도계상 재료 줄은 끝에 0 원 표시(841-1) @@ -442,39 +478,26 @@ class Solver: "unit": item.get("단위", ""), "ref": None, "price": {}, **{p: (None if p == part else 0.0) for p in PARTS}, "why": why} # fmt: skip - def _line(self, whole, item, n, env, times, rate, depth) -> dict[str, Any]: - try: - raw = mf.evaluate(mf.parse(item["수량"]), env, whole, 0) - except mf.EmptyInput as e: - return self._blank(item, str(e)) - qty = Decimal(str(raw)) / times * (rate or 1) + def _line(self, whole, item, n, times, rate, depth) -> dict[str, Any]: + x = self.eng[n] if n < len(self.eng) else {} + if x.get("수량") is None: # 빈 입력 · 못 셈 수량 = 빈 줄(문서 셈 까닭) + return self._blank(item, x.get("까닭") or "수량을 못 셈") + qty = x["수량"] / times * (rate or 1) q = float(qty) base = {"name": item.get("이름", ""), "spec": "", "qty": q, "unit": item.get("단위", "")} zero = dict.fromkeys(PARTS, 0.0) kind = item.get("종류") if kind == "로직": - return self._logic_line(whole, item, n, env, q, base, zero, depth) + return self._logic_line(whole, item, n, x, q, base, zero, depth) if kind == "인력": - key = mf.fill(item["요소"], env) if isinstance(item["요소"], str) else "" + key = str(x.get("키") or "") # 노임 키 = 셈 기록(부른 노임 줄) price = self._each(n, "labor", q) self.prices.labor[key] = price why = None if price is not None else f"노임 단가 없음(M02 엔진) 「{key}」" return {**base, **zero, "kind": "labor", "ref": {"tab": "labor", "key": key}, "price": {"labor": price}, "labor": _money(price, q), "why": why} # fmt: skip - ref = ( - {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()} - if isinstance(item["요소"], dict) - else mf.fill(item["요소"], env) - ) - _price, source, _why, extra = mf.mp.priced(whole, item, ref, env, n) - goods = (extra or {}).get("품목") or {} - key = str( - goods.get("키") or (source or "").split(".")[0] or (ref if isinstance(ref, str) else "") - ) - try: # 자리표시 글(「MO:경유:전국평균」) = 그 줄 키로 - key = str((whole.get(key) or {}).get("키") or key) - except (mf.FormulaError, KeyError, TypeError, ValueError): - pass + goods = x.get("품목") or {} # 고른 품목 = 셈 기록 · 자원 키(유가 MO 등) + key = str(x.get("키") or "") part = COST_PART.get(item.get("비목"), "material") price = self._each(n, part, q) self.prices.material[key] = price @@ -485,8 +508,8 @@ class Solver: "price": {part: price}, part: _money(price, q), "why": why, "_goods": goods} # fmt: skip - def _logic_line(self, whole, item, n, env, q, base, zero, depth) -> dict[str, Any]: - call = call_of(whole, item, env) + def _logic_line(self, whole, item, n, x, q, base, zero, depth) -> dict[str, Any]: + call = logic_call(whole, self.shelf.of(whole), item, x) if call and "machine" in call: keys = [call["machine"]] if call["machine"] else [] price = {p: self._each(n, p, q) for p in PARTS} # 기계 시간당 = M02 엔진 값(841-1) @@ -510,38 +533,30 @@ class Solver: return {**base, "kind": "sangeun", "ref": {"tab": "sg", "key": sub["key"]}, "price": price, **{p: _money(price[p], q) for p in PARTS}, "why": why} # fmt: skip - def _extras(self, whole, row, env, lines) -> None: - """% 줄(덧줄) — 엔진 식 그대로 · 밑수 = 그때까지 B09 비목 합 · 줄 금액 = 이름별 · - 「X * Y / 100」 덧줄 = 규격 「노무비의 %」 · 수량 = 율 · 단위 %(149-4 `pct_extras`).""" - heads = [{} for _ in row.get("호표", [])] - pcts = labor_doc.pct_extras( - whole, row, heads + [{} for _ in row.get("덧줄", [])], dict(env) - ) - for extra, pct in zip(row.get("덧줄", []), pcts[len(heads) :]): - sums = ss.sums(row, lines) # 합밖 · 제외(792-3) + def _extras(self, row, per, lines) -> None: + """% 줄(덧줄) — 값 = 문서 셈 답(`per` = 1 단위 몫 셈 · 밑수 = 그때까지 줄 합) · 줄 금액 = 줄 자리 · + 「X × Y%」 덧줄 = 규격 「노무비의 %」 · 수량 = 율 · 단위 %(149-4) · 앞 줄 빈칸 = 「밑수 빈칸」.""" + heads = len(row.get("호표", [])) + skip = {n for n, x in enumerate(per.lines) if x.get("합밖")} + for i, extra in enumerate(row.get("덧줄", [])): + n = heads + i + sums = ss.doc_sums(skip, lines) # 합밖 · 제외(792-3) part = COST_PART.get(extra.get("비목"), "material") line = {"kind": "extra", "name": extra["이름"], "spec": extra["식"], "qty": 1.0, "unit": "식", "ref": None, **dict.fromkeys(PARTS, 0.0)} # fmt: skip - if "율" in pct: - line.update(spec=pct.get("규격") or extra["식"], qty=float(pct["율"]), unit="%") - if of := PCT_OF.get(str(pct.get("규격") or "").removesuffix("의 %")): + if pct := per.pct(n): + line.update(spec=pct[1] or extra["식"], qty=float(pct[0]), unit="%") + if of := PCT_OF.get(pct[1].removesuffix("의 %")): line["of"] = of # 719-3 덮개 다시 셈 밑수(`Sangeun_Cover`) if any(v is None for v in sums.values()): lines.append({**line, part: None, "price": {}, "why": "밑수 빈칸"}) continue - env.update({k: Decimal(str(v)) for k, v in sums.items()}) - ss.scope(row, lines, env) # 번지 · 단계(792-3) - env["줄"] = { - ln["name"]: Decimal(str(sum(ln[p] or 0 for p in PARTS))) - for ln in lines - if ln["name"] - } - try: - value = float(mf.evaluate(mf.parse(extra["식"]), env, whole, 0)) - except (mf.FormulaError, ArithmeticError, TypeError, ValueError) as e: - lines.append({**line, part: None, "price": {}, "why": str(e)}) + x = per.lines[n] if n < len(per.lines) else {} + if x.get("금액") is None: + lines.append({**line, part: None, "price": {}, "why": x.get("까닭") or "못 셈"}) continue - money = ss.extra(row, extra, value, env) # 줄 자리(792-3) + value = float(x["금액"]) + money = ss.doc_cut(value, extra.get("자리")) # 줄 자리(792-3) lines.append({**line, "price": {part: value}, part: money, "why": None}) @@ -600,26 +615,20 @@ def hand_whole(hands: list[tuple[str, str, dict[str, Any]]]) -> Any: def hand_resource_keys(user: dict[str, Any] | None) -> list[str]: - """손 줄 로직이 부르는 자원 키(단가 책 수요 · `Linked.used_keys` 꼴) — 부른 차례 · 겹침 없음.""" + """손 줄 로직이 부르는 자원 키(단가 책 수요 · `Linked.used_keys` 꼴) — 부른 차례 · 겹침 없음 · + 셈 기록(`Doc_Run.resources`).""" hands = hand_sources(user) if not hands: return [] from B09_Estimation.B09_Estimation_Linked import RESOURCE_TABLES - whole = hand_whole(hands) + whole, docs = hand_whole(hands), {} seen: list[str] = [] - base = whole.get - - def get(ref: str) -> dict[str, Any]: - row = base(ref) - key = str(row.get("키") or "") - if key[:2] in RESOURCE_TABLES and key not in seen: - seen.append(key) - return row - - whole.get = get # 이 묶음 한 벌에만 - for _key, _use, src in hands: - labor_doc.run_line(whole, src["code"], src["given"], src["rate"], src["picks"]) + for _key, _use, src in hands: # 자원 키 = 문서 셈 기록(하위 포함 · 고른 품목만) + got = dr.solve(whole, docs, src["code"], src["given"], src["picks"], src["rate"]) + for key in got.resources if got else []: + if key[:2] in RESOURCE_TABLES and key not in seen: + seen.append(key) return seen @@ -638,7 +647,8 @@ def collect( solver = Solver(supply) for owner, folder in entries: whole = item_prices.load_prices(bundle(folder)) - for src in rows_of(folder, whole): + docs = solver.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + for src in rows_of(folder, whole, docs): solver.add(whole, src, owner) hand_keys: dict[str, str] = {} if hands: diff --git a/B09_Estimation/B09_Estimation_Sangeun_Sum.py b/B09_Estimation/B09_Estimation_Sangeun_Sum.py index 7d8eb85d5..64d8528d1 100644 --- a/B09_Estimation/B09_Estimation_Sangeun_Sum.py +++ b/B09_Estimation/B09_Estimation_Sangeun_Sum.py @@ -1,7 +1,8 @@ """B09 산근 풀이 셈 의미(PLAN 792-3) — 791-1 엔진 새 의미(줄 자리 · 합밖 · 번지 · 단계 · 블록 끝전 · 결과 조정 · 변수 표시)를 쓰는 로직만 엔진 규칙(`master_cut` · `master_formula_sum`) 그대로 · 새 칸 없는 로직 = 옛 B09 규칙(작업량 Q = ROUND 2 · 줄 ROUNDDOWN 1 · 총계 비목마다 ROUNDDOWN 0). -쓰는 곳 = `B09_Estimation_Sangeun.Solver` · 지킴 시험 = `test_792_3_engine_paths.py`(엔진 · M02 SK · +쓰는 곳 = 산출근거 글(`B09_Estimation_Sangeun_Text` · B9-4 에서 걷음) · 풀이 금액(`Sangeun.Solver`) = +아래 `doc_*`(855-F B9-3 · 문서 셈 답 `끝수` · `합밖` · 새 계산기 `master_doc_calc.cut` · `_settle`) · 지킴 시험 = `test_792_3_engine_paths.py`(엔진 · M02 SK · SC · B09 산근 네 길 같은 금액). """ @@ -16,6 +17,7 @@ from B09_Estimation.B09_Estimation_Calc_Base import round_half, rounddown, total from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠 mcut = importlib.import_module("master_cut") +mc = importlib.import_module("master_doc_calc") ms = importlib.import_module("master_formula_sum") PARTS = ("labor", "material", "expense") @@ -87,3 +89,52 @@ def totals(row: dict, lines: list[dict]) -> dict[str, float | None] | None: costs = mcut.settle(row, {k: Decimal(str(v)) for k, v in got.items()}) out = {COST_PART[k]: float(v) for k, v in costs.items()} return {**out, "sum": sum(out.values())} + + +# ── 문서 셈 답 길(855-F B9-3 · `Sangeun.Solver`) — 위 옛 길 = 산출근거 글 몫 ────────── +def doc_cut(value: float, rule: dict | None) -> float: + """줄 끝수 — 줄 `자리` 면 그 규칙(새 계산기 `master_doc_calc.cut`) · 없으면 ROUNDDOWN 1.""" + return float(mc.cut(Decimal(str(value)), rule)) if rule else rounddown(value, 1) + + +def doc_places(row: dict, lines: list[dict]) -> None: + """호표 줄 `자리`(줄 자리) — 그 줄 금액만 단가 × 수량을 그 규칙으로 다시 버림(제자리).""" + for item, ln in zip(row.get("호표", []), lines): + rule = item.get("자리") + if not rule or ln.get("qty") is None: + continue + for part, price in (ln.get("price") or {}).items(): + if part in PARTS and price is not None: + ln[part] = doc_cut(price * ln["qty"], rule) + + +def doc_sums(skip: set[int], lines: list[dict]) -> dict[str, float | None]: + """덧줄 밑 비목 합 — 합밖 · 제외 단계 줄(문서 셈 답 `합밖`)을 뺌.""" + kept = [ln for n, ln in enumerate(lines) if n not in skip] + return {name: total([ln[p] for ln in kept]) for name, p in COST_PART.items()} + + +def doc_totals(answer: Any, lines: list[dict]) -> dict[str, float | None]: + """총계 — 합밖 · 제외 줄 빼고 B09 줄 금액 비목 합 → 문서 답 `끝수`(끝전 · 계 · 조정 · 새 계산기 + `settle`) · 빈칸 비목 있으면 그 비목 · 합계 빈칸(옛 `block_totals`).""" + skip = {n for n, x in enumerate(answer.lines) if x.get("합밖")} + got = doc_sums(skip, lines) + if any(v is None for v in got.values()): + out = {COST_PART[k]: None if v is None else rounddown(v, 0) for k, v in got.items()} + return {**out, "sum": total(list(out.values()))} + costs = answer.settle({k: Decimal(str(v)) for k, v in got.items()}) + out = {COST_PART[k]: float(v) for k, v in costs.items()} + return {**out, "sum": sum(out.values())} + + +def doc_shown(row: dict) -> dict[str, int]: + """중간값 표시 자리 {이름: 자리} — `shown` 과 같은 뜻(`표시` · 옛 로직 작업량 Q = ROUND 2 · 엑셀 자리) · + 문서 셈에 그 식 줄을 반올림으로 씌워 셈(`Doc_Run.solve` `shown`).""" + new = ms.uses(row) + out: dict[str, int] = {} + for step in row.get("중간", []): + if step.get("표시") is not None: + out[step["이름"]] = int(step["표시"]) + elif not new and _Q.fullmatch(step["이름"]): + out[step["이름"]] = 2 + return out diff --git a/resources/master_data/scripts/master_doc_trace.py b/resources/master_data/scripts/master_doc_trace.py index 07e0278b1..7045c1942 100644 --- a/resources/master_data/scripts/master_doc_trace.py +++ b/resources/master_data/scripts/master_doc_trace.py @@ -50,7 +50,15 @@ class _Seen: setattr(self._m, name, value) def __getattr__(self, name): - raw = inspect.getattr_static(self._m, name) + target = self._m + while True: # 감싼 색인(`_Over` · 사본 색인)은 속 색인 메서드를 이 감쌈에 묶음 + try: + raw = inspect.getattr_static(target, name) + break + except AttributeError: + target = getattr(target, "_whole", None) + if target is None: + return getattr(self._m, name) if isinstance(raw, types.FunctionType): return raw.__get__(self) return getattr(self._m, name) diff --git a/resources/tester/golden_855_b09.json b/resources/tester/golden_855_b09.json index bf39536aa..36d1c81f4 100644 --- a/resources/tester/golden_855_b09.json +++ b/resources/tester/golden_855_b09.json @@ -3,18 +3,18 @@ "지문": { "키": "e68369418202e5ee", "calc_user": "6d74551273d6735f", - "daega_inputs": "d26099b92d7d0a1b", - "수요": "f793204cf95c45c4", - "산근 값": "c486d041a3246ffb", - "산근 글": "a21b34ec13661f0c", - "산근 관급 값": "c5c3daf85d9bd01b", - "산근 관급 글": "a65b945fc8582ca3", + "daega_inputs": "a06884bce408c602", + "수요": "5fdf7c49052e322c", + "산근 값": "38455c2edce885ff", + "산근 글": "c41b0c2e4ae200fb", + "산근 관급 값": "d154925ee64c985c", + "산근 관급 글": "396194c98b10b525", "미리보기 hand:rate 값": "091690571b7dc54b", "미리보기 hand:rate 글": "c49b1bc692d59fe5", "미리보기 hand:pick 값": "6c7f426d37e31998", "미리보기 hand:pick 글": "96a9de9a02e3d124", "미리보기 hand:net 값": "b1c2c650567a14ae", - "미리보기 hand:net 글": "be7884bdbeb29ed3", + "미리보기 hand:net 글": "9846e15ac6f0f663", "B08 단위수량": "896710398b04b4fd" } } diff --git a/resources/tester/helper_855_engine.py b/resources/tester/helper_855_engine.py index 224cead19..8eeb49b12 100644 --- a/resources/tester/helper_855_engine.py +++ b/resources/tester/helper_855_engine.py @@ -162,3 +162,34 @@ def fingerprint(key: str, row: dict, options: bool = True) -> str: got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)] raw = json.dumps(got, ensure_ascii=False, sort_keys=True) return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] + + +def old_line_calls(whole, code: str, given) -> dict: + """옛 엔진 하위 부름(855-F B9-3 전 `B09 line_calls` · 대조 기준 · 2-E4 에서 은퇴) — 로직 호표 줄 + 차례 → 기계경비 {machine} · 돈 로직 {code, given} · 못 셈 = None.""" + from B09_Estimation import B09_Estimation_Sangeun as sg + + try: + row = whole.logic(code) + env = sg._env(whole, row, sg._clean_given(given)) + except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + return {} + out: dict = {} + for n, item in enumerate(row.get("호표", [])): + if item.get("종류") != "로직": + continue + try: + node = mf.parse(item["요소"]) + called = node[1] if node and node[0] == "logic" else None + target = whole.logic(called) if called else None + if not target: + out[n] = None + elif mf.mb.is_machine(target): + keys = sg._captured(whole, node, env) + out[n] = {"machine": keys[0] if keys else None} + else: + given_ = {name: mf.evaluate(expr, env, whole, 1) for name, expr in node[2]} + out[n] = {"code": called, "given": sg._clean_given(given_)} + except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError): + out[n] = None + return out diff --git a/resources/tester/test_855_trace.py b/resources/tester/test_855_trace.py index 1be8cbb9e..b6e711607 100644 --- a/resources/tester/test_855_trace.py +++ b/resources/tester/test_855_trace.py @@ -4,7 +4,7 @@ - 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 · 찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 · 빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음). -- 하위 부름 = 옛 `B09 line_calls`(돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력 +- 하위 부름 = 옛 `B09 line_calls`(`helper_855_engine.old_line_calls` · 돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력 기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님. - 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원. - 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴. @@ -106,7 +106,7 @@ def survey() -> dict: new = set(got["자원"]) if old != new: out["자원"][key] = (sorted(old - new), sorted(new - old)) - lines = sg().line_calls(whole, key, given) + lines = h.old_line_calls(whole, key, given) # 옛 엔진 기준(B9-3 뒤 B09 는 문서 셈) a, b = _calls(lines, got, docs) if a != b: out["하위"][key] = (sorted(a), sorted(b))