"""M02 서고 쓰는 곳 색인 한 벌(858 5-5 · 설계 `설계_858_서고한벌.md` 부품 ⑦) — 「이 문서를 누가 쓰나」. 참조 찾기(단가산출 · 일위대가 · 구조물 조합 · 사본 블록 안 산근 — `M02_Labor_Ref.refs_in`): 쓰는 파일 = 모든 층(마스터 · 회사 · 개인 · 프로젝트 뺌) `labor` · `precombo` · `sangeun` 파일(`files`) · 파일마다 (이름, 참조 이름표들) 을 판(고친 때 · 크기)으로 기억(`ids_of` · 818-1) — 같은 판이면 안 엶 · 기억은 파생 저장본 `_derived/m02_layer_index/ids.json` 에도 둠(서버를 다시 띄워도 처음부터 안 읽음 · 지워도 다시 셈) · `users` = 「무엇 어디 「이름」」 목록 · `index` = {이름표: [(파일, 종류, 글)]} · `counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409. 자원 키 찾기(층 안): `machines` = 내 기계 키 → 이 층 단가산출(사본 · 수식 사본 단가 줄에 그 키) · `materials` = 내 재료 키 → 이 층 모든 문서(글에 그 키 · `_` `.` 폴더 · 내 재료 파일 뺌). 지우기 · 합치기는 `store.batch` 한 잠금 안에서 이 색인을 씀(`M02_Library_Delete` · `M02_Library_Same_Router`). """ from __future__ import annotations import json from pathlib import Path from typing import Any from common_util.common_util_derived_store import derived_dir, read_derived from common_util.common_util_json import atomic_write_json from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers #: 쓰는 쪽 종류 — 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」 KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출")) DERIVED, IDS = "m02_layer_index", "ids" # 파생 저장본 자리(826-1 층 목록 색인과 같은 폴더) UseFiles = list[tuple[str, str, str, Path]] # (종류, 무엇, 어디, 파일) Ids = tuple[str, frozenset[str]] _IDS: dict[Path, tuple[tuple[int, int], Ids]] = {} _LOADED: list[bool] = [] # ── 참조 ────────────────────────────────────────────────────────────── def files() -> UseFiles: """쓰는 곳을 찾을 파일 — 종류 차례 · 층 차례(마스터 → 회사 → 개인).""" return [(kind, what, at, path) for kind, what in KINDS for at, path in layers.layer_files(kind)] def ids_of(path: Path) -> Ids | None: """파일 하나의 (이름, 참조 이름표들) — 판이 같으면 기억한 것(로직 사본으로 SK 파일이 커서).""" _load() try: st = path.stat() stamp = (st.st_mtime_ns, st.st_size) if (hit := _IDS.get(path)) and hit[0] == stamp: return hit[1] doc = json.loads(path.read_bytes()) except (OSError, ValueError): return None name = ( (doc.get("일위대가번") or doc.get("이름") or path.stem) if isinstance(doc, dict) else None ) got = (str(name or path.stem), frozenset(refs.ref_id(one) for one in refs.refs_in(doc))) _IDS[path] = (stamp, got) return got def _scan(found: UseFiles | None) -> list[tuple[str, str, str, Path, Ids]]: """쓰는 파일마다 (종류, 무엇, 어디, 파일, 이름표) — 기억이 바뀌었으면 파생 저장본에 덧씀.""" found = files() if found is None else found _load() before = {path: hit[0] for path, hit in _IDS.items()} out = [(*one, got) for one in found if (got := ids_of(one[3]))] if any(before.get(one[3]) != _IDS[one[3]][0] for one in found if one[3] in _IDS): _save() return out def users(ref: refs.Ref, found: UseFiles | None = None) -> list[str]: """`ref` 를 담은 구조물 조합 · 일위대가 · 단가산출 — 「무엇 어디 「이름」」(프로젝트 뺌).""" rid = refs.ref_id(ref) return [f"{what} {at} 「{ids[0]}」" for _k, what, at, _p, ids in _scan(found) if rid in ids[1]] def index(found: UseFiles | None = None) -> dict[str, list[tuple[Path, str, str]]]: """한 번 훑어 {이름표: [(파일, 종류, 「무엇 어디 「이름」」)]}.""" out: dict[str, list[tuple[Path, str, str]]] = {} for kind, what, at, path, (name, rids) in _scan(found): for rid in rids: out.setdefault(rid, []).append((path, kind, f"{what} {at} 「{name}」")) return out def counts(found: UseFiles | None = None) -> dict[str, int]: """{이름표: 담은 파일 수} — `users` 개수와 같음.""" return {rid: len(hits) for rid, hits in index(found).items()} def refuse_used(folder: Path, kind: str, key: str) -> None: """쓰는 곳이 있으면 409 + 이름(서고 종류만).""" if kind not in refs.PREFIX: return layer, owner = refs.where(folder) if found := users({"층": layer, "주인": owner, "키": key}): raise store.StoreError(409, f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found)) def _load() -> None: """기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 판은 `ids_of` 가 다시 봄.""" if _LOADED: return _LOADED.append(True) got = read_derived(layers.storage_root(), DERIVED, IDS) for text, one in ((got or {}).get("value") or {}).items(): try: mtime, size, name, ids = one _IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids)))) except (TypeError, ValueError): continue def _save() -> None: """지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌 · 못 써도 다음에 다시 셈.""" got = read_derived(layers.storage_root(), DERIVED, IDS) value = dict((got or {}).get("value") or {}) for path, ((mtime, size), (name, ids)) in list(_IDS.items()): value[str(path)] = [mtime, size, name, sorted(ids)] value = {text: one for text, one in value.items() if Path(text).is_file()} try: path = derived_dir(layers.storage_root(), DERIVED) / f"{IDS}.json" atomic_write_json(path, {"key": IDS, "value": value}) except OSError: pass # ── 자원 키(층 안) ───────────────────────────────────────────────────── def machines(folder: Path | None = None) -> dict[str, list[dict[str, Any]]]: """{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것.""" from M02_MasterTemplete import M02_MyMachine as mym from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd out: dict[str, list[dict[str, Any]]] = {} for path in sorted(Path(folder or store.root()).joinpath(sd.KIND).glob("SK-*.json")): raw = path.read_bytes() if mym.PREFIX.encode() not in raw: continue try: doc = json.loads(raw) except ValueError: continue keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번 str(row["키"]) for part in (skc.KEY, "수식") for row in (doc.get(part) or {}).get("단가") or [] if mym.mine(row.get("키")) } for key in sorted(keys): out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")}) return out def materials(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]: """{내 재료 키: [{종류, 키, 이름}]} — 그 층 문서 글에 키가 든 것(파일은 한 번씩 읽음).""" from M02_MasterTemplete import M02_Material_Own as own folder = Path(folder) out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys} for path in sorted(folder.rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌 if path.name == own.FILE or _aside(path, folder): continue try: text = path.read_text(encoding="utf-8") except OSError: continue if not (hit := [k for k in keys if k in text]): continue try: doc = json.loads(text) except ValueError: continue name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem for k in hit: out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name}) return out def _aside(path: Path, folder: Path) -> bool: """밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님.""" return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])