From 2e7bb920444de309f01d6d97a06cfe2d690a2f28 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 10:45:20 +0900 Subject: [PATCH 1/3] =?UTF-8?q?refactor(855-E=202-E4):=20=EB=8B=A8?= =?UTF-8?q?=EA=B0=80=EC=82=B0=EC=B6=9C=20=EC=98=9B=20=EC=B9=B8=20=EC=88=98?= =?UTF-8?q?=EC=8B=9D=EA=B3=A0=EC=B9=A8=20=C2=B7=20=EC=97=B0=EA=B2=B0=20?= =?UTF-8?q?=EB=81=8A=EA=B8=B0=20=3D=20=EB=B0=9B=EC=9C=BC=EB=A9=B4=20400=20?= =?UTF-8?q?=E2=80=94=20=EC=97=94=EC=A7=84=20=EC=88=98=EC=8B=9D=20=EA=B3=A0?= =?UTF-8?q?=EC=B9=A8=20=EC=96=B9=EA=B8=B0=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 저장본 확인: 층 SK 14 · 문서 `수식고침` · 더한줄 `끊음` · `수식고침` 0 - M02_Sangeun_Equation: `apply` · `on`(M01 Equation edit_row 엔진 고침) · `strict` · `added_inputs` · 메모 지움 → `clean` = 옛 칸 있으면 400(WHY) - M02_Sangeun_Block: `own` · `row_of`(끊은 기초 `mine.logic`) · `strict` · `is_block` 지움 → `clean` = 끊음 · 수식고침 400 - M02_Sangeun_Calc.clean_doc: eqm · blk strict 부름 걷음(바탕 머리 = `_head_of`) · M02_Sangeun_Doc: 고침 더한 입력 거름 걷음 - 시험 test_796_2b: 옛 칸 고침 = 「수식고침」 400 · 화면 TS 파일 글자 보는 시험 걷음(소스 글자 시험 금지) - 검증: 관련 43 파일 + 지킴 + 관문 356 통과 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Sangeun_Block.py | 85 ++---------------- M02_MasterTemplete/M02_Sangeun_Calc.py | 6 +- M02_MasterTemplete/M02_Sangeun_Doc.py | 4 +- M02_MasterTemplete/M02_Sangeun_Equation.py | 95 ++------------------ resources/tester/test_796_2b_m02_equation.py | 14 +-- 5 files changed, 20 insertions(+), 184 deletions(-) diff --git a/M02_MasterTemplete/M02_Sangeun_Block.py b/M02_MasterTemplete/M02_Sangeun_Block.py index 2e0f1429f..b304ccbc9 100644 --- a/M02_MasterTemplete/M02_Sangeun_Block.py +++ b/M02_MasterTemplete/M02_Sangeun_Block.py @@ -1,88 +1,21 @@ -"""M02 단가산출(SK) 더한 기초 블록 [연결 끊기] · [다시 잇기](PLAN 796-2e · 요구 659-3 · 656-1). +"""M02 단가산출(SK) 더한 기초 옛 [연결 끊기](PLAN 796-2e) — 받지 않음(855-E 2-E4). -더한 기초 = 더한줄 로직(`종류: 로직`). 기본 = 연결 — 이 SK 의 로직 사본(`M02_Sangeun_Copy`)이 닿는 그 기초 -(원본 바뀜은 [재생성]·[다시 잇기]에서 따라옴 · 자동 아님 · 보기만). -끊음 = 더한줄 칸 `끊음` {시점, 로직 [M01 줄]} — 끊는 때 그 기초가 닿는 닫힌 묶음(하위 로직 · 찾기 표 · - 요율 · 사본 줄 그대로 = 금액 그대로)을 이 SK 안 자기 사본으로 굳힘 → 그 줄만 고침: - 칸 `수식고침`(796-2b 와 같은 꼴 · 같은 `eqm.apply`)을 그 기초 줄에 얹어 셈(`Calc.sub_run`). - [재생성] = 끊은 기초의 줄은 안 바꿈(자원 단가만 — 단가는 SK 사본 `단가` · [단가 갱신] 한 길). -다시 잇기 = `끊음` · `수식고침` 뗌 + 표지 `다시잇기`(서버만 · 셈·저장 첫머리 `Copy.settle` 이 그 기초가 닿는 - 닫힌 묶음을 지금 M01 줄로 갈음하고 표지 뗌 — 고친 것 버림). -화면 길(끊기 · 다시 잇기 · 끊은 기초 수식 탭)은 걷음(894) — 남은 것 = 저장 문서의 `끊음` · `수식고침` 꼴 · 셈. -저장 = SK [저장](서버가 다시 얹어 검사 · 셈 · 브라우저 값 안 받음 — 끊음 줄은 사본과 같은 `taken` 꼴 검사). +옛 끊음 = 더한줄 로직 칸 `끊음` {시점, 로직 [M01 줄]} + 그 줄 `수식고침` — 굳힌 로직 줄에 엔진 수식 고침을 +얹던 길 · 화면 길은 894 에서 걷음 · 저장본 0 — 받으면 400. """ from __future__ import annotations -from typing import Any - -from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sangeun_Equation as eqm CUT, EDIT = "끊음", eqm.KEY -MANY = 400 # 끊은 기초가 닿는 줄 상한 -_OWN: dict[int, tuple[Any, Any, Any]] = {} - - -def is_block(one: Any) -> bool: - """더한 기초 = 더한줄 로직(참조 · 고정 · 자원 줄 아님).""" - return isinstance(one, dict) and one.get("종류") == "로직" and bool(one.get("로직")) def clean(raw: dict, where: str) -> dict: - """`sd._added` 가 부름 — 끊음 · 수식고침 꼴만(뜻 검사는 셈 · 저장 `strict`).""" - cut = raw.get(CUT) - if not cut: - if raw.get(EDIT): - raise sd.DocError(f"{where} · 수식 고침은 연결을 끊은 기초만") - return {} - rows = cut.get("로직") if isinstance(cut, dict) else None - code = str(raw.get("로직")) - if any(raw.get(k) not in (None, {}, []) for k in sd.BODY): - raise sd.DocError(f"{where} · 넣은 SK 몸은 이미 이 SK 안 사본 — 연결 끊기 없음") - if ( - not isinstance(rows, list) - or len(rows) > MANY - or not all(isinstance(r, dict) and r.get("키") for r in rows) - ): - raise sd.DocError(f"{where} · 끊은 기초 사본 꼴이 틀림") - rows = [r for r in rows if str(r["키"])[:2] not in skc.RES] # 단가 = SK 사본 한 곳 - if code not in {str(r["키"]) for r in rows}: - raise sd.DocError(f"{where} · 끊은 기초 사본에 「{code}」 줄 없음") - return {CUT: {"시점": str(cut.get("시점") or ""), "로직": rows}} | eqm.clean(raw, {}) - - -def own(one: dict, whole: Any) -> Any: - """끊은 기초의 셈 색인 — `whole` 위에 자기 사본 줄(끊음 아님 = `whole` 그대로).""" - cut = one.get(CUT) - if not isinstance(cut, dict): - return whole - hit = _OWN.get(id(cut)) - if hit and hit[0] is cut and hit[1] is whole: - return hit[2] - if len(_OWN) > 32: # ponytail: 통째 비움 · 끊은 기초가 많아 느려지면 LRU 로 - _OWN.clear() - got = skc.Copy(whole, skc._rows(cut)) - _OWN[id(cut)] = (cut, whole, got) - return got - - -def row_of(whole: Any, one: dict, edits: list | None = None) -> tuple[dict, list[str], Any]: - """(끊은 기초 줄 + 수식 고침, 못 얹은 까닭, 그 기초 셈 색인) — `edits` None = 그 기초 자기 고침.""" - mine = own(one, whole) - row = mine.logic(str(one["로직"])) - use = one.get(EDIT) if edits is None else edits - if not use: - return row, [], mine - new, why = eqm.apply(row, use, mine) - return new, why, mine - - -def strict(doc: dict, whole: Any) -> None: - """저장 — 끊은 기초 고침이 못 얹히면 400.""" - for at, one in enumerate(doc.get("더한줄") or [], 1): - if is_block(one) and one.get(EDIT): - why = row_of(whole, one)[1] - if why: - raise sd.DocError(f"더한줄 {at}째 수식 고침 못 얹음 — " + " · ".join(why)) + """`sd._added` 가 부름 — 옛 칸 `끊음` · `수식고침` 이 있으면 400.""" + if raw.get(CUT) or raw.get(EDIT): + raise sd.DocError( + f"{where} · 연결 끊기 · 수식고침(옛 칸) — 받지 않음 · 단가산출 수식 문서로 고침" + ) + return {} diff --git a/M02_MasterTemplete/M02_Sangeun_Calc.py b/M02_MasterTemplete/M02_Sangeun_Calc.py index a4a6ee5a2..d3b6b42ce 100644 --- a/M02_MasterTemplete/M02_Sangeun_Calc.py +++ b/M02_MasterTemplete/M02_Sangeun_Calc.py @@ -21,9 +21,8 @@ from M02_MasterTemplete import M02_Doc_Sk as dsk # 수식 사본(802-4a) from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Sangeun_Block as blk from M02_MasterTemplete import M02_Sangeun_Const as const, M02_Sangeun_Copy as skc -from M02_MasterTemplete import M02_Sangeun_Doc as sd, M02_Sangeun_Equation as eqm +from M02_MasterTemplete import M02_Sangeun_Doc as sd COSTS = labor.COSTS Ref = dict[str, Any] @@ -243,8 +242,7 @@ def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: try: rough = sd.clean(doc, None, whole) _check_refs(rough, here_) - eqm.strict(base := _head_of(rough, whole)) # 수식 고침(796-2b) - blk.strict(rough, whole) # 끊은 기초 수식 고침(796-2e) + base = _head_of(rough, whole) out = sd.clean(doc, base["줄"], whole) out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"] for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 diff --git a/M02_MasterTemplete/M02_Sangeun_Doc.py b/M02_MasterTemplete/M02_Sangeun_Doc.py index 694331739..4de0e0c14 100644 --- a/M02_MasterTemplete/M02_Sangeun_Doc.py +++ b/M02_MasterTemplete/M02_Sangeun_Doc.py @@ -356,9 +356,7 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str given = _given(doc.get("입력값"), "입력값") opened = [str(x) for x in doc.get("열린입력") or []] if base_row is not None: - from M02_MasterTemplete import M02_Sangeun_Equation as eqm # 수식 고침 더한 입력(796-2b) - - keep = names | _added_names(whole, doc.get("더한줄")) | eqm.added_inputs(doc) + keep = names | _added_names(whole, doc.get("더한줄")) given = {k: v for k, v in given.items() if k in keep} bad = [x for x in opened if x not in names or x in given] if bad: diff --git a/M02_MasterTemplete/M02_Sangeun_Equation.py b/M02_MasterTemplete/M02_Sangeun_Equation.py index 0dbb846ee..82c6ee6a3 100644 --- a/M02_MasterTemplete/M02_Sangeun_Equation.py +++ b/M02_MasterTemplete/M02_Sangeun_Equation.py @@ -1,102 +1,21 @@ -"""M02 단가산출(SK) 수식 탭 서버 몫(PLAN 796-2b · 요구 655 · 656 · 657 · 요구서_655 0 · 2 장 1). +"""M02 단가산출(SK) 옛 칸 `수식고침`(PLAN 796-2b) — 받지 않음(855-E 2-E4). -수식 = 그 SK 바탕 줄(로직 사본 줄 `M02_Sangeun_Copy` · 가져온 식 줄 `M02_Sangeun_Imported.row_of`) + -문서 덧칸 `수식고침` = 사본 위 고침 기록 — M01 수식 탭 고침 꼴(`master_equation_edit` 머리 · - 차례대로 · 식 · 더함 · 지움 · 변수 · 표시) + 줄마다 `까닭`?(예정가격작성기준 제2조 ②) · - 사본은 찍은 그대로(= 원래 대비 · 고친 칸 = 고침 목록). -셈 = `M02_Sangeun_Calc._base_of` 가 바탕 줄에 `on` 으로 얹음(엔진 · 검사 = M01 `edit_row` 한 벌) → - 모든 셈 길(화면 · 저장 원값 · B09 · 펼침) 같은 줄 · 못 얹은 고침(재생성 뒤 자리 없음 등) = - 고침 없는 바탕 + 짝잃음 cid `수식` · 저장(`strict`) = 400 · [재생성] = 새 사본에 같은 고침 - 다시 얹음(못 얹음 = 795-1 `못얹은`). -수식 탭 화면 길(읽기 · 미리 셈 · 합계 소계)은 걷음(894) — 남은 것 = 저장 문서 `수식고침` 꼴 · 셈 · 저장 검사. - 저장 = SK [저장](`clean_doc` 이 다시 얹어 검사 · 셈 · 브라우저 값 안 받음). -바탕 참조 SK(`바탕.참조`) = 수식 없음(바탕 SK 의 고침은 그 SK 가 얹음). +옛 수식 탭 고침 = 바탕 로직 줄에 엔진 수식 고침(`master_equation_edit`)을 얹던 칸 · 화면 길은 894 에서 걷음 · +저장본 0 · 고침은 단가산출 수식 문서(줄 쌓기 · 수식 길 저장)로 — 받으면 400. """ from __future__ import annotations -import hashlib -import json from typing import Any from M02_MasterTemplete import M02_Sangeun_Doc as sd KEY = "수식고침" -MANY = 200 -LONG = 500 # 까닭 길이 -LOST = "수식" # 짝잃음 cid -STAND = "GX999997" # 가져온 식(SK 키) 줄을 엔진에 얹을 잠깐 키(GX999998 = 견본 · 999999 = 초안) -_MEMO: dict[tuple[str, str], tuple[dict, list[str]]] = {} - - -def _eqn() -> Any: - from M01_MasterData import M01_MasterData_Equation as eqn # M02 가 M01 을 부름 — 늦게 - - return eqn - - -def _hash(v: Any) -> str: - raw = json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) - return hashlib.sha256(raw.encode("utf-8")).hexdigest() +WHY = "수식고침(옛 칸) — 받지 않음 · 단가산출 수식 문서(줄 쌓기)로 고침" def clean(raw: Any, out: dict) -> dict: - """`sd.clean` 끝 — 꼴만(목록 · 묶음 · 까닭 길이) · 뜻 검사는 셈 · 저장 때 `on`.""" - edits = raw.get(KEY) if isinstance(raw, dict) else None - if not edits: - return out - if not isinstance(edits, list) or len(edits) > MANY: - raise sd.DocError(f"수식고침 · {MANY} 개까지 목록") - for at, one in enumerate(edits, 1): - why = one.get("까닭") if isinstance(one, dict) else None - if not isinstance(one, dict) or (why is not None and len(str(why)) > LONG): - raise sd.DocError(f"수식고침 {at}째 · 묶음 · 까닭 {LONG} 자까지") - out[KEY] = json.loads(json.dumps(edits, ensure_ascii=False, default=str)) + """`sd.clean` 끝 — 옛 칸 `수식고침` 이 있으면 400.""" + if isinstance(raw, dict) and raw.get(KEY): + raise sd.DocError(WHY) return out - - -def added_inputs(doc: Any) -> set[str]: - """고침으로 더한 입력 이름 — `sd.clean` 입력값 거름에서 남김.""" - edits = (doc.get(KEY) if isinstance(doc, dict) else None) or [] - return { - str(e.get("열쇠")) - for e in edits - if isinstance(e, dict) and e.get("할일") == "더함" and e.get("갈래") == "입력" - } - - -def _stand(row: dict) -> tuple[dict, str]: - """(엔진이 로직으로 부를 줄, 본 키) — M01 로직 키 아님(가져온 식 SK) = 잠깐 키.""" - key = str(row.get("키")) - return (row, key) if key[:2] in ("GC", "GF", "GX") else ({**row, "키": STAND}, key) - - -def apply(row: dict, edits: list, whole: Any) -> tuple[dict, list[str]]: - """바탕 줄 + 고침 → (새 줄, 까닭) — 같은 줄 · 같은 고침 = 메모(셈 길마다 다시 검사 안 함).""" - tag = (_hash(row), _hash(edits)) - got = _MEMO.get(tag) - if got is None: - if len(_MEMO) > 64: # ponytail: 통째 비움 · 쓰는 SK 가 많아 느려지면 LRU 로 - _MEMO.clear() - stand, key = _stand(row) - new, why = _eqn().edit_row(whole, stand, edits) - got = _MEMO[tag] = ({**new, "키": key}, why) - return got - - -def on(row: dict, doc: Any, whole: Any) -> tuple[dict, list[dict]]: - """셈 길 — 고침 얹은 줄 · 못 얹음 = 바탕 그대로 + 짝잃음 `수식`.""" - edits = (doc.get(KEY) if isinstance(doc, dict) else None) or [] - if not edits: - return row, [] - new, why = apply(row, edits, whole) - if why: - return row, [{"cid": LOST, "까닭": "수식 고침 못 얹음 — " + " · ".join(why)}] - return new, [] - - -def strict(base: dict) -> None: - """저장 — 이 SK 고침이 못 얹히면 400(바탕 SK 사슬 것 = 알림만).""" - for x in base.get("짝잃음") or []: - if x.get("cid") == LOST and "바탕" not in x: - raise sd.DocError(x["까닭"]) diff --git a/resources/tester/test_796_2b_m02_equation.py b/resources/tester/test_796_2b_m02_equation.py index 9bc4b2c9b..7f0b9ccc4 100644 --- a/resources/tester/test_796_2b_m02_equation.py +++ b/resources/tester/test_796_2b_m02_equation.py @@ -42,17 +42,5 @@ def test_imported_old_equation_edit_refused(world): doc = _doc(me, key) assert "로직" not in doc["가져온"] and doc["가져온"]["문서"]["금액"] edit = [{"할일": "식", "자리": "호표:0", "식": "0.5 × 2"}] - with pytest.raises(Exception, match="수식 고침 못 얹음"): + with pytest.raises(Exception, match="수식고침"): # 옛 칸 = 받지 않음(855-E 2-E4) _save(me, key, {**doc, eqm.KEY: edit}) - - -def test_screen_same_part_first_tab(): - """화면 — M02 수식 = 공용 수식 문서 화면(802-4b-2 · 옛 수식 나무 화면 걷음) · 첫 탭 · 옛 탭 걷음(799-2).""" - import re - from pathlib import Path - - root = Path(__file__).resolve().parents[2] / "M02_MasterTemplete" - assert not (root / "M02_MasterTemplete_Sangeun_Equation.ts").exists() - tabs = (root / "M02_MasterTemplete_Sangeun_Tabs.ts").read_text(encoding="utf-8") - # 799-2 · 836-3 — 시트 · 인력·재료·경비 · 시험 계산 · 텍스트 수식 · 보기 고르기(단가산출 상세 탭) 걷음 - assert not re.findall(r'\{ value: "(\w+)", label: ', tabs) and "createSegment" not in tabs From 8bf45a60e3cd021f30a2bdb1af33db270665e9f7 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 11:03:13 +0900 Subject: [PATCH 2/3] =?UTF-8?q?fix(855-E=202-E4):=20Doc=5FCopy=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C=20=EA=B3=A0=EB=A5=B4=EA=B8=B0=EA=B0=80=20M01=20?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20=EC=A4=84=EC=9D=84=20=EC=95=88=20=EC=9D=BD?= =?UTF-8?q?=EC=9D=8C=20=C2=B7=20=EB=AC=B8=EC=84=9C=20=EC=A7=80=EB=AC=B8=20?= =?UTF-8?q?=EC=88=98=20=EA=BC=B4(4=20=C2=B7=204.0)=20=EC=95=88=20=EA=B0=80?= =?UTF-8?q?=EB=A6=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - doc_of: 실어 온 사본 문서 › 값 사본 색인이 든 그 키 줄(옛 저장본 · `_held`) › M01 수식 문서 › M01 문서 없는 키 = 색인 줄 변환 — M01 키마다 `whole.logic` 을 읽던 것(sub4 표 L2 ⓑ-3 「Doc_Copy.doc_of · given_of 읽힘 18,002」) 걷음 - doc_fp: 정수 값 실수 = 정수(저장본 부름 문서 4 · M01 문서 4.0 이 다른 지문 → 서고 같은 내용 · M01 새판 거짓 판정) · 저장본 `원본.판`(13 파일) = 옛 지문도 받음(same_origin) - test_703 「자료집 같은 이름 물음」 빨강(같은 내용 지문) = 이 고침으로 통과 · 713_1 · 804_7 = 받은 M01 쪽 고침으로 이미 통과 - test_795_2: 값 사본에 로직 줄이 없는 꼴(855-F B9-6) — 로직 몫 확인 = 수식 부름 문서 - 검증: 관련 40 파일 + 지킴 + 관문 360 통과 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Copy.py | 51 ++++++++++++++++++++------ resources/tester/test_795_2_sc_copy.py | 9 +++-- 2 files changed, 45 insertions(+), 15 deletions(-) diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index 3f4b861f3..008bddeab 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -65,9 +65,21 @@ LOGIC = ("변수", "식", "금액", "끝수", "결과단위") # fmt: skip LABEL = ("이름", "규격", "단위", "비고", "출처") # fmt: skip -def doc_fp(doc: Any) -> str: +def _whole_num(v: Any) -> Any: + """수 꼴 맞춤 — 정수 값 실수(4.0) = 정수(4)(저장본 · M01 문서 읽기 꼴이 달라도 같은 지문 · 855-E 2-E4).""" + if isinstance(v, dict): + return {k: _whole_num(x) for k, x in v.items()} + if isinstance(v, list): + return [_whole_num(x) for x in v] + if isinstance(v, float) and v.is_integer(): + return int(v) + return v + + +def doc_fp(doc: Any, legacy: bool = False) -> str: """문서 계산 내용 지문(848-2) — 셈 칸(`LOGIC`)만 · 줄 · 변수의 글 칸 뺌 · 서버 표지 칸 뺌 · - `기계덮음`(②) · `위덮음`(①) · `손고침` 은 셈 칸 밖 = 바뀌어도 같은 지문.""" + `기계덮음`(②) · `위덮음`(①) · `손고침` 은 셈 칸 밖 = 바뀌어도 같은 지문 · 수 꼴(4 · 4.0) 안 가림 · + `legacy` = 수 꼴 가리던 옛 지문(저장본 `원본.판` 대조만).""" from M02_MasterTemplete import M02_Doc_Sk as dsk doc = doc if isinstance(doc, dict) else {} @@ -75,7 +87,8 @@ def doc_fp(doc: Any) -> str: got = {k: doc.get(k) for k in LOGIC} for part in ("변수", "식", "금액"): got[part] = [bare(x) for x in got[part] or []] - return fp(dsk._strip(got)) + got = dsk._strip(got) + return fp(got) if legacy else fp(_whole_num(ml._norm(got))) # ── M01 문서(정본 폴더) ──────────────────────────────────────────────── @@ -108,18 +121,34 @@ def _carried(whole: Any, key: str) -> dict | None: return None +def _held(whole: Any, key: str) -> dict | None: + """값 사본 색인(`skc.Copy`)이 든 그 키 줄(옛 저장본 · 새 값 사본엔 로직 줄 없음) · 없음 = None.""" + for _ in range(8): + box = getattr(whole, "_box", None) if isinstance(whole, skc.Copy) else None + if box and key in box: + return whole.index.get(key[:2], {}).get(key) + own = vars(whole) if hasattr(whole, "__dict__") else {} + whole = own.get("_whole") + if whole is None: + return None + return None + + def doc_of(whole: Any, key: str) -> dict | None: - """키 하나의 문서 — 색인이 실어 온 사본 문서 › 값 사본 줄 = 지금 M01 줄이면 M01 문서 · 다르면 그 줄 - 변환 · 없으면 None.""" + """키 하나의 문서 — 색인이 실어 온 사본 문서 › 값 사본 줄(옛 저장본) = 지금 M01 줄이면 M01 문서 · 다르면 + 그 줄 변환 › M01 문서 › M01 문서 없는 키 = 색인 줄 변환(견본 · 마스터 밖 줄) · 없으면 None · + M01 로직 줄은 안 읽음(855-E 2-E4).""" if (got := _carried(whole, str(key))) is not None: return cp.deepcopy(got) - try: - row = whole.logic(key) - except _ERR: - row = None live = folder().get(key) + row = _held(whole, str(key)) + if row is None and live is not None: + return cp.deepcopy(live) if row is None: - return cp.deepcopy(live) if live else None + try: + row = whole.logic(key) + except _ERR: + return None if live and (_live(key) is None or skc._fp(_live(key)) == skc._fp(prices.to_json(row))): return cp.deepcopy(live) try: @@ -442,4 +471,4 @@ def state(copy: dict) -> dict[str, Any]: def same_origin(base: dict, live: Any) -> bool: """`원본.판` 대 지금 M01 문서 — 계산 내용 지문(`doc_fp`) · 옛 통째 지문(`fp`) 둘 다 받음.""" - return base.get("판") in (doc_fp(live), fp(live)) + return base.get("판") in (doc_fp(live), doc_fp(live, True), fp(live)) diff --git a/resources/tester/test_795_2_sc_copy.py b/resources/tester/test_795_2_sc_copy.py index 910969bef..a3da6c9ed 100644 --- a/resources/tester/test_795_2_sc_copy.py +++ b/resources/tester/test_795_2_sc_copy.py @@ -83,7 +83,7 @@ def test_copy_stamped_logic_change_kept(world, monkeypatch): sc = _sc(me, [{"로직": PCT, "수량": {"손": 1}}]) doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) for got in (doc, _read(me, "precombo", sc)): - assert PCT in {r["키"] for r in skc.held(got)["로직"]} + assert PCT in got["수식"]["부름"] # 로직 몫 = 수식 부름 문서(값 사본 로직 줄 없음 · 855-E 2-E4) assert LB in {r["키"] for r in skc.held(got)["단가"]} was = (_calc(me, COL)["반영합"]["계"], _calc(me, sc)["기준합"]["계"], _unit(me, sc)) assert _calc(me, COL)["사본"]["M01새판"] is False @@ -115,7 +115,7 @@ def test_layer_and_column_copy_keep_copy(world, monkeypatch): co, me = world["company"], world["personal"] src = _sc(co, [{"로직": PCT, "수량": {"손": 1}, "패치": COVER}]) first = skc.held(_read(co, "precombo", src)) - old = skc.held(_labor(me, [{"로직": PCT, "수량": {"손": 2}}])) # 받는 열 = 옛 M01 사본 + old_doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) # 받는 열 = 옛 M01 사본 _fake(monkeypatch, [_double(LB), _changed(_live().logic(PCT))]) ref = {"층": "company", "주인": "7", "키": src} with store.at(me): @@ -125,8 +125,9 @@ def test_layer_and_column_copy_keep_copy(world, monkeypatch): mine = skc.held(_read(me, "precombo", got["이름"])) assert (mine["판"], mine["단가판"]) == (first["판"], first["단가판"]) _write(me, "labor", "sub2임시2", {"열": "sub2임시2", "담은로직": [{"로직": PCT}], "자재": []}) - other = skc.held(_read(me, "labor", "sub2임시2")) # 원본 열 = 바뀐 M01 사본 - assert other["판"] != old["판"] + other_doc = _read(me, "labor", "sub2임시2") # 원본 열 = 바뀐 M01 사본 + other = skc.held(other_doc) + assert other_doc["수식"]["부름"][PCT] != old_doc["수식"]["부름"][PCT] # 바뀐 M01 문서 with store.at(me): # 열 복사(copy_from) = 받은 사본 먼저 store.copy_from("labor", COL, "sub2임시2") assert skc.held(_read(me, "labor", COL))["판"] == other["판"] From 395c7072805d49f3974b90d14e03e5c6d92d600f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 11:33:12 +0900 Subject: [PATCH 3/3] =?UTF-8?q?refactor(855-E=202-E4):=20=EB=B0=94?= =?UTF-8?q?=ED=83=95=20=EC=9D=B4=EB=A6=84=EB=A7=8C=20=EC=93=B0=EB=8A=94=20?= =?UTF-8?q?M02=20=C2=B7=20B09=20import=20=EB=A5=BC=20master=5Fbase=20?= =?UTF-8?q?=EB=A1=9C=20=E2=80=94=20=EC=97=94=EC=A7=84=20=EB=AA=B8=20?= =?UTF-8?q?=EB=AA=A8=EB=93=88=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 - M02 Item_Prices · Labor_Doc · Labor_Fixed · Logic_Standard · Hopyo_Match: `mf = m01.cm.mf` → `import master_base as mf` (쓰는 이름 FormulaError · COST_ITEMS · LINKED · Master · candidates · mp 만) · Hopyo_Fixed · Hopyo_Sangeun · Machine_Hourly: `m01.cm.mf.*` → master_base(Machine_Hourly 는 master_machine_crew 를 scripts 길 뒤로 — 새 프로세스 첫 import 가 멈추던 차례 고침) - B09 Linked · Sangeun: 안 쓰는 `mf = item_prices.mf` 지움(Labor_Source · Sangeun_Copy 는 Item_Prices.mf = 바탕을 그대로) - 남김(남의 몫): MyMachine(sub3 858) · San_Basis_Index 의 cm.mf 길 깔기 · Sangeun_Formula._eng(M01 Equation · L4) - 검증: 바꾼 10 모듈 새 프로세스 단독 import 통과 · 관련 121 파일 + 지킴 + 관문 977 통과 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- B09_Estimation/B09_Estimation_Linked.py | 2 -- B09_Estimation/B09_Estimation_Sangeun.py | 1 - M02_MasterTemplete/M02_Hopyo_Fixed.py | 4 +++- M02_MasterTemplete/M02_Hopyo_Match.py | 3 ++- M02_MasterTemplete/M02_Hopyo_Sangeun.py | 6 ++++-- M02_MasterTemplete/M02_Item_Prices.py | 3 ++- M02_MasterTemplete/M02_Labor_Doc.py | 5 +++-- M02_MasterTemplete/M02_Labor_Fixed.py | 4 ++-- M02_MasterTemplete/M02_Logic_Standard.py | 6 +++--- M02_MasterTemplete/M02_Machine_Hourly.py | 13 +++++++------ 10 files changed, 26 insertions(+), 21 deletions(-) diff --git a/B09_Estimation/B09_Estimation_Linked.py b/B09_Estimation/B09_Estimation_Linked.py index fc26d152c..ab5c98588 100644 --- a/B09_Estimation/B09_Estimation_Linked.py +++ b/B09_Estimation/B09_Estimation_Linked.py @@ -31,8 +31,6 @@ from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, read_json #: 원가 단가 목록에 오르는 자원 표 RESOURCE_TABLES = ("LB", "EQ", "MT", "MO") -mf = item_prices.mf - def used_keys(folder: Path) -> list[str]: """사본 하나가 담은 로직을 돌릴 때 부른 자원 키 — 부른 차례 · 겹침 없음.""" diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py index f4b252da2..8c3b26d16 100644 --- a/B09_Estimation/B09_Estimation_Sangeun.py +++ b/B09_Estimation/B09_Estimation_Sangeun.py @@ -62,7 +62,6 @@ from M02_MasterTemplete.M02_Item_Snapshot import ( ) from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, read_json -mf = item_prices.mf PARTS = ("labor", "material", "expense") COST_PART = {"노무비": "labor", "재료비": "material", "경비": "expense"} diff --git a/M02_MasterTemplete/M02_Hopyo_Fixed.py b/M02_MasterTemplete/M02_Hopyo_Fixed.py index 42e381ebe..87b283812 100644 --- a/M02_MasterTemplete/M02_Hopyo_Fixed.py +++ b/M02_MasterTemplete/M02_Hopyo_Fixed.py @@ -45,7 +45,9 @@ def kind_of(line: dict[str, Any]) -> str: return kind -mm_plain = m01.cm.mf.mp.mm.plain +import master_base as mb # noqa: E402 — 바탕만(855-E 2-E4) + +mm_plain = mb.mp.mm.plain def _parts(money: Any) -> dict[str, Decimal]: diff --git a/M02_MasterTemplete/M02_Hopyo_Match.py b/M02_MasterTemplete/M02_Hopyo_Match.py index 1f6c8e65c..ef0716393 100644 --- a/M02_MasterTemplete/M02_Hopyo_Match.py +++ b/M02_MasterTemplete/M02_Hopyo_Match.py @@ -22,7 +22,8 @@ from M01_MasterData import M01_MasterData_Store as m01 from M01_MasterData import M01_MasterData_Store_Combo as combo_store from M02_MasterTemplete import M02_Mat_Place as place -mf = m01.cm.mf +import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 + mp = mf.mp mm = mp.mm SEED_NAME = "일위대가조합.json" diff --git a/M02_MasterTemplete/M02_Hopyo_Sangeun.py b/M02_MasterTemplete/M02_Hopyo_Sangeun.py index 87518e106..6035e0174 100644 --- a/M02_MasterTemplete/M02_Hopyo_Sangeun.py +++ b/M02_MasterTemplete/M02_Hopyo_Sangeun.py @@ -14,7 +14,7 @@ from decimal import Decimal from pathlib import Path from typing import Any -from M01_MasterData import M01_MasterData_Store as m01 +from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠 from M02_MasterTemplete import M02_Hopyo_Elem as elem from M02_MasterTemplete import M02_Hopyo_Fixed as hfix from M02_MasterTemplete import M02_Labor_Doc as labor @@ -35,7 +35,9 @@ WHY = { "호표": "하위 호표 단위 다름 · 같은 하위 둘째", "%": "밑수가 다른 줄 금액 합 아님", } -mm_unit = m01.cm.mf.mp.mm.plain_unit +import master_base as mb # noqa: E402 — 바탕만(855-E 2-E4) + +mm_unit = mb.mp.mm.plain_unit def mark(key: str, no: int) -> str: diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 5581e0dda..f85130025 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -25,7 +25,8 @@ from typing import Any from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_MyMachine as mym # noqa: F401 — Item_Bundle.collect 가 씀 -mf = m01.cm.mf +import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 + mk = m01.mk mcb = m01.mcb mm = mf.mp.mm # 품셈재료 · 자재품목 후보(`master_material`) diff --git a/M02_MasterTemplete/M02_Labor_Doc.py b/M02_MasterTemplete/M02_Labor_Doc.py index 826c55f5f..8bb2de626 100644 --- a/M02_MasterTemplete/M02_Labor_Doc.py +++ b/M02_MasterTemplete/M02_Labor_Doc.py @@ -36,7 +36,7 @@ import json from decimal import Decimal, InvalidOperation from typing import Any -from M01_MasterData import M01_MasterData_Store as m01 +from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠 from M01_MasterData import M01_MasterData_Store_Combo as combo_store from M02_MasterTemplete import M02_Labor_Fixed as fixed from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs @@ -46,7 +46,8 @@ from M02_MasterTemplete import M02_Labor_Spec as spec from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Material_Own as own -mf = m01.cm.mf +import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 + mm = mf.mp.mm import master_cut as mcut # noqa: E402 — 끝수(751-3 · 품셈 1-2-2) · scripts 길은 `m01` 이 둠 diff --git a/M02_MasterTemplete/M02_Labor_Fixed.py b/M02_MasterTemplete/M02_Labor_Fixed.py index e7a92e9eb..4e3b521c1 100644 --- a/M02_MasterTemplete/M02_Labor_Fixed.py +++ b/M02_MasterTemplete/M02_Labor_Fixed.py @@ -21,9 +21,9 @@ from __future__ import annotations from decimal import Decimal, InvalidOperation from typing import Any -from M01_MasterData import M01_MasterData_Store as m01 +from M01_MasterData import M01_MasterData_Store as m01 # noqa: F401 — scripts 길을 둠 -mf = m01.cm.mf +import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 import master_cut as mcut # noqa: E402 — 끝수(751-3) · scripts 길은 `m01` 이 둠 mm = mf.mp.mm diff --git a/M02_MasterTemplete/M02_Logic_Standard.py b/M02_MasterTemplete/M02_Logic_Standard.py index 456f29962..3e53579c5 100644 --- a/M02_MasterTemplete/M02_Logic_Standard.py +++ b/M02_MasterTemplete/M02_Logic_Standard.py @@ -33,7 +33,7 @@ from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete import M02_Template_Layers as layers -mf = m01.cm.mf +import master_base as mf # noqa: E402 — 바탕만(855-E 2-E4 · 엔진 몸 안 읽음) · scripts 길은 `m01` 이 둠 import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠 import master_doc_calc as mc # noqa: E402 import master_doc_link as ml # noqa: E402 @@ -113,7 +113,7 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s """표 `ref` 조건 칸 `cond` 줄마다 (값, 글) — 범위 줄은 위 끝(없으면 아래 끝 · 드는 값).""" try: table = whole.get(ref) - except m01.cm.mf.FormulaError: + except mf.FormulaError: return [] ranged = table.get("조건", {}).get(cond) == "범위" out: dict[Any, str] = {} @@ -374,7 +374,7 @@ def sheet(key: str, change: dict) -> dict: files, whole = m01.loaded() try: m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글 - except m01.cm.mf.FormulaError as e: + except mf.FormulaError as e: raise m01.StoreError(404, str(e)) from e doc = m01_doc.docs()[key] given, ax = _given(whole, doc, change) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index 5a8c70646..40474ffea 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -20,14 +20,15 @@ from __future__ import annotations from typing import Any -import master_machine_crew as mcrew - from M01_MasterData import M01_MasterData_Doc as m01doc from M01_MasterData import M01_MasterData_Store as store from M02_MasterTemplete import M02_Labor_Inputs as li from M02_MasterTemplete import M02_MyMachine as mym cm = store.cm +import master_base as mb # noqa: E402 — 바탕만(855-E 2-E4) · scripts 길은 `store` 가 둠 +import master_machine_crew as mcrew # noqa: E402 + _PLAIN = { "기계", "지역", @@ -184,7 +185,7 @@ def hourly(key: str) -> dict[str, Any]: return {"ok": False, "reason": f"「{key}」 는 기계 아님"} try: row = (whole := mym.whole()).get(key) - except cm.mf.FormulaError as e: + except mb.FormulaError as e: return {"ok": False, "reason": str(e)} if mym.mine(key): return mym.hourly(row, whole) @@ -228,7 +229,7 @@ def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: if not got["셈됨"]: why = got.get("까닭") or " · ".join(m["글"] for m in got["표지"]) or "셈 못 함" return {"ok": False, "reason": why, "로직": logic["키"]} - return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}} + return {"ok": True, "합": {k: float(got[k]) for k in (*mb.COST_ITEMS, "계")}} #: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1) @@ -241,7 +242,7 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: 마스터를 다시 읽지 않고 색인 위에서 셈 · 색인마다 메모) · 키 · 원문번호로 찾음 · 없는 키 = 뺌.""" from M02_MasterTemplete.M02_Item_Prices import to_json - index, mf = store.loaded()[1], cm.mf + index, mf = store.loaded()[1], mb # ponytail: 통째 비움 · 기계 수(655)의 세 배 if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000: _BRIEF.clear() @@ -273,7 +274,7 @@ def combo(main: str, part: str) -> tuple[str, str] | None: (GC000270 · 271) 고르기에 있을 때만 · 부착 기계 줄은 제 시간당(손료만).""" try: codes = [str(store.loaded()[1].get(k).get("원문번호") or "") for k in (main, part)] - except cm.mf.FormulaError: + except mb.FormulaError: return None rows = _rows() fits = any(