Merge remote-tracking branch 'origin/dev' into sub_laptop_1

This commit is contained in:
2026-11-18 04:07:44 +09:00
9 changed files with 78 additions and 27 deletions
+6 -4
View File
@@ -120,11 +120,13 @@ EMPTY_GONE = (
def trim(kind: str, doc: Any) -> Any:
"""층 저장 꼴 = 남는 칸만(855 2-D) — 값 사본 = `수식` 값 몫 한 벌(`사본` 은 셈 중 칸 · 파일엔 안 씀) ·
단가산출 빈 옛 칸 · `M01판`(읽는 곳 없음) 뺌 · 프로젝트 층은 이 길을 안 탐(`saved`)."""
if kind != "sangeun" or not isinstance(doc, dict):
if not isinstance(doc, dict):
return doc
out = {k: v for k, v in doc.items() if not (k in EMPTY_GONE and v in (None, {}, [], ""))}
out.pop("M01판", None)
form = out.get(dc.KEY)
out = dict(doc)
if kind == "sangeun":
out = {k: v for k, v in out.items() if not (k in EMPTY_GONE and v in (None, {}, [], ""))}
out.pop("M01판", None)
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))}
return out
+4 -4
View File
@@ -209,8 +209,8 @@ def with_upper(sk: dict, got: dict, keep: bool = False) -> dict:
def upper(sk: dict, got: Any) -> Any:
"""셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1)."""
if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk):
return got
if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk) or renew.frozen(got):
return got # 굳은 사본 = 실린 위덮음 그대로(855 2-D)
return with_upper(sk, got)
@@ -225,8 +225,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None:
if got is None:
return None
got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1)
if got.get("따로"):
return carry.carry(sk, got) # 848-7 가져온 식 ① = 가져온 값
if got.get("따로") or (renew.frozen(got) and isinstance(got.get("문서"), dict)):
return carry.carry(sk, got) # 848-7 가져온 식 ① = 가져온 값 · 굳은 사본 = 실린 문서 그대로
if old_only(sk):
return None
whole = whole if whole is not None else skc.over(sk, skc.whole_())
+4 -4
View File
@@ -1,6 +1,6 @@
"""M02 일위대가 · 사전조합(SC) 로직 사본(PLAN 795-2 · 요구 655 · 656 · 요구서_655) — 서버 단독.
SK 사본(`M02_Sangeun_Copy` · 795-1) 한 벌 — 문서 칸 `사본` 꼴 · 판 · 단가 · 할일 칸 `사본할일`
SK 사본(`M02_Sangeun_Copy` · 795-1) 한 벌 — 셈 중 문서 칸 `사본` 꼴(층 파일 = `수식` 값 몫 한 벌 · 855 2-D) · 판 · 단가 · 할일 칸 `사본할일`
(단가갱신 | 재생성) · [단가 갱신] = 자원 단가 줄만 · 자동 갱신 없음 · 지워진 M01 키 = 마지막 값.
사본에 담는 것 = 담은로직 로직 줄 · 줄 덮개(`M02_Labor_Patch`) 더한줄(로직 · 요소 · 고정 이음) ·
고정 줄 이음 · 사용자 자재(MT) 가 닿는 M01 닫힌 묶음(참조 줄 = 그 문서 제 사본).
@@ -66,7 +66,7 @@ def _file(doc: dict) -> dict:
def _stored(doc: dict) -> dict | None:
got = _file(doc)
return got[KEY] if skc.has(got) else None
return skc.held(got) # 셈 중 사본 › 층 파일 `수식` 값 몫(855 2-D)
def _keys(doc: dict) -> list[str]:
@@ -93,7 +93,7 @@ def settle(doc: Any, save: bool = False) -> Any:
job = doc.get(JOB) # 모르는 할일 = 없음
out = {k: v for k, v in doc.items() if k not in (KEY, JOB, dc.KEY)}
file = _file(doc)
copy = skc.taken(doc.get(KEY)) or (file[KEY] if skc.has(file) else None)
copy = skc.taken(skc.held(doc)) or skc.held(file) # 값 사본 = 층 파일 `수식` 값 몫(855 2-D)
if job == REGEN or (copy is None and save):
copy = stamp(out)
elif job == PRICE and copy:
@@ -210,7 +210,7 @@ def combo(expand: Any, doc: dict, trail: tuple[str, ...]) -> dict[str, Any]:
from M02_MasterTemplete import M02_Labor_Ref as refs
was = expand.whole
if expand.read is refs.read_ref and skc.has(doc):
if expand.read is refs.read_ref and skc.held(doc) is not None:
expand.whole = skc.over(doc, was)
try:
return expand._combo(doc, trail)
+2 -1
View File
@@ -155,7 +155,8 @@ def _auto(doc: Any, copy: dict) -> dict:
"""SK 사본 = 프로젝트 층 밖이면 지금 M01 줄(836-2 · `M02_Sk_AutoRenew`)."""
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
return renew.rows(copy) if renew.is_sk(doc) else copy
form = doc.get(FORM) if isinstance(doc, dict) else None
return renew.rows(copy) if renew.is_sk(doc) and not renew.frozen(form) else copy
def over(doc: Any, whole: Any) -> Any:
+10 -1
View File
@@ -52,6 +52,15 @@ _LIVE: list[Any] = [None]
_NO = object() # 바탕 모름
FROZEN = "굳힘" # `수식` 표지 — 사본(구조물 · B09 서고 · 프로젝트)이 만들 때 적음(sub1 B9-5)
def frozen(copy: Any) -> bool:
"""굳은 사본의 수식 — 위덮음 · 문서 · 값을 실린 그대로 셈(자동 따라옴 안 함 · 855 2-D ·
사용자 원칙: 프로젝트는 M02 것을 복사해 가져감 · [재생성] · [단가 갱신] 전까지 그대로)."""
return isinstance(copy, dict) and copy.get(FROZEN) is True
def on() -> bool:
"""자동 따라옴 — 프로젝트 층 밖."""
from M02_MasterTemplete import M02_Labor_Ref as refs
@@ -236,7 +245,7 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) ->
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
프로젝트 층 = 그대로 · `confirm` = 알림 [확인] 저장(바탕 걷음)."""
if not isinstance(got, dict) or not on() or not is_sk(sk):
if not isinstance(got, dict) or not on() or not is_sk(sk) or frozen(got):
return got
out = rows(got) if "로직" in got else dict(got)
out = _covers(sk, got, out, notes, confirm)
+9 -8
View File
@@ -82,8 +82,8 @@ 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 got["사본"]["로직"]}
assert LB in {r["키"] for r in got["사본"]["단가"]}
assert PCT in {r["키"] for r in skc.held(got)["로직"]}
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
_fake(monkeypatch, [_changed(_live().logic(PCT))])
@@ -113,22 +113,22 @@ def test_layer_and_column_copy_keep_copy(world, monkeypatch):
"""④ 층 사이 복사(회사 → 개인) · 열 복사 = 원본 사본 그대로(지금 M01 로 다시 안 찍음)."""
co, me = world["company"], world["personal"]
src = _sc(co, [{"로직": PCT, "수량": {"손": 1}, "패치": COVER}])
first = _read(co, "precombo", src)["사본"]
old = _labor(me, [{"로직": PCT, "수량": {"손": 2}}])["사본"] # 받는 열 = 옛 M01 사본
first = skc.held(_read(co, "precombo", src))
old = skc.held(_labor(me, [{"로직": PCT, "수량": {"손": 2}}])) # 받는 열 = 옛 M01 사본
_fake(monkeypatch, [_double(LB), _changed(_live().logic(PCT))])
ref = {"층": "company", "주인": "7", "키": src}
with store.at(me):
got = refs.create(
"precombo", refs.carry(refs.origin_mark(refs.read_ref(ref), ref), ("company", "7"))
)
mine = _read(me, "precombo", got["이름"])["사본"]
mine = skc.held(_read(me, "precombo", got["이름"]))
assert (mine["판"], mine["단가판"]) == (first["판"], first["단가판"])
_write(me, "labor", "sub2임시2", {"열": "sub2임시2", "담은로직": [{"로직": PCT}], "자재": []})
other = _read(me, "labor", "sub2임시2")["사본"] # 원본 열 = 바뀐 M01 사본
other = skc.held(_read(me, "labor", "sub2임시2")) # 원본 열 = 바뀐 M01 사본
assert other["판"] != old["판"]
with store.at(me): # 열 복사(copy_from) = 받은 사본 먼저
store.copy_from("labor", COL, "sub2임시2")
assert _read(me, "labor", COL)["사본"]["판"] == other["판"]
assert skc.held(_read(me, "labor", COL))["판"] == other["판"]
def test_ts_mirror_same_amount(world, monkeypatch):
@@ -152,7 +152,8 @@ def test_old_doc_without_copy_old_path(world, monkeypatch):
me = world["personal"]
_labor(me, [{"로직": PCT, "수량": {"손": 1}}])
path = me / "labor" / f"{COL}.json"
raw = {k: v for k, v in json.loads(path.read_bytes()).items() if k != "사본"}
gone = ("사본", "수식") # 값 사본 = `수식` 값 몫(855 2-D) — 둘 다 없는 옛 문서
raw = {k: v for k, v in json.loads(path.read_bytes()).items() if k not in gone}
path.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8")
assert "사본" not in _calc(me, COL)
_fake(monkeypatch, [_double(LB)])
+3 -2
View File
@@ -22,6 +22,7 @@ from M02_MasterTemplete import M02_Doc_Sk as dsk
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Imported as imp
from resources.tester.test_822_1_copy_gap import _move
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
@@ -138,7 +139,7 @@ def test_swap_machine_excel_basis(world, monkeypatch):
_at(me, path.save, key, {"문서": swapped, "판": 판})
again = _at(me, path.read, key)
assert again["셈"]["계"] == look["계"] and dim.swapped(again["문서"]) == 1
kept = _at(me, lambda: store.read("sangeun", key)["문서"]["사본"])
kept = _at(me, lambda: skc.held(store.read("sangeun", key)["문서"]))
assert NEW_EQ in {r["키"] for r in [*kept["로직"], *kept["단가"]]}
_move(monkeypatch, NEW_EQ)
assert _at(me, path.read, key)["셈"]["계"] == look["계"]
@@ -162,7 +163,7 @@ def test_swap_to_my_machine(world):
assert abs(_lines(look)[i] - hour * 0.1) < 1 # 수량 0.1 × 시간당
판 = _at(me, path.read, key)["판"]
_at(me, path.save, key, {"문서": swapped, "판": 판})
kept = _at(me, lambda: store.read("sangeun", key)["문서"]["사본"])
kept = _at(me, lambda: skc.held(store.read("sangeun", key)["문서"]))
assert row["키"] in {r["키"] for r in [*kept["로직"], *kept["단가"]]}
+3 -3
View File
@@ -180,11 +180,11 @@ def test_labor_and_combo_slim(world, monkeypatch):
full = prices.collect([DIG_BASE])
closed = sum(len(d[m01.items_key(d)]) for k, d in full.items() if not k.startswith("_"))
for doc in (lab, _read(me, "precombo", sc)):
assert len(_keys(doc[skc.KEY])) * 3 <= closed
assert _keys(doc[skc.KEY]) == _keys(doc["수식"])
assert len(_keys(skc.held(doc))) * 3 <= closed
assert skc.KEY not in doc # 값 사본 = `수식` 값 몫 한 벌(855 2-D)
unit = _unit(me, sc)
assert unit > 0
_move(monkeypatch, *[k for k in _keys(lab[skc.KEY]) if k[:2] in ("EQ", "LB", "MO")])
_move(monkeypatch, *[k for k in _keys(skc.held(lab)) if k[:2] in ("EQ", "LB", "MO")])
assert _unit(me, sc) == unit
+37
View File
@@ -0,0 +1,37 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""855 2-D — 굳은 사본 표지 `수식.굳힘`(사본을 만들 때 적음 · 사용자 원칙: 프로젝트는 M02 것을 복사해
가져가 [재생성] · [단가 갱신] 전까지 그대로).
임시 storage · 개인 층 단가산출(바탕 PCT · 노임 LB000036). M01 노임을 두 배로 바꾸면:
표지 없는 층 단가산출 = 따라옴(836-2) · 표지 있는 같은 문서 = 실린 값 · 문서 그대로 셈.
"""
from __future__ import annotations
import copy
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_Sk_AutoRenew as renew
from resources.tester.test_795_1_sk_copy import _doc, _fake, _sk
from resources.tester.test_795_2_sc_copy import LB, PCT, _double
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
def _sum(folder, doc) -> Decimal:
with store.at(folder):
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
def test_굳힘_표지면_M01_바뀌어도_그대로_없으면_따라옴(world, monkeypatch):
me = world["personal"]
live = _doc(me, _sk(me, 바탕={"로직": PCT}))
held = copy.deepcopy(live)
held["수식"][renew.FROZEN] = True
was = _sum(me, live)
assert _sum(me, held) == was > 0
_fake(monkeypatch, [_double(LB)]) # M01 노임 두 배
assert _sum(me, live) > was # 층 서고 = 지금 M01 따라옴
assert _sum(me, held) == was # 굳은 사본 = 실린 값 그대로