Files
Aislo/M01_MasterData/M01_MasterData_Doc.py
T
eomsangdonandClaude Opus 5.5 358c514c51 feat(855-2-B4): M01 [로직 복사/생성] 시험 계산 — 옛 엔진(/calc · /text) 대신 수식 문서 셈
- /logic/formula/preview 답에 「문서」 더함 — 저장하면 지을 수식 문서(Doc.of_row · 빌더 · Doc.make 와 같은 변환 · built 도 이 한 벌)
- 시험 계산 칸 = 그 문서를 /logic/doc/preview 로 셈 · 옵션 가로 · 합계 상자 = 줄 쌓기 화면 부품 그대로 · 결과 로직 = 결과 값 · 멈춤 = 까닭
- 고르기 글 → 목록 값으로 보냄(줄 쌓기 usable 과 같음 · 글 「45」 면 표 줄 못 찾음)
- 옛 길 본체(서버 /calc · /text · Store.calc · text · 화면 Logic_Drive · Logic_CalcPick · Api runCalc · runText)는 그대로 — 지움은 2-E1 박자
- 시험: test_m01_copy 미리보기 = 문서 셈이 저장 문서 셈과 같음(기본 · 옵션 바꿈) · 소스 글자 시험(149_4 pctView 한 벌 · 750_2 · 799_2 의 Calc 글자 줄)은 걸려 지움

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 20:17:38 +09:00

324 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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."""
for data in store.loaded()[0].values():
if data.get("그룹") != "로직":
continue
for row in data.get("줄") or []:
if str(row.get("키")) == key:
return of_row(row)
return None
def of_row(row: dict) -> dict | None:
"""로직 줄(저장 전 고친 줄도) → 빌더와 같은 변환의 수식 문서 · 변환 틀림 = None —
[로직 복사/생성] 시험 계산(855 2-B4)이 저장하면 지을 문서로 셈."""
import master_doc_convert as cv
try:
return cv.convert(store.loaded()[1], row)[0]
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
return None
def make(key: str) -> bool:
"""[로직 복사/생성](`Store_Make.logic_new`) 뒤 수식 문서를 지어 씀 — 빌더(`build_수식문서_802_2`)와
같은 변환 · 같은 대조(옛 엔진 = 새 계산기 · 기본 + 옵션 표본 · 부르는 단가산출이 저장본)를 지난 것만
(빌더도 그것만 넣음 · 못 지나면 안 씀 = 열면 빈 문서) · 이미 있으면 그대로 · 썼거나 있음 = True."""
import importlib
builder = importlib.import_module("build_수식문서_802_2")
files, whole = store.loaded()
row = next(
(
r
for data in files.values()
if data.get("그룹") == "로직"
for r in data.get("줄") or []
if str(r.get("키")) == key
),
None,
)
doc = built(key) if row is not None else None
if doc is None:
return False
with _LOCK:
have = docs()
if key in have:
return True
links = ml.Links(whole, {**have, key: doc})
if not builder._calls(doc) <= set(have) or not all(
builder.agree(
builder.old_answer(whole, row, given), builder.new_answer(links, doc, one)
)
for _, given, one in builder.cases_of(whole, row)
):
return False
path = folder() / _file_for(key)
data = (
ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
)
data.setdefault("줄", []).append(doc)
put(path, data)
return True
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