From ec761d09489e527915a7ef15ad302e33d6b43421 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 03:44:45 +0900 Subject: [PATCH 1/2] =?UTF-8?q?refactor(857-3b):=20=EB=B6=88=EB=9F=AC?= =?UTF-8?q?=EC=98=A8=20=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20=EC=A0=95?= =?UTF-8?q?=EB=B3=B8=20=3D=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20?= =?UTF-8?q?=E2=80=94=20=EC=A0=80=EC=9E=A5=EB=B3=B8=20=EA=B0=80=EC=A0=B8?= =?UTF-8?q?=EC=98=A8.=EB=A1=9C=EC=A7=81=20=EA=B1=B7=EC=9D=8C=20=C2=B7=20?= =?UTF-8?q?=EA=B3=A0=EC=B9=A8=20=EA=B8=B8=20=3D=20=EB=AC=B8=EC=84=9C=20?= =?UTF-8?q?=EC=97=B0=EA=B2=B0=20=C2=B7=20=EC=98=9B=20=EA=BC=B4=20=3D=20?= =?UTF-8?q?=EA=B9=8C=EB=8B=AD=20=ED=95=98=EB=82=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 저장 꼴: SK `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 원본, 단가기준, 검산, 연결?} · 가져온 줄(옛 로직 줄 꼴) 안 둠 · 다시 열기 = 저장 문서(Doc_Import.derive) · 고침 = 수식 따로 사본 · [초기화] = 가져온.문서 - 짓기: 불러올 때 한 번(Doc_Import.build · San_ToDoc · 줄 검사 = 문서 파서) · 검산 = 불러올 때 한 번(check_row · 옛 변환기 안 부름) · 뒤 저장 = 저장 파일 검산(화면 값 안 받음) - 고침 길: 이음 고침 = 그 가져온 줄 값 변수 연결(자리 = 호표:i · 엑셀 값 기억) · 소요량 고름 = 문서 그 수 → 표 연결 변수 · 풂 = 수 되돌림(자리 = 문서 머리 가져온.자리) · [저장] 처음 = 고친 미리 보기 문서 위에 안쪽 산근 참조 · 내 기계만 얹음(FromHopyo._onto) · 재료 고름 판 = 문서 머리 재료 - 둘레: 형제 SK 참조 = 문서 연결(Labor_Ref refs_in · _move_doc → imp.refs_of · move_refs) · 값 사본 닿을 것 = 문서 연결 + 기계 판정 키(Sangeun_Copy.stamp · reach_of) · B09 굳힌 사본 = 가져온 늘 실음 · 단가 묶음에 사본 요소(Item_Sangeun) · Doc_Sk old_only 가져온 식도 · frozen 가져온 식 빼고 · old_fp 옛 꼴만 · 우리 단가 색인 = 받은 색인 위(B09 사본 단가 전파) - 옛 꼴 저장본(가져온.로직) = 읽지 않음 · 지우지 않음 · 셈 · 검산 · 고침 = 까닭 「옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장」 · 가져온 식 옛 칸 고침(덮개 · 더한줄 · 식 칸) = 못 셈(2-C1 과 같게) - 857-3a 더한줄 갈래(San_ToDoc 요소 · 로직 부름) 걷음 · test_857_3a_import_adds 지움(가져온 식 옛 칸 = 죽은 길 · 대신 test_793_2 옛_칸_고침_못_셈 · 옛_꼴_저장본_까닭_하나) - 화면: 가져온 식 판정 = 문서 | 옛 로직 · 옛 꼴 = 이음 · 소요량 안 부름(Hopyo_Imported_Model · Hopyo_Imported · Sangeun_Origin) - 뜻한 바뀜: 불러온 문서 다듬기가 글줄 이름으로(저장 길에서도 지은 「율」 → 엑셀 글 머리 · 704 · test_809_1 · 812_3) · golden_855_b09 daega_inputs 다시 뜸 = 가져온 식 단가산출 = 수식 문서만 · 가져온.로직 없음 → 옛 굳힘 ROW 가 줄을 못 지음(B09 대가 블록 가져온 식 줄 0 · 금액 calc_user · 수요 · 산근 그대로 · B9-5 문서 셈 줄 뒤 다시 확인) · test_792_3 실무 가져온 식 대가 = 금액만(ROW 번지 · 단계 = 옛 굳힘 꼴) - 시험 고침: 옛 꼴 SK 손으로 짓던 견본 → imp.new_doc(793_2 · 797_1 · 797_2 · 802_4b1 · 809_1 · 810_2 · 857 도우미) · 로직 줄 읽던 단언 → 문서 변수 · 머리(793_3b · 821_4 · 827_3 · 835_1) · 옛 엔진 대조 · 옛 식 칸 가져온 식 길 걷음(802_4b1 · 796_2b) - 지킴: 857 골든 전수 같음(블록 3,241 두 판 · 검산 · 이음) · 812_1 전수 31 · 793 · 848_6 · 848_7 · 851_2 · 855 112 통과 · 관련 694 통과(실패 = 719_1 둘 · 719_2 셋 · 826_1 — 고치기 전에도 같음 · 나머지 = 이 커밋에서 고침) · typecheck 0 · 화면 8010 엑셀 · STC 저장 · 다시 열기 · 두 판 · 이음 고침 · 시간당 식 · 초기화 · 내 일위대가로(안쪽 SK 새 꼴) · 콘솔 0 · 서버 오류 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import.py | 248 +++------ M02_MasterTemplete/M02_Doc_NativeLayout.py | 8 +- M02_MasterTemplete/M02_Doc_Sk.py | 8 +- M02_MasterTemplete/M02_Item_Sangeun.py | 18 +- M02_MasterTemplete/M02_Labor_Expand.py | 4 +- M02_MasterTemplete/M02_Labor_Ref.py | 16 +- .../M02_MasterTemplete_Hopyo_Imported.ts | 13 +- M02_MasterTemplete/M02_San_MatPick.py | 4 +- M02_MasterTemplete/M02_San_ToDoc.py | 85 +-- M02_MasterTemplete/M02_Sangeun_Copy.py | 4 +- M02_MasterTemplete/M02_Sangeun_FromHopyo.py | 53 +- M02_MasterTemplete/M02_Sangeun_Imported.py | 485 +++++++++--------- M02_MasterTemplete/M02_Sangeun_QtyLinks.py | 215 ++++++-- .../logic/M02_Hopyo_Imported_Model.ts | 12 +- .../logic/M02_Sangeun_Origin.ts | 4 +- resources/tester/golden_855_b09.json | 2 +- resources/tester/helper_857_import.py | 9 +- resources/tester/test_792_3_engine_paths.py | 11 +- .../tester/test_793_2_sangeun_imported.py | 130 +++-- resources/tester/test_793_3b_import_screen.py | 2 +- resources/tester/test_796_2b_m02_equation.py | 13 +- resources/tester/test_797_1_import_links.py | 48 +- resources/tester/test_797_2_qty_coef_links.py | 14 +- resources/tester/test_802_4b1_import_doc.py | 49 +- resources/tester/test_809_1_import_labor.py | 4 +- resources/tester/test_810_2_native_doc.py | 9 +- resources/tester/test_812_3_native_layout.py | 23 +- .../tester/test_821_4_import_my_machine.py | 6 +- resources/tester/test_827_3_material_pick.py | 13 +- resources/tester/test_835_1_import_preview.py | 2 +- resources/tester/test_857_3a_import_adds.py | 129 ----- 31 files changed, 796 insertions(+), 845 deletions(-) delete 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 f885b0117..98f67bad2 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -45,7 +45,6 @@ HEAD = ( GUESS = "추정" # 원파일 품셈 조건 글 표지(810-2 `M02_Doc_NativeEst.GUESS`) SUB = "원파일 소계" # 원파일 소계 덧줄(810-2 `M02_Doc_NativeEst`) — 합 밖 · 비목 칸 비움 PICK = "소요량" # 고른 표 칸 기호 이름 머리 -_SCALE = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)} def is_imported(sk: Any) -> bool: @@ -68,164 +67,42 @@ def _index(sk: dict, master: Any = None, doc: Any = None) -> Any: from M02_MasterTemplete import M02_Sangeun_Copy as skc if basis_of(sk) == "우리" or swapped(doc): - return skc.over(sk, imp._whole()) + return skc.over(sk, master or imp._whole()) # 받은 색인(B09 사본 단가) 위 · 없으면 지금 M01 return master or imp._whole() -# ── 엑셀 단가 그대로 고친 줄(가져온 로직 줄 + SK 고침 · 엔진 셈 없음) ───────── -def _engine_adds(doc: dict) -> bool: - """값을 엔진 셈으로만 얻는 더한줄(율 · 세부 고친 둘째 기초)이 있음 — 못 셈(옛 셈 은퇴) · - 형제 SK 더한줄 = 단가산출 연결(`_attach`).""" - return any(sd.is_rate(one) or sd.sub_patched(one) for one in doc.get("더한줄") or []) +# ── 불러올 때 문서 한 번 짓기(857-3b) ─────────────────────────────────── +OLD_FORM = "옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장" +FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(정본 · 고침 = `수식` 따로 사본) +LIST = "이음없음" # 문서 머리 `가져온` — 이음 없는 가져온 줄 [{자리, 이름, 까닭, 견적?, 종?}] -def _ctx(sk: dict, whole: Any) -> tuple: - """엑셀 단가 기준 고친 줄(855 2-C2) — 가져온 로직 줄(`row_of`) + 수식 고침 · SK 고침(`sd.patched`) · - 더한줄 고정 값(`fixed.line`) → (색인, 키, 입력, {정체, 고친 줄(`ROW`)}, None) · 옛 엔진 안 돎. - 안쪽 산근(형제 SK) 줄 값 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음). - `_engine_adds` 인 SK = 못 셈(그 더한줄 값이 옛 엔진 답 — 옛 셈 은퇴 · 855 2-C1).""" - 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): - raise ValueError("율 · 고친 둘째 기초 더한줄 — 옛 엔진 셈 은퇴 · 못 셈") - 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["줄"]["호표"] - 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: - 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 w, key, values, {"정체": got["정체"], ROW: {**row, "키": key}}, None +def bare_row(row: dict, key: str = "SK-000000") -> dict: + """가져온 줄(읽기기 꼴 · 엑셀 판) → 문서 짓는 줄 — 요소 = 이음 | {이름}(로직 줄 = 이음 | None) · + 안쪽 산근(형제 SK) 줄 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음).""" + items = [] + for one in row.get("호표") or []: + link = one.get("이음") + item = {k: v for k, v in one.items() if k != "이음"} + item["요소"] = link or (None if one.get("종류") == "로직" else {"이름": one.get("이름")}) + if one.get("참조"): + item |= {"요소": None, "값묶음": dict.fromkeys(imp.COSTS, Decimal(0)), "기준": "엑셀"} + items.append(item) + return {"입력": [], "중간": [], "덧줄": [], **row, "키": key, "호표": items} -ROW = "고친줄" # `_ctx` 가 넘기는 엑셀 단가 기준 고친 줄(857-3a — 색인 `.logic` 안 부름) +def _unlinked(row: dict) -> list[dict]: + """이음 없는 자원 줄 — 자리 = 가져온 줄 자리(`호표:i`) · 까닭 = 814-1 `M02_San_Link.why` · + 견적 = 815-1 K5 그대로 쓰는 견적 · 운임 · 수수료 줄 · 종 = 827-3 재료 종 열쇠.""" + from M02_MasterTemplete import M02_San_Link as link - -# ── 소요량 · 계수 고른 칸 → 수 자리에 기호 ────────────────────────────── -CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자 — 수 세기에서 뺌(`QtyLinks._literals`) - - -def _swap_nth(node: Any, n: int, new: tuple, seen: list) -> Any: - """`M02_Sangeun_QtyLinks._literals` 차례의 n 번째 수 → `new` 마디(같은 걸음 규칙 · 문서 식 나무) · - 다른 수 = 끝 0 뗀 글(옛 엔진 글과 같게).""" - if not isinstance(node, tuple): - return node - kind = node[0] - if kind == "num": - seen[0] += 1 - return new if seen[0] - 1 == n else ("num", node[1].normalize()) - if kind == "bin": - cmp_ = node[1] in CMP - sides = [ - ("num", side[1].normalize()) - if cmp_ and side[0] == "num" - else _swap_nth(side, n, new, seen) - for side in node[2:] - ] - return (kind, node[1], *sides) - if kind in ("neg", "pct", "field"): - return (kind, _swap_nth(node[1], n, new, seen), *node[2:]) - if kind == "call": - return ("call", node[1], [_swap_nth(a, n, new, seen) for a in node[2]]) - return node - - -def _conds(table: dict, at: int) -> dict | None: - """표 줄 차례 → 그 줄 하나만 맞는 조건 {조건: 값}(범위 = 위 끝 › 아래 끝) · 못 가림 = None.""" - rows = table.get("줄") or [] - if not (0 <= at < len(rows)): - return None - row, out = rows[at], {} - for cond, how in (table.get("조건") or {}).items(): - if cond not in row: - continue - have = row[cond] - if how == "범위": - low, high = have - have = high if high is not None else low - if have is None: - return None - out[cond] = have - try: - hit = dc.ml.find(table, out) - except Exception: # noqa: BLE001 — 못 가림 = 수 그대로 - return None - return out if hit is row else None - - -def _picks(row: dict, ids: list[str], base: list[str], meta: dict, master: Any) -> dict: - """고른 칸(`가져온.연결.고름`) → 중간 줄(표 연결 바로 · `San_ToDoc`) · 수 자리에 그 기호 ÷ 배 · - 돌려줌 = {중간 이름: 엑셀 칸 값}. 자리 줄이 SK 고침으로 바뀌었으면 건너뜀.""" - src = meta["로직"] - picked = ((meta.get("연결") or {}).get("고름")) or [] - out: dict[str, Any] = {} - mids = row.setdefault("중간", []) - taken = {str(x.get("이름")) for x in [*(row.get("입력") or []), *mids]} - for one in picked: - part, i, n = str(one.get("자리") or "::").split(":")[:3] - field = "수량" if part == "호표" else "식" - lines = src.get(part) or [] - if not (i.isdigit() and n.isdigit() and int(i) < len(lines)): - continue - cid = base[int(i) + (len(src.get("호표") or []) if part == "덧줄" else 0)] - if cid not in ids: - continue - at = ids.index(cid) - mine = (row["호표"] if at < len(row["호표"]) else row.get("덧줄") or [])[ - at if at < len(row["호표"]) else at - len(row["호표"]) - ] - if str(mine.get(field)) != str(lines[int(i)].get(field)): - continue # SK 덮개가 그 식을 바꿈 — 수 자리 어긋남 - try: - table = master.get(str(one.get("표"))) - conds = _conds(table, int(one.get("줄"))) - node = dc.md.parse(str(mine[field])) - except Exception: # noqa: BLE001 — 표 · 식 못 읽음 = 수 그대로 - continue - if conds is None: - continue - name = next(f"{PICK}{k}" for k in range(1, 999) if f"{PICK}{k}" not in taken) - taken.add(name) - scale = next( - (m for m in _SCALE.get(str(one.get("꼴")), (1,)) if _near(one, m)), None - ) # 엑셀 수 = 칸 값 ÷ 배 - if scale is None: - continue - ref = ( - ("var", name) - if scale == 1 - else ("bin", "/", ("var", name), ("num", Decimal(str(scale)))) - ) - mine[field] = dc.md.text_of(_swap_nth(node, int(n), ref, [0])) - link = {"갈래": "표", "표": str(one["표"]).strip()} - link |= {"조건": {k: _lit(v) for k, v in conds.items()}, "칸": str(one["칸"])} - mids.append({"이름": name, "연결": link}) - out[name] = Decimal(str(one.get("값"))) - return out - - -def _near(one: dict, m: float) -> bool: - cell, v = float(one.get("값") or 0), float(one.get("수") or 0) - return abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell)) + return [ + {"자리": f"호표:{n}", "이름": one.get("이름") or "", "까닭": link.why(one)} + | ({"견적": True} if (one.get("자원") or {}).get("갈래") == "고정" else {}) + | ({"종": mp.kind_of(one["자원"])} if (one.get("자원") or {}).get("재료찾기") else {}) + for n, one in enumerate(row.get("호표") or []) + if not one.get("이음") and not one.get("참조") and not (one.get("자원") or {}).get("내기계") + ] def _lit(v: Any) -> str: @@ -447,41 +324,43 @@ def _numbers(doc: dict, keep: dict) -> None: def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: - """가져온 식 SK → 수식 문서(키 = SK 키) — `ctx` = 엑셀 단가 기준 고친 줄(`_ctx` · 옛 SK 셈 길이 넘긴 것도 같은 꼴).""" + """가져온 식 SK → 수식 문서(키 = SK 키) = 불러온 그대로 문서(`가져온.문서` · 857-3b) · + 옛 꼴(`가져온.로직`) = 읽지 않음(`OLD_FORM`).""" meta = sk[imp.KEY] - if ctx is None: - ctx = _ctx(sk, whole or imp._whole()) - master, key, values, got, _ = ctx - row = cp.deepcopy(got.get(ROW) or master.logic(key)) # 옛 셈 길이 넘긴 ctx = 그 색인 줄 - ids = list(got.get("정체") or []) - 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("참조") + got = meta.get(FIRST) + if not isinstance(got, dict): + raise sd.DocError(OLD_FORM) + doc = cp.deepcopy(got) + return { + **doc, + "키": str(sk.get("키") or doc.get("키")), + "이름": str(sk.get("이름") or doc.get("이름")), } - keep = _picks(row, ids, base, meta, master) - doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름) - _attach(doc, row, ids, src) - _numbers(doc, keep) - native = bool((meta.get("원본") or {}).get("원파일")) - if native or (meta.get("원본") or {}).get( - "엑셀" - ): # 810-2 · 812-1 — 소계 비목 칸 비움 · 값 변수 출처 + + +def build(row: dict, src: dict, whole: Any = None) -> dict: + """가져온 줄(읽기기 꼴 · 깨끗한 줄) + 원본 → 불러온 그대로 수식 문서 — 불러올 때 한 번(857-3b · + `M02_San_ToDoc` · 변환기 · 색인 `.logic` · 옛 식 파서 안 부름).""" + whole = whole or imp._whole() + row, src = cp.deepcopy(row), cp.deepcopy(src) # 다듬기가 단계 · 글줄을 제자리에서 고침 + meta = {"로직": row, "원본": src} + bare = bare_row(row) + ids = sd.line_ids(bare) + doc, notes = todoc.build(bare, whole, {}) + _attach(doc, bare, ids, dict(zip(ids, row.get("호표") or []))) + _numbers(doc, {}) + native = bool(src.get("원파일")) + if native or src.get("엑셀"): # 810-2 · 812-1 — 소계 비목 칸 비움 · 값 변수 출처 _native(doc, native) - head = {k: (meta.get("원본") or {}).get(k) for k in HEAD if (meta.get("원본") or {}).get(k)} - marks = list((meta.get("원본") or {}).get("표지") or []) - if native or (meta.get("원본") or {}).get( - "엑셀" - ): # 810-3 — 품셈 조건 글(값 없음) = 「추정」 칸 + head = {k: src.get(k) for k in HEAD if src.get(k)} + marks = list(src.get("표지") or []) + if native or src.get("엑셀"): # 810-3 — 품셈 조건 글(값 없음) = 「추정」 칸 head["추정"] = [ {"행": x.get("행"), "글": " ".join(str(x.get("글") or "").split())} - for x in meta["원본"].get("글줄") or [] + for x in src.get("글줄") or [] if GUESS in str(x.get("표지") or "") ] - if not (doc.get("금액") or doc.get("결과") or row["호표"] or row.get("덧줄")): + if not (doc.get("금액") or doc.get("결과") or bare["호표"] or bare.get("덧줄")): _empty(doc) # 빈 산근 = 엑셀 0 원(줄 없음 합) — 「—」 아님 marks.append(EMPTY) found = doc.pop(MACHINES, None) @@ -489,14 +368,19 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: head |= {"기계": found} if found else {} # 812-9 기계 찾기 판정(줄 쌓기 고르기 · 저장 때 별칭) doc["가져온"] = head | {"표지": marks} | ({"알림": notes} if notes else {}) shape.shape(doc, meta) # 809-1 · 요구 704 — 지은 이름 → 엑셀 글 머리 · EST 기계 세 줄 = 한 줄 + alive = {dc.md.var_id(v) for v in doc.get("변수") or []} if found: # 세 줄을 한 줄로 합쳐 사라진 기호의 기계 판정은 뺌 - alive = {dc.md.var_id(v) for v in doc.get("변수") or []} doc["가져온"]["기계"] = [x for x in found if x["기호"] in alive] if mats: # 827-3 재료 찾기 판정(줄 쌓기 풍선말 · 이미 만든 SK 고름 얹기) - alive = {dc.md.var_id(v) for v in doc.get("변수") or []} doc["가져온"]["재료"] = [x for x in mats if x["기호"] in alive] + if gaps := _unlinked(row): + doc["가져온"][LIST] = gaps + from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty # 서로 부름 — 늦게 + + if spots := qty.slots(row): # 797-2 소요량 · 계수 자리(가져온 줄 수 차례 · 고름 = 문서 고침) + doc["가져온"]["자리"] = spots qt.tidy(doc, meta) # 848-6 원문 단위 · Q 값 글자 - return {**doc, "키": str(sk.get("키") or key), "이름": str(sk.get("이름") or doc.get("이름"))} + return doc def _native(doc: dict, native: bool = True) -> None: diff --git a/M02_MasterTemplete/M02_Doc_NativeLayout.py b/M02_MasterTemplete/M02_Doc_NativeLayout.py index e33f940f8..659dbe139 100644 --- a/M02_MasterTemplete/M02_Doc_NativeLayout.py +++ b/M02_MasterTemplete/M02_Doc_NativeLayout.py @@ -63,12 +63,10 @@ def apply(doc: dict, meta: dict) -> None: src = meta.get("원본") or {} if not src.get(TAG) or not money or None in keys: return - from M02_MasterTemplete import M02_Sangeun_Imported as imp + from M02_MasterTemplete import M02_Doc_Import as dim - row = meta.get("로직") or {} - ids = sd.line_ids( - imp.row_of({imp.KEY: {"로직": row}}) or {} - ) # 글줄 자리 = 줄 정체(`imp._named`) + row = meta.get("로직") or {} # 불러올 때 지은 가져온 줄(`Doc_Import.build` · 저장 안 함) + ids = sd.line_ids(dim.bare_row(row)) # 글줄 자리 = 줄 정체(`imp._named`) lines = [*(row.get("호표") or []), *(row.get("덧줄") or [])] by: dict[str, int] = {} for k, (cid, one) in enumerate(zip(ids, lines)): diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index dc6a90e19..9107647ce 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -72,7 +72,7 @@ def old_fp(doc: dict) -> str: """옛 칸 지문 — 따로 문서 위 옛 칸 고침 막음(가져온 식 = 가져온 줄 · 고른 칸 · 이음도).""" got = {k: doc.get(k) for k in OLD_FIELDS if doc.get(k) not in (None, {}, [])} if dim.is_imported(doc): - got["가져온"] = {k: doc["가져온"].get(k) for k in ("로직", "연결")} + got["가져온"] = {"로직": doc["가져온"].get("로직")} # 옛 꼴만(857-3b 문서 = 수식 고침) return dc.fp(_strip(got)) @@ -127,12 +127,14 @@ def frozen(sk: dict) -> bool: """굳힌 사본 SK(B09 · 구조물 사본 `GX9…` 굳힌 줄 · 수식 사본 없음) — 바탕 로직에 M01 수식 문서 없음 · 셈 = 옛 길(B9 걸음 몫 · 855 2-C1 은 안 건드림).""" key = str((sk.get("바탕") or {}).get("로직") or "") + if dim.is_imported(sk): # 857-3b 가져온 식 굳힌 사본 = 불러온 그대로 문서 셈(굳힌 줄 없음) + return False return bool(key) and not dc.has(sk) and key not in dc.folder() def old_only(sk: dict) -> bool: - """옛 칸 고침이 든 파생 SK(가져온 식 빼고 — 그 문서는 `M02_Doc_Import` 가 지음) — 셈 안 함.""" - return not dim.is_imported(sk) and any(sk.get(k) not in (None, {}, []) for k in OLD_PATCH) + """옛 칸 고침이 든 파생 SK(가져온 식도 — 857-3b 문서 = 불러온 그대로 · 고침 = 줄 쌓기) — 셈 안 함.""" + return any(sk.get(k) not in (None, {}, []) for k in OLD_PATCH) def derive(sk: dict, whole: Any) -> dict: diff --git a/M02_MasterTemplete/M02_Item_Sangeun.py b/M02_MasterTemplete/M02_Item_Sangeun.py index 8b0ad87b2..952da25be 100644 --- a/M02_MasterTemplete/M02_Item_Sangeun.py +++ b/M02_MasterTemplete/M02_Item_Sangeun.py @@ -88,9 +88,8 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]: frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"]) if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02 frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것 - # 848-7 가져온 식 수식 고침(저장 문서) = 사본도 가져온 식 셈(단가기준 · 가져온 값 층) - if doc.get(_IMPORTED) and doc["수식"].get("따로"): - frozen[_IMPORTED] = doc[_IMPORTED] + if doc.get(_IMPORTED): # 848-7 · 857-3b 가져온 식 = 사본도 가져온 식 셈(불러온 그대로 문서) + frozen[_IMPORTED] = doc[_IMPORTED] out[rid] = frozen for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)): out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken) @@ -173,4 +172,17 @@ def materials(copies: dict[str, Any]) -> list[str]: for doc in copies.values(): lines = [x for x in doc.get("담은로직") or [] if isinstance(x, dict) and x.get(FROZEN)] out += [str(mt) for x in lines for mt in (x[FROZEN].get("고름") or {}).values()] + return out + _imported_reach(copies) + + +def _imported_reach(copies: dict[str, Any]) -> list[str]: + """857-3b 가져온 식 SK = 값 사본 줄이 닿는 요소 · 표(문서 셈이 읽음 · 로직 줄 뺌) — 굳힌 줄이 없음.""" + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + out = [] + for doc in copies.values(): + src = doc.get("원본") if is_sangeun(doc) and doc.get(_IMPORTED) else None + if skc.has(src): + rows = [*src[skc.KEY]["로직"], *(src[skc.KEY].get("단가") or [])] + out += [str(r.get("키")) for r in rows if str(r.get("키"))[:1] != "G"] return out diff --git a/M02_MasterTemplete/M02_Labor_Expand.py b/M02_MasterTemplete/M02_Labor_Expand.py index de58e151a..bddcd185c 100644 --- a/M02_MasterTemplete/M02_Labor_Expand.py +++ b/M02_MasterTemplete/M02_Labor_Expand.py @@ -72,7 +72,9 @@ class Expand: if refs.kind_of(ref["키"]) == "promote": self.memo[memo] = self._promote(doc) elif refs.kind_of(ref["키"]) == "sangeun": # 단가산출(715-2) = 고친 줄 셈 1 단위 - if basis and isinstance((doc.get("가져온") or {}).get("로직"), dict): + from M02_MasterTemplete import M02_Sangeun_Imported as imp + + if basis and imp.is_imported(doc): doc = {**doc, "가져온": {**doc["가져온"], "단가기준": basis}} self.memo[memo] = calc.unit(doc, self.whole, self, (*trail, rid)) else: # 사전조합 = 그 SC 로직 사본(795-2) diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index 2306ad99f..ea15b79a5 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -61,11 +61,11 @@ def refs_in(doc: Any) -> list[Ref]: return [] base = doc.get("바탕") lines = [*(doc.get("담은로직") or []), *(doc.get("더한줄") or []), base] - own = ((doc.get("가져온") or {}).get("로직") or {}).get("호표") # 가져온 식 산근 속 산근(797-1) - lines += own if isinstance(own, list) else [] + from M02_MasterTemplete import M02_Sangeun_Imported as imp # 가져온 식 산근 속 산근(797-1) + return [ one["참조"] for one in lines if isinstance(one, dict) and isinstance(one.get("참조"), dict) - ] + ] + imp.refs_of(doc) def ref_id(ref: Ref) -> str: @@ -567,13 +567,9 @@ def _move_doc(doc: dict[str, Any], move: Callable[[Ref, int], Ref], depth: int) out = {**doc, "더한줄": _moved(doc.get("더한줄"), move, depth)} if isinstance(base, dict) and isinstance(base.get("참조"), dict): out["바탕"] = {"참조": move(base["참조"], depth)} - own = (doc.get("가져온") or {}).get("로직") - if isinstance(own, dict): # 가져온 식 산근 속 산근(797-1) - out["가져온"] = { - **doc["가져온"], - "로직": {**own, "호표": _moved(own.get("호표"), move, depth)}, - } - return out + from M02_MasterTemplete import M02_Sangeun_Imported as imp # 가져온 식 산근 속 산근(797-1) + + return imp.move_refs(out, lambda ref: move(ref, depth)) def _spec_moved(doc: dict[str, Any], done: dict[str, Ref]) -> dict[str, Any]: diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Imported.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Imported.ts index 5d158ef2a..c8b1dabae 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Imported.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Imported.ts @@ -24,7 +24,12 @@ import { at, type HopyoScope } from "./M02_MasterTemplete_Hopyo_Api"; import { importedPanel, type PanelState } from "./M02_MasterTemplete_Hopyo_ImportedPanel"; import { openQtyLinks, type QtyRow, type QtyTally } from "./M02_MasterTemplete_Hopyo_QtyLinks"; import { mountSangeunDetail } from "./M02_MasterTemplete_Sangeun_Detail"; -import { type ImportedDoc, type Money4 } from "./logic/M02_Hopyo_Imported_Model"; +import { + isImported, + isOldForm, + type ImportedDoc, + type Money4, +} from "./logic/M02_Hopyo_Imported_Model"; const TEXT = { Title: ["가져온 식 단가산출 — 단산{n}", "Imported build-up — block {n}"], @@ -147,15 +152,15 @@ export function openImported(o: ImportedOptions): void { /** 이음 없는 자원 — 단가 기준 그대로 price 답(전 · 후 = 지금) */ async function unlinked(): Promise { - if (!st.doc.가져온?.로직) return void (st.unlinked = []); - const got = await edit("price", { 문서: st.doc, 기준: st.doc.가져온.단가기준 ?? "엑셀" }).catch(() => null); // prettier-ignore + if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.unlinked = []); + const got = await edit("price", { 문서: st.doc, 기준: st.doc.가져온?.단가기준 ?? "엑셀" }).catch(() => null); // prettier-ignore st.unlinked = got?.이음없음 ?? []; draw(); } /** 소요량 · 계수 이음 집계(797-2) — 가져온 식일 때만 */ async function qtyTally(): Promise { - if (!st.doc.가져온?.로직) return void (st.qty = null); + if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.qty = null); const got = await edit("qty", { 문서: st.doc }).catch(() => null); st.qty = got?.집계 ?? null; draw(); diff --git a/M02_MasterTemplete/M02_San_MatPick.py b/M02_MasterTemplete/M02_San_MatPick.py index cf4a080d9..b1a2bc2fd 100644 --- a/M02_MasterTemplete/M02_San_MatPick.py +++ b/M02_MasterTemplete/M02_San_MatPick.py @@ -357,8 +357,8 @@ def uses(fp: str, kind: str, skip: tuple = ()) -> list[str]: if key in skip: continue doc = json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes()) - lines = ((doc.get("가져온") or {}).get("로직") or {}).get("호표") or [] - if any(kind_of(x.get("자원") or {}) == kind for x in lines if (x.get("자원") or {}).get("재료찾기")): # fmt: skip + first = (doc.get("가져온") or {}).get("문서") or {} # 불러온 그대로 문서(857-3b) + if any(e.get("종") == kind for e in (first.get("가져온") or {}).get("재료") or []): out.append(key) return out diff --git a/M02_MasterTemplete/M02_San_ToDoc.py b/M02_MasterTemplete/M02_San_ToDoc.py index 47b890d7a..65baef7c4 100644 --- a/M02_MasterTemplete/M02_San_ToDoc.py +++ b/M02_MasterTemplete/M02_San_ToDoc.py @@ -1,11 +1,11 @@ -"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 걸음 4 설계 3 절) — 서버 단독. +"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 857-3b · 걸음 4 설계 3 절) — 서버 단독. -불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 `가져온.로직` 줄(+ SK 고침 · 고른 칸 중간)을 불러오기 -자기 모듈에서 문서로 지음 — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · 옛 식 파서 -(`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`). -가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · 사람이 더한 줄 = - 요소 키(인력 · 재료 · 기계 — 요소 연결 · M01 값) · 로직 부름(단가산출 연결) · - 중간 = 식 줄(표시 = 반올림) · 고른 칸 중간(`연결` 든 줄) = 그 기호에 바로 연결 · +불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 가져온 줄을 불러올 때 한 번 문서로 지음 +(저장 = 그 문서) — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · +옛 식 파서(`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`) · +사람 고침 = 줄 쌓기(문서). +가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 · + 중간 = 식 줄(표시 = 반올림) · 덧줄 = 금액 줄(단가 = 식) · `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 · 끝전 · 단계 · 조정 그대로. 기호 = `master_symbol` 규칙(이름 끝말) · 한 문서 안 겹침 = 아래첨자 끝 숫자. @@ -30,6 +30,8 @@ import master_doc_unit as mdu # noqa: E402 import master_doc_unit_rule as mdr # noqa: E402 import master_symbol as msym # noqa: E402 +FROM = "가져온줄" # 857-3b 문서 금액 줄 · 값 변수 ↔ 가져온 줄 자리(`호표:i` · `덧줄:i`) +KIND = "가져온종류" # 금액 줄 ↔ 가져온 줄 종류(인력 · 재료 · 기계 · 로직) LINE_KEYS = ("번지", "합밖", "자리", "출처", "부착") # 호표 → 금액 줄 그대로 옮기는 칸 ADD_KEYS = ("번지", "합밖", "자리", "출처") # 덧줄 → 금액 줄 @@ -88,8 +90,6 @@ class _Reg: _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: @@ -161,58 +161,19 @@ class _Doc: value: Any = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS} else: value = Decimal(str(item["단가"])) - return self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value}) + got = self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value}) + self.links[("손", at)][FROM] = f"호표:{at}" # 857-3b 가져온 줄 자리(이음 · 소요량 고침) + return got def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str: """값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙.""" if key not in self.links: - sign, low, up = msym.lookup(label, "요소") - self.reg.want(key, (sign, self._low(link, low), up)) + self.reg.want(key, msym.lookup(label, "요소")) self.order.append(key) 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 = 입력 값.""" @@ -315,23 +276,12 @@ def _money(c: _Doc, row: dict) -> list[dict]: except md.DocError as e: c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}") qty = str(item["수량"]) - 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["비목"])) + price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음" + if line["비목"] != "묶음" and item.get("값묶음"): + price = f"{price}.계" line |= {"수량": qty, "단가": price} line |= {k: item[k] for k in LINE_KEYS if k in item} + line |= {FROM: f"호표:{at}", KIND: str(item.get("종류") or "")} out.append(line) seen: dict[str, tuple] = {} for add in adds: @@ -343,6 +293,7 @@ def _money(c: _Doc, row: dict) -> list[dict]: price = str(add["식"]) line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price} line |= {k: add[k] for k in ADD_KEYS if k in add} + line[FROM] = f"덧줄:{len(out) - len(items)}" out.append(line) seen[name] = ("덧", name) last = {str(x.get("이름") or ""): i for i, x in enumerate(items)} # 같은 이름 = 뒤 줄 diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index b13faf544..b1c5daa9a 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -174,8 +174,8 @@ def stamp(doc: dict) -> dict | None: keys, links = reach(doc.get("더한줄")) keys = [str(base["로직"]), *keys] if base.get("로직") else keys links += mym.keys_in(doc) # 줄 쌓기 기계 입력 「개인 EQP…」(821-1) - extra = [row] if (row := imp.row_of(doc)) else [] - return snap(keys, links, extra) + more, near = imp.reach_of(doc) # 가져온 식 = 불러온 그대로 문서 연결(857-3b) + return snap([*keys, *more], [*links, *near]) def reach(adds: Any) -> tuple[list[str], list[str]]: diff --git a/M02_MasterTemplete/M02_Sangeun_FromHopyo.py b/M02_MasterTemplete/M02_Sangeun_FromHopyo.py index e208f48df..54754e691 100644 --- a/M02_MasterTemplete/M02_Sangeun_FromHopyo.py +++ b/M02_MasterTemplete/M02_Sangeun_FromHopyo.py @@ -225,26 +225,20 @@ def make( source: Path, key: str, no: int, name: str = "", _trail: tuple = (), doc: dict | None = None ) -> dict[str, Any]: """지금 층(만들 층)에 가져온 식 SK — 같은 내용이 있으면 그 SK(`다시씀`) · - 안쪽 산근 블록은 형제 SK 를 먼저 만들어 참조(797-1) · `doc` = 미리 보기에서 고친 문서([저장] · 835-1 — - 그 문서 로직 줄에 안쪽 참조 · 내 기계를 이어 저장).""" + 안쪽 산근 블록은 형제 SK 를 먼저 만들어 참조(797-1) · 못 이은 기계 = 내 기계(821-4) · + `doc` = 미리 보기에서 고친 문서([저장] · 835-1 — 다시 읽은 가져온 줄로 안쪽 참조 · 내 기계만 그 문서에 얹음).""" from M02_MasterTemplete import M02_Sangeun_Imported as imp - if doc is None: - out, makes = _prep(source, key, no) - else: - meta = doc.get(imp.KEY) if isinstance(doc, dict) else None - if not isinstance(meta, dict) or not isinstance(meta.get("로직"), dict): - raise store.StoreError(400, "가져온 식 문서 아님") - meta["원본"] = {**(meta.get("원본") or {}), "표지": list((meta.get("원본") or {}).get("표지") or [])} # fmt: skip - meta["원본"].pop("내기계예정", None) - out, makes = {"로직": meta["로직"], "원본": meta["원본"]}, _emit(source, key, no)[1] + if doc is not None and (not imp.is_imported(doc) or imp.old_form(doc)): + raise store.StoreError(400, "가져온 식 문서 아님") + out, makes = _prep(source, key, no) _link_inner(source, key, no, out, _trail) if doc is None: - _flag(out) # 고친 문서 = 미리 보기 때 붙은 표지 그대로 + _flag(out) made = mm.attach(out, makes) # 821-4 못 이은 기계 = 내 기계(그 층 같은 것 · 새로) mine = {"내기계": made} if made else {} - if doc is None: - doc = imp.new_doc(out["로직"], out["원본"], _title(out, no, name)) + fresh = imp.new_doc(out["로직"], out["원본"], _title(out, no, name)) + doc = fresh if doc is None else _onto(doc, fresh) try: return {**imp.keep(doc), "다시씀": False, **mine} except store.StoreError as e: @@ -252,3 +246,34 @@ def make( if e.status != 409 or not same: raise return {**imp.keep(doc, use=same[0]["키"]), "다시씀": True, **mine} + + +def _onto(doc: dict, fresh: dict) -> dict: + """미리 보기에서 고친 문서 위에 [저장] 때 이은 것(안쪽 산근 참조 · 내 기계)만 — 아직 이음 없는 값 + 변수(같은 가져온 줄 자리)에 새 문서 연결 · 원본 · 검산 · 머리 표지 · 기계 = 새 것(857-3b).""" + import copy as cp + + from M02_MasterTemplete import M02_Sangeun_Imported as imp + + doc = cp.deepcopy(doc) + new = fresh[imp.KEY][imp.FIRST] + by = {v.get(imp.FROM): v for v in new.get("변수") or [] if v.get(imp.FROM)} + for one in imp.docs_of(doc): + for var in one.get("변수") or []: + got = by.get(var.get(imp.FROM)) + if got is None or not imp._bare_value(var) or imp._bare_value(got): + continue + var["연결"] = cp.deepcopy(got["연결"]) + var.pop("설명", None) + var |= {"설명": got["설명"]} if got.get("설명") else {} + head = one.setdefault(imp.KEY, {}) + for k in ("표지", "기계"): + if (new.get(imp.KEY) or {}).get(k) is not None: + head[k] = cp.deepcopy(new[imp.KEY][k]) + gaps = {x["자리"] for x in (new.get(imp.KEY) or {}).get(imp.LIST) or []} + if head.get(imp.LIST): + head[imp.LIST] = [x for x in head[imp.LIST] if x.get("자리") in gaps] + src = fresh[imp.KEY].get("원본") or {} + when = ((doc[imp.KEY].get("원본") or {}).get("가져온때")) or src.get("가져온때") + doc[imp.KEY] |= {"원본": {**src, "가져온때": when}, "검산": fresh[imp.KEY]["검산"]} + return doc diff --git a/M02_MasterTemplete/M02_Sangeun_Imported.py b/M02_MasterTemplete/M02_Sangeun_Imported.py index b9d9ff5e4..28759dabc 100644 --- a/M02_MasterTemplete/M02_Sangeun_Imported.py +++ b/M02_MasterTemplete/M02_Sangeun_Imported.py @@ -1,39 +1,30 @@ -"""M02 가져온 식 단가산출(SK 바탕 갈래 · PLAN 793-2 · 요구 649 · 652 갈래 C) — 서버 단독. +"""M02 가져온 식 단가산출(SK 바탕 갈래 · PLAN 793-2 · 857-3b · 요구 649 · 652 갈래 C) — 서버 단독. -경쟁사 엑셀 산근 블록 = 엔진 로직 줄 하나(`_틀.md` 7 장 꼴 · sub4 793-2a 내보내기)를 SK 가 품음 · -셈 = 그 줄을 바탕 줄로(`M02_Sangeun_Doc.empty_row` → `row_of`) → `_Over` 로 얹어 같은 엔진 한 벌 · -790-2 · 792-1 고침(덮개 · 상수 · 표값 · 식 덮개 · 변수 줄 · 글 줄 · 까닭 · 더한줄)이 그대로 먹음. +경쟁사 엑셀 · 원파일 산근 블록 = 읽기기가 낸 가져온 줄(아래 꼴 · sub4 793-2a 내보내기) → 불러올 때 한 번 +수식 문서로 지음(`M02_Doc_Import.build` · `M02_San_ToDoc`) · 정본 = 그 문서(857-3b · 요구 898 · 899). -가져온 로직 줄(만들기 몸 `로직`) = {이름, 결과단위 「원/단위」, 입력?, 중간? [{이름, 식, 표시?}], +가져온 줄(만들기 몸 `로직` · 저장 안 함) = {이름, 결과단위 「원/단위」, 입력?, 중간? [{이름, 식, 표시?}], 호표 [줄], 덧줄? [{이름, 식, 비목, 번지?, 합밖?, 자리?}], 단계?, 끝전?, 조정?, 끝수?} - 호표 줄 = {종류 인력|재료|기계|로직, 이름, 규격?, 단위, 수량(엔진 식 글), - 비목(로직 줄은 없으면 노 · 재 · 경 나눠 얹음), - 단가?(엑셀 단가 · 인력 · 재료 · 기계) | 값묶음? {노무비, 재료비, 경비}(엑셀 · 로직 줄), + 호표 줄 = {종류 인력|재료|기계|로직, 이름, 규격?, 단위, 수량(식 글), 비목(로직 줄은 없으면 묶음), + 단가?(엑셀 단가) | 값묶음? {노무비, 재료비, 경비}(엑셀 · 로직 줄), 이음?(M01 요소 키 LB · MT · EQ … | 로직 줄 = 「로직(GC…, 이름='값')」 글 | null), - 번지?, 합밖?, 자리?} · `요소` 칸은 서버가 채움(이음 | {이름}) · - 줄 정체 cid 머리 = 이음 키 | 이름. -원본(만들기 몸 `원본`) = {파일, 시트, 행 [처음, 끝], 갈래 STmate|EST, - 엑셀금액 {노무비, 재료비, 경비, 계}(1 단위), - 글줄 [{행, 글, 자리?(셈 줄 cid | mid:이름), 값?(그 줄 엑셀 금액)}]}. -SK 문서 덧칸 `가져온` = {로직(엑셀 단가 그대로 · 고치지 않음), 단가기준 엑셀|우리, 원본, - 검산 {같음, 까닭, 셈 {노..계}, 엑셀 {노..계}, 줄 [{자리, 행, 셈, 엑셀, 같음, 까닭?}]}, - 근거후보 · 바꿈(옛 문서 읽기만 · 809-1 부터 안 씀)} · - 바탕 = null · 가져온 식 SK = `가져온.로직` 있음 · 검산 = 저장 때 서버가 다시. -단가기준 엑셀 = 줄 단가 · 값묶음 그대로 / - 우리 = 이음 있는 줄만 단가 · 값묶음 떼고 M01(B09 = 사본 단가) 지금 값 · - 이음 없는 줄 = 엑셀 단가 그대로 + 표지(`이음없음`). -길(`M02_Sangeun_Router` · 저장 없음 = 화면 캐시 · 만들기만 층 쓰기): - POST …/sangeun/imported 몸 {로직, 원본, 이름?, 단위?, 구분?, 상세구분?, 새로?, 씀?} - → {이름(SK 키), 검산, 단가기준}(서버가 다시 셈해 엑셀과 맞댐 · 같은 내용 409 = 기존 길) + 참조?(같은 엑셀의 형제 가져온 식 SK · 797-1) · 번지?, 합밖?, 자리?, 자원?}. +원본(만들기 몸 `원본`) = {파일, 시트, 행 [처음, 끝], 갈래 STmate|EST, 엑셀금액 {노..계}(1 단위), + 글줄 [{행, 글, 자리?(셈 줄 cid | mid:이름), 값?}]}. +SK 문서 덧칸 `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 단가기준 엑셀|우리, 원본, + 검산 {같음, 까닭, 셈, 엑셀, 줄}(불러올 때 한 번 · 엑셀 단가 · 고침 없음), 연결?(소요량 이음 기록 · 797-2), + 근거후보 · 바꿈(옛 문서 읽기만)} · 바탕 = null · 고침 = `수식` 따로 사본(줄 쌓기) · [초기화] = `문서`. + 옛 꼴(`가져온.로직` · 857-3b 앞 저장본) = 읽지 않음 · 지우지 않음 — 셈 · 열기 = 까닭 하나(`OLD_FORM`). +단가기준 엑셀 = 연결의 엑셀 값 기억 · 우리 = 연결 값(`M02_Doc_Import.view`). +길(`M02_Sangeun_Router` · 저장 없음 = 화면 캐시): POST …/sangeun/imported/price 몸 {문서, 기준} → {문서, 전, 후, 이음없음 [{자리, 이름}]} - POST …/sangeun/imported/link 몸 {문서, 자리, 이음} → {문서}(이음 고름 · 덮개 열쇠 옮김) - (우리 기초로 바꾸기 `to-base` 는 809-1 에서 지움 — 경쟁사 로직 인정 · 요구 703) -셈 답(`…/sangeun/calc`) = 옛 꼴 그대로 · `원래` = 엑셀 금액(「M01 원래」 자리) · 덧칸 `가져온` - {단가기준, 파일, 시트, 행, 갈래, 엑셀금액, 글줄 [{행, 글, 자리, 엑셀, 지금, 같음}], 이음없음}. + POST …/sangeun/imported/link 몸 {문서, 자리(가져온 줄 `호표:i`), 이음} → {문서}(문서 연결 고침) +셈 답(`…/sangeun/calc`) 덧칸 `가져온` {단가기준, 파일, 시트, 행, 갈래, 엑셀금액, 글줄, 이음없음} · `원래` = 엑셀 금액. """ from __future__ import annotations +import copy as cp import json import math import re @@ -43,6 +34,7 @@ from typing import Any from M02_MasterTemplete import M02_Sangeun_Doc as sd KEY = "가져온" +FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(`M02_Doc_Import.FIRST`) BASIS = ("엑셀", "우리") COSTS = ("노무비", "재료비", "경비") KINDS = ("인력", "재료", "기계", "로직") @@ -51,16 +43,11 @@ LINE = ("종류", "이름", "규격", "단위", "수량", "비목", "단가", " LINE += ("자리", "출처", "비고", "자원") # 자원 = 경쟁사 코드 · 엑셀 단가 원본(793-2a · 셈 안 씀) LINE += ("참조", "참조비목") # 산근 속 산근 = 같은 엑셀의 형제 가져온 식 SK(797-1 · 로직 줄만) EXTRA = ("이름", "식", "비목", "번지", "합밖", "자리", "출처", "비고") -META = ("원본", "검산", "근거후보", "바꿈", "연결") # 검산 = 저장 때 서버가 다시 적음(`stamp`) +META = ("원본", "검산", "근거후보", "바꿈", "연결") MANY = 300 # 호표 · 덧줄 · 중간 줄 수 BIG = 400_000 # 메타 글 크기(바이트) -_KEYED = ("덮개", "고름", "자재표시", "상수덮개", "표값덮개", "식덮개", "까닭", "M01판") - - -def _mf() -> Any: - from M02_MasterTemplete import M02_Labor_Doc as labor - - return labor.m01.cm.mf +DOC_BIG = 4_000_000 # 불러온 그대로 문서 크기(바이트) +FROZEN = "GX9" # 굳힌 사본 바탕 로직 키 머리(`M02_Item_Sangeun.frozen_key`) def _whole() -> Any: @@ -70,11 +57,26 @@ def _whole() -> Any: return mym.whole() +def _dim() -> Any: + from M02_MasterTemplete import M02_Doc_Import as dim # 서로 부름 — 늦게 + + return dim + + def is_imported(doc: Any) -> bool: - return isinstance(doc, dict) and isinstance((doc.get(KEY) or {}).get("로직"), dict) + """가져온 식 SK — 불러온 그대로 문서(857-3b) · 옛 꼴(`로직`)도 가져온 식(읽지 않음 · 까닭).""" + meta = doc.get(KEY) if isinstance(doc, dict) else None + return isinstance(meta, dict) and ( + isinstance(meta.get(FIRST), dict) or isinstance(meta.get("로직"), dict) + ) -# ── 바탕 줄 ─────────────────────────────────────────────────────────── +def old_form(doc: Any) -> bool: + """857-3b 앞 옛 꼴 저장본(`가져온.로직` · 문서 없음).""" + return is_imported(doc) and not isinstance(doc[KEY].get(FIRST), dict) + + +# ── 이음 기계 시간당 ─────────────────────────────────────────────────── _HOURLY: dict[str, Any] = {"whole": None, "rows": {}} @@ -90,93 +92,54 @@ def hourly_of(key: str) -> dict: return _HOURLY["rows"][key] -def machine_price(link: str, part: Any, excel: Any) -> Any: - """[우리 단가로] 기계 이음 줄 값 — 시간당 경비의 그 비목 · 시간당 자료 없으면 엑셀 단가 그대로.""" - got = hourly_of(link) - if got.get("ok") and part in COSTS: - return sd.plain(Decimal(str(got[part]))) - return excel - - -def row_of(doc: Any) -> dict | None: - """가져온 식 바탕 줄(엔진 로직 줄) — 단가기준 우리 = 이음 있는 줄의 단가 · 값묶음 뗌 · 요소 = - 이음 | {이름}(로직 줄 = 이음 | None) · 가져온 식 아님 = None.""" - if not is_imported(doc): - return None - meta = doc[KEY] - ours = meta.get("단가기준") == "우리" - items = [] - for one in meta["로직"].get("호표") or []: - link = one.get("이음") - item = {k: v for k, v in one.items() if k != "이음"} - item["요소"] = link or (None if one.get("종류") == "로직" else {"이름": one.get("이름")}) - if one.get( - "참조" - ): # 안쪽 산근 = 형제 SK 1 단위 값(셈이 채움 · 엑셀 값묶음은 얼린 사본으로 둠) - item |= {"요소": None, "값묶음": None, "기준": "우리" if ours else "엑셀"} - if ours and not link and (mine := (one.get("자원") or {}).get("내기계")): - _direct(item, one, mine) # 821-4 시간당 값 직접 내기계 = 그 줄 값 - if ours and link: - item.pop("단가", None) - item.pop("값묶음", None) - if str(link).startswith( - "EQ" - ): # EQ = 기계 제원 묶음 — 줄 값은 시간당 기계경비의 그 비목 - item["단가"] = machine_price(link, one.get("비목"), one.get("단가")) - items.append(item) - row = {"입력": [], "중간": [], "덧줄": [], **meta["로직"]} - return {**row, "키": doc.get("키"), "호표": items} - - -def _direct(item: dict, one: dict, key: str) -> None: - """[우리 단가로] 이음 없이 이은 내 기계(시간당 값 직접 · 821-4) — 단가 = 그 비목 · 값묶음 = 셋 · - 지운 내 기계 = 엑셀 값 그대로.""" - got = hourly_of(key) - if not got.get("ok"): - return - if "단가" in item and one.get("비목") in COSTS: - item["단가"] = sd.plain(Decimal(str(got[one["비목"]]))) - elif "값묶음" in item: - item["값묶음"] = {k: sd.plain(Decimal(str(got[k]))) for k in COSTS} +def row_of(doc: Any) -> None: + """옛 가져온 줄(엔진 로직 줄) — 857-3b 부터 저장 안 함 · 읽지 않음(늘 None · 2-D 가 부름 걷음).""" + return None def base_row(doc: dict) -> dict[str, Any]: - """바탕 없는 SK 바탕 줄(`sd.empty_row`) — 가져온 식 = 그 줄 · 아니면 입력 · 줄 없음.""" - return row_of(doc) or { + """바탕 없는 SK 바탕 줄(`sd.empty_row`) — 입력 · 줄 없음 · 가져온 식 결과단위 = 문서 결과단위(1 단위 배).""" + first = (doc.get(KEY) or {}).get(FIRST) if isinstance(doc.get(KEY), dict) else None + unit = (first or {}).get("결과단위") or f"원/{doc.get('단위') or ''}" + return { "키": doc.get("키"), "이름": doc.get("이름"), - "결과단위": f"원/{doc.get('단위') or ''}", + "결과단위": unit, **{k: [] for k in ("입력", "중간", "호표", "덧줄")}, } -# ── 꼴 검사 ─────────────────────────────────────────────────────────── +# ── 가져온 줄 꼴 검사(불러올 때 · 문서 파서) ───────────────────────────── def _formula(raw: Any, where: str) -> str: - from M02_MasterTemplete import M02_Sangeun_Formula as fx + from M02_MasterTemplete import M02_San_ToDoc as todoc text = str(raw if raw is not None else "").strip() if not text: raise sd.DocError(f"{where} · 식이 빔") - if bad := fx.limits(text): - raise sd.DocError(f"{where} · {bad[0]}") + if len(text) > 2000: + raise sd.DocError(f"{where} · 식이 너무 김") try: - _mf().parse(text) - except Exception as e: # noqa: BLE001 — 엔진 FormulaError + todoc.md.parse(text) + except todoc.md.DocError as e: raise sd.DocError(f"{where} · {e}") from e return text def _link(raw: Any, kind: str, where: str, whole: Any) -> str | None: - """이음 — 로직 줄 = 「로직(GC…)」 글(부르는 로직 있음) · 그 밖 = M01 요소 키(있음).""" + """이음 — 로직 줄 = 「로직(GC…)」 글(부르는 수식 문서 있음) · 그 밖 = M01 요소 키(있음).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_San_ToDoc as todoc + if raw in (None, ""): return None text = str(raw).strip() try: if kind == "로직": - node = _mf().parse(text) - if node[0] != "logic": + got = todoc.logic_call(text) + if got is None: raise ValueError("로직(…) 꼴 아님") - whole.logic(node[1]) + if dc.folder().get(got[0]) is None: + raise ValueError("없는 단가산출") else: whole.get(text) except Exception as e: # noqa: BLE001 @@ -221,7 +184,7 @@ def _line(raw: Any, where: str, whole: Any) -> dict: def clean_row(raw: Any, whole: Any = None) -> dict[str, Any]: - """가져온 로직 줄 꼴 — 줄 수 · 식(엔진 파서 · 상한) · 이음 키 · 엑셀 값 · 틀리면 `DocError`.""" + """가져온 줄 꼴 — 줄 수 · 식(문서 파서) · 이음 키 · 엑셀 값 · 틀리면 `DocError`.""" whole = whole or _whole() if not isinstance(raw, dict): raise sd.DocError("가져온 로직 · 묶음 아님") @@ -253,13 +216,13 @@ def _extra(raw: Any, where: str) -> dict: return {**out, "이름": str(raw.get("이름") or where), "식": _formula(raw.get("식"), where)} -def _meta(raw: Any, name: str) -> Any: +def _meta(raw: Any, name: str, big: int = BIG) -> Any: try: size = len(json.dumps(raw, ensure_ascii=False, default=str).encode("utf-8")) except (TypeError, ValueError) as e: raise sd.DocError(f"가져온 {name} · 글로 못 담음") from e - if size > BIG: - raise sd.DocError(f"가져온 {name} · {BIG} 바이트를 넘음") + if size > big: + raise sd.DocError(f"가져온 {name} · {big} 바이트를 넘음") want = list if name == "근거후보" else dict if not isinstance(raw, want): raise sd.DocError(f"가져온 {name} · {'목록' if want is list else '묶음'} 아님") @@ -268,7 +231,8 @@ def _meta(raw: Any, name: str) -> Any: def clean(raw: Any, out: dict) -> dict: """`sd.clean` 끝(`const.clean_more`) — `가져온` 칸 · 바탕과 같이 못 둠 · - `가져온보관` = 우리 기초 사본으로 바꾼 SK 의 원래 가져온 식 몸(810-4 되돌리기).""" + `가져온보관` = 우리 기초 사본으로 바꾼 SK 의 원래 가져온 식 몸(810-4 되돌리기) · + 옛 꼴(`로직`) = 그대로 둠(읽지 않음 · 지우지 않음).""" kept = raw.get("가져온보관") if isinstance(raw, dict) else None if isinstance(kept, dict) and isinstance(kept.get(KEY), dict): out = {**out, "가져온보관": _meta(kept, "가져온보관")} @@ -278,27 +242,28 @@ def clean(raw: Any, out: dict) -> dict: if not isinstance(meta, dict): raise sd.DocError("가져온 · 묶음 아님") got = {k: _meta(meta[k], k) for k in META if meta.get(k) not in (None, {}, [])} - if meta.get("로직") is not None: - if out.get("바탕"): - raise sd.DocError("가져온 식 단가산출은 바탕 없음") + if meta.get(FIRST) is not None or meta.get("로직") is not None: + if out.get("바탕") and not str((out["바탕"] or {}).get("로직") or "").startswith(FROZEN): + raise sd.DocError("가져온 식 단가산출은 바탕 없음") # 굳힌 사본(B09 · `GX9…`)만 바탕 basis = meta.get("단가기준") or "엑셀" if basis not in BASIS: raise sd.DocError("단가기준은 엑셀 · 우리") - got |= {"로직": clean_row(meta["로직"]), "단가기준": basis} - if got.get("원본"): - got["원본"] = _named(got["원본"], got["로직"]) - if got.get("연결"): # 소요량 · 계수 이음 기록(797-2) — 자리 · 수 맞는 것만 - from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty - - got["연결"] = qty.tidy(got["연결"], got["로직"]) - got = {k: v for k, v in got.items() if v or k != "연결"} + got["단가기준"] = basis + if meta.get(FIRST) is not None: + first = _meta(meta[FIRST], FIRST, DOC_BIG) + for name in ("변수", "식", "금액"): + if not isinstance(first.get(name, []), list): + raise sd.DocError(f"가져온 문서 · 「{name}」 목록 아님") + got[FIRST] = first + else: + got["로직"] = meta["로직"] # 옛 꼴 — 그대로(읽지 않음) return out | ({KEY: got} if got else {}) def _named(src: dict, row: dict) -> dict: """원본 글줄 `자리` · `자리들` = 셈 줄 이름(793-2a) → 줄 정체 cid(이미 cid · `mid:` · `단계:` = 그대로 · 블록 안 줄 이름은 겹치지 않음).""" - ids = sd.line_ids(row_of({KEY: {"로직": row}}) or {}) + ids = sd.line_ids(_dim().bare_row(row)) by: dict[str, str] = {} for one, cid in zip([*row["호표"], *(row.get("덧줄") or [])], ids): by.setdefault(str(one.get("이름")), cid) @@ -313,65 +278,56 @@ def _named(src: dict, row: dict) -> dict: def same_part(doc: Any) -> dict | None: - """같은 내용 지문 몫(`M02_Library_Same`) — 로직 · 단가기준(원본 · 검산 · 근거후보 뺌).""" + """같은 내용 지문 몫(`M02_Library_Same`) — 불러온 그대로 문서(머리 `가져온` = 파일 · 행 · 표지 뺌) · + 단가기준(원본 · 검산 뺌).""" if not is_imported(doc): return None - return {k: doc[KEY].get(k) for k in ("로직", "단가기준")} + meta = doc[KEY] + first = meta.get(FIRST) + out = {k: meta.get(k) for k in ("로직", "단가기준") if meta.get(k) is not None} + if isinstance(first, dict): + out[FIRST] = {k: v for k, v in first.items() if k != KEY} + return out def unlinked(doc: dict) -> list[dict]: - """이음 없는 자원 줄(표지 · 사람이 고름) `[{자리, 이름, 까닭, 견적?, 종?}]`(까닭 = 814-1 `M02_San_Link.why` · - 견적 = 815-1 K5 그대로 쓰는 견적 · 운임 · 수수료 줄 — 못 이음 수에서 뺌 · 종 = 827-3 재료 종 열쇠).""" - from M02_MasterTemplete import M02_San_Link as link - from M02_MasterTemplete import M02_San_MatPick as mp - - row = row_of(doc) or {} - ids = sd.line_ids(row) - return [ - {"자리": ids[n], "이름": one.get("이름") or "", "까닭": link.why(one)} - | ({"견적": True} if (one.get("자원") or {}).get("갈래") == "고정" else {}) - | ({"종": mp.kind_of(one["자원"])} if (one.get("자원") or {}).get("재료찾기") else {}) - for n, one in enumerate(doc[KEY]["로직"].get("호표") or []) - if not one.get("이음") and not one.get("참조") and not (one.get("자원") or {}).get("내기계") - ] + """이음 없는 자원 줄 `[{자리, 이름, 까닭, 견적?, 종?}]` — 불러올 때 문서 머리 목록(`Doc_Import.LIST`) + 가운데 아직 이음 없는 것(자리 = 가져온 줄 `호표:i`).""" + first = (doc.get(KEY) or {}).get(FIRST) + if not isinstance(first, dict): + return [] + have = {v.get(FROM) for v in first.get("변수") or [] if _bare_value(v)} + return [x for x in (first.get(KEY) or {}).get(LIST) or [] if x.get("자리") in have] -# ── 셈 · 검산 ───────────────────────────────────────────────────────── +FROM = "가져온줄" # `M02_San_ToDoc.FROM` +LIST = "이음없음" # `M02_Doc_Import.LIST` +XL = "엑셀" # `M02_Doc_Import.XL` + + +def _bare_value(var: dict) -> bool: + """이음 없는 가져온 값 변수 — 숫자 연결(엑셀 값 그대로).""" + return isinstance(var, dict) and (var.get("연결") or {}).get("갈래") == "숫자" + + +# ── 검산(불러올 때 한 번 · 엑셀 단가 · 고침 없음) ──────────────────────── def _json(value: Any) -> Any: from M02_MasterTemplete import M02_Labor_Doc as labor return labor._json(value) -class _One: - """M01 색인 위에 가져온 줄 하나 — `logic(키)` 만 가로챔(문서 변환 색인 · 그 밖 그대로).""" - - def __init__(self, whole: Any, key: str, row: dict) -> None: - self._whole, self._key, self._row = whole, key, row - - def logic(self, ref: str) -> dict: - return self._row if ref == self._key else self._whole.logic(ref) - - def __getattr__(self, name: str) -> Any: - return getattr(self._whole, name) - - -def _doc_of(bare: dict, whole: Any) -> tuple[dict, list[str], dict]: - """검산 문서(855 2-C3) — 가져온 줄(엑셀 단가 · 고침 없음)을 줄 차례 그대로 문서로(다듬기 없음 · - 금액 줄 k = 줄 정체 k) · 안쪽 산근 줄 = 형제 SK 연결(문서 셈 · 부르는 쪽 단가기준) → - (문서, 줄 정체, {중간 이름: 기호}).""" +def _doc_of(row: dict, whole: Any) -> tuple[dict, list[str], dict]: + """검산 문서(855 2-C3 · 857-3b) — 가져온 줄(엑셀 단가 · 고침 없음)을 줄 차례 그대로 문서로 + (`M02_San_ToDoc` · 다듬기 없음 · 금액 줄 k = 줄 정체 k) · 안쪽 산근 줄 = 형제 SK 연결(문서 셈 · + 부르는 쪽 단가기준) → (문서, 줄 정체, {중간 이름: 기호}).""" from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_San_ToDoc as todoc - key = str(bare.get("키") or "SK-000000") - row = {**row_of(bare), "키": key} - row["호표"] = [dict(x) for x in row["호표"]] - for item in row["호표"]: # 형제 SK 줄 = 아래에서 연결로 갈음 — 변환 자리값 - if item.get("참조") and item.get("값묶음") is None: - item["값묶음"] = dict.fromkeys(COSTS, Decimal(0)) - master = _One(whole, key, row) - doc, _ = dc.cv.convert(master, row, dc.given_of(master, key, bare.get("입력값"))) + bare = _dim().bare_row(row) + doc, _ = todoc.build(bare, whole, {}) by = {dc.md.var_id(v): v for v in doc.get("변수") or []} - for item, line in zip(row["호표"], doc.get("금액") or []): + for item, line in zip(bare["호표"], doc.get("금액") or []): var = by.get(str(line.get("단가") or "").removesuffix(".계")) if not item.get("참조") or var is None: continue @@ -386,11 +342,11 @@ def _doc_of(bare: dict, whole: Any) -> tuple[dict, list[str], dict]: line["단가"], line["비목"] = dc.md.var_id(var), item["참조비목"] var["연결"] = link mids = {str(v.get("열쇠")): dc.md.var_id(v) for v in doc.get("변수") or []} - return doc, sd.line_ids(row), mids + return doc, sd.line_ids(bare), mids def _run(doc: dict, whole: Any) -> dict: - """SK 셈(`to_price` 전 · 후 1 단위) — `Sangeun_Calc.run` 한 길(2-C1 몫 · 검산은 `_doc_of`).""" + """SK 셈(`to_price` 전 · 후 1 단위) — `Sangeun_Calc.run` 한 길(2-C1).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc return calc.run(sd.clean(doc, None, whole), whole) @@ -412,28 +368,23 @@ def _same(mine: Any, excel: Any) -> bool: return abs(Decimal(str(mine)) - want) < step -def check(doc: dict, whole: Any = None) -> dict[str, Any]: - """검산 — 가져온 줄(엑셀 단가 · 고침 없음)을 문서 계산기로 다시 셈(855 2-C3 · 옛 엔진 안 돎) → - 엑셀 금액 · 글줄마다 맞댐(글줄 `자리` = 줄 정체 cid ↔ 검산 문서 금액 줄 같은 차례 · `mid:이름` = - 중간 변수 값 · `단계:이름` = 단계 계) · 못 셈 = {같음 False, 까닭}.""" +def check_row(row: dict, src: dict, head: dict, whole: Any = None) -> dict[str, Any]: + """검산 — 가져온 줄(엑셀 단가 · 고침 없음)을 문서 계산기로 다시 셈(855 2-C3) → 엑셀 금액 · + 글줄마다 맞댐(글줄 `자리` = 줄 정체 cid ↔ 검산 문서 금액 줄 같은 차례 · `mid:이름` = 중간 변수 값 · + `단계:이름` = 단계 계) · 못 셈 = {같음 False, 까닭} · `head` = SK {키, 단위, 환산}(1 단위 배).""" from M02_MasterTemplete import M02_Doc_Copy as dc - from M02_MasterTemplete import M02_Doc_Import as dim from M02_MasterTemplete import M02_Sangeun_Calc as calc whole = whole or _whole() - meta = doc[KEY] - bare = {k: doc.get(k) for k in ("키", "이름", "단위", "입력값", "환산")} - bare |= {"바탕": None, KEY: {"로직": meta["로직"], "단가기준": "엑셀"}} - src = meta.get("원본") or {} excel = src.get("엑셀금액") or {} + sk = {"키": head.get("키") or "SK-000000", KEY: {"단가기준": "엑셀"}} try: - bare = sd.clean(bare, None, whole) - times = calc.ratio_of(bare, row_of(bare), whole) # 1 단위 = 문서 셈 ÷ 배(옛 `1단위`) + times = calc.ratio_of(head, {"결과단위": row.get("결과단위")}, whole) # 1 단위 = 셈 ÷ 배 except sd.DocError as e: return {"같음": False, "까닭": str(e), "셈": None, "엑셀": excel, "줄": []} try: - mine_doc, ids, mids = _doc_of(bare, whole) - got = dim.run(mine_doc, bare, whole) + mine_doc, ids, mids = _doc_of(row, whole) + got = _dim().run(mine_doc, sk, whole) except Exception as e: # noqa: BLE001 — 변환 · 셈 틀림 = 맞댈 값 없음 got, ids, mids, mine_doc = {"셈됨": False, "까닭": str(e)}, [], {}, None money = dc.money(got) if got.get("셈됨") else None @@ -470,6 +421,25 @@ def check(doc: dict, whole: Any = None) -> dict[str, Any]: return _json({"같음": ok, "까닭": why, "셈": mine, "엑셀": excel, "줄": lines}) +def check(doc: dict, whole: Any = None) -> dict[str, Any]: + """검산 — 불러올 때 적은 것(가져온 줄은 저장 안 함 · 857-3b) · 이미 저장된 SK = 그 파일 것(화면 값 + 안 받음) · 옛 꼴 = 까닭 하나.""" + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + if old_form(doc): + return {"같음": False, "까닭": _dim().OLD_FORM, "셈": None, "엑셀": None, "줄": []} + have = skc.stored_doc(doc.get("키")) + if is_imported(have) and not old_form(have) and (have[KEY].get("검산")): + return have[KEY]["검산"] + return (doc.get(KEY) or {}).get("검산") or { + "같음": False, + "까닭": "검산 없음", + "셈": None, + "엑셀": None, + "줄": [], + } + + def _all_same(mine: dict, excel: dict) -> bool: return all(_same(mine.get(k), excel.get(k)) for k in excel) @@ -539,6 +509,8 @@ def more(out: dict, clean_: dict) -> dict: def _need(doc: Any) -> dict: if not is_imported(doc): raise sd.DocError("가져온 식 단가산출 아님") + if old_form(doc): + raise sd.DocError(_dim().OLD_FORM) return doc @@ -553,64 +525,53 @@ def to_price(doc: Any, basis: str) -> dict[str, Any]: raise sd.DocError("단가기준은 엑셀 · 우리") whole = _whole() after = _with(doc, 단가기준=basis) - before = _money(_run(doc, whole)) return { "문서": after, - "전": before, + "전": _money(_run(doc, whole)), "후": _money(_run(after, whole)), "이음없음": unlinked(doc), } -def link(doc: Any, spot: str, key: Any) -> dict[str, Any]: - """자원 줄 이음 고름 — 그 줄 `이음` · 줄 정체가 바뀐 만큼 덮개 · 뺀줄 · 글줄 · 까닭 열쇠 - 옮김.""" - doc = _need(doc) - whole = _whole() - old = sd.line_ids(row_of(doc)) - if spot not in old[: len(doc[KEY]["로직"]["호표"])]: - raise sd.DocError(f"없는 자원 줄 「{spot}」") - items = [dict(x) for x in doc[KEY]["로직"]["호표"]] - at = old.index(spot) - items[at]["이음"] = _link(key, items[at]["종류"], f"「{spot}」", whole) - after = _with(doc, 로직={**doc[KEY]["로직"], "호표": items}) - move = dict(zip(old, sd.line_ids(row_of(after)))) - return {"문서": _rekey(after, {a: b for a, b in move.items() if a != b})} +def docs_of(doc: dict) -> list[dict]: + """가져온 줄 고침을 얹을 문서 — 불러온 그대로(`가져온.문서`) + 줄 쌓기 따로 사본(있으면 · 같은 기호).""" + from M02_MasterTemplete import M02_Doc_Copy as dc - -def _rekey(doc: dict, move: dict) -> dict: - if not move: - return doc - out = dict(doc) - for name in _KEYED: - if isinstance(doc.get(name), dict): - out[name] = {move.get(c, c): v for c, v in doc[name].items()} - if isinstance(doc.get("뺀줄"), list): - out["뺀줄"] = [move.get(c, c) for c in doc["뺀줄"]] - if isinstance(doc.get("글줄"), list): - out["글줄"] = [{**t, "자리": move.get(t.get("자리"), t.get("자리"))} for t in doc["글줄"]] - out["더한줄"] = [_rate_rekey(x, move) for x in doc.get("더한줄") or []] - src = doc[KEY].get("원본") or {} - if src.get("글줄"): - lines = [ - {**t, "자리": move.get(t.get("자리"), t.get("자리"))} - | ({"자리들": [move.get(x, x) for x in t["자리들"]]} if t.get("자리들") else {}) - for t in src["글줄"] - ] - out[KEY] = {**out[KEY], "원본": {**src, "글줄": lines}} + out = [doc[KEY][FIRST]] + got = doc.get(dc.KEY) if isinstance(doc.get(dc.KEY), dict) else {} + if got.get("따로") and isinstance(got.get("문서"), dict): + out.append(got["문서"]) return out -def _rate_rekey(one: Any, move: dict) -> Any: - """율 더한줄 기준 줄 목록(778-4 · `열쇠@비목`) 열쇠 옮김.""" - rate = ((one.get("고정") or {}).get("비율") or {}) if isinstance(one, dict) else {} - if not isinstance(rate.get("기준"), list): - return one - keys = [] - for k in rate["기준"]: - head, _, part = str(k).partition("@") - keys.append(move.get(head, head) + (f"@{part}" if part else "")) - return {**one, "고정": {**one["고정"], "비율": {**rate, "기준": keys}}} +def link(doc: Any, spot: str, key: Any) -> dict[str, Any]: + """이음 없는 자원 줄 이음 고름(857-3b) — 그 가져온 줄 값 변수 연결 = 고른 이음(엑셀 값 기억) · + 자리 = 가져온 줄 `호표:i`(문서 머리 `이음없음`).""" + dim = _dim() + doc = cp.deepcopy(_need(doc)) + first = doc[KEY][FIRST] + var = next((v for v in first.get("변수") or [] if v.get(FROM) == spot), None) + line = next((x for x in first.get("금액") or [] if x.get(FROM) == spot), None) + if var is None or line is None: + raise sd.DocError(f"없는 자원 줄 「{spot}」") + kind = str(line.get("가져온종류") or "") + code = _link(key, kind, f"「{spot}」", _whole()) + if code is None: + raise sd.DocError(f"「{spot}」 · 이음 키 없음") + item = {"이음": code, "종류": kind, "비목": line.get("비목"), "단위": line.get("단위")} + got, note = dim._link_of(item) + if got is None: + raise sd.DocError(f"「{spot}」 · {note or '이을 수 없음'}") + sym, opt = dim.dc.md.var_id(var), got.pop(dim.OPTION, None) + for one in docs_of(doc): + mine = next((v for v in one.get("변수") or [] if dim.dc.md.var_id(v) == sym), None) + if mine is None or not _bare_value(mine): + continue + if opt and opt["열쇠"] not in {v.get("열쇠") for v in one["변수"]}: + one["변수"].append(opt) + mine["연결"] = {**cp.deepcopy(got), XL: mine["연결"].get("값")} + mine.pop("설명", None) if not note else mine.__setitem__("설명", note) + return {"문서": doc} # ── 만들기(개인 층) ─────────────────────────────────────────────────── @@ -618,37 +579,43 @@ def create( logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None, new: bool = False, use: str | None = None, ) -> dict[str, Any]: # fmt: skip - """엔진 로직 줄 + 원본 → 지금 층 새 가져온 식 SK — 서버가 다시 셈해 엑셀과 맞댐(검산 · - 다르면 `같음` False 로 표지 · 막지 않음) · 같은 층 같은 내용 = 409(`ask` · 733-2) · - 서버 길(POST sangeun/imported)은 853-3 에서 걷음 — 시험이 가져온 식 SK 바탕으로 씀.""" + """가져온 줄 + 원본 → 지금 층 새 가져온 식 SK(불러온 그대로 문서 · 검산) · 같은 층 같은 내용 = 409 + (`ask` · 733-2).""" return keep(new_doc(logic, source, name, unit, head), new, use) def new_doc( logic: Any, source: Any, name: str = "", unit: str = "", head: dict | None = None ) -> dict[str, Any]: - """가져온 식 SK 문서(키 없음 · 층에 안 씀).""" - row = clean_row(logic, _whole()) + """가져온 식 SK 문서(키 없음 · 층에 안 씀) — 불러온 그대로 문서를 한 번 지음(857-3b · 가져온 줄 안 둠).""" + whole = _whole() + row = clean_row(logic, whole) unit = str(unit or "").strip() or row["결과단위"].split("/", 1)[1] doc = {"키": "SK-000000", "이름": str(name or "").strip() or row["이름"], "단위": unit} doc |= {k: str((head or {}).get(k) or "") for k in ("구분", "상세구분")} doc |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []} - meta = {"로직": row, "단가기준": "엑셀"} - if source not in (None, {}): - meta["원본"] = _meta(source, "원본") - doc[KEY] = meta + raw = _meta(source, "원본") if source not in (None, {}) else {} + src = _named(raw, row) if raw else {} # 글줄 자리 = 줄 정체 cid(검산 · 셈 답 맞댐) + first = _norm(_dim().build(row, raw, whole)) # 다듬기 = 글줄 자리 이름 그대로(704) · JSON 꼴 + meta = {FIRST: first, "단가기준": "엑셀", "검산": check_row(row, src, doc, whole)} + doc[KEY] = meta | ({"원본": src} if src else {}) return doc +def _norm(doc: dict) -> dict: + from M02_MasterTemplete import M02_Doc_Copy as dc + + return json.loads(json.dumps(dc.ml._norm(doc), ensure_ascii=False, default=str)) + + def keep(doc: dict, new: bool = False, use: str | None = None) -> dict[str, Any]: """문서 → 지금 층 SK(같은 내용 = 409 · `use` = 그것을 씀 · 안 씀).""" from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Ask as ask - whole = _whole() - got = check(sd.clean(doc, None, whole), whole) key = ask.ask(sd.KIND, doc, new, use) or refs.create(sd.KIND, doc)["이름"] - return {"이름": key, "검산": got, "단가기준": (doc.get(KEY) or {}).get("단가기준") or "엑셀"} + meta = doc.get(KEY) or {} + return {"이름": key, "검산": check(doc), "단가기준": meta.get("단가기준") or "엑셀"} def draft(doc: dict) -> dict[str, Any]: @@ -657,8 +624,6 @@ def draft(doc: dict) -> dict[str, Any]: from M02_MasterTemplete import M02_Library_Ask as ask from M02_MasterTemplete import M02_MasterTemplete_Store as store - whole = _whole() - got = check(sd.clean(doc, None, whole), whole) try: ask.ask(sd.KIND, doc) same = None @@ -667,4 +632,54 @@ def draft(doc: dict) -> dict[str, Any]: if e.status != 409 or not rows: raise same = rows[0]["키"] - return {"문서": refs.clean_doc(sd.KIND, doc), "검산": got, "같은것": same} + return {"문서": refs.clean_doc(sd.KIND, doc), "검산": check(doc), "같은것": same} + + +# ── 산근 속 산근 참조(797-1 · `M02_Labor_Ref`) ────────────────────────── +def refs_of(doc: Any) -> list[dict]: + """가져온 식이 부르는 형제 SK 참조 `[{층, 주인, 키}]` — 불러온 그대로 · 따로 사본 문서의 단가산출 연결.""" + if not is_imported(doc) or old_form(doc): + return [] + out = [] + for one in docs_of(doc): + for var in one.get("변수") or []: + link = var.get("연결") or {} + if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict): + out.append({**link["참조"], "키": link.get("키")}) + return out + + +def move_refs(doc: dict, move: Any) -> dict: + """형제 SK 참조 자리를 `move(참조) → 새 참조` 로(층 옮김 · 복사) — 문서 사본을 고침.""" + if not is_imported(doc) or old_form(doc): + return doc + doc = cp.deepcopy(doc) + for one in docs_of(doc): + for var in one.get("변수") or []: + link = var.get("연결") or {} + if link.get("갈래") == "단가산출" and isinstance(link.get("참조"), dict): + new = move({**link["참조"], "키": link.get("키")}) + link["키"], link["참조"] = new["키"], {k: new.get(k) for k in ("층", "주인")} + return doc + + +def reach_of(doc: Any) -> tuple[list[str], list[str]]: + """값 사본이 닿을 것(`M02_Sangeun_Copy.stamp`) — 문서 연결의 (단가산출 키, 요소 키) · + 형제 SK · 입력 든 키(유가 지역 등) 뺌.""" + if not is_imported(doc) or old_form(doc): + return [], [] + keys, links = [], [] + for one in docs_of(doc): + for var in one.get("변수") or []: + link = var.get("연결") or {} + key = str(link.get("키") or "") + if not key or "{" in key or key.startswith("SK-"): + continue + if link.get("갈래") == "단가산출": + keys.append(key) + elif link.get("갈래") == "요소": + links.append(key) + for one_ in (one.get(KEY) or {}).get("기계") or []: # 시간당 연결 기계 = 판정 키(EQ) + if str(one_.get("키") or "")[:2] == "EQ": + links.append(str(one_["키"])) + return list(dict.fromkeys(keys)), list(dict.fromkeys(links)) diff --git a/M02_MasterTemplete/M02_Sangeun_QtyLinks.py b/M02_MasterTemplete/M02_Sangeun_QtyLinks.py index 737366239..56d628e30 100644 --- a/M02_MasterTemplete/M02_Sangeun_QtyLinks.py +++ b/M02_MasterTemplete/M02_Sangeun_QtyLinks.py @@ -8,8 +8,9 @@ 이름 문맥이 없어 자리 아님). 일반 수(1 · 10 · 60 · 100 · 1000 · 8) · 비교 글자 · 찾기 · 로직 부름 인자는 안 셈. - 고름 = 엑셀 수와 표 칸 값이 같을 때만(같은 값 · 율 ↔ 소수 · t ↔ kg) — 다르면 못 고름 + 까닭. - 기록(`가져온.연결` = {고름 [..], 버림 [..]})만 — 셈 · 금액 · 엔진 안 건드림 · [단가 갱신]은 자원 - 단가만(요구 656-1) · [재생성]이 이 기록을 따라가는 길은 아직 없음(기록만). + 기록(`가져온.연결` = {고름 [..], 버림 [..]}) + 문서 고침(857-3b) — 그 금액 줄 식의 그 수 자리 = 표 연결 + 변수(`소요량k` · 엑셀 칸 값 기억 · 금액 그대로) · 풂 = 수로 되돌림 · 자리 = 불러올 때 문서 머리 + `가져온.자리`(가져온 줄 수 차례 · 앞 수 `앞` → 문서 식 수 차례로 맞춤). - 고름 = {자리, 수, 층 「M01」, 표, 줄, 칸, 값, 꼴 eq|pct|kgt} · 로직이 바뀌어 자리의 수가 달라지면 그 기록은 버려진 것으로 보고 화면에 안 내놓음. @@ -18,12 +19,14 @@ from __future__ import annotations +import copy as cp import re from decimal import Decimal from typing import Any from M02_MasterTemplete import M02_San_Basis_Index as bi from M02_MasterTemplete import M02_San_Emit as em +from M02_MasterTemplete import M02_San_ToDoc as todoc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sangeun_Imported as imp @@ -40,19 +43,22 @@ def _flat(s: Any) -> str: return re.sub(r"[^가-힣A-Za-z0-9]", "", str(s or "")) +CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자 + + def _literals(node: Any, out: list[Decimal]) -> None: - """식 나무 → 수 글자(차례대로) — 비교 글자 · 찾기 · 로직 부름 인자는 뺌.""" + """식 나무(문서 파서) → 수 글자(차례대로) — 비교 글자는 뺌.""" if not isinstance(node, tuple): return kind = node[0] if kind == "num": out.append(node[1]) elif kind == "bin": - cmp_ = node[1] in bi.mf._OPS + cmp_ = node[1] in CMP for side in node[2:]: if not (cmp_ and isinstance(side, tuple) and side[0] == "num"): _literals(side, out) - elif kind in ("neg", "field"): + elif kind in ("neg", "pct", "field"): _literals(node[1], out) elif kind == "call": for arg in node[2]: @@ -62,8 +68,8 @@ def _literals(node: Any, out: list[Decimal]) -> None: def literals(text: Any) -> list[Decimal]: out: list[Decimal] = [] try: - _literals(bi.mf.parse(str(text)), out) - except bi.mf.FormulaError: + _literals(todoc.md.parse(str(text)), out) + except todoc.md.DocError: pass return out @@ -76,12 +82,14 @@ def slots(row: dict) -> list[dict]: if not isinstance(one, dict): continue labor = kind == "호표" and one.get("종류") == "인력" - for n, x in enumerate(literals(one.get(field))): + nums = literals(one.get(field)) + for n, x in enumerate(nums): if float(x) in GENERAL: continue out.append( { "자리": f"{kind}:{i}:{n}", + "앞": [str(v) for v in nums[:n]], "갈래": kind, "종류": str(one.get("종류") or ""), "줄": str(one.get("이름") or ""), @@ -218,11 +226,16 @@ def tally(scanned: list[dict]) -> dict[str, int]: # ── 고름 · 버림(문서 기록) ───────────────────────────────────────────── def _need(doc: Any) -> dict: - if not imp.is_imported(doc): - raise sd.DocError("가져온 식 단가산출만") + if not imp.is_imported(doc) or imp.old_form(doc): + raise sd.DocError("가져온 식 단가산출만(옛 꼴 = 다시 불러오기)") return doc +def _slots(doc: dict) -> list[dict]: + """불러올 때 적은 자리(문서 머리 `가져온.자리`).""" + return list(((doc[imp.KEY][imp.FIRST].get(imp.KEY) or {}).get("자리")) or []) + + def _state(doc: dict) -> dict[str, list]: meta = doc[imp.KEY].get(KEY) or {} return {"고름": list(meta.get("고름") or []), "버림": list(meta.get("버림") or [])} @@ -238,18 +251,18 @@ def view(doc: Any, idx: bi.Index | None = None) -> dict[str, Any]: """화면 답 — 자리마다 {자리, 줄, 수, 단위, 후보수, 후보, 상태 후보|없음|고름|버림, 고른}.""" doc = _need(doc) state, rows = _state(doc), [] - scanned = scan(doc[imp.KEY]["로직"], idx) + idx = idx or bi.get() + title = str(doc[imp.KEY][imp.FIRST].get("이름") or "") + scanned = [{**s, "후보": find(idx, s, title)} for s in _slots(doc)] picked = {x["자리"]: x for x in state["고름"] if x.get("수") is not None} dropped = set(state["버림"]) for s in scanned: mine = picked.get(s["자리"]) - if mine and abs(mine["수"] - s["수"]) > 1e-12: - mine = None # 로직이 바뀜 — 옛 기록 안 씀 if mine: # M01 칸 값이 그새 바뀌었으면 알림(기록은 그대로) now = next( ( c["v"] - for c in (idx or bi.get()).cells_of_table.get(mine["표"], []) + for c in idx.cells_of_table.get(mine["표"], []) if c["줄"] == mine["줄"] and c["칸"] == mine["칸"] ), None, @@ -284,10 +297,11 @@ def view(doc: Any, idx: bi.Index | None = None) -> dict[str, Any]: def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[str, Any]: - """후보 칸 고름 — 엑셀 수 = 칸 값일 때만(다르면 400 까닭) · 기록만 · 금액 그대로.""" - doc = _need(doc) + """후보 칸 고름 — 엑셀 수 = 칸 값일 때만(다르면 400 까닭) · 기록 + 문서 그 수 자리 = 표 연결 변수 + (엑셀 칸 값 기억 · 금액 그대로).""" + doc = cp.deepcopy(_need(doc)) idx = idx or bi.get() - slot = next((s for s in slots(doc[imp.KEY]["로직"]) if s["자리"] == spot), None) + slot = next((s for s in _slots(doc) if s["자리"] == spot), None) if slot is None: raise sd.DocError(f"없는 자리 「{spot}」") table = idx.tables.get(str((cell or {}).get("표"))) @@ -318,6 +332,11 @@ def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[s "값": found["v"], "꼴": how, } + conds = _conds(table, at) + for target in imp.docs_of(doc): + _unpick(target, spot) + if conds is not None: + _apply(target, slot, one, conds) state = _state(doc) state["고름"] = [x for x in state["고름"] if x.get("자리") != spot] + [one] state["버림"] = [x for x in state["버림"] if x != spot] @@ -325,33 +344,151 @@ def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[s def drop(doc: Any, spot: str, undo: bool = False) -> dict[str, Any]: - """자리 후보 버림(또는 [되돌리기]) — 고른 것이 있으면 같이 풂 · 기록만.""" - doc = _need(doc) - if not any(s["자리"] == spot for s in slots(doc[imp.KEY]["로직"])): + """자리 후보 버림(또는 [되돌리기]) — 고른 것이 있으면 같이 풂(문서 수 되돌림).""" + doc = cp.deepcopy(_need(doc)) + if not any(s["자리"] == spot for s in _slots(doc)): raise sd.DocError(f"없는 자리 「{spot}」") + for target in imp.docs_of(doc): + _unpick(target, spot) state = _state(doc) state["고름"] = [x for x in state["고름"] if x.get("자리") != spot] state["버림"] = [x for x in state["버림"] if x != spot] + ([] if undo else [spot]) return {"문서": _with(doc, state)} -def tidy(raw: Any, row: dict) -> dict[str, list]: - """저장 때 서버가 다시 거름(`M02_Sangeun_Imported.clean`) — 자리가 있고 수가 같은 기록만 · - 칸 값 대조는 고를 때(`pick`)만(M01 이 바뀌었으면 화면이 알림).""" - have = {s["자리"]: s["수"] for s in slots(row)} - raw = raw if isinstance(raw, dict) else {} - keep = ("자리", "수", "층", "표", "줄", "칸", "값", "꼴") - picked = [] - for x in raw.get("고름") or []: - if not (isinstance(x, dict) and x.get("자리") in have and x.get("꼴") in FORMS): +# ── 문서 고침(857-3b) — 그 수 자리 ↔ 표 연결 변수 ───────────────────────── +SPOT = "가져온자리" # 고른 칸 변수 — 자리 · 되돌릴 수 글 +SCALE = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)} + + +def _field(spot: str) -> str: + return "수량" if spot.startswith("호표:") else "단가" + + +def _line_of(doc: dict, spot: str) -> dict | None: + head = spot.rsplit(":", 1)[0] + return next((x for x in doc.get("금액") or [] if x.get(todoc.FROM) == head), None) + + +def _doc_nth(node: Any, before: list[str]) -> int | None: + """가져온 줄 n 번째 수(앞 수 `before`) → 문서 식 수 차례 — 문서 = 가져온 줄 수에서 군더더기 + (0 · 1 · 100)만 빠진 차례.""" + doc_nums: list[Decimal] = [] + _literals(node, doc_nums) + j = 0 + for v in (Decimal(x) for x in before): + if j < len(doc_nums) and doc_nums[j] == v: + j += 1 + return j if j < len(doc_nums) else None + + +def _swap(node: Any, n: int, new: tuple, seen: list) -> Any: + """`_literals` 차례의 n 번째 수 → `new` 마디.""" + if not isinstance(node, tuple): + return node + kind = node[0] + if kind == "num": + seen[0] += 1 + return new if seen[0] - 1 == n else node + if kind == "bin": + cmp_ = node[1] in CMP + sides = [ + side if cmp_ and side[0] == "num" else _swap(side, n, new, seen) for side in node[2:] + ] + return (kind, node[1], *sides) + if kind in ("neg", "pct", "field"): + return (kind, _swap(node[1], n, new, seen), *node[2:]) + if kind == "call": + return ("call", node[1], [_swap(a, n, new, seen) for a in node[2]]) + return node + + +def _conds(table: dict, at: int) -> dict | None: + """표 줄 차례 → 그 줄 하나만 맞는 조건 {조건: 값}(범위 = 위 끝 › 아래 끝) · 못 가림 = None.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + + rows = table.get("줄") or [] + if not (0 <= at < len(rows)): + return None + row, out = rows[at], {} + for cond, how in (table.get("조건") or {}).items(): + if cond not in row: continue - num = x.get("수") - if ( - isinstance(num, (int, float)) - and abs(num - have[x["자리"]]) <= 1e-12 - and x.get("층") == LAYER - ): - picked.append({k: x[k] for k in keep if k in x}) - done = {p["자리"] for p in picked} - gone = [x for x in raw.get("버림") or [] if isinstance(x, str) and x in have and x not in done] - return {k: v for k, v in (("고름", picked), ("버림", gone)) if v} + have = row[cond] + if how == "범위": + low, high = have + have = high if high is not None else low + if have is None: + return None + out[cond] = have + try: + hit = dc.ml.find(table, out) + except Exception: # noqa: BLE001 — 못 가림 = 수 그대로 + return None + return out if hit is row else None + + +def _times(one: dict, m: float) -> bool: + """칸 값 = 엑셀 수 × 배 m.""" + cell, v = float(one.get("값") or 0), float(one.get("수") or 0) + return abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell)) + + +def _apply(doc: dict, slot: dict, one: dict, conds: dict) -> None: + """문서 그 금액 줄 식의 그 수 → 표 연결 변수(÷ 배) · 줄 · 수가 안 맞으면 그대로(기록만).""" + from M02_MasterTemplete import M02_Doc_Import as dim + + spot = slot["자리"] + line, field = _line_of(doc, spot), _field(spot) + if line is None: + return + try: + node = todoc.md.parse(str(line.get(field))) + except todoc.md.DocError: + return + n = _doc_nth(node, list(slot.get("앞") or [])) + nums: list[Decimal] = [] + _literals(node, nums) + scale = next((m for m in SCALE.get(str(one["꼴"]), (1,)) if _times(one, m)), None) + if n is None or float(nums[n]) != float(slot["수"]) or scale is None: + return + taken = {str(v.get("열쇠")) for v in doc.get("변수") or []} + taken |= {todoc.md.var_id(v) for v in doc.get("변수") or []} + name = next(f"{dim.PICK}{k}" for k in range(1, 999) if f"{dim.PICK}{k}" not in taken) + ref = ("var", name) if scale == 1 else ("bin", "/", ("var", name), ("num", Decimal(str(scale)))) + line[field] = todoc.md.text_of(_swap(node, n, ref, [0])) + link = {"갈래": "표", "표": str(one["표"]), "조건": {k: dim._lit(v) for k, v in conds.items()}} + link |= {"칸": str(one["칸"]), dim.XL: Decimal(str(one["값"]))} + var = {"열쇠": name, "기호": name, "아래": "", "위": "", "이름": name, "단위": "", "연결": link} + doc.setdefault("변수", []).append(var | {SPOT: {"자리": spot, "수": str(nums[n])}}) + + +def _unpick(doc: dict, spot: str) -> None: + """그 자리 고른 칸 변수 → 원래 수로 되돌림 · 변수 지움.""" + mine = [v for v in doc.get("변수") or [] if (v.get(SPOT) or {}).get("자리") == spot] + if not mine: + return + line, field = _line_of(doc, spot), _field(spot) + for var in mine: + name, num = todoc.md.var_id(var), ("num", Decimal(var[SPOT]["수"])) + if line is not None: + try: + node = todoc.md.parse(str(line.get(field))) + line[field] = todoc.md.text_of(_back(node, name, num)) + except todoc.md.DocError: + pass + doc["변수"] = [v for v in doc["변수"] if v is not var] + + +def _back(node: Any, name: str, num: tuple) -> Any: + if not isinstance(node, tuple): + return node + if node == ("var", name) or (node[0] == "bin" and node[1] == "/" and node[2] == ("var", name)): + return num + if node[0] == "bin": + return ("bin", node[1], _back(node[2], name, num), _back(node[3], name, num)) + if node[0] in ("neg", "pct", "field"): + return (node[0], _back(node[1], name, num), *node[2:]) + if node[0] == "call": + return ("call", node[1], [_back(a, name, num) for a in node[2]]) + return node diff --git a/M02_MasterTemplete/logic/M02_Hopyo_Imported_Model.ts b/M02_MasterTemplete/logic/M02_Hopyo_Imported_Model.ts index 6d5a8598e..e1e12c4d9 100644 --- a/M02_MasterTemplete/logic/M02_Hopyo_Imported_Model.ts +++ b/M02_MasterTemplete/logic/M02_Hopyo_Imported_Model.ts @@ -18,7 +18,10 @@ export interface CheckLine { /** SK 문서 덧칸 `가져온` */ export interface ImportedMeta { - 로직?: { 이름?: string; 호표?: { 이름?: string; 이음?: string | null }[] }; + /** 불러온 그대로 수식 문서(857-3b · 정본) */ + 문서?: Record; + /** 옛 꼴(857-3b 앞 저장본 — 읽지 않음) */ + 로직?: unknown; 단가기준?: "엑셀" | "우리"; 원본?: { 파일?: string; @@ -50,7 +53,12 @@ export interface ImportedDoc { } /** 가져온 식(경쟁사 로직이 든 SK) */ -export const isImported = (d: ImportedDoc | null | undefined): boolean => !!d?.가져온?.로직; +export const isImported = (d: ImportedDoc | null | undefined): boolean => + !!(d?.가져온?.문서 || d?.가져온?.로직); + +/** 857-3b 앞 옛 꼴 저장본(읽지 않음 · 다시 불러오기) */ +export const isOldForm = (d: ImportedDoc | null | undefined): boolean => + !!d?.가져온?.로직 && !d?.가져온?.문서; /** 검산 다른 줄 */ export const wrongLines = (d: ImportedDoc): CheckLine[] => diff --git a/M02_MasterTemplete/logic/M02_Sangeun_Origin.ts b/M02_MasterTemplete/logic/M02_Sangeun_Origin.ts index aaefade58..ae55eae78 100644 --- a/M02_MasterTemplete/logic/M02_Sangeun_Origin.ts +++ b/M02_MasterTemplete/logic/M02_Sangeun_Origin.ts @@ -7,6 +7,8 @@ * ========================================================================== */ export interface OriginMeta { + /** 불러온 그대로 문서(857-3b) · 옛 꼴 = 로직 */ + 문서?: unknown; 로직?: unknown; 원본?: { 파일?: string; @@ -84,7 +86,7 @@ const localTime = (s?: string): string => { /** 가져온 식이 아니면 null */ export function originOf(meta: OriginMeta | null | undefined): Origin | null { - if (!meta?.로직 || !meta.원본) return null; + if (!(meta?.문서 || meta?.로직) || !meta.원본) return null; const src = meta.원본; const code = src.코드 ?? ""; const block = src.갈래 === "EST" && code !== "" ? `단산${code}` : String(code); diff --git a/resources/tester/golden_855_b09.json b/resources/tester/golden_855_b09.json index bf39536aa..c901507dc 100644 --- a/resources/tester/golden_855_b09.json +++ b/resources/tester/golden_855_b09.json @@ -3,7 +3,7 @@ "지문": { "키": "e68369418202e5ee", "calc_user": "6d74551273d6735f", - "daega_inputs": "d26099b92d7d0a1b", + "daega_inputs": "e5632248d8d1444e", "수요": "f793204cf95c45c4", "산근 값": "c486d041a3246ffb", "산근 글": "a21b34ec13661f0c", diff --git a/resources/tester/helper_857_import.py b/resources/tester/helper_857_import.py index ffbb4f759..5b557dcf7 100644 --- a/resources/tester/helper_857_import.py +++ b/resources/tester/helper_857_import.py @@ -1,7 +1,7 @@ """857-0 지킴 도우미 — 불러오기 지문(블록 × 두 판 · 검산 · 이음 / 엑셀 올림 · 호표 목록 · 칠 · 고정 줄 / 재료 이음 표). -- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(저장 없음) → +- 블록 = 견본(원파일 EST · STC · 실무 엑셀)마다 `Doc_FromNative.emit` → 가져온 식 SK(`new_doc` · 저장 없음) → 엑셀 판 · 우리 판 문서 셈(`Doc_Import.derive` + `run`) 노 · 재 · 경 · 계 + 검산(`Sangeun_Imported.check` 같음 · 줄 같음 수) + 줄마다 이음(종류 · 이음 · 기계 찾기 · 재료 찾기 판정 · 키). @@ -143,12 +143,9 @@ def block(saved: dict, no: int) -> dict: out = fn.emit(saved, no) row = out["로직"] sk = { + **imp.new_doc(row, out["원본"], row["이름"]), "키": "SK-999999", - "이름": row["이름"], - "단위": str(row.get("결과단위", "/")).split("/", 1)[-1], - } - sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []} - sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"} + } # 857-3b 불러온 그대로 문서 sk = sd.clean(sk, None, whole) got: dict[str, Any] = {"이음": _links(row)} for basis in ("엑셀", "우리"): diff --git a/resources/tester/test_792_3_engine_paths.py b/resources/tester/test_792_3_engine_paths.py index c06e7ac3b..ff2b1a75d 100644 --- a/resources/tester/test_792_3_engine_paths.py +++ b/resources/tester/test_792_3_engine_paths.py @@ -181,10 +181,13 @@ def test_실무_가져온_식_SK_대가_내역_엑셀(tag, code, world): whole = m01.loaded()[1] rid = "project||SK-990001" frozen = item_sk.freeze({rid: sd.clean(doc, None, whole)})[rid] - key, row = frozen["바탕"]["로직"], json.loads(json.dumps(frozen[item_sk.ROW])) - assert ms_uses(row) # 새 의미 로직(줄 자리 · 번지 · 단계) - books = {"labor": [], "material": [], "machine": [], "gaps": []} # 엑셀 단가 = 고정 줄 - got = _daega(sc._Over(whole, key, row), frozen, books) + # 857-3b 가져온 식 = 수식 문서만(가져온 줄 없음) → 굳힌 사본도 문서 셈(옛 굳힘 ROW 번지 · 단계 없음 · + # B09 대가 블록 줄 = B9-5 문서 셈 줄 뒤 다시 확인) + from M02_MasterTemplete import M02_Sangeun_Calc as calc + + over = sc._Over(whole, frozen["바탕"]["로직"], json.loads(json.dumps(frozen[item_sk.ROW]))) + unit = calc.run(sd.clean(frozen, None, over), over)["1단위"] + got = {k: D(str(round(float(v)))) for k, v in unit.items()} excel = {k: D(str(round(v))) for k, v in out["원본"]["엑셀금액"].items()} assert got == excel diff --git a/resources/tester/test_793_2_sangeun_imported.py b/resources/tester/test_793_2_sangeun_imported.py index d4efcf548..bd147eca1 100644 --- a/resources/tester/test_793_2_sangeun_imported.py +++ b/resources/tester/test_793_2_sangeun_imported.py @@ -3,9 +3,9 @@ - 견본 둘 = 791-1 손 옮김 견본(봉화 D00102 합판거푸집 STmate 번지 · 율 / 북부청임도 18 문양거푸집 EST 줄 자리) · 단가 = 엑셀 목록표 값 → 셈 = 엑셀 금액 · 줄마다 검산 -- 덮개 · 상수 덮개 · 식 칸 · 변수 줄이 가져온 줄에도 먹음 +- 857-3b 저장 = 불러온 그대로 문서(`가져온.문서`) · 가져온 줄 안 둠 · 옛 칸 고침(덮개 · 더한줄 …) = 못 셈 - 셈 답 `원래` = 엑셀 금액 · `가져온` 원본 글 -- [우리 단가로] · [엑셀 단가로] · 이음 고름(덮개 열쇠 옮김) · [우리 기초로 바꾸기] 없음(809-1) +- [우리 단가로] · [엑셀 단가로] · 이음 고름(문서 연결) · [우리 기초로 바꾸기] 없음(809-1) - 만들기(임시 층) · 같은 내용 409 · 옛 SK 지문 그대로 · 펼침 막음 · B09 굳힘 · 단가 전파 """ @@ -117,10 +117,12 @@ def _bukbu() -> tuple[dict, dict]: return row, src -def _doc(sample=_bonghwa, **more): +def _doc(sample=_bonghwa, src_fix=None, **more): row, src = sample() - meta = {"로직": row, "단가기준": "엑셀", "원본": src} - return {"키": "SK-000001", "이름": "가져온", "단위": "㎡", "바탕": None, imp.KEY: meta, **more} + if src_fix: + src_fix(src) + doc = imp.new_doc(row, src, "가져온", "㎡") # 857-3b 불러온 그대로 문서 + return {**doc, "키": "SK-000001", **more} def _run(doc, whole=None): @@ -141,10 +143,12 @@ def test_봉화_셈_엑셀_검산(): assert _sum(_doc()) == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652} got = imp.check(sd.clean(_doc(), None, _whole())) assert got["같음"] is True and len(got["줄"]) == 4 and all(x["같음"] for x in got["줄"]) - bad = _doc() - bad[imp.KEY]["원본"]["엑셀금액"]["계"] = 45653 - bad[imp.KEY]["원본"]["글줄"][1]["값"] = 3870 - got = imp.check(sd.clean(bad, None, _whole())) + + def lie(src): + src["엑셀금액"]["계"] = 45653 + src["글줄"][1]["값"] = 3870 + + got = imp.check(sd.clean(_doc(src_fix=lie), None, _whole())) assert got["같음"] is False and got["까닭"] == "금액 다름" assert got["줄"][0]["까닭"] == "셈 3862.5 · 엑셀 3870" @@ -154,28 +158,30 @@ def test_북부청_18_줄_자리_셈_엑셀(): assert imp.check(sd.clean(_doc(_bukbu), None, _whole()))["같음"] is True -# ── 덮개 · 식 칸 · 셈 답 ───────────────────────────────────────────── -def test_덮개_상수_식칸_가져온_줄에_먹음(): - base = _total(_doc()) - covered = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}) - assert _total(covered) > base # 형틀목공 5/50 → 0.2 인 - assert ( - _total(_doc(상수덮개={BURN: {"0": 12}})) == 45652 + 101 - ) # 소모자재 11 → 12 %(A01 재료 10,083.7 × 1 %) - assert _total(_doc(식덮개={"labor:형틀목공#0": "6 / 50"})) > base - var = [{"이름": "할증", "식": "1.2", "자리": ""}] - assert _total(_doc(변수줄=var, 식덮개={"labor:형틀목공#0": "5 / 50 * 할증"})) > base - assert _total(_doc(뺀줄=[PLY])) < base - adds = [{"종류": "인력", "요소": MAN, "수량": 0.01}] - assert _total(_doc(더한줄=adds)) > base +# ── 옛 칸 고침 · 셈 답 ──────────────────────────────────────────────── +@pytest.mark.parametrize( + "more", + [ + {"덮개": {"labor:형틀목공#0": {"qty": 0.2}}}, + {"상수덮개": {BURN: {"0": 12}}}, + {"뺀줄": [PLY]}, + {"더한줄": [{"종류": "인력", "요소": MAN, "수량": 0.01}]}, + ], +) +def test_옛_칸_고침_못_셈(more): + """857-3b — 가져온 식도 옛 칸 고침 = 셈 안 함(2-C1 · 고침 = 줄 쌓기 문서).""" + from M02_MasterTemplete import M02_Doc_Sk as dsk + + got = _run(_doc(**more)) + assert got["1단위"] is None and got["까닭"] == dsk.OLD_WHY def test_셈_답_원래_엑셀_원본_글(world): - doc = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}, 까닭={"labor:형틀목공#0": "현장 품"}) + doc = _doc() with store.at(world["personal"]): got = calc.calc_doc(doc) assert got["원래"] == {"노무비": 34119, "재료비": 11192, "경비": 341, "계": 45652} - assert got["기준"]["계"] > 45652 + assert got["기준"]["계"] == 45652 view = got[imp.KEY] assert view["단가기준"] == "엑셀" and view["파일"] == "봉화.xlsx" and view["행"] == [2909, 2943] lines = view["글줄"] @@ -198,21 +204,23 @@ def test_우리_단가로_엑셀_단가로(): imp.to_price({"키": "SK-000001", "바탕": {"로직": FORM}}, "우리") -def test_이음_고름_덮개_열쇠_옮김(): - doc = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}, 까닭={"labor:형틀목공#0": "현장"}) - doc["글줄"] = [{"자리": "labor:형틀목공#0", "글": "※ 현장 조정"}] - got = imp.link(doc, "labor:형틀목공#0", CARP)["문서"] - new = f"labor:{CARP}#0" - assert got["덮개"] == {new: {"qty": 0.2}} and got["까닭"] == {new: "현장"} - assert got["글줄"][0]["자리"] == new - assert got[imp.KEY]["원본"]["글줄"][2]["자리"] == new +def test_이음_고름_문서_연결(): + """857-3b — 이음 고름 = 그 가져온 줄 값 변수 연결(엑셀 값 기억 · 엑셀 판 금액 그대로).""" + doc = _doc() + spot = "호표:2" # 형틀목공 + assert spot in {x["자리"] for x in imp.unlinked(doc)} + got = imp.link(doc, spot, CARP)["문서"] + var = next(v for v in got[imp.KEY]["문서"]["변수"] if v.get(imp.FROM) == spot) + assert var["연결"]["갈래"] == "요소" and var["연결"]["키"] == CARP + assert var["연결"]["엑셀"] == 274978 # 엑셀 단가 기억 + assert spot not in {x["자리"] for x in imp.unlinked(got)} assert _total(got) == _total(doc) # 엑셀 단가 그대로 = 금액 그대로 ours = imp.to_price(got, "우리") assert len(ours["이음없음"]) == 2 and ours["후"]["계"] != ours["전"]["계"] with pytest.raises(sd.DocError): - imp.link(doc, "labor:형틀목공#0", "LB999999") + imp.link(doc, spot, "LB999999") with pytest.raises(sd.DocError): - imp.link(doc, "labor:없는줄#0", CARP) + imp.link(doc, "호표:99", CARP) def test_우리_기초로_바꾸기_없음(): @@ -234,10 +242,10 @@ def test_우리_기초로_바꾸기_없음(): ], ) def test_틀린_가져온_로직(change, why): - doc = _doc() - change(doc[imp.KEY]["로직"]) + row, src = _bonghwa() + change(row) with pytest.raises(sd.DocError, match=why): - sd.clean(doc, None, _whole()) + imp.new_doc(row, src, "가져온", "㎡") def test_바탕과_같이_못_둠_펼침_막음(): @@ -262,7 +270,9 @@ def test_만들기_저장_같은_내용(world): assert made["검산"]["같음"] is True and made["단가기준"] == "엑셀" meta = doc[imp.KEY] assert doc["바탕"] is None and doc["단위"] == "㎡" and meta["원본"] == src - assert meta["검산"]["같음"] is True and meta["로직"]["호표"][3]["이음"] == MAN + assert "로직" not in meta # 857-3b 가져온 줄 안 둠 · 정본 = 문서 + man = next(v for v in meta["문서"]["변수"] if v.get(imp.FROM) == "호표:3") + assert meta["검산"]["같음"] is True and man["연결"]["키"] == MAN assert again != made["이름"] != ours plain = {"키": "SK-000009", "이름": "x", "단위": "식", "바탕": {"로직": FORM}, "입력값": F211} one = same.finger("sangeun", doc) @@ -304,7 +314,7 @@ def _frozen_total(doc, whole): rid = "personal|7/42|SK-000001" frozen = sk.freeze({rid: sd.clean(doc, None, _whole())})[rid] key, row = frozen["바탕"]["로직"], json.loads(json.dumps(frozen[sk.ROW])) - assert key.startswith("GX9") and frozen["원본"][imp.KEY]["로직"] + assert key.startswith("GX9") and frozen["원본"][imp.KEY]["문서"] over = calc._Over(whole, key, row) return float(calc.run(sd.clean(frozen, None, over), over)["1단위"]["계"]) @@ -318,15 +328,13 @@ def test_B09_굳힘_단가_전파(): up = _Priced(whole, MAN, float(whole.get(MAN)["값"]) + 50000) assert _frozen_total(excel, up) == 45652 # 엑셀 단가 그대로 = 안 바뀜 assert _frozen_total(ours, up) == pytest.approx(live + 50000 * 2 / 50 * 1.01, abs=2) - covered = _doc(덮개={"labor:형틀목공#0": {"qty": 0.2}}) - assert _frozen_total(covered, whole) == _total(covered) def test_원본_보존_사본(): doc = _doc() keep = copy.deepcopy(doc) imp.to_price(doc, "우리") - imp.link(doc, "labor:형틀목공#0", CARP) + imp.link(doc, "호표:2", CARP) assert doc == keep # 받은 문서 안 고침(화면 캐시 = 답 문서로 바꿈) assert refs.kind_of("SK-000001") == "sangeun" and MINE["층"] == "personal" assert flat.flat_doc("sangeun", doc) == doc # 참조 없음 = 그대로 @@ -382,4 +390,38 @@ def test_실무_블록_가져온_식(tag, code, world): assert _frozen_total(doc, _whole()) == excel["계"] ours = imp.to_price(doc, "우리") assert {k: round(float(v)) for k, v in ours["전"].items()} == excel - assert len(ours["이음없음"]) < len(doc[imp.KEY]["로직"]["호표"]) # 1차 줄 판정 이음 + assert len(ours["이음없음"]) < len(out["로직"]["호표"]) # 1차 줄 판정 이음 + + +# ── 857-3b 옛 꼴 저장본(`가져온.로직`) = 읽지 않음 · 까닭 하나 ────────────────── +def test_옛_꼴_저장본_까닭_하나(world): + """857-3b — 옛 꼴(가져온 줄만 · 문서 없음) = 셈 · 검산 · 고침 모두 까닭 하나 · 파일 그대로.""" + from M02_MasterTemplete import M02_Doc_Import as dim + from M02_MasterTemplete import M02_Doc_Sk_Path as path + from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty + + row, src = _bonghwa() + old = {"키": "SK-000001", "이름": "옛 꼴", "단위": "㎡", "바탕": None, "입력값": {}} + old[imp.KEY] = {"로직": row, "단가기준": "엑셀", "원본": src} + assert imp.is_imported(old) and imp.old_form(old) + got = _run(old) + assert got["1단위"] is None and got["수식셈"]["까닭"] == dim.OLD_FORM + assert imp.check(old)["까닭"] == dim.OLD_FORM + for edit in ( + lambda: imp.to_price(old, "우리"), + lambda: imp.link(old, "호표:2", CARP), + lambda: qty.view(old), + ): + with pytest.raises(sd.DocError): + edit() + with store.at( + world["personal"] + ): # 857-3b 앞 저장본 = 그대로(지우지 않음 · 고치지 않음) · 열기 = 까닭 + file = store.root() / "sangeun" / "SK-000777.json" + file.parent.mkdir(parents=True, exist_ok=True) + body = {"종류": sd.TITLE, **old, "키": "SK-000777", "덮개": {}, "뺀줄": [], "더한줄": []} + file.write_text(json.dumps(body, ensure_ascii=False, default=str), "utf-8") + before = file.read_bytes() + read = path.read("SK-000777") + assert read["셈"]["셈됨"] is False and dim.OLD_FORM in json.dumps(read, ensure_ascii=False) + assert file.read_bytes() == before diff --git a/resources/tester/test_793_3b_import_screen.py b/resources/tester/test_793_3b_import_screen.py index 4415f5128..02986b756 100644 --- a/resources/tester/test_793_3b_import_screen.py +++ b/resources/tester/test_793_3b_import_screen.py @@ -69,7 +69,7 @@ def test_단산_블록_가져온_식_만들기_다시씀_지움(client): ten = _open(client, 10).json() # 야면석소운반 — 근거 기초 제안 없음(809-1 · 요구 703) with store.at(folder): meta = store.read("sangeun", ten["이름"])["문서"]["가져온"] - assert meta["로직"] and "근거후보" not in meta + assert meta["문서"] and "로직" not in meta and "근거후보" not in meta # 857-3b 문서 정본 assert _open(client, 99999).status_code == 404 fh._path(folder, KEY).unlink() # 산근 없는 옛 HP = 다시 올림 old = _open(client) diff --git a/resources/tester/test_796_2b_m02_equation.py b/resources/tester/test_796_2b_m02_equation.py index a7245d468..9bc4b2c9b 100644 --- a/resources/tester/test_796_2b_m02_equation.py +++ b/resources/tester/test_796_2b_m02_equation.py @@ -15,7 +15,6 @@ from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Sangeun_Equation as eqm from M02_MasterTemplete import M02_Sangeun_Imported as imp from resources.tester.test_795_1_sk_copy import ( - _calc, _doc, _imported_row, _save, @@ -35,18 +34,16 @@ KEY = "GC000211" # 합판거푸집 — 중간 시공량 · 형틀목공 · 보 DOUBLE = [{"할일": "식", "자리": "호표:0", "식": "형틀목공 × 2", "까닭": "sub2임시 시험"}] -def test_imported_same_path(world): - """⑥ 가져온 식 SK(바탕 null · 가져온.로직) — 같은 고침 · 저장.""" +def test_imported_old_equation_edit_refused(world): + """⑥ 857-3b 가져온 식 SK(불러온 그대로 문서 · 가져온 줄 안 둠) — 옛 식 칸 고침은 얹을 줄 없음(고침 = 줄 쌓기).""" me = world["personal"] with store.at(me): key = imp.create(_imported_row(), None, "sub2임시 가져온")["이름"] doc = _doc(me, key) - was = _calc(me, doc)["기준"]["노무비"] + assert "로직" not in doc["가져온"] and doc["가져온"]["문서"]["금액"] edit = [{"할일": "식", "자리": "호표:0", "식": "0.5 × 2"}] - _save(me, key, {**doc, eqm.KEY: edit}) - now = _calc(me, _doc(me, key)) - assert now["기준"]["노무비"] == pytest.approx(was * 2, abs=1) - assert _doc(me, key)["가져온"]["로직"]["호표"][0]["수량"] == "0.5" # 엑셀 줄 그대로 + with pytest.raises(Exception, match="수식 고침 못 얹음"): + _save(me, key, {**doc, eqm.KEY: edit}) def test_screen_same_part_first_tab(): diff --git a/resources/tester/test_797_1_import_links.py b/resources/tester/test_797_1_import_links.py index b8acb41dc..5215d62df 100644 --- a/resources/tester/test_797_1_import_links.py +++ b/resources/tester/test_797_1_import_links.py @@ -33,8 +33,21 @@ KEY = "HP-000001" def _doc(items: list[dict], excel: dict | None = None) -> dict: row = {"이름": "연결 견본", "결과단위": "원/식", "호표": items} - meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": excel or {}}} - return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta} + doc = imp.new_doc(row, {"엑셀금액": excel or {}}, "견본", "식") # 857-3b 불러온 그대로 문서 + return {**doc, "키": "SK-000001"} + + +def _money(doc: dict) -> float: + """저장 SK 셈(단가기준 그대로 · 형제 SK 연결 따라감).""" + from M02_MasterTemplete import M02_Doc_Import as dim + + return float(dim.run(dim.derive(doc), doc)["계"]) + + +def _inner(doc: dict) -> list[dict]: + """형제 SK 연결 변수(산근 속 산근 797-1).""" + first = doc[imp.KEY]["문서"] + return [v for v in first["변수"] if (v.get("연결") or {}).get("참조")] def _item(kind: str, name: str, price: float, part: str, link: str | None, qty: str = "1"): @@ -123,10 +136,11 @@ def test_nested_stmate_follows_inner(world) -> None: with store.at(folder): made = fh.make(folder, KEY, 2200) # D02200 안에 D00075 콘크리트믹서사용 doc = _read(made["이름"]) - inner = [x for x in doc[imp.KEY]["로직"]["호표"] if x.get("참조")] - assert len(inner) == 1 and inner[0]["값묶음"]["노무비"] == 6216 # 엑셀 얼린 값은 곁에 남음 - ref = inner[0]["참조"] + inner = _inner(doc) + assert len(inner) == 1 and inner[0]["연결"]["엑셀"]["노무비"] == 6216 # 엑셀 값 기억 + ref = {**inner[0]["연결"]["참조"], "키": inner[0]["연결"]["키"]} assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383 + assert _money(doc) == 67383 assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK assert refs.users(ref) # 쓰는 곳에 바깥 SK with pytest.raises(store.StoreError) as why: @@ -134,18 +148,22 @@ def test_nested_stmate_follows_inner(world) -> None: assert why.value.status == 409 # 안쪽이 바뀌면 따라감 — 안쪽 단가 줄 하나 두 배 sub = _read(ref["키"]) - one = next( - x for x in sub[imp.KEY]["로직"]["호표"] if "값묶음" in x - ) # 814-1 기계 세 줄 = 값묶음 한 줄 - one["값묶음"] = {k: v * 2 for k, v in one["값묶음"].items()} + link = next( # 엑셀 값(숫자 연결 값 · 이은 줄 엑셀 기억) 한 칸 두 배 + v["연결"] + for v in sub[imp.KEY]["문서"]["변수"] + if (v.get("연결") or {}).get("갈래") == "숫자" or "엑셀" in (v.get("연결") or {}) + ) + at = "값" if link.get("갈래") == "숫자" else "엑셀" + got = link[at] + link[at] = {k: x * 2 for k, x in got.items()} if isinstance(got, dict) else got * 2 store.write("sangeun", ref["키"], store.read("sangeun", ref["키"])["판"], sub) - inner_now = imp.check(_read(ref["키"]))["셈"]["계"] + inner_now = _money(_read(ref["키"])) assert inner_now != 7528 - assert imp.check(doc)["셈"]["계"] == pytest.approx(67383 - 7528 + inner_now, abs=1) + assert _money(doc) == pytest.approx(67383 - 7528 + inner_now, abs=1) # 바깥이 따라감 # 단가기준 따라감 — 안쪽 SK 가 우리 단가로 저장돼도 엑셀 기준 바깥은 엑셀 값 ours_sub = imp.to_price(_read(ref["키"]), "우리")["문서"] store.write("sangeun", ref["키"], store.read("sangeun", ref["키"])["판"], ours_sub) - assert imp.check(doc)["셈"]["계"] == pytest.approx(67383 - 7528 + inner_now, abs=1) + assert _money(doc) == pytest.approx(67383 - 7528 + inner_now, abs=1) assert imp.to_price(doc, "우리")["후"] is not None @@ -154,11 +172,11 @@ def test_nested_est_by_part_matches_excel(world) -> None: with store.at(folder): made = fh.make(folder, KEY, 67) # 단산68 세 줄 = 묶음 한 줄로 부름(812-1 · 원파일 길) doc = _read(made["이름"]) - inner = [x for x in doc[imp.KEY]["로직"]["호표"] if x.get("참조")] - assert len(inner) == 1 and "참조비목" not in inner[0] + inner = _inner(doc) + assert len(inner) == 1 and "칸" not in inner[0]["연결"] assert made["검산"]["같음"] is True # 엑셀 단가 그대로 금액 = 굳힌 값 합과 같음 - frozen = sum(float(v) for v in inner[0]["값묶음"].values()) + frozen = sum(float(v) for v in inner[0]["연결"]["엑셀"].values()) assert float(made["검산"]["셈"]["계"]) == pytest.approx( float(made["검산"]["엑셀"]["계"]), abs=1 ) diff --git a/resources/tester/test_797_2_qty_coef_links.py b/resources/tester/test_797_2_qty_coef_links.py index 58d473a03..fc9c21eb3 100644 --- a/resources/tester/test_797_2_qty_coef_links.py +++ b/resources/tester/test_797_2_qty_coef_links.py @@ -97,8 +97,8 @@ def _line(kind: str, name: str, qty_: str, unit: str = "", price: float = 1000.0 def _doc(row: dict) -> dict: - meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}}} - return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta} + """857-3b 가져온 식 SK = 불러온 그대로 문서(자리 = 문서 머리 `가져온.자리`).""" + return {**imp.new_doc(row, {"엑셀금액": {}}, "견본", "식"), "키": "SK-000001"} ROW = _row( @@ -169,8 +169,7 @@ def test_pick_records_cell_and_money_unchanged(idx) -> None: "eq", ) assert one["수"] == one["값"] == 0.05 - assert _money(got) == _money(doc) # 기록만 — 금액 그대로 - assert got[imp.KEY]["로직"] == doc[imp.KEY]["로직"] # 엑셀 줄 안 건드림 + assert _money(got) == _money(doc) # 엑셀 칸 값 기억 — 금액 그대로 view = {x["자리"]: x for x in qty.view(got, idx)["줄"]} assert view["호표:1:0"]["상태"] == "고름" and view["호표:1:0"]["고른"]["같음"] is True assert view["호표:0:0"]["상태"] == "후보" and view["호표:2:0"]["상태"] == "없음" @@ -213,17 +212,14 @@ def test_pick_twice_replaces_and_drop_undo(idx) -> None: # ── ③ 저장 거름 · 서버 길 ────────────────────────────────────────────── -def test_clean_keeps_valid_and_drops_stale(idx) -> None: +def test_clean_keeps_record(idx) -> None: + """857-3b — 저장 거름 = 기록 꼴만(자리는 불러올 때 문서 머리에 굳음 · 가져온 줄이 안 바뀜).""" whole = m01.loaded()[1] got = qty.pick(_doc(ROW), "호표:1:0", {"표": "QC900001", "줄": 0, "칸": "특별인부"}, idx)[ "문서" ] kept = sd.clean(got, None, whole)[imp.KEY]["연결"] assert kept["고름"][0]["표"] == "QC900001" - got[imp.KEY]["연결"]["고름"][0]["수"] = 0.5 # 로직 수와 안 맞음 → 거름 - got[imp.KEY]["연결"]["버림"] = ["호표:0:0", "호표:99:0", {"x": 1}] - again = sd.clean(got, None, whole)[imp.KEY]["연결"] - assert "고름" not in again and again["버림"] == ["호표:0:0"] got[imp.KEY]["연결"] = "엉뚱" with pytest.raises(sd.DocError): sd.clean(got, None, whole) diff --git a/resources/tester/test_802_4b1_import_doc.py b/resources/tester/test_802_4b1_import_doc.py index 4bd3bb069..91d1ab238 100644 --- a/resources/tester/test_802_4b1_import_doc.py +++ b/resources/tester/test_802_4b1_import_doc.py @@ -23,7 +23,6 @@ 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_Doc_Sk as dsk from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Hopyo_Store as hs from M02_MasterTemplete import M02_Machine_Hourly as machine @@ -36,10 +35,14 @@ from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 KEY = "HP-000001" +def _row(items: list[dict], extra: dict | None = None) -> dict: + return {"이름": "견본 sub2임시", "결과단위": "원/식", "호표": items, **(extra or {})} + + def _doc(items: list[dict], extra: dict | None = None, src: dict | None = None) -> dict: - row = {"이름": "견본 sub2임시", "결과단위": "원/식", "호표": items, **(extra or {})} - meta = {"로직": row, "단가기준": "엑셀", "원본": {"엑셀금액": {}, **(src or {})}} - return {"키": "SK-000001", "이름": "견본", "단위": "식", "바탕": None, imp.KEY: meta} + """857-3b 가져온 식 SK = 불러온 그대로 문서(가져온 줄 안 둠).""" + doc = imp.new_doc(_row(items, extra), {"엑셀금액": {}, **(src or {})}, "견본", "식") + return {**doc, "키": "SK-000001"} def _item(kind: str, name: str, price: float, part: str, link: str | None = None, qty_="1"): @@ -104,8 +107,9 @@ def test_machine_without_hourly_keeps_number_with_note() -> None: assert dim.run(dim.derive(doc), _ours(doc))["계"] == 5000 -def test_sk_money_is_doc_calc_and_equals_old_engine(world) -> None: - """⑤ SK 금액 = 문서 셈(수식셈 표지) = 옛 엔진 셈 — 엑셀 · 우리 둘 다 · 덧줄 율 · 합밖.""" +def test_sk_money_is_doc_calc(world) -> None: + """⑤ SK 금액 = 문서 셈 — 엑셀 · 우리 둘 다 · 덧줄 율 · 합밖(옛 엔진 대조는 857-3b 에서 걷음 — + 가져온 줄을 안 두어 옛 엔진이 읽을 줄 없음).""" items = [ _item("인력", "보통인부", 100000, "노무비", "LB000002", "0.33"), _item("재료", "경유", 1700, "재료비", "MO000002", "3") | {"합밖": True}, @@ -114,13 +118,7 @@ def test_sk_money_is_doc_calc_and_equals_old_engine(world) -> None: doc = _doc(items, extra) for basis in ("엑셀", "우리"): mine = imp._with(doc, 단가기준=basis) - new = imp._money(imp._run(mine, imp._whole())) - token = dsk.OLD.set(True) - try: - old = imp._money(imp._run(mine, imp._whole())) - finally: - dsk.OLD.reset(token) - assert new == old, basis + assert imp._money(imp._run(mine, imp._whole())) is not None, basis got = imp.to_price(doc, "우리") assert got["전"]["계"] == 33000 + 990 and got["후"]["계"] != got["전"]["계"] @@ -154,11 +152,11 @@ def test_stmate_nested_is_sibling_link(world) -> None: assert dim.run(root, doc)["계"] == 67383 == made["검산"]["엑셀"]["계"] assert dim.run(root, _ours(doc))["셈됨"] is True sub = _read(inner["키"]) # 안쪽 단가 줄 하나 두 배 → 바깥이 따라감(엑셀 기준도) - one = sub[imp.KEY]["로직"]["호표"][0] # 단가 한 칸 · 값 묶음(노 · 재 · 경) 한 줄 둘 다 있음 - if "단가" in one: - one["단가"] = one["단가"] * 2 - else: - one["값묶음"] = {k: v * 2 for k, v in one["값묶음"].items()} + one = next( # 가져온 값 변수 하나(단가 한 칸 · 값 묶음) 두 배 + v for v in sub[imp.KEY]["문서"]["변수"] if (v.get("연결") or {}).get("갈래") == "숫자" + ) + got = one["연결"]["값"] + one["연결"]["값"] = {k: x * 2 for k, x in got.items()} if isinstance(got, dict) else got * 2 store.write("sangeun", inner["키"], store.read("sangeun", inner["키"])["판"], sub) now = dim.run(dim.derive(_read(inner["키"])), _read(inner["키"]))["계"] assert now != 7528 @@ -200,8 +198,7 @@ def test_qty_pick_becomes_table_link(world) -> None: if found is None: pytest.skip("야면석채집및운반(계곡내) 블록 없음") row = found["로직"] - doc = _doc(row["호표"], {k: row[k] for k in ("중간", "덧줄", "단계", "끝전") if row.get(k)}) - doc[imp.KEY]["로직"] |= {k: row[k] for k in ("이름", "결과단위")} + doc = {**imp.new_doc(row, {"엑셀금액": {}}, "견본", "식"), "키": "SK-000001"} at = next(i for i, x in enumerate(row["호표"]) if x["이름"] == "보통인부") cell = next(c for c in qty.view(doc)["줄"] if c["자리"] == f"호표:{at}:0")["후보"][0] kept = qty.pick(doc, f"호표:{at}:0", {k: cell[k] for k in ("표", "줄", "칸")})["문서"] @@ -219,9 +216,9 @@ def test_qty_pick_becomes_table_link(world) -> None: # ── ⑤ 수식 길 · 옮기기 ─────────────────────────────────────────────────── def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None: folder = world["personal"] - doc = _doc([_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.5")]) with store.at(folder): - key = imp.create(doc[imp.KEY]["로직"], {"엑셀금액": {"계": 50000}}, "sub2임시 견본")["이름"] + row = _row([_item("인력", "보통인부", 100000, "노무비", "LB000002", "0.5")]) + key = imp.create(row, {"엑셀금액": {"계": 50000}}, "sub2임시 견본")["이름"] read = path.read(key) assert read["셈"]["계"] == 50000 and read["사본"]["단가기준"] == "엑셀" edit = copy.deepcopy(read["문서"]) @@ -232,9 +229,9 @@ def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None: again = path.read(key) assert again["사본"]["따로"] is True and again["셈"]["계"] == 100000 sk = _read(key) - moved = imp.link(sk, sd_id(sk), None)["문서"] # 이음 풂 = 옛 칸 고침 → 409 + old = {**sk, "덮개": {"labor:LB000002#0": {"qty": 1}}} # 옛 칸 고침 → 409 with pytest.raises(store.StoreError) as why: - store.write("sangeun", key, store.read("sangeun", key)["판"], moved) + store.write("sangeun", key, store.read("sangeun", key)["판"], old) assert why.value.status == 409 ours = imp.to_price(sk, "우리")["문서"] # 단가기준만 바꿈 = 됨(문서 그대로 · 연결 값) store.write("sangeun", key, store.read("sangeun", key)["판"], ours) @@ -242,10 +239,6 @@ def test_formula_route_edit_then_old_edit_409_and_regen(world) -> None: assert path.read(key)["셈"]["노무비"] == int(lb * 10) / Decimal(10) -def sd_id(sk: dict) -> str: - return imp.sd.line_ids(imp.row_of(sk))[0] - - # ── TS 짝(importView) 거울 ───────────────────────────────────────────── _NODE = """ const fs = require("fs"), path = require("path"); diff --git a/resources/tester/test_809_1_import_labor.py b/resources/tester/test_809_1_import_labor.py index 738905254..f2141b873 100644 --- a/resources/tester/test_809_1_import_labor.py +++ b/resources/tester/test_809_1_import_labor.py @@ -149,9 +149,7 @@ def test_imported_doc_names_and_machine_line(world) -> None: out = fh.emit( folder, hp, 8 ) # 배수관부설(파형강관)(D=800mm) — 크레인 세 줄 · 줄_2 · 노무비_2 · 계_2 - unit = out["로직"]["결과단위"].split("/", 1)[1] - sk = {"키": "SK-000000", "이름": "x", "단위": unit, "바탕": None, "입력값": {}} - sk[imp.KEY] = {"로직": out["로직"], "단가기준": "엑셀", "원본": out["원본"]} + sk = imp.new_doc(out["로직"], out["원본"], "x") # 857-3b 불러온 그대로 문서 new = dim.derive(sk) names = [x["이름"] for x in new["금액"]] assert "공구손료 및 잡재료비(노무비의 2%)" in names # 읽기기 지은 「율」 → 엑셀 글 머리 diff --git a/resources/tester/test_810_2_native_doc.py b/resources/tester/test_810_2_native_doc.py index 71bf0d72e..560ea7d59 100644 --- a/resources/tester/test_810_2_native_doc.py +++ b/resources/tester/test_810_2_native_doc.py @@ -71,11 +71,8 @@ def picked(saved: dict, few: int = 8) -> dict: def sk_of(out: dict) -> dict: - """{로직, 원본} → 저장 없는 가져온 식 SK(만들기 몸과 같은 꼴 · 키 = 시험용).""" - row = out["로직"] - sk = {"키": "SK-999999", "이름": row["이름"], "단위": row["결과단위"].split("/", 1)[1]} - sk |= {"바탕": None, "입력값": {}, "덮개": {}, "뺀줄": [], "더한줄": []} - sk[imp.KEY] = {"로직": row, "원본": out["원본"], "단가기준": "엑셀"} + """{로직, 원본} → 저장 없는 가져온 식 SK(만들기 몸 · 불러온 그대로 문서 857-3b · 키 = 시험용).""" + sk = {**imp.new_doc(out["로직"], out["원본"], out["로직"]["이름"]), "키": "SK-999999"} return sd.clean(sk, None, whole()) @@ -224,7 +221,7 @@ def test_upload_native_one_file_list_only(world) -> None: made = fh.make(folder, got["키"], 15) # 전석 메쌓기 — 안쪽 산근 둘 + 굴삭기 sk = store.read("sangeun", made["이름"])["문서"] assert sk["가져온"]["원본"]["원파일"] and made["검산"]["같음"] - assert len([x for x in sk["가져온"]["로직"]["호표"] if x.get("참조")]) == 2 + assert len(imp.refs_of(sk)) == 2 # 안쪽 산근 둘 = 형제 SK 연결(857-3b 문서) ans = dim.run(dim.of(sk), sk) assert (ans["노무비"], ans["재료비"], ans["경비"]) == (74880, 7029, 12306) st = fh.upload_native(folder, stc.name, stc.read_bytes(), WHO) diff --git a/resources/tester/test_812_3_native_layout.py b/resources/tester/test_812_3_native_layout.py index 2220ff3bd..5bce1f1fd 100644 --- a/resources/tester/test_812_3_native_layout.py +++ b/resources/tester/test_812_3_native_layout.py @@ -104,16 +104,19 @@ def test_sample_formwork_text_rate_subtotal() -> None: False, ["#< 토목품셈 6-3-1 합판거푸집(2022개정) >", "#※ 사용횟수 4회 : 보통"], ) - assert got[1] == ( - "재료비", - False, - [ - "합판(내수),대전", - "외송각재,대전", - "주자재소계", - "#소모자재(박리재등) (주자재비의 9%)", - "율", - ], + assert ( + got[1] + == ( + "재료비", + False, + [ + "합판(내수),대전", + "외송각재,대전", + "주자재소계", + "#소모자재(박리재등) (주자재비의 9%)", + "소모자재(박리재등) (주자재비의 9%)", # 857-3b 지은 「율」 → 엑셀 글 머리(704 · 저장 길도) + ], + ) ) assert got[2][0] == "인건비 (24년 품셈 개정)" and got[2][2][:3] == [ "형틀목공", diff --git a/resources/tester/test_821_4_import_my_machine.py b/resources/tester/test_821_4_import_my_machine.py index 947923914..a76363f4a 100644 --- a/resources/tester/test_821_4_import_my_machine.py +++ b/resources/tester/test_821_4_import_my_machine.py @@ -156,9 +156,9 @@ def test_make_flow(world) -> None: assert not any(m["새로"] for m in again["내기계"]) doc = store.read("sangeun", got["이름"])["문서"] assert doc[imp.KEY]["원본"]["내기계"][0]["키"] == one["키"] - items = doc[imp.KEY]["로직"]["호표"] - mine = [x for x in items if (x.get("자원") or {}).get("내기계") == one["키"]] - assert mine and all(f"개인 {one['키']}" in str(x.get("이음")) for x in mine) + first = doc[imp.KEY]["문서"] # 857-3b 불러온 그대로 문서 — 내 기계 연결 · 설명 + mine = [v for v in first["변수"] if f"내 기계 {one['키']}" in str(v.get("설명") or "")] + assert mine and all(one["키"] in str(v.get("연결")) for v in mine) assert not [ u for u in imp.unlinked(doc) if "파워트로웰" in u["이름"] ] # 「못 이음」 에서 빠짐 diff --git a/resources/tester/test_827_3_material_pick.py b/resources/tester/test_827_3_material_pick.py index a33662718..40f3bdd9f 100644 --- a/resources/tester/test_827_3_material_pick.py +++ b/resources/tester/test_827_3_material_pick.py @@ -44,7 +44,9 @@ def _upload(folder: Path, tag: str) -> str: def _lines(doc: dict, kind: str) -> list[dict]: - return [x for x in doc[imp.KEY]["로직"]["호표"] if mp.kind_of(x.get("자원") or {}) == kind] + """857-3b — 그 종 재료 줄 판정(불러온 그대로 문서 머리 `가져온.재료` · 가져온 줄 안 둠).""" + first = doc[imp.KEY]["문서"] + return [e for e in (first.get(imp.KEY) or {}).get("재료") or [] if e.get("종") == kind] def _var(conv: dict, sym: str) -> dict: @@ -75,11 +77,8 @@ def test_pick_whole_file(world) -> None: doc = store.read("sangeun", key)["문서"] assert doc[imp.KEY]["원본"]["지문"] == fp lines = _lines(doc, WIRE) - assert lines and all(x["이음"] == pick["키"] for x in lines) - assert all(x["자원"]["재료찾기"]["고름"]["키"] == pick["키"] for x in lines) - assert all( - x["자원"]["재료찾기"]["판정"] == "후보 여럿" for x in lines - ) # 엔진 판정 그대로 + assert lines and all(x["고름"]["키"] == pick["키"] for x in lines) + assert all(x["판정"] == "후보 여럿" for x in lines) # 엔진 판정 그대로 conv = dim.derive(doc, None, imp._whole()) e = _entry(conv, WIRE) assert e["고름"]["키"] == pick["키"] and e["처음"]["갈래"] == "숫자" @@ -167,7 +166,7 @@ def test_apart_item_zero(world) -> None: assert got["이름"] != plain["이름"] and got["검산"] == plain["검산"] # 금액 그대로(단가 0) doc = store.read("sangeun", got["이름"])["문서"] mine = _lines(doc, kind)[0] - assert mine["이음"] is None and mine["자원"]["재료찾기"]["고름"]["키"] == gov["키"] + assert mine["별도계상"] and mine["고름"]["키"] == gov["키"] conv = dim.derive(doc, None, imp._whole()) e = _entry(conv, kind) var = _var(conv, e["기호"]) diff --git a/resources/tester/test_835_1_import_preview.py b/resources/tester/test_835_1_import_preview.py index 194a11bb3..50443a9bb 100644 --- a/resources/tester/test_835_1_import_preview.py +++ b/resources/tester/test_835_1_import_preview.py @@ -43,7 +43,7 @@ def test_preview_writes_nothing_save_makes_same(world) -> None: before = _files(folder) seen = fh.draft(folder, row["키"], 3) # 단산3 깬잡석채집 — 기계 줄 assert _files(folder) == before # 보기 = 디스크 쓰기 0 - assert seen["같은것"] is None and seen["문서"]["가져온"]["로직"]["호표"] + assert seen["같은것"] is None and seen["문서"]["가져온"]["문서"]["금액"] # 857-3b 문서 assert seen["검산"]["같음"] is True made = fh.make(folder, row["키"], 3, doc=seen["문서"]) # [저장] assert made["다시씀"] is False and (folder / "sangeun" / f"{made['이름']}.json").is_file() diff --git a/resources/tester/test_857_3a_import_adds.py b/resources/tester/test_857_3a_import_adds.py deleted file mode 100644 index 56ec2c674..000000000 --- a/resources/tester/test_857_3a_import_adds.py +++ /dev/null @@ -1,129 +0,0 @@ -"""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 db375b67e6cc0a61374f238af3181f0932652891 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 03:44:56 +0900 Subject: [PATCH 2/2] =?UTF-8?q?refactor(857-3b):=20=EC=86=8C=EC=9A=94?= =?UTF-8?q?=EB=9F=89=20=C2=B7=20=EA=B3=84=EC=88=98=20=EA=B0=92=20=EC=97=AD?= =?UTF-8?q?=EC=83=89=EC=9D=B8=20=3D=20M01=20=EC=88=98=EC=8B=9D=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C=20=E2=80=94=20=EC=98=9B=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A4=84=20=C2=B7=20=EC=98=9B=20=EC=8B=9D=20=ED=8C=8C=EC=84=9C?= =?UTF-8?q?=20=EC=95=88=20=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - San_Basis_Index.load 로직 = 수식문서 폴더(master_doc_link.load_all) · scan = 문서 변수 연결(표 찾기 · 단가산출 부름 · 기계 요소 칸) · 식 줄 · 덧줄 식 · 금액 줄 수량 수(문서 파서) · 이름 인자 = 입력 이름(기호 → 열쇠) · 지문에 수식 문서 파일 - master_auto(ma._texts) · mf.parse · mf._OPS 안 씀 · trade 는 그대로(이미 Hopyo_ReadEst.trade 한 줄 감쌈 = 가벼운 자리 Hopyo_Shares 와 같은 것) - 대조: 옛 역색인 대 새 역색인 — 3,241 블록 소요량 자리 10,671 후보 전부 같음(속 표 uses · inline 은 문서가 × 1 · ÷ 100 군더더기를 걷어 갈래 몇이 다름 · 후보에는 안 닿음) - 세기: 불러오기 길(짓기 · 검산 · 열기 두 판 · 이음 고침 · 소요량 보기 · 단가기준) 옛 변환기 · 색인 .logic · 옛 식 파서 부름 0(전 = 역색인 짓기 mf.parse 14,102) - 지킴: test_797_2 · 802_4b1 · 857 골든 전수 · 관련 시험 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_San_Basis_Index.py | 111 +++++++++++++--------- 1 file changed, 68 insertions(+), 43 deletions(-) diff --git a/M02_MasterTemplete/M02_San_Basis_Index.py b/M02_MasterTemplete/M02_San_Basis_Index.py index fd5ce7fcc..9176ec44b 100644 --- a/M02_MasterTemplete/M02_San_Basis_Index.py +++ b/M02_MasterTemplete/M02_San_Basis_Index.py @@ -12,7 +12,8 @@ N6 표 기준 · N7 식 속 수 · N8 단위 성격(N9 · N10 옛 근거 제안 쓰는 곳 = 소요량 · 계수 이음 `M02_Sangeun_QtyLinks`). 우연 보정(`q_of` · `pb_sig`) = 보정 자료(실무 여덟 파일 상수 · `M02_San_Basis_corpus.json`) 몫 · 포아송 이항 꼬리 −log10. -짓기 = M01 폴더 지문(`stamp`)마다 한 번(`get` · 프로세스 안 캐시 · 지문 바뀌면 다시). +짓기 = M01 폴더 지문(`stamp`)마다 한 번(`get` · 프로세스 안 캐시 · 지문 바뀌면 다시) · +로직 = M01 수식 문서(857-3b · 옛 로직 줄 · 옛 식 파서 안 읽음 · 문서 파서). """ from __future__ import annotations @@ -34,8 +35,12 @@ from common_util import common_util_derived_store as derived from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Hopyo_ReadEst as est -mf = m01.cm.mf -import master_auto as ma # noqa: E402 — mf 를 불러 scripts 경로가 깔린 뒤 +m01.cm.mf # noqa: B018 — scripts 경로를 깖(M01 저장 모듈이 부름) +import master_doc as md # noqa: E402 +import master_doc_link as ml # noqa: E402 + +DOCS = "수식문서" # M01 폴더 아래 수식 문서 폴더(`master_doc_link.FOLDER`) +CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자 CORPUS = Path(__file__).with_name("M02_San_Basis_corpus.json") INLINE_MAX = 20 # 식 속 수가 이보다 많은 로직(표를 식으로 펼친 것)은 식 속 수 맞음을 안 셈 @@ -149,6 +154,8 @@ def stamp() -> str: } if m01.cm.mmf.here(folder()): # 기계 = 폴더(826-2) files[m01.cm.mmf.NAME] = m01.version_of(m01.cm.mmf.raw(folder(), m01.cm.mmf.NAME)) + for p in sorted((folder() / DOCS).glob("수식_*.json")): # 857-3b 로직 = 수식 문서 + files[f"{DOCS}/{p.name}"] = derived.file_digest(p) return derived.derived_key("san-basis-index", files, derived.file_digest(CORPUS)) @@ -157,9 +164,8 @@ def load(root: Path) -> tuple[dict, dict, dict, dict]: for f in glob.glob(str(root / "소요량_*.json")) + glob.glob(str(root / "계수_*.json")): for t in json.loads(Path(f).read_text(encoding="utf-8")).get("표", []): tables[t["키"]] = t - for f in glob.glob(str(root / "로직_*.json")): - for it in json.loads(Path(f).read_text(encoding="utf-8"))["줄"]: - logic[it["키"]] = it + if (root / DOCS).is_dir(): # 857-3b 로직 = 수식 문서(옛 로직 줄 안 읽음) + logic = ml.load_all(root / DOCS) for r in m01.cm.mmf.table(root)[0]["줄"]: # 기계 = 폴더(826-2) eq[r["키"]] = r by_no: dict = {} @@ -178,63 +184,82 @@ def _resolve(ref: str, tables: dict, by_no: dict) -> str | None: return hit[0] if len(hit) == 1 else None -def scan(item: dict, tables: dict, by_no: dict) -> tuple: - """로직 하나 → (찾기 부름, 식 속 수, 하위 로직 부름, 기계 부름, 호표 수량 속 수).""" - names = {s["이름"] for s in item.get("입력", [])} +def inputs_of(doc: dict) -> dict[str, str]: + """문서 입력 · 선택 변수 {기호: 열쇠(입력 이름)}.""" + return { + md.var_id(v): str(v.get("열쇠")) + for v in doc.get("변수") or [] + if (v.get("연결") or {}).get("갈래") in ("입력", "선택") + } + + +def scan(doc: dict, tables: dict, by_no: dict) -> tuple: + """수식 문서 하나 → (찾기 부름, 식 속 수, 하위 로직 부름, 기계 부름, 호표 수량 속 수) — 857-3b · + 옛 로직 줄 훑기와 같은 꼴(이름 = 입력 이름 · 표 · 하위 로직 · 기계 = 변수 연결).""" + names = inputs_of(doc) finds, nums, calls, eqs = [], [], [], [] - def arg_of(node): + def parse(text: Any) -> Any: + try: + return md.parse(text) + except md.DocError: + return None + + def arg_of(text: Any) -> tuple: + node = parse(text) + if node is None: + return ("expr", str(text)[:80]) if node[0] == "str": return ("lit", node[1]) if node[0] == "num": return ("lit", float(node[1])) - if node[0] == "name": - return ("name", node[1]) if node[1] in names else ("expr", node[1]) + if node[0] == "var": + return ("name", names[node[1]]) if node[1] in names else ("expr", node[1]) + visit(node) return ("expr", str(node)[:80]) - def visit(node, field=None): + def visit(node: Any) -> None: kind = node[0] - if kind == "field": - visit(node[1], node[2]) - elif kind in ("find", "logic"): - if kind == "find" and (ref := _resolve(node[1], tables, by_no)): - finds.append((ref, field, {c: arg_of(a) for c, a in node[2]})) - if kind == "logic" and isinstance(node[1], str) and "{" not in node[1]: - calls.append((node[1], {c: arg_of(a) for c, a in node[2]})) - for _, a in node[2]: - if a[0] not in ("str", "num", "name"): - visit(a) - elif kind == "ref": - if node[1].startswith("EQ") and field: - eqs.append((node[1], field)) - elif kind == "num": + if kind == "num": nums.append(float(node[1])) elif kind == "bin": for side in (node[2], node[3]): # 비교 글자(「SCH == 20」)는 셈 수가 아님 - if node[1] in mf._OPS and side[0] == "num": + if node[1] in CMP and side[0] == "num": continue visit(side) - elif kind == "neg": + elif kind in ("neg", "pct", "field"): visit(node[1]) elif kind == "call": for a in node[2]: visit(a) - for text in ma._texts(item): - if any(text is h["수량"] for h in item.get("호표", [])): - continue - try: - visit(mf.parse(text)) - except mf.FormulaError: - pass + def hole(key: str) -> str: + """`EQ:{기호}` → `EQ:{입력 이름}`(옛 로직 줄 꼴).""" + return re.sub(r"\{([^{}]+)\}", lambda m: "{" + names.get(m.group(1), m.group(1)) + "}", key) + + for var in doc.get("변수") or []: + link = var.get("연결") or {} + kind, key = link.get("갈래"), str(link.get("키") or link.get("표") or "") + if kind == "표" and (ref := _resolve(key, tables, by_no)): + args = {c: arg_of(a) for c, a in (link.get("조건") or {}).items()} + finds.append((ref, link.get("칸"), args)) + elif kind == "단가산출" and key and "{" not in key and not key.startswith("SK-"): + calls.append((key, {c: arg_of(a) for c, a in (link.get("입력") or {}).items()})) + elif kind == "요소" and key.startswith("EQ") and link.get("칸"): + eqs.append((hole(key), link["칸"])) + texts = [x.get("식") for x in doc.get("식") or []] + texts += [x.get("단가") for x in doc.get("금액") or [] if "수량" not in x] # 덧줄 식 + for text in texts: + if (node := parse(text)) is not None: + visit(node) trade_nums = [] # (호표 이름, 수량 식 속 수) - for h in item.get("호표", []): - before = len(nums) - try: - visit(mf.parse(h["수량"])) - except mf.FormulaError: + for line in doc.get("금액") or []: + if "수량" not in line or (node := parse(line["수량"])) is None: continue - trade_nums += [(h.get("이름") or "", x) for x in nums[before:]] + before = len(nums) + visit(node) + trade_nums += [(line.get("이름") or "", x) for x in nums[before:]] + return finds, nums, calls, eqs, trade_nums @@ -371,7 +396,7 @@ class Index: m = re.match(r"EQ:\{(\w+)\}", ref) if m: arg = m.group(1) - inputs = {sp["이름"] for sp in self.logic[key].get("입력", [])} + inputs = set(inputs_of(self.logic[key]).values()) if depth == 0 and arg in inputs: use = ("입력", arg) elif depth > 0 and arg in rename: