diff --git a/M02_MasterTemplete/M02_Copy_Slim.py b/M02_MasterTemplete/M02_Copy_Slim.py index 482265429..196b3e4f2 100644 --- a/M02_MasterTemplete/M02_Copy_Slim.py +++ b/M02_MasterTemplete/M02_Copy_Slim.py @@ -7,7 +7,7 @@ 이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈). 파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음). 읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦. -층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌. +층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌. """ from __future__ import annotations @@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any: form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름) if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list): out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))} + form = out.get(dc.KEY) + if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list): + out[dc.KEY] = { + **form, + **skc.held({"종류": "단가산출", dc.KEY: form}), + } # 로직 줄 안 씀(855 L2 ⓑ) return out diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index fbe8b4653..1695a2cf1 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]: except dc._ERR: pass have = _have(copy) - return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have) + got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have + return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ) def fill(copy: dict) -> dict: @@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict: seen = _Seen(dim._index(sk, None, doc)) dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음) keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY])) + keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ) if not keys: return sk return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))} diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 857649a66..8bcba8554 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: if renew.on() and live is not None: return dc.doc_of(whole, key), True kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None - if kept: - return cp.deepcopy(kept), True + if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값) + return cp.deepcopy(kept), renew.on() if live is not None and live.get(mcv.HAND): from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 @@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None: whole = dc.over(values) calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") - seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지) + # 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ) + seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {} return {**got, **values, "문서": root, "부름": calls, **origin} @@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: UPPER ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) first[UPPER] = have[UPPER] + if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣) + kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC) + key = str((out.get("바탕") or {}).get("로직") or "") + if kept is None and key in dc.folder(): + kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서 + if kept: + first[BASE_DOC] = norm(_bare_doc(kept)) copy = copy_of({**out, KEY: first}, whole) if ( copy and skc.READS.get() is not None - ): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3) + ): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ) run({**out, KEY: copy}, copy, whole) - index = dc.over(copy) - for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠 - try: - index.logic(key) - except dc._ERR: - pass if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) ): # 파생 — 옛 로직 사본에 박음(822-1) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 0611e02e2..fd00e77b1 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict: def _rows(copy: dict) -> set[str]: - return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]} + rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ) + return {str(r.get("키")) for r in rows} def _basis(doc: dict, body: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index c92cc9cd7..31e99baf1 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -3,7 +3,9 @@ 사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` · 층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로): {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?} - 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등) + 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) — + 단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 = + 문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌) 단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음. 셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) — `M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 · @@ -67,16 +69,31 @@ def has(doc: Any) -> bool: FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D) VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가") +#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`) +LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직") + + +def plain(rows: Any) -> list: + """값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만).""" + return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)] + + +def _plain(copy: dict) -> dict: + """단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴).""" + rows = plain(copy["로직"]) + return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)} def held(doc: Any) -> dict | None: """문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D · - 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None.""" + 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None.""" + sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE if has(doc): - return doc[KEY] + return _plain(doc[KEY]) if sk else doc[KEY] form = doc.get(FORM) if isinstance(doc, dict) else None if isinstance(form, dict) and isinstance(form.get("로직"), list): - return {k: form[k] for k in VALUES if k in form} + got = {k: form[k] for k in VALUES if k in form} + return _plain(got) if sk else got return None @@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any: if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함 copy = grow(copy, stamp(out)) out = _formula_job(out, job) - return {**out, KEY: copy} if copy else out + return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ) def _formula_job(out: dict, job: Any) -> dict: @@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict: if got is None or job not in (PRICE, REGEN): return out if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림 - drop = ("문서", "끊음", "따로", "처음", *renew.KEEP) + drop = ( + "문서", + "끊음", + "따로", + "처음", + "바탕문서", + *renew.KEEP, + ) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ) got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}} elif got.get("따로"): got = dc.refresh(got)[0] @@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict: return ans copy = doc[KEY] head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")} - return {**ans, KEY: {**head, **state(copy, whole_())}} + got = state(copy, whole_()) + if not got["M01새판"] and _doc_moved(doc): + got = {**got, "M01새판": True} + return {**ans, KEY: {**head, **got}} + + +def _doc_moved(doc: dict) -> bool: + """M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) · + 자동 따라옴 SK = 늘 지금 문서라 안 봄.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + form = doc.get(FORM) + if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)): + return False + return bool(dc.state(form)["문서새판"]) def same_part(doc: Any) -> str | None: @@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None: if copy is None: return None seen = state(copy, whole_()) - fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"]) + fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc)) return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}" diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index c893a4bb9..c0057bcb5 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -97,9 +97,9 @@ def rows(copy: Any) -> Any: return {**copy, **hit} got: dict = {} for part, mark in (("로직", "판"), ("단가", "단가판")): - old = copy.get(part) or [] + old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ) new = [_fresh(r, live) if isinstance(r, dict) else r for r in old] - if any(a is not b for a, b in zip(old, new)): + if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)): got |= {part: new, mark: skc._fp(new)} if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로 _MEMO.clear() diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 1a28585d6..29fc83f18 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()): from M02_MasterTemplete import M02_Doc_Copy as dc files, live = m01.loaded() - fake = skc.Copy(live, [copy.deepcopy(r) for r in rows]) + fake = copy.copy( + live + ) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ) + fake.index = {t: dict(v) for t, v in live.index.items()} + fake.numbers = {t: dict(v) for t, v in live.numbers.items()} + for row in rows: + row, key = copy.deepcopy(row), str(row["키"]) + fake.index.setdefault(key[:2], {})[key] = row + if row.get("원문번호"): + fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row for key in drop: - skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None) + fake.index.get(key[:2], {}).pop(key, None) monkeypatch.setattr(m01, "loaded", lambda: (files, fake)) docs = {k: v for k, v in dc.folder().items() if k not in drop} docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r} @@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) got = skc.held(_doc(me, key)) - assert PCT in {r["키"] for r in got["로직"]} + assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ) assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"]) assert not any(r["키"][:2] in skc.RES for r in got["로직"]) first = _calc(me, _doc(me, key)) @@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch): def test_deleted_keys_keep_last_value(world, monkeypatch): - """⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지.""" + """⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409).""" me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB")) - _fake(monkeypatch, drop=[PCT, lb]) - with pytest.raises(Exception): - m01.loaded()[1].logic(PCT) + _fake(monkeypatch, drop=[lb]) now = _calc(me, _doc(me, key)) assert now["기준"]["계"] == was - assert {PCT, lb} <= set(now["사본"]["지운키"]) + assert {lb} <= set(now["사본"]["지운키"]) with store.at(me): got = path.preview(key, {"할일": skc.PRICE}) assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"] diff --git a/resources/tester/test_855_l2b_copy_plain.py b/resources/tester/test_855_l2b_copy_plain.py new file mode 100644 index 000000000..5f8ec907f --- /dev/null +++ b/resources/tester/test_855_l2b_copy_plain.py @@ -0,0 +1,50 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 · +일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌). + +임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음. +""" + +from __future__ import annotations + +import copy +import json +from decimal import Decimal + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Copy as skc +from resources.tester.test_795_1_sk_copy import _doc, _sk +from resources.tester.test_795_2_sc_copy import PCT, _read, _sc +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + + +def _logic_rows(doc: dict) -> list[str]: + rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])] + return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC] + + +def _sum(folder, doc) -> Decimal: + with store.at(folder): + return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"])) + + +def test_저장본에_로직줄_없음_금액_같음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}])) + assert _logic_rows(sk) == [] and PCT in _logic_rows(sc) + assert _sum(me, sk) > 0 + + +def test_옛_저장본_로직줄은_안_읽음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + was = _sum(me, sk) + old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것) + row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str)) + row["호표"] = row["호표"][:1] + old["수식"]["로직"] = [*old["수식"]["로직"], row] + assert skc.held(old)["로직"] == skc.held(sk)["로직"] + assert _sum(me, old) == was