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:
@@ -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),
|
||||
}
|
||||
Reference in New Issue
Block a user