diff --git a/M01_MasterData/M01_MasterData_Alias.py b/M01_MasterData/M01_MasterData_Alias.py index 69c2514e8..314c238f4 100644 --- a/M01_MasterData/M01_MasterData_Alias.py +++ b/M01_MasterData/M01_MasterData_Alias.py @@ -80,10 +80,16 @@ def _find(key: str, files: tuple[str, ...] | None = None) -> tuple[str, dict[str def set_alias(key: str, text: str) -> dict[str, Any]: - """그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음).""" - file, _ = _find(key) - data, version = store.read(file) - row = dict(next(r for r in data["줄"] if str(r.get("키")) == key)) + """그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음) · + 단가산출 기초 = 문서 머리(855 L3 ⓐ · `Store_Logic`).""" + doc = store._docs().docs().get(key) + if doc is not None: + file = store._docs().find(key)[0] + version, row = store._docs().file_version(file), store._docs().head_of(doc) + else: + file, _ = _find(key) + data, version = store.read(file) + row = dict(next(r for r in data["줄"] if str(r.get("키")) == key)) row[ALIAS] = text change = {"op": "edit", "key": key, "row": row} make.save([{"file": file, "version": version, "changes": [change]}], True) @@ -109,11 +115,10 @@ def board() -> dict[str, Any]: (str(v.get("키")), ma.norm(v.get(ALIAS))) for v in book.values() if v.get("상태") == "승인" } rows = [] - logic = ( - store._docs().logic_files() - ) # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ) · 파일 차례는 그대로 - for file, data in store.loaded()[0].items(): - data = logic.get(file, {}) if data.get("그룹") == "로직" else data + every = {n: d for n, d in store.loaded()[0].items() if d.get("그룹") != "로직"} + every |= store._docs().logic_files() # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ · L3 ⓐ) + for file in sorted(every): # 파일 이름 차례(마스터 폴더 차례와 같음) + data = every[file] kind = kind_of(file, str(data.get("그룹") or "")) for row in data.get("줄") or []: if not str(row.get(ALIAS) or "").strip(): diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 1b7c086fd..eec60ecf8 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -48,6 +48,12 @@ def version_of(doc: dict | None) -> str: return "" if doc is None else store.version_of(ml.dump(doc).encode("utf-8")) +def file_version(logic_file: str) -> str: + """기초 파일 판(855 L3 ⓐ) — 옛 로직 파일 이름에 짝인 수식 문서 파일 글의 지문 · 없음 = 빈 글.""" + path = folder() / ml.file_of(logic_file) + return store.version_of(path.read_bytes()) if path.is_file() else "" + + def put(path: Path, data: dict) -> None: """수식 문서 파일 한 벌 — 임시 파일 → 교체(원자적) · `_LOCK` 안에서 부름. 마스터만 사본으로 바꾼 시험(`Store.FOLDER` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀.""" @@ -152,18 +158,15 @@ def _check(doc) -> dict: def read(key: str) -> dict: + """기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404.""" found = docs().get(key) - fresh = found is None - if fresh: # 로직 줄은 있고 문서가 없는 키(옛 자료 받침 — 새 로직은 `ensure` 가 문서를 둠) - row = _row(key) - if row is None: - raise store.StoreError(404, f"없는 로직 「{key}」") - found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) + if found is None: + raise store.StoreError(404, f"없는 로직 「{key}」") out = _run(found) - up = None if fresh else built(key) + up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음 more = {"층바탕": {"위": up}} if up is not None else {} - 판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409) - return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more} + 판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409) + return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more} def preview(doc: dict, given: dict | None = None) -> dict: @@ -171,24 +174,15 @@ def preview(doc: dict, given: dict | None = None) -> dict: def _file_for(key: str) -> str: - """문서 파일 — 있던 파일 › 로직 줄이 든 로직 파일 짝(쓰기 짝 · L3 에서 걷음) › 자체.""" - have = _where(key) - if have: - return have - for name, data in store.loaded()[0].items(): - if data.get("그룹") == "로직" and any( - str(r.get("키")) == key for r in data.get("줄") or [] - ): - return ml.file_of(name) - return OWN_FILE + """문서 파일 — 있던 파일 › 자체(새 기초는 자체에만 · 855 L3 ⓐ).""" + return _where(key) or OWN_FILE def _new_file(name: str) -> dict: - """새 문서 파일 머리 — 짝 로직 파일의 이름 · 머리(원문 · 부문 · 차례)를 그대로(목록 분류 정본).""" + """새 문서 파일 머리 — 자체 문서 파일만 새로 생김(원문 = 자체 · 목록 분류 정본).""" logic = "로직_" + name.split("_", 1)[1] - head = store.loaded()[0].get(logic) or {} - tags = {k: head[k] for k in md.FILE_TAGS if k in head} - return {"그룹": "수식문서", "로직파일": logic if head else "", **tags, "줄": []} + tags = {"원문": "자체"} if name == OWN_FILE else {} + return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []} def _row(key: str) -> dict | None: @@ -345,14 +339,14 @@ def save(doc: dict, 판: str | None = None) -> dict: doc = _check(doc) key = str(doc["키"]).strip() with _LOCK: - if (row := _row(key)) is not None: # 이름표 = 로직 줄 것(화면 왕복에 안 지워짐 · 855 L1) - doc = md.tag(doc, row) - doc = layered(doc, key) name = _file_for(key) path = folder() / name data = ml.load_file(path) if path.exists() else _new_file(path.name) rows = data.setdefault("줄", []) at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + if at is not None: # 이름표 = 저장된 문서 것(화면 왕복에 안 지워짐 · 고침은 기초 [저장] 길) + doc = md.tag(doc, rows[at]) + doc = layered(doc, key) if 판 is not None and version_of(None if at is None else rows[at]) != 판: raise store.StoreError(409, STALE.format(v=f"{name} {key}")) if at is None: @@ -428,15 +422,8 @@ def drop(key: str) -> None: def remove(key: str, file: str, version: str, confirmed: bool) -> dict: - """로직 지우기 — 부르는 곳이 있으면 409 {쓰는곳} · 로직 저장 길(개정 확인 · 판 · 검사) 뒤 문서도.""" - from M01_MasterData import M01_MasterData_Store_Make as make + """로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" + from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게 - used = users(key) - if used: - raise store.StoreError(409, {"쓰는곳": used}) - got = make.save( - [{"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}], - confirmed, - ) - drop(key) - return got + part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]} + return logic_store.save([part], confirmed) diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index b4787a23f..2a38b88ca 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -11,7 +11,6 @@ M01 에서 만든 기계(출처 모두 「자체」)를 지우면 그 번호 기 from __future__ import annotations -import copy from decimal import Decimal from typing import Any, Callable @@ -118,20 +117,10 @@ def formula(row: dict) -> dict: return base | ({"키": got["키"], "이름": got.get("이름")} if got else {}) -def _family_files() -> dict[str, str]: - """기계경비식 키 → 로직 파일 이름.""" - return { - str(r.get("키")): name - for name, data in store.loaded()[0].items() - if data.get("그룹") == "로직" and "건설기계" in name - for r in data.get("줄") or [] - } - - def register(batch: list[dict]) -> Callable[[], None]: """[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를 - 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길) · - 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록에도 같은 더함 · 뺌(848-5 · 두 목록 한 벌).""" + 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 · + 848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ).""" from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게 from M02_MasterTemplete import M02_MyMachine as mym @@ -162,23 +151,13 @@ def register(batch: list[dict]) -> Callable[[], None]: drop.add(code) if not add and not drop: return lambda: None - files = _family_files() - for name in dict.fromkeys(files.values()): - changes = [] - for logic in store.read(name)[0].get("줄") or []: - ins = logic.get("입력") or [] - pick = next((i for i in ins if i.get("이름") == "기계" and "고르기" in i), None) - if pick is None: - continue - codes = [c for c in pick["고르기"] if str(c) not in drop] - codes += [c for c in add.get(str(logic["키"]), []) if c not in codes] - if codes != pick["고르기"]: - new = copy.deepcopy(logic) - next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes - changes.append({"op": "edit", "key": logic["키"], "row": new}) - if changes: - batch.append({"file": name, "version": store.read(name)[1], "changes": changes}) - after = lambda: _register_docs(add, drop) # noqa: E731 + + def after() -> None: + from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름) + + _register_docs(add, drop) + logic_store.mirror([], (add, drop)) + after.lists = ( add, drop, diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index 13e79738b..2363f6657 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -48,26 +48,14 @@ class SaveBody(BaseModel): class CopyLogic(BaseModel): + """[복사/생성](본떠 만들기) — 원본 문서를 새 자체 기초로 · 빈 글 = 원본 그대로.""" + key: str 이름: str = "" owner: str = make.OWNERS[0] - - -class FormulaLogic(BaseModel): - """복사해서 만들기 — 별칭 꼴 식이 든 로직 줄과 그 별칭표(되돌릴 원문).""" - - 로직: dict[str, Any] - 별칭: list[dict[str, Any]] = [] - owner: str = make.OWNERS[0] - 이름: str = "" - 본뜬키: str = "" - - -class FormulaPreview(BaseModel): - """저장 전 미리보기 — 별칭을 원문으로 되돌린 로직 줄만 받고 싶을 때(시험 계산 전).""" - - 로직: dict[str, Any] - 별칭: list[dict[str, Any]] = [] + 원문번호: str = "" + 결과단위: str = "" + 출처: str = "" def _num(v): @@ -248,27 +236,8 @@ def post_save(body: SaveBody) -> dict: @router.post("/logic/copy") def post_logic_copy(body: CopyLogic) -> dict: - return _call(make.logic_copy, body.key, body.이름, body.owner) - - -@router.get("/logic/formula") -def get_logic_formula(key: str) -> dict: - """복사해서 만들기 — 로직 한 줄을 별칭 꼴 식 묶음으로.""" - return _call(make.logic_formula, key) - - -@router.post("/logic/formula/save") -def post_logic_formula_save(body: FormulaLogic) -> dict: - """고친 식 묶음을 자체 로직(`GX`)으로 — 별칭은 원문으로 되돌려 저장.""" - return _call(make.logic_from_formula, body.로직, body.별칭, body.owner, body.이름, body.본뜬키) - - -@router.post("/logic/formula/preview") -def post_logic_formula_preview(body: FormulaPreview) -> dict: - """저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄 + 저장하면 지을 수식 문서 - {logic, 문서}(저장 안 함 · 화면은 `문서` 를 `/logic/doc/preview` 로 셈 · 855 2-B4).""" - got = _call(make.logic_formula_preview, body.로직, body.별칭) - return {**got, "문서": doc_screen.of_row(got["logic"])} + more = {"원문번호": body.원문번호, "결과단위": body.결과단위, "출처": body.출처} + return _call(make.logic_copy, body.key, body.이름, body.owner, more) # ── 수식 문서(802-3) — 단가산출 기초 정본 · 화면은 같은 계산기로 즉시 셈 ── @@ -280,7 +249,7 @@ class DocBody(BaseModel): @router.get("/logic/doc") def get_logic_doc(key: str) -> dict: - """수식 문서 {문서, 셈, 연결, 파일, 새} — 없으면 빈 문서(쓰기 없음).""" + """수식 문서 {문서, 셈, 연결, 파일, 새} — 없는 키 = 404(쓰기 없음).""" return _call(doc_screen.read, key) @@ -311,7 +280,7 @@ def get_logic_users(key: str) -> dict: @router.post("/logic/remove") def post_logic_remove(body: RemoveBody) -> dict: - """로직 지우기(804-7) — 로직 줄 + 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}.""" + """로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}.""" return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인) diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index b6b6efb2e..8dcd7421d 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -21,7 +21,6 @@ sys.path.insert(0, str(SCRIPTS)) import check_master as cm # noqa: E402 import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀) import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀) -import master_copy as mcp # noqa: E402,F401 (`_Store_Make` 가 `store.mcp` 로 씀) import master_keys as mk # noqa: E402 import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀) @@ -116,7 +115,7 @@ def _docs(): def files_of(group: str) -> list[dict]: - """로직 = 수식 문서 파일(855 L2 ⓐ) · 판(해) · version 은 로직 파일(저장 409 짝 · L3 에서 문서로).""" + """로직 = 수식 문서 파일(855 L2 ⓐ) · 판 = 문서 파일 머리 · version = 문서 파일 글 지문(855 L3 ⓐ).""" if group not in cm.mf.GROUPS: raise StoreError(404, f"없는 그룹 「{group}」") logic = _docs().logic_files() if group == "로직" else None @@ -124,8 +123,12 @@ def files_of(group: str) -> list[dict]: for name in sorted(logic) if logic is not None else cm.mmf.names(FOLDER): if name != f"{group}.json" and not name.startswith(f"{group}_"): continue - data, version = read(name) - head = data if logic is None else logic[name] + if logic is None: + data, version = read(name) + head = data + else: + data = head = logic[name] + version = _docs().file_version(name) out.append( { "file": name, @@ -390,18 +393,14 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "") def logic(key: str) -> dict: - """로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) · - 셈 칸(입력 · 호표 …) · `version` = 로직 파일(화면 [저장]이 줄째 되돌려 씀 — L3 에서 걷음).""" - files, whole = loaded() + """로직 하나 — 키는 전체에서 하나 · 파일 · `logic` = 수식 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · + 부품 — 화면 [저장]이 이 칸만 되돌려 보냄 · 셈은 줄 쌓기 문서) · `version` = 문서 파일 판(855 L3 ⓐ).""" name, doc = _docs().find(key) - row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {}) - head, named = _docs().head_of(doc), (*_docs().md.TAGS, *_docs().HEAD) - row = {k: head.get(k, v) for k, v in row.items() if k in head or k not in named} | head - reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3) + reasons = cache.reasons(key, loaded()[1]) # 수식 문서 기준(855 2-B3) return { "file": name, - "version": read(name)[1], - "logic": row, + "version": _docs().file_version(name), + "logic": _docs().head_of(doc), "blocked": bool(reasons), "reasons": reasons, } diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py index 230240e04..9af34c9dc 100644 --- a/M01_MasterData/M01_MasterData_Store_Cache.py +++ b/M01_MasterData/M01_MasterData_Store_Cache.py @@ -330,10 +330,11 @@ def _labor_files() -> list[tuple[str, Path]]: ] -def labor_errors(whole, keys=None) -> list[str]: +def labor_errors(whole, keys=None, have=None) -> list[str]: """일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) — 로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은 - `save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶).""" + `save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) · + `have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신).""" out = [] if keys is not None and not keys: return out @@ -350,6 +351,10 @@ def labor_errors(whole, keys=None) -> list[str]: key = str(one.get("로직") or "") if isinstance(one, dict) else "" if not key or (keys is not None and key not in keys): continue + if have is not None: + if key not in have: + out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌") + continue try: whole.logic(key) except cm.mf.FormulaError: diff --git a/M01_MasterData/M01_MasterData_Store_Logic.py b/M01_MasterData/M01_MasterData_Store_Logic.py new file mode 100644 index 000000000..1683b2a09 --- /dev/null +++ b/M01_MasterData/M01_MasterData_Store_Logic.py @@ -0,0 +1,267 @@ +"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898). + +화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로. +- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale} +- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`) +- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장) +- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`) +화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫. +""" + +from __future__ import annotations + +import copy +import os +from pathlib import Path + +from common_util.common_util_time import kst_today +from M01_MasterData import M01_MasterData_Doc as doc_store +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Revise as revise +from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape + +md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm + +#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움 +WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0" +OWN = "로직_자체.json" +FIELDS = revise.FIELDS +CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) + + +def is_logic(file: str) -> bool: + return file.startswith("로직_") and file.endswith(".json") + + +def head(row: dict) -> dict: + """화면이 보낸 줄에서 쓸 칸 — 키 · 이름표 · 머리.""" + return {k: row[k] for k in FIELDS if k in row} + + +def _doc_file(file: str) -> Path: + return doc_store.folder() / ml.file_of(file) + + +def _rows(data: dict) -> list[dict]: + return data.setdefault("줄", []) + + +def _at(rows: list[dict], key: str) -> int | None: + return next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None) + + +def _fresh_doc(key: str, row: dict, base: dict | None) -> dict: + """새 기초 문서 — 원본 문서 복제(본뜸) 또는 빈 문서(출처 = 결과단위 다음) · 이름표 · 머리 = 받은 줄.""" + if base is None: + blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원")) + items = list(blank.items()) + base = {**dict(items[:5]), "출처": row.get("출처"), **dict(items[5:])} + else: + base = {k: v for k, v in copy.deepcopy(base).items() if k != "손고침"} + base["키"] = key + return doc_store._headed(base, {**head(row), "키": key}) + + +def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: + """고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키).""" + plan: dict[str, dict] = {} + edits, added, gone = [], [], set() + for part in parts: + file = str(part.get("file") or "") + path = _doc_file(file) + if path.name not in plan: + plan[path.name] = ( + copy.deepcopy(ml.load_file(path)) if path.is_file() else doc_store._new_file(path.name) + ) + rows = _rows(plan[path.name]) + for ch in part.get("changes") or []: + op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") + if op not in ("edit", "add", "delete"): + raise store.StoreError(400, f"모르는 op 「{op}」") + at = None if op == "add" else _at(rows, key) + if op != "add" and at is None: + raise store.StoreError(404, f"{file} · 없는 키 「{key}」") + if op != "delete" and ( + not isinstance(row, dict) or not str(row.get("이름") or "").strip() + ): + raise store.StoreError(400, f"{file} · 줄에 「이름」 이 없음") + if op == "edit": + if str(row.get("키")) != key: + raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」") + rows[at] = doc_store._headed(rows[at], head(row)) + edits.append(("머리", key, doc_store.head_of(rows[at]))) + elif op == "add": + if file != OWN: + raise store.StoreError(400, f"새 기초는 {OWN} 에만") + tid = mk.table_id("로직", "자체") + number = str(row.get("원문번호") or "") + key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file) + source = str(ch.get("from") or "") + base = doc_store.docs().get(source) if source else None + rows.append(_fresh_doc(key, row, base)) + edits.append(("더함", key, {"file": file, "row": head(row), "from": source})) + added.append({"file": file, "key": key}) + else: + del rows[at] + gone.add(key) + edits.append(("지움", key, None)) + return plan, edits, added, gone + + +def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]: + """문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌).""" + have = dict(doc_store.logic_files()) + after = dict(have) + for name, data in plan.items(): + logic = str(data.get("로직파일") or "") or "로직_" + name.split("_", 1)[1] + after[logic] = {"그룹": "로직", "줄": data.get("줄") or []} + keys = {str(d.get("키")) for f in after.values() for d in f["줄"]} + old = set(cm.duplicate_keys(have, old_book)) + out = [x for x in cm.duplicate_keys(after, book) if x not in old] + return out + store.cache.labor_errors(None, gone, keys) + + +def save(parts: list[dict], confirmed: bool = False) -> dict: + """로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}.""" + revise.guard(parts, confirmed) + gone_used = { + k: used + for p in parts + for c in p.get("changes") or [] + if c.get("op") == "delete" and (k := str(c.get("key") or "")) + and (used := doc_store.users(k)) + } + if gone_used: + raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]}) + with doc_store._LOCK: + stale = [ + str(p.get("file")) for p in parts + if doc_store.file_version(str(p.get("file"))) != (p.get("version") or "") + ] # fmt: skip + if stale: + raise store.StoreError(409, {"stale": stale}) + book_path = store.FOLDER / mk.BOOK.name + book = mk.load_book(book_path) + old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])} + plan, edits, added, gone = _plan(parts, book) + mk.finish(book) + if bad := _errors(plan, gone, old_book, book): + raise store.StoreError(422, {"errors": bad}) + paths = {n: doc_store.folder() / n for n in plan} + raw = {n: p.read_bytes() for n, p in paths.items() if p.is_file()} + book_raw = book_path.read_bytes() if book["다음"] != old_book["다음"] else None + try: + if book_raw is not None: + mk.save_book(book, book_path) + for name, data in plan.items(): + doc_store.put(paths[name], data) + except BaseException: + _undo(paths, raw, book_path, book_raw) + raise + mirror(edits) + files = list(dict.fromkeys(str(p.get("file")) for p in parts)) + return { + "files": [{"file": f, "version": doc_store.file_version(f)} for f in files], + "added": added, + "warnings": [], + } + + +def _undo(paths: dict, raw: dict, book_path: Path, book_raw: bytes | None) -> None: + """쓰기 중간 실패 — 문서 파일 · 대장을 저장 전 글로(새로 만든 문서 파일은 지움).""" + for name, path in paths.items(): + if name in raw: + _put(path, raw[name]) + else: + path.unlink(missing_ok=True) + if book_raw is not None: + _put(book_path, book_raw) + doc_store._memo.clear() + + +def _put(path: Path, data: bytes) -> None: + tmp = path.with_name(f".{path.name}.tmp") + tmp.write_bytes(data) + os.replace(tmp, path) + + +# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ────────── +def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None: + """문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) · + 더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌). + 검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함.""" + if not WRITE or (not edits and not picks): + return + with store._LOCK: + files = store.loaded()[0] + logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"} + where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []} + after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()} + touched: set[str] = set() + for op, key, what in edits: + if op == "더함": + name = what["file"] + if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦 + after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []} + src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or [] + if str(r.get("키")) == what["from"]), None) # fmt: skip + calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS} + after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key})) + where[key] = name + elif (name := where.get(key)) is not None: + rows = after[name]["줄"] + at = _at(rows, key) + if at is None: + continue + if op == "지움": + del rows[at] + else: + rows[at] = _headed_row(rows[at], what) + else: + continue + touched.add(name) + if picks: + touched |= _picks(after, *picks) + for name in touched: + _write(name, logic.get(name), after[name]) + store.cache.stale(touched) + + +def _ordered(row: dict) -> dict: + """새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지.""" + order = mk.ROW_ORDER["로직"] + return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}} + + +def _headed_row(row: dict, head_: dict) -> dict: + """로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음).""" + out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_} + return {**out, **{k: v for k, v in head_.items() if k not in out}} + + +def _picks(after: dict, add: dict, drop: set) -> set[str]: + """기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5).""" + touched = set() + for name, data in after.items(): + if "건설기계" not in name: + continue + for at, row in enumerate(data["줄"]): + pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None) + if pick is None: + continue + codes = [c for c in pick["고르기"] if str(c) not in drop] + codes += [c for c in add.get(str(row["키"]), []) if c not in codes] + if codes != pick["고르기"]: + new = copy.deepcopy(row) + next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes + data["줄"][at] = new + touched.add(name) + return touched + + +def _write(name: str, before: dict | None, after: dict) -> None: + path = store.FOLDER / name + text = None + if before is not None and path.is_file(): + text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄") + _put(path, (text or dump(after)).encode("utf-8")) diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 2718e60fa..2eefbac48 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -1,21 +1,20 @@ -"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기·본뜨기·고치기·지우기 -· 복사해서 만들기(정본 로직을 별칭 꼴 식으로 펴 보이고 되돌려 저장). +"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기 · 본뜨기(= [복사/생성]) · 고치기 · 지우기. -계약: `resources/master_data/_화면_계약.md` 2장·5장·7장 · 파일 모양: `_틀.md` 7장. -자체 로직은 `로직_자체.json` 한 파일 · 키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌). +계약: `resources/master_data/_화면_계약.md` 2장·5장 · 파일 모양: `_틀.md` 7장. +기초(로직) 저장 = 수식 문서 먼저(`Store_Logic` · 855 L3 ⓐ) · 자체 기초는 `수식_자체.json` 한 파일 · +키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌). """ from __future__ import annotations import re -from pathlib import Path - -from common_util.common_util_time import kst_today +from M01_MasterData import M01_MasterData_Doc as doc_store from M01_MasterData import M01_MasterData_Machine as machine from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Logic as logic_store from M01_MasterData import M01_MasterData_Store_Revise as revise -cm, mk, mcp = store.cm, store.mk, store.mcp +cm, mk = store.cm, store.mk OWN = "로직_자체.json" # 자체 로직 한 자리 — 이 파일 줄만 고치고 지울 수 있음 OWNERS = ("현장", "공용") @@ -206,97 +205,46 @@ def source(src: str) -> dict: return {"source": src, "found": found} -# ── 자체 로직 ────────────────────────────────────────────────────────── -def _own_path() -> Path: - return store.FOLDER / OWN - - -def _make_file() -> None: - """자체 로직 파일이 없으면 머리만 두고 만듦.""" - path = _own_path() - if path.is_file(): - return - head = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []} - path.write_text(store.dump(head), encoding="utf-8", newline="\n") +# ── 저장 ────────────────────────────────────────────────────────────── +def _alias(part: dict) -> None: + """별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음.""" + for ch in part.get("changes") or []: + row = ch.get("row") + if isinstance(row, dict) and "별칭" in row: + text = str(row["별칭"] or "").strip() + row.update(별칭=text) if text else row.pop("별칭") def save(batch: list[dict], confirmed: bool = False) -> dict: - """`/save` — 로직 정본 줄 고침은 `confirmed`(「원문 개정 반영」) 없으면 409(`Store_Revise`) · - 자체 파일 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}.""" - revise.guard(batch, confirmed) + """`/save` — 기초(로직 파일 몫)는 `Store_Logic`(문서 먼저 · 정본 머리 고침은 `confirmed` 없으면 409) · + 요소 · 표는 `store.save` · 자체 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}.""" + logic = [p for p in batch if logic_store.is_logic(str(p.get("file") or ""))] + rest = [p for p in batch if not logic_store.is_logic(str(p.get("file") or ""))] + revise.guard(logic, confirmed) for part in batch: + _alias(part) + for part in logic: for ch in part.get("changes") or []: row = ch.get("row") - if ( - isinstance(row, dict) and "별칭" in row - ): # 별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음 - text = str(row["별칭"] or "").strip() - row.update(별칭=text) if text else row.pop("별칭") - machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) - _keep_same(part) - docs_too = machine.register( - batch - ) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침) - fresh = False - for part in batch: - if part.get("file") != OWN: - continue - for ch in part.get("changes") or []: - row = ch.get("row") - if isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")): + if part.get("file") == OWN and isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")): ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0]))) - if not _own_path().is_file(): - _make_file() - fresh = True - part["version"] = part.get("version") or store.read(OWN)[1] - before = {p["file"]: set(_file_keys(p["file"])) for p in batch} # 자재 3만 키 — 목록 찾기 금지 - try: + files, added = [], [] + if rest: + for part in rest: + machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) + _keep_same(part) + docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본) + before = {p["file"]: set(_file_keys(p["file"])) for p in rest} # 자재 3만 키 — 목록 찾기 금지 with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))): - files = store.save(batch) - except store.StoreError: - if fresh: - _own_path().unlink(missing_ok=True) - raise - docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5) - _drop_docs(batch) - added = [ - {"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old - ] - _sync_tags(batch, added) + files = store.save(rest) + docs_too() + added = [{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old] + if logic: + got = logic_store.save(logic, True) + files, added = files + got["files"], added + got["added"] return {"files": files, "added": added, "warnings": []} -def _sync_tags(batch: list[dict], added: list[dict]) -> None: - """고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게) · - 더한 로직 줄은 문서부터 둠(`Doc.ensure` — 목록이 문서에서 읽음 · 855 L2 ⓐ).""" - from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 - - files = store.loaded()[0] - for a in added: - if (files.get(a["file"]) or {}).get("그룹") == "로직": - doc_store.ensure(a["key"]) - keys = {a["key"] for a in added} | { - str(c.get("key")) - for p in batch - for c in p.get("changes") or [] - if c.get("op") == "edit" and c.get("key") - } - doc_store.sync_tags(keys) - - -def _drop_docs(batch: list[dict]) -> None: - """지운 로직 줄의 수식 문서도 지움(문서만 남지 않게 · `/logic/remove` 와 같은 끝).""" - from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 - - files = store.loaded()[0] - for part in batch: - if (files.get(str(part.get("file"))) or {}).get("그룹") != "로직": - continue - for ch in part.get("changes") or []: - if ch.get("op") == "delete" and ch.get("key"): - doc_store.drop(str(ch["key"])) - - def _keep_same(part: dict) -> None: """고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜).""" data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2) @@ -315,11 +263,7 @@ def _file_keys(file: str) -> list[str]: return [str(r.get("키")) for r in data.get(store.items_key(data)) or []] -def _find(key: str) -> tuple[str, dict]: - got = store.logic(key) - return got["file"], got["logic"] - - +# ── 자체 로직 ────────────────────────────────────────────────────────── def _clean(logic: dict, owner: str, key: str | None = None) -> dict: """서버가 잡는 칸 — 키·소유·구분·상세구분. 화면이 보낸 것은 안 씀.""" if not isinstance(logic, dict) or not str(logic.get("이름") or "").strip(): @@ -354,79 +298,23 @@ def _chapter_of(logic: dict) -> str: return "" -def _write(changes: list[dict]) -> dict: - """자체 파일 한 벌 저장 — 검사는 `/save` 와 같음(422 면 아무것도 안 씀).""" - fresh = not _own_path().is_file() - _make_file() - try: - out = store.save([{"file": OWN, "version": store.read(OWN)[1], "changes": changes}]) - except store.StoreError: - if fresh: - _own_path().unlink(missing_ok=True) - raise - return out[0] +def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict: + """새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) · + 옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`).""" + change = {"op": "add", "row": _clean(logic, owner), "from": source} + part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]} + got = logic_store.save([part], True) + key = got["added"][-1]["key"] + return {**got["files"][0], "key": key, "logic": store.logic(key)["logic"], "수식문서": True} -def _keys() -> list[str]: - if not _own_path().is_file(): - return [] - return [str(r.get("키")) for r in store.read(OWN)[0].get("줄") or []] - - -def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict: - """새 자체 로직 — 키 = 서버가 `GX` 다음 번호 · 수식 문서도 같이(`Doc.make` · 요구 896).""" - from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게 - - before = set(_keys()) - done = _write([{"op": "add", "row": _clean(logic, owner)}]) - key = next((k for k in reversed(_keys()) if k not in before), "") - made = doc_store.ensure(key) if key else False - return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made} - - -def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0]) -> dict: - """본떠 만들기 — 정본도 본뜰 수 있음 · 비고 끝에 본뜬 키를 적음.""" - _, row = _find(key) +def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0], more: dict | None = None) -> dict: + """본떠 만들기 = [복사/생성] — 원본 문서를 새 자체 기초로 복제(정본도 본뜸) · 비고 끝에 본뜬 키 · + `more` = 기본정보 창에서 고친 원문번호 · 결과단위 · 출처(빈 글은 원본 그대로).""" + _, doc = doc_store.find(key) + row = doc_store.head_of(doc) note = " · ".join(x for x in (str(row.get("비고") or ""), f"{key} 를 본뜸") if x) - copy = {**row, "비고": note} + copy = {**row, "비고": note, **{k: v for k, v in (more or {}).items() if v}} if 이름: copy["이름"] = 이름 - return logic_new(copy, owner) - - -# ── 복사해서 만들기 ──────────────────────────────────────────────────── -def logic_formula(key: str) -> dict: - """로직 한 줄을 별칭 꼴 식 묶음으로 펴 보임 — 되돌릴 원문은 `별칭` 에 그대로(정본은 안 바뀜).""" - got = store.logic(key) - master = store.loaded()[1] - return { - "file": got["file"], - "version": got["version"], - "key": key, - "소유": got["logic"].get("소유") or "", - **mcp.spread(master, got["logic"]), - } - - -def _gather(logic: dict, marks: list[dict]) -> dict: - try: - return mcp.gather(logic, marks) - except cm.mf.FormulaError as e: - raise store.StoreError(400, str(e)) from e - - -def logic_formula_preview(logic: dict, marks: list[dict]) -> dict: - """별칭을 원문으로 되돌린 로직 줄만 — 저장 안 함(시험 계산 전 미리보기).""" - return {"logic": _gather(logic, marks)} - - -def logic_from_formula( - logic: dict, marks: list[dict], owner: str = OWNERS[0], 이름: str = "", 본뜬키: str = "" -) -> dict: - """고친 식 묶음을 자체 로직으로 저장 — 별칭을 원문으로 되돌린 뒤 `logic_new` 를 그대로 씀.""" - row = _gather(logic, marks) - if 이름: - row["이름"] = 이름 - if 본뜬키: - row["비고"] = " · ".join(x for x in (str(row.get("비고") or ""), f"{본뜬키} 를 본뜸") if x) - return logic_new(row, owner) + return logic_new(copy, owner, key) diff --git a/M01_MasterData/M01_MasterData_Store_Revise.py b/M01_MasterData/M01_MasterData_Store_Revise.py index 2d28fba21..1c05a9926 100644 --- a/M01_MasterData/M01_MasterData_Store_Revise.py +++ b/M01_MasterData/M01_MasterData_Store_Revise.py @@ -1,23 +1,20 @@ -"""M01 로직 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17). +"""M01 단가산출 기초 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17 · 855 L3 ⓐ 문서 기준). -- 로직 정본 파일(`로직_*.json` · 자체 `로직_자체.json` 뺌) 줄을 실제로 바꾸는 `/save`(흐름 저장 · - 지우기 포함)는 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭. -- 요소 파일(인력 · 재료 · 표 …) · 자체 로직 · 같은 줄 그대로 다시 보냄은 대상 밖. -- 줄 바탕 지문(`row_print`) = 계산 칸만 정렬 JSON(수는 Decimal 정규 글) sha256 앞 16 자 — - M02 덮개가 담아 두고 「M01 개정 — 확인」 배지를 띄울 값. -- 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git. +- 정본 기초(로직 파일 이름 `로직_*.json` · 자체 `로직_자체.json` 뺌)의 문서 머리를 실제로 바꾸는 저장 + (지우기 포함)은 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭. +- 대조 = 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 같은 머리를 그대로 다시 보냄은 대상 밖. +- 자체 기초 · 요소 파일(인력 · 재료 · 표 …)은 대상 밖 · 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git. """ from __future__ import annotations -import hashlib -import json from decimal import Decimal -from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Doc as doc_store OWN = "로직_자체.json" -PRINT_FIELDS = ("결과단위", "입력", "중간", "호표", "덧줄", "결과", "끝수", "흐름") +#: 기초 머리 — 화면 [저장]이 보내 문서에 쓰는 칸(셈 칸은 줄 쌓기 문서 저장 몫) +FIELDS = ("키", *doc_store.md.TAGS, *doc_store.HEAD) WHY = "로직 정본(품셈 원문) 줄을 바꿈 — 「원문 개정 반영」 확인 뒤 저장(개정확인)" @@ -38,30 +35,24 @@ def _norm(v): return str(v) -def row_print(row: dict) -> str: - """줄 바탕 지문 — 계산 칸(`PRINT_FIELDS`)만 · 이름 · 별칭 · 비고 고침은 지문을 안 바꿈.""" - calc = {k: _norm(row[k]) for k in PRINT_FIELDS if row.get(k) is not None} - raw = json.dumps(calc, ensure_ascii=False, sort_keys=True, separators=(",", ":")) - return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] +def _head(row: dict) -> dict: + return _norm({k: row[k] for k in FIELDS if k in row}) def changed(batch: list[dict]) -> list[dict]: - """정본 줄을 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 줄을 그대로 다시 보낸 edit 은 뺌.""" + """정본 기초 머리를 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 머리를 그대로 다시 보낸 edit 은 뺌.""" + have = doc_store.docs() out = [] for part in batch: file = str(part.get("file") or "") if not is_canon(file): continue - try: - rows = {str(r.get("키")): r for r in store.read(file)[0].get("줄") or []} - except store.StoreError: - continue # 없는 파일 — `store.save` 가 404 for ch in part.get("changes") or []: op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") - old = rows.get(key) - if op == "edit" and old is not None and store._dec(row) == old: + old = have.get(key) + if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old): continue - name = (row or {}).get("이름") if isinstance(row, dict) else None + name = row.get("이름") if isinstance(row, dict) else None out.append( { "file": file, @@ -78,4 +69,4 @@ def guard(batch: list[dict], confirmed: bool) -> None: return hits = changed(batch) if hits: - raise store.StoreError(409, {"개정": hits, "까닭": WHY}) + raise doc_store.store.StoreError(409, {"개정": hits, "까닭": WHY}) diff --git a/M02_MasterTemplete/M02_Copy_Slim.py b/M02_MasterTemplete/M02_Copy_Slim.py index 482265429..196b3e4f2 100644 --- a/M02_MasterTemplete/M02_Copy_Slim.py +++ b/M02_MasterTemplete/M02_Copy_Slim.py @@ -7,7 +7,7 @@ 이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈). 파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음). 읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦. -층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌. +층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌. """ from __future__ import annotations @@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any: form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름) if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list): out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))} + form = out.get(dc.KEY) + if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list): + out[dc.KEY] = { + **form, + **skc.held({"종류": "단가산출", dc.KEY: form}), + } # 로직 줄 안 씀(855 L2 ⓑ) return out diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index fbe8b4653..1695a2cf1 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]: except dc._ERR: pass have = _have(copy) - return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have) + got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have + return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ) def fill(copy: dict) -> dict: @@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict: seen = _Seen(dim._index(sk, None, doc)) dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음) keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY])) + keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ) if not keys: return sk return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))} diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 857649a66..8bcba8554 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: if renew.on() and live is not None: return dc.doc_of(whole, key), True kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None - if kept: - return cp.deepcopy(kept), True + if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값) + return cp.deepcopy(kept), renew.on() if live is not None and live.get(mcv.HAND): from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 @@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None: whole = dc.over(values) calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") - seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지) + # 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ) + seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {} return {**got, **values, "문서": root, "부름": calls, **origin} @@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: UPPER ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) first[UPPER] = have[UPPER] + if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣) + kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC) + key = str((out.get("바탕") or {}).get("로직") or "") + if kept is None and key in dc.folder(): + kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서 + if kept: + first[BASE_DOC] = norm(_bare_doc(kept)) copy = copy_of({**out, KEY: first}, whole) if ( copy and skc.READS.get() is not None - ): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3) + ): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ) run({**out, KEY: copy}, copy, whole) - index = dc.over(copy) - for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠 - try: - index.logic(key) - except dc._ERR: - pass if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) ): # 파생 — 옛 로직 사본에 박음(822-1) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 0611e02e2..fd00e77b1 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict: def _rows(copy: dict) -> set[str]: - return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]} + rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ) + return {str(r.get("키")) for r in rows} def _basis(doc: dict, body: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index c92cc9cd7..31e99baf1 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -3,7 +3,9 @@ 사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` · 층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로): {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?} - 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등) + 로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) — + 단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 = + 문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌) 단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음. 셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) — `M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 · @@ -67,16 +69,31 @@ def has(doc: Any) -> bool: FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D) VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가") +#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`) +LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직") + + +def plain(rows: Any) -> list: + """값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만).""" + return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)] + + +def _plain(copy: dict) -> dict: + """단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴).""" + rows = plain(copy["로직"]) + return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)} def held(doc: Any) -> dict | None: """문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D · - 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None.""" + 층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None.""" + sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE if has(doc): - return doc[KEY] + return _plain(doc[KEY]) if sk else doc[KEY] form = doc.get(FORM) if isinstance(doc, dict) else None if isinstance(form, dict) and isinstance(form.get("로직"), list): - return {k: form[k] for k in VALUES if k in form} + got = {k: form[k] for k in VALUES if k in form} + return _plain(got) if sk else got return None @@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any: if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함 copy = grow(copy, stamp(out)) out = _formula_job(out, job) - return {**out, KEY: copy} if copy else out + return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ) def _formula_job(out: dict, job: Any) -> dict: @@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict: if got is None or job not in (PRICE, REGEN): return out if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림 - drop = ("문서", "끊음", "따로", "처음", *renew.KEEP) + drop = ( + "문서", + "끊음", + "따로", + "처음", + "바탕문서", + *renew.KEEP, + ) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ) got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}} elif got.get("따로"): got = dc.refresh(got)[0] @@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict: return ans copy = doc[KEY] head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")} - return {**ans, KEY: {**head, **state(copy, whole_())}} + got = state(copy, whole_()) + if not got["M01새판"] and _doc_moved(doc): + got = {**got, "M01새판": True} + return {**ans, KEY: {**head, **got}} + + +def _doc_moved(doc: dict) -> bool: + """M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) · + 자동 따라옴 SK = 늘 지금 문서라 안 봄.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Sk_AutoRenew as renew + + form = doc.get(FORM) + if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)): + return False + return bool(dc.state(form)["문서새판"]) def same_part(doc: Any) -> str | None: @@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None: if copy is None: return None seen = state(copy, whole_()) - fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"]) + fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc)) return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}" diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index c893a4bb9..c0057bcb5 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -97,9 +97,9 @@ def rows(copy: Any) -> Any: return {**copy, **hit} got: dict = {} for part, mark in (("로직", "판"), ("단가", "단가판")): - old = copy.get(part) or [] + old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ) new = [_fresh(r, live) if isinstance(r, dict) else r for r in old] - if any(a is not b for a, b in zip(old, new)): + if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)): got |= {part: new, mark: skc._fp(new)} if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로 _MEMO.clear() diff --git a/resources/master_data/scripts/master_base.py b/resources/master_data/scripts/master_base.py new file mode 100644 index 000000000..8b405543e --- /dev/null +++ b/resources/master_data/scripts/master_base.py @@ -0,0 +1,175 @@ +# -*- coding: utf-8 -*- +"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음. + +옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀. +`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음). +""" + +from __future__ import annotations + +from decimal import Decimal + +import master_keys as mk +import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3) + +# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음 +# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) +GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직") +TABLE_GROUPS = ("소요량", "계수") +TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS) +COST_ITEMS = ("노무비", "재료비", "경비") +BUNDLE = (*COST_ITEMS, "계") + + +class FormulaError(ValueError): + pass + + +class EmptyInput(FormulaError): + """값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`).""" + + +class NoRow(EmptyInput): + """표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길).""" + + +def _plain(v) -> str: + """사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이.""" + return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v) + + +# ── 마스터 모음 ──────────────────────────────────────────────────────── +class Master: + """요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal). + `ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨).""" + + def __init__(self, files: dict[str, dict]): + self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄} + self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄} + self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름 + for data in files.values(): + rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄") + for row in rows or []: + key = str(row.get("키")) + self.index.setdefault(key[:2], {}).setdefault(key, row) + if row.get("원문번호"): + number = str(row["원문번호"]) + slot = self.numbers.setdefault(key[:2], {}) + if number in slot: + self.twice.add((key[:2], number)) + slot.setdefault(number, row) + mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게 + + def get(self, ref: str) -> dict: + tid, _, number = ref.partition(":") + if number and mk.KEY.fullmatch(number) and number[:2] == tid: + row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리 + elif number: + if (tid, number) in self.twice: + raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것") + row = self.numbers.get(tid, {}).get(number) + else: + row = self.index.get(ref[:2], {}).get(ref) + if row is None: + raise FormulaError(f"없는 요소 「{ref}」") + return row + + def label(self, ref) -> str: + """알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글.""" + if isinstance(ref, dict): + return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v) + try: + row = self.get(ref) + except FormulaError: + return ref + return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}" + + def value(self, ref: str): + """요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값.""" + row = self.get(ref) + alias = row.get("준용") + if alias not in (None, ""): + target = self.get(str(alias)) + name = target.get("이름") or alias + if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠 + return row.get("값"), f"추정(준용: {name})" + return target.get("값"), f"준용: {name}" + return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None + + def logic(self, ref: str) -> dict: + if mk.GROUP_OF.get(mk.id_of(ref)) != "로직": + raise FormulaError(f"로직 아님 「{ref}」") + return self.get(ref) + + +# ── 표 줄 찾기 ──────────────────────────────────────────────────────── +def _match(table: dict, row: dict, cond: str, want) -> bool: + if cond not in row: # 빈 조건 칸은 무엇이든 맞음 + return True + have = row[cond] + if table.get("조건", {}).get(cond) == "범위": + low, high = have + rule, *more = table.get("범위규칙", "초과·이하").split(" · ") + rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌 + if rule == "이상·이하": + return (low is None or want >= low) and (high is None or want <= high) + if rule == "초과·이하": + return (low is None or want > low) and (high is None or want <= high) + if rule == "이상·미만": + # 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함 + top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None) + closed = any("이하 포함" in x for x in more) and high == top + return (low is None or want >= low) and ( + high is None or want < high or (closed and want == high) + ) + if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find) + return (low is None or want > low) and (high is None or want <= high) + if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find) + return (low is None or want >= low) and (high is None or want <= high) + raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」") + return have == want + + +def _name(row: dict) -> str: + return f"{row.get('키')} {row.get('원문번호')}" + + +def find(table: dict, conds: dict, want: str | None = None) -> dict: + for cond in conds: + if cond not in table.get("조건", {}): + raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」") + hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())] + if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"): + for c in conds: + ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)] + if ups and None not in ups: + hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)] + if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만 + hits = [row for row in hits if want in row] + if len(hits) != 1: + where = f"표 {table.get('키')}({table.get('원문번호')})" + what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items()) + raise NoRow( + f"{where}에 {what} 인 줄이 없음" + if not hits + else f"{where}에 {what} 인 줄이 {len(hits)}개" + ) + return hits[0] + + +# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음 +from master_material import ( # noqa: E402, F401 + LINKED, + PICK_KEYS, + REGION, + SLOTS, + TARIFF, + candidates, + check_pick, + check_unit, + static, + cond_text, + element, + pick, +) +import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위 diff --git a/resources/master_data/scripts/master_doc_block.py b/resources/master_data/scripts/master_doc_block.py index fe466e96f..69ca054be 100644 --- a/resources/master_data/scripts/master_doc_block.py +++ b/resources/master_data/scripts/master_doc_block.py @@ -11,7 +11,7 @@ from __future__ import annotations import master_doc as md -import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError +import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError import master_keys as mk import master_material as mm # 재료 고르기 조건 검사(`check_pick`) diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 64d3d9b38..353c54126 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -20,7 +20,7 @@ from pathlib import Path import master_doc as md import master_doc_calc as mc -import master_formula as mf +import master_base as mf # 바탕 기반(색인 · 오류) import master_machine_crew as mcrew import master_material as mm import master_pick as mp diff --git a/resources/master_data/scripts/master_doc_record.py b/resources/master_data/scripts/master_doc_record.py index 49416118c..ee7b647b3 100644 --- a/resources/master_data/scripts/master_doc_record.py +++ b/resources/master_data/scripts/master_doc_record.py @@ -13,7 +13,7 @@ from __future__ import annotations import master_doc_calc as mc -import master_formula as mf +import master_base as mf # 바탕 기반(색인 · 오류) class Rec: diff --git a/resources/master_data/scripts/master_formula.py b/resources/master_data/scripts/master_formula.py index 4cd540ecd..a5e35281d 100644 --- a/resources/master_data/scripts/master_formula.py +++ b/resources/master_data/scripts/master_formula.py @@ -3,6 +3,7 @@ 식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게). `check_master.py` 가 부름. +바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄. """ from __future__ import annotations @@ -12,15 +13,22 @@ import re from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal import master_keys as mk -import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3) +from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로 + BUNDLE, + COST_ITEMS, + GROUPS, + TABLE_GROUPS, + TABLE_IDS, + EmptyInput, + FormulaError, + Master, + NoRow, + _match, + _name, + _plain, + find, +) -# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음 -# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) -GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직") -TABLE_GROUPS = ("소요량", "계수") -TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS) -COST_ITEMS = ("노무비", "재료비", "경비") -BUNDLE = (*COST_ITEMS, "계") FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대") _NAME = re.compile(r"[\w가-힣]+") _NUMBER = re.compile(r"\d+(?:\.\d+)?") @@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]: raise FormulaError(FLOW_GONE) -class FormulaError(ValueError): - pass - - -class EmptyInput(FormulaError): - """값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`).""" - - -class NoRow(EmptyInput): - """표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길).""" - - class Blank: """못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움.""" @@ -57,11 +53,6 @@ class Blank: self.why = why -def _plain(v) -> str: - """사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이.""" - return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v) - - # ── 읽기 ────────────────────────────────────────────────────────────── class _Parser: def __init__(self, text: str): @@ -257,70 +248,6 @@ def walk(node): yield from walk(item) -# ── 마스터 모음 ──────────────────────────────────────────────────────── -class Master: - """요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal). - `ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨).""" - - def __init__(self, files: dict[str, dict]): - self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄} - self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄} - self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름 - for data in files.values(): - rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄") - for row in rows or []: - key = str(row.get("키")) - self.index.setdefault(key[:2], {}).setdefault(key, row) - if row.get("원문번호"): - number = str(row["원문번호"]) - slot = self.numbers.setdefault(key[:2], {}) - if number in slot: - self.twice.add((key[:2], number)) - slot.setdefault(number, row) - mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게 - - def get(self, ref: str) -> dict: - tid, _, number = ref.partition(":") - if number and mk.KEY.fullmatch(number) and number[:2] == tid: - row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리 - elif number: - if (tid, number) in self.twice: - raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것") - row = self.numbers.get(tid, {}).get(number) - else: - row = self.index.get(ref[:2], {}).get(ref) - if row is None: - raise FormulaError(f"없는 요소 「{ref}」") - return row - - def label(self, ref) -> str: - """알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글.""" - if isinstance(ref, dict): - return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v) - try: - row = self.get(ref) - except FormulaError: - return ref - return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}" - - def value(self, ref: str): - """요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값.""" - row = self.get(ref) - alias = row.get("준용") - if alias not in (None, ""): - target = self.get(str(alias)) - name = target.get("이름") or alias - if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠 - return row.get("값"), f"추정(준용: {name})" - return target.get("값"), f"준용: {name}" - return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None - - def logic(self, ref: str) -> dict: - if mk.GROUP_OF.get(mk.id_of(ref)) != "로직": - raise FormulaError(f"로직 아님 「{ref}」") - return self.get(ref) - - def fill(template: str, env: dict) -> str: def one(m): if m.group(1) not in env: @@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal: return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode) -def _match(table: dict, row: dict, cond: str, want) -> bool: - if cond not in row: # 빈 조건 칸은 무엇이든 맞음 - return True - have = row[cond] - if table.get("조건", {}).get(cond) == "범위": - low, high = have - rule, *more = table.get("범위규칙", "초과·이하").split(" · ") - rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌 - if rule == "이상·이하": - return (low is None or want >= low) and (high is None or want <= high) - if rule == "초과·이하": - return (low is None or want > low) and (high is None or want <= high) - if rule == "이상·미만": - # 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함 - top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None) - closed = any("이하 포함" in x for x in more) and high == top - return (low is None or want >= low) and ( - high is None or want < high or (closed and want == high) - ) - if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find) - return (low is None or want > low) and (high is None or want <= high) - if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find) - return (low is None or want >= low) and (high is None or want <= high) - raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」") - return have == want - - -def _name(row: dict) -> str: - return f"{row.get('키')} {row.get('원문번호')}" - - -def find(table: dict, conds: dict, want: str | None = None) -> dict: - for cond in conds: - if cond not in table.get("조건", {}): - raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」") - hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())] - if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"): - for c in conds: - ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)] - if ups and None not in ups: - hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)] - if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만 - hits = [row for row in hits if want in row] - if len(hits) != 1: - where = f"표 {table.get('키')}({table.get('원문번호')})" - what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items()) - raise NoRow( - f"{where}에 {what} 인 줄이 없음" - if not hits - else f"{where}에 {what} 인 줄이 {len(hits)}개" - ) - return hits[0] - - def evaluate(node, env: dict, master: Master, depth: int = 0): kind = node[0] if kind in ("num", "str"): diff --git a/resources/master_data/scripts/master_material.py b/resources/master_data/scripts/master_material.py index c6e3b3f47..b12cf25f7 100644 --- a/resources/master_data/scripts/master_material.py +++ b/resources/master_data/scripts/master_material.py @@ -284,5 +284,5 @@ def element( return min(offers, key=lambda x: x[0]) if offers else (None, None) -import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 +import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 import master_pick as mp # noqa: E402 — 검색어 찾기 diff --git a/resources/master_data/scripts/master_pick.py b/resources/master_data/scripts/master_pick.py index ffc906650..e17db0c85 100644 --- a/resources/master_data/scripts/master_pick.py +++ b/resources/master_data/scripts/master_pick.py @@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]: return [] -import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 +import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음 diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 1a28585d6..29fc83f18 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()): from M02_MasterTemplete import M02_Doc_Copy as dc files, live = m01.loaded() - fake = skc.Copy(live, [copy.deepcopy(r) for r in rows]) + fake = copy.copy( + live + ) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ) + fake.index = {t: dict(v) for t, v in live.index.items()} + fake.numbers = {t: dict(v) for t, v in live.numbers.items()} + for row in rows: + row, key = copy.deepcopy(row), str(row["키"]) + fake.index.setdefault(key[:2], {})[key] = row + if row.get("원문번호"): + fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row for key in drop: - skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None) + fake.index.get(key[:2], {}).pop(key, None) monkeypatch.setattr(m01, "loaded", lambda: (files, fake)) docs = {k: v for k, v in dc.folder().items() if k not in drop} docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r} @@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) got = skc.held(_doc(me, key)) - assert PCT in {r["키"] for r in got["로직"]} + assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ) assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"]) assert not any(r["키"][:2] in skc.RES for r in got["로직"]) first = _calc(me, _doc(me, key)) @@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch): def test_deleted_keys_keep_last_value(world, monkeypatch): - """⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지.""" + """⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409).""" me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB")) - _fake(monkeypatch, drop=[PCT, lb]) - with pytest.raises(Exception): - m01.loaded()[1].logic(PCT) + _fake(monkeypatch, drop=[lb]) now = _calc(me, _doc(me, key)) assert now["기준"]["계"] == was - assert {PCT, lb} <= set(now["사본"]["지운키"]) + assert {lb} <= set(now["사본"]["지운키"]) with store.at(me): got = path.preview(key, {"할일": skc.PRICE}) assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"] diff --git a/resources/tester/test_855_e4a_base_only.py b/resources/tester/test_855_e4a_base_only.py new file mode 100644 index 000000000..4ff887b3a --- /dev/null +++ b/resources/tester/test_855_e4a_base_only.py @@ -0,0 +1,111 @@ +"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈. + +- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어 + 견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘. +- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import subprocess +import sys +from decimal import Decimal +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SCRIPTS = ROOT / "resources" / "master_data" / "scripts" +N = 24 # 견본 로직 수(키 차례 고르게) +ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패 + "master_formula", + "master_formula_check", + "master_formula_sum", + "master_cut", + "master_text", + "master_text_item", + "master_auto", + "master_combo", + "master_sheet_line", + "master_gate", + "master_equation", + "check_master", +) + + +def _enc(v): + if isinstance(v, Decimal): + return {"$d": str(v)} + raise TypeError(type(v).__name__) + + +def _dec(d: dict): + return Decimal(d["$d"]) if set(d) == {"$d"} else d + + +def _child() -> None: + """자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}.""" + sys.path.insert(0, str(SCRIPTS)) + import master_base as mb + import master_doc_calc as mc + import master_doc_link as ml + import master_machine_files as mmf + + folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve() + files = {} + for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기 + if name == mmf.NAME and mmf.here(folder): + files[name] = mmf.table(folder)[0] + elif not name.startswith("_"): + raw = (folder / name).read_bytes() + files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal) + docs = ml.load_all() + links = ml.Links(mb.Master(files), docs) + want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec) + out = {} + for key, cases in want.items(): + rows = [] + for label, changed in cases: + try: + got = mc.calc(docs[key], links, changed) + except Exception: + got = None + rows.append([label, got if got and got.get("셈됨") else None]) + out[key] = rows + body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)} + sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8")) + + +def test_바탕_기반만으로_새_계산기_지문_골든과_같음(): + import helper_855_engine as h + from helper_test_all import spread + + rows, _, docs, _ = h.world() + rows = spread([r for r in rows if str(r["키"]) in docs], N) + want = { + str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows + } + run = subprocess.run( + [sys.executable, str(Path(__file__)), "--child"], + input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"), + capture_output=True, + cwd=str(ROOT), + timeout=600, + ) + assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:] + body = json.loads(run.stdout.decode("utf-8")) + assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}" + golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"] + diff = [] + for key, cases in body["답"].items(): + got = [[label, h.answer(g)] for label, g in cases] + raw = json.dumps(got, ensure_ascii=False, sort_keys=True) + if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]: + diff.append(key) + assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}" + + +if __name__ == "__main__" and "--child" in sys.argv: + _child() diff --git a/resources/tester/test_855_l2b_copy_plain.py b/resources/tester/test_855_l2b_copy_plain.py new file mode 100644 index 000000000..5f8ec907f --- /dev/null +++ b/resources/tester/test_855_l2b_copy_plain.py @@ -0,0 +1,50 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 · +일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌). + +임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음. +""" + +from __future__ import annotations + +import copy +import json +from decimal import Decimal + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from M02_MasterTemplete import M02_Sangeun_Copy as skc +from resources.tester.test_795_1_sk_copy import _doc, _sk +from resources.tester.test_795_2_sc_copy import PCT, _read, _sc +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + + +def _logic_rows(doc: dict) -> list[str]: + rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])] + return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC] + + +def _sum(folder, doc) -> Decimal: + with store.at(folder): + return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"])) + + +def test_저장본에_로직줄_없음_금액_같음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}])) + assert _logic_rows(sk) == [] and PCT in _logic_rows(sc) + assert _sum(me, sk) > 0 + + +def test_옛_저장본_로직줄은_안_읽음(world): + me = world["personal"] + sk = _doc(me, _sk(me, 바탕={"로직": PCT})) + was = _sum(me, sk) + old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것) + row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str)) + row["호표"] = row["호표"][:1] + old["수식"]["로직"] = [*old["수식"]["로직"], row] + assert skc.held(old)["로직"] == skc.held(sk)["로직"] + assert _sum(me, old) == was