- Doc.put 한 곳으로 씀(save · drop · Machine._register_docs) · Doc._LOCK 안 · 임시 파일 → os.replace - 판 = 문서 한 장 저장 글 지문 · 읽기가 「판」 을 줌 · /logic/doc/save 가 받은 판과 다르면 409(화면 Save_Stale 과 같은 글) · 판 없음 = 대조 안 함(옛 부름 · 시험) - M01 줄 쌓기 [저장]이 판을 보냄(M02 사본 길은 그대로) — 기계 목록 등록이 바꾼 문서를 옛 화면이 덮지 않음 - 수식 문서 폴더가 AISLO_MASTER_DIR 사본을 따름(마스터 사본 · 문서 정본이 갈리던 것) · 마스터만 사본인 시험은 정본 문서를 안 씀 - 시험 test_854_2_m01_doc_write — 옛 판 409 · 동시 두 저장 = 하나 ok 하나 409 · 기계 등록 뒤 옛 판 409 · 정본 안 씀 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
277 lines
12 KiB
Python
277 lines
12 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` — 셈이 쓴 요소 값 · 표 · 단가산출 문서를 화면 캐시로 실음
|
||
(화면은 같은 계산기로 즉시 셈 · 캐시에 없는 연결만 뒤에서 미리 셈).
|
||
- 읽기 {키} → {문서, 셈, 연결, 파일, 새, 층바탕?} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) ·
|
||
층바탕(848-8) = {위: 빌더가 지을 문서} — 화면이 칸 단위로 맞대 시스템 관리자 고침 테두리(읽기만 · 파일 안 씀)
|
||
- 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음
|
||
- 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음)
|
||
· 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면
|
||
빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐)
|
||
권한 = 라우터를 `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 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 docs() -> dict[str, dict]:
|
||
"""저장 문서 전부 {키: 문서} — 파일 시각이 같으면 다시 안 읽음."""
|
||
stamp = (str(folder()), _stamp())
|
||
if _memo.get("stamp") != stamp:
|
||
_memo.update(stamp=stamp, docs=ml.load_all(folder()))
|
||
return _memo["docs"]
|
||
|
||
|
||
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:
|
||
found = docs().get(key)
|
||
fresh = found is None
|
||
if fresh:
|
||
row = store.logic(key)["logic"] # 없는 키 = 404
|
||
found = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
|
||
out = _run(found)
|
||
up = None if fresh else built(key)
|
||
more = {"층바탕": {"위": up}} if up is not None else {}
|
||
판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409)
|
||
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more}
|
||
|
||
|
||
def preview(doc: dict, given: dict | None = None) -> dict:
|
||
return _run(_check(doc), given)
|
||
|
||
|
||
def _file_for(key: str) -> str:
|
||
"""문서 파일 — 있던 파일 › 로직 파일 짝 › 자체."""
|
||
have = _where(key)
|
||
if have:
|
||
return have
|
||
try:
|
||
return ml.file_of(store.logic(key)["file"])
|
||
except store.StoreError:
|
||
return OWN_FILE
|
||
|
||
|
||
def built(key: str) -> dict | None:
|
||
"""빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None."""
|
||
import master_doc_convert as cv
|
||
|
||
files, whole = store.loaded()
|
||
for data in files.values():
|
||
if data.get("그룹") != "로직":
|
||
continue
|
||
for row in data.get("줄") or []:
|
||
if str(row.get("키")) == key:
|
||
try:
|
||
return cv.convert(whole, row)[0]
|
||
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
|
||
return None
|
||
return None
|
||
|
||
|
||
def layered(doc: dict, key: str) -> dict:
|
||
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 ·
|
||
다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로."""
|
||
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)}
|
||
base = built(key)
|
||
hand = base is not None and ml._norm(bare) != ml._norm(base)
|
||
if base is not None and not hand:
|
||
bare = base
|
||
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:
|
||
doc = layered(doc, key)
|
||
name = _file_for(key)
|
||
path = folder() / name
|
||
data = (
|
||
ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||
)
|
||
rows = data.setdefault("줄", [])
|
||
at = next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
|
||
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 {쓰는곳} · 로직 저장 길(개정 확인 · 판 · 검사) 뒤 문서도."""
|
||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||
|
||
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
|