From 63cd2f995788dd7f2995a78e4d69074b93131c46 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 00:01:07 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-2-C1):=20=EC=98=9B=20=EC=B9=B8=20?= =?UTF-8?q?=EC=B2=98=EB=A6=AC=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20=ED=99=94?= =?UTF-8?q?=EB=A9=B4=20=EC=85=88=20=EB=8B=B5=20=EC=98=9B=20=EC=8B=9C?= =?UTF-8?q?=ED=8A=B8=20=C2=B7=20=EB=B3=B4=EA=B8=B0=20=EA=B8=80=20=C2=B7=20?= =?UTF-8?q?=EC=A0=80=EC=9E=A5=20=EB=95=8C=20=EC=98=9B=20=EC=B9=B8=20?= =?UTF-8?q?=EC=9B=90=EA=B0=92=20=EC=A0=81=EA=B8=B0=20=C2=B7=20=EC=95=88=20?= =?UTF-8?q?=EC=93=B0=EB=8A=94=20=EC=85=88=20=EB=8F=84=EA=B5=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - `M02_Sangeun_Views.py` 지움(보기 글 · 중간 — 부르는 곳 0 · 화면 보기 false 856-1) - `Sangeun_Const.answer` = 셈 답 + 머리 + 가져온 식 원본 보기만 · 옛 `원래` · `시트` 덧칸(`sheet` · `_mids` 옛 엔진 · `_finds` · `_bare` · `lost`) 지움 → 화면 셈 길(`/sangeun/calc`) 옛 엔진 부름 0 - `Sangeun_Calc`: `_detail`(둘째 기초 세부) · `_rate_text` · `_stamp_adds` · `_was` · 저장 때 덮개 `원값` 셈 지움 · `calc_doc` 옛 보기 인자 안 넘김 · 머리 글 한 길로 고침 - 남김(까닭): `resolve` · `_base_of` · `_fill` · `_gap` · `_bundles` · `_rated` · `_Over` · `_frozen`(굳힌 사본 = B9 걸음 몫 · `Doc_Import._ctx` 가 부름) · `M02_Sangeun_Formula` · `Sangeun_Doc.patched`(가져온 식 SK 고침 · B09 resolve 가 부름) · `/sangeun/calc` 길 · 머리 띠 칸(856-2 뒤 2-E2) - `Doc_Copy.doc_of` 변환 길에도 855 L1 이름표(`md.tag` — 빌더와 같게) · 받기로 들어온 L1 뒤 test_802_4a ③ 깨짐(값 사본 줄 변환 문서에 이름표 없음) 고침 - 시험: 790_2 옛 저장본 = 금액만 · 793_2 시트 덮개 단언 뺌 · 793_3b 시트 M01바뀜 시험 지움(시트 덧칸 걷음) - 여덟 군 남은 시험(715_3 · 715_store · 715_doc · 717_4 · 742_1 · 806_1) = 살아 있는 길(패치 검사 · 층 복사 · 문서 꼴 · SK 고르기 · SC 수량 · 일위대가 보기)을 봄 → 남김 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Copy.py | 2 +- M02_MasterTemplete/M02_Sangeun_Calc.py | 114 ++-------------- M02_MasterTemplete/M02_Sangeun_Const.py | 126 +----------------- M02_MasterTemplete/M02_Sangeun_Views.py | 83 ------------ resources/tester/test_790_2_sangeun_const.py | 5 +- .../tester/test_793_2_sangeun_imported.py | 2 - resources/tester/test_793_3b_import_screen.py | 17 --- 7 files changed, 22 insertions(+), 327 deletions(-) delete mode 100644 M02_MasterTemplete/M02_Sangeun_Views.py diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index 2e0a2a2b7..cb27f2b10 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -107,7 +107,7 @@ def doc_of(whole: Any, key: str) -> dict | None: if live and (_live(key) is None or skc._fp(_live(key)) == skc._fp(prices.to_json(row))): return cp.deepcopy(live) try: - return cv.convert(whole, row)[0] + return md.tag(cv.convert(whole, row)[0], row) # 855 L1 이름표 = 빌더와 같게 except _ERR: return cp.deepcopy(live) if live else None diff --git a/M02_MasterTemplete/M02_Sangeun_Calc.py b/M02_MasterTemplete/M02_Sangeun_Calc.py index 16f91a12f..42d0b5687 100644 --- a/M02_MasterTemplete/M02_Sangeun_Calc.py +++ b/M02_MasterTemplete/M02_Sangeun_Calc.py @@ -1,27 +1,15 @@ -"""M02 단가산출(SK) 셈 — 바탕 사슬 → 고친 줄 → M01 엔진 한 벌(PLAN 715-1b · 715-2). +"""M02 단가산출(SK) 셈 — 수식 사본 문서 셈 한 길(PLAN 855 2-C1 · 715-1b · 715-2). -셈 = ① 바탕(M01 로직 · 바탕 SK 의 고친 줄 · 없음) ② `M02_Sangeun_Doc.patched` ③ 더한줄 참조 · -(SK · SC) · 고정 줄 = 먼저 셈한 1 단위 노 · 재 · 경 → `값묶음` -④ M01 색인 위에 고친 줄을 SK 키로 얹어 -(M01 시험 계산 `_swap` 과 같은 꼴 · 메모리만 · 정본 · 캐시 안 고침) `labor.run_line` — 자동값 · -켜쌓기율 · 고름 · % 덧줄을 엔진이 다시 셈. 1 단위 = 기준 ÷ 배(바탕 로직 결과단위 앞 수). +셈(`run`) = 수식 사본(`M02_Doc_Sk.copy_of` — 따로 = 저장 문서 · 파생 = 기초 문서 + 줄 규칙)을 문서 계산기로 · +기준 · 1 단위 · 줄 · 비목 · 끝수 = 문서 답 · 옛 엔진 안 돎 · 수식 사본 없음(바탕 참조) · 옛 칸 고침(덮개 · +뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` · +`resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀). 계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만). -저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `원값` · `바탕판` 적음. -둘째 기초(727-2 · 더한줄 로직) = 세부 덮개 · 뺀줄 있으면 고친 기초 줄을 엔진으로 셈한 `값묶음` 줄 -(B09 굳힘도 그 값) · 화면 셈 길(`calc_doc`) = 그 줄 덧칸 `펼침`(세부 줄 × 수량) · `뺀세부` · -`바탕판` · -`꼬리표`(원문번호) · 답 `꼬리표` = 바탕 원문번호. +저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `바탕판` · `M01판` 적음. SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` · -「식」 · 빈 단위 = 앞 수 뗀 바탕 단위 = 옛 셈) · -다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} · 없으면 셈 막음(까닭) · -화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`). -바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(M01 기초처럼 재료비에 듦 · 「별도계상」 고른 줄만 밖) · -일위대가 덮개 줄(`line` · `M02_Labor_Patch.run`)은 일위대가 기본(222-1 · 162-1) 그대로. -보기 넷 한 답(750-1) = 화면 셈 길 답에 `글`(읽는 식) · `중간`(`M02_Sangeun_Views`) · 일위대가 줄 -모달 = 문서 `줄모드` true → `line`(일위대가 그 줄 셈과 같은 값). -율 더한줄(778-4 · `_rated`) = 엔진 한 번 돈 줄로 밑(`M02_Labor_Fixed.rate_base` · 짝 화면 -`M02_MasterTemplete_Labor_Calc.ts` `rateBase` · 거울 시험 `test_778_4_rate_line.py`) → 율 줄 `값묶음` = -{비목: 밑 ÷ 100} → 엔진 다시(율 줄 없는 문서 = 한 번만 · 값 그대로) · 줄 덧칸 `율` · `규격`. +「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} · +없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`). +바탕 재료(747-1) = 별도계상 빈 칸 = 직접계산(「별도계상」 고른 줄만 문서 금액 줄 `합밖`). """ from __future__ import annotations @@ -266,46 +254,6 @@ def tag_of(whole: Any, code: str) -> str: return code -def _detail(one: dict, at: int, whole: Any) -> dict[str, Any]: - """둘째 기초 세부 줄(화면) — 수량 · 금액 · 비목 = 세부 × 더한줄 수량(상자 합 몫) · `원문` = - 그 기초 1 기준단위 몫(M01 원문 품 · 744-1 화면 품 칸) · cid `add:#k/세부 cid` · - `바탕값` = 덮기 전 1 기준단위 품 · 단가 · `뺀세부` = 뺀 줄 이름.""" - sub = sub_run(one, whole) - plain = sub_run(one, whole, False) if sd.sub_patched(one) else sub - was = dict(zip(plain["정체"], plain.get("줄") or [])) - covers, times = one.get("덮개") or {}, Decimal(str(one.get("수량") or 0)) - rows = [] - for cid, line in zip(sub["정체"], sub.get("줄") or []): - mine = covers.get(cid) or {} - scaled = { - k: None if line.get(k) is None else Decimal(str(line[k])) * times - for k in ("수량", "금액") - } - parts = { - k: None if v is None else Decimal(str(v)) * times - for k, v in (line.get("비목") or {}).items() - } - rows.append( - { - **line, - **scaled, - "비목": parts, - "cid": f"add:#{at}/{cid}", - "원문": {k: line.get(k) for k in ("수량", "금액", "비목")}, - "바탕값": _was(was[cid]) if cid in was else None, - **({"덮개": [k for k in sd.COVER_KEYS if k in mine]} if mine else {}), - **({"원값": mine["원값"]} if "원값" in mine else {}), - } - ) - gone = [ - {"cid": f"add:#{at}/{c}", "이름": was[c].get("이름") or ""} - for c in one.get("뺀줄") or [] - if c in was - ] - tag = tag_of(whole, str(one["로직"])) - return {"펼침": rows, "뺀세부": gone, "바탕판": sub["바탕판"], "꼬리표": tag} - - def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None: """더한줄 참조 · 고정 줄 `값묶음` = 1 단위 노 · 재 · 경 — 못 셈 줄 = `_gap`(나머지 셈 계속).""" for at, item in enumerate(row["호표"]): @@ -478,12 +426,6 @@ def _rated(row: dict, eng: list, ids: list, marks: dict, stack: Any = None) -> l return lost -def _rate_text(rate: dict) -> str: - """율 줄 규격 — 「인력의 %」 · 목록 = 「줄 n 개의 %」.""" - basis = rate["기준"] - return f"줄 {len(basis)} 개의 %" if isinstance(basis, list) else f"{basis}의 %" - - def unit(doc: dict, whole: Any, expand: Any, trail: tuple) -> dict[str, Any]: """펼침(`Expand`) 한 칸 — `{이름, 단위, 기준(1 단위), 까닭, 줄, 짝잃음}` · 못 셈 = 까닭.""" head = {"이름": doc.get("이름"), "단위": doc.get("단위")} @@ -561,7 +503,8 @@ def _check_refs(doc: dict, here_: refs.Here) -> None: def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: - """저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `원값` · `바탕판`.""" + """저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `바탕판` · `M01판` · + 옛 칸 덮개 · 둘째 기초 `원값` 적기는 걷음(옛 칸 셈 은퇴 · 855 2-C1).""" raw, job = doc, doc.get(skc.JOB) if isinstance(doc, dict) else None # 수식 사본(802-4a) whole = skc.over(doc := skc.settle(doc, True), skc.whole_()) # 사본(795-1) · 내 기계(821-1) try: @@ -573,45 +516,17 @@ def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"] for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 one.setdefault("처음수량", one["수량"]) - if out["덮개"]: - bare = run({**out, "덮개": {}}, whole) # 덮기 전 값 = 원값(그때 M01) - was = {x["cid"]: x for x in bare.get("줄") or []} - for cid, one in out["덮개"].items(): - if cid in was: - one["원값"] = _was(was[cid]) out |= const.stamp(base["줄"], out) # 바탕판 · M01판(790-2) · 식 칸 엔진 식(792-1) ratio_of(out, base["줄"], whole) # 단위 못 바꿈(계수 없음) = 저장 막음(728-2) - _stamp_adds(out, base, whole) out = dsk.settle(out, whole, job, raw) except sd.DocError as e: raise _fail(e) from e return out -def _stamp_adds(out: dict, base: dict, whole: Any) -> None: - """둘째 기초 저장 칸(727-2) — `바탕판` = 그 기초 지문 · 세부 덮개 `원값` = 덮기 전 - 1 기준단위 값.""" - filled, _ = _fill(out, whole, {**base["입력값"], **out["입력값"]}) - for one, mine in zip(filled["더한줄"], out["더한줄"]): - if one.get("종류") != "로직": - continue - plain = sub_run(one, whole, False) - if plain["바탕판"]: - mine["바탕판"] = plain["바탕판"] - was = dict(zip(plain["정체"], plain.get("줄") or [])) - for cid, cover in (mine.get("덮개") or {}).items(): - if cid in was: - cover["원값"] = _was(was[cid]) - - -def _was(line: dict) -> dict[str, Any]: - keep = {"qty": line.get("율", line.get("수량")), "단가": line.get("단가")} - return {k: sd.plain(Decimal(str(v))) for k, v in keep.items() if v is not None} - - def calc_doc(doc: Any, given: dict | None = None, seen: bool = True) -> dict[str, Any]: """셈 길(`M02_Sangeun_Router`) — 지금 층 문서 · 저장 전 화면 문서 · 틀림 400 · 순환 422 · - `seen` = 보기 덧칸(`글` · `중간`) 지음.""" + `seen` = 옛 보기 덧칸 자리(856-1 뒤 안 지음 · 길 꼴만 · 2-E2 에서 걷음).""" from M01_MasterData import M01_MasterData_Store as m01 with m01.cache.steady(): # 한 셈 동안 M01 파일 자국 한 번(792-2) @@ -620,8 +535,7 @@ def calc_doc(doc: Any, given: dict | None = None, seen: bool = True) -> dict[str clean = sd.clean(doc, None, whole) _check_refs(clean, refs.here()) # 저장 전 문서도 위 층만 · 있는 문서 · 순환 422 me = refs.ref_id({"층": refs.here()[0], "주인": refs.here()[1], "키": clean["키"]}) - line = isinstance(doc, dict) and doc.get("줄모드") is True # 일위대가 줄 모달(750-1) - got = run(clean, whole, given, trail=(me,), detail=True, line=line, seen=seen) + got = run(clean, whole, given, trail=(me,)) except sd.DocError as e: raise _fail(e) from e - return skc.mark(const.answer(got, clean, doc, given, (me,)), clean) # 790-2 · 795-1 + return skc.mark(const.answer(got, clean), clean) # 795-1 diff --git a/M02_MasterTemplete/M02_Sangeun_Const.py b/M02_MasterTemplete/M02_Sangeun_Const.py index 1ea8c1a7c..c9f02132e 100644 --- a/M02_MasterTemplete/M02_Sangeun_Const.py +++ b/M02_MasterTemplete/M02_Sangeun_Const.py @@ -1,4 +1,4 @@ -"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래 · 시트 답. +"""M02 단가산출(SK) 숫자 넓힘(PLAN 790-2 · 요구서_652 · _분석_650-H3 E2) — 새 덮개 갈래. 시험 `resources/tester/test_790_2_sangeun_const.py` · 799-2 — 화면 짝(`Const_Model.ts` · 시트 탭)은 걷음, 서버만 남음. @@ -15,8 +15,7 @@ 셈 = `M02_Sangeun_Doc.patched` 첫머리 `formulas`(바탕 줄 식을 바꾼 사본) → 모든 셈 길(화면 · 저장 원값 · B09 · 펼침 겹침) 한 벌 · 펼침(`M02_Library_Flat._read`) = 새 덮개 SK 는 안 펼침 (옛 참조 그대로) · [초기화](`M02_Library_Flat.reset`) = `restore` 전체. -화면 셈 답(`answer`) 덧칸 `원래` {노무비, 재료비, 경비, 계}(1 단위) + `시트` {자리, 글줄, 짝잃음} · -M01 원래 = 같은 옵션 · 덮개 · 뺀줄 · 더한줄 · 새 덮개 없는 셈. +화면 셈 답(`answer`) = 문서 셈 답 + 머리(옛 `원래` · `시트` 덧칸은 855 2-C1 에서 걷음 · 상세 몸 856-1). """ from __future__ import annotations @@ -25,7 +24,6 @@ import functools import hashlib import json import re -from decimal import Decimal from typing import Any from M02_MasterTemplete import M02_Sangeun_Doc as sd @@ -139,24 +137,6 @@ def _swapped(row: dict, doc: dict) -> dict: return out -def lost(row: dict, doc: dict) -> list[dict]: - """짝 잃은 새 덮개 — 바탕에 없는 자리 · 없는 n 번째.""" - where, out = places(row), [] - for name, kind in (("상수덮개", "num"), ("표값덮개", "find")): - for spot, cover in (doc.get(name) or {}).items(): - if spot not in where: - out.append({"cid": spot, "까닭": f"{name} — 바탕에 없는 줄"}) - continue - part, at = where[spot] - have = len(scan(str((row[part][at] or {}).get(FIELD[part])))[kind]) - out += [ - {"cid": spot, "까닭": f"{name} — {int(n) + 1} 번째 없음"} - for n in cover - if int(n) >= have - ] - return out - - def no_flat(doc: Any) -> None: """펼침 막음 — 상수 · 표값 덮개 SK(펼친 줄에 못 옮김 · 옛 참조 그대로 = 값 그대로).""" keys = ("상수덮개", "표값덮개", eqm.KEY) # 수식 고침(796-2b) @@ -313,105 +293,9 @@ def kinds(doc: dict, spot: str) -> list[str]: # ── 화면 셈 답 ──────────────────────────────────────────────────────── -def answer(got: dict, clean: dict, raw: Any, given: dict | None, trail: tuple) -> dict: - """`M02_Sangeun_Calc.calc_doc` 답 — 옛 답 + `원래` · `시트`.""" +def answer(got: dict, clean: dict) -> dict: + """`M02_Sangeun_Calc.calc_doc` 답 — 셈 답(1 단위 몫) + 머리 · 가져온 식 원본 보기(옛 `원래` · `시트` 걷음 · 855 2-C1).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc out = {**calc.per_unit(got, clean), "머리": calc.head_of(clean)} - return calc.labor._json(imp.more(out | sheet(out, clean, raw, given, trail), clean)) - - -def _bare(doc: dict) -> dict: - out = {k: v for k, v in doc.items() if k not in (*NEW, *fx.FIELDS, "뺀더한줄", eqm.KEY)} - return out | {"덮개": {}, "뺀줄": [], "더한줄": []} - - -def _mids(whole: Any, key: str, row: dict, values: dict) -> tuple[dict, dict]: - """(중간 값, 엔진 입력) — 시험 계산과 같은 길(`M02_Sangeun_Views.text_of`) · 못 셈 = 빈.""" - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - over = calc._Over(whole, key, {**row, "키": key}) - m01 = calc.labor.m01 - auto = {k: v for k, v in m01.mau.values(over, over.logic(key)).items() if v is not None} - given = {**auto, **m01._dec(values or {})} - try: - mid = calc.labor.mcut.engine(over, key, m01.cm.mf.run(over, key, given)).get("중간") or {} - except Exception: # noqa: BLE001 — 엔진 FormulaError · 셈 틀림 = 값 없음 - return {}, given - return mid, given - - -def _finds(whole: Any, text: str, env: dict) -> list[dict]: - from M02_MasterTemplete import M02_Labor_Doc as labor - - mf, out = labor.m01.cm.mf, [] - for n, (a, b) in enumerate(scan(text)["find"]): - try: - value = mf.evaluate(mf.parse(text[a:b]), dict(env), whole) - except Exception: # noqa: BLE001 - value = None - out.append({"n": n, "글": text[a:b], "값": value}) - return out - - -def sheet(ans: dict, clean: dict, raw: Any, given: dict | None, trail: tuple) -> dict: - """`원래` · `시트` — 자리마다 원래 · 지금 · 덮개 갈래 · 까닭 · M01바뀜 · 상수 · 표값.""" - from M02_MasterTemplete import M02_Labor_Ref as refs - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - whole = calc.skc.over(clean, calc.labor.m01.loaded()[1]) # 사본(795-1) — 중간 · 표값도 - try: - base = calc._base_of(clean, whole, refs.read_ref, trail)["줄"] - bare = calc.per_unit(calc.run(_bare(clean), whole, given, trail=trail), clean) - except sd.DocError: - return {"원래": None, "시트": {"자리": {}, "글줄": clean.get("글줄") or [], "짝잃음": []}} - was = {x["cid"]: x for x in bare.get("줄") or [] if x.get("cid")} - now = {x["cid"]: x for x in ans.get("줄") or [] if x.get("cid")} - key = str(clean.get("키") or "SK-000000") - values = {**(clean.get("입력값") or {}), **(given or {})} - mids0, env0 = _mids(whole, key, base, values) - mids1, _ = _mids(whole, key, formulas(base, clean), values) - stamps = (raw.get("M01판") if isinstance(raw, dict) else None) or {} - stamps = {} if imp.is_imported(clean) else stamps # 가져온 식 = M01 짝 없음(793-3b) - fresh = stamp(base)["M01판"] - why = clean.get("까닭") or {} - nums, finds = clean.get("상수덮개") or {}, clean.get("표값덮개") or {} - spots: dict[str, dict] = {} - for spot, (part, at) in places(base).items(): - line = base[part][at] - text = str(line.get(FIELD[part])) - consts = [ - {"n": n, "값": nums.get(spot, {}).get(str(n), v), "원값": v} - for n, v in enumerate(Decimal(text[a:b]) for a, b in scan(text)["num"]) - ] - tables = [ - {**t, "원값": t["값"], "값": finds.get(spot, {}).get(str(t["n"]), t["값"])} - for t in _finds(whole, text, {**env0, **mids0}) - ] - if part == "중간": - name = str(line.get("이름")) - old, cur = mids0.get(name), mids1.get(name) - else: - old, cur = (was.get(spot) or {}).get("금액"), (now.get(spot) or {}).get("금액") - spots[spot] = { - "갈래": part, - "이름": line.get("이름") or "", - "식": text, - "상수": consts, - "표값": tables, - "원래": old, - "지금": cur, - "덮개": kinds(clean, spot), - "까닭": why.get(spot), - "M01바뀜": spot in stamps and stamps[spot] != fresh.get(spot), - } - for cid, line in now.items(): - if _ADD.match(cid) and cid not in spots: - spots[cid] = {"갈래": "더한줄", "이름": line.get("이름") or "", "원래": None} - spots[cid] |= {"지금": line.get("금액"), "덮개": [], "까닭": why.get(cid)} - gone = lost(base, clean) + [ - {"cid": s, "까닭": "M01 바뀜 — 바탕에 없는 줄"} for s in stamps if s not in fresh - ] - gone += fx.sheet_more(spots, base, clean, mids1) # 식 칸(792-1) 덧칸 · 변수 줄 · 틀린 식 - top = {"글줄": clean.get("글줄") or [], "짝잃음": gone, "이름표": fx.name_table(base, clean)} - return {"원래": bare.get("기준"), "시트": {"자리": spots, **top}} + return calc.labor._json(imp.more(out, clean)) diff --git a/M02_MasterTemplete/M02_Sangeun_Views.py b/M02_MasterTemplete/M02_Sangeun_Views.py deleted file mode 100644 index 04c9adb90..000000000 --- a/M02_MasterTemplete/M02_Sangeun_Views.py +++ /dev/null @@ -1,83 +0,0 @@ -"""M02 단가산출(SK) 보기 넷 = 셈 답 하나(PLAN 750-1 · 요구 588-1) — 화면 셈 길 답 덧칸. - -- `글` = 읽는 식(M01 `/text` 와 같은 꼴 · `master_text.lines` + `master_sheet_line.annotate`) · - SK 고친 줄(`_Over`) · 같은 입력(자동값 + 입력값) · 같은 고름(`choosing`) 위에서 지음. - 줄마다 `cid` = SK 줄 cid(`annotate` 와 같은 차례 — 호표 줄 × `_shares` 비목 · 뒤 덧줄). - 금액 · 소계 · 계 = SK `줄` · `기준` 그대로(`finish` — 별도계상 뺌 · 켜쌓기율 · 단위 환산 ÷배 · - 못 셈 줄 까닭) · 식 글(`글` · `이름글`)은 바탕 단위 셈 그대로 + 머리 `나눔`(배 ≠ 1). -- `중간` = 시험 계산 중간값(수 · 글만) — 시험 계산 = {lines: `줄`, sums: `기준`, middle: `중간`}. -계산 자리 = 서버 단독(CLAUDE.md 5장 ③) · 화면은 그리기만. -""" - -from __future__ import annotations - -from decimal import Decimal -from typing import Any - -from M02_MasterTemplete import M02_Labor_Doc as labor - -mf = labor.m01.cm.mf -import master_sheet_line as msl # noqa: E402 — scripts 길은 `m01` 이 둠 -import master_text as mtx # noqa: E402 - -_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) - - -def text_of(over: Any, key: str, values: dict, picks: Any, ids: list, eng: list) -> dict: - """`{글, 중간}` — `eng` = `run_line` 줄(별도계상 빼기 전 · 차례 맞춤용) · 못 지음 = 까닭.""" - row = over.logic(key) - auto = {k: v for k, v in labor.m01.mau.values(over, row).items() if v is not None} - given = {**auto, **labor.m01._dec(values or {})} - try: - with mf.mp.choosing(picks or None): - text = msl.annotate(over, key, given, mtx.lines(over, key, given)) - mid = labor.mcut.engine(over, key, mf.run(over, key, given)).get("중간") or {} # 751-3 - except _ERRORS as e: - return {"글": {"ok": False, "reason": str(e) or type(e).__name__}, "중간": {}} - if text.get("ok") and "groups" in text and "결과" not in row: - _tag(row, ids, eng, text) - keep = (Decimal, int, float, str, bool) - return {"글": text, "중간": {k: v for k, v in mid.items() if isinstance(v, keep)}} - - -def _tag(row: dict, ids: list, eng: list, text: dict) -> None: - """글 줄마다 `cid` — `annotate` 와 같은 차례(호표 줄 × 몫 비목 → 덧줄).""" - slots = {g["비목"]: iter(g["줄"]) for g in text["groups"]} - items, adds = row.get("호표") or [], row.get("덧줄") or [] - for n, line in enumerate(eng): - if n < len(items): - parts = [p for p, _ in mtx._shares(line)] if line.get("비목") else [] - else: - parts = [adds[n - len(items)]["비목"]] if n - len(items) < len(adds) else [] - for part in parts: - one = next(slots.get(part, iter(())), None) - if one is not None and n < len(ids): - one["cid"] = ids[n] - - -def finish(ans: dict) -> dict: - """화면 답(`per_unit` 뒤) — 글 금액 · 소계 · 계 = SK 줄 · 기준 · SK 에 없는 줄(별도계상) 뺌.""" - text = ans.get("글") or {} - base = ans.get("기준") - if not text.get("ok") or "groups" not in text or not base: - return ans - sk = {x["cid"]: x for x in ans.get("줄") or [] if x.get("cid")} - groups = [] - for g in text["groups"]: - kept = [] - for one in g["줄"]: - line = sk.get(one.get("cid")) - if line is None and one.get("cid"): - continue # SK 에서 빠진 줄(별도계상) - if line is not None: - parts = line.get("비목") or {} - money = parts.get(g["비목"]) if len(parts) > 1 else line.get("금액") - one = {**one, "금액": money} - if line.get("까닭"): - one["까닭"] = line["까닭"] - kept.append(one) - if kept: - groups.append({**g, "줄": kept, "소계": base.get(g["비목"])}) - times = ans.get("화면배") - head = {"나눔": times} if times not in (None, 1) else {} - return {**ans, "글": {**text, "groups": groups, "계": base.get("계"), **head}} diff --git a/resources/tester/test_790_2_sangeun_const.py b/resources/tester/test_790_2_sangeun_const.py index 23aeea8e1..46c80ad6f 100644 --- a/resources/tester/test_790_2_sangeun_const.py +++ b/resources/tester/test_790_2_sangeun_const.py @@ -144,7 +144,6 @@ def _calc(folder, doc, given=None): def test_옛_저장본_셈답(world): - """새 칸 없는 옛 저장본(M01판 없음) = 금액 그대로 · M01바뀜 없음.""" + """새 칸 없는 옛 저장본(M01판 없음) = 금액 그대로(옛 `원래` · `시트` 덧칸은 855 2-C1 에서 걷음).""" got = _calc(world["personal"], {**_doc(FORM, F211), "바탕판": "0" * 16}) - assert got["기준"]["계"] == 51419 == got["원래"]["계"] - assert not any(x.get("M01바뀜") for x in got["시트"]["자리"].values()) + assert got["기준"]["계"] == 51419 diff --git a/resources/tester/test_793_2_sangeun_imported.py b/resources/tester/test_793_2_sangeun_imported.py index 8e55d349e..d4efcf548 100644 --- a/resources/tester/test_793_2_sangeun_imported.py +++ b/resources/tester/test_793_2_sangeun_imported.py @@ -176,8 +176,6 @@ def test_셈_답_원래_엑셀_원본_글(world): got = calc.calc_doc(doc) assert got["원래"] == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652} assert got["기준"]["계"] > 45652 - spot = got["시트"]["자리"]["labor:형틀목공#0"] - assert spot["덮개"] == ["품"] and spot["까닭"] == "현장 품" view = got[imp.KEY] assert view["단가기준"] == "엑셀" and view["파일"] == "봉화.xlsx" and view["행"] == [2909, 2943] lines = view["글줄"] diff --git a/resources/tester/test_793_3b_import_screen.py b/resources/tester/test_793_3b_import_screen.py index c6f08a4d7..4415f5128 100644 --- a/resources/tester/test_793_3b_import_screen.py +++ b/resources/tester/test_793_3b_import_screen.py @@ -138,20 +138,3 @@ def test_부품상자만_700줄_공용_안_고침(): assert "#" not in "".join(re.findall(r"color:\s*[^;]+", text)), name for name in ("Labor_Rows", "Labor_SkEdit", "Sangeun_Detail", "Sangeun_Tabs"): assert "Hopyo_Imported" not in _src(name), name # 공용 쪽은 새 모달을 모름 - - -def test_가져온_식_시트_M01바뀜_없음(client): - """가져온 식 SK 는 M01 짝이 없음 — 저장 M01판이 있어도 시트 「M01 바뀜」 · 짝잃음 안 띄움.""" - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - client.app.include_router(sangeun_router.router) - assert _post(client).status_code == 200 - name = _open(client).json()["이름"] - folder = layers.personal_dir(7, 42) - with store.at(folder): - doc = store.read("sangeun", name)["문서"] - spots = list(calc.calc_doc(doc)["시트"]["자리"]) - ans = calc.calc_doc({**doc, "M01판": {k: "다름" for k in [*spots, "x"]}}) - sheet = ans["시트"] - assert sheet["자리"] and not any(x["M01바뀜"] for x in sheet["자리"].values()) - assert sheet["짝잃음"] == []