"""기계 쓰는 곳 색인(PLAN 848-5 · 요구서 889 6 장) — 수식 문서 기준 · 단가산출 역색인 · 덮음 세기. 기초(수식 문서) 색인 — 문서 파일 자국 · M01 판이 같으면 다시 안 셈(프로세스 기억 · 1 초 안): 직접 = 기계 고르기 목록에 듦 · 부름 입력 값에 박힘(`'0201-0020'` — 입력 이름 무관 · 집게 · 브레이커) · EQ 요소 키 기본 = 직접 가운데 기본 선택(고르기 `값`) · 박힌 입력 · EQ 요소 — 그 기계를 기본으로 탐 사슬 = 직접 문서를 부르는 문서(거슬러 닫힘 · 직접 뺌 · 고름에 달림 = 상한) 덮음 = 기초 `기계덮음` 의 기계 입력 글 → 덮은 칸 단가산출(SK) 색인 — 모든 층 + 프로젝트 사본 · 파일 자국이 같으면 기억 그대로(SK 저장 = 자국 바뀜 = 그 파일만 다시 읽음) · 파생 저장본 storage `_derived/m01_machine_uses/`(지워도 다시 지음): 기계 = 사본 단가 줄의 EQ 키(그 SK 가 지금 고름으로 실제 쓰는 기계 · 내 기계 EQP 도) 바탕 = 원본 키 · 바탕 로직 · 부름 문서 · 문서의 단가산출 연결 키(기초 → 단가산출 역색인) 덮음 = `COVERS` 길마다 기계 입력 글 → 덮은 칸 — 덮음(② 내 고침 `수식.문서.기계덮음`) · 위덮음(① 위 층 고침 `수식.위덮음` · 848-1 계약) — 「따로 고쳐 둔 곳」 = ② 만 · ① 은 따로 셈 덮은 칸 이름 = 값 칸 이름 · 줄 묶음(조종원 · 잡품 · 그 밖 덮음 머리 칸). 읽기만 — 기계 · 문서 · SK 를 고치지 않음. 이름은 기초만 냄 — 단가산출은 층별 수만(남의 층 이름 안 냄). """ from __future__ import annotations import json import os import re import threading from pathlib import Path from typing import Any from common_util.common_util_derived_store import derived_dir, file_stamp, read_derived from common_util.common_util_json import atomic_write_json from M01_MasterData import M01_MasterData_Doc as docmod from M01_MasterData import M01_MasterData_Store as store COVER = "기계덮음" COVERS: dict[str, tuple[str, ...]] = { # SK 안 덮음 칸 길(848-1 계약) "덮음": ("수식", "문서", COVER), # ② 내 고침 "위덮음": ("수식", "위덮음"), # ① 위 층 고침(기초에서 고친 것) } PRICE_PARTS = ("수식", "사본") # 사본 단가 줄이 든 칸(수식 길 · 옛 칸) KIND, SHAPE = "m01_machine_uses", 2 # 기록 꼴이 바뀌면 올림 _EQ = re.compile(r"EQ\d{6}") _LOCK = threading.RLock() _DOC: dict[str, Any] = {} _SK: dict[str, Any] = {} # ── 기초 색인 ───────────────────────────────────────────────────────── def _machines(whole) -> dict[str, list[str]]: """원문번호 → 기계 키(번호 겹침 = 여럿).""" out: dict[str, list[str]] = {} for key, row in (whole.index.get("EQ") or {}).items(): out.setdefault(str(row.get("원문번호") or ""), []).append(key) return out def cover_of(doc: Any) -> dict[str, list[str]]: """덮음 묶음 {기계 입력 글: {값?: {칸}, 조종원?, 잡품?, …}} → {입력 글: 덮은 칸 이름}.""" out: dict[str, list[str]] = {} if not isinstance(doc, dict): return out for text, one in doc.items(): if not isinstance(one, dict): continue names = [*(one.get("값") or {})] + [k for k in one if k != "값"] if names: out[str(text).strip("'")] = names return out def _scan(doc: dict, codes: dict[str, str]) -> tuple[set[str], set[str], set[str]]: """문서 하나 → (직접 원문번호, 기본 원문번호, 부르는 문서 키) — `codes` = 원문번호 · 키 → 원문번호.""" direct: set[str] = set() default: set[str] = set() calls: set[str] = set() for v in doc.get("변수") or []: link = v.get("연결") or {} kind = link.get("갈래") if kind == "선택": for x in link.get("목록") or []: if isinstance(x, str) and x in codes: direct.add(codes[x]) if str(link.get("값")) == x: default.add(codes[x]) elif kind == "요소" and _EQ.fullmatch(str(link.get("키") or "")): key = str(link["키"]) code = codes.get(key, key) direct.add(code) default.add(code) elif kind == "단가산출": if link.get("키"): calls.add(str(link["키"])) for t in (link.get("입력") or {}).values(): t = str(t).strip("'") if t in codes: direct.add(codes[t]) default.add(codes[t]) return direct, default, calls def doc_index() -> dict[str, Any]: """{직접: {원문번호: {문서}}, 기본: …, 부름: {문서: {부르는 문서}}, 덮음: {문서: {입력 글: 칸}}, 문서}.""" docs, whole = docmod.docs(), store.loaded()[1] with _LOCK: if _DOC.get("docs") is docs and _DOC.get("whole") is whole: return _DOC numbers = _machines(whole) codes = {c: c for c in numbers} | {k: c for c, ks in numbers.items() for k in ks} direct: dict[str, set[str]] = {} default: dict[str, set[str]] = {} callers: dict[str, set[str]] = {} covers: dict[str, dict[str, list[str]]] = {} for key, doc in docs.items(): d, b, calls = _scan(doc, codes) for c in d: direct.setdefault(c, set()).add(key) for c in b: default.setdefault(c, set()).add(key) for target in calls: callers.setdefault(target, set()).add(key) if got := cover_of(doc.get(COVER)): covers[key] = got _DOC.clear() _DOC.update(docs=docs, whole=whole, 직접=direct, 기본=default, 부름=callers, 덮음=covers) return _DOC def chain(seed: set[str], callers: dict[str, set[str]]) -> set[str]: """`seed` 를 (거슬러) 부르는 문서 전부 — `seed` 포함.""" seen, todo = set(seed), list(seed) while todo: for c in callers.get(todo.pop(), ()): if c not in seen: seen.add(c) todo.append(c) return seen # ── 단가산출 색인 ───────────────────────────────────────────────────── def _sk_files() -> list[tuple[str, Path]]: """(층, 파일) — 마스터 · 회사 · 개인 + 프로젝트 사본(`<회사>/<사용자>/<프로젝트>/templates/sangeun`).""" from M02_MasterTemplete import M02_Template_Layers as layers # M02 가 M01 을 부름 — 늦게 out = [(where.split()[0], path) for where, path in layers.layer_files("sangeun")] for company in _dirs(layers.storage_root(), digits=True): # glob 은 storage 를 다 훑어 느림 for user in _dirs(company, digits=True): for project in _dirs(user): folder = project / layers.TEMPLATES_DIRNAME / "sangeun" if folder.is_dir(): out += [("프로젝트", p) for p in sorted(folder.glob("[!._]*.json"))] return out def _dirs(folder: Path, digits: bool = False) -> list[Path]: try: return [ Path(e.path) for e in os.scandir(folder) if e.is_dir() and (e.name.isdigit() or not digits and not e.name.startswith(("_", "."))) ] except OSError: return [] def sk_record(sk: dict) -> dict[str, Any]: """SK 하나 → {키, 이름, 기계, 바탕, 덮음, 위덮음}.""" form = sk.get("수식") if isinstance(sk.get("수식"), dict) else {} machines = { str(row.get("키")) for part in PRICE_PARTS for row in (sk.get(part) or {}).get("단가") or [] if str(row.get("키") or "").startswith("EQ") } base = { str((sk.get("바탕") or {}).get("로직") or ""), str((form.get("원본") or {}).get("키") or ""), } base |= {str(k) for k in form.get("부름") or {}} for v in (form.get("문서") or {}).get("변수") or []: link = v.get("연결") or {} if link.get("갈래") == "단가산출" and link.get("키"): base.add(str(link["키"])) covers: dict[str, dict[str, list[str]]] = {} for name, route in COVERS.items(): node: Any = sk for step in route: node = node.get(step) if isinstance(node, dict) else None covers[name] = cover_of(node) return { "키": sk.get("키"), "이름": sk.get("이름"), "기계": sorted(machines), "바탕": sorted(base - {""}), **covers, } def sk_index() -> list[dict[str, Any]]: """[{층, 파일, 키, 이름, 기계, 바탕, 덮음, 위덮음}] — 자국이 같은 파일은 기억 그대로.""" from M02_MasterTemplete import M02_Template_Layers as layers root = layers.storage_root() with _LOCK: if _SK.get("root") != root: got = read_derived(root, KIND, f"sk{SHAPE}") _SK.update(root=root, files=dict((got or {}).get("value") or {})) files: dict[str, list] = _SK["files"] out, seen, dirty = [], set(), False for layer, path in _sk_files(): text, stamp = str(path), file_stamp(path) seen.add(text) hit = files.get(text) if not (isinstance(hit, list) and len(hit) == 2 and hit[0] == stamp): try: hit = [stamp, sk_record(json.loads(path.read_bytes()))] except (OSError, ValueError, AttributeError): hit = [stamp, None] files[text], dirty = hit, True if hit[1]: out.append({"층": layer, "파일": text, **hit[1]}) for text in [t for t in files if t not in seen]: del files[text] dirty = True if dirty: try: atomic_write_json( derived_dir(root, KIND) / f"sk{SHAPE}.json", {"key": f"sk{SHAPE}", "value": files}, ) except OSError: # 파생 저장본 — 못 써도 다음에 다시 셈 pass return out def layer_counts(rows: list[dict]) -> dict[str, int]: out = {"마스터": 0, "회사": 0, "개인": 0, "프로젝트": 0} for r in rows: out[r["층"]] = out.get(r["층"], 0) + 1 return out def sk_users(key: str, code: str, docs: set[str]) -> list[dict]: """그 기계를 쓰는 SK — 사본 단가에 키 · 덮음에 입력 글 · 바탕이 `docs` 에 듦.""" return [ r for r in sk_index() if key in r["기계"] or any(n in r.get(c) or {} for c in COVERS for n in (code, key)) or docs & set(r["바탕"]) ] # ── 쓰는 곳 ───────────────────────────────────────────────────────── def uses(key: str) -> dict[str, Any]: """M01 기계 상세 「쓰는 곳」 — {uses: 직접 기초 글, 직접, 기본, 사슬, 고침{기초, 단가산출}, 단가산출{층: 수}}.""" whole = store.loaded()[1] row = (whole.index.get("EQ") or {}).get(key) if row is None: raise store.StoreError(404, f"없는 기계 「{key}」") code = str(row.get("원문번호") or "") idx = doc_index() direct = idx["직접"].get(code, set()) default = idx["기본"].get(code, set()) docs = idx["docs"] reach = chain(direct, idx["부름"]) sks = sk_users(key, code, direct) return { "uses": [ f"기초 {k} {docs[k].get('이름') or ''}".strip() + (" · 기본" if k in default else "") for k in sorted(direct) ], "직접": len(direct), "기본": len(default), "사슬": len(reach - direct), "고침": { "기초": sum(1 for c in idx["덮음"].values() if code in c or key in c), "단가산출": sum(1 for r in sks if code in r["덮음"] or key in r["덮음"]), "위층": sum(1 for r in sks if code in r["위덮음"] or key in r["위덮음"]), }, "단가산출": layer_counts(sks), }