Files
Aislo/M01_MasterData/M01_MasterData_Doc.py
T
eomsangdonandClaude Opus 5.5 7e6190f8d3 refactor(855-E L3ⓐ): M01 기초 저장 · 검사 · 막힘 세기 = 수식 문서 기준 · 로직 줄 쓰기 = Store_Logic.mirror 한 자리
앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어
- Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움
- Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음
- Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리)
- 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록)
  · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀)
  · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음
  · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음)
  · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사
  · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움)

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

435 lines
19 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 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"]
#: 목록 · 상세가 문서에서 읽는 머리(이름표 `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:
"""기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404."""
found = docs().get(key)
if found is None:
raise store.StoreError(404, f"없는 로직 「{key}」")
out = _run(found)
up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음
more = {"층바탕": {"위": up}} if up is not None else {}
판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more}
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 _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:
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)