auto: 2026-11-18 07:18 (ESD_LAPTOP)

This commit is contained in:
2026-11-18 07:18:07 +09:00
parent 5eb42dfbd0
commit 0e4f3604b8
13 changed files with 290 additions and 225 deletions
+17 -61
View File
@@ -398,7 +398,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
def summary(
folder: Path, kind: str, key: str, expand: Expand | None = None, files: UseFiles | None = None
folder: Path, kind: str, key: str, expand: Expand | None = None, files: list | None = None
) -> dict[str, Any]:
"""층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면
1 단위 기준 계(`기준금액` · 51-4)."""
@@ -422,14 +422,16 @@ def summary(
top, (layer, owner) = doc.get("바탕") or {}, where(folder)
logic = top.get("로직")
out["바탕"] = logic or (top.get("참조") or {}).get("키")
if logic and expand is not None:
try:
out["바탕"] = f"{logic} {expand.whole.logic(logic).get('이름') or ''}".strip()
except Exception: # noqa: BLE001 — 없는 로직 = 키만(셈 때 까닭)
pass
if logic and expand is not None: # 이름 = M01 수식 문서(로직 줄 안 읽음 · 855 L2 ⓑ)
from M01_MasterData import M01_MasterData_Doc as m01doc
name = (m01doc.docs().get(str(logic)) or {}).get("이름") or ""
out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭)
out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄"))
# SK 마다 모든 층 훑음(users) — 파일 읽기는 판 기억(`_ids_of`)이라 처음 한 번만 무거움
out["쓰는곳수"] = len(users({"층": layer, "주인": owner, "키": key}, files))
# SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움
from M02_MasterTemplete import M02_Library_Uses as uses
out["쓰는곳수"] = len(uses.users({"층": layer, "주인": owner, "키": key}, files))
return out
@@ -439,66 +441,20 @@ def summaries(folder: Path, rows: list[dict[str, Any]]) -> None:
from M02_MasterTemplete.M02_Labor_Expand import Expand
expand = Expand(m01.loaded()[1])
files = use_files() if any(row["종류"] == "sangeun" for row in rows) else None
from M02_MasterTemplete import M02_Library_Uses as uses
files = uses.files() if any(row["종류"] == "sangeun" for row in rows) else None
for row in rows:
if row["종류"] in layers.LIBRARY_KINDS:
row.update(summary(folder, row["종류"], row["이름"], expand, files))
# ── 쓰는 곳 · 지우기 ──────────────────────────────────────────────────
UseFiles = list[tuple[str, str, Path]]
def use_files() -> UseFiles:
"""쓰는 곳을 찾을 파일 — (무엇, 어디, 파일) · 목록 한 번에 한 번 찾음(818-1)."""
# 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」
kinds = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
return [(what, at, path) for kind, what in kinds for at, path in layers.layer_files(kind)]
def users(ref: Ref, files: UseFiles | None = None) -> list[str]:
"""`ref` 를 담은 일위대가 · 사전조합 · 단가산출(바탕 · 더한줄) — 「어디 이름」 목록(모든 층 훑음 ·
프로젝트 뺌)."""
rid, out = ref_id(ref), []
for what, at, path in use_files() if files is None else files:
got = _ids_of(path)
if got and rid in got[1]:
out.append(f"{what} {at} 「{got[0]}」")
return out
_IDS: dict[Path, tuple[tuple[int, int], tuple[str, frozenset[str]]]] = {}
def _ids_of(path: Path) -> tuple[str, frozenset[str]] | None:
"""파일 하나의 (이름, 참조 이름표들) — 판(고친 때 · 크기)이 같으면 기억한 것(818-1 · 로직 사본으로
SK 파일이 MB 단위라 목록 줄마다 모든 층을 다시 읽으면 분 단위)."""
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 path.stem
)
got = (str(name), frozenset(ref_id(one) for one in refs_in(doc)))
_IDS[path] = (stamp, got)
return got
def refuse_used(folder: Path, kind: str, key: str) -> None:
"""쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
if kind not in PREFIX:
return
layer, owner = where(folder)
found = users({"층": layer, "주인": owner, "키": key})
if found:
raise _bad(f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found), 409)
"""쓰는 곳이 있으면 409 — 쓰는 곳 색인 한 벌(`M02_Library_Uses` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as uses
uses.refuse_used(folder, kind, key)
# ── 층 사이 복사 ──────────────────────────────────────────────────────
+3 -1
View File
@@ -175,7 +175,9 @@ def own_materials(
return {"줄": []}
folder = _root(session, layer, owner)
rows = own.rows(folder)
used = own.usage(folder, [str(r.get("키")) for r in rows])
from M02_MasterTemplete import M02_Library_Uses as library_uses
used = library_uses.materials(folder, [str(r.get("키")) for r in rows])
return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]}
+5 -45
View File
@@ -6,9 +6,9 @@
요약 서고 줄 `M02_Labor_Ref.summary`(쓰는곳수 뺌) — 자국 · 바탕 · 기댐이 모두 같을 때만 씀
바탕 셈 코드 내용 · M01 폴더 · 층 곁 파일(내 기계 등 — 항목 폴더 · manifest 뺌) 자국 지문
기댐 셈 때 읽은 참조 파일(SC · SK) 자국(`refs.SEEN`)
쓰는곳수 = 요청마다 쓰는 곳 파일을 한 번 훑어 거꾸로 셈(`refs._ids_of` 기억 · 파일당 stat 한 번).
쓰는곳수 = 요청마다 쓰는 곳 색인을 한 번 훑어 거꾸로 셈(`M02_Library_Uses.counts` · 파일당 stat 한 번).
자리 = 프로세스 메모리 + storage `_derived/m02_layer_index/`(파생 저장본 · 층마다 한 파일 ·
참조 이름표 기억 `ids.json`) — 없거나 깨지면 다시 지음 · 지워도 됨 · 다른 PC · 옛 코드는 안 읽음.
참조 이름표 기억 `ids.json` 은 `M02_Library_Uses` 몫) — 없거나 깨지면 다시 지음 · 지워도 됨.
"""
from __future__ import annotations
@@ -28,11 +28,9 @@ from M02_MasterTemplete import M02_Template_Layers as layers
KIND = "m02_layer_index"
SHAPE = 1 # 기록 꼴이 바뀌면 올림(옛 기록 = 다시 셈)
IDS = "ids"
CODE_DIRS = ("M02_MasterTemplete", "M01_MasterData", "resources/master_data/scripts", "common_util")
_LOCK = threading.RLock()
_MEM: dict[str, dict[str, Any]] = {} # 층 열쇠 → {항목: 기록}
_IDS_LOADED: list[bool] = []
@lru_cache(maxsize=1)
@@ -175,47 +173,9 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None:
_save(key, recs)
sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row]
if sk:
uses, (layer, owner) = _uses(), refs.where(folder)
from M02_MasterTemplete import M02_Library_Uses as library_uses
uses, (layer, owner) = library_uses.counts(), refs.where(folder)
for row in sk:
rid = refs.ref_id({"층": layer, "주인": owner, "키": row["이름"]})
row["쓰는곳수"] = uses.get(rid, 0)
# ── 쓰는 곳 수 ────────────────────────────────────────────────────────
def _uses() -> dict[str, int]:
"""참조 이름표 → 담은 파일 수(`refs.users` 개수와 같음) — 쓰는 곳 파일 한 번 훑음."""
_load_ids()
before = {path: hit[0] for path, hit in refs._IDS.items()}
files = [path for _what, _at, path in refs.use_files()]
count: dict[str, int] = {}
for path in files:
got = refs._ids_of(path)
for rid in got[1] if got else ():
count[rid] = count.get(rid, 0) + 1
if any(before.get(path) != refs._IDS[path][0] for path in files if path in refs._IDS):
_save_ids()
return count
def _load_ids() -> None:
"""참조 이름표 기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 자국은 `_ids_of` 가 다시 봄."""
if _IDS_LOADED:
return
_IDS_LOADED.append(True)
got = read_derived(layers.storage_root(), KIND, IDS)
for text, one in ((got or {}).get("value") or {}).items():
try:
mtime, size, name, ids = one
refs._IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids))))
except (TypeError, ValueError):
continue
def _save_ids() -> None:
"""지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌."""
got = read_derived(layers.storage_root(), KIND, IDS)
value = dict((got or {}).get("value") or {})
for path, ((mtime, size), (name, ids)) in list(refs._IDS.items()):
value[str(path)] = [mtime, size, name, sorted(ids)]
value = {text: one for text, one in value.items() if Path(text).is_file()}
_save(IDS, value)
+35 -34
View File
@@ -25,12 +25,11 @@ from typing import Any
from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Library_Uses as uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MasterTemplete_Tree as tree
from M02_MasterTemplete import M02_Template_Layers as layers
GONE = "_합친것"
USER_KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
_ADD = re.compile(r"^add:#(\d+)(.*)$")
_PATCH = ("덮개", "고름", "자재표시")
@@ -66,42 +65,44 @@ def _columns(folder: Path, memo: dict[Path, dict[str, str]]) -> dict[str, str]:
def users(session: dict[str, Any] | None, kind: str, gone: list[str]) -> list[dict[str, Any]]:
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌)."""
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌) ·
쓰는 파일 = 쓰는 곳 색인(`M02_Library_Uses.index`)에 걸린 것만 열어 줄 자리를 셈."""
mine = refs.here()
rids = {refs.ref_id({"층": mine[0], "주인": mine[1], "키": k}): k for k in gone}
skip = {(store.root() / kind / f"{k}.json").resolve() for k in gone}
found = uses.index()
hit_files = {path for rid in rids for path, _k, _l in found.get(rid, [])}
rows, memo = [], {}
for ukind, what in USER_KINDS:
for where, path in layers.layer_files(ukind):
if path.resolve() in skip:
continue
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
hits = _hits(doc, rids) if isinstance(doc, dict) else []
if not hits:
continue
at = refs.where(path.parent.parent)
ok = can_write(session, at)
name = doc.get("일위대가번") or doc.get("이름") or path.stem
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
name = f"{title} · {name}"
for line, key in hits:
rows.append(
{
"층": at[0],
"주인": at[1],
"어디": where,
"종류": what,
"문서종류": ukind,
"문서": path.stem,
"이름": name,
"키": key,
"줄": line,
"쓰기": ok,
}
)
for ukind, what, where, path in uses.files():
if path not in hit_files or path.resolve() in skip:
continue
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
hits = _hits(doc, rids) if isinstance(doc, dict) else []
if not hits:
continue
at = refs.where(path.parent.parent)
ok = can_write(session, at)
name = doc.get("일위대가번") or doc.get("이름") or path.stem
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
name = f"{title} · {name}"
for line, key in hits:
rows.append(
{
"층": at[0],
"주인": at[1],
"어디": where,
"종류": what,
"문서종류": ukind,
"문서": path.stem,
"이름": name,
"키": key,
"줄": line,
"쓰기": ok,
}
)
return rows
+3 -19
View File
@@ -36,16 +36,15 @@ from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Library_Delete as deleting
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_Library_Uses as uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
from M02_MasterTemplete import M02_Template_Layers as layers
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _root
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Library Same"])
Kind = Literal["precombo", "sangeun"]
GONE = deleting.GONE
USER_KINDS = deleting.USER_KINDS
_ORDER = {"system": 0, "company": 1, "personal": 2}
@@ -89,21 +88,6 @@ def _docs(at: refs.Here, kind: str) -> list[tuple[str, dict[str, Any]]]:
# ── 쓰는 곳 ───────────────────────────────────────────────────────────
def _user_index() -> dict[str, list[tuple[Path, str, str]]]:
"""모든 층(프로젝트 뺌) 훑기 한 번 — {ref_id: [(파일, 종류, 「어디 이름」)]}."""
out: dict[str, list[tuple[Path, str, str]]] = {}
for kind, what in USER_KINDS:
for where, path in layers.layer_files(kind):
try:
doc = json.loads(path.read_bytes())
except (OSError, ValueError):
continue
name = doc.get("일위대가번") or doc.get("이름") or path.stem
for rid in {refs.ref_id(one) for one in refs.refs_in(doc)}:
out.setdefault(rid, []).append((path, kind, f"{what} {where} 「{name}」"))
return out
def _can_write(session: Session, at: refs.Here) -> bool:
return access.can_write(session, at)
@@ -177,7 +161,7 @@ def _gone_rows(folder: Path, kind: str) -> list[dict[str, Any]]:
def find(folder: Path, kind: str) -> dict[str, Any]:
"""이 층 + 위 층 같은 지문 묶음 — 이 층 문서가 든 묶음 · 둘 이상만."""
mine = refs.where(folder)
index = _user_index()
index = uses.index()
groups: dict[str, list[tuple[refs.Here, str, dict[str, Any]]]] = {}
marks = same.Same() # 한 요청 안 참조 지문 메모
for at in [mine, *same.above(mine)]:
@@ -235,7 +219,7 @@ def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[s
rids = {refs.ref_id(_ref(mine, k)): k for k in gone}
by_file: dict[Path, tuple[str, set[str]]] = {}
labels: dict[Path, str] = {}
index = _user_index()
index = uses.index()
for rid in rids:
for path, ukind, label in index.get(rid, []):
by_file.setdefault(path, (ukind, set()))[1].add(rid)
+185
View File
@@ -0,0 +1,185 @@
"""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])
+4 -29
View File
@@ -135,36 +135,11 @@ def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]
return got
def _aside(path: Path, folder: str | Path) -> bool:
"""밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님."""
return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])
def usage(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]:
"""그 층에서 키마다 쓰는 문서(단가산출 · 일위대가 …) {키: [{종류, 키, 이름}]} — 파일은 한 번씩 읽음."""
out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys}
for path in sorted(Path(folder).rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌
if path.name == FILE or _aside(path, folder):
continue
try:
text = path.read_text(encoding="utf-8")
except OSError:
continue
hit = [k for k in keys if k in text]
if not hit:
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 uses(folder: str | Path, key: str) -> list[dict[str, Any]]:
return usage(folder, [key])[key]
"""쓰는 문서 — 쓰는 곳 색인 한 벌(`M02_Library_Uses.materials` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as library_uses
return library_uses.materials(folder, [key])[key]
def remove(folder: str | Path, key: str) -> None:
+22 -27
View File
@@ -259,13 +259,26 @@ def hourly(row: dict, index: Any) -> dict[str, Any]:
key = logic_key(row)
if key is None:
return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"}
logic = index.logic(key)
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2)
got = mh.hour(row, logic, index)
got = mh.hour(row, _head(key), index)
return {"ok": got["ok"], **head, **got}
def _head(key: str) -> dict[str, Any]:
"""식 머리 {키, 입력} — M01 수식 문서에서(로직 줄 안 읽음 · 855 L2 ⓑ) · 입력 = 고르기 · 입력 변수
(옛 로직 줄 「입력」 과 1,521 문서 같음) · 문서 없음 = 빈 입력(`hour` 가 「식 문서 없음」)."""
from M01_MasterData import M01_MasterData_Doc as m01doc
doc = m01doc.docs().get(key) or {}
opens = [
{"이름": v.get("이름")}
for v in doc.get("변수") or []
if isinstance(v, dict) and (v.get("연결") or {}).get("갈래") in ("선택", "입력")
]
return {"키": key, "입력": opens}
# ── 검사 ──────────────────────────────────────────────────────────────
def _num(value: Any, name: str) -> float | None:
if value in (None, ""):
@@ -479,36 +492,18 @@ def delete(key: str) -> dict[str, Any]:
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
_user()
_old(key)
used = uses().get(key, [])
used = _uses().get(key, [])
with _LOCK:
_old(key)
(_dir() / f"{key}.json").unlink(missing_ok=True)
return {"지움": key, "쓰는곳": used}
def uses() -> dict[str, list[dict]]:
"""{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것."""
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
def _uses() -> dict[str, list[dict]]:
"""{내 기계 키: [{키, 이름}]} — 쓰는 곳 색인 한 벌(`M02_Library_Uses.machines` · 858 5-5)."""
from M02_MasterTemplete import M02_Library_Uses as library_uses
out: dict[str, list[dict]] = {}
for path in sorted((store.root() / sd.KIND).glob("SK-*.json")):
raw = path.read_bytes()
if 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 mine(row.get("키"))
}
for key in sorted(keys):
out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")})
return out
return library_uses.machines()
def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
@@ -542,12 +537,12 @@ def one(key: str) -> dict[str, Any]:
got = next((r for r in rows() if r["키"] == key), None)
if got is None:
raise _bad(f"없는 내 기계 「{key}」", 404)
return answer(got, uses().get(key, []))
return answer(got, _uses().get(key, []))
def listing() -> dict[str, Any]:
"""목록 — 줄마다 시간당 · 쓰는곳수(넣은 차례)."""
index, used = whole(), uses()
index, used = whole(), _uses()
return {
"줄": [
{**r, "시간당": hourly(engine(r), index), "쓰는곳수": len(used.get(r["키"], []))}
+2 -1
View File
@@ -21,6 +21,7 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_Library_Same_Router as same_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
@@ -112,7 +113,7 @@ def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world):
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
with store.at(me):
(me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움
assert refs.users({**MINE, "키": inner}) == []
assert library_uses.users({**MINE, "키": inner}) == []
store.delete("precombo", inner)
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로
+2 -1
View File
@@ -20,6 +20,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Store as hs
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as machine
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_Emit as em
@@ -142,7 +143,7 @@ def test_nested_stmate_follows_inner(world) -> None:
assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383
assert _money(doc) == 67383
assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK
assert refs.users(ref) # 쓰는 곳에 바깥 SK
assert library_uses.users(ref) # 쓰는 곳에 바깥 SK
with pytest.raises(store.StoreError) as why:
refs.refuse_used(folder, "sangeun", ref["키"])
assert why.value.status == 409
+5 -4
View File
@@ -11,6 +11,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
@@ -26,15 +27,15 @@ LIB = ("sangeun", "precombo", "labor")
def fresh(world, monkeypatch): # noqa: F811
"""색인 기억 비움 — 시험끼리 안 섞임."""
monkeypatch.setattr(index, "_MEM", {})
monkeypatch.setattr(index, "_IDS_LOADED", [])
monkeypatch.setattr(refs, "_IDS", {})
monkeypatch.setattr(library_uses, "_LOADED", [])
monkeypatch.setattr(library_uses, "_IDS", {})
return world
def _forget():
index._MEM.clear()
index._IDS_LOADED.clear()
refs._IDS.clear()
library_uses._LOADED.clear()
library_uses._IDS.clear()
def _sk(folder, name, extra=None):
@@ -18,6 +18,7 @@ from fastapi import HTTPException
from M02_MasterTemplete import M02_Doc_Router as doc_route
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as mh
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
@@ -104,7 +105,7 @@ def test_save_creates_links_and_stamps(world):
assert f"'개인 {key}'" in text
assert key in [r["키"] for r in saved["단가"]] # 사본에 박힘
assert after["셈"]["계"] == look["셈"]["계"] and after["사본"]["단가새값"] is False
assert _at(me, mym.uses)[key] == [{"키": sk, "이름": "sub1임시"}]
assert _at(me, library_uses.machines)[key] == [{"키": sk, "이름": "sub1임시"}]
def test_same_draft_two_lines(world):
+5 -2
View File
@@ -13,6 +13,7 @@ import pytest
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_labor_calc_mirror import _same, _ts
@@ -324,10 +325,12 @@ def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world):
ref = {**SYS, "키": sc}
with store.at(world["personal"]):
store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []})
assert len(refs.users(ref)) == 1 and refs.users(ref) == refs.users(ref, refs.use_files())
assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users(
ref, library_uses.files()
)
ver = store.read("labor", "x1")["판"]
store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []})
assert refs.users(ref) == []
assert library_uses.users(ref) == []
def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):