- 색인(M01_MasterData_Machine_Uses) — 기계 시간당 식 · 부품 문서(83 장 · GC000267 · 270 · 271 · 273 · 1202 …)는 직접 · 기본 · 사슬 씨앗에서 뺌 — 고르기 목록에 들었을 뿐 그 기계를 쓰는 단가산출 기초가 아님 · 그 식을 부르는 기초는 제 입력(박힘 · 고르기 목록 · 식 줄 · 만약 속 따옴표 원문번호)으로 셈 (전 = GC000273 손료만 식 · 기계 256 대 목록을 부르는 부착 줄 문서가 모든 목록 기계의 사슬로 부풀음) - 굴착기 0.2㎥ 직접 65 · 사슬 0 · 집게 0.2㎥ 24 · 0 · 크레인 10ton 102 · 0 · 브레이커 0.2㎥ 6 · 0 · 가격 +10 % 금액 바뀌는 기초 0.6㎥ 37 · 0.2㎥ 42 · 0.12㎥ 6(전 9 의 늘어난 하나 = GC001202 자신 · GC000267 · 271 · 1202 = 기본 기계 0.12㎥ 인 기계 식 문서라 뺌) - 시험 test_848_5 = 박은 수 대신 색인 수 = 독립 셈(변수 · 식 글 원문번호 · 부름 거슬러) · 기계 식 부름만으로는 안 셈 · test_821_2 쓰는 곳 = 기초 GC000087(GC000267 기계 식 문서 아님) — 뜻이 바뀌어 고침 - 독립 글 셈과 색인 직접 = 기계 원문번호 631 전부 같음 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
293 lines
13 KiB
Python
293 lines
13 KiB
Python
"""기계 쓰는 곳 색인(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}")
|
|
_QUOTED = re.compile(r"'([^']*)'")
|
|
_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])
|
|
else: # 식으로 고른 기계(`만약(…, '0201-0040', '0201-0020')`) — 고를 수 있는 것 = 직접
|
|
direct |= {codes[x] for x in _QUOTED.findall(t) if x in codes}
|
|
for line in doc.get("식") or []: # 부름 입력이 식 줄 기호(S_굴착기 = 만약(…))
|
|
direct |= {codes[x] for x in _QUOTED.findall(str(line.get("식") or "")) if x in codes}
|
|
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():
|
|
if is_tool(doc):
|
|
continue
|
|
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 is_tool(doc: dict) -> bool:
|
|
"""기계 식 문서 — 기계 시간당 식(결과 원/시간 · `EQ:{S_기계}`) · 부품 문서(기계경비식 · 작업량 틀 · 계수식)."""
|
|
return docmod.mcv.is_machine(doc) or bool((doc.get("부품") or {}).get("갈래"))
|
|
|
|
|
|
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),
|
|
}
|