Files
Aislo/M01_MasterData/M01_MasterData_Store_Cache.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

338 lines
14 KiB
Python

"""M01 마스터 한 번 읽어 두기 — 목록 길이 요청마다 마스터를 새로 읽지 않게.
`M01_MasterData_Store.loaded` · `.blocks` 가 씀(읽기 전용 길만).
자국(파일 시각·크기)이 바뀐 파일만 다시 읽고, 로직 막힘도 미리 세어 둠 —
목록은 검사를 돌리지 않고 세어 둔 값을 씀. 고치는 길(`calc` · `text` · `save`)은
사본을 만지므로 그대로 `cm.load` 로 새로 읽음.
저장 전 검사(`check_saved`)도 여기 — 어느 로직이 어느 요소·표·로직을 보는지 세어 두고
그것으로 저장이 흔드는 줄만 검사함(`narrow`).
"""
from __future__ import annotations
import contextlib
import contextvars
import copy
import json
import sys
import threading
from decimal import Decimal
from pathlib import Path
SCRIPTS = Path(__file__).resolve().parents[1] / "resources/master_data/scripts"
sys.path.insert(0, str(SCRIPTS))
import check_master as cm # noqa: E402
import master_doc_block as mb # noqa: E402 (막힘 · 저장 검사 = 수식 문서 기준 · 855 2-B3)
_FRESH = threading.RLock()
_READ: dict[str, tuple[tuple, dict]] = {} # 파일 이름 → (자국, 읽은 내용)
_INDEX: dict = {} # 폴더 · 자국 · files · whole
_BLOCK: dict[str, tuple[tuple, dict]] = {} # 로직 파일 → (자국, {키: `_check` 가 센 것})
_BASE: dict[str, tuple] = {} # 막힘을 셀 때 바탕이던, 로직 아닌 파일의 자국
_MARKED: dict[str, set] = {} # 우리가 고친 요소·표 파일 → 흔들린 자리(`narrow` 가 고른 것)
#: `steady()` 범위 — 폴더 → 자국(범위 안에선 자국 한 번 · `to_thread` 도 같은 묶음)
_STEADY: contextvars.ContextVar[dict | None] = contextvars.ContextVar("m01_steady", default=None)
@contextlib.contextmanager
def steady():
"""요청 한 번처럼 마스터가 안 바뀌는 범위 — `loaded` 가 파일 자국을 한 번만 셈."""
token = _STEADY.set({}) if _STEADY.get() is None else None
try:
yield
finally:
if token is not None:
_STEADY.reset(token)
def _now(folder: Path) -> dict[str, tuple]:
held = _STEADY.get()
if held is None:
return _stamps(folder)
if folder not in held:
held[folder] = _stamps(folder)
return held[folder]
def _stamps(folder: Path) -> dict[str, tuple]:
"""첫 층 JSON 자국 — {이름: (시각, 크기)} · 밑줄 파일은 `cm.load` 가 안 읽으므로 뺌."""
out = {}
for name in cm.mmf.names(folder):
if name == cm.mmf.NAME and cm.mmf.here(folder): # 기계 폴더(826-2) — 대마다 자국
out[name] = cm.mmf.stamp(folder)
elif not name.startswith("_"):
stat = (folder / name).stat()
out[name] = (stat.st_mtime_ns, stat.st_size)
return out
def _doc_store():
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게
return doc_store
def docs() -> dict[str, dict]:
"""저장 수식 문서 전부 {키: 문서}(`M01_MasterData_Doc.docs` · 파일 시각이 같으면 같은 묶음)."""
return _doc_store().docs()
def _logic_files():
"""단가산출 기초 = 수식 문서 파일(옛 로직 파일 이름 · `Doc.logic_files` · 855 L3 ⓐ)."""
return _doc_store().logic_files().items()
def reasons(key: str, whole) -> list[str]:
"""로직 하나의 막힘 까닭 — 수식 문서 기준(`master_doc_block` · 요소 닫힘은 `whole` 색인)."""
have = docs()
return mb.reasons(key, have.get(key), have, whole)
def _check(whole, row: dict) -> tuple[list[str], set, set]:
"""(막힘 까닭, 부르는 로직, 본 요소·표) — 그 로직의 수식 문서 기준(855 2-B3) ·
본 것 = 연결 요소 · 표 키 · 재료 고르기면 자재품목 묶음 통째(「#MT」)."""
have, key = docs(), str(row.get("키"))
doc = have.get(key)
if doc is None:
return mb.reasons(key, None, have, whole), set(), set()
return mb.reasons(key, doc, have, whole), mb.calls(doc), mb.seen(doc)
def forget() -> None:
"""읽어 둔 것을 버림 — 파일을 고친 자리(저장)에서 부름."""
with _FRESH:
_READ.clear()
_INDEX.clear()
_BLOCK.clear()
_BASE.clear()
_MARKED.clear()
if (held := _STEADY.get()) is not None:
held.clear()
def stale(names, marks=()) -> None:
"""그 파일만 다시 읽게 함 — 저장처럼 스스로 고친 자리에서 부름
(자국은 시각이 같은 틱이면 못 가릴 수 있으므로 고친 쪽이 알려 줌).
`marks` = 요소·표에서 흔들린 자리 — 그 자리를 보던 로직 줄만 다시 셈."""
with _FRESH:
for name in names:
_READ.pop(name, None)
_BLOCK.pop(name, None)
_MARKED.setdefault(name, set()).update(marks)
_INDEX.pop("자국", None)
if (held := _STEADY.get()) is not None:
held.clear()
def adopt(folder: Path, files: dict[str, dict], whole, names, marks=()) -> None:
"""저장 뒤 — 쓴 파일(`names`)만 기억에 갈아 끼움(다시 읽지 않음 · `files` · `whole` = 저장한 뒤
모습). 흔들린 자리는 `stale` 처럼 적어 둠. 그 사이 다른 파일도 바뀌었으면 `stale` 로."""
with _FRESH:
now = _stamps(folder)
rest = [n for n in now if n not in names]
if (
_INDEX.get("폴더") != folder
or set(now) != set(_READ) | set(names)
or any(_READ[n][0] != now[n] for n in rest)
):
return stale(names, marks)
for name in names:
_READ[name] = (now[name], files[name])
_BLOCK.pop(name, None)
_MARKED.setdefault(name, set()).update(marks)
_INDEX.update(자국=now, files={n: _READ[n][1] for n in now}, whole=whole)
if (held := _STEADY.get()) is not None:
held.clear()
def loaded(folder: Path) -> tuple[dict[str, dict], object]:
"""(파일 묶음, 색인) — **읽기 전용**. 고칠 것이면 `cm.load` 로 새로 읽을 것."""
with _FRESH:
if _INDEX.get("폴더") != folder: # 시험은 사본 폴더로 바꿈
forget()
_INDEX["폴더"] = folder
now = _now(folder)
for gone in [name for name in _READ if name not in now]:
del _READ[gone]
for name, stamp in now.items():
if _READ.get(name, (None,))[0] != stamp:
if name == cm.mmf.NAME and cm.mmf.here(folder): # 바뀐 대만 다시 읽음
_READ[name] = (stamp, cm.mmf.table(folder, shared=True)[0])
continue
raw = (folder / name).read_bytes()
_READ[name] = (stamp, json.loads(raw, parse_float=Decimal, parse_int=Decimal))
if _INDEX.get("자국") != now:
files = {name: _READ[name][1] for name in now}
_INDEX.update(자국=now, files=files, whole=cm.mf.Master(files))
return _INDEX["files"], _INDEX["whole"]
def blocks(folder: Path) -> dict[str, list[str]]:
"""로직 키마다 막힘 까닭 — 미리 세어 둔 값(수식 문서 파일마다). 요소 파일이 바뀌면 흔들린 자리를 보던
기초만 · 수식 문서가 바뀌면 통째로 다시 셈."""
with _FRESH:
files, whole = loaded(folder)
stamps = _INDEX["자국"]
if _INDEX.get("문서") is not (now := docs()): # 수식 문서가 바뀌면 통째로 다시
_BLOCK.clear()
_INDEX["문서"] = now
base = dict(stamps)
marks = None # 요소·표에서 흔들린 자리 — None 이면 무엇이 바뀐지 모름(통째로 다시)
if _BASE != base: # 인력 · 재료 · 표가 바뀌면 바탕이 달라짐
off = {n for n in set(_BASE) | set(base) if _BASE.get(n) != base.get(n)}
marks = set()
for name in off:
if name not in _MARKED: # 다른 창이 고친 파일 — 어디가 흔들렸는지 모름
marks = None
break
marks |= _MARKED[name]
if marks is None:
_BLOCK.clear()
_BASE.clear()
_BASE.update(base)
_MARKED.clear()
for (
name,
data,
) in _logic_files(): # 문서가 그대로면 세어 둔 것 · 바뀐 요소를 보던 기초만 다시
if name not in _BLOCK:
_BLOCK[name] = (None, {str(r.get("키")): _check(whole, r) for r in data["줄"]})
continue
got = _BLOCK[name][1]
rows = {str(r.get("키")): r for r in data["줄"]}
for key in [k for k, (_, _c, seen) in got.items() if marks and seen & marks]:
got[key] = _check(whole, rows[key])
return {key: why for _, got in _BLOCK.values() for key, (why, *_) in got.items()}
def counted(folder: Path) -> dict[str, tuple]:
"""로직 키마다 (막힘 까닭, 부르는 로직, 본 요소·표) — 미리 세어 둔 것."""
with _FRESH:
blocks(folder)
return {key: got for _, rows in _BLOCK.values() for key, got in rows.items()}
def _rows_of(data: dict) -> list:
return data.get("표") or data.get("줄") or []
def narrow(folder: Path, batch: list[dict], before: dict, after: dict):
"""(검사할 로직 키, 로직마다 부르는 키, 흔들린 자리) — 저장이 흔드는 줄만.
요소·표 줄은 그 줄을 **보던 기초**(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔
수식 문서 연결 지도) · 기초(로직) 고침은 이 길로 안 옴(`Store_Logic` · 855 L3 ⓐ).
"""
counts = counted(folder)
calls = {key: got[1] for key, got in counts.items()}
marks = set()
for part in batch:
name = part["file"]
was, now = ({str(r.get("키")): r for r in _rows_of(side[name])} for side in (before, after))
keys = (set(now) - set(was)) | {
str(c.get("key")) for c in part.get("changes") or [] if c.get("op") != "add"
}
for key in keys | (set(was) - set(now)): # 지운 줄도 — 가리키던 자리가 끊김
marks |= {key, "#" + key[:2]}
for side in (was, now):
number = (side.get(key) or {}).get("원문번호")
if number:
marks.add(f"{key[:2]}:{number}")
only = {key for key, got in counts.items() if got[2] & marks}
return only, calls, marks
_PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None)
@contextlib.contextmanager
def picks(add: dict, drop: set):
"""저장 중 — 저장 뒤 수식 문서 기계 고르기 목록에 할 더함 · 뺌(`Machine.register`)을 검사가 미리 봄."""
token = _PICKS.set((add, drop))
try:
yield
finally:
_PICKS.reset(token)
def _docs_of() -> dict[str, dict]:
"""수식 문서 전부(기초 정본 · 855 L3 ⓐ) — 저장 중 기계 목록 고침(`picks`)은 사본에 얹음."""
out = dict(docs())
if pending := _PICKS.get():
from M01_MasterData import (
M01_MasterData_Machine as machine,
) # Machine 이 Store 를 부름 — 늦게
for k, d in out.items():
one = copy.deepcopy(d)
if machine.relist(one, *pending):
out[k] = one
return out
def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str]:
"""저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) ·
좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 ·
문서 사이 순환) — 같은 흠을 두 번 안 적음."""
view = files | dict(_logic_files())
out = cm.duplicate_keys(view, book) + ([] if narrow else cm.check_links(whole))
return out or mb.check_docs(_docs_of(), narrow[0] if narrow else None, whole)
def combo_errors(files: dict) -> list[str]:
"""일위대가 조합 전부(옛 `master_combo.check_all` 대신) — 로직이 있는지는 수식 문서로."""
have = _docs_of()
return [f"{name} · {x}" for name, row in cm.mcb.rows(files) for x in mb.combo_row(row, have)]
def _labor_files() -> list[tuple[str, Path]]:
"""모든 층(마스터 · 회사 · 개인)의 일위대가 `labor/<열>.json` · 사전조합 `precombo/<키>.json`(51-11) —
(어디, 파일)."""
from M02_MasterTemplete import M02_Template_Layers as layers # M02 가 M01 을 부름 — 늦게
return [
(f"{what} {where}", path)
for kind, what in (("labor", "일위대가"), ("precombo", "사전조합"))
for where, path in layers.layer_files(kind)
]
def labor_errors(have, keys=None) -> list[str]:
"""일위대가 · 사전조합 문서가 담은 로직이 기초에 없음(39-1d · 50-3) —
로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은
`save` 가 고치기 전 검사와 견주어 뺌. `have` = 있는 기초 키(수식 문서 · 855-E L3) ·
`keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶)."""
out = []
if keys is not None and not keys:
return out
for where, path in _labor_files():
try:
raw = path.read_bytes()
if keys is not None and not any(k.encode() in raw for k in keys):
continue
doc = json.loads(raw)
except (OSError, ValueError):
continue
name = (doc.get("일위대가번") if isinstance(doc, dict) else None) or path.stem
for one in (doc.get("담은로직") if isinstance(doc, dict) else None) or []:
key = str(one.get("로직") or "") if isinstance(one, dict) else ""
if not key or (keys is not None and key not in keys):
continue
if key not in have:
out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
return out
def warm(folder: Path) -> threading.Thread:
"""서버가 뜰 때 뒤에서 한 번 읽어 둠 — 켠 뒤 첫 목록이 3초 걸리던 것을 없앰."""
def run() -> None:
try:
blocks(folder)
except Exception: # 마스터가 깨져 있어도 서버 시동을 막지 않음 — 목록에서 다시 드러남
pass
thread = threading.Thread(target=run, name="m01-warm", daemon=True)
thread.start()
return thread