From 157240a7e50b5e770637f886b4288d7248d25d96 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 19:46:45 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-2-C2):=20=EA=B0=80=EC=A0=B8?= =?UTF-8?q?=EC=98=A8=20=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EC=A7=93=EA=B8=B0?= =?UTF-8?q?=20=3D=20=EA=B0=80=EC=A0=B8=EC=98=A8=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A4=84=20=EC=A7=81=EC=A0=91=20=E2=80=94=20=EC=98=9B=20?= =?UTF-8?q?=EC=97=94=EC=A7=84=20=EC=85=88(Sangeun=5FCalc.run)=20=EC=95=88?= =?UTF-8?q?=20=EB=8F=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Doc_Import._ctx: 가져온 로직 줄(row_of · 엑셀 단가 기준) + 수식 고침(eqm.on) + SK 고침(sd.patched · 더한줄 입력 채움 · 고정 줄 값) → (색인, 키, 입력, {정체}) · 엔진 run_line 안 부름 · 안쪽 산근(형제 SK) 줄 값 = 0 자리값 — `_attach` 가 형제 SK 연결 + 엑셀 값으로 늘 갈음(옛 길은 형제 SK 를 옛 엔진으로 셈해 넣고 버림) · 옛 셈 길(`_old_ctx`)은 값이 엔진 답인 더한줄(형제 SK · 율 · 세부 고친 둘째 기초)을 단 SK 만 — 2-C1 · 2-C5 몫 - 옛 식 파서(mf.parse · 연산 표) 그대로 · 검산(Sangeun_Imported._run · check)은 2-C3 몫이라 안 고침 · 가져온 값 층 · 초기화 · Q · 모양은 색인에 안 기댐(고칠 곳 0) - 전후 대조(불러오기 블록 전수 3,241 — EST 1,849 · STC 371 · 엑셀 1,021): 지은 문서 지문 다름 0 · 엑셀 · 우리 두 판 셈 답(계 · 비목 · 줄) 다름 0 · 예외 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import.py | 49 +++++++++++++++++++++++++--- 1 file changed, 45 insertions(+), 4 deletions(-) diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index 0653bd54e..2b558fa89 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -70,13 +70,54 @@ def _index(sk: dict, master: Any = None, doc: Any = None) -> Any: return master or imp._whole() -# ── 엑셀 단가 그대로 엔진 줄(옛 셈 길 · SK 고침 얹은 것) ─────────────────── +# ── 엑셀 단가 그대로 고친 줄(가져온 로직 줄 + SK 고침 · 엔진 셈 없음) ───────── +def _engine_adds(doc: dict) -> bool: + """값을 엔진 셈으로만 얻는 더한줄(형제 SK · 율 · 세부 고친 둘째 기초)이 있음 — 옛 길(`_old_ctx`).""" + return any( + one.get("참조") or sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or [] + ) + + def _ctx(sk: dict, whole: Any) -> tuple: - """엑셀 단가 기준 고친 줄 — 옛 셈 길(`OLD`)로 돌려 엔진에 넣은 (색인, 키, 입력, 답, 재료).""" + """엑셀 단가 기준 고친 줄(855 2-C2) — 가져온 로직 줄(`row_of`) + 수식 고침 · SK 고침(`sd.patched`) · + 더한줄 고정 값(`fixed.line`) → (색인, 키, 입력, {정체}, None) · 옛 엔진 안 돎. + 안쪽 산근(형제 SK) 줄 값 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음). + `_engine_adds` 인 SK 만 옛 셈 길(그 더한줄 값이 엔진 답 — 2-C1 · 2-C5 몫).""" + from M02_MasterTemplete import M02_Sangeun_Calc as calc + from M02_MasterTemplete import M02_Sangeun_Copy as skc + from M02_MasterTemplete import M02_Sangeun_Equation as eqm + + raw = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}} + doc = sd.clean(raw, None, whole) + if _engine_adds(doc): + return _old_ctx(raw, whole) + w = skc.over(doc, whole) + base = sd.empty_row(doc) + base = {**base, "호표": [dict(x) for x in base.get("호표") or []]} + for item in base["호표"]: + if "참조" in item and item.get("값묶음") is None: + item["값묶음"] = dict.fromkeys(imp.COSTS, Decimal(0)) + base, _ = eqm.on(base, doc, skc.over(doc, w)) + filled, lack = calc._fill(doc, w, dict(doc.get("입력값") or {})) + got = sd.patched(base, filled, {}, {}) + items = got["줄"]["호표"] + calc._direct(got["자재표시"], items) + for at, cid in enumerate(got["정체"][: len(items)]): + if cid.startswith("add:#") and int(cid[5:]) in lack: + items[at] = calc._gap(items[at], lack[int(cid[5:])]) + row = {**got["줄"], "호표": [dict(x) for x in items]} + calc._bundles(row, w, None, ()) # 더한줄 고정 줄 = 줄 값 · 이은 노임 · 자재(엔진 아님) + key = str(doc.get("키") or "SK-000000") + names = {str(i.get("이름")) for i in row.get("입력") or []} + values = {k: v for k, v in (doc.get("입력값") or {}).items() if k in names} + return _Row(w, key, {**row, "키": key}), key, values, {"정체": got["정체"]}, None + + +def _old_ctx(raw: dict, whole: Any) -> tuple: + """옛 셈 길(`OLD`)로 돌려 엔진에 넣은 (색인, 키, 입력, 답, 재료) — `_engine_adds` SK 만.""" from M02_MasterTemplete import M02_Doc_Sk as dsk from M02_MasterTemplete import M02_Sangeun_Calc as calc - raw = {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "엑셀"}} box: list = [] token = dsk.OLD.set(True) try: @@ -407,7 +448,7 @@ def _numbers(doc: dict, keep: dict) -> None: def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: - """가져온 식 SK → 수식 문서(키 = SK 키) — `ctx` = 엑셀 단가 기준 옛 셈 길이 엔진에 넣은 것.""" + """가져온 식 SK → 수식 문서(키 = SK 키) — `ctx` = 엑셀 단가 기준 고친 줄(`_ctx` · 옛 SK 셈 길이 넘긴 것도 같은 꼴).""" meta = sk[imp.KEY] if ctx is None: ctx = _ctx(sk, whole or imp._whole())