From 0e4f3604b8833868265e33123e3f6a2151e49f06 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:07 +0900 Subject: [PATCH] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- M02_MasterTemplete/M02_Labor_Ref.py | 78 ++------ M02_MasterTemplete/M02_Labor_Router.py | 4 +- M02_MasterTemplete/M02_Layer_Index.py | 50 +---- M02_MasterTemplete/M02_Library_Delete.py | 69 +++---- M02_MasterTemplete/M02_Library_Same_Router.py | 22 +-- M02_MasterTemplete/M02_Library_Uses.py | 185 ++++++++++++++++++ M02_MasterTemplete/M02_Material_Own.py | 33 +--- M02_MasterTemplete/M02_MyMachine.py | 49 +++-- resources/tester/test_740_1_library_flat.py | 3 +- resources/tester/test_797_1_import_links.py | 3 +- resources/tester/test_826_1_layer_index.py | 9 +- resources/tester/test_827_1_machine_window.py | 3 +- resources/tester/test_m02_labor_ref.py | 7 +- 13 files changed, 290 insertions(+), 225 deletions(-) create mode 100644 M02_MasterTemplete/M02_Library_Uses.py diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index ea15b79a5..468cb5b8f 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -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) # ── 층 사이 복사 ────────────────────────────────────────────────────── diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py index a1ea5e11f..2b8253dfc 100644 --- a/M02_MasterTemplete/M02_Labor_Router.py +++ b/M02_MasterTemplete/M02_Labor_Router.py @@ -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]} diff --git a/M02_MasterTemplete/M02_Layer_Index.py b/M02_MasterTemplete/M02_Layer_Index.py index 9203e5d68..00a04b1e9 100644 --- a/M02_MasterTemplete/M02_Layer_Index.py +++ b/M02_MasterTemplete/M02_Layer_Index.py @@ -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) diff --git a/M02_MasterTemplete/M02_Library_Delete.py b/M02_MasterTemplete/M02_Library_Delete.py index 47c2f7ccf..61329df94 100644 --- a/M02_MasterTemplete/M02_Library_Delete.py +++ b/M02_MasterTemplete/M02_Library_Delete.py @@ -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 diff --git a/M02_MasterTemplete/M02_Library_Same_Router.py b/M02_MasterTemplete/M02_Library_Same_Router.py index 0c4b89389..d17ee2a0f 100644 --- a/M02_MasterTemplete/M02_Library_Same_Router.py +++ b/M02_MasterTemplete/M02_Library_Same_Router.py @@ -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) diff --git a/M02_MasterTemplete/M02_Library_Uses.py b/M02_MasterTemplete/M02_Library_Uses.py new file mode 100644 index 000000000..f8b1ab3f8 --- /dev/null +++ b/M02_MasterTemplete/M02_Library_Uses.py @@ -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]) diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index 789962c58..c7cad14a8 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -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: diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index 9a5f2b25f..141e483b0 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -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["키"], []))} diff --git a/resources/tester/test_740_1_library_flat.py b/resources/tester/test_740_1_library_flat.py index 0e496cf7b..bbca3739f 100644 --- a/resources/tester/test_740_1_library_flat.py +++ b/resources/tester/test_740_1_library_flat.py @@ -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) # 원본 지워도 그대로 diff --git a/resources/tester/test_797_1_import_links.py b/resources/tester/test_797_1_import_links.py index 5215d62df..9c270f506 100644 --- a/resources/tester/test_797_1_import_links.py +++ b/resources/tester/test_797_1_import_links.py @@ -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 diff --git a/resources/tester/test_826_1_layer_index.py b/resources/tester/test_826_1_layer_index.py index 4953b8a38..66e1f7267 100644 --- a/resources/tester/test_826_1_layer_index.py +++ b/resources/tester/test_826_1_layer_index.py @@ -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): diff --git a/resources/tester/test_827_1_machine_window.py b/resources/tester/test_827_1_machine_window.py index 4532bd602..2b506ab56 100644 --- a/resources/tester/test_827_1_machine_window.py +++ b/resources/tester/test_827_1_machine_window.py @@ -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): diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py index ee77ac30f..c4ec1d66a 100644 --- a/resources/tester/test_m02_labor_ref.py +++ b/resources/tester/test_m02_labor_ref.py @@ -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):