Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -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():
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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.개정확인)
|
||||
|
||||
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
@@ -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"))
|
||||
@@ -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)
|
||||
|
||||
@@ -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})
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
이 문서 셈 = 사본 줄 묶음이 이 문서 사본 안에 드는 색인(남의 SK · SC 참조 셈 = 제 사본 → 안 셈).
|
||||
파일 꼴 그대로 — 옛 코드는 사본에 없는 줄을 지금 M01 로 읽음(지금 옵션에서 안 읽는 줄 = 금액 같음).
|
||||
읽은 줄 없음(셈 안 돎) · 프로젝트 층 = 그대로 · 이미 저장된 파일은 다음 [저장] 때 줄어듦.
|
||||
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀) · 단가산출 빈 옛 칸 뺌.
|
||||
층 저장 꼴(`trim` · 855 2-D) = 남는 칸만 — 값 사본 = `수식` 값 몫 한 벌(`사본` 안 씀 · 단가산출 로직 줄 안 담음 855 L2 ⓑ) · 단가산출 빈 옛 칸 뺌.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -129,4 +129,10 @@ def trim(kind: str, doc: Any) -> Any:
|
||||
form = out.get(dc.KEY) # 단가산출 · 일위대가 · 사전조합 같은 꼴(SC `수식` = 값 몫 + 부름)
|
||||
if skc.has(out) and isinstance(form, dict) and isinstance(form.get("로직"), list):
|
||||
out[dc.KEY] = {**form, **dc.values_of(out.pop(skc.KEY))}
|
||||
form = out.get(dc.KEY)
|
||||
if kind == "sangeun" and isinstance(form, dict) and isinstance(form.get("로직"), list):
|
||||
out[dc.KEY] = {
|
||||
**form,
|
||||
**skc.held({"종류": "단가산출", dc.KEY: form}),
|
||||
} # 로직 줄 안 씀(855 L2 ⓑ)
|
||||
return out
|
||||
|
||||
@@ -56,7 +56,8 @@ def gaps(copy: dict) -> list[str]:
|
||||
except dc._ERR:
|
||||
pass
|
||||
have = _have(copy)
|
||||
return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have)
|
||||
got = {*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have
|
||||
return sorted(k for k in got if k[:2] not in skc.LOGIC) # 로직 줄 = 문서 사본(855 L2 ⓑ)
|
||||
|
||||
|
||||
def fill(copy: dict) -> dict:
|
||||
@@ -78,6 +79,7 @@ def fill_imported(sk: dict, doc: Any) -> dict:
|
||||
seen = _Seen(dim._index(sk, None, doc))
|
||||
dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음)
|
||||
keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY]))
|
||||
keys = [k for k in keys if k[:2] not in skc.LOGIC] # 로직 줄 안 담음(855 L2 ⓑ)
|
||||
if not keys:
|
||||
return sk
|
||||
return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))}
|
||||
|
||||
@@ -97,8 +97,8 @@ def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]:
|
||||
if renew.on() and live is not None:
|
||||
return dc.doc_of(whole, key), True
|
||||
kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None
|
||||
if kept:
|
||||
return cp.deepcopy(kept), True
|
||||
if kept: # 프로젝트 층 = 굳힐 때 문서 + 옛 자동값(855 L2 ⓑ — 전과 같은 옵션 값)
|
||||
return cp.deepcopy(kept), renew.on()
|
||||
if live is not None and live.get(mcv.HAND):
|
||||
from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게
|
||||
|
||||
@@ -247,7 +247,8 @@ def copy_of(sk: dict, whole: Any = None) -> dict | None:
|
||||
whole = dc.over(values)
|
||||
calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름"))
|
||||
base = str((sk.get("바탕") or {}).get("로직") or "")
|
||||
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
|
||||
# 바탕 문서 판(「M01 새 판」 표지) = 셈에 쓴 기초 문서(층 = 지금 M01 · 프로젝트 = `바탕문서` · 855 L2 ⓑ)
|
||||
seen = base_doc({**sk, KEY: got}, whole, base)[0] if base else None
|
||||
origin = {"원본": {"키": base, "판": dc.doc_fp(seen)}} if seen else {}
|
||||
return {**got, **values, "문서": root, "부름": calls, **origin}
|
||||
|
||||
@@ -315,17 +316,18 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
|
||||
UPPER
|
||||
): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1)
|
||||
first[UPPER] = have[UPPER]
|
||||
if not renew.on() and not patched(out): # 프로젝트 층 = 기초 문서 사본으로 굳힘(855 L2 ⓑ ㉣)
|
||||
kept = None if job == skc.REGEN else (have or {}).get(BASE_DOC)
|
||||
key = str((out.get("바탕") or {}).get("로직") or "")
|
||||
if kept is None and key in dc.folder():
|
||||
kept = base_doc({**out, KEY: {}}, whole, key)[0] # 굳히기 전과 같은 문서
|
||||
if kept:
|
||||
first[BASE_DOC] = norm(_bare_doc(kept))
|
||||
copy = copy_of({**out, KEY: first}, whole)
|
||||
if (
|
||||
copy and skc.READS.get() is not None
|
||||
): # 저장 관문 — 문서 셈 · 부름 줄이 읽은 줄을 적음(826-3)
|
||||
): # 저장 관문 — 문서 셈이 읽은 줄을 적음(826-3 · 부름 = 문서 사본 · 로직 줄 안 둠 855 L2 ⓑ)
|
||||
run({**out, KEY: copy}, copy, whole)
|
||||
index = dc.over(copy)
|
||||
for key in copy.get("부름") or {}: # 부름 문서를 가른 값 사본 줄(`dc.doc_of`)도 둠
|
||||
try:
|
||||
index.logic(key)
|
||||
except dc._ERR:
|
||||
pass
|
||||
if (
|
||||
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
|
||||
): # 파생 — 옛 로직 사본에 박음(822-1)
|
||||
|
||||
@@ -271,7 +271,8 @@ def plain(mine: dict, sk: dict) -> dict:
|
||||
|
||||
|
||||
def _rows(copy: dict) -> set[str]:
|
||||
return {str(r.get("키")) for r in [*(copy.get("로직") or []), *(copy.get("단가") or [])]}
|
||||
rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ)
|
||||
return {str(r.get("키")) for r in rows}
|
||||
|
||||
|
||||
def _basis(doc: dict, body: dict) -> dict:
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
"""M02 일위대가 입력 목록(39-3).
|
||||
|
||||
담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은
|
||||
그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 =
|
||||
`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이
|
||||
씀. M01 은 읽기만 · 권한은 부르는 쪽 몫.
|
||||
그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직
|
||||
입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달
|
||||
(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -12,10 +12,10 @@ import re
|
||||
from decimal import Decimal
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
||||
|
||||
_SPEC = ("이름", "설명", "단위", "고르기", "범위")
|
||||
INPUTS = ("입력", "선택") # 문서 입력 변수 갈래
|
||||
_LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직
|
||||
_NUMBER = re.compile(r"(?<![\d-])\d+(?:-\d+)+(?![\d-])") # 품셈 절 번호(「12-1-3」)
|
||||
|
||||
@@ -31,16 +31,27 @@ def _num(value: Any) -> Any:
|
||||
return value
|
||||
|
||||
|
||||
def _logics(codes: list[str]) -> tuple[list[dict], list[str]]:
|
||||
"""([로직 줄 …], 빠진 로직 키) — 키 차례 그대로."""
|
||||
whole = m01.loaded()[1]
|
||||
found, missing = [], []
|
||||
for code in codes:
|
||||
try:
|
||||
found.append(whole.logic(code))
|
||||
except combo_store.cm.mf.FormulaError:
|
||||
missing.append(code)
|
||||
return found, missing
|
||||
def _docs(codes: list[str]) -> tuple[list[dict], list[str]]:
|
||||
"""([수식 문서 …], 빠진 로직 키) — 키 차례 그대로."""
|
||||
docs = m01doc.docs()
|
||||
found = [docs[code] for code in codes if code in docs]
|
||||
return found, [code for code in codes if code not in docs]
|
||||
|
||||
|
||||
def specs(doc: dict) -> list[dict[str, Any]]:
|
||||
"""문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례)."""
|
||||
out = []
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") not in INPUTS or not v.get("열쇠"):
|
||||
continue
|
||||
one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None}
|
||||
if link.get("갈래") == "선택":
|
||||
one["고르기"] = list(link.get("목록") or [])
|
||||
if link.get("범위"):
|
||||
one["범위"] = list(link["범위"])
|
||||
out.append(one)
|
||||
return out
|
||||
|
||||
|
||||
def layered() -> set[str]:
|
||||
@@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]:
|
||||
return out
|
||||
|
||||
|
||||
def sources(logic: dict) -> Any:
|
||||
"""원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이
|
||||
같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01
|
||||
`make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
|
||||
main = str(logic.get("출처") or "")
|
||||
def sources(doc: dict) -> Any:
|
||||
"""원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처`
|
||||
가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이
|
||||
절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로."""
|
||||
main = str(doc.get("출처") or "")
|
||||
head = _NUMBER.search(main)
|
||||
if not head:
|
||||
return logic.get("출처")
|
||||
return doc.get("출처")
|
||||
book, seen = main[: head.start()], set(_NUMBER.findall(main))
|
||||
money = [x for x in doc.get("금액") or [] if isinstance(x, dict)]
|
||||
rows = [x for x in money if "수량" in x] + list(doc.get("변수") or [])
|
||||
extra = []
|
||||
for part in ("호표", "입력", "중간", "덧줄"):
|
||||
for row in logic.get(part) or []:
|
||||
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
|
||||
hit = _NUMBER.search(src)
|
||||
if hit and src[: hit.start()] == book and hit.group() not in seen:
|
||||
seen.add(hit.group())
|
||||
extra.append(hit.group())
|
||||
for row in rows + [x for x in money if "수량" not in x]:
|
||||
src = str(row.get("출처") or "") if isinstance(row, dict) else ""
|
||||
hit = _NUMBER.search(src)
|
||||
if hit and src[: hit.start()] == book and hit.group() not in seen:
|
||||
seen.add(hit.group())
|
||||
extra.append(hit.group())
|
||||
return " · ".join([main, *extra])
|
||||
|
||||
|
||||
def _listed(logics: list[dict]) -> list[dict[str, Any]]:
|
||||
"""로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
|
||||
def _listed(docs: list[dict]) -> list[dict[str, Any]]:
|
||||
"""문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기,
|
||||
입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
whole = m01.loaded()[1]
|
||||
layers = layered()
|
||||
out = []
|
||||
for logic in logics:
|
||||
auto = m01.mau.values(whole, logic)
|
||||
specs = []
|
||||
for spec in logic.get("입력") or []:
|
||||
one = {k: spec[k] for k in _SPEC if k in spec}
|
||||
one.setdefault("설명", None)
|
||||
one.setdefault("단위", None)
|
||||
labels = _labels(whole, spec)
|
||||
for doc in docs:
|
||||
auto = dc.auto_of(doc, whole)
|
||||
rows = []
|
||||
for one in specs(doc):
|
||||
labels = _labels(whole, one)
|
||||
if labels:
|
||||
one["고르기이름"] = labels
|
||||
specs.append({**one, "자동값": auto.get(spec["이름"])})
|
||||
rows.append({**one, "자동값": auto.get(one["이름"])})
|
||||
out.append(
|
||||
{
|
||||
"로직": logic.get("키"),
|
||||
"이름": logic.get("이름"),
|
||||
"결과단위": logic.get("결과단위"),
|
||||
"출처": sources(logic),
|
||||
"켜쌓기": logic.get("키") in layers,
|
||||
"입력": specs,
|
||||
"로직": doc.get("키"),
|
||||
"이름": doc.get("이름"),
|
||||
"결과단위": doc.get("결과단위"),
|
||||
"출처": sources(doc),
|
||||
"켜쌓기": doc.get("키") in layers,
|
||||
"입력": rows,
|
||||
}
|
||||
)
|
||||
return out
|
||||
@@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]:
|
||||
|
||||
def logic_inputs(codes: list[str]) -> dict[str, Any]:
|
||||
"""일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)"""
|
||||
found, missing = _logics(list(dict.fromkeys(c for c in codes if c)))
|
||||
found, missing = _docs(list(dict.fromkeys(c for c in codes if c)))
|
||||
return _num({"로직": _listed(found), "빠진로직": missing})
|
||||
|
||||
@@ -1,115 +0,0 @@
|
||||
"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 ·
|
||||
`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`).
|
||||
|
||||
줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 ·
|
||||
작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤).
|
||||
근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙).
|
||||
M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번).
|
||||
하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
mf = m01.cm.mf
|
||||
_Q = re.compile(r"Q\d*")
|
||||
|
||||
|
||||
def _down(value: Any, places: int) -> Any:
|
||||
return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN)
|
||||
|
||||
|
||||
def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict:
|
||||
"""로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로)."""
|
||||
node = mf.parse(item["요소"])
|
||||
if node[0] != "logic":
|
||||
return mf.evaluate(node, env, whole, depth)
|
||||
given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]}
|
||||
got = settle(whole, mf.fill(node[1], env), given, depth + 1)
|
||||
return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE}
|
||||
|
||||
|
||||
def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict:
|
||||
"""`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙."""
|
||||
row = whole.logic(ref)
|
||||
if isinstance(row.get("흐름"), dict) or "결과" in row:
|
||||
return mf.run(whole, ref, given, depth)
|
||||
env = mf._inputs(row, given)
|
||||
for step in row.get("중간", []):
|
||||
try:
|
||||
value = mf.evaluate(mf.parse(step["식"]), env, whole, depth)
|
||||
except mf.EmptyInput as e:
|
||||
env[step["이름"]] = mf.Blank(str(e))
|
||||
continue
|
||||
if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal):
|
||||
value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
|
||||
env[step["이름"]] = value
|
||||
lines: list[dict] = []
|
||||
for n, item in enumerate(row.get("호표", [])):
|
||||
try:
|
||||
qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth)
|
||||
if item["종류"] == "로직":
|
||||
bundle = _bundle(whole, item, env, depth)
|
||||
price = bundle["계"]
|
||||
split = (
|
||||
{k: qty * bundle[k] for k in mf.COST_ITEMS}
|
||||
if "비목" not in item
|
||||
else {item["비목"]: qty * price}
|
||||
)
|
||||
else:
|
||||
ref_ = (
|
||||
{
|
||||
k: mf.fill(v, env) if isinstance(v, str) else v
|
||||
for k, v in item["요소"].items()
|
||||
}
|
||||
if isinstance(item["요소"], dict)
|
||||
else mf.fill(item["요소"], env)
|
||||
)
|
||||
if isinstance(ref_, str) and qty != 0:
|
||||
whole.get(ref_)
|
||||
price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0]
|
||||
if price is None and qty == 0:
|
||||
price = Decimal(0)
|
||||
split = {item["비목"]: None if price is None else qty * price}
|
||||
except mf.EmptyInput as e:
|
||||
lines.append(mf._blank_line(item, str(e)))
|
||||
continue
|
||||
lines.append(_line(item["이름"], split))
|
||||
sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS}
|
||||
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
|
||||
for extra in row.get("덧줄", []):
|
||||
env.update(sums)
|
||||
try:
|
||||
value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth)
|
||||
env[extra["이름"]] = value
|
||||
except mf.FormulaError:
|
||||
value = None
|
||||
sums[extra["비목"]] += _down(value, 1) or 0
|
||||
lines.append(_line(extra["이름"], {extra["비목"]: value}))
|
||||
if value is not None:
|
||||
env["줄"][extra["이름"]] = lines[-1]["금액"]
|
||||
sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()}
|
||||
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)}
|
||||
|
||||
|
||||
def _line(name: str, split: dict) -> dict:
|
||||
cut = {k: _down(v, 1) for k, v in split.items()}
|
||||
whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values())
|
||||
return {"이름": name, "비목": cut, "금액": whole_sum}
|
||||
|
||||
|
||||
def apply(groups: list[dict], engine: dict, done: dict) -> None:
|
||||
"""계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음."""
|
||||
seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS}
|
||||
for eng, mine in zip(engine["줄"], done["줄"]):
|
||||
for part, _ in m01.mtx._shares(eng):
|
||||
seq[part].append(mine["비목"].get(part))
|
||||
for group in groups:
|
||||
for line, amount in zip(group["줄"], seq.get(group["비목"], [])):
|
||||
line["금액"] = amount
|
||||
group["소계"] = done[group["비목"]]
|
||||
@@ -8,13 +8,12 @@
|
||||
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
|
||||
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
|
||||
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
|
||||
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
|
||||
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
|
||||
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
|
||||
같으면 안 셈 ·
|
||||
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
|
||||
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
|
||||
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
|
||||
이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ).
|
||||
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
|
||||
"""
|
||||
|
||||
@@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str:
|
||||
return " · ".join(parts)
|
||||
|
||||
|
||||
def _unit(logic: dict) -> str:
|
||||
unit = str(logic.get("결과단위") or "")
|
||||
def _unit(doc: dict) -> str:
|
||||
unit = str(doc.get("결과단위") or "")
|
||||
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
|
||||
|
||||
|
||||
@@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
|
||||
return got.get("계") if got.get("계") is not None else got.get("결과")
|
||||
|
||||
|
||||
def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]:
|
||||
doc = m01_doc.docs().get(str(logic.get("키")))
|
||||
if doc is None:
|
||||
return []
|
||||
def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]:
|
||||
links = links or _links(whole)
|
||||
base, ax = axes(whole, doc)
|
||||
changes: list[dict] = [{}]
|
||||
for name, reps in ax:
|
||||
changes += [{name: v} for v, _ in reps if v != base.get(name)]
|
||||
head = {
|
||||
"키": logic.get("키"),
|
||||
"이름": logic.get("이름") or "",
|
||||
"단위": _unit(logic),
|
||||
"출처": logic.get("출처") or "",
|
||||
"공종": kind_of(logic),
|
||||
"별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x),
|
||||
"구분": logic.get("구분") or "",
|
||||
"상세구분": logic.get("상세구분") or "",
|
||||
"키": doc.get("키"),
|
||||
"이름": doc.get("이름") or "",
|
||||
"단위": _unit(doc),
|
||||
"출처": doc.get("출처") or "",
|
||||
"공종": kind_of(doc),
|
||||
"별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x),
|
||||
"구분": doc.get("구분") or "",
|
||||
"상세구분": doc.get("상세구분") or "",
|
||||
"막힘": blocked,
|
||||
}
|
||||
out = []
|
||||
@@ -283,12 +279,12 @@ def _stamp() -> str:
|
||||
|
||||
|
||||
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
|
||||
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
|
||||
whole = m01.loaded()[1]
|
||||
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음)."""
|
||||
whole, docs = m01.loaded()[1], m01_doc.docs()
|
||||
links = _links(whole)
|
||||
out = []
|
||||
for key in keys:
|
||||
out += _rows_of(whole, whole.logic(key), key in blocked, links)
|
||||
out += _rows_of(whole, docs[key], key in blocked, links)
|
||||
return out
|
||||
|
||||
|
||||
@@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict:
|
||||
"""기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로)."""
|
||||
why_of = m01.blocks()
|
||||
blocked = {k for k, why in why_of.items() if why}
|
||||
keys = [
|
||||
str(logic.get("키"))
|
||||
for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1]))
|
||||
for logic in data.get("줄") or []
|
||||
]
|
||||
chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order)
|
||||
keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []]
|
||||
size = max(1, len(keys) // (workers * 8))
|
||||
parts = [keys[i : i + size] for i in range(0, len(keys), size)]
|
||||
if workers > 1:
|
||||
@@ -379,13 +372,11 @@ def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
|
||||
def sheet(key: str, change: dict) -> dict:
|
||||
"""계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈)."""
|
||||
files, whole = m01.loaded()
|
||||
doc = m01_doc.docs().get(key)
|
||||
try:
|
||||
logic = whole.logic(key)
|
||||
m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글
|
||||
except m01.cm.mf.FormulaError as e:
|
||||
raise m01.StoreError(404, str(e)) from e
|
||||
if doc is None:
|
||||
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
|
||||
doc = m01_doc.docs()[key]
|
||||
given, ax = _given(whole, doc, change)
|
||||
links = _links(whole)
|
||||
got = _calc(doc, links, given) or {}
|
||||
@@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict:
|
||||
return labor_inputs._num(
|
||||
{
|
||||
"키": key,
|
||||
"이름": logic.get("이름") or "",
|
||||
"이름": doc.get("이름") or "",
|
||||
"규격": _spec(given, ax),
|
||||
"단위": _unit(logic),
|
||||
"출처": labor_inputs.sources(logic) or "",
|
||||
"단위": _unit(doc),
|
||||
"출처": labor_inputs.sources(doc) or "",
|
||||
"판": edition(files),
|
||||
"입력": given,
|
||||
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
|
||||
"계": got.get("계") if money else got.get("결과"),
|
||||
"기준단위": _unit(logic) or None,
|
||||
"기준단위": _unit(doc) or None,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -3,7 +3,9 @@
|
||||
사본 = 저장 때 서버가 찍는 M01 닫힌 묶음(`M02_Item_Prices.collect` 다시 씀) — 셈 중 문서 칸 `사본` ·
|
||||
층 저장 파일 = `수식` 의 값 몫 한 벌(`held` · 855 2-D — 파일엔 `사본` 안 씀 · 프로젝트 사본 꼴은 그대로):
|
||||
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 줄], 빠진?}
|
||||
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직 · 찾기 표 · 그 밖 요소(요율 등)
|
||||
로직 = 바탕 로직 · 더한줄 로직 · 가져온 식 이음 · 하위 로직이 닿는 찾기 표 · 그 밖 요소(요율 등) —
|
||||
단가산출 = 로직 줄(GF · GC · GX) 자체는 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름` · M01 바뀜 =
|
||||
문서 지문) · 일위대가 · 사전조합 = 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 `Labor_Copy.stamp` 에서 뺌)
|
||||
단가 = 자원 단가 줄(`RES` 노임 · 자재 · 기계 · 유가전력 · 환율) = 단가 기준 시점 묶음.
|
||||
셈 = M01 색인 위에 사본 줄을 얹은 `Copy`(키 · 원문번호 찾기만 사본 먼저 · M01 색인 안 고침) —
|
||||
`M02_Sangeun_Calc._base_of`(바탕 줄) · `run`(엔진 · 하위 로직 · 표 · 단가)이 `over` 로 부름 ·
|
||||
@@ -67,16 +69,31 @@ def has(doc: Any) -> bool:
|
||||
|
||||
FORM = "수식" # 수식 사본 칸(`M02_Doc_Copy.KEY`) — 층 저장 파일의 값 사본 자리(855 2-D)
|
||||
VALUES = ("판", "시점", "로직", "단가판", "단가시점", "단가")
|
||||
#: M01 로직 줄 키 머리(GF · GC · GX) — 단가산출 값 사본에 안 담음 · 안 읽음(855 L2 ⓑ · 셈 = 수식 문서 사본 `부름`)
|
||||
LOGIC = frozenset(t for t, g in prices.mf.mk.GROUP_OF.items() if g == "로직")
|
||||
|
||||
|
||||
def plain(rows: Any) -> list:
|
||||
"""값 사본 줄에서 로직 줄을 뺌(표 · 요율 · 자원 줄만)."""
|
||||
return [r for r in rows or [] if not (isinstance(r, dict) and str(r.get("키"))[:2] in LOGIC)]
|
||||
|
||||
|
||||
def _plain(copy: dict) -> dict:
|
||||
"""단가산출 값 사본 — 로직 줄 뺀 꼴 · 판 다시(옛 저장본 = 읽을 때 뺌 · 파일은 다음 [저장] 때 새 꼴)."""
|
||||
rows = plain(copy["로직"])
|
||||
return copy if len(rows) == len(copy["로직"]) else {**copy, "로직": rows, "판": _fp(rows)}
|
||||
|
||||
|
||||
def held(doc: Any) -> dict | None:
|
||||
"""문서의 값 사본 — 셈 · 저장 중 `settle` 이 붙인 `사본` › 층 저장 파일 `수식` 의 값 몫(855 2-D ·
|
||||
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 없음 = None."""
|
||||
층 파일엔 `사본` 을 안 씀 · 프로젝트 사본은 `사본` 그대로) · 단가산출 = 로직 줄 뺌(855 L2 ⓑ) · 없음 = None."""
|
||||
sk = isinstance(doc, dict) and doc.get("종류") == sd.TITLE
|
||||
if has(doc):
|
||||
return doc[KEY]
|
||||
return _plain(doc[KEY]) if sk else doc[KEY]
|
||||
form = doc.get(FORM) if isinstance(doc, dict) else None
|
||||
if isinstance(form, dict) and isinstance(form.get("로직"), list):
|
||||
return {k: form[k] for k in VALUES if k in form}
|
||||
got = {k: form[k] for k in VALUES if k in form}
|
||||
return _plain(got) if sk else got
|
||||
return None
|
||||
|
||||
|
||||
@@ -327,7 +344,7 @@ def settle(doc: Any, save: bool = False) -> Any:
|
||||
if save and copy and READS.get() is None: # 읽은 줄만(826-3) = 저장 관문이 더함
|
||||
copy = grow(copy, stamp(out))
|
||||
out = _formula_job(out, job)
|
||||
return {**out, KEY: copy} if copy else out
|
||||
return {**out, KEY: _plain(copy)} if copy else out # 로직 줄 안 담음(855 L2 ⓑ)
|
||||
|
||||
|
||||
def _formula_job(out: dict, job: Any) -> dict:
|
||||
@@ -340,7 +357,14 @@ def _formula_job(out: dict, job: Any) -> dict:
|
||||
if got is None or job not in (PRICE, REGEN):
|
||||
return out
|
||||
if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림
|
||||
drop = ("문서", "끊음", "따로", "처음", *renew.KEEP)
|
||||
drop = (
|
||||
"문서",
|
||||
"끊음",
|
||||
"따로",
|
||||
"처음",
|
||||
"바탕문서",
|
||||
*renew.KEEP,
|
||||
) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ)
|
||||
got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}}
|
||||
elif got.get("따로"):
|
||||
got = dc.refresh(got)[0]
|
||||
@@ -373,7 +397,22 @@ def mark(ans: dict, doc: dict) -> dict:
|
||||
return ans
|
||||
copy = doc[KEY]
|
||||
head = {"시점": copy.get("시점"), "단가시점": copy.get("단가시점")}
|
||||
return {**ans, KEY: {**head, **state(copy, whole_())}}
|
||||
got = state(copy, whole_())
|
||||
if not got["M01새판"] and _doc_moved(doc):
|
||||
got = {**got, "M01새판": True}
|
||||
return {**ans, KEY: {**head, **got}}
|
||||
|
||||
|
||||
def _doc_moved(doc: dict) -> bool:
|
||||
"""M01 바뀜 = 수식 사본 문서(부름 · 원본) 지문 ≠ 지금 M01 문서(855 L2 ⓑ · 로직 줄 값 사본 대신) ·
|
||||
자동 따라옴 SK = 늘 지금 문서라 안 봄."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
form = doc.get(FORM)
|
||||
if not dc.has(doc) or (renew.is_sk(doc) and renew.on() and not renew.frozen(form)):
|
||||
return False
|
||||
return bool(dc.state(form)["문서새판"])
|
||||
|
||||
|
||||
def same_part(doc: Any) -> str | None:
|
||||
@@ -382,5 +421,5 @@ def same_part(doc: Any) -> str | None:
|
||||
if copy is None:
|
||||
return None
|
||||
seen = state(copy, whole_())
|
||||
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"])
|
||||
fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"] or _doc_moved(doc))
|
||||
return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}"
|
||||
|
||||
@@ -97,9 +97,9 @@ def rows(copy: Any) -> Any:
|
||||
return {**copy, **hit}
|
||||
got: dict = {}
|
||||
for part, mark in (("로직", "판"), ("단가", "단가판")):
|
||||
old = copy.get(part) or []
|
||||
old = skc.plain(copy.get(part)) # 로직 줄 = 문서 사본 · 값 사본에 안 둠(855 L2 ⓑ)
|
||||
new = [_fresh(r, live) if isinstance(r, dict) else r for r in old]
|
||||
if any(a is not b for a, b in zip(old, new)):
|
||||
if len(old) != len(copy.get(part) or []) or any(a is not b for a, b in zip(old, new)):
|
||||
got |= {part: new, mark: skc._fp(new)}
|
||||
if len(_MEMO) > 64: # ponytail: 통째 비움 · SK 가 많아 느려지면 LRU 로
|
||||
_MEMO.clear()
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
|
||||
|
||||
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
|
||||
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal
|
||||
|
||||
import master_keys as mk
|
||||
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
|
||||
|
||||
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
|
||||
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
|
||||
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
|
||||
TABLE_GROUPS = ("소요량", "계수")
|
||||
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
|
||||
COST_ITEMS = ("노무비", "재료비", "경비")
|
||||
BUNDLE = (*COST_ITEMS, "계")
|
||||
|
||||
|
||||
class FormulaError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class EmptyInput(FormulaError):
|
||||
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
|
||||
|
||||
|
||||
class NoRow(EmptyInput):
|
||||
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
|
||||
|
||||
|
||||
def _plain(v) -> str:
|
||||
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
|
||||
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
|
||||
|
||||
|
||||
# ── 마스터 모음 ────────────────────────────────────────────────────────
|
||||
class Master:
|
||||
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
|
||||
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
|
||||
|
||||
def __init__(self, files: dict[str, dict]):
|
||||
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
|
||||
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
|
||||
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
|
||||
for data in files.values():
|
||||
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
|
||||
for row in rows or []:
|
||||
key = str(row.get("키"))
|
||||
self.index.setdefault(key[:2], {}).setdefault(key, row)
|
||||
if row.get("원문번호"):
|
||||
number = str(row["원문번호"])
|
||||
slot = self.numbers.setdefault(key[:2], {})
|
||||
if number in slot:
|
||||
self.twice.add((key[:2], number))
|
||||
slot.setdefault(number, row)
|
||||
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
|
||||
|
||||
def get(self, ref: str) -> dict:
|
||||
tid, _, number = ref.partition(":")
|
||||
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
|
||||
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
|
||||
elif number:
|
||||
if (tid, number) in self.twice:
|
||||
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
|
||||
row = self.numbers.get(tid, {}).get(number)
|
||||
else:
|
||||
row = self.index.get(ref[:2], {}).get(ref)
|
||||
if row is None:
|
||||
raise FormulaError(f"없는 요소 「{ref}」")
|
||||
return row
|
||||
|
||||
def label(self, ref) -> str:
|
||||
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
|
||||
if isinstance(ref, dict):
|
||||
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
|
||||
try:
|
||||
row = self.get(ref)
|
||||
except FormulaError:
|
||||
return ref
|
||||
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
|
||||
|
||||
def value(self, ref: str):
|
||||
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
|
||||
row = self.get(ref)
|
||||
alias = row.get("준용")
|
||||
if alias not in (None, ""):
|
||||
target = self.get(str(alias))
|
||||
name = target.get("이름") or alias
|
||||
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
|
||||
return row.get("값"), f"추정(준용: {name})"
|
||||
return target.get("값"), f"준용: {name}"
|
||||
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
|
||||
|
||||
def logic(self, ref: str) -> dict:
|
||||
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
|
||||
raise FormulaError(f"로직 아님 「{ref}」")
|
||||
return self.get(ref)
|
||||
|
||||
|
||||
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
|
||||
def _match(table: dict, row: dict, cond: str, want) -> bool:
|
||||
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
|
||||
return True
|
||||
have = row[cond]
|
||||
if table.get("조건", {}).get(cond) == "범위":
|
||||
low, high = have
|
||||
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
|
||||
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
|
||||
if rule == "이상·이하":
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
if rule == "초과·이하":
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·미만":
|
||||
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
|
||||
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
|
||||
closed = any("이하 포함" in x for x in more) and high == top
|
||||
return (low is None or want >= low) and (
|
||||
high is None or want < high or (closed and want == high)
|
||||
)
|
||||
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
|
||||
return have == want
|
||||
|
||||
|
||||
def _name(row: dict) -> str:
|
||||
return f"{row.get('키')} {row.get('원문번호')}"
|
||||
|
||||
|
||||
def find(table: dict, conds: dict, want: str | None = None) -> dict:
|
||||
for cond in conds:
|
||||
if cond not in table.get("조건", {}):
|
||||
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
|
||||
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
|
||||
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
|
||||
for c in conds:
|
||||
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
|
||||
if ups and None not in ups:
|
||||
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
|
||||
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
|
||||
hits = [row for row in hits if want in row]
|
||||
if len(hits) != 1:
|
||||
where = f"표 {table.get('키')}({table.get('원문번호')})"
|
||||
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
|
||||
raise NoRow(
|
||||
f"{where}에 {what} 인 줄이 없음"
|
||||
if not hits
|
||||
else f"{where}에 {what} 인 줄이 {len(hits)}개"
|
||||
)
|
||||
return hits[0]
|
||||
|
||||
|
||||
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
|
||||
from master_material import ( # noqa: E402, F401
|
||||
LINKED,
|
||||
PICK_KEYS,
|
||||
REGION,
|
||||
SLOTS,
|
||||
TARIFF,
|
||||
candidates,
|
||||
check_pick,
|
||||
check_unit,
|
||||
static,
|
||||
cond_text,
|
||||
element,
|
||||
pick,
|
||||
)
|
||||
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
|
||||
@@ -11,7 +11,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import master_doc as md
|
||||
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
|
||||
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
|
||||
import master_keys as mk
|
||||
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@ from pathlib import Path
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
import master_formula as mf
|
||||
import master_base as mf # 바탕 기반(색인 · 오류)
|
||||
import master_machine_crew as mcrew
|
||||
import master_material as mm
|
||||
import master_pick as mp
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import master_doc_calc as mc
|
||||
import master_formula as mf
|
||||
import master_base as mf # 바탕 기반(색인 · 오류)
|
||||
|
||||
|
||||
class Rec:
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
|
||||
`check_master.py` 가 부름.
|
||||
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -12,15 +13,22 @@ import re
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
|
||||
|
||||
import master_keys as mk
|
||||
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
|
||||
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
|
||||
BUNDLE,
|
||||
COST_ITEMS,
|
||||
GROUPS,
|
||||
TABLE_GROUPS,
|
||||
TABLE_IDS,
|
||||
EmptyInput,
|
||||
FormulaError,
|
||||
Master,
|
||||
NoRow,
|
||||
_match,
|
||||
_name,
|
||||
_plain,
|
||||
find,
|
||||
)
|
||||
|
||||
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
|
||||
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
|
||||
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
|
||||
TABLE_GROUPS = ("소요량", "계수")
|
||||
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
|
||||
COST_ITEMS = ("노무비", "재료비", "경비")
|
||||
BUNDLE = (*COST_ITEMS, "계")
|
||||
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
|
||||
_NAME = re.compile(r"[\w가-힣]+")
|
||||
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
|
||||
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
|
||||
raise FormulaError(FLOW_GONE)
|
||||
|
||||
|
||||
class FormulaError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class EmptyInput(FormulaError):
|
||||
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
|
||||
|
||||
|
||||
class NoRow(EmptyInput):
|
||||
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
|
||||
|
||||
|
||||
class Blank:
|
||||
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
|
||||
|
||||
@@ -57,11 +53,6 @@ class Blank:
|
||||
self.why = why
|
||||
|
||||
|
||||
def _plain(v) -> str:
|
||||
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
|
||||
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
|
||||
|
||||
|
||||
# ── 읽기 ──────────────────────────────────────────────────────────────
|
||||
class _Parser:
|
||||
def __init__(self, text: str):
|
||||
@@ -257,70 +248,6 @@ def walk(node):
|
||||
yield from walk(item)
|
||||
|
||||
|
||||
# ── 마스터 모음 ────────────────────────────────────────────────────────
|
||||
class Master:
|
||||
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
|
||||
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
|
||||
|
||||
def __init__(self, files: dict[str, dict]):
|
||||
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
|
||||
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
|
||||
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
|
||||
for data in files.values():
|
||||
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
|
||||
for row in rows or []:
|
||||
key = str(row.get("키"))
|
||||
self.index.setdefault(key[:2], {}).setdefault(key, row)
|
||||
if row.get("원문번호"):
|
||||
number = str(row["원문번호"])
|
||||
slot = self.numbers.setdefault(key[:2], {})
|
||||
if number in slot:
|
||||
self.twice.add((key[:2], number))
|
||||
slot.setdefault(number, row)
|
||||
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
|
||||
|
||||
def get(self, ref: str) -> dict:
|
||||
tid, _, number = ref.partition(":")
|
||||
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
|
||||
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
|
||||
elif number:
|
||||
if (tid, number) in self.twice:
|
||||
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
|
||||
row = self.numbers.get(tid, {}).get(number)
|
||||
else:
|
||||
row = self.index.get(ref[:2], {}).get(ref)
|
||||
if row is None:
|
||||
raise FormulaError(f"없는 요소 「{ref}」")
|
||||
return row
|
||||
|
||||
def label(self, ref) -> str:
|
||||
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
|
||||
if isinstance(ref, dict):
|
||||
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
|
||||
try:
|
||||
row = self.get(ref)
|
||||
except FormulaError:
|
||||
return ref
|
||||
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
|
||||
|
||||
def value(self, ref: str):
|
||||
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
|
||||
row = self.get(ref)
|
||||
alias = row.get("준용")
|
||||
if alias not in (None, ""):
|
||||
target = self.get(str(alias))
|
||||
name = target.get("이름") or alias
|
||||
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
|
||||
return row.get("값"), f"추정(준용: {name})"
|
||||
return target.get("값"), f"준용: {name}"
|
||||
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
|
||||
|
||||
def logic(self, ref: str) -> dict:
|
||||
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
|
||||
raise FormulaError(f"로직 아님 「{ref}」")
|
||||
return self.get(ref)
|
||||
|
||||
|
||||
def fill(template: str, env: dict) -> str:
|
||||
def one(m):
|
||||
if m.group(1) not in env:
|
||||
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
|
||||
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
|
||||
|
||||
|
||||
def _match(table: dict, row: dict, cond: str, want) -> bool:
|
||||
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
|
||||
return True
|
||||
have = row[cond]
|
||||
if table.get("조건", {}).get(cond) == "범위":
|
||||
low, high = have
|
||||
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
|
||||
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
|
||||
if rule == "이상·이하":
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
if rule == "초과·이하":
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·미만":
|
||||
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
|
||||
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
|
||||
closed = any("이하 포함" in x for x in more) and high == top
|
||||
return (low is None or want >= low) and (
|
||||
high is None or want < high or (closed and want == high)
|
||||
)
|
||||
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
|
||||
return have == want
|
||||
|
||||
|
||||
def _name(row: dict) -> str:
|
||||
return f"{row.get('키')} {row.get('원문번호')}"
|
||||
|
||||
|
||||
def find(table: dict, conds: dict, want: str | None = None) -> dict:
|
||||
for cond in conds:
|
||||
if cond not in table.get("조건", {}):
|
||||
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
|
||||
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
|
||||
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
|
||||
for c in conds:
|
||||
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
|
||||
if ups and None not in ups:
|
||||
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
|
||||
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
|
||||
hits = [row for row in hits if want in row]
|
||||
if len(hits) != 1:
|
||||
where = f"표 {table.get('키')}({table.get('원문번호')})"
|
||||
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
|
||||
raise NoRow(
|
||||
f"{where}에 {what} 인 줄이 없음"
|
||||
if not hits
|
||||
else f"{where}에 {what} 인 줄이 {len(hits)}개"
|
||||
)
|
||||
return hits[0]
|
||||
|
||||
|
||||
def evaluate(node, env: dict, master: Master, depth: int = 0):
|
||||
kind = node[0]
|
||||
if kind in ("num", "str"):
|
||||
|
||||
@@ -284,5 +284,5 @@ def element(
|
||||
return min(offers, key=lambda x: x[0]) if offers else (None, None)
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_pick as mp # noqa: E402 — 검색어 찾기
|
||||
|
||||
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
|
||||
return []
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고).
|
||||
② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는
|
||||
남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길.
|
||||
③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
|
||||
③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -13,6 +13,7 @@ from decimal import Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
@@ -132,7 +133,7 @@ def test_사전조합_안_줄도_별도계상_뺌():
|
||||
|
||||
# ── ③ 원문 여럿 ──────────────────────────────────────────────────────
|
||||
def test_원문_출처는_같은_책_절_모두():
|
||||
src = inputs.sources(_whole().logic(MIX))
|
||||
src = inputs.sources(m01_doc.docs()[MIX])
|
||||
assert src == "산림품셈 12-1-2 · 12-1-3"
|
||||
assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src
|
||||
assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"]
|
||||
@@ -143,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로():
|
||||
assert inputs.sources({"출처": None}) is None
|
||||
one = {
|
||||
"출처": "산림품셈 3-1",
|
||||
"호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}],
|
||||
"금액": [
|
||||
{"수량": "1", "출처": "건설품셈 공통 1-2-4 3"},
|
||||
{"수량": "1", "출처": "산림품셈 3-1"},
|
||||
],
|
||||
}
|
||||
assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임
|
||||
|
||||
@@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) ·
|
||||
|
||||
def _rows(key: str) -> list[dict]:
|
||||
whole = m01.loaded()[1]
|
||||
return st._rows_of(whole, whole.logic(key), False)
|
||||
return st._rows_of(whole, m01_doc.docs()[key], False)
|
||||
|
||||
|
||||
def _given(key: str, change: dict) -> dict:
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0).
|
||||
"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈).
|
||||
|
||||
거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값.
|
||||
옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ).
|
||||
"""
|
||||
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
@@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2]
|
||||
if str(ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
|
||||
|
||||
mf = m01.cm.mf
|
||||
PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"}
|
||||
|
||||
|
||||
def _plain(row: dict) -> bool:
|
||||
"""로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음."""
|
||||
return (
|
||||
str(row.get("결과단위") or "").startswith("원")
|
||||
and not row.get("덧줄")
|
||||
and not row.get("끝수")
|
||||
and not any(i.get("종류") == "로직" for i in row.get("호표") or [])
|
||||
and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or [])
|
||||
)
|
||||
|
||||
|
||||
def test_줄마다_버림_비목마다_버림_B09와_같음():
|
||||
files, whole = m01.loaded()
|
||||
checked = 0
|
||||
for _, data in m01._logic_files(files):
|
||||
for row in data.get("줄") or []:
|
||||
if not _plain(row) or checked >= 60:
|
||||
continue
|
||||
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
|
||||
given = mf.fill_empty(row, base)
|
||||
got = mf.run(whole, row["키"], given)
|
||||
lines = []
|
||||
for line in got["줄"]:
|
||||
one = dict.fromkeys(PART_OF.values(), 0.0)
|
||||
for part, money in line["비목"].items():
|
||||
one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None
|
||||
lines.append(one)
|
||||
if any(v is None for one in lines for v in one.values()):
|
||||
continue
|
||||
want = sg.block_totals(lines)
|
||||
mine = st.settle(whole, row["키"], given)
|
||||
for name, part in PART_OF.items():
|
||||
assert float(mine[name]) == want[part], (row["키"], name)
|
||||
assert float(mine["계"]) == want["sum"], row["키"]
|
||||
checked += 1
|
||||
assert checked >= 30
|
||||
|
||||
|
||||
def test_계산서_줄_소계_계가_맞물림():
|
||||
files, whole = m01.loaded()
|
||||
|
||||
@@ -15,6 +15,7 @@ from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
@@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄():
|
||||
whole = m01.loaded()[1]
|
||||
rows = []
|
||||
for key in (GF, "GC000269", "GC001109"):
|
||||
rows += standard._rows_of(whole, whole.logic(key), False)
|
||||
rows += standard._rows_of(whole, m01_doc.docs()[key], False)
|
||||
assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕
|
||||
got = _heads(rows)
|
||||
assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"]
|
||||
|
||||
@@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()):
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
files, live = m01.loaded()
|
||||
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
|
||||
fake = copy.copy(
|
||||
live
|
||||
) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ)
|
||||
fake.index = {t: dict(v) for t, v in live.index.items()}
|
||||
fake.numbers = {t: dict(v) for t, v in live.numbers.items()}
|
||||
for row in rows:
|
||||
row, key = copy.deepcopy(row), str(row["키"])
|
||||
fake.index.setdefault(key[:2], {})[key] = row
|
||||
if row.get("원문번호"):
|
||||
fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row
|
||||
for key in drop:
|
||||
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
|
||||
fake.index.get(key[:2], {}).pop(key, None)
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
|
||||
docs = {k: v for k, v in dc.folder().items() if k not in drop}
|
||||
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
|
||||
@@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
got = skc.held(_doc(me, key))
|
||||
assert PCT in {r["키"] for r in got["로직"]}
|
||||
assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ)
|
||||
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
|
||||
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
|
||||
first = _calc(me, _doc(me, key))
|
||||
@@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch):
|
||||
|
||||
|
||||
def test_deleted_keys_keep_last_value(world, monkeypatch):
|
||||
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
|
||||
"""⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409)."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
was = _sum(me, key)
|
||||
lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB"))
|
||||
_fake(monkeypatch, drop=[PCT, lb])
|
||||
with pytest.raises(Exception):
|
||||
m01.loaded()[1].logic(PCT)
|
||||
_fake(monkeypatch, drop=[lb])
|
||||
now = _calc(me, _doc(me, key))
|
||||
assert now["기준"]["계"] == was
|
||||
assert {PCT, lb} <= set(now["사본"]["지운키"])
|
||||
assert {lb} <= set(now["사본"]["지운키"])
|
||||
with store.at(me):
|
||||
got = path.preview(key, {"할일": skc.PRICE})
|
||||
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
|
||||
|
||||
@@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈():
|
||||
whole = m01.loaded()[1]
|
||||
docs, links, _ = world()
|
||||
for key in ("GF000220", "GC000404", "GX000004"):
|
||||
for row in st._rows_of(whole, whole.logic(key), False, links):
|
||||
for row in st._rows_of(whole, docs[key], False, links):
|
||||
given = st._given(whole, docs[key], row["바꿈"])[0]
|
||||
want = mc.calc(docs[key], links, given)
|
||||
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
|
||||
|
||||
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
|
||||
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
|
||||
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[1]
|
||||
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
|
||||
N = 24 # 견본 로직 수(키 차례 고르게)
|
||||
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
|
||||
"master_formula",
|
||||
"master_formula_check",
|
||||
"master_formula_sum",
|
||||
"master_cut",
|
||||
"master_text",
|
||||
"master_text_item",
|
||||
"master_auto",
|
||||
"master_combo",
|
||||
"master_sheet_line",
|
||||
"master_gate",
|
||||
"master_equation",
|
||||
"check_master",
|
||||
)
|
||||
|
||||
|
||||
def _enc(v):
|
||||
if isinstance(v, Decimal):
|
||||
return {"$d": str(v)}
|
||||
raise TypeError(type(v).__name__)
|
||||
|
||||
|
||||
def _dec(d: dict):
|
||||
return Decimal(d["$d"]) if set(d) == {"$d"} else d
|
||||
|
||||
|
||||
def _child() -> None:
|
||||
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
|
||||
sys.path.insert(0, str(SCRIPTS))
|
||||
import master_base as mb
|
||||
import master_doc_calc as mc
|
||||
import master_doc_link as ml
|
||||
import master_machine_files as mmf
|
||||
|
||||
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
|
||||
files = {}
|
||||
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
|
||||
if name == mmf.NAME and mmf.here(folder):
|
||||
files[name] = mmf.table(folder)[0]
|
||||
elif not name.startswith("_"):
|
||||
raw = (folder / name).read_bytes()
|
||||
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
|
||||
docs = ml.load_all()
|
||||
links = ml.Links(mb.Master(files), docs)
|
||||
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
|
||||
out = {}
|
||||
for key, cases in want.items():
|
||||
rows = []
|
||||
for label, changed in cases:
|
||||
try:
|
||||
got = mc.calc(docs[key], links, changed)
|
||||
except Exception:
|
||||
got = None
|
||||
rows.append([label, got if got and got.get("셈됨") else None])
|
||||
out[key] = rows
|
||||
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
|
||||
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
|
||||
|
||||
|
||||
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
|
||||
import helper_855_engine as h
|
||||
from helper_test_all import spread
|
||||
|
||||
rows, _, docs, _ = h.world()
|
||||
rows = spread([r for r in rows if str(r["키"]) in docs], N)
|
||||
want = {
|
||||
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
|
||||
}
|
||||
run = subprocess.run(
|
||||
[sys.executable, str(Path(__file__)), "--child"],
|
||||
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
|
||||
capture_output=True,
|
||||
cwd=str(ROOT),
|
||||
timeout=600,
|
||||
)
|
||||
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
|
||||
body = json.loads(run.stdout.decode("utf-8"))
|
||||
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
|
||||
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
|
||||
diff = []
|
||||
for key, cases in body["답"].items():
|
||||
got = [[label, h.answer(g)] for label, g in cases]
|
||||
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
|
||||
diff.append(key)
|
||||
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
|
||||
|
||||
|
||||
if __name__ == "__main__" and "--child" in sys.argv:
|
||||
_child()
|
||||
@@ -0,0 +1,50 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 ·
|
||||
일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌).
|
||||
|
||||
임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
from decimal import Decimal
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from resources.tester.test_795_1_sk_copy import _doc, _sk
|
||||
from resources.tester.test_795_2_sc_copy import PCT, _read, _sc
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
|
||||
def _logic_rows(doc: dict) -> list[str]:
|
||||
rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])]
|
||||
return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC]
|
||||
|
||||
|
||||
def _sum(folder, doc) -> Decimal:
|
||||
with store.at(folder):
|
||||
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
|
||||
|
||||
|
||||
def test_저장본에_로직줄_없음_금액_같음(world):
|
||||
me = world["personal"]
|
||||
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
|
||||
sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}]))
|
||||
assert _logic_rows(sk) == [] and PCT in _logic_rows(sc)
|
||||
assert _sum(me, sk) > 0
|
||||
|
||||
|
||||
def test_옛_저장본_로직줄은_안_읽음(world):
|
||||
me = world["personal"]
|
||||
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
|
||||
was = _sum(me, sk)
|
||||
old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것)
|
||||
row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str))
|
||||
row["호표"] = row["호표"][:1]
|
||||
old["수식"]["로직"] = [*old["수식"]["로직"], row]
|
||||
assert skc.held(old)["로직"] == skc.held(sk)["로직"]
|
||||
assert _sum(me, old) == was
|
||||
Reference in New Issue
Block a user