auto: 2026-11-18 07:18 (ESD_LAPTOP)

This commit is contained in:
2026-11-18 07:18:00 +09:00
parent 5eb42dfbd0
commit cce57c2984
9 changed files with 410 additions and 320 deletions
+14 -9
View File
@@ -80,10 +80,16 @@ def _find(key: str, files: tuple[str, ...] | None = None) -> tuple[str, dict[str
def set_alias(key: str, text: str) -> dict[str, Any]:
"""그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음)."""
file, _ = _find(key)
data, version = store.read(file)
row = dict(next(r for r in data["줄"] if str(r.get("키")) == key))
"""그 줄 `별칭` 만 바꿔 M01 저장 길로(빈 글 = 칸 없음 · 별칭만이라 정본 개정 확인 안 물음) ·
단가산출 기초 = 문서 머리(855 L3 ⓐ · `Store_Logic`)."""
doc = store._docs().docs().get(key)
if doc is not None:
file = store._docs().find(key)[0]
version, row = store._docs().file_version(file), store._docs().head_of(doc)
else:
file, _ = _find(key)
data, version = store.read(file)
row = dict(next(r for r in data["줄"] if str(r.get("키")) == key))
row[ALIAS] = text
change = {"op": "edit", "key": key, "row": row}
make.save([{"file": file, "version": version, "changes": [change]}], True)
@@ -109,11 +115,10 @@ def board() -> dict[str, Any]:
(str(v.get("키")), ma.norm(v.get(ALIAS))) for v in book.values() if v.get("상태") == "승인"
}
rows = []
logic = (
store._docs().logic_files()
) # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ) · 파일 차례는 그대로
for file, data in store.loaded()[0].items():
data = logic.get(file, {}) if data.get("그룹") == "로직" else data
every = {n: d for n, d in store.loaded()[0].items() if d.get("그룹") != "로직"}
every |= store._docs().logic_files() # 단가산출 기초 = 수식 문서 머리(855 L2 ⓐ · L3 ⓐ)
for file in sorted(every): # 파일 이름 차례(마스터 폴더 차례와 같음)
data = every[file]
kind = kind_of(file, str(data.get("그룹") or ""))
for row in data.get("줄") or []:
if not str(row.get(ALIAS) or "").strip():
+24 -37
View File
@@ -48,6 +48,12 @@ 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` ≠ 정본)이 정본 수식 문서를 쓰지 않게 건너뜀."""
@@ -152,18 +158,15 @@ def _check(doc) -> dict:
def read(key: str) -> dict:
"""기초마다 문서가 늘 있음(855 L3 ⓐ — 만들 때 문서부터) · 없는 키 = 404."""
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 "원"))
if found is None:
raise store.StoreError(404, f"없는 로직 「{key}」")
out = _run(found)
up = None if fresh else built(key)
up = built(key) # ponytail: 빌더 문서(층바탕) — 로직 JSON 이 없으면 None · 둘째 박자에서 걷음
more = {"층바탕": {"위": up}} if up is not None else {}
판 = version_of(None if fresh else found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": fresh, "판": 판, **more}
판 = version_of(found) # 저장 때 대조(다른 곳에서 바뀌면 409)
return {"문서": found, **out, "파일": _where(key) or "", "새": False, "판": 판, **more}
def preview(doc: dict, given: dict | None = None) -> dict:
@@ -171,24 +174,15 @@ def preview(doc: dict, given: dict | None = None) -> dict:
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
"""문서 파일 — 있던 파일 › 자체(새 기초는 자체에만 · 855 L3 ⓐ)."""
return _where(key) or 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, "줄": []}
tags = {"원문": "자체"} if name == OWN_FILE else {}
return {"그룹": "수식문서", "로직파일": logic, **tags, "줄": []}
def _row(key: str) -> dict | None:
@@ -345,14 +339,14 @@ def save(doc: dict, 판: str | None = None) -> dict:
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 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:
@@ -428,15 +422,8 @@ def drop(key: str) -> None:
def remove(key: str, file: str, version: str, confirmed: bool) -> dict:
"""로직 지우기 — 부르는 곳이 있으면 409 {쓰는곳} · 로직 저장 길(개정 확인 · 판 · 검사) 뒤 문서도."""
from M01_MasterData import M01_MasterData_Store_Make as make
"""로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기)."""
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게
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
part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]}
return logic_store.save([part], confirmed)
+9 -30
View File
@@ -11,7 +11,6 @@ M01 에서 만든 기계(출처 모두 「자체」)를 지우면 그 번호 기
from __future__ import annotations
import copy
from decimal import Decimal
from typing import Any, Callable
@@ -118,20 +117,10 @@ def formula(row: dict) -> dict:
return base | ({"키": got["키"], "이름": got.get("이름")} if got else {})
def _family_files() -> dict[str, str]:
"""기계경비식 키 → 로직 파일 이름."""
return {
str(r.get("키")): name
for name, data in store.loaded()[0].items()
if data.get("그룹") == "로직" and "건설기계" in name
for r in data.get("줄") or []
}
def register(batch: list[dict]) -> Callable[[], None]:
"""[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를
지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길) ·
돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록에도 같은 더함 · 뺌(848-5 · 두 목록 한 벌)."""
지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록(정본 ·
848-5)에 더함 · 뺌 + 옛 로직 줄 고르기 같이 쓰기(`Store_Logic.mirror` · 855 L3 ⓐ)."""
from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게
from M02_MasterTemplete import M02_MyMachine as mym
@@ -162,23 +151,13 @@ def register(batch: list[dict]) -> Callable[[], None]:
drop.add(code)
if not add and not drop:
return lambda: None
files = _family_files()
for name in dict.fromkeys(files.values()):
changes = []
for logic in store.read(name)[0].get("줄") or []:
ins = logic.get("입력") or []
pick = next((i for i in ins if i.get("이름") == "기계" and "고르기" in i), None)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(logic["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(logic)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
changes.append({"op": "edit", "key": logic["키"], "row": new})
if changes:
batch.append({"file": name, "version": store.read(name)[1], "changes": changes})
after = lambda: _register_docs(add, drop) # noqa: E731
def after() -> None:
from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 늦게(서로 부름)
_register_docs(add, drop)
logic_store.mirror([], (add, drop))
after.lists = (
add,
drop,
+9 -40
View File
@@ -48,26 +48,14 @@ class SaveBody(BaseModel):
class CopyLogic(BaseModel):
"""[복사/생성](본떠 만들기) — 원본 문서를 새 자체 기초로 · 빈 글 = 원본 그대로."""
key: str
이름: str = ""
owner: str = make.OWNERS[0]
class FormulaLogic(BaseModel):
"""복사해서 만들기 — 별칭 꼴 식이 든 로직 줄과 그 별칭표(되돌릴 원문)."""
로직: dict[str, Any]
별칭: list[dict[str, Any]] = []
owner: str = make.OWNERS[0]
이름: str = ""
본뜬키: str = ""
class FormulaPreview(BaseModel):
"""저장 전 미리보기 — 별칭을 원문으로 되돌린 로직 줄만 받고 싶을 때(시험 계산 전)."""
로직: dict[str, Any]
별칭: list[dict[str, Any]] = []
원문번호: str = ""
결과단위: str = ""
출처: str = ""
def _num(v):
@@ -248,27 +236,8 @@ def post_save(body: SaveBody) -> dict:
@router.post("/logic/copy")
def post_logic_copy(body: CopyLogic) -> dict:
return _call(make.logic_copy, body.key, body.이름, body.owner)
@router.get("/logic/formula")
def get_logic_formula(key: str) -> dict:
"""복사해서 만들기 — 로직 한 줄을 별칭 꼴 식 묶음으로."""
return _call(make.logic_formula, key)
@router.post("/logic/formula/save")
def post_logic_formula_save(body: FormulaLogic) -> dict:
"""고친 식 묶음을 자체 로직(`GX`)으로 — 별칭은 원문으로 되돌려 저장."""
return _call(make.logic_from_formula, body.로직, body.별칭, body.owner, body.이름, body.본뜬키)
@router.post("/logic/formula/preview")
def post_logic_formula_preview(body: FormulaPreview) -> dict:
"""저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄 + 저장하면 지을 수식 문서
{logic, 문서}(저장 안 함 · 화면은 `문서` 를 `/logic/doc/preview` 로 셈 · 855 2-B4)."""
got = _call(make.logic_formula_preview, body.로직, body.별칭)
return {**got, "문서": doc_screen.of_row(got["logic"])}
more = {"원문번호": body.원문번호, "결과단위": body.결과단위, "출처": body.출처}
return _call(make.logic_copy, body.key, body.이름, body.owner, more)
# ── 수식 문서(802-3) — 단가산출 기초 정본 · 화면은 같은 계산기로 즉시 셈 ──
@@ -280,7 +249,7 @@ class DocBody(BaseModel):
@router.get("/logic/doc")
def get_logic_doc(key: str) -> dict:
"""수식 문서 {문서, 셈, 연결, 파일, 새} — 없으면 빈 문서(쓰기 없음)."""
"""수식 문서 {문서, 셈, 연결, 파일, 새} — 없는 키 = 404(쓰기 없음)."""
return _call(doc_screen.read, key)
@@ -311,7 +280,7 @@ def get_logic_users(key: str) -> dict:
@router.post("/logic/remove")
def post_logic_remove(body: RemoveBody) -> dict:
"""로직 지우기(804-7) — 로직 줄 + 수식 문서 · 부르는 곳 있으면 409 {쓰는곳}."""
"""로직 지우기(804-7) — 수식 문서(+ 옛 로직 줄 같이 쓰기) · 부르는 곳 있으면 409 {쓰는곳}."""
return _call(doc_screen.remove, body.key, body.file, body.version, body.개정확인)
+12 -13
View File
@@ -21,7 +21,6 @@ sys.path.insert(0, str(SCRIPTS))
import check_master as cm # noqa: E402
import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀)
import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀)
import master_copy as mcp # noqa: E402,F401 (`_Store_Make` 가 `store.mcp` 로 씀)
import master_keys as mk # noqa: E402
import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀)
@@ -116,7 +115,7 @@ def _docs():
def files_of(group: str) -> list[dict]:
"""로직 = 수식 문서 파일(855 L2 ⓐ) · 판(해) · version 은 로직 파일(저장 409 짝 · L3 에서 문서로)."""
"""로직 = 수식 문서 파일(855 L2 ⓐ) · 판 = 문서 파일 머리 · version = 문서 파일 글 지문(855 L3 ⓐ)."""
if group not in cm.mf.GROUPS:
raise StoreError(404, f"없는 그룹 「{group}」")
logic = _docs().logic_files() if group == "로직" else None
@@ -124,8 +123,12 @@ def files_of(group: str) -> list[dict]:
for name in sorted(logic) if logic is not None else cm.mmf.names(FOLDER):
if name != f"{group}.json" and not name.startswith(f"{group}_"):
continue
data, version = read(name)
head = data if logic is None else logic[name]
if logic is None:
data, version = read(name)
head = data
else:
data = head = logic[name]
version = _docs().file_version(name)
out.append(
{
"file": name,
@@ -390,18 +393,14 @@ def logics(sub: str, detail: str, q: str, blocked: int | None, owner: str = "")
def logic(key: str) -> dict:
"""로직 하나 — 키는 전체에서 하나 · 있는지 · 파일 · 이름표 = 수식 문서(855 L2 ⓐ) ·
셈 칸(입력 · 호표 …) · `version` = 로직 파일(화면 [저장]이 줄째 되돌려 씀 — L3 에서 걷음)."""
files, whole = loaded()
"""로직 하나 — 키는 전체에서 하나 · 파일 · `logic` = 수식 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 ·
부품 — 화면 [저장]이 이 칸만 되돌려 보냄 · 셈은 줄 쌓기 문서) · `version` = 문서 파일 판(855 L3 ⓐ)."""
name, doc = _docs().find(key)
row = next((r for r in (files.get(name) or {}).get("줄") or [] if str(r.get("키")) == key), {})
head, named = _docs().head_of(doc), (*_docs().md.TAGS, *_docs().HEAD)
row = {k: head.get(k, v) for k, v in row.items() if k in head or k not in named} | head
reasons = cache.reasons(key, whole) # 수식 문서 기준(855 2-B3)
reasons = cache.reasons(key, loaded()[1]) # 수식 문서 기준(855 2-B3)
return {
"file": name,
"version": read(name)[1],
"logic": row,
"version": _docs().file_version(name),
"logic": _docs().head_of(doc),
"blocked": bool(reasons),
"reasons": reasons,
}
+7 -2
View File
@@ -330,10 +330,11 @@ def _labor_files() -> list[tuple[str, Path]]:
]
def labor_errors(whole, keys=None) -> list[str]:
def labor_errors(whole, keys=None, have=None) -> list[str]:
"""일위대가 · 사전조합 문서가 담은 로직 마스터에 없음(39-1d · 50-3) —
로직 지우기를 막음 · 어디서 쓰는지 알림 · 참조 줄(로직 없음)은 건너뜀. 전부터 깨진 것은
`save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶)."""
`save` 가 고치기 전 검사와 견주어 뺌. `keys` = 그 로직 키만 봄(빈 묶음이면 파일을 안 엶) ·
`have` = 있는 기초 키(저장 뒤 문서 · 855 L3 ⓐ — 주면 `whole` 대신)."""
out = []
if keys is not None and not keys:
return out
@@ -350,6 +351,10 @@ def labor_errors(whole, keys=None) -> list[str]:
key = str(one.get("로직") or "") if isinstance(one, dict) else ""
if not key or (keys is not None and key not in keys):
continue
if have is not None:
if key not in have:
out.append(f"{where} 「{name}」 이 로직 「{key}」 을 씀 — 거기서 먼저 뺌")
continue
try:
whole.logic(key)
except cm.mf.FormulaError:
@@ -0,0 +1,267 @@
"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898).
화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
"""
from __future__ import annotations
import copy
import os
from pathlib import Path
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Revise as revise
from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape
md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움
WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json"
FIELDS = revise.FIELDS
CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
def is_logic(file: str) -> bool:
return file.startswith("로직_") and file.endswith(".json")
def head(row: dict) -> dict:
"""화면이 보낸 줄에서 쓸 칸 — 키 · 이름표 · 머리."""
return {k: row[k] for k in FIELDS if k in row}
def _doc_file(file: str) -> Path:
return doc_store.folder() / ml.file_of(file)
def _rows(data: dict) -> list[dict]:
return data.setdefault("줄", [])
def _at(rows: list[dict], key: str) -> int | None:
return next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
def _fresh_doc(key: str, row: dict, base: dict | None) -> dict:
"""새 기초 문서 — 원본 문서 복제(본뜸) 또는 빈 문서(출처 = 결과단위 다음) · 이름표 · 머리 = 받은 줄."""
if base is None:
blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
items = list(blank.items())
base = {**dict(items[:5]), "출처": row.get("출처"), **dict(items[5:])}
else:
base = {k: v for k, v in copy.deepcopy(base).items() if k != "손고침"}
base["키"] = key
return doc_store._headed(base, {**head(row), "키": key})
def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]:
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키)."""
plan: dict[str, dict] = {}
edits, added, gone = [], [], set()
for part in parts:
file = str(part.get("file") or "")
path = _doc_file(file)
if path.name not in plan:
plan[path.name] = (
copy.deepcopy(ml.load_file(path)) if path.is_file() else doc_store._new_file(path.name)
)
rows = _rows(plan[path.name])
for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
if op not in ("edit", "add", "delete"):
raise store.StoreError(400, f"모르는 op 「{op}」")
at = None if op == "add" else _at(rows, key)
if op != "add" and at is None:
raise store.StoreError(404, f"{file} · 없는 키 「{key}」")
if op != "delete" and (
not isinstance(row, dict) or not str(row.get("이름") or "").strip()
):
raise store.StoreError(400, f"{file} · 줄에 「이름」 이 없음")
if op == "edit":
if str(row.get("키")) != key:
raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」")
rows[at] = doc_store._headed(rows[at], head(row))
edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add":
if file != OWN:
raise store.StoreError(400, f"새 기초는 {OWN} 에만")
tid = mk.table_id("로직", "자체")
number = str(row.get("원문번호") or "")
key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file)
source = str(ch.get("from") or "")
base = doc_store.docs().get(source) if source else None
rows.append(_fresh_doc(key, row, base))
edits.append(("더함", key, {"file": file, "row": head(row), "from": source}))
added.append({"file": file, "key": key})
else:
del rows[at]
gone.add(key)
edits.append(("지움", key, None))
return plan, edits, added, gone
def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
"""문서 검사 — 일위대가 · 사전조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
have = dict(doc_store.logic_files())
after = dict(have)
for name, data in plan.items():
logic = str(data.get("로직파일") or "") or "로직_" + name.split("_", 1)[1]
after[logic] = {"그룹": "로직", "줄": data.get("줄") or []}
keys = {str(d.get("키")) for f in after.values() for d in f["줄"]}
old = set(cm.duplicate_keys(have, old_book))
out = [x for x in cm.duplicate_keys(after, book) if x not in old]
return out + store.cache.labor_errors(None, gone, keys)
def save(parts: list[dict], confirmed: bool = False) -> dict:
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
revise.guard(parts, confirmed)
gone_used = {
k: used
for p in parts
for c in p.get("changes") or []
if c.get("op") == "delete" and (k := str(c.get("key") or ""))
and (used := doc_store.users(k))
}
if gone_used:
raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]})
with doc_store._LOCK:
stale = [
str(p.get("file")) for p in parts
if doc_store.file_version(str(p.get("file"))) != (p.get("version") or "")
] # fmt: skip
if stale:
raise store.StoreError(409, {"stale": stale})
book_path = store.FOLDER / mk.BOOK.name
book = mk.load_book(book_path)
old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])}
plan, edits, added, gone = _plan(parts, book)
mk.finish(book)
if bad := _errors(plan, gone, old_book, book):
raise store.StoreError(422, {"errors": bad})
paths = {n: doc_store.folder() / n for n in plan}
raw = {n: p.read_bytes() for n, p in paths.items() if p.is_file()}
book_raw = book_path.read_bytes() if book["다음"] != old_book["다음"] else None
try:
if book_raw is not None:
mk.save_book(book, book_path)
for name, data in plan.items():
doc_store.put(paths[name], data)
except BaseException:
_undo(paths, raw, book_path, book_raw)
raise
mirror(edits)
files = list(dict.fromkeys(str(p.get("file")) for p in parts))
return {
"files": [{"file": f, "version": doc_store.file_version(f)} for f in files],
"added": added,
"warnings": [],
}
def _undo(paths: dict, raw: dict, book_path: Path, book_raw: bytes | None) -> None:
"""쓰기 중간 실패 — 문서 파일 · 대장을 저장 전 글로(새로 만든 문서 파일은 지움)."""
for name, path in paths.items():
if name in raw:
_put(path, raw[name])
else:
path.unlink(missing_ok=True)
if book_raw is not None:
_put(book_path, book_raw)
doc_store._memo.clear()
def _put(path: Path, data: bytes) -> None:
tmp = path.with_name(f".{path.name}.tmp")
tmp.write_bytes(data)
os.replace(tmp, path)
# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ──────────
def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
"""문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) ·
더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌).
검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함."""
if not WRITE or (not edits and not picks):
return
with store._LOCK:
files = store.loaded()[0]
logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"}
where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []}
after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()}
touched: set[str] = set()
for op, key, what in edits:
if op == "더함":
name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦
after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or []
if str(r.get("키")) == what["from"]), None) # fmt: skip
calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS}
after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key}))
where[key] = name
elif (name := where.get(key)) is not None:
rows = after[name]["줄"]
at = _at(rows, key)
if at is None:
continue
if op == "지움":
del rows[at]
else:
rows[at] = _headed_row(rows[at], what)
else:
continue
touched.add(name)
if picks:
touched |= _picks(after, *picks)
for name in touched:
_write(name, logic.get(name), after[name])
store.cache.stale(touched)
def _ordered(row: dict) -> dict:
"""새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지."""
order = mk.ROW_ORDER["로직"]
return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}}
def _headed_row(row: dict, head_: dict) -> dict:
"""로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음)."""
out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_}
return {**out, **{k: v for k, v in head_.items() if k not in out}}
def _picks(after: dict, add: dict, drop: set) -> set[str]:
"""기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5)."""
touched = set()
for name, data in after.items():
if "건설기계" not in name:
continue
for at, row in enumerate(data["줄"]):
pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(row["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(row)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
data["줄"][at] = new
touched.add(name)
return touched
def _write(name: str, before: dict | None, after: dict) -> None:
path = store.FOLDER / name
text = None
if before is not None and path.is_file():
text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄")
_put(path, (text or dump(after)).encode("utf-8"))
+52 -164
View File
@@ -1,21 +1,20 @@
"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기·본뜨기·고치기·지우기
· 복사해서 만들기(정본 로직을 별칭 꼴 식으로 펴 보이고 되돌려 저장).
"""M01 「만들기」 저장소 — 원문 절 목록 · 표 조건 값 · 자체 로직 만들기 · 본뜨기(= [복사/생성]) · 고치기 · 지우기.
계약: `resources/master_data/_화면_계약.md` 2장·5장·7장 · 파일 모양: `_틀.md` 7장.
자체 로직은 `로직_자체.json` 한 파일 · 키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌).
계약: `resources/master_data/_화면_계약.md` 2장·5장 · 파일 모양: `_틀.md` 7장.
기초(로직) 저장 = 수식 문서 먼저(`Store_Logic` · 855 L3 ⓐ) · 자체 기초는 `수식_자체.json` 한 파일 ·
키는 `_키대장.json` 의 `GX` 다음 번호(서버가 줌).
"""
from __future__ import annotations
import re
from pathlib import Path
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Machine as machine
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Logic as logic_store
from M01_MasterData import M01_MasterData_Store_Revise as revise
cm, mk, mcp = store.cm, store.mk, store.mcp
cm, mk = store.cm, store.mk
OWN = "로직_자체.json" # 자체 로직 한 자리 — 이 파일 줄만 고치고 지울 수 있음
OWNERS = ("현장", "공용")
@@ -206,97 +205,46 @@ def source(src: str) -> dict:
return {"source": src, "found": found}
# ── 자체 로직 ──────────────────────────────────────────────────────────
def _own_path() -> Path:
return store.FOLDER / OWN
def _make_file() -> None:
"""자체 로직 파일이 없으면 머리만 두고 만듦."""
path = _own_path()
if path.is_file():
return
head = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
path.write_text(store.dump(head), encoding="utf-8", newline="\n")
# ── 저장 ──────────────────────────────────────────────────────────────
def _alias(part: dict) -> None:
"""별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음."""
for ch in part.get("changes") or []:
row = ch.get("row")
if isinstance(row, dict) and "별칭" in row:
text = str(row["별칭"] or "").strip()
row.update(별칭=text) if text else row.pop("별칭")
def save(batch: list[dict], confirmed: bool = False) -> dict:
"""`/save` — 로직 정본 줄 고침은 `confirmed`(「원문 개정 반영」) 없으면 409(`Store_Revise`) ·
자체 파일 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}."""
revise.guard(batch, confirmed)
"""`/save` — 기초(로직 파일 몫)는 `Store_Logic`(문서 먼저 · 정본 머리 고침은 `confirmed` 없으면 409) ·
요소 · 표는 `store.save` · 자체 새 줄(키 없음)은 서버가 칸을 잡고 GX 다음 키 — {files, added, warnings}."""
logic = [p for p in batch if logic_store.is_logic(str(p.get("file") or ""))]
rest = [p for p in batch if not logic_store.is_logic(str(p.get("file") or ""))]
revise.guard(logic, confirmed)
for part in batch:
_alias(part)
for part in logic:
for ch in part.get("changes") or []:
row = ch.get("row")
if (
isinstance(row, dict) and "별칭" in row
): # 별칭(815-2) = 앞뒤 빈칸만 뗌 · 빈 글 = 칸 없음
text = str(row["별칭"] or "").strip()
row.update(별칭=text) if text else row.pop("별칭")
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part)
docs_too = machine.register(
batch
) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침)
fresh = False
for part in batch:
if part.get("file") != OWN:
continue
for ch in part.get("changes") or []:
row = ch.get("row")
if isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")):
if part.get("file") == OWN and isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")):
ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0])))
if not _own_path().is_file():
_make_file()
fresh = True
part["version"] = part.get("version") or store.read(OWN)[1]
before = {p["file"]: set(_file_keys(p["file"])) for p in batch} # 자재 3만 키 — 목록 찾기 금지
try:
files, added = [], []
if rest:
for part in rest:
machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2)
_keep_same(part)
docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본)
before = {p["file"]: set(_file_keys(p["file"])) for p in rest} # 자재 3만 키 — 목록 찾기 금지
with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))):
files = store.save(batch)
except store.StoreError:
if fresh:
_own_path().unlink(missing_ok=True)
raise
docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5)
_drop_docs(batch)
added = [
{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old
]
_sync_tags(batch, added)
files = store.save(rest)
docs_too()
added = [{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old]
if logic:
got = logic_store.save(logic, True)
files, added = files + got["files"], added + got["added"]
return {"files": files, "added": added, "warnings": []}
def _sync_tags(batch: list[dict], added: list[dict]) -> None:
"""고친 · 더한 로직 줄 이름표(비고 · 별칭 · 이름 · 개정 …)를 수식 문서에도(855 L1 · 두 곳 같게) ·
더한 로직 줄은 문서부터 둠(`Doc.ensure` — 목록이 문서에서 읽음 · 855 L2 ⓐ)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
files = store.loaded()[0]
for a in added:
if (files.get(a["file"]) or {}).get("그룹") == "로직":
doc_store.ensure(a["key"])
keys = {a["key"] for a in added} | {
str(c.get("key"))
for p in batch
for c in p.get("changes") or []
if c.get("op") == "edit" and c.get("key")
}
doc_store.sync_tags(keys)
def _drop_docs(batch: list[dict]) -> None:
"""지운 로직 줄의 수식 문서도 지움(문서만 남지 않게 · `/logic/remove` 와 같은 끝)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
files = store.loaded()[0]
for part in batch:
if (files.get(str(part.get("file"))) or {}).get("그룹") != "로직":
continue
for ch in part.get("changes") or []:
if ch.get("op") == "delete" and ch.get("key"):
doc_store.drop(str(ch["key"]))
def _keep_same(part: dict) -> None:
"""고친 줄의 값이 같은 칸 = 파일 값 그대로(화면 왕복 「9.0」 → 「9」 막음 · 그 칸만 바뀜)."""
data = store.loaded()[0].get(str(part.get("file") or "")) # 읽기만 — 기억(826-2)
@@ -315,11 +263,7 @@ def _file_keys(file: str) -> list[str]:
return [str(r.get("키")) for r in data.get(store.items_key(data)) or []]
def _find(key: str) -> tuple[str, dict]:
got = store.logic(key)
return got["file"], got["logic"]
# ── 자체 로직 ──────────────────────────────────────────────────────────
def _clean(logic: dict, owner: str, key: str | None = None) -> dict:
"""서버가 잡는 칸 — 키·소유·구분·상세구분. 화면이 보낸 것은 안 씀."""
if not isinstance(logic, dict) or not str(logic.get("이름") or "").strip():
@@ -354,79 +298,23 @@ def _chapter_of(logic: dict) -> str:
return ""
def _write(changes: list[dict]) -> dict:
"""자체 파일 한 벌 저장 — 검사는 `/save` 와 같음(422 면 아무것도 안 씀)."""
fresh = not _own_path().is_file()
_make_file()
try:
out = store.save([{"file": OWN, "version": store.read(OWN)[1], "changes": changes}])
except store.StoreError:
if fresh:
_own_path().unlink(missing_ok=True)
raise
return out[0]
def logic_new(logic: dict, owner: str = OWNERS[0], source: str = "") -> dict:
"""새 자체 기초 — 키 = 서버가 `GX` 다음 번호 · 문서 = 빈 문서 / `source` 문서 복제(본뜸) ·
옛 로직 줄은 같이 쓰기(`Store_Logic.mirror`)."""
change = {"op": "add", "row": _clean(logic, owner), "from": source}
part = {"file": OWN, "version": doc_store.file_version(OWN), "changes": [change]}
got = logic_store.save([part], True)
key = got["added"][-1]["key"]
return {**got["files"][0], "key": key, "logic": store.logic(key)["logic"], "수식문서": True}
def _keys() -> list[str]:
if not _own_path().is_file():
return []
return [str(r.get("키")) for r in store.read(OWN)[0].get("줄") or []]
def logic_new(logic: dict, owner: str = OWNERS[0]) -> dict:
"""새 자체 로직 — 키 = 서버가 `GX` 다음 번호 · 수식 문서도 같이(`Doc.make` · 요구 896)."""
from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 이 파일을 늦게 부름 — 늦게
before = set(_keys())
done = _write([{"op": "add", "row": _clean(logic, owner)}])
key = next((k for k in reversed(_keys()) if k not in before), "")
made = doc_store.ensure(key) if key else False
return {**done, "key": key, "logic": store.logic(key)["logic"] if key else {}, "수식문서": made}
def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0]) -> dict:
"""본떠 만들기 — 정본도 본뜰 수 있음 · 비고 끝에 본뜬 키를 적음."""
_, row = _find(key)
def logic_copy(key: str, 이름: str = "", owner: str = OWNERS[0], more: dict | None = None) -> dict:
"""본떠 만들기 = [복사/생성] — 원본 문서를 새 자체 기초로 복제(정본도 본뜸) · 비고 끝에 본뜬 키 ·
`more` = 기본정보 창에서 고친 원문번호 · 결과단위 · 출처(빈 글은 원본 그대로)."""
_, doc = doc_store.find(key)
row = doc_store.head_of(doc)
note = " · ".join(x for x in (str(row.get("비고") or ""), f"{key} 를 본뜸") if x)
copy = {**row, "비고": note}
copy = {**row, "비고": note, **{k: v for k, v in (more or {}).items() if v}}
if 이름:
copy["이름"] = 이름
return logic_new(copy, owner)
# ── 복사해서 만들기 ────────────────────────────────────────────────────
def logic_formula(key: str) -> dict:
"""로직 한 줄을 별칭 꼴 식 묶음으로 펴 보임 — 되돌릴 원문은 `별칭` 에 그대로(정본은 안 바뀜)."""
got = store.logic(key)
master = store.loaded()[1]
return {
"file": got["file"],
"version": got["version"],
"key": key,
"소유": got["logic"].get("소유") or "",
**mcp.spread(master, got["logic"]),
}
def _gather(logic: dict, marks: list[dict]) -> dict:
try:
return mcp.gather(logic, marks)
except cm.mf.FormulaError as e:
raise store.StoreError(400, str(e)) from e
def logic_formula_preview(logic: dict, marks: list[dict]) -> dict:
"""별칭을 원문으로 되돌린 로직 줄만 — 저장 안 함(시험 계산 전 미리보기)."""
return {"logic": _gather(logic, marks)}
def logic_from_formula(
logic: dict, marks: list[dict], owner: str = OWNERS[0], 이름: str = "", 본뜬키: str = ""
) -> dict:
"""고친 식 묶음을 자체 로직으로 저장 — 별칭을 원문으로 되돌린 뒤 `logic_new` 를 그대로 씀."""
row = _gather(logic, marks)
if 이름:
row["이름"] = 이름
if 본뜬키:
row["비고"] = " · ".join(x for x in (str(row.get("비고") or ""), f"{본뜬키} 를 본뜸") if x)
return logic_new(row, owner)
return logic_new(copy, owner, key)
+16 -25
View File
@@ -1,23 +1,20 @@
"""M01 로직 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17).
"""M01 단가산출 기초 정본 개정 확인 (PLAN 713-1 · 요구서 내역12 4장 10 · 17 · 855 L3 ⓐ 문서 기준).
- 로직 정본 파일(`로직_*.json` · 자체 `로직_자체.json` 뺌) 줄을 실제로 바꾸는 `/save`(흐름 저장 ·
지우기 포함)는 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭.
- 요소 파일(인력 · 재료 · 표 …) · 자체 로직 · 같은 줄 그대로 다시 보냄은 대상 밖.
- 줄 바탕 지문(`row_print`) = 계산 칸만 정렬 JSON(수는 Decimal 정규 글) sha256 앞 16 자 —
M02 덮개가 담아 두고 「M01 개정 — 확인」 배지를 띄울 값.
- 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git.
- 정본 기초(로직 파일 이름 `로직_*.json` · 자체 `로직_자체.json` 뺌)의 문서 머리를 실제로 바꾸는 저장
(지우기 포함)은 「원문 개정 반영」 확인 값(`개정확인`)이 있어야 함 — 없으면 409 + 까닭.
- 대조 = 문서 머리(키 · 이름표 · 이름 · 결과단위 · 출처 · 부품) — 같은 머리를 그대로 다시 보냄은 대상 밖.
- 자체 기초 · 요소 파일(인력 · 재료 · 표 …)은 대상 밖 · 판 칸 · 옛 줄 사본은 안 둠 — 정본 이력은 git.
"""
from __future__ import annotations
import hashlib
import json
from decimal import Decimal
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Doc as doc_store
OWN = "로직_자체.json"
PRINT_FIELDS = ("결과단위", "입력", "중간", "호표", "덧줄", "결과", "끝수", "흐름")
#: 기초 머리 — 화면 [저장]이 보내 문서에 쓰는 칸(셈 칸은 줄 쌓기 문서 저장 몫)
FIELDS = ("키", *doc_store.md.TAGS, *doc_store.HEAD)
WHY = "로직 정본(품셈 원문) 줄을 바꿈 — 「원문 개정 반영」 확인 뒤 저장(개정확인)"
@@ -38,30 +35,24 @@ def _norm(v):
return str(v)
def row_print(row: dict) -> str:
"""줄 바탕 지문 — 계산 칸(`PRINT_FIELDS`)만 · 이름 · 별칭 · 비고 고침은 지문을 안 바꿈."""
calc = {k: _norm(row[k]) for k in PRINT_FIELDS if row.get(k) is not None}
raw = json.dumps(calc, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
def _head(row: dict) -> dict:
return _norm({k: row[k] for k in FIELDS if k in row})
def changed(batch: list[dict]) -> list[dict]:
"""정본 줄을 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 줄을 그대로 다시 보낸 edit 은 뺌."""
"""정본 기초 머리를 바꾸는 고침 — `[{file, key, op, 이름}]` · 같은 머리를 그대로 다시 보낸 edit 은 뺌."""
have = doc_store.docs()
out = []
for part in batch:
file = str(part.get("file") or "")
if not is_canon(file):
continue
try:
rows = {str(r.get("키")): r for r in store.read(file)[0].get("줄") or []}
except store.StoreError:
continue # 없는 파일 — `store.save` 가 404
for ch in part.get("changes") or []:
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
old = rows.get(key)
if op == "edit" and old is not None and store._dec(row) == old:
old = have.get(key)
if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old):
continue
name = (row or {}).get("이름") if isinstance(row, dict) else None
name = row.get("이름") if isinstance(row, dict) else None
out.append(
{
"file": file,
@@ -78,4 +69,4 @@ def guard(batch: list[dict], confirmed: bool) -> None:
return
hits = changed(batch)
if hits:
raise store.StoreError(409, {"개정": hits, "까닭": WHY})
raise doc_store.store.StoreError(409, {"개정": hits, "까닭": WHY})