Files
Aislo/M01_MasterData/M01_MasterData_Doc.py
T
eomsangdonandClaude Opus 5.5 badceff991 refactor(855-E L3b ②): 로직 줄 같이 쓰기 끔 — mirror · 스위치 · 빌더 문서 갈래 걷음
- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0)
- Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 ·
  labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움)
- M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 ·
  손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함)
- M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서)
- 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움
- 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 ·
  파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) ·
  848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음
- 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 13:28:00 +09:00

315 lines
14 KiB
Python

"""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)