Files
Aislo/M01_MasterData/M01_MasterData_Store_Save.py
T
eomsangdonandClaude Opus 5.5 badceff991 refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0)
- Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 ·
  labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움)
- M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 ·
  손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함)
- M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서)
- 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움
- 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 ·
  파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) ·
  848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음
- 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:28:00 +09:00

170 lines
7.4 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""M01 저장 — `M01_MasterData_Store.save` 의 몸(826-2 · 저장 길 줄이기).
전 = 기억(`Store_Cache.loaded`) · 후 = 고친 파일만 얕은 사본(줄 목록만 새로 · 줄은 바꿔 끼움만) —
폴더를 다시 읽지 않음. 검사 = 저장이 흔드는 것만: 로직은 `Store_Cache.narrow` · 틀은 고친 줄만 ·
연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤을 때 · 키 겹침 · 대장 대조 ·
돌고 도는 참조는 전체(가벼움) · 기초(로직) 저장은 `Store_Logic`(855 L3 ⓐ).
전 검사는 기억 색인(재료 고르기 찾기 기억이 데워져 있음) · 후 색인은 그 기억을 이어받음
(자재품목 줄이 바뀌면 그 줄이 걸리는 찾기만 버림). 저장 뒤 = 쓴 파일만 기억에 갈아 끼움.
"""
from __future__ import annotations
import os
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Cache as cache
from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape
cm, mk = store.cm, store.mk
mmf = cm.mmf
def _copy(data: dict) -> dict:
"""고칠 사본 — 머리는 그대로 나누고 줄 목록만 새로(`_apply` 는 줄을 바꿔 끼우기만 함)."""
key = store.items_key(data)
return {**data, key: list(data.get(key) or [])}
def _rows(data: dict) -> dict[str, dict]:
return {str(r.get("키")): r for r in data.get(store.items_key(data)) or []}
def _only(name: str, data: dict, keys: set[str]) -> dict:
"""틀 검사 몫 — 줄마다 보는 검사라 고친 줄만(조합 파일은 이름 겹침을 보므로 통째)."""
if name == cm.mcb.FILE:
return data
key = store.items_key(data)
return {**data, key: [r for r in data.get(key) or [] if str(r.get("키")) in keys]}
def _index(files: dict, whole, moved: list[dict]):
"""후 색인 — 전 색인의 찾기 기억을 이어받음. `moved` = 바뀐 자재품목 줄(전 · 후)."""
out = cm.mf.Master(files)
mp = cm.mf.mp
mm = mp.mm
if not moved:
for name in ("_found", "_market", "_by_class"):
if hasattr(whole, name):
setattr(out, name, getattr(whole, name))
return out
found = getattr(whole, "_found", None) or {}
texts = [(mm.label(r).replace("×", "x"), mm.plain_spec(r.get("규격")), r) for r in moved]
def hit(memo_key) -> bool: # `master_pick._search` 의 거름과 같음 — 걸리면 답이 바뀔 수 있음
term, kind, detail = memo_key[:3]
words = mp._words(term)[0]
return any(
all(w in name or w in spec for w in words)
and (not kind or row.get("구분") == kind)
and (not detail or row.get("상세구분") == detail)
for name, spec, row in texts
)
out._found = {k: v for k, v in found.items() if not hit(k)}
return out
def _errors(files, whole, names, book, narrowed, keys) -> list[str]:
out = [x for name in names for x in cm.check_form(name, _only(name, files[name], keys[name]))]
out += cache.logic_errors(files, whole, book, narrowed[:2]) # 수식 문서 기준(855 2-B3)
if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로)
out += cm.check_links(whole)
if cm.mcb.FILE in names:
out += cache.combo_errors(files)
return out
def save(batch: list[dict]) -> list[dict]:
"""요소 · 표 파일 저장 — 단가산출 기초는 `Store_Logic`(855 L3 ⓐ · `Store_Make.save` 가 가름)."""
with store._LOCK:
stale = [
p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version")
]
if stale:
raise store.StoreError(409, {"stale": stale})
before, whole = store.loaded()
names = list(dict.fromkeys(part["file"] for part in batch))
after = {**before, **{name: _copy(before[name]) for name in names}}
book_path = store.FOLDER / mk.BOOK.name
book = mk.load_book(book_path)
old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])} # `issue` 는 새 키만 더함
issued = dict(book["다음"])
for part in batch:
store._apply(after[part["file"]], part.get("changes") or [], part["file"], book)
mk.finish(book)
keys, moved = {}, []
for name in names:
was, now = _rows(before[name]), _rows(after[name])
keys[name] = set(now) - set(was)
keys[name] |= {
str(c.get("key"))
for p in batch
if p["file"] == name
for c in p.get("changes") or []
if c.get("op") != "add"
}
moved += [s[k] for k in keys[name] for s in (was, now) if k[:2] == "MT" and k in s]
# 저장이 흔드는 줄만 검사(고친 줄 · 그 줄을 부르던 줄 · 그 요소를 보던 줄) —
# 마스터 전체 검사는 `check_master` 몫
narrowed = cache.narrow(store.FOLDER, batch, before, after)
old = set(_errors(before, whole, names, old_book, narrowed, keys))
fresh = _index(after, whole, moved)
new = [x for x in _errors(after, fresh, names, book, narrowed, keys) if x not in old]
if new:
raise store.StoreError(422, {"errors": new})
# 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게)
raw = {n: (store.FOLDER / n).read_bytes() for n in names if not _machine(n)}
book_raw = book_path.read_bytes() if book["다음"] != issued else None
tried: list[str] = []
try:
if book_raw is not None:
mk.save_book(book, book_path)
out = []
for name in names:
tried.append(name)
out.append({"file": name, "version": _write(name, before[name], after[name])})
except BaseException:
_undo(tried, before, after, raw, book_path, book_raw)
raise
# 저장 뒤 — 쓴 파일만 기억에 갈아 끼우고 흔들린 자리를 알려 줘 그 줄만 다시 세게
cache.adopt(store.FOLDER, after, fresh, names, narrowed[2])
return out
def _machine(name: str) -> bool:
return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2)
def _put(path, raw: bytes) -> None:
tmp = path.with_name(f".{path.name}.tmp")
tmp.write_bytes(raw)
os.replace(tmp, path)
def _undo(names, before, after, raw, book_path, book_raw) -> None:
"""쓰기 중간 실패 — 쓴(쓰려던) 파일 · 대장을 저장 전 글로 되돌림."""
for name in names:
if _machine(name):
mmf.write(
store.FOLDER, before[name], after[name]
) # 바뀐 · 더한 · 지운 대를 저장 전으로
else:
_put(store.FOLDER / name, raw[name])
if book_raw is not None:
_put(book_path, book_raw)
def _write(name: str, before: dict, after: dict) -> str:
if _machine(name): # 기계 = 바뀐 대 파일만(826-2)
mmf.write(store.FOLDER, after, before)
return store.version(name)
path = store.FOLDER / name
old_text = path.read_bytes().decode("utf-8")
key = store.items_key(after)
text = keep_shape(old_text, before, after, key) or dump(after)
tmp = store.FOLDER / f".{name}.tmp"
tmp.write_text(text, encoding="utf-8", newline="\n")
os.replace(tmp, path)
return store.version_of(text.encode("utf-8"))