From 1050acc424351164c2a33db800a2cf2d8deff9ab Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 01:27:16 +0900 Subject: [PATCH] =?UTF-8?q?feat(848-7):=20=EA=B0=80=EC=A0=B8=EC=98=A8=20?= =?UTF-8?q?=EC=8B=9D=20SK=20=EB=A8=B8=EB=A6=AC=20[=EC=B4=88=EA=B8=B0?= =?UTF-8?q?=ED=99=94]=20=3D=20=EB=B6=88=EB=9F=AC=EC=98=A8=20=EA=B7=B8?= =?UTF-8?q?=EB=8C=80=EB=A1=9C=20=C2=B7=20=EB=82=A1=EC=9D=80=20=EC=8B=9C?= =?UTF-8?q?=ED=97=98=20=EB=AC=B8=EC=84=9C=20=EC=88=98=20=EB=B0=95=EC=9D=8C?= =?UTF-8?q?=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 M02_Doc_Import_Reset — 걷을 것 = 수식 길 고침(따로 문서 → 불러올 때 문서 · 내 고침 기계덮음 · 기계 바꿈 · 줄 · 값) · 옛 칸 고침(덮개 · 뺀줄 · 더한줄) · 재생성 할일로 저장(옛 따로 사본 안 이어받음) · 남김 = 단가 기준(엑셀 · 우리) · 가져온 값 층 · 고른 재료 · 내 기계 · 값 사본 - M02_Library_Flat formula_edits · reset — 가져온 식이면 위 둘을 부름(확인창 목록 848-3 꼴 그대로 · 없으면 「되돌릴 고침 없음」) - 시험 test_848_7 초기화 둘(거창 1 엑셀 판 · 봉화 109 우리 판 — 고침 뒤 초기화 금액 = 불러온 직후 · 단가 기준 그대로) - 낡은 시험 고침: test_845_1 · test_813_2 가 수식 문서 수 1,520 · 1,521 을 박아 둠(848-4 새 식 GC001202 로 1,521 → 실패) → 「로직마다 수식 문서 하나」 · 「목록 = 로직 − 부품」 처럼 자료가 늘어도 뜻을 지키는 단언으로 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import_Reset.py | 71 +++++++++++++++++++++ M02_MasterTemplete/M02_Library_Flat.py | 18 +++++- resources/tester/test_813_2_parts.py | 6 +- resources/tester/test_845_1_doc_units.py | 7 +- resources/tester/test_848_7_import_carry.py | 41 ++++++++++++ 5 files changed, 135 insertions(+), 8 deletions(-) create mode 100644 M02_MasterTemplete/M02_Doc_Import_Reset.py diff --git a/M02_MasterTemplete/M02_Doc_Import_Reset.py b/M02_MasterTemplete/M02_Doc_Import_Reset.py new file mode 100644 index 000000000..2a3e1217a --- /dev/null +++ b/M02_MasterTemplete/M02_Doc_Import_Reset.py @@ -0,0 +1,71 @@ +"""M02 가져온 식 SK [초기화] = 「불러온 그대로」(PLAN 848-7 · 요구 889 「초기화 = 위 층과 같게」) — 서버 단독. + +걷는 것 = 수식 길 고침(따로 문서 → 불러올 때 문서 `처음` · 내 고침 ② `기계덮음` — 작업량 방식 · 변수 · +값 · 인력 · 잡품 · 기계 바꿈(823-1 연결 `바꿈`) · 줄 · 식 고침) · 옛 칸 고침(덮개 · 뺀줄 · 더한줄). +남기는 것 = 단가 기준(엑셀 · 우리 지금 고른 판) · 가져온 줄 · 불러올 때 고른 재료(827-3) · 내 기계(821-4) · +값 사본 · 이름 · 기본정보 · ① 가져온 값 층(셈마다 문서에서 지음 · `M02_Doc_Import_Carry`). +`M02_Library_Flat.formula_edits` · `reset` 이 가져온 식이면 이 두 함수를 부름(확인창 목록 = 848-3 꼴). +""" + +from __future__ import annotations + +from typing import Any + +from M02_MasterTemplete import M02_Doc_Copy as dc + +OLD = ("덮개", "뺀줄", "더한줄") # 옛 칸 고침 +GONE = ("따로", "처음", "끊음") # 수식 길 고침 표지(걷으면 셈마다 가져온 줄에서 다시 지음) + + +def _covers(got: dict) -> dict: + return {**(got.get("기계덮음") or {}), **((got.get("문서") or {}).get("기계덮음") or {})} + + +def _swaps(doc: dict) -> int: + return sum( + 1 + for v in doc.get("변수") or [] + if isinstance(v.get("연결"), dict) and v["연결"].get("바꿈") + ) + + +def _bare(doc: dict) -> str: + """셈 칸 지문 — 기계덮음 · 이름 · 글 칸 뺌(`doc_fp`) · 바꾼 연결 = 원래(`바꿈.연결` · 823-1).""" + rows = [ + {**v, "연결": v["연결"]["바꿈"]["연결"]} + if isinstance(v.get("연결"), dict) + and isinstance((v["연결"].get("바꿈") or {}).get("연결"), dict) + else v + for v in doc.get("변수") or [] + ] + return dc.doc_fp({**{k: v for k, v in doc.items() if k != "기계덮음"}, "변수": rows}) + + +def edits(sk: dict) -> list[str]: + """걷힐 것 목록 — 없음 = [].""" + got = sk.get(dc.KEY) if isinstance(sk.get(dc.KEY), dict) else {} + mine, first = got.get("문서") or {}, got.get("처음") + items = [f"기계 고침 — {k}" for k in sorted(_covers(got))] + if n := _swaps(mine): + items.append(f"기계 바꿈 — {n} 줄") + if got.get("따로") and isinstance(first, dict) and _bare(mine) != _bare(first): + items.insert(0, "수식 문서 고침(줄 · 식)") + items += [f"옛 칸 고침 — {k}" for k in OLD if sk.get(k)] + return items + + +def reset(sk: dict) -> tuple[dict, int]: + """(걷은 SK, 걷힌 수) — 걷을 것 없음 = (그대로, 0).""" + items = edits(sk) + if not items: + return sk, 0 + # 재생성 할일 = 저장이 옛 수식 사본(따로)을 안 이어받고 가져온 줄에서 다시 지음(값 사본 · 단가 기준 그대로) + out = {**sk, "덮개": {}, "뺀줄": [], "더한줄": [], dc.skc.JOB: dc.skc.REGEN} + got = sk.get(dc.KEY) + if isinstance(got, dict): + copy: dict[str, Any] = {k: v for k, v in got.items() if k not in (*GONE, "기계덮음")} + first = got.get("처음") if isinstance(got.get("처음"), dict) else got.get("문서") + if isinstance(first, dict): + copy["문서"] = {k: v for k, v in first.items() if k != "기계덮음"} + out[dc.KEY] = copy + return out, len(items) diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index b4f573445..64ab90384 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -539,14 +539,18 @@ def _options(mine: dict) -> dict: def formula_edits(doc: dict) -> list[str]: - """수식 길 고침(889) — 줄 · 식 고친 문서 · 끊은 부름 · 기계 고침 목록(가져온 식 = 없음 · 엑셀 원본 대비 · + """수식 길 고침(889) — 줄 · 식 고친 문서 · 끊은 부름 · 기계 고침 목록(가져온 식 = 불러온 그대로 대비 · 848-7 · 바탕 기초 없는 SK = 없음 · 같게 할 기초가 없어 줄을 지키고 기계 고침은 줄마다 되돌림) · 줄 · 식 판정 = 셈 칸 지문(`doc_fp` · 이름 · 글 칸 뺌) · 옵션 값은 남기니 판정에서 뺌.""" from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Import as imp + if imp.is_imported(doc): # 848-7 가져온 식 = 「불러온 그대로」 대비 + from M02_MasterTemplete import M02_Doc_Import_Reset as imported + + return imported.edits(doc) got = doc.get(dc.KEY) if dc.has(doc) else None - if not got or imp.is_imported(doc) or not (doc.get("바탕") or {}).get("로직"): + if not got or not (doc.get("바탕") or {}).get("로직"): return [] mine, first = got.get("문서") or {}, got.get("처음") @@ -567,6 +571,12 @@ def formula_edits(doc: dict) -> list[str]: return items +def _imported(doc: dict) -> bool: + from M02_MasterTemplete import M02_Doc_Import as imp + + return imp.is_imported(doc) + + def reset(kind: str, doc: dict) -> tuple[dict, int]: """[초기화] — (걷은 문서, 걷힌 고침 수) · 먼저 펼침(옛 참조 줄도 M01 키로) · SK 수식 길 고침(따로 문서 · 끊음 · 기계 고침 · 889) = 재생성 할일로 함께 걷음(그 기초와 같게) · @@ -574,7 +584,11 @@ def reset(kind: str, doc: dict) -> tuple[dict, int]: from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Sangeun_Copy as skc + from M02_MasterTemplete import M02_Doc_Import_Reset as imported + doc = flat_doc(kind, doc) + if kind == "sangeun" and _imported(doc): # 848-7 = 불러온 그대로(단가 기준 그대로) + return imported.reset(doc) if kind == "sangeun": adds, n = _reset_adds(doc.get("더한줄") or []) n += const.covers_n(doc) # 790-2 상수 · 표값 덮개도 걷음(까닭 같이) diff --git a/resources/tester/test_813_2_parts.py b/resources/tester/test_813_2_parts.py index 4ceea569b..372d81088 100644 --- a/resources/tester/test_813_2_parts.py +++ b/resources/tester/test_813_2_parts.py @@ -63,9 +63,7 @@ def test_지움_6_이름_4(): led = json.loads((store.FOLDER / "_키대장.json").read_text(encoding="utf-8")) for k in GONE: assert k not in docs and k not in rows and k not in led["키"] and k in led["폐기"] - assert ( - len(docs) == len(rows) == 1521 - ) # 813-2 뒤 1,513 + 새 기계경비식 8(816-3 · 822-2 · 822-2b · 848-4) + assert len(docs) == len(rows) > 1000 # 로직마다 수식 문서 하나(새 식이 늘어도 뜻 그대로) for k, name in NAMES.items(): assert docs[k]["이름"] == rows[k]["이름"] == name and "부품" not in docs[k] @@ -74,7 +72,7 @@ def test_목록에서_뺌_키로_열림_부르기_그대로(): tags = parts.parts() m01 = {x["키"] for x in m01_router.get_logics()["logics"]} m02 = {x["키"] for x in combos.get_logics()["logics"]} - assert not (m01 | m02) & set(tags) and len(m01) == len(m02) == 1521 - 81 + assert not (m01 | m02) & set(tags) and len(m01) == len(m02) == len(_rows()) - len(tags) for k in ("GC000267", "GF000088", "GC001191"): assert doc_store.read(k)["문서"]["부품"] == tags[k] assert m01_router.get_logic(k)["logic"]["키"] == k diff --git a/resources/tester/test_845_1_doc_units.py b/resources/tester/test_845_1_doc_units.py index effa9828e..7ddba2e82 100644 --- a/resources/tester/test_845_1_doc_units.py +++ b/resources/tester/test_845_1_doc_units.py @@ -1,6 +1,6 @@ """845-1 수식 문서 변수 단위 채움 지킴 시험 (요구 880). -① 저장본 1,520 문서 — 채움 규칙(`master_doc_unit.fill`)을 다시 돌려도 바뀔 단위 0 +① 저장본 전부(로직 줄과 같은 수) — 채움 규칙(`master_doc_unit.fill`)을 다시 돌려도 바뀔 단위 0 (단위 있어야 할 줄에 빈 단위 0 · 남긴 짐작 빼고). ② 단위 칸에 자리표시 · 「수」 글이 남지 않음 — 행마다 다른 단위는 「줄 따름」 한 표기. ③ 단가 단위(원/X)를 가진 금액 줄은 줄 단위 X 와 맞음(노임 원/일 = 인 · 「D/M」 글 둘 뺌). @@ -39,7 +39,10 @@ def whole(): def test_다시_채워도_바뀔_단위_없음(saved, whole): - assert len(saved) == 1520 + logic = {str(r["키"]) for d in m01.loaded()[0].values() if d.get("그룹") == "로직" for r in d.get("줄") or []} # fmt: skip + assert ( + len(saved) > 1000 and set(saved) == logic + ) # 로직마다 수식 문서 하나(자료가 늘어도 뜻 그대로) left = {k: mu.fill(copy.deepcopy(d), whole) for k, d in saved.items()} assert {k: v for k, v in left.items() if v} == {} diff --git a/resources/tester/test_848_7_import_carry.py b/resources/tester/test_848_7_import_carry.py index 52b800fe1..2373aa683 100644 --- a/resources/tester/test_848_7_import_carry.py +++ b/resources/tester/test_848_7_import_carry.py @@ -401,3 +401,44 @@ def test_방식_없는_위_층_변수_물려받음_거울(): proc = subprocess.run(["node", "-e", _JS_PRUNE, str(ROOT)], input=json.dumps(cases), capture_output=True, text=True, encoding="utf-8", check=True) # fmt: skip assert json.loads(proc.stdout) == want + + +# ── ⑧ 가져온 식 [초기화] = 불러온 그대로(임시 storage) ─────────────────────── +@pytest.mark.parametrize( + "kind, tag, no, sym, basis", + [("EST", "거창", 1, "P_굴삭기", "엑셀"), ("STC", "봉화", 109, "P_노무", "우리")], +) +def test_초기화_불러온_그대로_단가기준_그대로(world, kind, tag, no, sym, basis): + from M02_MasterTemplete import M02_Doc_Sk_Path as path + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_Library_Flat as flat + from M02_MasterTemplete import M02_MasterTemplete_Store as store + + sk, _, _ = _block(kind, tag, no) + sk["가져온"]["단가기준"] = basis + with store.at(world["personal"]): + key = refs.create("sangeun", {**sk, "이름": "848-7 sub1임시 초기화"})["이름"] + got = path.read(key) + first = _money(got["셈"]) + assert flat.reset_doc("sangeun", key, None, True, None)["걷힘"] == 0 # 고침 없음 + doc = cp.deepcopy(got["문서"]) + doc["기계덮음"] = { + sym: {"작업량": {"방식": "시간당", "식": got["위덮음"][sym]["작업량"]["식"]}} + } + var = next(v for v in doc["변수"] if (v.get("연결") or {}).get("갈래") == "숫자" and not isinstance(v["연결"]["값"], dict)) # fmt: skip + var["연결"]["값"] = float(var["연결"]["값"]) * 1.5 # 줄 · 값 고침 + edited = _money(path.save(key, {"문서": doc, "판": got["판"]})["셈"]) + assert edited != first + look = flat.reset_doc("sangeun", key, None, True, None) + assert look["걷힘"] == 2 and look["목록"] == [ + "수식 문서 고침(줄 · 식)", + f"기계 고침 — {sym}", + ] + flat.reset_doc("sangeun", key, None, False, None) + again = path.read(key) + assert _money(again["셈"]) == first and again["사본"]["단가기준"] == basis + assert ( + not again["사본"]["따로"] + and not again["문서"].get("기계덮음") + and again["위덮음"] == got["위덮음"] + )