186 lines
8.8 KiB
Python
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])
|