perf(826-3-3): SK 저장 길 한 번씩 — M01 모으기 0 · SK 파일 읽기 한 번 · 빈틈 셈 겹침 뺌
- 저장 관문이 읽은 줄을 박을 때 저장마다 닫힌 묶음 다시 모으기(grow(stamp)) 안 함(SK · 일위대가 · 사전조합) - SK 파일 읽기 = 파일 자국 같으면 앞 것(skc.stored_doc · dsk.stored 같이 씀) - 수식 사본 빈틈 셈(gap.gaps · gap.fill)은 저장 관문이 같은 셈 한 번으로 갈음 - 들여쓰기 없이 쓰기는 안 함 — 마스터 층 SK 파일이 git 추적이라 한 줄 JSON 이면 창끼리 합칠 때 통째 충돌 · 줄인 뒤 이득 파일당 약 1 ms - 새 지킴 시험 test_826_3_copy_slim(아홉) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -165,14 +165,7 @@ def run(sk: dict, copy: dict, master: Any = None) -> dict:
|
||||
|
||||
# ── 저장 첫머리(옛 길 `clean_doc` 끝) ──────────────────────────────────
|
||||
def stored(key: Any) -> dict | None:
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
if not sd.KEY.match(str(key or "")):
|
||||
return None
|
||||
try:
|
||||
return json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
return skc.stored_doc(key) # 한 저장 안 한 번 읽음(826-3)
|
||||
|
||||
|
||||
def norm(copy: dict) -> dict:
|
||||
@@ -204,7 +197,8 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
|
||||
if dim.is_imported(out):
|
||||
return {**out, KEY: norm(have)}
|
||||
copy = dc.refresh(have)[0] if job == skc.PRICE else have
|
||||
return {**out, KEY: norm(gap.fill(copy))} # 사본 빈틈 = 지금 값으로 박음(822-1)
|
||||
slim = skc.READS.get() is not None # 저장 관문이 셈 한 번으로 박음(826-3)
|
||||
return {**out, KEY: norm(copy if slim else gap.fill(copy))} # 빈틈 = 지금 값(822-1)
|
||||
# 빈 SK(바탕 · 줄 없음) = 빈 문서(요구서_664 0 장) · 수식 길로 고친 빈 SK = 위 따로(804-4)
|
||||
if not skc.has(out) and not dim.is_imported(out):
|
||||
empty = seed(out)
|
||||
@@ -214,7 +208,9 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
|
||||
calls = {} if job == skc.REGEN else (have or {}).get("부름") or {}
|
||||
first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": calls}
|
||||
copy = copy_of({**out, KEY: first}, box[-1] if box else None)
|
||||
if copy and skc.has(out) and (keys := gap.gaps(copy)): # 파생 — 옛 로직 사본에 박음(822-1)
|
||||
if (
|
||||
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
|
||||
): # 파생 — 옛 로직 사본에 박음(822-1)
|
||||
out = {**out, skc.KEY: skc.grow(out[skc.KEY], skc.snap([], keys))}
|
||||
copy = {**copy, **dc.values_of(out[skc.KEY])}
|
||||
return {**out, KEY: norm({k: v for k, v in (copy or first).items() if k != "따로"})}
|
||||
|
||||
@@ -99,7 +99,7 @@ def settle(doc: Any, save: bool = False) -> Any:
|
||||
elif job == PRICE and copy:
|
||||
copy = skc.refresh(copy, skc.whole_())[0]
|
||||
if save and copy:
|
||||
copy = skc.grow(copy, stamp(out))
|
||||
copy = skc.grow(copy, stamp(out)) if skc.READS.get() is None else copy # 826-3
|
||||
if not copy:
|
||||
return out
|
||||
got = {**out, KEY: copy}
|
||||
|
||||
@@ -249,15 +249,29 @@ def taken(raw: Any) -> dict | None:
|
||||
return {**keep, "로직": logic, "판": _fp(logic), "단가": cost, "단가판": _fp(cost)}
|
||||
|
||||
|
||||
def _stored(key: Any) -> dict | None:
|
||||
_FILE: list = [(None, None)] # (자국, SK 파일) — 한 저장 안 같은 파일 되풀이 읽기 막음(826-3)
|
||||
|
||||
|
||||
def stored_doc(key: Any) -> dict | None:
|
||||
"""저장된 SK 파일(읽기만 — 고치지 말 것) · 파일 자국(경로 · 고친 때 · 크기)이 같으면 앞 것."""
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
if not sd.KEY.match(str(key or "")):
|
||||
return None
|
||||
file = store.root() / sd.KIND / f"{key}.json"
|
||||
try:
|
||||
got = json.loads((store.root() / sd.KIND / f"{key}.json").read_bytes())
|
||||
st = file.stat()
|
||||
mark = (str(file), st.st_mtime_ns, st.st_size)
|
||||
have = _FILE[0]
|
||||
if have[0] != mark:
|
||||
have = _FILE[0] = (mark, json.loads(file.read_bytes()))
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
return have[1]
|
||||
|
||||
|
||||
def _stored(key: Any) -> dict | None:
|
||||
got = stored_doc(key)
|
||||
return got[KEY] if has(got) else None
|
||||
|
||||
|
||||
@@ -276,7 +290,7 @@ def settle(doc: Any, save: bool = False) -> Any:
|
||||
copy = refresh(copy, whole_())[0]
|
||||
if copy and any(isinstance(x, dict) and x.get("다시잇기") for x in out.get("더한줄") or []):
|
||||
copy = rejoin(copy, out["더한줄"])
|
||||
if save and copy:
|
||||
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
|
||||
|
||||
@@ -0,0 +1,244 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""826-3 사본 = 셈이 실제로 읽은 줄만(요구 806 · 808) · SK 저장 길 한 번씩.
|
||||
|
||||
지킴: 사본 줄 = 읽은 줄(닫힌 묶음 수백 줄 → 열 줄 안팎) · 금액 = 닫힌 묶음 사본과 같음 ·
|
||||
M01 값 바뀌어도 그대로 · 옵션(기계) 바꿈 = 미리 셈 「사본없음 n」 + 지금 M01 값 → [저장] 때 박음
|
||||
(남은 줄 = 사본 값 그대로) · [단가 갱신] · [재생성] · 층 복사 · 일위대가 · 사전조합 사본도 ·
|
||||
옛 큰 사본 SK 그대로 읽힘 · 다음 [저장] 때 줄어듦 · 저장 한 번에 M01 모으기 0 · SK 파일 읽기 한 번.
|
||||
M01 바꿈 = 메모리 색인 사본(정본 파일 안 고침) · 층 = 임시 storage.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Item_Prices as prices
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
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_2_sc_copy import PCT, _labor, _read, _sc, _unit
|
||||
from resources.tester.test_822_1_copy_gap import (
|
||||
DIG,
|
||||
DIG2_NO,
|
||||
MACHINE,
|
||||
_at,
|
||||
_fuel_and_crew,
|
||||
_move,
|
||||
_price,
|
||||
_sk,
|
||||
_stack,
|
||||
_sum,
|
||||
)
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
DIG_BASE = "GC000088" # 터파기(기계) 보통토사 — 「기계」 고르기 후보를 닫힌 묶음이 다 담음
|
||||
|
||||
|
||||
def _file(folder, key) -> dict:
|
||||
return json.loads((folder / "sangeun" / f"{key}.json").read_bytes())
|
||||
|
||||
|
||||
def _keys(copy_: dict) -> list[str]:
|
||||
return [str(r.get("키")) for r in [*copy_["로직"], *(copy_.get("단가") or [])]]
|
||||
|
||||
|
||||
def _closed(doc: dict) -> int:
|
||||
"""옛 길(후보 전부 닫힌 묶음) 줄 수."""
|
||||
got = prices.collect([str(doc["바탕"]["로직"])])
|
||||
return sum(len(d[m01.items_key(d)]) for k, d in got.items() if not k.startswith("_"))
|
||||
|
||||
|
||||
def test_base_logic_read_rows_only(world):
|
||||
"""견본(터파기 기계) — 닫힌 묶음 수백 줄 → 읽은 줄만 · 자원 줄 한 자리 · 금액 = 닫힌 묶음 사본."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
doc = _file(me, key)
|
||||
have = doc[skc.KEY]
|
||||
assert _closed(doc) >= 3 * len(_keys(have))
|
||||
assert len(_keys(have)) <= 12 and len(have["단가"]) < 10
|
||||
assert _keys(have) == _keys(doc["수식"]) # 두 자리 같은 줄(꼴 그대로)
|
||||
full = {**doc, skc.KEY: skc.stamp(doc)} # 옛 길 사본(후보 전부)
|
||||
assert len(_keys(full[skc.KEY])) >= 3 * len(_keys(have))
|
||||
with store.at(me):
|
||||
old = calc.calc_doc(full, None, False)["기준"]
|
||||
new = calc.calc_doc(doc, None, False)["기준"]
|
||||
assert new == old and new["계"] > 0
|
||||
assert _sum(me, key) == new["계"]
|
||||
|
||||
|
||||
def test_m01_change_kept_then_price(world, monkeypatch):
|
||||
"""만든 뒤 M01(기계 · 유가 · 노임) 바뀜 → 금액 그대로 + 단가새값 → [단가 갱신] → 반영 · 그래도 작음."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
was = _sum(me, key)
|
||||
read = set(_keys(_file(me, key)[skc.KEY]))
|
||||
moved = [k for k in read if k[:2] in ("EQ", "LB", "MO")]
|
||||
assert moved
|
||||
_move(monkeypatch, *moved)
|
||||
assert _sum(me, key) == was
|
||||
assert _at(me, path.read, key)["사본"]["단가새값"] is True
|
||||
got = _price(me, key)
|
||||
assert set(got["바뀐"]) == set(moved) and got["후"] > was
|
||||
assert set(_keys(_file(me, key)[skc.KEY])) == read
|
||||
|
||||
|
||||
def test_machine_swap_preview_then_save(world, monkeypatch):
|
||||
"""기계 바꿈(옵션) — 미리 셈 = 새 기계 지금 M01 값 + 「사본없음 n」 · [저장] = 새 줄만 박음 ·
|
||||
남은 줄(유가 · 노임) = 사본 값 그대로 · 안 읽는 옛 기계 줄은 빠짐."""
|
||||
me = world["personal"]
|
||||
key = _sk(me)
|
||||
_stack(me, key, [("기계", MACHINE, "묶음")])
|
||||
first = _file(me, key) # 줄 쌓기(수식 길) = 수식 사본 값 몫
|
||||
before = set(_keys(first["수식"]))
|
||||
assert DIG in before
|
||||
fuel, crew = _fuel_and_crew()
|
||||
w = m01.loaded()[1]
|
||||
dig2 = w.numbers["EQ"][DIG2_NO]["키"]
|
||||
assert dig2 not in before
|
||||
files, live = m01.loaded()
|
||||
_move(monkeypatch, dig2) # 바꾸는 때의 M01 = 새 기계 값 두 배
|
||||
fake_dig2 = m01.loaded()[1]
|
||||
_move(monkeypatch, fuel, crew) # 사본에 든 유가 · 노임도 바뀜(사본 값이 이겨야 함)
|
||||
got = _at(me, path.read, key)
|
||||
doc = copy.deepcopy(got["문서"])
|
||||
for var in doc["변수"]:
|
||||
if (var.get("연결") or {}).get("갈래") == "단가산출":
|
||||
var["연결"]["입력"] = {"기계": f"'{DIG2_NO}'"}
|
||||
look = _at(me, path.preview, key, {"문서": doc})
|
||||
assert look["사본"]["사본없음"] > 0 # 저장하면 지금 값으로 굳음
|
||||
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
||||
after = _file(me, key)
|
||||
now = set(_keys(after["수식"]))
|
||||
assert dig2 in now and DIG not in now and {fuel, crew} <= now
|
||||
old_rows = {str(r["키"]): r for r in first["수식"]["단가"]}
|
||||
new_rows = {str(r["키"]): r for r in after["수식"]["단가"]}
|
||||
assert new_rows[fuel] == old_rows[fuel] and new_rows[crew] == old_rows[crew]
|
||||
amount = _sum(me, key)
|
||||
assert amount == look["셈"]["계"]
|
||||
# 기준 = 새 기계만 두 배인 M01 로 처음 만든 같은 SK(유가 · 노임 = 처음 값)
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (files, fake_dig2))
|
||||
ref = _sk(me)
|
||||
_stack(me, ref, [("기계", {**MACHINE, "입력": {"기계": f"'{DIG2_NO}'"}}, "묶음")])
|
||||
assert _sum(me, ref) == amount
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (files, live))
|
||||
assert _sum(me, key) == amount # M01 되돌아가도 그대로
|
||||
|
||||
|
||||
def test_regen_slim(world, monkeypatch):
|
||||
"""[재생성] — 지금 M01 로 다시 찍어도 읽은 줄만 · 그 뒤 M01 바뀌어도 그대로."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
read = [k for k in _keys(_file(me, key)[skc.KEY]) if k[:2] in ("EQ", "MO")]
|
||||
_move(monkeypatch, *read)
|
||||
판 = _at(me, path.read, key)["판"]
|
||||
_at(me, path.save, key, {"할일": skc.REGEN, "판": 판})
|
||||
after = _file(me, key)[skc.KEY]
|
||||
assert len(_keys(after)) <= 12
|
||||
was = _sum(me, key)
|
||||
_move(monkeypatch, *read)
|
||||
assert _sum(me, key) == was
|
||||
|
||||
|
||||
def test_layer_copy_slim(world, monkeypatch):
|
||||
"""층 복사(개인 → 회사) — 받은 사본째 · 읽은 줄만 · 원본 M01 바뀐 뒤 복사해도 그 값."""
|
||||
me, co = world["personal"], world["company"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
was = _sum(me, key)
|
||||
_move(monkeypatch, DIG, *[k for k in _keys(_file(me, key)[skc.KEY]) if k[:2] == "EQ"])
|
||||
ref = {"층": "personal", "주인": "7/42", "키": key}
|
||||
with store.at(co):
|
||||
doc = refs.read_ref(ref)
|
||||
new = refs.create("sangeun", refs.carry(refs.origin_mark(doc, ref), ("personal", "7/42")))
|
||||
assert _sum(co, new["이름"]) == was
|
||||
assert _keys(_file(co, new["이름"])[skc.KEY]) == _keys(_file(me, key)[skc.KEY])
|
||||
|
||||
|
||||
def test_labor_and_combo_slim(world, monkeypatch):
|
||||
"""일위대가 · 사전조합 사본 — 닫힌 묶음보다 작음 · 금액 그대로 · M01 바뀌어도 그대로."""
|
||||
me = world["personal"]
|
||||
lines = [{"로직": DIG_BASE, "수량": {"손": 1}}]
|
||||
lab = _labor(me, lines)
|
||||
sc = _sc(me, lines)
|
||||
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["수식"])
|
||||
unit = _unit(me, sc)
|
||||
assert unit > 0
|
||||
_move(monkeypatch, *[k for k in _keys(lab[skc.KEY]) if k[:2] in ("EQ", "LB", "MO")])
|
||||
assert _unit(me, sc) == unit
|
||||
|
||||
|
||||
def test_old_big_copy_reads_then_slims(world):
|
||||
"""옛 큰 사본(후보 전부) SK — 그대로 읽힘(같은 금액 · 열기 = 안 고쳐 씀) · 다음 [저장] 때 줄어듦."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
was = _sum(me, key)
|
||||
file = me / "sangeun" / f"{key}.json"
|
||||
raw = json.loads(file.read_bytes())
|
||||
big = skc.stamp(raw)
|
||||
raw[skc.KEY] = big
|
||||
raw["수식"] = {**raw["수식"], **{k: big[k] for k in ("판", "로직", "단가판", "단가")}}
|
||||
file.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8")
|
||||
before = file.read_bytes()
|
||||
assert _sum(me, key) == was
|
||||
assert file.read_bytes() == before
|
||||
with store.at(me):
|
||||
got = store.read("sangeun", key)
|
||||
store.write("sangeun", key, got["판"], got["문서"])
|
||||
assert len(_keys(_file(me, key)[skc.KEY])) * 3 <= len(big["로직"]) + len(big["단가"])
|
||||
assert _sum(me, key) == was
|
||||
|
||||
|
||||
def test_save_path_once(world, monkeypatch):
|
||||
"""SK 다시 저장 한 번 — M01 모으기 0 · SK 파일 읽기(셈 쪽) 한 번 · 옛 셈 한 번."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
count = {"모으기": 0, "읽기": 0, "셈": 0}
|
||||
collect, run, read_bytes = prices.collect, calc.run, Path.read_bytes
|
||||
|
||||
def counted(name, fn):
|
||||
def wrap(*a, **k):
|
||||
count[name] += 1
|
||||
return fn(*a, **k)
|
||||
|
||||
return wrap
|
||||
|
||||
def reading(self):
|
||||
if self.name == f"{key}.json":
|
||||
count["읽기"] += 1
|
||||
return read_bytes(self)
|
||||
|
||||
with store.at(me):
|
||||
got = store.read("sangeun", key)
|
||||
monkeypatch.setattr(prices, "collect", counted("모으기", collect))
|
||||
monkeypatch.setattr(calc, "run", counted("셈", run))
|
||||
monkeypatch.setattr(Path, "read_bytes", reading)
|
||||
store.write("sangeun", key, got["판"], got["문서"])
|
||||
# 읽기 = 사본 정함 한 번 + 판 맞춤(쓰기 전) + 새 판(쓰기 뒤)
|
||||
assert count == {"모으기": 0, "읽기": 3, "셈": 1}
|
||||
|
||||
|
||||
def test_doc_path_save_keeps_both_slots(world):
|
||||
"""수식 길 저장(옵션 Type · 지역 바꿈) — 사본 · 수식 두 칸 같은 줄 · 새로 읽은 줄 더함 ·
|
||||
금액 = 미리 셈 = 같은 옵션으로 처음 만든 것."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥")
|
||||
got = _at(me, path.read, key)
|
||||
doc = copy.deepcopy(got["문서"])
|
||||
for var in doc["변수"]:
|
||||
if var.get("열쇠") in ("Type", "지역"):
|
||||
var["연결"]["값"] = {"Type": "TypeⅢ", "지역": "경북"}[var["열쇠"]]
|
||||
look = _at(me, path.preview, key, {"문서": doc})
|
||||
assert look["사본"]["사본없음"] > 0
|
||||
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
||||
after = _file(me, key)
|
||||
assert set(_keys(after[skc.KEY])) == set(_keys(after["수식"]))
|
||||
assert len(_keys(after[skc.KEY])) >= 6
|
||||
assert _sum(me, key) == look["셈"]["계"] != got["셈"]["계"]
|
||||
Reference in New Issue
Block a user