- 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>
170 lines
7.4 KiB
Python
170 lines
7.4 KiB
Python
"""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"))
|