"""M01 단가산출 기초 수식 문서 화면 서버 몫(PLAN 802-3 · 요구 664 · 요구서_664 3 장). 문서 = `resources/master_data/수식문서/수식_<로직 파일 꼬리>.json`(`master_doc_link.FOLDER`) · 셈 = `master_doc_calc.calc`(파이썬 정본 · TS 짝 `common_util_formula_doc_calc.ts`) · 연결 기록 = `master_doc_record.Rec` — 셈이 쓴 요소 값 · 표 · 단가산출 문서를 화면 캐시로 실음 (화면은 같은 계산기로 즉시 셈 · 캐시에 없는 연결만 뒤에서 미리 셈). - 읽기 {키} → {문서, 셈, 연결, 파일, 새, 판} — 없는 키 = 404 - 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음 - 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음) · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸을 고치면 `손고침`(M02 SK 가 기초 문서 사본을 실음 · 한 번 붙으면 남음) 권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4). """ from __future__ import annotations import json import os import threading from decimal import Decimal from pathlib import Path from M01_MasterData import M01_MasterData_Store as store import master_doc as md # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤 import master_doc_calc as mc # noqa: E402 import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_doc_record as mr # noqa: E402 import master_equation_link as link # noqa: E402 OWN_FILE = "수식_자체.json" _memo: dict = {} # 수식 문서 쓰기 한 번에 하나 — 저장 · 지움 · 기계 고르기 목록 등록(`Machine._register_docs`) # ponytail: 프로세스 안 잠금(`Store._LOCK` 과 같은 한계) · 서버를 여럿 띄우면 파일 잠금으로 _LOCK = threading.Lock() _HOME = Path(ml.__file__).resolve().parents[1] # 저장소 정본 마스터 폴더 STALE = "그 사이 파일이 바뀜 — 고친 것을 버리고 다시 여세요: {v}" # 화면 `Save_Stale` 과 같은 글 def folder() -> Path: return ml.FOLDER 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` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀.""" if path.resolve().parent.parent == _HOME and Path(store.FOLDER).resolve() != _HOME: return tmp = path.with_name(f".{path.name}.tmp") tmp.write_text(ml.dump(data), encoding="utf-8", newline="\n") os.replace(tmp, path) _memo.clear() def _stamp() -> tuple: return tuple((p.name, p.stat().st_mtime_ns) for p in sorted(folder().glob("수식_*.json"))) def logic_files() -> dict[str, dict]: """로직 그룹 관문(855 L2 ⓐ) — 수식 문서 파일을 옛 로직 파일 이름으로 {로직 파일: {그룹 로직 · 원문 · 부문 · 차례 · 줄 = 문서}} · 파일 시각이 같으면 다시 안 읽음(읽기 전용).""" stamp = (str(folder()), _stamp()) if _memo.get("stamp") != stamp: files = {} for path in sorted(folder().glob("수식_*.json")): data = ml.load_file(path) name = data.get("로직파일") or "로직_" + path.name.split("_", 1)[1] head = {k: data[k] for k in md.FILE_TAGS if k in data} files[name] = {"그룹": "로직", **head, "줄": data.get("줄") or []} every = {str(d.get("키")): d for f in files.values() for d in f["줄"]} _memo.update(stamp=stamp, files=files, docs=every) return _memo["files"] def docs() -> dict[str, dict]: """저장 문서 전부 {키: 문서} — 파일 시각이 같으면 다시 안 읽음.""" logic_files() return _memo["docs"] #: 손고침 표지를 가르는 셈 칸(`layered`) CALC = ("변수", "식", "금액", "끝수") #: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) HEAD = ("이름", "결과단위", "출처", "부품") def head_of(doc: dict) -> dict: """문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 로직 목록 · 상세의 이름표 정본.""" return {k: doc[k] for k in ("키", *md.TAGS, *HEAD) if k in doc} def find(key: str) -> tuple[str, dict]: """(옛 로직 파일 이름, 문서) — 없는 키 = 404.""" for name, data in logic_files().items(): for doc in data["줄"]: if str(doc.get("키")) == key: return name, doc raise store.StoreError(404, f"없는 로직 「{key}」") def head(ref: str) -> dict: """`Master.logic` 과 같은 거름 · 같은 까닭 글 — 로직 키 → 문서 머리(조합 알약 · 담은 로직 요약).""" if store.mk.GROUP_OF.get(store.mk.id_of(ref)) != "로직": raise store.cm.mf.FormulaError(f"로직 아님 「{ref}」") doc = docs().get(ref) if doc is None: raise store.cm.mf.FormulaError(f"없는 요소 「{ref}」") return head_of(doc) def _dec(doc) -> dict: """화면 JSON(float) → Decimal 문서 — 저장 문서와 같은 수 꼴로 셈.""" return json.loads(json.dumps(doc, ensure_ascii=False), parse_float=Decimal, parse_int=Decimal) def _where(key: str) -> str | None: for path in sorted(folder().glob("수식_*.json")): if any(str(d.get("키")) == key for d in ml.load_file(path).get("줄") or []): return path.name return None def _run(doc: dict, given: dict | None = None) -> dict: whole = store.loaded()[1] every = docs() own = str(doc.get("키") or "") links = ml.Links(whole, {**every, own: doc} if own else every) rec = mr.Rec(links) rec.prefetch(doc) answer = mc.calc(doc, rec, _dec(given or {})) # 848-8 덮인 칸의 정본 값도 기록(제어 구역 「원래 값」) — 작업량만 얹음 if cover := mcv.cover_of(doc): work = {k: {"작업량": v["작업량"]} for k, v in cover.items() if "작업량" in (v or {})} mc.calc(doc, rec, _dec(given or {}), cover=work) # 셈 답은 위 · 기록만 return {"셈": answer, "연결": rec.out()} def _check(doc) -> dict: if not isinstance(doc, dict) or doc.get("꼴") != "수식문서": raise store.StoreError(400, "수식 문서 꼴 아님") if not str(doc.get("키") or "").strip(): raise store.StoreError(400, "문서 키 없음") for k in ("변수", "식", "금액"): if not isinstance(doc.get(k) or [], list): raise store.StoreError(400, f"「{k}」 는 목록") return _dec(doc) def read(key: str) -> dict: """기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404.""" found = docs().get(key) if found is None: raise store.StoreError(404, f"없는 로직 「{key}」") out = _run(found) 판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409) return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판} def preview(doc: dict, given: dict | None = None) -> dict: return _run(_check(doc), given) def _file_for(key: str) -> str: """문서 파일 — 있던 파일 › 자체(새 기초는 자체에만 · 855 L3 ⓐ).""" return _where(key) or OWN_FILE def _new_file(name: str) -> dict: """새 문서 파일 머리 — 자체 문서 파일만 새로 생김(원문 = 자체 · 목록 분류 정본).""" logic = "로직_" + name.split("_", 1)[1] tags = {"원문": "자체"} if name == OWN_FILE else {} return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []} def _headed(doc: dict, row: dict) -> dict: """문서 머리를 받은 머리와 같게 — 이름표(`md.tag`) + `HEAD`(있던 자리 그대로 · 머리에 없는 칸은 뺌).""" out = md.tag(doc, row) for k in HEAD: if k in row: out[k] = row[k] else: out.pop(k, None) return out def layered(doc: dict, key: str) -> dict: """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 받은 문서 + 덮음 · `손고침` = 셈 칸(`CALC`)을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 855-E L4).""" links = ml.Links(store.loaded()[1], {**docs(), key: doc}) try: doc = mcv.prune_doc(doc, links) except ValueError as e: raise store.StoreError(400, str(e)) from e cover = doc.get(mcv.COVER) bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} was = docs().get(key) calc = lambda d: ml._norm({k: d.get(k) for k in CALC}) # noqa: E731 hand = was is not None and (bool(was.get(mcv.HAND)) or calc(was) != calc(bare)) out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})} if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례) out["쌓기"] = out.pop("쌓기") return out def save(doc: dict, 판: str | None = None) -> dict: """`판` = 읽을 때 받은 판(없음 = 대조 안 함 · 빈 글 = 저장본 없던 문서) · 다르면 409.""" doc = _check(doc) key = str(doc["키"]).strip() with _LOCK: 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: rows.append(doc) else: rows[at] = doc put(path, data) return {"문서": doc, **_run(doc), "파일": name, "판": version_of(doc)} def candidates(ask: dict) -> dict: """연결 후보 — 요소 · 표 = M01 색인 찾기 · 단가산출 = 수식 문서 이름 찾기(읽기만).""" if ask.get("갈래") != "단가산출": return link.candidates(store.loaded()[1], ask) words = str(ask.get("검색") or "").lower().split() out = [] for key, d in docs().items(): text = f"{key} {d.get('이름') or ''}".lower() if words and all(w in text for w in words): ins = [ str(v.get("열쇠")) for v in d.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력", "숫자") and v.get("열쇠") ] out.append({"키": key, "이름": d.get("이름"), "단위": d.get("결과단위"), "입력": ins}) return {"후보": out[: link.LIMIT], "더있음": len(out) > link.LIMIT} def table(key: str) -> dict: """표 하나(조건 · 칸 고르기) — 기록 꼴 그대로.""" rec = mr.Rec(ml.Links(store.loaded()[1], {})) rec.see_table(key) return rec.표[key] # ── 로직 지우기(804-7 · 요구 687-1) — 로직 줄 + 수식 문서를 서버 정본에서 함께 ── def users(key: str) -> list[str]: """이 로직을 부르는 곳 — 다른 수식 문서(단가산출 연결) · 일위대가 조합 · M02 단가산출(바탕). 다른 로직 줄이 부르는 것은 로직 저장 검사(422)가 막음.""" from M01_MasterData import M01_MasterData_Store_Combo as combo_store from M02_MasterTemplete import M02_Template_Layers as layers # M02 가 M01 을 부름 — 늦게 out = [] for k, d in docs().items(): if k != key and any( (v.get("연결") or {}).get("갈래") == "단가산출" and str((v.get("연결") or {}).get("키")) == key for v in d.get("변수") or [] ): out.append(f"단가산출 {k} {d.get('이름') or ''}".strip()) for c in combo_store.combos_of_logic(key)["combos"]: out.append(f"일위대가 조합 {c.get('키')} {c.get('이름') or ''}".strip()) for where, path in layers.layer_files("sangeun"): try: sk = json.loads(path.read_bytes()) except (OSError, ValueError): continue if str((sk.get("바탕") or {}).get("로직") or "") == key: out.append(f"M02 단가산출 {where} {sk.get('이름') or path.stem}") return out def drop(key: str) -> None: """수식 문서 줄 하나 지움(없으면 그냥).""" with _LOCK: name = _where(key) if not name: return path = folder() / name data = ml.load_file(path) data["줄"] = [d for d in data.get("줄") or [] if str(d.get("키")) != key] put(path, data) def remove(key: str, file: str, version: str, confirmed: bool) -> dict: """로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움).""" from M01_MasterData import ( M01_MasterData_Store_Logic as logic_store, ) # 그 파일이 이 파일을 부름 — 늦게 used = users(key) if used: raise store.StoreError(409, {"쓰는곳": used}) part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]} return logic_store.save([part], confirmed)