From 0e4f3604b8833868265e33123e3f6a2151e49f06 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:07 +0900 Subject: [PATCH 1/9] 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): From 296ec60eecb8c7eca9e387c4a90f1c244f3854f7 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:10 +0900 Subject: [PATCH 2/9] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- B08_Quantity/B08_Quantity_Router_Material.py | 4 +- B09_Estimation/B09_Estimation_Bill_Library.py | 14 +- .../B09_Estimation_Daega_Personal.py | 135 +++++++++------- B09_Estimation/B09_Estimation_Doc_Run.py | 13 ++ B09_Estimation/B09_Estimation_Labor_Source.py | 9 +- B09_Estimation/B09_Estimation_Linked.py | 4 +- B09_Estimation/B09_Estimation_Sangeun.py | 17 +- M02_MasterTemplete/M02_Doc_B09.py | 24 +-- M02_MasterTemplete/M02_Doc_Copy.py | 17 +- M02_MasterTemplete/M02_Item_Bundle.py | 153 ++++++++++++++++++ M02_MasterTemplete/M02_Item_Prices.py | 3 +- M02_MasterTemplete/M02_Item_Snapshot.py | 8 +- M02_MasterTemplete/M02_Item_Source.py | 84 +++++----- resources/tester/test_145_1_b09_sangeun.py | 23 ++- resources/tester/test_145_2_b09_labor_calc.py | 7 +- resources/tester/test_719_2_sk_project.py | 21 +++ resources/tester/test_795_4_b09_copy.py | 27 ++-- resources/tester/test_802_4a_m02_doc.py | 5 +- resources/tester/test_841_1_b09_m02_values.py | 15 +- resources/tester/test_855_b09_golden.py | 9 +- resources/tester/test_item_copy_complete.py | 15 +- resources/tester/test_m02_item_labor.py | 5 +- .../test_structures_summary_snapshot.py | 6 +- 23 files changed, 439 insertions(+), 179 deletions(-) create mode 100644 M02_MasterTemplete/M02_Item_Bundle.py diff --git a/B08_Quantity/B08_Quantity_Router_Material.py b/B08_Quantity/B08_Quantity_Router_Material.py index 7f27fdd93..68631747b 100644 --- a/B08_Quantity/B08_Quantity_Router_Material.py +++ b/B08_Quantity/B08_Quantity_Router_Material.py @@ -123,11 +123,11 @@ def _folder_units(root: str | Path, folder: str, meta: dict[str, dict]) -> dict[ """사본 하나 = 집계 항목 1 단위의 자재 `{키: 수량}` — 일위대가 자재(키 = MT 코드) + 로직 재료 (키 = 고른 품목 MT 코드 · 없으면 이름|단위 · 재료 수량 × 줄 수량 ÷ 배) + 참조 줄 안 재료 (160-3) · 줄 수량 빈칸 · 0 · 파형강관 · 기계 연료는 안 담음 · 셈 못 하면 빈 것.""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Item_Copy as copies from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete.M02_Doc_B09 import FILE as FORMULA_FILE - from M02_MasterTemplete.M02_Item_Prices import load_prices from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, PRICE_FILE, read_json try: @@ -176,7 +176,7 @@ def _folder_units(root: str | Path, folder: str, meta: dict[str, dict]) -> dict[ if qty is None: continue if isinstance(line.get("참조"), dict): # 참조 줄 = 배 1 - whole = load_prices(bundle) if whole is None else whole + whole = item_bundle.load(bundle, docs) if whole is None else whole for mat, per in _ref_mats(whole, read, line["참조"], given=given, docs=docs): logic_mat(mat, per * qty) continue diff --git a/B09_Estimation/B09_Estimation_Bill_Library.py b/B09_Estimation/B09_Estimation_Bill_Library.py index f8c89b2a9..2a14b4436 100644 --- a/B09_Estimation/B09_Estimation_Bill_Library.py +++ b/B09_Estimation/B09_Estimation_Bill_Library.py @@ -97,17 +97,15 @@ def _precombo_files(layer: str, owner: str | None, key: str, kind: str = "precom raise LookupError(f"{refs.TITLE[kind]} {key} 이 {layer} 층에 없음") line = {"참조": ref, "수량": {"손": 1}} labor = labor_doc_rows({"이름": doc.get("이름"), "단위": doc.get("단위"), "담은로직": [line]}) - return { - LABOR_FILE: labor, - PRICE_FILE: price_bundle(labor, refs.folder_of(layer, owner)), - "_원본": {"참조": ref, "name": doc.get("이름") or key, "단위": doc.get("단위") or ""}, - } + files = {LABOR_FILE: labor, PRICE_FILE: price_bundle(labor, refs.folder_of(layer, owner))} + origin = {"참조": ref, "name": doc.get("이름") or key, "단위": doc.get("단위") or ""} + return {**doc_b09.attach(files), "_원본": origin} # 수식 문서 사본 = 로직 몫(855-F B9-6) def source_version(files: dict[str, Any]) -> str: - """서고 사본 원본판(719-1) = 일위대가.json 지문 — 굳힌 SC · SK 문서(SK = 수식 사본) · - 단가는 뺌(단가 바뀜은 [업데이트] 단가 굳힘 몫) · 값 덮기 전에 셈.""" - return version_of(files.get(LABOR_FILE)) + """서고 사본 원본판(719-1) = 일위대가.json + 수식 문서(로직 몫 · 855-F B9-6) 지문 — 굳힌 SC · SK + 문서(SK = 수식 사본) · 단가는 뺌(단가 바뀜은 [단가 갱신] 몫) · 값 덮기 전에 셈.""" + return version_of([files.get(LABOR_FILE), (files.get(doc_b09.FILE) or {}).get("문서")]) def _build(kind: str, layer: str, owner: str | None, key: str) -> tuple[dict, dict]: diff --git a/B09_Estimation/B09_Estimation_Daega_Personal.py b/B09_Estimation/B09_Estimation_Daega_Personal.py index 9495f7dad..68a4641e9 100644 --- a/B09_Estimation/B09_Estimation_Daega_Personal.py +++ b/B09_Estimation/B09_Estimation_Daega_Personal.py @@ -10,10 +10,9 @@ 복사본 `K:`(703-2) = 원본까지 따라감(이름 · 덮개 = 복사본 것) 같은 이름 = 409 `{같은이름: 키, 이름}` → 부르는 쪽이 덮어쓰기(`overwrite` = 그 키) · 새 이름 · 쓰기 = 지금 층(`store.at` · 층 권한 · 폴더는 부르는 쪽). -품셈 블록(`P:` · 굳힌 SK 포함 · 719-2) = 개인 층 단가산출(SK · `sangeun`) — 바탕 = 그 M01 로직 · -원본 SK 문서(바탕 · 덮개 · 더한줄 · 뺀줄) · 넣을 값 · 고른 자재(cid) · B09 품 · 단가 덮개 = -SK 덮개(같은 cid · 굳힌 SK = `정체` 로 원본 cid · 더한줄 줄 = 그 더한줄 수량 · 단가) · -못 옮긴 칸 = 안담음 수 · +품셈 블록(`P:` · 사본 SK 포함 · 719-2) = 개인 층 단가산출(SK · `sangeun` · 855-F B9-6 수식 문서) — +바탕 = 그 M01 로직(넣을 값 · 켜쌓기율) · 사본 SK = 그 칸 + 수식 사본 문서 · B09 품 · 단가 덮개 · +고른 재료 = 수식 문서 금액 줄 고침(따로 · 옛 칸 덮개 안 씀) · 못 옮긴 칸 = 안담음 수 · 내 자료집 SK 불러오기 = B09 서고 사본 `sangeun`(`Bill_Library`). 불러온 공사 일위대가(707-7 · 참조 층 `project`) = 하위 호표 굳힌 문서를 문서 `_하위` 에 실어 보내고 쓸 때 지금 층에 같이 씀(새 키 · `본뜬.복사원본` = 그 참조 · 같은 하위는 한 번만 · @@ -43,7 +42,7 @@ from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, PRICE_FILE, read_json KIND = "precombo" SK_KIND = "sangeun" -SK_KEEP = ("바탕", "입력값", "열린입력", "켜쌓기율", "고름", "자재표시", "덮개", "더한줄", "뺀줄") +SK_KEEP = ("바탕", "입력값", "켜쌓기율", "환산", "가져온") # 사본 SK 에서 옮기는 칸(수식 = 고침) SUBS = "_하위" PRICE_KEYS = ("labor", "material", "expense") @@ -53,9 +52,11 @@ def _combo(folder: Path) -> tuple[list[dict], list[dict]]: labor = read_json(folder / LABOR_FILE) or {} values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} - got = item_prices.calc( - labor, read_json(folder / PRICE_FILE) or {}, values, picks, read_json(folder / AREA_FILE) - ) + prices = read_json(folder / PRICE_FILE) or {} + formula = read_json( + folder / "수식.json" + ) # 사본 수식 문서(855-F B9-6 · 단가.json 에 로직 줄 없음) + got = item_prices.calc(labor, prices, values, picks, read_json(folder / AREA_FILE), formula) doc = item_prices.with_values(labor.get("줄") or {}, values, picks) lines = [ {**one, "수량": {"손": done.get("수량")}} @@ -176,67 +177,81 @@ def build(root: Path, cover_key: str, cover: dict[str, Any], name: str | None = def _sangeun(root: Path, block: dict, mine: dict, name: str | None) -> dict[str, Any]: - """품셈 블록 → 개인 층 SK 문서 `{문서, 담음, 안담음}` — 블록 줄 차례 = 엔진 줄 차례 = - cid 차례.""" - from M01_MasterData import M01_MasterData_Store as m01 + """품셈 블록 → 개인 층 SK 문서 `{문서, 담음, 안담음}`(855-F B9-6 · 수식 문서 꼴) — 바탕 = 그 M01 + 로직(입력값 · 켜쌓기율) · 사본 SK 블록 = 그 SK 칸 + 수식 사본 문서 · 블록 줄 차례 = 문서 금액 줄 + 차례 → B09 품 · 단가 덮개 = 그 금액 줄 수량 · 단가 글(한 비목 줄만) · 고른 재료 = 줄 규칙 · + 고친 것은 쓴 뒤 수식 길로 저장(`write` · `_수식`) · 못 옮긴 칸 = 안담음 수.""" + from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Sangeun_Doc as sd origin = block.get("origin") or {} rid = origin.get("단가산출") - if rid: # 굳힌 SK = 원본 문서 위에 · cid = 정체(굳힌 줄 차례 → 원본 cid) + fix: dict[str, Any] = {"줄": {}} + if rid: # 사본 SK = 그 칸 + 수식 사본 문서(855-F B9-5) frozen = _frozen(root, rid) - if frozen is None or not isinstance(frozen.get("원본"), dict): + if frozen is None or not isinstance((frozen.get("수식") or {}).get("문서"), dict): raise LookupError(f"단가산출 원천을 못 찾음 「{rid}」") - doc = {k: copy.deepcopy(frozen["원본"][k]) for k in SK_KEEP if k in frozen["원본"]} - ids = list(frozen.get("정체") or []) - unit = str(frozen["원본"].get("단위") or "") - else: # M01 로직 한 줄 = 바탕 · 고름 차례 → cid - try: - row = m01.loaded()[1].logic(str(origin.get("로직"))) - except Exception as e: # noqa: BLE001 — 엔진 FormulaError - raise LookupError(f"로직을 못 찾음 「{origin.get('로직')}」") from e - ids, unit = sd.line_ids(row), sg._unit(row)[0] - chosen = (origin.get("고름") or {}).items() - picks = {ids[int(n)]: mt for n, mt in chosen if int(n) < len(ids)} - doc = {"바탕": {"로직": origin.get("로직")}, "입력값": dict(origin.get("입력값") or {})} - doc |= {"고름": picks} if picks else {} + doc = {k: copy.deepcopy(frozen[k]) for k in SK_KEEP if k in frozen} + fix["문서"] = copy.deepcopy(frozen["수식"]["문서"]) + unit = str(frozen.get("단위") or "") + else: # M01 로직 한 줄 = 바탕 · 넣을 값 · 켜쌓기율 · 고른 재료(줄 차례) = 줄 규칙 + code = str(origin.get("로직") or "") + live = dc.folder().get(code) + if live is None: + raise LookupError(f"로직을 못 찾음 「{code}」") + unit = sg._unit({"결과단위": live.get("결과단위")})[0] + doc = {"바탕": {"로직": code}, "입력값": dict(origin.get("입력값") or {})} if origin.get("켜쌓기율") is not None: doc["켜쌓기율"] = origin["켜쌓기율"] - covers, added = doc.setdefault("덮개", {}), doc.setdefault("더한줄", []) + if origin.get("고름"): + fix["고름"] = {str(n): mt for n, mt in origin["고름"].items()} kept, skip = {"품": 0, "단가": 0}, {"품": 0, "단가": 0} for n, line in enumerate(block["lines"]): cell = {k: v for k, v in (mine.get(line.get("cid")) or {}).items() if k in COVER_KEYS} - cid = ids[n] if n < len(ids) else "" if not cell: continue - if cid.startswith("add:#"): # 더한줄 = 그 줄 수량 · 단가(한 비목 줄만) - one = added[int(cid[5:])] - if "qty" in cell: - one["수량"], kept["품"] = cell["qty"], kept["품"] + 1 - prices = [cell[k] for k in PRICE_KEYS if k in cell] - ok = len(prices) == 1 and "참조" not in one and "고정" not in one - if ok: - one["단가"], kept["단가"] = prices[0], kept["단가"] + 1 - skip["단가"] += len(prices) - (1 if ok else 0) - continue - if not cid or ("qty" in cell and doc.get("열린입력")): # 열어 둔 SK = 품 배율만 - skip["품"] += "qty" in cell - cell.pop("qty", None) - if not cell: - continue - if not cid: - skip["단가"] += len(cell) - continue - was = {k: v for k, v in (covers.get(cid) or {}).items() if k != "원값"} + one: dict[str, Any] = {} if "qty" in cell: - was.pop("배율", None) - covers[cid] = {**was, **cell} - kept["품"] += "qty" in cell - kept["단가"] += sum(k in cell for k in PRICE_KEYS) - if not covers: - doc.pop("덮개") + one["수량"], kept["품"] = cell["qty"], kept["품"] + 1 + prices = [cell[k] for k in PRICE_KEYS if k in cell] + if len(prices) == 1 and line.get("kind") in ("labor", "material", "fixed"): + one["단가"], kept["단가"] = prices[0], kept["단가"] + 1 + else: + skip["단가"] += len(prices) + if one: + fix["줄"][str(n)] = one head = {"종류": sd.TITLE, "이름": (name or block.get("name") or "").strip(), "단위": unit} - return {"문서": {**head, **doc}, "담음": kept, "안담음": skip} + head["더한줄"] = [] # SK 양식 뼈대(빈 목록 · 옛 칸 값 없음) + has_fix = fix["줄"] or fix.get("문서") or fix.get("고름") + made = {**head, **doc, **({FIX: fix} if has_fix else {})} + return {"문서": made, "담음": kept, "안담음": skip} + + +FIX = "_수식" # 쓴 뒤 수식 길로 저장할 고침(`write` 가 뗌) + + +def _num_text(value: Any) -> str: + from decimal import Decimal + + return format(Decimal(str(value)).normalize(), "f") + + +def _apply(key: str, fix: dict[str, Any]) -> None: + """새 SK 에 고침 — 문서(사본 SK 수식 문서 · 없으면 쓴 SK 문서) · 고른 재료 = 줄 규칙 · 줄 수량 · + 단가 글 → 수식 길 저장(`M02_Doc_Sk_Path.save` · 따로).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path + + read = sk_path.read(key) + base = copy.deepcopy(fix.get("문서") or read["문서"]) + base = {**base, "키": read["문서"].get("키", base.get("키"))} + if fix.get("고름"): + base = dc.line_doc(base, None, {int(n): mt for n, mt in fix["고름"].items()}) + for n, one in (fix.get("줄") or {}).items(): + lines = base.get("금액") or [] + if int(n) < len(lines): + lines[int(n)].update({k: _num_text(v) for k, v in one.items()}) + sk_path.save(key, {"문서": base, "판": read["판"]}) def _own(lines: Any) -> list[dict[str, Any]]: @@ -317,8 +332,8 @@ def write( """지금 층(`store.at` 안)에 씀 — 같은 이름이면 409 · `overwrite` = 같은 이름 그 키를 덮음 · 같은 내용(733-2) = 409 `{같은것, 까닭}`(같은 이름도 있으면 `같은이름 · 이름` 함께) → `new` 그래도 새로 · `use` 그 키(새로 안 만듦 · 답 `씀`).""" - subs = doc.get(SUBS) or {} - doc = {k: v for k, v in doc.items() if k != SUBS} + subs, fix = doc.get(SUBS) or {}, doc.get(FIX) + doc = {k: v for k, v in doc.items() if k not in (SUBS, FIX)} kind = SK_KIND if doc.get("종류") == refs.TITLE[SK_KIND] else KIND same = [ path.stem @@ -341,5 +356,9 @@ def write( doc = {**doc, "담은로직": _carry(doc["담은로직"], subs, {})} if overwrite: old = store.read(kind, overwrite) - return store.write(kind, overwrite, old["판"], {**doc, "키": overwrite}) - return refs.create(kind, doc) + got = store.write(kind, overwrite, old["판"], {**doc, "키": overwrite}) + else: + got = refs.create(kind, doc) + if fix: # 855-F B9-6 — SK 고침 = 수식 문서(옛 칸 덮개 안 씀) + _apply(str(got.get("이름") or overwrite), fix) + return got diff --git a/B09_Estimation/B09_Estimation_Doc_Run.py b/B09_Estimation/B09_Estimation_Doc_Run.py index e75b4a36e..a299aae80 100644 --- a/B09_Estimation/B09_Estimation_Doc_Run.py +++ b/B09_Estimation/B09_Estimation_Doc_Run.py @@ -315,6 +315,13 @@ def _shown(doc: dict, shown: dict[str, int]) -> dict: return doc +def load(bundle: dict[str, Any], docs: dict[str, dict]) -> Any: + """사본 셈 색인 = 단가 묶음 + 문서 이름표(`M02_Item_Bundle.load` · 855-F B9-6).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + return item_bundle.load(bundle, docs) + + class Shelf: """값 색인(`whole`) → 문서 묶음 — 같은 색인 = 같은 묶음(사본 `수식.json` · 없으면 셈 때 그 자리).""" @@ -325,6 +332,12 @@ class Shelf: self._got.append((whole, docs)) return docs + def put_whole(self, bundle: dict[str, Any], docs: dict[str, dict]) -> Any: + """단가 묶음 + 문서 → 셈 색인(`load`)을 짓고 그 문서 묶음을 둠 — 색인.""" + whole = load(bundle, docs) + self.put(whole, docs) + return whole + def of(self, whole: Any) -> dict[str, dict]: got = next((d for w, d in self._got if w is whole), None) return self.put(whole, {}) if got is None else got diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py index b547f173a..09fbbc388 100644 --- a/B09_Estimation/B09_Estimation_Labor_Source.py +++ b/B09_Estimation/B09_Estimation_Labor_Source.py @@ -432,8 +432,8 @@ class Builder: prices = bundle(folder) # 841-1 미리 보기 덮개 values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} - whole = item_prices.load_prices(prices) - docs = self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + docs = dr.docs_of(folder) # 사본 수식 문서(855-F B9-3) + whole = self.shelf.put_whole(prices, docs) # 색인 = 단가 묶음 + 문서 이름표(B9-6) area = read_json(folder / AREA_FILE) result = item_prices.calc(labor, prices, values, picks, area, {"문서": docs}) use = (labor_doc.area_values(area), cover or f"S:{folder.name}") # SC 안 줄 알약(723-4) @@ -488,8 +488,9 @@ class Builder: doc = copies.get(refs.ref_id(ref)) if isinstance(ref, dict) else None if not isinstance(doc, dict): return None - whole = item_prices.load_prices(bundle(folder)) - self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + whole = self.shelf.put_whole( + bundle(folder), dr.docs_of(folder) + ) # 사본 수식 문서(B9-3 · B9-6) if manifest["종류"] == "sangeun": # 내 자료집 단가산출(719-2) return self.sangeun(whole, ref, doc, copies, 1) return self.precombo(whole, ref, doc, copies, 1) diff --git a/B09_Estimation/B09_Estimation_Linked.py b/B09_Estimation/B09_Estimation_Linked.py index 755df9188..fc26d152c 100644 --- a/B09_Estimation/B09_Estimation_Linked.py +++ b/B09_Estimation/B09_Estimation_Linked.py @@ -39,11 +39,11 @@ def used_keys(folder: Path) -> list[str]: labor = read_json(folder / LABOR_FILE) if not isinstance(labor, dict): return [] - snapshot = item_prices.load_prices(bundle(folder)) + docs = dr.docs_of(folder) # 사본 수식 문서 — 셈 기록의 자원 키(855-F B9-3) + snapshot = dr.load(bundle(folder), docs) values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} seen: list[str] = [] - docs = dr.docs_of(folder) # 사본 수식 문서 — 셈 기록의 자원 키(855-F B9-3) # 사본 셈 한 벌(142-1)과 같은 길 — 빈 입력 = 자동값 · 켜쌓기율 · 고름 · # 굳힌 참조사본 안 로직까지 doc = item_prices.with_values(labor.get("줄") or {}, values, picks) diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py index 1544dbb57..f4b252da2 100644 --- a/B09_Estimation/B09_Estimation_Sangeun.py +++ b/B09_Estimation/B09_Estimation_Sangeun.py @@ -113,9 +113,9 @@ def rows_of(folder: Path, whole: Any = None, docs: dict | None = None) -> list[d labor = read_json(folder / LABOR_FILE) if not isinstance(labor, dict): return [] - if whole is None: - whole = item_prices.load_prices(bundle(folder)) docs = dr.docs_of(folder) if docs is None else docs + if whole is None: + whole = dr.load(bundle(folder), docs) values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} copies = labor.get("참조사본") or {} @@ -515,9 +515,14 @@ def hand_sources(user: dict[str, Any] | None) -> list[tuple[str, str, dict[str, def hand_whole(hands: list[tuple[str, str, dict[str, Any]]]) -> Any: - """손 줄 로직의 닫힌 단가 묶음(사본 `단가.json` 꼴 · 마스터 캐시는 안 건드림).""" + """손 줄 로직의 닫힌 묶음 — 지금 M01 수식 문서 + 그 문서가 잇는 자원 · 표 줄(사본 꼴 · 855-F B9-6 · + 마스터 캐시는 안 건드림).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + codes = list(dict.fromkeys(src["code"] for _k, _u, src in hands)) - return item_prices.load_prices(item_prices.to_json(item_prices.collect(codes))) + docs = dc.closure(item_prices.master()[1], codes) + return dr.load(item_prices.to_json(item_bundle.collect(docs)), docs) def hand_resource_keys(user: dict[str, Any] | None) -> list[str]: @@ -552,8 +557,8 @@ def collect( return copy.deepcopy(memo["sg"]) solver = Solver(supply) for owner, folder in entries: - whole = item_prices.load_prices(bundle(folder)) - docs = solver.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + docs = dr.docs_of(folder) # 사본 수식 문서(855-F B9-3) + whole = solver.shelf.put_whole(bundle(folder), docs) for src in rows_of(folder, whole, docs): solver.add(whole, src, owner) hand_keys: dict[str, str] = {} diff --git a/M02_MasterTemplete/M02_Doc_B09.py b/M02_MasterTemplete/M02_Doc_B09.py index 3143da594..ad2c067eb 100644 --- a/M02_MasterTemplete/M02_Doc_B09.py +++ b/M02_MasterTemplete/M02_Doc_B09.py @@ -13,35 +13,17 @@ from __future__ import annotations from typing import Any -from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Sk as dsk FILE = "수식.json" GROUP = "수식문서" -def logic_keys(bundle: dict[str, Any]) -> list[str]: - """단가 묶음의 로직 줄 키(그룹 「로직」 파일).""" - return [ - str(row.get("키")) - for data in bundle.values() - if isinstance(data, dict) and data.get("그룹") == "로직" - for row in data.get("줄") or [] - if isinstance(row, dict) and row.get("키") - ] - - def build(bundle: dict[str, Any], labor: dict[str, Any] | None = None) -> dict[str, Any]: - """`단가.json` 묶음 → `수식.json` 내용.""" - from M02_MasterTemplete import M02_Item_Prices as prices + """사본 일위대가 → `수식.json` 내용(`M02_Item_Source.formula_docs` · 단가 묶음 = 안 읽음).""" + from M02_MasterTemplete import M02_Item_Source as source - keys = logic_keys(bundle) - if not keys: - return {"그룹": GROUP, "문서": {}} - doc = (labor or {}).get("줄") or {} - have = (doc.get(dc.KEY) or {}).get("부름") if dc.has(doc) else None - whole = prices.load_prices(bundle) - return dsk.norm({"그룹": GROUP, "문서": dc.closure(whole, keys, have)}) + return dsk.norm({"그룹": GROUP, "문서": source.formula_docs(labor)}) def attach(files: dict[str, Any]) -> dict[str, Any]: diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index b053f1112..3f4b861f3 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -96,8 +96,23 @@ def _live(key: str) -> Any: return whole.index.get(key[:2], {}).get(key) +def _carried(whole: Any, key: str) -> dict | None: + """색인이 실어 온 문서(사본 셈 색인 `M02_Item_Bundle.Index.docs` · 감싼 색인 안쪽까지).""" + for _ in range(8): + own = vars(whole) if hasattr(whole, "__dict__") else {} + if key in (own.get("docs") or {}): + return own["docs"][key] + whole = own.get("_whole") + if whole is None: + return None + return None + + def doc_of(whole: Any, key: str) -> dict | None: - """키 하나의 문서 — 값 사본 줄 = 지금 M01 줄이면 M01 문서 · 다르면 그 줄 변환 · 없으면 None.""" + """키 하나의 문서 — 색인이 실어 온 사본 문서 › 값 사본 줄 = 지금 M01 줄이면 M01 문서 · 다르면 그 줄 + 변환 · 없으면 None.""" + if (got := _carried(whole, str(key))) is not None: + return cp.deepcopy(got) try: row = whole.logic(key) except _ERR: diff --git a/M02_MasterTemplete/M02_Item_Bundle.py b/M02_MasterTemplete/M02_Item_Bundle.py new file mode 100644 index 000000000..2bd426671 --- /dev/null +++ b/M02_MasterTemplete/M02_Item_Bundle.py @@ -0,0 +1,153 @@ +"""프로젝트 사본 단가 묶음(`단가.json`) — 수식 문서 묶음이 잇는 자원 · 표 줄만(PLAN 855-F B9-6). + +사본 = `수식.json`(셈 정본 · 닫힌 문서 묶음) + `단가.json`(자원 · 표 줄 — [단가 갱신] 이 바꾸는 자리) · +M01 로직 줄은 사본에 안 실음. 모으기 = 문서 변수 연결을 훑음(옛 로직 줄 식 글 훑기 대신): + 표 = 그 표 · 요소 키 = 그 줄(`{변수}` 틀 구멍 = 그 변수 고르기 목록으로 끼움 · 못 끼우면 그 + 테이블 전부 · 자재품목 뺌) · 재료 조건 = 후보 줄(구멍 = 목록 · 못 끼우면 구멍 칸 뺀 조건 · + 지역 · 계약종별 「입력」 = 넓게) · 준용 · 연결 줄도(`M02_Item_Prices._Collector.add`). +셈 색인(`load`) = 묶음 색인 + 문서 이름표 — `logic(키)` = 문서의 이름 · 결과단위 · 입력 이름(SK 배 · +B09 줄 꼴이 읽음 · 로직 줄 셈 칸 없음) · `docs` = 그 문서 묶음(`M02_Doc_Copy.doc_of` 가 먼저 읽음). +""" + +from __future__ import annotations + +import re +from typing import Any + +import master_doc as md # noqa: E402 — scripts 길 = prices(m01) + +from M02_MasterTemplete import M02_Item_Prices as prices + +_HOLE = re.compile(r"\{([^{}]+)\}") + + +def _options(ids: dict, hole: str) -> list | None: + opts = ((ids.get(hole) or {}).get("연결") or {}).get("목록") + return [str(x).strip("'") for x in opts] if opts else None + + +class _Docs(prices._Collector): + """수식 문서가 잇는 자원 · 표 줄 키 모음.""" + + def doc(self, doc: dict) -> None: + ids = {md.var_id(v): v for v in doc.get("변수") or []} + for v in ids.values(): + link = v.get("연결") or {} + if link.get("갈래") == "표" and link.get("표"): + self.add(str(link["표"])) + elif link.get("갈래") == "요소" and isinstance(link.get("재료"), dict): + self.cond(link["재료"], link.get("단위"), ids) + elif link.get("갈래") == "요소" and link.get("키"): + for ref in self.fill(str(link["키"]), ids): + self.add(ref) + + def fill(self, text: str, ids: dict) -> list[str]: + """틀 글 `{변수}` 구멍 → 고르기 목록으로 끼운 글들 · 목록 없는 구멍 = 그 테이블 전부(빈 목록).""" + out = [text] + for hole in sorted(set(_HOLE.findall(text))): + opts = _options(ids, hole) + if opts is None: + tid = prices.mk.id_of(text) + if tid and tid not in prices._TOO_BIG: + self.keys.update(self.whole.index.get(tid, {})) + return [] + out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts] + return out + + def cond(self, cond: dict, unit: Any, ids: dict) -> None: + if cond.get("지역") == "입력" or cond.get("계약종별") == "입력": + self.widely(cond, unit) + return + variants = [cond] + holes = {h for v in cond.values() if isinstance(v, str) for h in _HOLE.findall(v)} + for hole in sorted(holes): + opts = _options(ids, hole) + if opts is None: + variants = [prices.mm.static(cond)] + break + variants = [ + { + k: v.replace(f"{{{hole}}}", x) if isinstance(v, str) else v + for k, v in one.items() + } + for one in variants + for x in opts + ] + for one in variants: + if one.get("대표"): + self.add(str(one["대표"])) + if one.get("구분") or one.get("검색어"): + for key in prices._candidates(self.whole, one): + self.add(key) + + +def collect( + docs: dict[str, dict], materials: list[str] | None = None, over: list[dict] | None = None +) -> dict[str, Any]: + """문서 묶음 `docs` 가 잇는 자원 · 표 줄 + 자재(MT)의 닫힌 단가 묶음 — 로직 줄 없음 · + `over` = M02 값 사본 줄(795-4 · 같은 키는 M01 줄 대신 · M01 에 없는 키 = `COPY_FILE`).""" + from M02_MasterTemplete import M02_Material_Own as mat + + files, whole = prices.master() + whole = mat.whole(prices.mym.whole(whole)) # 지금 층 내 기계(821-1) · 내 재료(840-4) + own = {str(r.get("키")): r for r in (*prices.mym.added(whole), *mat.added(whole))} + mine = {str(r.get("키")): r for r in over or [] if "호표" not in r and "흐름" not in r} + if mine: + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + whole = skc.Copy(whole, skc._rows({"로직": list(mine.values())})) + got = _Docs(whole) + for doc in docs.values(): + got.doc(doc) + for code in materials or []: + got.add(code) + out: dict[str, Any] = {} + seen: set[str] = set() + for name, data in files.items(): + if data.get("그룹") == "로직": + continue + slot = prices.m01.items_key(data) + rows = [ + mine.get(str(row.get("키")), row) + for row in data.get(slot) or [] + if str(row.get("키")) in got.keys + ] + seen.update(str(row.get("키")) for row in rows) + if rows: + out[name] = {**{k: v for k, v in data.items() if k != slot}, slot: rows} + left = [r for k, r in {**own, **mine}.items() if k in got.keys and k not in seen] + if left: + out[prices.COPY_FILE] = {"그룹": "사본", "줄": left} + if got.missing: + out["_빠진"] = sorted(set(got.missing)) + return out + + +class Index: + """사본 셈 색인 — 단가 묶음 색인 위 문서 이름표(`logic`) · 문서 묶음(`docs`) · 그 밖 그대로.""" + + def __init__(self, whole: Any, docs: dict[str, dict]) -> None: + self._whole, self.docs = whole, docs + + def logic(self, key: str) -> dict: + doc = self.docs.get(str(key)) + if doc is None: + return self._whole.logic(key) + names = prices.doc_inputs(doc) + row = {k: doc.get(k) for k in ("키", "이름", "결과단위", "출처")} + return {**row, "입력": [{"이름": n} for n in names], "호표": [], "중간": [], "덧줄": []} + + def __getattr__(self, name: str) -> Any: + return getattr(self._whole, name) + + def __setattr__(self, name: str, value: Any) -> None: + if name in ("_whole", "docs"): + object.__setattr__(self, name, value) + else: + setattr(self._whole, name, value) + + +def load(bundle: dict[str, Any], docs: dict[str, dict] | None) -> Any: + """`단가.json` + 문서 묶음 → 사본 셈 색인(문서 없음 = 묶음 색인 그대로).""" + whole = prices.load_prices(bundle) + return Index(whole, docs) if docs else whole diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 83bd69728..263c05b4e 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -452,11 +452,12 @@ def calc( (`formula`) 문서 셈(`line` · 855-F B9-2) · 단가 = 사본 `단가.json` · 참조 = 굳힌 `참조사본` · 알약 = 가져온 때 것 · 수량 칸 = 사본 `면적.json` · 빈 입력 = 자동값. 답 = 층 셈 꼴(`줄` · `자재` · `기준합` · `반영합`) + `알약` + `빠진입력`(「빈 값 n」 표시).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs - snapshot = load_prices(prices) docs = dict((formula or {}).get("문서") or {}) + snapshot = item_bundle.load(prices, docs) # 단가 묶음 + 문서 이름표(855-F B9-6) doc = with_values(labor.get("줄") or {}, values or {}, picks or {}) copies = labor.get("참조사본") or {} saved = labor.get("알약") diff --git a/M02_MasterTemplete/M02_Item_Snapshot.py b/M02_MasterTemplete/M02_Item_Snapshot.py index a6315b09e..efe468cbc 100644 --- a/M02_MasterTemplete/M02_Item_Snapshot.py +++ b/M02_MasterTemplete/M02_Item_Snapshot.py @@ -117,16 +117,14 @@ def seed_picks(labor: Any) -> dict[str, Any]: def build_snapshot(item: dict[str, Any]) -> dict[str, Any]: """원본 내용 + 프로젝트 값(입력값 · 고른자재 첫 값 = 일위대가 문서 것) — `{파일 이름: 내용}` · SS 줄이 없으면 LookupError.""" - from M02_MasterTemplete import M02_Doc_B09 as doc_b09 - - files = doc_b09.attach(build_source(item)) # 수식 문서 사본(802-4a) + files = build_source(item) # 수식 문서 사본(802-4a) 포함 labor = files.get(LABOR_FILE) return {**files, VALUES_FILE: seed_values(labor), PICKS_FILE: seed_picks(labor)} def source_files(files: dict[str, Any]) -> dict[str, Any]: - """원본판 몫 — 수식 문서 사본(802-4a · 로직은 `단가.json` 이 잼)은 뺌.""" - return {k: v for k, v in files.items() if k not in (*LOCAL_FILES, "수식.json")} + """원본판 몫 — 프로젝트 값 빼고 전부(수식 문서 사본 = 로직 몫 · 855-F B9-6).""" + return {k: v for k, v in files.items() if k not in LOCAL_FILES} def write_snapshot(target: Path, item: dict[str, Any], owner_id: str, extra: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Item_Source.py b/M02_MasterTemplete/M02_Item_Source.py index 0ef96b1bc..241c337c5 100644 --- a/M02_MasterTemplete/M02_Item_Source.py +++ b/M02_MasterTemplete/M02_Item_Source.py @@ -103,33 +103,44 @@ def labor_doc_rows(doc: dict[str, Any]) -> dict[str, Any]: def logic_rows(row: dict[str, Any]) -> dict[str, Any]: - """`{줄: row, 로직: 담은 로직 줄(M01 시스템), 빠진로직: 없는 로직 키}`.""" - from M01_MasterData import M01_MasterData_Store as m01 + """`{줄: row, 빠진로직: M01 수식 문서에 없는 로직 키}` — 로직 줄 사본 안 실음(855-F B9-6 · + 셈 = 사본 `수식.json`).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + have = dc.folder() wanted = [str(entry.get("로직")) for entry in row.get("담은로직") or [] if entry.get("로직")] - found: dict[str, dict[str, Any]] = {} - raw: dict[str, Any] = {} # M01 적재본은 수가 Decimal — 줄은 원본 파일 JSON 그대로 담음 - # 로직 키 → 파일 이름만(`m01.logic` 은 검사 · 단가 미리보기까지 돌아 느림 · 156-2) - files, _ = m01.loaded() - where = { - str(one.get("키")): name - for name, data in m01._logic_files(files) - for one in data.get("줄") or [] - } - for key in wanted: - file = where.get(key) - if file is None: - continue - if file not in raw: - raw[file] = read_json(Path(m01.FOLDER) / file) - got = row_of(raw[file], key) - if got is not None: - found[key] = got - return { - "줄": row, - "로직": [found[key] for key in wanted if key in found], - "빠진로직": [key for key in wanted if key not in found], - } + return {"줄": row, "빠진로직": [key for key in wanted if key not in have]} + + +def formula_keys(labor: dict[str, Any] | None) -> list[str]: + """사본 셈이 부르는 로직 키 — 담은 로직 · 굳힌 참조사본 안 로직 줄 · SK 바탕 · 수식 사본 부름.""" + from M02_MasterTemplete import M02_Item_Sangeun as sk + from M02_MasterTemplete import M02_Labor_Ref as refs + + doc = (labor or {}).get("줄") or {} + copies = (labor or {}).get("참조사본") or {} + keys = [ + str(one["로직"]) + for one in doc.get("담은로직") or [] + if isinstance(one, dict) and one.get("로직") + ] + return list(dict.fromkeys([*keys, *refs.frozen_logics(copies), *sk.bundle_keys(copies)[0]])) + + +def formula_docs(labor: dict[str, Any] | None) -> dict[str, dict]: + """사본 수식 문서 닫힌 묶음(`수식.json` 몫) — 원본 일위대가 문서의 수식 사본 부름이 먼저(만든 때 것) · + M02 값 사본 로직 줄(795-4) = 그 줄 문서 · 그 밖 = 지금 M01 문서(`M02_Doc_Copy.closure`).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Prices as prices + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + doc = (labor or {}).get("줄") or {} + copies = (labor or {}).get("참조사본") or {} + have = (doc.get(dc.KEY) or {}).get("부름") if dc.has(doc) else None + rows = [r for r in copy_rows([doc, *copies.values()]) if "호표" in r or "흐름" in r] + whole = prices.master()[1] + whole = skc.Copy(whole, skc._rows({"로직": rows})) if rows else whole + return dc.closure(whole, formula_keys(labor), have) def build_source(item: dict[str, Any]) -> dict[str, Any]: @@ -156,23 +167,23 @@ def build_source(item: dict[str, Any]) -> dict[str, Any]: if labor is not None: files[LABOR_FILE] = labor files[PRICE_FILE] = price_bundle(labor, root) - return files + from M02_MasterTemplete import M02_Doc_B09 as doc_b09 + + return doc_b09.attach(files) # 수식 문서 사본(802-4a · 로직 몫 · 원본판에 듦 · 855-F B9-6) def price_bundle(labor: dict[str, Any] | None, root: Path) -> dict[str, Any]: - """사본 단가 묶음(`단가.json`) — 담은 로직 · 굳힌 참조 로직 · SK 바탕 로직 · 자재 · 고른 자재 · - 사전조합 자재 · 개인 자재(`root` = 원본 층 · B09 설계내역서 서고 사본도 이 길 · 204-2) · - SK 셈 = 그 수식 사본(굳힌 SK 로직 줄 없음 · 855-F B9-5).""" + """사본 단가 묶음(`단가.json`) — 수식 문서 묶음이 잇는 자원 · 표 줄 · 자재 · 고른 자재 · 사전조합 + 자재 · 개인 자재(`root` = 원본 층 · B09 설계내역서 서고 사본도 이 길 · 204-2) · M01 로직 줄 없음 + (855-F B9-6 · 셈 = `수식.json`).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Item_Prices as prices from M02_MasterTemplete import M02_Item_Sangeun as sk from M02_MasterTemplete import M02_Labor_Fixed as fixed from M02_MasterTemplete import M02_Labor_Ref as refs copies = (labor or {}).get("참조사본") or {} - logic_keys = [str(one.get("키")) for one in (labor or {}).get("로직", [])] - logic_keys += refs.frozen_logics(copies) # 굳힌 단가승격 로직 - sk_logic, sk_res = sk.bundle_keys(copies) # SK 수식 사본 셈이 읽는 줄(855-F B9-5) - logic_keys += sk_logic + _logic, sk_res = sk.bundle_keys(copies) # SK 수식 사본 셈이 읽는 자원 줄(855-F B9-5) doc = (labor or {}).get("줄") or {} materials = [str(m.get("코드")) for m in doc.get("자재") or []] materials += [ # 고른 로직 자재(103-1) 품목 줄도 — 복사본 계산이 그 단가를 씀 @@ -181,9 +192,10 @@ def price_bundle(labor: dict[str, Any] | None, root: Path) -> dict[str, Any]: materials += refs.frozen_materials((labor or {}).get("참조사본") or {}) # 175-2 사전조합 자재 materials += fixed.link_keys(doc) # 705-1 고정 줄이 잇는 노임 · 자재 · 기계 materials += sk_res - wanted = logic_keys + [code for code in materials if code] - over = copy_rows([doc, *copies.values()]) # M02 로직 사본(795-4) = 만든 때 줄 먼저 - bundle = prices.to_json(prices.collect(logic_keys, materials, None, over)) if wanted else {} + docs = formula_docs(labor) # 855-F B9-6 — 자원 · 표 줄 = 수식 문서가 잇는 것(로직 줄 없음) + wanted = list(docs) + [code for code in materials if code] + over = copy_rows([doc, *copies.values()]) # M02 값 사본(795-4) = 만든 때 줄 먼저 + bundle = prices.to_json(item_bundle.collect(docs, materials, over)) if wanted else {} if mine := own.bundle( [c for c in materials if own.is_own(c)], root ): # 개인 자재(148-3 · 사전조합 것도 175-2) — 원본 목록이 바뀌어도 사본 그대로 diff --git a/resources/tester/test_145_1_b09_sangeun.py b/resources/tester/test_145_1_b09_sangeun.py index 772417bbd..2caa85cdc 100644 --- a/resources/tester/test_145_1_b09_sangeun.py +++ b/resources/tester/test_145_1_b09_sangeun.py @@ -22,7 +22,6 @@ if str(ROOT) not in sys.path: from B09_Estimation import B09_Estimation_Router as router_mod # noqa: E402 from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 from M02_MasterTemplete import M02_Item_Prices as item_prices # noqa: E402 -from M02_MasterTemplete import M02_Labor_Doc as labor_doc # noqa: E402 STONE = "GF000219" # 돌쌓기 메쌓기(인력) — 석공 0.195 · 보통인부 0.156 / ㎡ NET = "GC000337" # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋 @@ -37,8 +36,15 @@ def _snapshot(folder: Path, rows, values=None, copies=None) -> Path: "줄": {"종류": "일위대가", "담은로직": rows}, **({"참조사본": copies} if copies else {}), } + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure( + item_prices.master()[1], [STONE, NET] + ) # 사본 = 수식 문서 + 자원 줄(855-F B9-6) files = { - "단가.json": item_prices.to_json(item_prices.collect([STONE, NET])), + "수식.json": item_prices.to_json({"그룹": "수식문서", "문서": docs}), + "단가.json": item_prices.to_json(item_bundle.collect(docs)), "일위대가.json": labor, "입력값.json": {k: {n: {"값": v} for n, v in d.items()} for k, d in (values or {}).items()}, } @@ -48,9 +54,16 @@ def _snapshot(folder: Path, rows, values=None, copies=None) -> Path: def _engine(folder: Path, code: str, given=None) -> dict: - """M02 엔진 기준(사본 단가 묶음 · 날 값 줄 · 끝수 뒤 기준).""" - whole = item_prices.load_prices(json.loads((folder / "단가.json").read_text(encoding="utf-8"))) - return labor_doc.run_line(whole, code, given or {}) + """M02 셈 기준(사본 수식 문서 셈 · 끝수 뒤 기준 · 855-F B9-6).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = json.loads((folder / "수식.json").read_text(encoding="utf-8"))["문서"] + bundle = json.loads((folder / "단가.json").read_text(encoding="utf-8")) + from B09_Estimation import B09_Estimation_Doc_Run as dr + from M02_MasterTemplete import M02_Doc_Copy as dc + + got = dr.solve(item_bundle.load(bundle, docs), docs, code, given or {}) + return {"기준": dc.money(got.ans)} def test_단가산출_줄만_산근_블록_단가는_M02_엔진(tmp_path): diff --git a/resources/tester/test_145_2_b09_labor_calc.py b/resources/tester/test_145_2_b09_labor_calc.py index c9ec97f1a..06ecb9edd 100644 --- a/resources/tester/test_145_2_b09_labor_calc.py +++ b/resources/tester/test_145_2_b09_labor_calc.py @@ -260,7 +260,12 @@ def _snap(root, owner, key, lines, values, copies=None): for doc in (copies or {}).values(): codes += [one["로직"] for one in doc["담은로직"] if "로직" in one] write(snapshots.MANIFEST_NAME, {"원본": {**_item(key), "경로": ["기슭막이", key]}}) - write("단가.json", item_prices.to_json(item_prices.collect(codes))) + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure(item_prices.master()[1], codes) # 사본 = 수식 문서 + 자원 줄(855-F B9-6) + write("수식.json", item_prices.to_json({"그룹": "수식문서", "문서": docs})) + write("단가.json", item_prices.to_json(item_bundle.collect(docs))) doc = {"종류": "일위대가", "단위": "m", "담은로직": lines, "자재": []} write("일위대가.json", {"줄": doc, **({"참조사본": copies} if copies else {})}) write("입력값.json", values) diff --git a/resources/tester/test_719_2_sk_project.py b/resources/tester/test_719_2_sk_project.py index 058ce82cb..c32d51746 100644 --- a/resources/tester/test_719_2_sk_project.py +++ b/resources/tester/test_719_2_sk_project.py @@ -180,3 +180,24 @@ def test_SK_하위_단가산출_줄_산근(world, tmp_path): subs = [ln for ln in lines if ln["kind"] == "sangeun"] assert subs and all(ln["key"] in sg_rows for ln in subs) assert {ln["key"].split(":")[1] for ln in subs} == {"GF000160"} + + +def test_내_자료집_SK_수식_문서로(world, tmp_path): + """B09 품셈 블록(사본 SK) → [내 자료집] = 개인 층 SK · 고친 품 = 수식 문서 금액 줄(따로 · 옛 칸 + 덮개 없음) · 그 SK M02 셈 = B09 덮은 블록 금액(855-F B9-6).""" + from B09_Estimation import B09_Estimation_Daega_Personal as personal + + key = _mine(world) + root, folder = _lib(world, tmp_path, key) + daega, done, _ = _b09(root) + block = done[daega["libs"][folder]] + cover = {block["cover"]: {block["lines"][0]["cid"]: {"qty": 0.05}}} + made = personal.build(root, block["cover"], cover, "sub1임시 내 SK") + assert made["담음"]["품"] == 1 and "덮개" not in made["문서"] + with store.at(world["personal"]): + new = personal.write(made["문서"])["이름"] + saved = store.read("sangeun", new)["문서"] + assert saved["수식"]["따로"] and saved["수식"]["문서"]["금액"][0]["수량"] == "0.05" + _, covered, _ = _b09(root, cover) + live = _calc(world["personal"], new) + assert float(live["1단위"]["계"]) == pytest.approx(covered[daega["libs"][folder]]["sum"], abs=5) diff --git a/resources/tester/test_795_4_b09_copy.py b/resources/tester/test_795_4_b09_copy.py index 9b13b5888..97f3ac7f5 100644 --- a/resources/tester/test_795_4_b09_copy.py +++ b/resources/tester/test_795_4_b09_copy.py @@ -47,8 +47,13 @@ def _m01(monkeypatch, rows=(), drop=()): monkeypatch.setattr(m01, "loaded", lambda: (out, fake)) -def _amount(labor_rows, bundle): - got = item_prices.calc(labor_rows, bundle, {}, {}) +def _copy(labor_rows, me): + """사본 = 단가 묶음(자원 줄) + 수식 문서(855-F B9-6 · 로직 몫).""" + return source.price_bundle(labor_rows, me), {"문서": source.formula_docs(labor_rows)} + + +def _amount(labor_rows, made): + got = item_prices.calc(labor_rows, made[0], {}, {}, None, made[1]) return _json(got["반영합"]) @@ -58,28 +63,30 @@ def test_bundle_is_m02_copy_then_frozen(world, monkeypatch): doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) assert skc.held(doc) # 값 사본 = 수식 쪽 한 벌(855 2-D) rows = source.labor_doc_rows(doc) - was = _amount(rows, source.price_bundle(rows, me)) # 지금 M01 = 사본 만든 때 - bundle = source.price_bundle(rows, me) + was = _amount(rows, _copy(rows, me)) # 지금 M01 = 사본 만든 때 + bundle = _copy(rows, me) _m01(monkeypatch, [_changed(_live().logic(PCT)), _double(LB)]) assert _amount(rows, bundle) == was # 굳힌 묶음 = M01 안 읽음 - late = source.price_bundle(source.labor_doc_rows(doc), me) # 구조물 지정이 M01 바뀐 뒤 + late = _copy(source.labor_doc_rows(doc), me) # 구조물 지정이 M01 바뀐 뒤 assert _amount(rows, late) == was # M02 사본 = 만든 때 old = { k: v for k, v in doc.items() if k not in (skc.KEY, skc.FORM) } # ② 값 사본 없음 = 지금 M01 old_rows = source.labor_doc_rows(old) - assert _amount(old_rows, source.price_bundle(old_rows, me)) != was + assert _amount(old_rows, _copy(old_rows, me)) != was def test_deleted_m01_key_kept_in_copy(world, monkeypatch): - """① M01 에서 지워진 로직 키 = 사본 줄 그대로(`사본_남은줄.json`) · 같은 금액.""" + """① M01 에서 지워진 로직 키 = 사본 수식 문서 그대로(만든 때 부름 · 855-F B9-6) · 같은 금액.""" me = world["personal"] doc = _labor(me, [{"로직": PCT, "수량": {"손": 1}}]) rows = source.labor_doc_rows(doc) - was = _amount(rows, source.price_bundle(rows, me)) + was = _amount(rows, _copy(rows, me)) _m01(monkeypatch, drop=[PCT]) - late = source.price_bundle(rows, me) - assert [r["키"] for r in late[item_prices.COPY_FILE]["줄"]] == [PCT] + late = _copy(rows, me) + assert PCT in late[1]["문서"] and not any( + isinstance(v, dict) and v.get("그룹") == "로직" for v in late[0].values() + ) assert _amount(rows, late) == was diff --git a/resources/tester/test_802_4a_m02_doc.py b/resources/tester/test_802_4a_m02_doc.py index 73bc230ad..7a1dfa208 100644 --- a/resources/tester/test_802_4a_m02_doc.py +++ b/resources/tester/test_802_4a_m02_doc.py @@ -215,14 +215,15 @@ def test_line_rules_in_doc(code, rate, picks, marks): def test_b09_copy_has_doc_file(world, monkeypatch): - """⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판엔 안 듦 · M01 바뀌어도 그대로.""" + """⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판에 듦(로직 몫 · 855-F B9-6) · + M01 바뀌어도 그대로.""" me = world["personal"] doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) rows = source.labor_doc_rows(doc) files = doc_b09.attach({"일위대가.json": rows, "단가.json": source.price_bundle(rows, me)}) made = files[doc_b09.FILE] assert made["그룹"] == "수식문서" and PCT in made["문서"] - assert doc_b09.FILE not in snap.source_files(files) + assert doc_b09.FILE in snap.source_files(files) assert doc_b09.attach(files) is files # 이미 있음 = 그대로 _fake(monkeypatch, [_changed(_live().logic(PCT))]) again = doc_b09.build(source.price_bundle(rows, me), rows) diff --git a/resources/tester/test_841_1_b09_m02_values.py b/resources/tester/test_841_1_b09_m02_values.py index c225b41c9..4d71c2c6e 100644 --- a/resources/tester/test_841_1_b09_m02_values.py +++ b/resources/tester/test_841_1_b09_m02_values.py @@ -13,13 +13,14 @@ import re import tempfile from pathlib import Path +from B09_Estimation import B09_Estimation_Doc_Run as dr from B09_Estimation import B09_Estimation_Router as router from B09_Estimation import B09_Estimation_Supply as supply from B09_Estimation.B09_Estimation_Labor_Source import _Loose, daega_inputs +from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Item_Prices as item_prices from M02_MasterTemplete import M02_Item_Snapshot as snapshots from M02_MasterTemplete import M02_Item_Source as source -from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from resources.tester.test_145_2_b09_labor_calc import _project, _snap @@ -50,8 +51,9 @@ def test_기계_대가_블록_M02_엔진_값(): sheets = router.compute_sheets(root, inputs, {}) block = next(b for b in sheets["daega"] if b["kind"] == "품셈") folder = next(snapshots.structures_dir(root).rglob("단가.json")).parent - whole = item_prices.load_prices(source.read_json(folder / "단가.json")) - want = labor_doc.run_line(whole, MACHINE, {})["기준"] + docs = dr.docs_of(folder) # 855-F B9-6 — 사본 = 자원 줄 + 수식 문서(견본 사본엔 없음 = 그 자리) + whole = item_bundle.load(source.read_json(folder / "단가.json"), docs) + want = item_prices.line(whole, docs, {"로직": MACHINE})["기준"] # M02 문서 셈 assert [block[p] for p in ("labor", "material", "expense", "sum")] == [ float(want[k]) for k in ("노무비", "재료비", "경비", "계") ] @@ -91,11 +93,14 @@ def test_기계_덮음_SK_사본까지(world): {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} ) bundle = source.price_bundle(rows, me) - got = item_prices.calc(rows, bundle, {}, {}) # 구조물 · 서고 사본 = 같은 굳히기 · 같은 셈 + docs = source.formula_docs(rows) # 사본 수식 문서(855-F B9-6) + got = item_prices.calc( + rows, bundle, {}, {}, None, {"문서": docs} + ) # 구조물 · 서고 사본 = 같은 셈 assert float(got["반영합"]["계"]) == now rid = refs.ref_id(ref) copies = rows["참조사본"] - whole = item_prices.load_prices(bundle) + whole = item_bundle.load(bundle, docs) expand = _Loose(whole, lambda r: copies.get(refs.ref_id(r))) b09 = supply.sk_money(copies[rid], whole, expand, rid) assert sum(b09.values()) == now diff --git a/resources/tester/test_855_b09_golden.py b/resources/tester/test_855_b09_golden.py index 2d1daf1b3..8acdbb7c5 100644 --- a/resources/tester/test_855_b09_golden.py +++ b/resources/tester/test_855_b09_golden.py @@ -4,7 +4,8 @@ 임시 storage(개인 층 7/42) · 견본을 시험이 지음 → 사본 만들기(지금 길) → 답 지문: - 층 견본 — 단가산출(SK): 바탕 로직 · 율 더한줄 · 형제(바탕 참조) · 「따로」 · 가져온 식 · 기계 · 재료 / 일위대가(SC): SK 참조 · 고정 · 로직 줄 + 자재 -- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle` +- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle` · + `Doc_B09.attach`(수식.json · 실제 사본 길과 같게 · 855-F B9-6) · B09 서고 사본 = `Bill_Library.import_copy`(SK 따로 · SK 가져온 식 · SC) - 손 줄 = 설계내역서 로직 줄(율 · 고른 재료 · 입력) + 운반공(거리 채움) - 답 = B09 `calc_user` · `daega_inputs` · 단가 수요 키(`_demand`) · 산근(`Sangeun.build` · 관급 있음 · 없음) @@ -37,6 +38,7 @@ from B09_Estimation import B09_Estimation_Router as b09 from B09_Estimation import B09_Estimation_Sangeun as sangeun from B09_Estimation import B09_Estimation_Store as b09_store from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs +from M02_MasterTemplete import M02_Doc_B09 as doc_b09 from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path from M02_MasterTemplete import M02_Item_Snapshot as snapshots from M02_MasterTemplete import M02_Item_Source as source @@ -132,8 +134,9 @@ def _structure(world, keys: dict[str, str], root: Path) -> None: ) rows = source.labor_doc_rows(doc) files = { - source.LABOR_FILE: rows, - source.PRICE_FILE: source.price_bundle(rows, me), + **doc_b09.attach( + {source.LABOR_FILE: rows, source.PRICE_FILE: source.price_bundle(rows, me)} + ), snapshots.VALUES_FILE: {STONE: {"높이": {"값": 1.5}}}, snapshots.PICKS_FILE: {TWO_MATS: {"1": "MT003196", "2": "MT003173"}}, snapshots.MANIFEST_NAME: {"원본": {**_item("SS000901"), "경로": ["x"]}}, diff --git a/resources/tester/test_item_copy_complete.py b/resources/tester/test_item_copy_complete.py index 046bf5f8d..5a657b2f2 100644 --- a/resources/tester/test_item_copy_complete.py +++ b/resources/tester/test_item_copy_complete.py @@ -92,12 +92,16 @@ def _stuck(got: dict) -> list: def _auto_values(root: Path) -> dict[str, Any]: """담은 로직마다 자동값을 확인한 값으로 — 사용자가 다 채운 것과 같게.""" - labor = _read(root / "templates/structures" / FOLDER / "일위대가.json") + from M02_MasterTemplete import M02_Doc_Copy as dc + + folder = root / "templates/structures" / FOLDER + docs = _read(folder / "수식.json")["문서"] # 855-F B9-6 — 입력 = 사본 수식 문서 + lines = _read(folder / "일위대가.json")["줄"]["담은로직"] _, whole = m01.loaded() out: dict[str, Any] = {} - for row in labor["로직"]: - values = m01.mau.values(whole, whole.logic(row["키"])) - out[row["키"]] = {k: {"값": prices.to_json(v), "확인": True} for k, v in values.items()} + for key in (one["로직"] for one in lines if one.get("로직")): + values = dc.auto_of(docs[key], whole) # 옛 master_auto 와 같은 자동값(문서) + out[key] = {k: {"값": prices.to_json(v), "확인": True} for k, v in values.items()} return out @@ -121,7 +125,8 @@ def test_지정하면_새_파일까지_복사(world): rows = {k: len(v.get("줄") or v.get("표")) for k, v in price.items()} assert rows["인력.json"] >= 2 and rows["재료_자재품목.json"] > 0 and "_빠진" not in price keys = {row["키"] for data in price.values() for row in data.get("줄") or data.get("표")} - assert {"GF000176", "GC000088", "GF000113", "GC000267", LABOR_PRICE} <= keys + docs = _read(folder / "수식.json")["문서"] # 로직 = 사본 수식 문서(855-F B9-6) + assert {"GF000176", "GC000088", "GF000113", "GC000267"} <= set(docs) and LABOR_PRICE in keys manifest = _read(folder / "manifest.json") assert manifest["가져온날"] and len(manifest["원본판"]) == 16 assert copies.list_items(root) == [ diff --git a/resources/tester/test_m02_item_labor.py b/resources/tester/test_m02_item_labor.py index 03049d04e..9d4eab6ef 100644 --- a/resources/tester/test_m02_item_labor.py +++ b/resources/tester/test_m02_item_labor.py @@ -137,12 +137,13 @@ def test_스냅샷_일위대가는_문서_알약_자재_단가(world): folder = root / "templates/structures" / FOLDER labor = _read(folder / "일위대가.json") assert labor["줄"] == world["doc"] - assert [row["키"] for row in labor["로직"]] == list(LOGICS) and labor["빠진로직"] == [] + assert labor["빠진로직"] == [] and "로직" not in labor # 로직 줄 사본 없음(855-F B9-6) + assert set(LOGICS) <= set(_read(folder / "수식.json")["문서"]) # 셈 = 사본 수식 문서 assert {p["키"] for p in labor["알약"]} == set(world["pills"]) keys = { row["키"] for data in _read(folder / "단가.json").values() for row in data.get("줄", []) } - assert MATERIAL in keys and set(LOGICS) <= keys + assert MATERIAL in keys and not set(LOGICS) & keys # 단가 묶음 = 자원 · 표 줄만 def test_입력값_첫_값은_문서_입력값(world): diff --git a/resources/tester/test_structures_summary_snapshot.py b/resources/tester/test_structures_summary_snapshot.py index bae53e40a..ed8b3c2c4 100644 --- a/resources/tester/test_structures_summary_snapshot.py +++ b/resources/tester/test_structures_summary_snapshot.py @@ -150,9 +150,11 @@ def test_지정하면_폴더가_생기고_내용이_원본과_같음(world): # 일위대가 UA 줄 + 담은 로직 줄(M01 시스템) labor = json.loads((_items(root) / "pipe@40.0/일위대가.json").read_text(encoding="utf-8")) assert labor["줄"]["키"] == "UA000036" - assert [row["키"] for row in labor["로직"]] + labor["빠진로직"] == [ + wanted = [ entry["로직"] for entry in labor["줄"]["담은로직"] - ] + ] # 로직 = 사본 수식 문서(855-F B9-6) + docs = json.loads((_items(root) / "pipe@40.0/수식.json").read_text(encoding="utf-8"))["문서"] + assert "로직" not in labor and set(wanted) - set(labor["빠진로직"]) <= set(docs) def test_원본을_바꿔도_프로젝트_값은_그대로(world): From 56146d5f4a46d1e112636d2772327a6dec0f6f28 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:20:38 +0900 Subject: [PATCH 3/9] =?UTF-8?q?refactor(855-F=20B9-6):=20=ED=94=84?= =?UTF-8?q?=EB=A1=9C=EC=A0=9D=ED=8A=B8=20=EC=82=AC=EB=B3=B8=EC=97=90?= =?UTF-8?q?=EC=84=9C=20M01=20=EB=A1=9C=EC=A7=81=20=EC=A4=84=20=EA=B1=B7?= =?UTF-8?q?=EC=9D=8C=20=E2=80=94=20=EB=8B=A8=EA=B0=80.json=20=EB=A1=9C?= =?UTF-8?q?=EC=A7=81=20=ED=8C=8C=EC=9D=BC=20=C2=B7=20=EC=9D=BC=EC=9C=84?= =?UTF-8?q?=EB=8C=80=EA=B0=80.json=20=EB=A1=9C=EC=A7=81=20=EC=82=AC?= =?UTF-8?q?=EB=B3=B8=200=20=C2=B7=20=EC=85=88=20=3D=20=EC=88=98=EC=8B=9D.j?= =?UTF-8?q?son?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 앞 커밋 296ec60ee(auto · 앞 세션 결제 오류로 멈춘 미커밋을 싱크가 올림)의 설명 + 그 뒤 시험 고침. - M02_Item_Source: logic_rows 가 로직 줄 안 실음(빠진로직 = M01 수식 문서에 없는 키) · formula_docs(사본 수식 문서 닫힌 묶음) · price_bundle = 새 M02_Item_Bundle.collect(문서 변수 연결을 훑어 자원 · 표 줄만 · 로직 줄 없음) · build_source 가 수식.json 붙임 - M02_Item_Bundle(새): 문서 연결 훑기 모음 · 셈 색인 Index(문서 이름표 + docs) · load - M02_Doc_B09.build = formula_docs(단가 묶음 안 읽음 · logic_keys 걷음) · M02_Doc_Copy.doc_of = 색인이 실어 온 사본 문서 먼저 - M02_Item_Snapshot.source_files 원본판에 수식.json 듦 · Item_Prices.calc 색인 = 묶음 + 문서 - B08 Router_Material · B09 Sangeun · Labor_Source · Linked · Doc_Run · Bill_Library(서고 사본 수식 · 원본판 = 일위대가 + 수식 문서) = 같은 색인 - B09 Daega_Personal 단가산출 [내 자료집] = 수식 문서 꼴(옛 칸 덮개 · 원본 · 정체 안 씀 · 고침 = 수식 길 저장) - 시험: 사본 셈 견본이 수식.json 을 같이 넘김(실제 Item_Copy.calc 길) — test_719_1 셋 · 848_1 · 848_10 · 795_4 · 145_1 · 145_2 · 719_2 · 802_4a · 841_1 · item_copy_complete · m02_item_labor · structures_summary_snapshot · 855_b09_golden - 세기(골든 견본 사본 8): 단가.json 로직 파일 22 → 0 · 로직 줄 28 → 0 · 일위대가.json 로직 사본 4 → 0 - 검증: 관련 + 핵심 + 143 + 855_2d_frozen 898 중 실패 = 703(같은 내용 지문 4 ↔ 4.0 · 고치기 전 코드도 같음) · 713_1 · 804_7(M01 cce57c298 몫) 뿐 · 실제 B09 프로젝트 답 해시 같음 · 빌더 --check 같음 · typecheck 0 Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_719_1_sk_freeze.py | 17 +++++++++++++---- resources/tester/test_848_10_upper_down.py | 3 ++- resources/tester/test_848_1_cover_layers.py | 7 +++++-- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/resources/tester/test_719_1_sk_freeze.py b/resources/tester/test_719_1_sk_freeze.py index e3d98145f..a26c78b29 100644 --- a/resources/tester/test_719_1_sk_freeze.py +++ b/resources/tester/test_719_1_sk_freeze.py @@ -86,9 +86,10 @@ def test_구조물_사본_수식_사본_값_같음_원본_지우고_고쳐도(wo assert not [r for r in _rows(bundle) if str(r.get("키")).startswith("GX9")] json.dumps(rows["참조사본"], ensure_ascii=False) # 사본 파일로 쓸 수 있는 꼴(Decimal 없음) saved = json.loads(json.dumps(bundle, ensure_ascii=False)) + formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6 · 로직 몫) edit(world["personal"], key, 3) # M02 에서 다시 고침 → 사본 그대로 (world["personal"] / "sangeun" / f"{key}.json").unlink() # 원본이 사라져도 사본만 봄 - got = prices.calc(rows, saved, {}, {}, None) + got = prices.calc(rows, saved, {}, {}, None, formula) line = got["줄"][0] assert not line["까닭"] for part in ("노무비", "재료비", "경비", "계"): @@ -104,7 +105,10 @@ def test_재생성은_M02_새_값(world): _, live = _top(ref) again = source.labor_doc_rows(doc) bundle = source.price_bundle(again, world["personal"]) - got = prices.calc(again, json.loads(json.dumps(bundle, ensure_ascii=False)), {}, {}, None) + formula = {"문서": source.formula_docs(again)} + got = prices.calc( + again, json.loads(json.dumps(bundle, ensure_ascii=False)), {}, {}, None, formula + ) assert got["줄"][0]["기준"]["계"] == pytest.approx(live["기준"]["계"], rel=1e-9) rid = refs.ref_id(ref["ref"]) assert first["참조사본"][rid]["수식"]["문서"] != again["참조사본"][rid]["수식"]["문서"] @@ -131,11 +135,16 @@ def test_B09_서고_사본_값_같음_원본판(world, tmp_path): assert made["만듦"] and _print(world["personal"]) == before folder = library.library_dir(root) / made["폴더"] read = {p.name: json.loads(p.read_text(encoding="utf-8")) for p in folder.glob("*.json")} - bare = prices.calc(read[source.LABOR_FILE], read[source.PRICE_FILE], {}, {}, None)["줄"][0] + labor_file, price_file, formula = ( + read[source.LABOR_FILE], + read[source.PRICE_FILE], + read["수식.json"], + ) + bare = prices.calc(labor_file, price_file, {}, {}, None, formula)["줄"][0] assert bare["기준"]["계"] == pytest.approx( live["기준"]["계"], rel=1e-9 ) # 이은 값 없음 = 저장 2 - got = prices.calc(read[source.LABOR_FILE], read[source.PRICE_FILE], {}, {}, area)["줄"][0] + got = prices.calc(labor_file, price_file, {}, {}, area, formula)["줄"][0] assert not got["까닭"] and not live["까닭"] assert got["기준"]["계"] == pytest.approx(live["기준"]["계"], rel=1e-9) mark = read["manifest.json"]["원본판"] diff --git a/resources/tester/test_848_10_upper_down.py b/resources/tester/test_848_10_upper_down.py index b5f726ef9..99686b011 100644 --- a/resources/tester/test_848_10_upper_down.py +++ b/resources/tester/test_848_10_upper_down.py @@ -177,7 +177,8 @@ def _freeze(me, key): {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} ) bundle = source.price_bundle(rows, me) - return lambda: float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) + formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6) + return lambda: float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) def test_프로젝트_사본(world, docs_tmp): diff --git a/resources/tester/test_848_1_cover_layers.py b/resources/tester/test_848_1_cover_layers.py index dd2b6ceca..e670bd317 100644 --- a/resources/tester/test_848_1_cover_layers.py +++ b/resources/tester/test_848_1_cover_layers.py @@ -318,14 +318,17 @@ def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world): {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} ) bundle = source.price_bundle(rows, me) + formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6) frozen = rows["참조사본"][refs.ref_id(ref)]["수식"] assert _norm(frozen[mcv.UPPER]) == _norm(upper) - was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) + was = float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) assert was == float(after["셈"]["계"]) _save_m01(_upper(d, D(2))) # 기초 고침이 바뀜 now = _at(me, path.read, key) assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것 - assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것 + assert ( + float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) == was + ) # 사본 = 굳은 것 _save_m01(upper) # ㉢ ② 를 위 층 값으로 = ② 0 now = _at(me, path.read, key) From a2151105c8fa01e5440182b8d6c976e8d09ac6ad Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:21:23 +0900 Subject: [PATCH 4/9] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-3):=20?= =?UTF-8?q?=EC=9D=BC=EC=9C=84=EB=8C=80=EA=B0=80=20=EB=A1=9C=EC=A7=81=20?= =?UTF-8?q?=EC=A4=84=20=EC=9E=AC=EB=A3=8C=20=EC=B0=A8=EB=A1=80=20=C2=B7=20?= =?UTF-8?q?=EC=9D=B4=EB=A6=84=20=C2=B7=20=EB=8B=A8=EC=9C=84=20=3D=20?= =?UTF-8?q?=EB=AC=B8=EC=84=9C=20=EA=B8=88=EC=95=A1=20=EC=A4=84(=EB=A1=9C?= =?UTF-8?q?=EC=A7=81=20=EC=A4=84=20=ED=98=B8=ED=91=9C=20=EC=95=88=20?= =?UTF-8?q?=EC=9D=BD=EC=9D=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Labor_Copy.line · _mats — 재료 줄 = 수식 문서 금액 줄(Item_Prices._mat_lines · 단위 = 연결 단위 = 로직 원문 표기) - 흐름 갈래 걷음(M01 로직 1,521 중 흐름 0) - M01 1,521 전수 재료 줄 차례 · 이름 · 단위 로직 줄과 같음 · 셈 답(기준 · 재료 목록) 1,541 다름 0 - M01 로직 줄 읽힘(Labor_Copy.line) 1,521 → 0 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Labor_Copy.py | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/M02_MasterTemplete/M02_Labor_Copy.py b/M02_MasterTemplete/M02_Labor_Copy.py index 8dbedbf8f..d4a9992c3 100644 --- a/M02_MasterTemplete/M02_Labor_Copy.py +++ b/M02_MasterTemplete/M02_Labor_Copy.py @@ -151,11 +151,8 @@ def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]: docs = dc.closure(whole, dc.calls(base), None) if base else {} if base is None: return {"기준": None, "줄": [], "재료": [], "까닭": f"수식 문서 없음 「{code}」"} - row = whole.logic(code) - mats = [] if isinstance(row.get("흐름"), dict) else row.get("호표") or [] - apart = dc.apart_of( - one.get("자재표시"), [{"차례": n} for n, x in enumerate(mats) if x.get("종류") == "재료"] - ) + mats = dc.prices._mat_lines(base) # 재료 금액 줄(855 L2 ⓑ-3 — 로직 줄 호표 안 읽음) + apart = dc.apart_of(one.get("자재표시"), [{"차례": n} for n, _, _ in mats]) given = dc.given_of(whole, code, one.get("입력값")) body = dc.line_doc(base, rate, picks, apart) ans = _traced(body, whole, docs, given, copy) @@ -185,12 +182,12 @@ def _traced(doc: dict, whole: Any, docs: dict, given: dict, copy: dict) -> dict: } -def _mats(items: list, ans: dict, picks: Any) -> list[dict[str, Any]]: - """로직 자재(103-1) — 맨 위 재료 줄(호표 차례 = 문서 금액 줄 차례)마다 셈 기록이 읽은 품목 키 · - 수량 · 단가 · 금액(별도계상 · 같은 품목 400 · 호표 들이기 `_inside` 가 읽음).""" +def _mats(mats: list, ans: dict, picks: Any) -> list[dict[str, Any]]: + """로직 자재(103-1) — 재료 금액 줄(`_mat_lines` · 단위 = 연결 단위 = 로직 원문 표기)마다 + 셈 기록이 읽은 품목 키 · 수량 · 단가 · 금액(별도계상 · 같은 품목 400 · `_inside` 가 읽음).""" calls, lines, out = ans.get("부름") or [], ans.get("줄") or [], [] - for n, item in enumerate(items): - if item.get("종류") != "재료" or n >= len(lines): + for n, line, link in mats: + if n >= len(lines): continue read = [calls[j] for j in lines[n].get("부름") or [] if j < len(calls)] keys = [c.get("품목") for c in read] + [ @@ -199,7 +196,12 @@ def _mats(items: list, ans: dict, picks: Any) -> list[dict[str, Any]]: key = next((k for k in keys if k), None) head = {k: lines[n].get(k) for k in ("수량", "단가", "금액", "까닭")} out.append( - {"차례": n, "이름": item.get("이름") or "", "단위": item.get("단위") or "", **head} + { + "차례": n, + "이름": line.get("이름") or "", + "단위": link.get("단위") or line.get("단위") or "", + } + | head | {"품목": {"키": key} if key else None, "고름": str(n) in (picks or {})} ) return out From 85df15367dc85be1171576d70a7cf7d9ca650150 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:21:24 +0900 Subject: [PATCH 5/9] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-3):=20?= =?UTF-8?q?=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20=EA=B8=B0=EC=B4=88=20?= =?UTF-8?q?=EB=A8=B8=EB=A6=AC(=EC=9E=85=EB=A0=A5=20=EC=9D=B4=EB=A6=84=20?= =?UTF-8?q?=C2=B7=20=EA=BC=AC=EB=A6=AC=ED=91=9C=20=C2=B7=20=EB=B0=B0)=20?= =?UTF-8?q?=3D=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=C2=B7=20?= =?UTF-8?q?=EB=B0=94=ED=83=95=ED=8C=90=20=EC=95=88=20=EC=A0=81=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Sangeun_Doc.doc_row 새 — M01 수식 문서의 이름 · 결과단위 · 원문번호 · 입력 이름(M01 문서 없는 키 = 색인 줄 그대로) - Sangeun_Doc._logic · _added_names · Sangeun_Calc.tag_of · _row_of = doc_row(1,521 전수 입력 이름 · 결과단위 · 원문번호 같음) - Sangeun_Calc.clean_doc 바탕 = _head_of(로직 바탕 · 옛 칸 없음 = 문서 머리 · 그 밖 = 바탕 사슬 그대로) - 바탕판(바탕 줄 지문) 셈 답 · 저장 파일에서 걷음 — 화면 · 서버 읽는 곳 0(서고 같음 판정 DROP) - 시험 골든 m02_858_shelf_golden 다시 뜸 — sangeun.읽기 답의 바탕판 칸 둘 빠짐(+ 가림 번호 하나)만 다름 - 셈 답 1,541 · m855_sk 14 금액 · 꼬리표 · 배 다름 0 · M01 로직 줄 읽힘 내 몫 6,097 → 1,526(남은 derive = 줄 규칙 열쇠 묶음) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Sangeun_Calc.py | 33 ++++++++++++------- M02_MasterTemplete/M02_Sangeun_Const.py | 12 +++---- M02_MasterTemplete/M02_Sangeun_Doc.py | 28 +++++++++++++--- .../tester/fixtures/m02_858_shelf_golden.json | 2 +- 4 files changed, 51 insertions(+), 24 deletions(-) diff --git a/M02_MasterTemplete/M02_Sangeun_Calc.py b/M02_MasterTemplete/M02_Sangeun_Calc.py index e26f10e73..17212c7ce 100644 --- a/M02_MasterTemplete/M02_Sangeun_Calc.py +++ b/M02_MasterTemplete/M02_Sangeun_Calc.py @@ -5,7 +5,7 @@ 뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` · `resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀). 계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만). -저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `바탕판` · `M01판` 적음. +저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 · 바탕 머리 = 기초 문서(855 L2 ⓑ-3). SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` · 「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} · 없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`). @@ -247,9 +247,9 @@ def _bundled(item: dict, sub: dict) -> dict: def tag_of(whole: Any, code: str) -> str: - """꼬리표 = 기초 원문번호(「9-12-1」) · 없으면 키.""" + """꼬리표 = 기초 원문번호(「9-12-1」 · 문서 이름표 855 L2 ⓑ-3) · 없으면 키.""" try: - return str(whole.logic(code).get("원문번호") or code) + return str(sd.doc_row(whole, code).get("원문번호") or code) except Exception: # noqa: BLE001 return code @@ -279,10 +279,11 @@ def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None: def _row_of(doc: dict, whole: Any) -> dict: - """배 · 바탕판이 읽는 바탕 줄(셈 아님) — 바탕 로직 = 그 줄 · 없음 = 빈 줄(가져온 식 = 그 줄).""" + """배가 읽는 바탕 머리(셈 아님) — 바탕 로직 = 기초 문서 머리(`sd.doc_row` · 855 L2 ⓑ-3) · + 없음 = 빈 줄(가져온 식 = 그 줄).""" key = (doc.get("바탕") or {}).get("로직") try: - return whole.logic(key) if key else sd.empty_row(doc) + return sd.doc_row(whole, key) if key else sd.empty_row(doc) except Exception as e: # noqa: BLE001 — 없는 로직 raise sd.DocError(f"바탕 로직 · {e}") from e @@ -311,7 +312,7 @@ def run( copy = dsk.copy_of(doc, whole) if copy is None: why = dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY - none = {"기준": None, "1단위": None, "배": Decimal(1), "바탕판": "", "줄": [], "정체": []} + none = {"기준": None, "1단위": None, "배": Decimal(1), "줄": [], "정체": []} return {**head, **none, "까닭": why, "수식셈": {"셈됨": False, "따로": False, "까닭": why}} row = _row_of(doc, whole) times = ratio_of(doc, row, whole) @@ -331,7 +332,6 @@ def run( "기준": total, "1단위": {k: v / times for k, v in total.items()} if total else None, "배": times, - "바탕판": fingerprint(row), "줄": lines, "정체": [x["cid"] for x in lines], "끝수": got.get("끝수"), @@ -496,21 +496,32 @@ def _check_refs(doc: dict, here_: refs.Here) -> None: refs._no_loop(ref, [me, ref]) +def _head_of(doc: dict, whole: Any) -> dict[str, Any]: + """저장 검사가 읽는 바탕 — 로직 바탕 · 옛 칸 고침 없음 = 기초 문서 머리(입력 이름 · 결과단위 · + 855 L2 ⓑ-3 로직 줄 안 읽음) · 그 밖(가져온 식 · 참조 · 옛 칸) = 바탕 사슬(`_base_of`).""" + if "로직" in (doc.get("바탕") or {}) and not dsk.patched(doc): + try: + return {"줄": sd.doc_row(whole, doc["바탕"]["로직"]), "짝잃음": []} + except Exception as e: # noqa: BLE001 — 엔진 FormulaError(없는 기초) + raise sd.DocError(f"바탕 로직 · {e}") from e + return _base_of(doc, whole, refs.read_ref, ()) + + def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: - """저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `바탕판` · `M01판` · - 옛 칸 덮개 · 둘째 기초 `원값` 적기는 걷음(옛 칸 셈 은퇴 · 855 2-C1).""" + """저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 가져온 식 검산 · 서버가 적던 + `바탕판` · `M01판` · 옛 칸 덮개 · 둘째 기초 `원값` 은 걷음(855 2-C1 · 2-D · L2 ⓑ-3).""" raw, job = doc, doc.get(skc.JOB) if isinstance(doc, dict) else None # 수식 사본(802-4a) whole = skc.over(doc := skc.settle(doc, True), skc.whole_()) # 사본(795-1) · 내 기계(821-1) try: rough = sd.clean(doc, None, whole) _check_refs(rough, here_) - eqm.strict(base := _base_of(rough, whole, refs.read_ref, ())) # 수식 고침(796-2b) + eqm.strict(base := _head_of(rough, whole)) # 수식 고침(796-2b) blk.strict(rough, whole) # 끊은 기초 수식 고침(796-2e) out = sd.clean(doc, base["줄"], whole) out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"] for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 one.setdefault("처음수량", one["수량"]) - out |= const.stamp(base["줄"], out) # 바탕판 · M01판(790-2) · 식 칸 엔진 식(792-1) + const.stamp(out) # 가져온 식 검산(793-2) ratio_of(out, base["줄"], whole) # 단위 못 바꿈(계수 없음) = 저장 막음(728-2) out = dsk.settle(out, whole, job, raw) except sd.DocError as e: diff --git a/M02_MasterTemplete/M02_Sangeun_Const.py b/M02_MasterTemplete/M02_Sangeun_Const.py index a538f06e7..418faec5a 100644 --- a/M02_MasterTemplete/M02_Sangeun_Const.py +++ b/M02_MasterTemplete/M02_Sangeun_Const.py @@ -90,16 +90,12 @@ def clean_more(raw: Any, out: dict) -> dict: return imp.clean(raw, out) # 가져온 식(793-2) -def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]: - """저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · 가져온 식 검산 · - 옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D).""" - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - if doc is not None and imp.is_imported(doc): # 가져온 식 검산(793-2) = 서버가 다시 +def stamp(doc: dict) -> None: + """저장 때 서버 칸 — 가져온 식 검산(793-2 · 서버가 다시) · 옛 `바탕판`(바탕 줄 지문 · 읽는 곳 0 · + 855 L2 ⓑ-3) · 옛 `M01판`(855 2-D)은 안 적음.""" + if imp.is_imported(doc): doc[imp.KEY]["검산"] = imp.check(doc) - return {"바탕판": calc.fingerprint(row)} - # ── 고치기 ────────────────────────────────────── def restore(doc: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Sangeun_Doc.py b/M02_MasterTemplete/M02_Sangeun_Doc.py index 96f620a6b..1a427e6af 100644 --- a/M02_MasterTemplete/M02_Sangeun_Doc.py +++ b/M02_MasterTemplete/M02_Sangeun_Doc.py @@ -268,19 +268,39 @@ def _added_names(whole: Any, adds: Any) -> set[str]: for one in adds or []: if isinstance(one, dict) and one.get("종류") == "로직": try: - out |= { - str(s.get("이름")) for s in whole.logic(str(one.get("로직"))).get("입력") or [] - } + out |= {str(s.get("이름")) for s in doc_row(whole, str(one.get("로직")))["입력"]} except Exception: # noqa: BLE001 continue return out +def doc_row(whole: Any, code: str) -> dict: + """기초 머리(855 L2 ⓑ-3 · 로직 줄 안 읽음) — M01 수식 문서의 이름 · 결과단위 · 원문번호 · 입력 이름 + (입력 · 선택 변수 열쇠) · M01 문서 없는 키(굳힌 사본 줄 등) = 색인 줄 그대로(없으면 엔진 틀림).""" + from M02_MasterTemplete import M02_Doc_Copy as dc # 늦게 — dc 가 이 파일을 부름 + + doc = dc.folder().get(str(code)) + if doc is None: + return whole.logic(code) + names = [ + v["열쇠"] + for v in doc.get("변수") or [] + if (v.get("연결") or {}).get("갈래") in ("입력", "선택") and v.get("열쇠") + ] + return { + "키": str(code), + "이름": doc.get("이름"), + "결과단위": doc.get("결과단위"), + "원문번호": dc.md.tags_of(doc).get("원문번호"), + "입력": [{"이름": n} for n in names], + } + + def _logic(whole: Any, code: str, where: str) -> dict | None: if whole is None: return None try: - return whole.logic(code) + return doc_row(whole, code) except Exception as e: # noqa: BLE001 — 엔진 FormulaError(가져오기 둘레 피함) raise DocError(f"{where} · {e}") from e diff --git a/resources/tester/fixtures/m02_858_shelf_golden.json b/resources/tester/fixtures/m02_858_shelf_golden.json index 4c4f06cd4..df6b583e7 100644 --- a/resources/tester/fixtures/m02_858_shelf_golden.json +++ b/resources/tester/fixtures/m02_858_shelf_golden.json @@ -20,7 +20,7 @@ "sangeun.복사": "40edbd4d0644186f", "sangeun.붙여넣기": "57cfb7bb522a80d3", "sangeun.쓰는곳": "2c9ec1824709481f", - "sangeun.읽기": "19662ccd4c5ae0c0", + "sangeun.읽기": "670646670a5685b4", "sangeun.중복": "2c9378c6e9c61251", "sangeun.지우기": "db8b1e8ad9bef9eb", "sangeun.합치기": "b8f7720e8a1e1bbb", From 1b4a5fc28a0a837429465fa43bcb9a543ebbb981 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:36:45 +0900 Subject: [PATCH 6/9] =?UTF-8?q?refactor(855-F=20B9-6):=20=EC=9D=BC?= =?UTF-8?q?=EC=9C=84=EB=8C=80=EA=B0=80=20=C2=B7=20=EC=82=AC=EC=A0=84?= =?UTF-8?q?=EC=A1=B0=ED=95=A9=20=EA=B0=92=20=EC=82=AC=EB=B3=B8=EC=97=90?= =?UTF-8?q?=EC=84=9C=20=EB=A1=9C=EC=A7=81=20=EC=A4=84=20=EA=B1=B7=EC=9D=8C?= =?UTF-8?q?=20=E2=80=94=20=ED=94=84=EB=A1=9C=EC=A0=9D=ED=8A=B8=20=EC=82=AC?= =?UTF-8?q?=EB=B3=B8=20=EB=AC=B8=EC=84=9C=20=3D=20=EC=88=98=EC=8B=9D=20?= =?UTF-8?q?=EB=B6=80=EB=A6=84=EB=A7=8C=20=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Item_Source.formula_docs: 값 사본 로직 줄(skc.Copy) 안 읽음 — 원본 일위대가 · 굳힌 참조사본의 수식 부름(만든 때 문서 · 겹침 = 원본 것) 먼저 · 그 밖 = 지금 M01 문서 - M02_Labor_Copy.stamp: 새 값 사본 = skc._plain(로직 줄 뺌 · 표 · 요율 · 자원 줄만 · PLAN 855-E 「이음(L2 ⓑ-2 · L3 · B9-6 로)」) - 세기: 견본 일위대가(GF000219 · GF000206) 값 사본 로직 줄 3 → 0 - 검증: 관련 17 + 핵심 + 143 · 145 · 719 · 792_3 · 855_2d_frozen · 855_l2b_copy_plain · 855_sk_layers 385 통과 (156_2 시간 한도 하나 = 빌더 동시 실행 탓 · 따로 다시 6 통과) · 795_4 · 795_2 통과 · 실제 B09 답 해시 같음 · 빌더 --check 같음 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Item_Source.py | 16 ++++++++-------- M02_MasterTemplete/M02_Labor_Copy.py | 3 ++- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/M02_MasterTemplete/M02_Item_Source.py b/M02_MasterTemplete/M02_Item_Source.py index 241c337c5..fd7546ce3 100644 --- a/M02_MasterTemplete/M02_Item_Source.py +++ b/M02_MasterTemplete/M02_Item_Source.py @@ -128,19 +128,19 @@ def formula_keys(labor: dict[str, Any] | None) -> list[str]: def formula_docs(labor: dict[str, Any] | None) -> dict[str, dict]: - """사본 수식 문서 닫힌 묶음(`수식.json` 몫) — 원본 일위대가 문서의 수식 사본 부름이 먼저(만든 때 것) · - M02 값 사본 로직 줄(795-4) = 그 줄 문서 · 그 밖 = 지금 M01 문서(`M02_Doc_Copy.closure`).""" + """사본 수식 문서 닫힌 묶음(`수식.json` 몫) — 원본 일위대가 · 굳힌 참조사본의 수식 사본 부름(만든 때 + 것 · 키 겹침 = 원본 문서 것) 먼저 · 그 밖 = 지금 M01 문서(`M02_Doc_Copy.closure` · 값 사본 로직 줄 + 안 읽음 · 855-F B9-6).""" from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Item_Prices as prices - from M02_MasterTemplete import M02_Sangeun_Copy as skc doc = (labor or {}).get("줄") or {} copies = (labor or {}).get("참조사본") or {} - have = (doc.get(dc.KEY) or {}).get("부름") if dc.has(doc) else None - rows = [r for r in copy_rows([doc, *copies.values()]) if "호표" in r or "흐름" in r] - whole = prices.master()[1] - whole = skc.Copy(whole, skc._rows({"로직": rows})) if rows else whole - return dc.closure(whole, formula_keys(labor), have) + have: dict[str, dict] = {} + for one in [*copies.values(), doc]: + if dc.has(one): + have.update(one[dc.KEY].get("부름") or {}) + return dc.closure(prices.master()[1], formula_keys(labor), have) def build_source(item: dict[str, Any]) -> dict[str, Any]: diff --git a/M02_MasterTemplete/M02_Labor_Copy.py b/M02_MasterTemplete/M02_Labor_Copy.py index 8dbedbf8f..510c3a31b 100644 --- a/M02_MasterTemplete/M02_Labor_Copy.py +++ b/M02_MasterTemplete/M02_Labor_Copy.py @@ -49,7 +49,8 @@ def stamp(doc: dict) -> dict | None: links += [ str(m["코드"]) for m in doc.get("자재") or [] if isinstance(m, dict) and m.get("코드") ] - return skc.snap(list(dict.fromkeys(keys)), list(dict.fromkeys(links))) + got = skc.snap(list(dict.fromkeys(keys)), list(dict.fromkeys(links))) + return got and skc._plain(got) # 로직 줄 안 담음(855-F B9-6 · 셈 = 수식 부름) def _file(doc: dict) -> dict: From c030ed24a7882f1648b36e0da0cb6a585d2888a1 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:37:11 +0900 Subject: [PATCH 7/9] =?UTF-8?q?refactor(858=205-6):=20=EB=82=B4=20?= =?UTF-8?q?=EA=B8=B0=EA=B3=84=20=C2=B7=20=EB=82=B4=20=EC=9E=AC=EB=A3=8C?= =?UTF-8?q?=EB=A5=BC=20=EC=84=9C=EA=B3=A0=20=ED=8B=80=EB=A1=9C=20=E2=80=94?= =?UTF-8?q?=20=EC=A2=85=EB=A5=98=20=ED=91=9C=20=C2=B7=20=EC=B8=B5=20?= =?UTF-8?q?=EB=B2=88=ED=98=B8=20=EC=9E=A5=EB=B6=80=20=C2=B7=20=EB=82=B4=20?= =?UTF-8?q?=EC=9E=AC=EB=A3=8C=20=ED=8C=90=20=C2=B7=20=EA=B8=B8=20=ED=95=9C?= =?UTF-8?q?=20=EB=AC=B6=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 종류 표 `Template_Layers.SHELF`(자리 · 머리 · 이름 · 번호 · 나무) — LIBRARY_KINDS · Labor_Ref PREFIX · TITLE · 내 기계 · 내 재료 자리 · 머리를 표에서 읽음 - 내 기계 번호 = 층 `_번호.json` 「내기계」 칸(Labor_Ref.issued · keep_issued 공개) · 지운 끝 번호 안 다시 씀 · 옛 `_다음.json` · 옛 `내기계.json` 옮김(_move · _read) 걷음(요구 899 — 옛 꼴 호환 없음) - 내 기계 잠금 = store._LOCK 한 벌(RLock) — 번호 장부를 SK · SC 와 같이 쓰므로 두 잠금 순서 교착 막음 - 내 재료 = 한 파일 + 판(version) · 고칠 때 옛 판 409 {stale, 판, 까닭} · 목록 답에 판 - 내 재료 길 넷을 Labor_Router → MyMachine_Router(길 글자 그대로 · openapi 묶음 이름만 바뀜) - 화면 Api 「종류 + 층」 한 함수 shelfPath(내 기계 · 내 재료 · 찾기 · 내 품목) · Material_Pick 은 내 재료 Api 부름 · 내 재료 화면이 판을 보내고 409 면 다시 읽음 - 시험: 854_1 번호 장부 · 내 기계 지운 끝 번호 · material_own 판 409 새 시험 · 826_2 ③(옛 파일 옮김 = 죽은 코드만 붙듦) 지움 · material_own 화면 소스 글자 시험 지움(글자 시험 규칙) · shelf golden 다시 뜸(고치기 전 답과 통째 대조 — 다름 = 내 재료 목록 판 칸 하나 · 뒤 차례 번호 밀림) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Labor_Ref.py | 25 ++++--- M02_MasterTemplete/M02_Labor_Router.py | 65 +---------------- .../M02_MasterTemplete_Find_Pick.ts | 4 +- M02_MasterTemplete/M02_Material_Own.py | 21 +++++- M02_MasterTemplete/M02_Material_Pick.ts | 19 ++--- M02_MasterTemplete/M02_MyMachine.py | 61 +++++----------- M02_MasterTemplete/M02_MyMachine_Api.ts | 26 ++++--- M02_MasterTemplete/M02_MyMachine_Router.py | 73 ++++++++++++++++++- M02_MasterTemplete/M02_MyMaterial_Api.ts | 29 +++++--- M02_MasterTemplete/M02_MyMaterial_View.ts | 15 +++- M02_MasterTemplete/M02_Template_Layers.py | 11 ++- .../tester/fixtures/m02_858_shelf_golden.json | 8 +- resources/tester/test_826_2_machine_files.py | 18 ----- .../tester/test_854_1_my_machine_lock.py | 15 +++- resources/tester/test_m02_material_own.py | 34 +++++---- 15 files changed, 223 insertions(+), 201 deletions(-) diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index 468cb5b8f..c363d7921 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -34,8 +34,8 @@ from M02_MasterTemplete import M02_Template_Layers as layers if TYPE_CHECKING: from M02_MasterTemplete.M02_Labor_Expand import Expand -PREFIX = {"precombo": "SC", "sangeun": "SK"} -TITLE = {"precombo": "사전조합", "sangeun": "단가산출"} +PREFIX = {k: layers.SHELF[k]["머리"] for k in layers.LIBRARY_KINDS} # 종류 표 한 벌(858 5-6) +TITLE = {k: layers.SHELF[k]["이름"] for k in layers.LIBRARY_KINDS} DEPTH = 8 # 참조 깊이 상한(저장 · 계산 둘 다) REF_HEAD = "참조|" _KEY = re.compile(r"^(SP|SC|SK)-(\d{6})$") @@ -352,11 +352,12 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None: _no_loop(child, [*trail, child]) -#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻) +#: 층 뿌리 번호 장부 {칸: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻) · +#: 칸 = 종류 표 `번호`(SK · SC · 내 기계 · 858 5-6) ISSUED = "_번호.json" -def _issued() -> dict[str, Any]: +def issued() -> dict[str, Any]: try: got = json.loads((store.root() / ISSUED).read_bytes()) except (OSError, ValueError): @@ -368,18 +369,18 @@ def next_key(kind: str) -> str: """지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1).""" folder = store.root() / kind have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))] - return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}" + book = int(issued().get(layers.SHELF[kind]["번호"]) or 0) + return f"{PREFIX[kind]}-{max(*have, book, 0) + 1:06d}" -def _keep_issued(kind: str, key: str) -> None: - """장부에 발급한 번호(더 클 때만).""" +def keep_issued(book: str, n: int) -> None: + """장부 `book` 칸에 발급한 번호(더 클 때만).""" from common_util.common_util_json import atomic_write_json - n = int(_KEY.match(key).group(2)) with store._LOCK: - got = _issued() - if int(got.get(kind) or 0) < n: - atomic_write_json(store.root() / ISSUED, {**got, kind: n}) + got = issued() + if int(got.get(book) or 0) < n: + atomic_write_json(store.root() / ISSUED, {**got, book: n}) def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: @@ -392,7 +393,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]: if e.status != 409 or not isinstance(e.detail, dict): raise else: - _keep_issued(kind, key) + keep_issued(layers.SHELF[kind]["번호"], int(_KEY.match(key).group(2))) return got raise _bad("새 키를 못 잡음 — 다시 누름", 409) diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py index 2b8253dfc..739fbe262 100644 --- a/M02_MasterTemplete/M02_Labor_Router.py +++ b/M02_MasterTemplete/M02_Labor_Router.py @@ -2,7 +2,7 @@ 문서 읽기 · 쓰기는 양식 길(`GET/PUT /api/m02/layers/{층}/templates/labor/{열}`) 그대로 · 여기는 저장하지 않는 셈만 + 서고(단가승격 · 사전조합 · 50-3) 새로 · 복사(키는 서버가 줌 · 고침 · -지우기는 양식 길 그대로) + 개인 자재 목록 · 추가(148-2 · 개인 층만 · 품번은 서버) + +지우기는 양식 길 그대로) + 내 재료 길은 `M02_MyMachine_Router`(858 5-6) + 서고 나무 자유 폴더(158-1 · 716-4 `{종류}-tree` · `M02_Precombo_Folders` · 읽기 = 층 읽기 · 고침 = 층 쓰기) + 일위대가 실무자료 길 = `M02_Hopyo_Router`(785-5). @@ -24,7 +24,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Layer_Access as access from M02_MasterTemplete import M02_Library_Ask as library_ask from M02_MasterTemplete import M02_MasterTemplete_Store as store -from M02_MasterTemplete import M02_Material_Own as own from M02_MasterTemplete import M02_Precombo_Folders as pre_folders from M02_MasterTemplete.M02_MasterTemplete_Router_Items import ( Layer, @@ -162,65 +161,3 @@ def paste_library_tree( target = _root(session, layer, owner, write=True) source = _root(session, body.from_layer, body.from_owner) return _call(target, pre_folders.paste, source, body.대상, body.경로, kind) - - -@router.get("/layers/{layer}/materials") -def own_materials( - layer: Layer, - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록 · 줄마다 쓰는 곳(840-4).""" - if layer != "personal": - return {"줄": []} - folder = _root(session, layer, owner) - rows = own.rows(folder) - 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]} - - -@router.post("/layers/{layer}/materials") -def new_material( - layer: Layer, - body: dict[str, Any], - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """신규 자재(148-2) — `{이름, 규격, 단위, 값}` → 새 줄(품번 `PM` + 6자리 서버 일련) · - 개인 층만.""" - if layer != "personal": - raise HTTPException(status_code=400, detail="신규 자재는 개인 층에서만") - folder = _root(session, layer, owner, write=True) - return _call(folder, own.add, folder, body) - - -@router.put("/layers/{layer}/materials/{key}") -def edit_material( - layer: Layer, - key: str, - body: dict[str, Any], - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """내 재료 고침(840-4) — `{이름, 규격, 단위, 값}` · 키 그대로 · 개인 층만.""" - if layer != "personal": - raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") - folder = _root(session, layer, owner, write=True) - return _call(folder, own.update, folder, key, body) - - -@router.delete("/layers/{layer}/materials/{key}") -def drop_material( - layer: Layer, - key: str, - owner: str | None = None, - session: Session = Depends(verify_session), -) -> dict: - """내 재료 지움(840-4) — 쓰는 곳 있으면 409 · 개인 층만.""" - if layer != "personal": - raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") - folder = _root(session, layer, owner, write=True) - _call(folder, own.remove, folder, key) - return {"ok": True} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts index 0965708ec..399ec0357 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts @@ -474,8 +474,8 @@ export function openFindPicker(opt: FindPickOptions): void { .catch(fail); if (opt.mineMat && ok("material")) void listMyMaterials(opt.mineMat.owner) - .then((rows) => { - mats = rows; + .then((got) => { + mats = got.줄; draw(); }) .catch(fail); diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index c7cad14a8..ea946596b 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -9,6 +9,8 @@ 840-4 내 재료 = M01 재료 DB 에 없는 자재를 등록하는 자리 — M01 과 이름 · 규격 · 단위가 같으면 막음(409) · 고치기 · 지우기(쓰는 곳 있으면 막음) · 단가산출 셈 색인에 M01 재료처럼 얹음(`whole` · `M02_Sangeun_Copy.whole_`) → 프로젝트 층 밖 SK 는 값이 바뀌면 자동 따라옴(836-2 `M02_Sk_AutoRenew`) · 프로젝트 층 = 사본 값. +858 5-6 — 자리 · 머리 = 서고 종류 표(`Template_Layers.SHELF`) · 판 = 파일 바이트 지문(`version`) · 고칠 때 연 판이 +다르면 409 {stale, 판, 까닭}(한 파일 + 판 · 브레인 정함) · 길 = `M02_MyMachine_Router`(내 기계와 한 묶음). """ from __future__ import annotations @@ -23,8 +25,7 @@ from common_util.common_util_json import atomic_write_json from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Template_Layers as layers -FILE = "개인자재.json" -PREFIX = "PM" +FILE, PREFIX = layers.SHELF["my-material"]["자리"], layers.SHELF["my-material"]["머리"] KEY = re.compile(rf"^{PREFIX}(\d{{6}})$") FIND = re.compile(rf"(? dict[str, Any]: return got -def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]: - """내 재료 한 줄 고침(키 그대로) — 없는 키 = 404 · 검사는 새로 만들기와 같음.""" +def version(folder: str | Path) -> str: + """내 재료 파일 판(바이트 지문 · 없으면 빈 글).""" + path = Path(folder) / FILE + return store.version_of(path.read_bytes()) if path.is_file() else "" + + +def update( + folder: str | Path, key: str, body: dict[str, Any], ver: str | None = None +) -> dict[str, Any]: + """내 재료 한 줄 고침(키 그대로) — 없는 키 = 404 · 검사는 새로 만들기와 같음 · `ver`(화면이 연 판)가 + 지금 판과 다르면 409 {stale, 판, 까닭}(None = 대조 없음).""" with store._LOCK: + if ver is not None and (have := version(folder)) != ver: + why = "다른 곳에서 먼저 고침 — 목록을 다시 읽고 고침" + raise store.StoreError(409, {"stale": [key], "판": have, "까닭": why}) doc = read(folder) at = next((i for i, r in enumerate(doc["줄"]) if r.get("키") == key), None) if at is None: diff --git a/M02_MasterTemplete/M02_Material_Pick.ts b/M02_MasterTemplete/M02_Material_Pick.ts index c9eb8297c..3e2933f3c 100644 --- a/M02_MasterTemplete/M02_Material_Pick.ts +++ b/M02_MasterTemplete/M02_Material_Pick.ts @@ -11,7 +11,7 @@ import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements"; import { openModal } from "@ui/ui_template_modal"; import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch"; -import { call } from "./M02_MasterTemplete_Api_Fetch"; +import { addMyMaterial, listMyMaterials } from "./M02_MyMaterial_Api"; import { createUnitPick, NO_UNIT } from "@ui/ui_template_unit_pick"; import { createBadge } from "@ui/ui_template_badge"; import { createText } from "@ui/ui_template_text"; @@ -60,8 +60,6 @@ const TEXT = { needName: "품명 · 단위는 꼭 적음", }; -const ownPath = (own: OwnLayer): string => - `/layers/personal/materials${own.owner ? `?owner=${encodeURIComponent(own.owner)}` : ""}`; const toItem = (r: OwnRow): MaterialItem => ({ 코드: r.키, 이름: r.이름, @@ -78,7 +76,7 @@ const matches = (r: OwnRow, words: string[]): boolean => { export function pickMaterial(done: (item: MaterialItem) => void, own?: OwnLayer): void { let mine: OwnRow[] = []; const loaded = own - ? call<{ 줄: OwnRow[] }>(ownPath(own)) + ? listMyMaterials(own.owner) .then((d) => void (mine = d.줄)) .catch(() => undefined) : Promise.resolve(); @@ -225,14 +223,11 @@ function newForm( const raw = price.input.value.trim(); try { saved( - await call(ownPath(own), { - method: "POST", - body: JSON.stringify({ - 이름, - 규격: spec.input.value.trim(), - 단위: unit, - 값: raw === "" ? null : Number(raw), - }), + await addMyMaterial(own.owner, { + 이름, + 규격: spec.input.value.trim(), + 단위: unit, + 값: raw === "" ? null : Number(raw), }), ); } catch (e) { diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index 141e483b0..a2e9b8526 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -1,7 +1,7 @@ """M02 내 기계(PLAN 821-1 · 요구 795 · 요구서_796 3 · 7 장) — 개인 층 기계 줄 목록 · 서버 단독. -저장 = 층 뿌리 폴더 `내기계/` — 한 대 한 파일 `<키>.json`(줄) + `_다음.json` {다음: 수}(826-2 · - 옛 `내기계.json` {줄, 다음} 은 읽을 때 한 번 옮기고 지움) — 줄 = M01 기계 줄 꼴 +저장 = 층 뿌리 폴더 `내기계/` — 한 대 한 파일 `<키>.json`(줄 · 826-2) · 번호 = 층 번호 장부 `_번호.json` + 「내기계」 칸(서고 종류 표 `Template_Layers.SHELF` · `Labor_Ref.issued` · 858 5-6) — 줄 = M01 기계 줄 꼴 {키 `EQP{사용자}-####`, 원문번호 「개인 {키}」, 원문 · 구분 · 출처 = 개인, 상세구분 · 이름, 규격, 단위, 값, 비고, 방식 바로|품셈|직접, 시간당?(직접 {노무비, 재료비, 경비}), 넣은날, 고친날, 본뜬?} 값 칸 이름 = M01 기계 줄과 같음 · 바로 = 손료계수 한 칸 · 품셈 = 비율 다섯 → 계수 넷(저장 때 서버가 @@ -23,7 +23,6 @@ from __future__ import annotations import json import os import re -import threading from collections.abc import Callable from contextvars import ContextVar from datetime import datetime @@ -34,9 +33,10 @@ from typing import Any from common_util.common_util_json import atomic_write_json from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Template_Layers as layers -FILE, DIR, NEXT = "내기계.json", "내기계", "_다음.json" # FILE = 옛 한 파일(옮기기만) -PREFIX, NO = "EQP", "개인 " +_SHELF = layers.SHELF["my-machine"] # 서고 종류 표(858 5-6) +DIR, PREFIX, NUMBER, NO = _SHELF["자리"], _SHELF["머리"], _SHELF["번호"], "개인 " FIND = re.compile(rf"{NO}({PREFIX}\d+-\d+)") # 문서 안 기계 입력 「개인 EQP…」 EASY, BOOK, DIRECT = "바로", "품셈", "직접" COSTS = ("노무비", "재료비", "경비") @@ -57,9 +57,9 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199" FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b) -#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게) -# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로 -_LOCK = threading.RLock() +#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 서고 쓰기 잠금 한 벌(`store._LOCK` · RLock · 858 5-6 — +#: 층 번호 장부를 SK · SC 와 같이 씀 · `Store.write` 안 불러오기가 `create` 를 불러도 교착 없음) +_LOCK = store._LOCK #: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음 @@ -96,21 +96,6 @@ def _order(path: Path) -> tuple: return (head, int(n) if n.isdigit() else 0, path.stem) -def _move(folder: Path | None = None) -> None: - """옛 한 파일 `내기계.json` → 폴더(한 번 · 내용 같음 · 옛 파일 지움).""" - old = Path(folder or store.root()) / FILE - if not old.is_file(): - return - got = _load(old) - base = _dir(folder) - for row in got.get("줄") or []: - if isinstance(row, dict) and mine(row.get("키")): - atomic_write_json(base / f"{row['키']}.json", row) - had = int(_load(base / NEXT).get("다음") or 1) # 옛 코드 창이 다시 쓴 옛 파일도 — 번호는 큰 쪽 - atomic_write_json(base / NEXT, {"다음": max(had, int(got.get("다음") or 1))}) - old.unlink() - - def _put(row: dict) -> None: atomic_write_json(_dir() / f"{row['키']}.json", row) @@ -122,33 +107,28 @@ def version(key: str) -> str: def add(build: Callable[[str], dict]) -> dict: - """새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) · - `build(키)` = 저장 줄.""" + """새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — 층 번호 장부 다음 번호 · 이미 있는 파일 번호는 건너뜀 + (덮어쓰기 없음) · 지운 끝 번호 안 다시 씀 · `build(키)` = 저장 줄.""" + from M02_MasterTemplete import M02_Labor_Ref as refs + with _LOCK: - _move() - user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1) + user, n = _user(), int(refs.issued().get(NUMBER) or 0) + 1 while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists(): n += 1 row = build(f"{PREFIX}{user}-{n:04d}") - atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게 + refs.keep_issued(NUMBER, n) # 번호 먼저 — 겹쳐 쓰지 않게 _put(row) return row -def _read(folder: Path | None = None) -> dict[str, Any]: - _move(folder) - base = _dir(folder) - rows = [] - for path in sorted(base.glob(f"{PREFIX}*.json"), key=_order): +def rows(folder: Path | None = None) -> list[dict]: + """지금 층 내 기계 줄(저장 꼴 · 넣은 차례).""" + out = [] + for path in sorted(_dir(folder).glob(f"{PREFIX}*.json"), key=_order): row = _load(path) if isinstance(row, dict) and mine(row.get("키")) and path.stem == row["키"]: - rows.append(row) - return {"줄": rows, "다음": int(_load(base / NEXT).get("다음") or 1)} - - -def rows(folder: Path | None = None) -> list[dict]: - """지금 층 내 기계 줄(저장 꼴).""" - return _read(folder)["줄"] + out.append(row) + return out # ── 셈 색인 ────────────────────────────────────────────────────────── @@ -184,7 +164,6 @@ def _whole(base: Any = None) -> Any: from M02_MasterTemplete import M02_Sangeun_Copy as skc base = m01.loaded()[1] if base is None else base - _move() path = _dir() try: with os.scandir(path) as it: # 폴더 자국 — 대마다 (이름, 시각, 크기) diff --git a/M02_MasterTemplete/M02_MyMachine_Api.ts b/M02_MasterTemplete/M02_MyMachine_Api.ts index a7f10a983..d78b537fc 100644 --- a/M02_MasterTemplete/M02_MyMachine_Api.ts +++ b/M02_MasterTemplete/M02_MyMachine_Api.ts @@ -3,10 +3,11 @@ * M02 내 기계 · 내 품목 서버 호출(PLAN 821-3) — 개인 층만. * 내 기계 = `/layers/personal/my-machines`(821-1 · `M02_MyMachine_Router`) — 목록 · 하나 · 만들기 · 고치기 · 지우기 * 양식 목록 · 비슷한 기계 찾기 · 내 품목 = `M02_MyMachine_Look`(읽기만) + * 길 = 「종류 + 층」 한 함수 `shelfPath`(858 5-6 · 내 재료 `M02_MyMaterial_Api` 도 씀) * ========================================================================== */ import type { MachinePick, MachineValues } from "../common_util/common_util_machine_sheet"; -import { call } from "./M02_MasterTemplete_Api_Fetch"; +import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch"; import type { M01Element } from "./M02_MasterTemplete_Find_Pick"; export type MachineHow = "바로" | "품셈" | "직접"; @@ -91,14 +92,21 @@ export interface MyItem { 쓰는곳: Use[]; } -const at = (owner: string | null, tail = "", q: Record = {}): string => { +/** 내 기계 · 내 재료 길 종류(서버 `M02_MyMachine_Router` · `M02_MyMachine_Look`) */ +export type ShelfKind = "my-machines" | "materials" | "my-machine-find" | "my-items"; + +/** 「종류 + 층」 길 한 함수 — `owner` = 남의 층(없으면 내 층) · `tail` = `/키` 등 · 층 = 지금은 개인 층만 */ +export const shelfPath = ( + kind: ShelfKind, + owner: string | null, + tail = "", + q: Record = {}, + layer: Layer = "personal", +): string => { const ask = new URLSearchParams({ ...q, ...(owner ? { owner } : {}) }).toString(); - return `/layers/personal/my-machines${tail}${ask ? `?${ask}` : ""}`; -}; -const look = (owner: string | null, path: string, q: Record = {}): string => { - const ask = new URLSearchParams({ ...q, ...(owner ? { owner } : {}) }).toString(); - return `/layers/personal/${path}${ask ? `?${ask}` : ""}`; + return `/layers/${layer}/${kind}${tail}${ask ? `?${ask}` : ""}`; }; +const at = (owner: string | null, tail = ""): string => shelfPath("my-machines", owner, tail); const key = (k: string): string => `/${encodeURIComponent(k)}`; export const listMyMachines = async (owner: string | null): Promise => @@ -148,10 +156,10 @@ export const fetchMyMachineLists = (): Promise => })); export const findSimilar = async (owner: string | null, q: string): Promise => - (await call<{ rows: SimilarRow[] }>(look(owner, "my-machine-find", { q }))).rows; + (await call<{ rows: SimilarRow[] }>(shelfPath("my-machine-find", owner, "", { q }))).rows; export const listMyItems = async (owner: string | null): Promise => - (await call<{ rows: MyItem[] }>(look(owner, "my-items"))).rows; + (await call<{ rows: MyItem[] }>(shelfPath("my-items", owner))).rows; /** 단가산출 줄 기계 입력 글(줄 쌓기 `기계='개인 EQP…'`) */ export const machineArg = (no: string): string => `'${no}'`; diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 725d07f61..c7226c8c4 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -5,6 +5,9 @@ POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에 PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · 옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김. +내 재료 길(858 5-6 · `M02_Material_Own` · 길 글자 그대로) = `/api/m02/layers/{층}/materials`(/{키}) — GET 목록 +{줄(줄마다 쓰는곳), 판} · POST 만들기 · PUT 고치기 몸 {이름, 규격, 단위, 값, 판?}(판 다르면 409) · DELETE 지우기 +(쓰는 곳 있으면 409) · 개인 층만(회사 · 마스터 = 빈 목록 · 쓰기 400). 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). """ @@ -13,13 +16,15 @@ from __future__ import annotations from typing import Any -from fastapi import APIRouter, Depends +from fastapi import APIRouter, Depends, HTTPException from pydantic import BaseModel from common_util.common_util_auth import verify_session +from M02_MasterTemplete import M02_Library_Uses as library_uses +from M02_MasterTemplete import M02_Material_Own as own from M02_MasterTemplete import M02_MyMachine as mym from M02_MasterTemplete import M02_MyMachine_Impact as impact -from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root +from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root router = APIRouter(prefix="/api/m02", tags=["M02 My Machine"]) PATH = "/layers/{layer}/my-machines" @@ -85,3 +90,67 @@ def my_machine_delete( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) ): return _call(_folder(session, layer, owner, True), mym.delete, key) + + +# ── 내 재료(858 5-6 · `Labor_Router` 에서 옮김) ────────────────────────── +@router.get("/layers/{layer}/materials") +def own_materials( + layer: Layer, + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록 · 줄마다 쓰는 곳(840-4).""" + if layer != "personal": + return {"줄": []} + folder = _root(session, layer, owner) + rows = own.rows(folder) + used = library_uses.materials(folder, [str(r.get("키")) for r in rows]) + return { + "줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows], + "판": own.version(folder), + } + + +@router.post("/layers/{layer}/materials") +def new_material( + layer: Layer, + body: dict[str, Any], + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """신규 자재(148-2) — `{이름, 규격, 단위, 값}` → 새 줄(품번 `PM` + 6자리 서버 일련) · + 개인 층만.""" + if layer != "personal": + raise HTTPException(status_code=400, detail="신규 자재는 개인 층에서만") + folder = _root(session, layer, owner, write=True) + return _call(folder, own.add, folder, body) + + +@router.put("/layers/{layer}/materials/{key}") +def edit_material( + layer: Layer, + key: str, + body: dict[str, Any], + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """내 재료 고침(840-4) — `{이름, 규격, 단위, 값, 판?}` · 키 그대로 · 개인 층만 · 판 다르면 409(858 5-6).""" + if layer != "personal": + raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") + folder = _root(session, layer, owner, write=True) + return _call(folder, own.update, folder, key, body, body.get("판")) + + +@router.delete("/layers/{layer}/materials/{key}") +def drop_material( + layer: Layer, + key: str, + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """내 재료 지움(840-4) — 쓰는 곳 있으면 409 · 개인 층만.""" + if layer != "personal": + raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") + folder = _root(session, layer, owner, write=True) + _call(folder, own.remove, folder, key) + return {"ok": True} diff --git a/M02_MasterTemplete/M02_MyMaterial_Api.ts b/M02_MasterTemplete/M02_MyMaterial_Api.ts index 477530f6d..28b5bbf29 100644 --- a/M02_MasterTemplete/M02_MyMaterial_Api.ts +++ b/M02_MasterTemplete/M02_MyMaterial_Api.ts @@ -1,10 +1,13 @@ /* ============================================================================= * M02_MyMaterial_Api.ts - * M02 내 재료(개인 자재 PM · PLAN 840-4) 서버 호출 — 개인 층만 · 서버 `M02_Labor_Router` 의 /layers/personal/materials - * 목록(줄마다 쓰는 곳) · 만들기 · 고치기 · 지우기(쓰는 곳 있으면 409) · M01 재료 DB 와 같은 이름 · 규격 · 단위 = 409 + * M02 내 재료(개인 자재 PM · PLAN 840-4) 서버 호출 — 개인 층만 · 서버 `M02_MyMachine_Router` 의 /layers/personal/materials + * (길 = 내 기계와 한 함수 `shelfPath` · 858 5-6) + * 목록(줄마다 쓰는 곳 + 파일 판) · 만들기 · 고치기(연 판 · 다르면 409 `StaleError`) · 지우기(쓰는 곳 있으면 409) + * · M01 재료 DB 와 같은 이름 · 규격 · 단위 = 409 * ========================================================================== */ import { call } from "./M02_MasterTemplete_Api_Fetch"; +import { shelfPath } from "./M02_MyMachine_Api"; export interface MyMaterialUse { 종류: string; @@ -23,13 +26,17 @@ export interface MyMaterial { export type MyMaterialBody = Pick; -const path = (owner: string | null, key = ""): string => - `/layers/personal/materials${key ? `/${encodeURIComponent(key)}` : ""}${ - owner ? `?owner=${encodeURIComponent(owner)}` : "" - }`; +/** 목록 + 파일 판(고칠 때 보냄 · 858 5-6) */ +export interface MyMaterialList { + 줄: MyMaterial[]; + 판?: string; +} -export const listMyMaterials = (owner: string | null): Promise => - call<{ 줄: MyMaterial[] }>(path(owner)).then((d) => d.줄); +const path = (owner: string | null, key = ""): string => + shelfPath("materials", owner, key ? `/${encodeURIComponent(key)}` : ""); + +export const listMyMaterials = (owner: string | null): Promise => + call(path(owner)); export const addMyMaterial = (owner: string | null, body: MyMaterialBody): Promise => call(path(owner), { method: "POST", body: JSON.stringify(body) }); @@ -38,8 +45,12 @@ export const editMyMaterial = ( owner: string | null, key: string, body: MyMaterialBody, + ver?: string, ): Promise => - call(path(owner, key), { method: "PUT", body: JSON.stringify(body) }); + call(path(owner, key), { + method: "PUT", + body: JSON.stringify({ ...body, 판: ver ?? null }), + }); export const dropMyMaterial = (owner: string | null, key: string): Promise => call(path(owner, key), { method: "DELETE" }); diff --git a/M02_MasterTemplete/M02_MyMaterial_View.ts b/M02_MasterTemplete/M02_MyMaterial_View.ts index 7e92db159..a340173c3 100644 --- a/M02_MasterTemplete/M02_MyMaterial_View.ts +++ b/M02_MasterTemplete/M02_MyMaterial_View.ts @@ -5,6 +5,7 @@ * 표 = 이름 · 규격 · 단위 · 값 · 쓰는 곳 · 키 · 줄 누름 = 아래 칸에서 고치기 · [새 자재] = 빈 칸 * [저장] = 서버(M01 과 이름 · 규격 · 단위 같으면 서버가 막음 — 까닭 그대로 알림) · [지우기] = 쓰는 곳 있으면 서버가 막음 * 값을 고치면 그 재료를 쓰는 개인 층 단가산출이 따라옴(836-2 자동 따라옴 · 프로젝트 층 = 사본 값) + * [저장] 고치기 = 목록 때 받은 판을 같이 보냄 — 다른 탭이 먼저 고쳤으면 서버 409 → 까닭 알림 · 칸 닫고 다시 읽음(858 5-6) * 남의 층(owner 있음) = 읽기만 * ========================================================================== */ @@ -13,6 +14,7 @@ import { createDataTable } from "@ui/ui_template_data_table"; import { createInputField, el, showConfirmDialog, showToast } from "@ui/ui_template_elements"; import { createText } from "@ui/ui_template_text"; import { createUnitPick, NO_UNIT } from "@ui/ui_template_unit_pick"; +import { StaleError } from "./M02_MasterTemplete_Api_Fetch"; import { addMyMaterial, dropMyMaterial, @@ -50,6 +52,7 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement { const canWrite = opt.owner === null; let rows: MyMaterial[] = []; let editing: MyMaterial | null = null; + let ver: string | undefined; // 목록 때 받은 파일 판(858 5-6) let unit = ""; const table = createDataTable({ caption: TEXT.title, @@ -128,10 +131,12 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement { form.hidden = true; } async function load(): Promise { - rows = await listMyMaterials(opt.owner).catch((e) => { + const got = await listMyMaterials(opt.owner).catch((e) => { showToast(e instanceof Error ? e.message : String(e), "error"); - return []; + return { 줄: [] as MyMaterial[], 판: undefined }; }); + rows = got.줄; + ver = got.판; table.setRows(rows.map((r) => ({ ...r, 쓰는곳: r.쓰는곳?.length ?? 0 }))); } async function save(): Promise { @@ -146,13 +151,17 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement { }; saveBtn.disabled = true; try { - if (editing) await editMyMaterial(opt.owner, editing.키, body); + if (editing) await editMyMaterial(opt.owner, editing.키, body, ver); else await addMyMaterial(opt.owner, body); showToast(TEXT.saved, "success"); close(); await load(); } catch (e) { showToast(e instanceof Error ? e.message : String(e), "error"); + if (e instanceof StaleError && (e.detail as { 판?: string } | null)?.판 !== undefined) { + close(); // 옛 판 — 다른 곳 고침을 덮지 않게 다시 읽음 + await load(); + } } finally { saveBtn.disabled = false; } diff --git a/M02_MasterTemplete/M02_Template_Layers.py b/M02_MasterTemplete/M02_Template_Layers.py index 9513f016f..1e765d04f 100644 --- a/M02_MasterTemplete/M02_Template_Layers.py +++ b/M02_MasterTemplete/M02_Template_Layers.py @@ -30,7 +30,16 @@ LAYERS = ("system", "company", "personal", "project") # labor = 일위대가(구조물 열마다 · `M02_Labor_Doc`) # precombo = 사전조합(SC-) — 일위대가 사전조합 서고(`M02_Labor_Ref` · 옛 단가승격 promote 는 134-2 에서 뺌) # sangeun = 단가산출(SK- · 715-2 · 꼴 `M02_Sangeun_Doc`) -LIBRARY_KINDS = ("precombo", "sangeun") +#: 서고 종류 표(858 5-6 · 설계 2-2) — 자리 = 층 안 폴더 · 파일 / 머리 = 키 머리 / 이름 = 화면 이름 / +#: 번호 = 층 `_번호.json` 칸(지운 끝 번호 안 다시 씀 · 없음 = 전 층 최대 + 파일 `마지막`) / 나무 = `{종류}_폴더.json` · +#: 내 기계 · 내 재료 = 개인 층만 +SHELF: dict[str, dict[str, Any]] = { + "precombo": {"자리": "precombo", "머리": "SC", "이름": "사전조합", "번호": "precombo", "나무": True}, + "sangeun": {"자리": "sangeun", "머리": "SK", "이름": "단가산출", "번호": "sangeun", "나무": True}, + "my-machine": {"자리": "내기계", "머리": "EQP", "이름": "내 기계", "번호": "내기계", "나무": False}, + "my-material": {"자리": "개인자재.json", "머리": "PM", "이름": "내 재료", "번호": None, "나무": False}, +} # fmt: skip +LIBRARY_KINDS = tuple(k for k, v in SHELF.items() if v["나무"]) # ("precombo", "sangeun") KINDS = ("table", "drawing", "structure", "labor", "area", *LIBRARY_KINDS) TEMPLATES_DIRNAME = "templates" INITIAL_DIRNAME = "_initial" diff --git a/resources/tester/fixtures/m02_858_shelf_golden.json b/resources/tester/fixtures/m02_858_shelf_golden.json index 4c4f06cd4..88f130d02 100644 --- a/resources/tester/fixtures/m02_858_shelf_golden.json +++ b/resources/tester/fixtures/m02_858_shelf_golden.json @@ -31,9 +31,9 @@ "공유.요청": "762ba10d5af57643", "권한.같은회사남": "2d3d50a90583497d", "권한.남의회사관리": "a1213c908c70528f", - "권한.시스템": "504e7d86285faeb9", - "권한.일반": "10c970d97dc81571", - "권한.회사관리": "d1435cf9f015fbc7", + "권한.시스템": "62482b9feacef35d", + "권한.일반": "1c5a65215f7e254e", + "권한.회사관리": "c08e29bffd8dd114", "내기계.고치기": "3f00365dbfb77cee", "내기계.만들기": "20f5562f02c276f8", "내기계.목록": "064102da4c9740d6", @@ -43,7 +43,7 @@ "내기계.찾기": "feca2de012a206ee", "내재료.고치기": "60c0d3337d7dde06", "내재료.만들기": "9fec4ce2a9bbfb82", - "내재료.목록": "9c5929426719e9ae", + "내재료.목록": "c653f76fd62ed174", "내재료.지우기": "9c194d1b5367920e", "항목.나무": "abb5815352e81102", "항목.목록": "f7ff1a6372bf308f", diff --git a/resources/tester/test_826_2_machine_files.py b/resources/tester/test_826_2_machine_files.py index 6ba1edb8c..ffa0d0836 100644 --- a/resources/tester/test_826_2_machine_files.py +++ b/resources/tester/test_826_2_machine_files.py @@ -2,7 +2,6 @@ ① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜 ② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409 -③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움) ④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 오류 목록(견본 고침 스물) 기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 로직 · 조합)마다 하나 이상 아홉(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1` """ @@ -19,7 +18,6 @@ import pytest from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Cache as cache -from M02_MasterTemplete import M02_MyMachine as mym ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT / "resources" / "master_data" / "scripts")) @@ -115,22 +113,6 @@ def test_one_machine_one_file(master: Path) -> None: assert e.value.status == 409 and e.value.detail == {"stale": [M]} -# ③ 내 기계 옮김 ─────────────────────────────────────────────────────── -def test_my_machine_moves_once(tmp_path: Path) -> None: - rows = [{"키": f"EQP42-{n:04d}", "이름": f"sub1임시{n}", "값": {"가격": n}} for n in (1, 2, 10)] - old = {"줄": rows, "다음": 11} - (tmp_path / mym.FILE).write_text(json.dumps(old, ensure_ascii=False), encoding="utf-8") - got = mym._read(tmp_path) - assert got == old and not (tmp_path / mym.FILE).exists() # 내용 · 차례 같음 · 옛 파일 지움 - assert sorted(p.name for p in (tmp_path / mym.DIR).iterdir()) == [ - "EQP42-0001.json", "EQP42-0002.json", "EQP42-0010.json", mym.NEXT, - ] # fmt: skip - assert mym._read(tmp_path) == old and mym.rows(tmp_path) == rows - assert mym._read(tmp_path / "없음") == {"줄": [], "다음": 1} - (tmp_path / mym.FILE).write_text(json.dumps({"줄": [], "다음": 5}), encoding="utf-8") - assert mym._read(tmp_path)["다음"] == 11 # 옛 코드가 다시 쓴 옛 파일 — 번호 뒤로 안 감 - - # ④ 저장 검사 좁히기 = 옛 길과 같은 오류 ───────────────────────────────── def _old_check(files: dict, changed: list[str], book: dict, narrowed) -> list[str]: """826-2 전 `Store_Cache.check_saved` 그대로 — 폴더 전부 색인 · 틀 · 조합 · 모든 층 문서.""" diff --git a/resources/tester/test_854_1_my_machine_lock.py b/resources/tester/test_854_1_my_machine_lock.py index 0e3c84833..ff2ef4b2b 100644 --- a/resources/tester/test_854_1_my_machine_lock.py +++ b/resources/tester/test_854_1_my_machine_lock.py @@ -2,7 +2,8 @@ """854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침). ① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨 -③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음. +③ 번호 장부(층 `_번호.json` 「내기계」 칸 · 858 5-6)가 뒤처져도 있는 파일 번호를 덮지 않음 · +⑤ 끝 번호를 지운 뒤 새로 만들면 새 번호(SK · PM · 내 기계). """ from __future__ import annotations @@ -15,6 +16,7 @@ import pytest from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_MyMachine as mym +from M02_MasterTemplete.M02_Labor_Ref import ISSUED from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 N = 8 @@ -48,7 +50,7 @@ def test_parallel_create_no_clash(world, monkeypatch): assert len(files) == N names = {json.loads(p.read_bytes())["이름"] for p in files} assert names == {f"sub4임시{i}" for i in range(N)} - assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1 + assert json.loads((me / ISSUED).read_bytes())[mym.NUMBER] == N # 층 번호 장부(858 5-6) def test_stale_version_409(world): @@ -68,10 +70,10 @@ def test_stale_version_409(world): def test_counter_behind_skips_file(world): - """③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호.""" + """③ 번호 장부가 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호.""" me = world["personal"] first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"] - (me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8") + (me / ISSUED).write_text(json.dumps({mym.NUMBER: 0}), encoding="utf-8") second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"] assert second != first assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음" @@ -117,3 +119,8 @@ def test_deleted_last_key_not_reused(world): assert keys == ["PM000001", "PM000002"] own.remove(me, keys[-1]) assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003" + + machines = [_at(me, mym.create, _easy(f"sub4임시기계{i}"))["줄"]["키"] for i in range(2)] + _at(me, mym.delete, machines[-1]) + again = _at(me, mym.create, _easy("sub4임시기계3"))["줄"]["키"] + assert again not in machines and again.endswith("-0003") # 내 기계도(858 5-6) diff --git a/resources/tester/test_m02_material_own.py b/resources/tester/test_m02_material_own.py index a20d6b2a6..59e34f4c0 100644 --- a/resources/tester/test_m02_material_own.py +++ b/resources/tester/test_m02_material_own.py @@ -4,6 +4,7 @@ - 품번 = 모든 사람 통틀어 한 줄 번호(두 사람 · 두 회사 안 겹침) · 화면이 보낸 키는 안 받음 - 품명 · 단위 빈 = 400 · 단가 = 0 이상 수 또는 빈 값 · 같은 품명 + 규격 + 단위 = 409 - 개인 층만(회사 = 빈 목록 · 추가 400) · 남의 개인 층 = 403 +- 고치기 판(858 5-6) — 목록 판으로 고침 = 됨 · 옛 판 = 409 {stale, 판, 까닭} · 막힌 고침은 안 적힘 층은 임시 폴더(마스터 · storage). """ @@ -18,9 +19,9 @@ from fastapi.testclient import TestClient from common_util.common_util_auth import verify_session from config import config_system -from M02_MasterTemplete import M02_Labor_Router as labor_router from M02_MasterTemplete import M02_MasterTemplete_Store as store from M02_MasterTemplete import M02_Material_Own as own +from M02_MasterTemplete import M02_MyMachine_Router as machine_router from M02_MasterTemplete import M02_Template_Layers as layers from resources.tester.test_m02_structure import write_sample_table @@ -39,7 +40,7 @@ def world(tmp_path, monkeypatch) -> dict[str, Any]: monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(tmp_path / "storage")) session: dict[str, Any] = {"user_id": 42, "company_id": 7, "role": "USER", "is_master": False} app = FastAPI() - app.include_router(labor_router.router) + app.include_router(machine_router.router) # 내 재료 길 = 내 기계 묶음(858 5-6) app.dependency_overrides[verify_session] = lambda: session return {"client": TestClient(app), "session": session} @@ -100,6 +101,21 @@ def test_회사_층은_빈_목록_추가_400_남의_개인_403(world): assert other.post(URL.format("personal") + "?owner=7/42", json=BOLT).status_code == 403 +def test_옛_판으로_고치면_409_고침_안_적힘(world): + c = _as(world, 42) + key = c.post(URL.format("personal"), json=BOLT).json()["키"] + old = c.get(URL.format("personal")).json()["판"] + one = c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 1500, "판": old}) + assert one.status_code == 200, one.text + new = c.get(URL.format("personal")).json()["판"] + assert new and new != old + two = c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 9999, "판": old}) + assert two.status_code == 409 + assert two.json()["detail"]["stale"] == [key] and two.json()["detail"]["판"] == new + assert c.get(URL.format("personal")).json()["줄"][0]["값"] == 1500 + assert c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 7}).status_code == 200 + + # ── 148-3 — 저장 검사 · 셈 · 사본 · 층 사이 · 개인에 저장 ────────────── @@ -215,17 +231,3 @@ def test_개인에_저장은_사본_개인_줄을_내_목록에_같은_키(world doc = store.read("labor", made["열"])["문서"] assert doc["자재"][0]["코드"] == key assert own.rows(b) == own.rows(a) - - -def test_화면_신규_자재는_머리_단추_개인_층만(): - """148-3 — [신규 자재] = 공용 모달 `actions`(개인 층만) · 품번은 안 보냄 · 상세는 개인 층에만 넘김.""" - import os - - here = os.path.join(os.path.dirname(__file__), "..", "..", "M02_MasterTemplete") - pick = open(os.path.join(here, "M02_Material_Pick.ts"), encoding="utf-8").read() - assert "...(own ? { actions: [newButton] } : {})" in pick - assert ( - "`/layers/personal/materials" in pick and "키:" not in pick.split("JSON.stringify")[1][:200] - ) - detail = open(os.path.join(here, "M02_MasterTemplete_Labor_Detail.ts"), encoding="utf-8").read() - assert "addMaterialButton" not in detail # 736-1 [자재 추가] 단추 걷음 — 재료는 찾아 넣기 창 From 1877d4ee674b57c91c93a2c2acff939830e23b6c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:40:45 +0900 Subject: [PATCH 8/9] =?UTF-8?q?test(855-F=20B9-6):=20B08=20=C2=B7=20B09=20?= =?UTF-8?q?=EC=82=AC=EB=B3=B8=20=EA=B2=AC=EB=B3=B8=EC=9D=84=20=EC=83=88=20?= =?UTF-8?q?=EA=BC=B4=EB=A1=9C=20=E2=80=94=20=EC=88=98=EC=8B=9D.json=20+=20?= =?UTF-8?q?=EC=9E=90=EC=9B=90=20=EC=A4=84=20=EB=8B=A8=EA=B0=80.json(?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20=EC=A4=84=20=EC=97=86=EC=9D=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 저장소 사본 전수 = 0(단가.json · 수식.json · 일위대가.json 사본 파일 없음) — 옛 꼴(단가.json 에 로직 줄 · 수식.json 없음) 사본은 견본에만 있어 실제 build_source 꼴로 바꿈 - test_145_2.copy_files(로직 키 → 수식.json 닫힌 문서 + Item_Bundle.collect 단가.json) 한 곳 · 145_2 _snap · 144 · 155 · 166_2 · 705_1 이 씀 - 검증: 바꾼 다섯 파일 38 통과 Co-Authored-By: Claude Opus 5.5 --- resources/tester/test_144_b09_skeleton.py | 5 ++--- resources/tester/test_145_2_b09_labor_calc.py | 21 +++++++++++++------ resources/tester/test_155_b09_sources.py | 3 +-- resources/tester/test_166_2_b09_bill_hand.py | 4 ++-- resources/tester/test_705_1_fixed_line.py | 3 ++- 5 files changed, 22 insertions(+), 14 deletions(-) diff --git a/resources/tester/test_144_b09_skeleton.py b/resources/tester/test_144_b09_skeleton.py index 08be64184..5e5bb8f76 100644 --- a/resources/tester/test_144_b09_skeleton.py +++ b/resources/tester/test_144_b09_skeleton.py @@ -116,11 +116,10 @@ def test_연결_없으면_빈_표와_연결_없음(tmp_path, monkeypatch): def test_연결된_사본이_부른_자원만(tmp_path): """사본 단가 묶음 통째(고르기 후보 기계 100여)가 아니라 로직이 실제로 부른 줄만.""" from B09_Estimation.B09_Estimation_Linked import used_keys - from M02_MasterTemplete import M02_Item_Prices as item_prices + from resources.tester.test_145_2_b09_labor_calc import copy_files - bundle = item_prices.to_json(item_prices.collect(["GC000268"])) # 기계 시간당 기계경비 files = { - "단가.json": bundle, + **copy_files(["GC000268"]), # 기계 시간당 기계경비 · 사본 = 수식 문서 + 자원 줄(855-F B9-6) "일위대가.json": {"줄": {"종류": "일위대가", "담은로직": [{"로직": "GC000268"}]}}, "입력값.json": {"GC000268": {"기계": {"값": "0101-0019"}, "지역": {"값": "전국평균"}}}, } diff --git a/resources/tester/test_145_2_b09_labor_calc.py b/resources/tester/test_145_2_b09_labor_calc.py index 06ecb9edd..ace32872e 100644 --- a/resources/tester/test_145_2_b09_labor_calc.py +++ b/resources/tester/test_145_2_b09_labor_calc.py @@ -250,6 +250,19 @@ def _values(given): return {"GF000219": {k: {"값": v} for k, v in given.items()}} +def copy_files(codes, materials=None) -> dict: + """사본 셈 파일 견본 — `수식.json`(로직 키 닫힌 문서) + `단가.json`(그 문서 · 자재가 잇는 자원 줄 · + 로직 줄 없음 · 855-F B9-6 · `M02_Item_Source.build_source` 꼴).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure(item_prices.master()[1], codes) + return { + "수식.json": item_prices.to_json({"그룹": "수식문서", "문서": docs}), + "단가.json": item_prices.to_json(item_bundle.collect(docs, materials)), + } + + def _snap(root, owner, key, lines, values, copies=None): folder = snapshots.structures_dir(root) / snapshots.folder_name(owner) folder.mkdir(parents=True) @@ -260,12 +273,8 @@ def _snap(root, owner, key, lines, values, copies=None): for doc in (copies or {}).values(): codes += [one["로직"] for one in doc["담은로직"] if "로직" in one] write(snapshots.MANIFEST_NAME, {"원본": {**_item(key), "경로": ["기슭막이", key]}}) - from M02_MasterTemplete import M02_Doc_Copy as dc - from M02_MasterTemplete import M02_Item_Bundle as item_bundle - - docs = dc.closure(item_prices.master()[1], codes) # 사본 = 수식 문서 + 자원 줄(855-F B9-6) - write("수식.json", item_prices.to_json({"그룹": "수식문서", "문서": docs})) - write("단가.json", item_prices.to_json(item_bundle.collect(docs))) + for name, data in copy_files(codes).items(): + write(name, data) doc = {"종류": "일위대가", "단위": "m", "담은로직": lines, "자재": []} write("일위대가.json", {"줄": doc, **({"참조사본": copies} if copies else {})}) write("입력값.json", values) diff --git a/resources/tester/test_155_b09_sources.py b/resources/tester/test_155_b09_sources.py index 54791d24b..7a8b56536 100644 --- a/resources/tester/test_155_b09_sources.py +++ b/resources/tester/test_155_b09_sources.py @@ -23,7 +23,6 @@ from B09_Estimation.B09_Estimation_Calc_Labor import compute_labor # noqa: E402 from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs # noqa: E402 from B09_Estimation.B09_Estimation_Linked import linked_resource_keys # noqa: E402 from B09_Estimation.B09_Estimation_Router import compute_sheets # noqa: E402 -from M02_MasterTemplete import M02_Item_Prices as item_prices # noqa: E402 PILE = "GF000233" # 말뚝 다듬기 — 원/10개(배 10) · 인력 줄 둘 PIPE = "GF000174" # 흄관 부설 — 하위 로직 줄(GF000155 · GF000160) = 하위 산근 @@ -83,7 +82,7 @@ def test_155_4_산근_자재_자리표시_키_대비표로(tmp_path): folder = tmp_path / "a" folder.mkdir() files = { - "단가.json": item_prices.to_json(item_prices.collect([FUEL])), + **t145.copy_files([FUEL]), # 사본 = 수식 문서 + 자원 줄(855-F B9-6) "일위대가.json": {"줄": {"종류": "일위대가", "담은로직": [{"로직": FUEL}]}}, "입력값.json": {}, } diff --git a/resources/tester/test_166_2_b09_bill_hand.py b/resources/tester/test_166_2_b09_bill_hand.py index 983b62914..99ca94eeb 100644 --- a/resources/tester/test_166_2_b09_bill_hand.py +++ b/resources/tester/test_166_2_b09_bill_hand.py @@ -22,7 +22,7 @@ from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 from B09_Estimation.B09_Estimation_Calc_Bill import WHY_LOGIC, compute_estimation # noqa: E402 from B09_Estimation.B09_Estimation_Store import clean_user # noqa: E402 from B09_Estimation.B09_Estimation_Summary import compute_summary, hopyo_lines # noqa: E402 -from M02_MasterTemplete import M02_Item_Prices as item_prices # noqa: E402 +from resources.tester.test_145_2_b09_labor_calc import copy_files # noqa: E402 IMPORTS = re.compile(r"^import[^;]*;\n", re.MULTILINE) STONE = "GF000219" # 돌쌓기 메쌓기(인력) — 석공 0.195 · 보통인부 0.156 / ㎡ @@ -156,7 +156,7 @@ def test_저장_다듬기_bill(): def _snapshot(folder: Path, rows, values=None) -> Path: folder.mkdir(parents=True, exist_ok=True) files = { - "단가.json": item_prices.to_json(item_prices.collect([STONE, NET])), + **copy_files([STONE, NET]), # 사본 = 수식 문서 + 자원 줄(855-F B9-6) "일위대가.json": {"줄": {"종류": "일위대가", "담은로직": rows}}, "입력값.json": {k: {n: {"값": v} for n, v in d.items()} for k, d in (values or {}).items()}, } diff --git a/resources/tester/test_705_1_fixed_line.py b/resources/tester/test_705_1_fixed_line.py index d52cbf7d9..4565c4f1e 100644 --- a/resources/tester/test_705_1_fixed_line.py +++ b/resources/tester/test_705_1_fixed_line.py @@ -209,7 +209,8 @@ def _snap(root, owner, key, lines): doc = labor.clean({"단위": "m", "담은로직": lines}) codes = [one["로직"] for one in lines if "로직" in one] write(snapshots.MANIFEST_NAME, {"원본": {**b145._item(key), "경로": ["기슭막이", key]}}) - write("단가.json", item_prices.to_json(item_prices.collect(codes, fixed.link_keys(doc)))) + for name, data in b145.copy_files(codes, fixed.link_keys(doc)).items(): # 855-F B9-6 + write(name, data) write("일위대가.json", {"줄": doc}) write("입력값.json", b145._values(b145.STONE)) From 2b038bc410399ca8b1a2efc5b96a2a149e381f5f Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:53:51 +0900 Subject: [PATCH 9/9] =?UTF-8?q?fix(855-F=20B9-6):=20=EC=83=88=20=EB=AA=A8?= =?UTF-8?q?=EB=93=88=20=EB=91=98(Item=5FBundle=20=C2=B7=20B09=20Sheet)?= =?UTF-8?q?=EC=9D=B4=20=EC=B2=98=EC=9D=8C=20=EB=B6=88=EB=A6=B4=20=EB=95=8C?= =?UTF-8?q?=20scripts=20=EA=B8=B8=20=EC=97=86=EC=9D=B4=20=EB=A9=88?= =?UTF-8?q?=EC=B6=94=EB=8D=98=20import=20=EC=B0=A8=EB=A1=80=20=EA=B3=A0?= =?UTF-8?q?=EC=B9=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Item_Bundle · B09_Estimation_Sheet: master_doc · master_basis · master_unit 을 scripts 길을 두는 import(Item_Prices · M01 Store) 뒤로 - 찾은 곳: 화면 검증 중 B08 _folder_units 를 새 프로세스에서 처음 부를 때 ModuleNotFoundError(서버는 다른 모듈이 먼저 길을 둬 안 드러남) - 검증: 두 모듈 새 프로세스 단독 import 통과 · 관련 + 855_b09_golden · 719_4 20 통과 Co-Authored-By: Claude Opus 5.5 --- B09_Estimation/B09_Estimation_Sheet.py | 8 ++++---- M02_MasterTemplete/M02_Item_Bundle.py | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/B09_Estimation/B09_Estimation_Sheet.py b/B09_Estimation/B09_Estimation_Sheet.py index 7d99817f0..d540ec132 100644 --- a/B09_Estimation/B09_Estimation_Sheet.py +++ b/B09_Estimation/B09_Estimation_Sheet.py @@ -14,13 +14,13 @@ import re from decimal import Decimal from typing import Any -import master_basis as mbs # noqa: E402 -import master_doc as md # noqa: E402 -import master_unit as mu # noqa: E402 - from B09_Estimation import B09_Estimation_Doc_Run as dr from M01_MasterData import M01_MasterData_Store as _m01 # noqa: F401 — scripts 길을 둠 +import master_basis as mbs # noqa: E402 — scripts 길(_m01) 뒤에 +import master_doc as md # noqa: E402 +import master_unit as mu # noqa: E402 + _HOLE = re.compile(r"\{([^{}]+)\}") diff --git a/M02_MasterTemplete/M02_Item_Bundle.py b/M02_MasterTemplete/M02_Item_Bundle.py index 2bd426671..674440550 100644 --- a/M02_MasterTemplete/M02_Item_Bundle.py +++ b/M02_MasterTemplete/M02_Item_Bundle.py @@ -14,10 +14,10 @@ from __future__ import annotations import re from typing import Any -import master_doc as md # noqa: E402 — scripts 길 = prices(m01) - from M02_MasterTemplete import M02_Item_Prices as prices +import master_doc as md # noqa: E402 — scripts 길 = prices(m01) 뒤에 + _HOLE = re.compile(r"\{([^{}]+)\}")