Files
Aislo/M02_MasterTemplete/M02_Library_Uses.py
T

186 lines
8.8 KiB
Python

"""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])