Files
Aislo/M01_MasterData/M01_MasterData_Doc.py
T
eomsangdonandClaude Opus 5.5 cb729416a3 refactor(855-E L2a): M01 로직 목록 · 파일 · 분류 · 상세 이름표 · 별칭판 · 조합 알약을 수식 문서에서 읽음
- 관문 `M01_MasterData_Doc.logic_files` — 수식 문서 파일을 옛 로직 파일 이름으로(머리 원문 · 부문 · 차례 · 줄 = 문서) · docs() 도 같은 읽기
- /logics · /groups/로직/files · /subs?group=로직 · /elements?group=로직 · /logic 이름표 · 목록 덧칸(인재경 = 문서 금액 줄 · 작업량 = 문서 결과) · /alias 로직 줄 · 조합 알약 · 담은 로직 요약 = 문서
- 남김(쓰기 짝 · L3) — /logic 셈 칸 · prices(옛 상세 몸) · 파일 판(해) · version(저장 409)
- 쓰기 마무리 — 더한 로직 줄은 문서부터(Doc.ensure · 못 지으면 빈 문서 + 머리) · 새 문서 파일 머리 = 짝 로직 파일 머리 · sync_tags 가 이름 · 결과단위 · 출처 · 부품도 같게
- 서버 답 전후 243 건 다름 0 · 조합 알약 1,558 건 다름 0
- 시험 6 파일: 마스터만 임시 사본으로 바꾸던 준비에 수식 문서 사본도(목록이 문서에서 읽으므로 사본 저장이 보이게) · test_m01_cache 한 시험의 겹친 사본 걷음

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

443 lines
19 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 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"]
#: 목록 · 상세가 문서에서 읽는 머리(이름표 `md.TAGS` 밖) — 로직 줄 고침도 같게(`sync_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:
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 "원"))
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:
"""문서 파일 — 있던 파일 › 로직 줄이 든 로직 파일 짝(쓰기 짝 · 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
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, "줄": []}
def _row(key: str) -> dict | None:
"""그 키의 로직 줄(기억 · 읽기만) — 없음 = None."""
for data in store.loaded()[0].values():
if data.get("그룹") == "로직":
for row in data.get("줄") or []:
if str(row.get("키")) == key:
return row
return None
def sync_tags(keys) -> int:
"""로직 줄 이름표를 수식 문서 줄 머리에 같게(855 L1 · 읽는 쪽이 문서로 옮길 때까지 두 곳) —
로직 줄 · 문서가 둘 다 있는 키만 · 바뀐 문서 파일만 씀(`put`) · 바꾼 문서 수."""
want = {k: r for k in set(map(str, keys)) if (r := _row(k)) is not None}
if not want:
return 0
n = 0
with _LOCK:
for path in sorted(folder().glob("수식_*.json")):
data, hit = ml.load_file(path), False
rows = data.get("줄") or []
for at, doc in enumerate(rows):
row = want.get(str(doc.get("키")))
if row is not None and _headed(doc, row) != doc:
rows[at], hit = _headed(doc, row), True
n += 1
if hit:
put(path, data)
return n
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 ensure(key: str) -> bool:
"""새 로직 줄의 수식 문서 — 빌더와 같은 문서(`make`) · 못 지으면 빈 문서 + 머리(목록이 문서에서 읽으므로
문서 없는 로직 0 · 열면 빈 문서는 그대로) · 지어 넣었거나 이미 있음 = True."""
if make(key):
return True
row = _row(key)
if row is None:
return False
blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
blank = {
**dict(list(blank.items())[:5]),
"출처": row.get("출처"),
**dict(list(blank.items())[5:]),
}
with _LOCK:
if key in docs():
return True
path = folder() / _file_for(key)
data = ml.load_file(path) if path.exists() else _new_file(path.name)
data.setdefault("줄", []).append(_headed(blank, row))
put(path, data)
return False
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:
doc = cv.convert(store.loaded()[1], row)[0]
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
return None
return md.tag(doc, row) # 855 L1 이름표 = 빌더와 같게
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 _new_file(path.name)
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:
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 판 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