feat(848-5): 기계 정본 저장 전 영향 확인창 · 쓰는 곳 = 수식 문서 기준 · [새 기계] 목록 두 벌 같이

- 쓰는 곳 색인(M01_MasterData_Machine_Uses) — 수식 문서 기계 고르기 목록 · 박힌 입력(집게 · 브레이커 포함) · EQ 요소 = 직접 · 기본 선택 · 부름 사슬 따로 · 655 대 조사 목록과 다름 0
- 단가산출 역색인 — 모든 층 + 프로젝트 사본 · 사본 단가 기계 · 바탕(원본 · 부름) · 덮음(② 내 고침 · ① 위덮음 848-1 계약) · 파일 자국 기억 · 파생 저장본(지워도 다시 지음)
- 영향 셈(M01_MasterData_Machine_Impact) — 저장과 같은 손질 뒤 고친 기계를 얹은 얕은 복사 마스터로 영향 기초만 전 · 후 셈 · 바뀐 기초 수 · 크게 바뀐 다섯 · 정본 기억 안 건드림
- M01 페이지 [저장] 전 확인창 · 기계 상세 쓰는 곳 표시 새 꼴 · 내 기계 [저장] 전 확인창(이 층 쓰는 단가산출 · 따로 고친 곳)
- [새 기계] 저장 = 로직 목록과 같은 더함 · 뺌을 수식 문서 기계 고르기 목록에도
- 옛 「쓰는 곳」(로직 JSON 입력 이름 「기계」 · 글자 찾기) 걷음
- 시험: test_848_5 새로 · test_821_2 · test_822_2 임시 폴더에 수식 문서도 복사(새 기계 저장이 문서 목록도 고쳐 정본 폴더에 쓰지 않게) · test_821_2 쓰는 곳 = 임시 storage

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:09:03 +09:00
co-authored by Claude Opus 5.5
parent c327c72a73
commit 59d20ae464
19 changed files with 1070 additions and 69 deletions
@@ -0,0 +1,279 @@
"""기계 쓰는 곳 색인(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),
}