Files
Aislo/M01_MasterData/M01_MasterData_Store_Save.py
T
eomsangdonandClaude Opus 5.5 7e6190f8d3 refactor(855-E L3ⓐ): M01 기초 저장 · 검사 · 막힘 세기 = 수식 문서 기준 · 로직 줄 쓰기 = Store_Logic.mirror 한 자리
앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어
- Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움
- Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음
- Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리)
- 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록)
  · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀)
  · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음
  · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음)
  · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사
  · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움)

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

176 lines
7.7 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 ⓐ)."""
if bad := [p.get("file") for p in batch if _logic_file(p.get("file", ""))]:
raise store.StoreError(400, f"기초는 기초 저장 길로 — {', '.join(bad)}")
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 _logic_file(name: str) -> bool:
return name.startswith("로직_") and name.endswith(".json")
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"))