feat(855-C): 2-C4 기준 목록 · 계산서를 수식 문서 셈으로 · 서버 산출근거 글 모듈 새로

- 새 `master_doc_text.py` — 문서 셈 답 → 산출근거 글(금액 줄 · 묶음 줄 · 계 줄 · 계산서 묶음) · 화면 짝(line_stack_out · eqText · unitText · moneyUnits · offLine) 규칙을 옮김 · 거울 시험 `test_855_c4_doc_text`(+ helper .cjs)
- `M02_Logic_Standard` — 기준 목록 축 = 문서 선택 변수 · 표 조건 입력 변수 · 바탕 = 문서 기본값 · 금액 = 문서 셈 · 계산서 = 문서 셈 + 새 글 · 파생 저장본 열쇠에 수식 문서 지문(SHAPE 4) · 답 꼴 그대로(화면 안 고침) · `M02_Logic_Settle` 은 B09 짝이라 남김
- 전수(1,521 기초 · 옛 줄 11,267): 같은 입력이면 금액 같음 11,165 · 다름 101 = 옛 목록만의 B09 산근 끝수(settle) — 새 값 = 옛 엔진 값 = M02 단가산출 값 · 옛 엔진 멈춤 1(새 0 원 줄은 목록에서 빠짐)
- 바탕 = 문서 기본값(옛 = master_auto 자동값) — 114 기초의 바탕 줄 규격이 바뀜(시험입력 · 기본 칸을 담은 문서 기본값)
- 시험 고침: test_704_logic_standard(옛 엔진 끝수 차 3 원 허용 → 수식 탭 셈과 같음) · test_704_settle(축 · 금액 인자가 문서) · test_714_1 의 「M01 /text 와 M02 계산서가 같은 줄 꼴」 시험 지움(M02 계산서가 옛 덧칸 길을 안 탐 — 까닭: 855-C 새 길)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 17:59:31 +09:00
co-authored by Claude Opus 5.5
parent c2ea206f6a
commit c42d66ad68
7 changed files with 672 additions and 87 deletions
+103 -61
View File
@@ -1,17 +1,20 @@
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 요구서 4장 8) — 로직 고르기 창이 읽음.
"""M02 기준 목록 · 계산서 보기(PLAN 704-1 · 704-2 · 855-C 2-C4 · 요구서 4장 8) — 로직 고르기 창.
기준 목록 = 단가산출 로직 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
대표 규격 = 고르기 입력 값 전부 · 표 찾기 조건으로 쓰이는 수 입력은 그 표 줄마다 값 하나(범위 줄은
위 끝) · 그 밖 연속 값 입력은 견본 자동값(`master_auto.values`) 한 줄 · 지역 = 자동값(전국평균).
펼침 = 바탕(자동값 · 규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
기준 목록 = 단가산출 기초 하나를 대표 규격으로 펼친 줄(품명 · 규격 · 단위 · 금액 · 출처 · 공종).
대표 규격 = 수식 문서 선택 변수(`선택 목록`) 값 전부 · 표 조건으로 바로 쓰이는 입력 변수는
그 표 줄마다 값 하나(범위 줄은 위 끝) · 지역 = 문서 기본값(전국평균) 한 벌 ·
바탕 = 문서 변수 기본값(`연결.값`).
펼침 = 바탕(규격 축은 첫 대표 값) 한 줄 + 규격 축마다 값 하나씩 바꾼 줄(곱하지 않음 ·
바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌).
금액 = M01 엔진 식 + B09 산근 끝수(줄마다 버림 · `M02_Logic_Settle` · 근거 지식DB
`technical_info/01_임도/05_원가정보/단수처리_규칙.md`) · 최신 판 노임(마스터 판).
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개 · 수 분) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 내용 지문 + `SHAPE` · 같으면 안 셈 ·
금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) ·
계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판).
(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.)
목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본
(storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` ·
같으면 안 셈 ·
셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸).
실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음.
계산서 = `master_text.lines`(줄 「석공 | 268,908 * 0.1 = 26,891」 · 비목 소계 · 계) + 같은 끝수 값.
이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫).
M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인).
"""
@@ -26,15 +29,18 @@ from decimal import Decimal
from typing import Any
from common_util.common_util_derived_store import derived_key, read_derived, write_derived
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_Inputs as labor_inputs
from M02_MasterTemplete import M02_Logic_Settle as settle
from M02_MasterTemplete import M02_Template_Layers as layers
mf = m01.cm.mf
import master_sheet_line as msl # noqa: E402 — 계산서 줄 덧칸(714-1) · scripts 길은 `m01` 이 둠
import master_doc as md # noqa: E402 — scripts 길은 `m01` 이 둠
import master_doc_calc as mc # noqa: E402
import master_doc_link as ml # noqa: E402
import master_doc_text as mdt # noqa: E402 — 계산서 줄 글(줄 쌓기 산출근거와 같은 규칙)
SHAPE = 3 # 줄 꼴이 바뀌면 올림 — 옛 저장본을 안 씀
SHAPE = 4 # 줄 꼴 · 셈이 바뀌면 올림 — 옛 저장본을 안 씀(4 = 855-C 문서 셈)
KIND = "m02_logic_standard"
REGION = "지역" # 지역 = 자동값 한 벌(정함 8)
QUIET = ("해당 없음", "없음") # 규격 글에서 뺄 값
@@ -95,7 +101,7 @@ def words_of(row: dict) -> list[str]:
def _range_label(table: dict, low: Any, high: Any, unit: str) -> str:
f = m01.mtx.fmt
f = mdt.eq_text
if low is None:
return f"{f(high)}{unit} 이하"
if high is None:
@@ -118,29 +124,52 @@ def _table_reps(whole: Any, ref: str, cond: str, unit: str) -> list[tuple[Any, s
continue
if not ranged:
if isinstance(have, Decimal):
out.setdefault(have, f"{m01.mtx.fmt(have)}{unit}")
out.setdefault(have, f"{mdt.eq_text(have)}{unit}")
continue
low, high = have
tries = [v for v in (high, low, (low or 0) + 1) if isinstance(v, Decimal)]
got = next((v for v in tries if m01.cm.mf._match(table, r, cond, v)), None)
got = next((v for v in tries if ml._match(table, r, cond, v)), None)
if got is not None:
out.setdefault(got, _range_label(table, low, high, unit))
return sorted(out.items())
def axes(whole: Any, logic: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
"""(바탕 입력, [(입력 이름, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 고르기 · 표 찾기 수 입력."""
base = m01.mau.values(whole, logic)
finds, _ = m01.mau._uses(logic)
def _default(var: dict) -> Any:
"""문서 변수 기본값(`연결.값`) — 수 글은 수로."""
value = (var.get("연결") or {}).get("값")
if isinstance(value, str) and value.strip():
num = mdt._dec(value)
return value if num is None else num
return value
def axes(whole: Any, doc: dict) -> tuple[dict, list[tuple[str, list[tuple[Any, str]]]]]:
"""(바탕 입력, [(변수 열쇠, [(값, 글) …]) …]) — 규격 축 = 지역 뺀 선택 변수(`선택 목록`) ·
표 조건으로 바로 쓰이는 입력 변수(그 표 줄마다 값 하나) · 바탕 = 문서 기본값."""
found = [
v for v in doc.get("변수") or [] if (v.get("연결") or {}).get("갈래") in ("선택", "입력")
]
base = {str(v["열쇠"]): _default(v) for v in found}
ids = {md.var_id(v): str(v["열쇠"]) for v in found}
finds: dict[str, list[tuple[str, str]]] = {}
for v in doc.get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") != "표":
continue
for cond, expr in (link.get("조건") or {}).items():
node = mdt.node_of(expr)
if node and node[0] == "var" and node[1] in ids:
finds.setdefault(ids[node[1]], []).append((str(link.get("표")), cond))
out = []
for spec in logic.get("입력") or []:
name = spec["이름"]
for var in found:
name, link = str(var["열쇠"]), var["연결"]
if name == REGION:
continue
unit = str(spec.get("단위") or "")
if spec.get("고르기"):
unit = str(var.get("단위") or "")
if link["갈래"] == "선택":
spec = {"이름": name, "고르기": link.get("목록") or []}
labels = labor_inputs._labels(whole, spec)
reps = [(v, str(labels.get(v, m01.mtx.fmt(v) if isinstance(v, Decimal) else v)))
reps = [(v, str(labels.get(v, mdt.eq_text(v) if isinstance(v, Decimal) else v)))
for v in spec["고르기"]] # fmt: skip
elif name in finds:
seen: dict[Any, str] = {}
@@ -172,18 +201,34 @@ def _unit(logic: dict) -> str:
return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit)
def _money(whole: Any, logic: dict, given: dict) -> Decimal | None:
if not str(logic.get("결과단위") or "").startswith("원"):
return None
def _links(whole: Any) -> Any:
return ml.Links(whole, m01_doc.docs())
def _calc(doc: dict, links: Any, given: dict) -> dict | None:
try:
got = settle.settle(whole, str(logic["키"]), m01.cm.mf.fill_empty(logic, given))
except (m01.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
got = mc.calc(doc, links, given)
except Exception: # noqa: BLE001 — 계산기는 예외 없음이 원칙 · 혹시 = 못 셈
return None
return got.get("계", got.get("결과"))
return got if got.get("셈됨") else None
def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
base, ax = axes(whole, logic)
def _money(doc: dict, links: Any, given: dict) -> Decimal | None:
"""돈 기초(결과단위 「원…」)의 계(돈 아닌 결과 문서 = 결과) — 못 셈 = None."""
if not str(doc.get("결과단위") or "").startswith("원"):
return None
got = _calc(doc, links, given)
if got is None:
return 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 []
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)]
@@ -201,7 +246,7 @@ def _rows_of(whole: Any, logic: dict, blocked: bool) -> list[dict]:
out = []
for change in changes:
given = {**base, **change}
money = _money(whole, logic, given)
money = _money(doc, links, given)
if change and money == 0: # 표에 없는 규격 조합(견치돌 · 뒷길이 25 따위) — 0 원 줄은 뺌
continue
out.append(
@@ -231,15 +276,19 @@ def _stamp() -> str:
if not name.startswith("_"):
sha.update(name.encode())
sha.update(hashlib.sha1(m01.cm.mmf.raw(m01.FOLDER, name)).digest())
for path in sorted(m01_doc.folder().glob("수식_*.json")): # 수식 문서(855-C · 셈 정본)
sha.update(path.name.encode())
sha.update(hashlib.sha1(path.read_bytes()).digest())
return sha.hexdigest()
def _chunk(keys: list[str], blocked: set[str]) -> list[dict]:
"""일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음)."""
whole = m01.loaded()[1]
links = _links(whole)
out = []
for key in keys:
out += _rows_of(whole, whole.logic(key), key in blocked)
out += _rows_of(whole, whole.logic(key), key in blocked, links)
return out
@@ -268,23 +317,25 @@ def _make(files: dict, whole: Any, key: str) -> None:
value = build(files, WORKERS)
write_derived(layers.storage_root(), KIND, key, value)
with _LOCK:
if _MEMO.get("whole") is whole:
if _MEMO.get("key") == key:
_MEMO.update(value=value)
except Exception as e: # noqa: BLE001 — 다음 요청이 다시 셈
print(f"[M02 기준 목록] 셈 실패: {e}", file=sys.stderr)
finally:
with _LOCK:
if _MEMO.get("whole") is whole:
if _MEMO.get("key") == key:
_MEMO["job"] = None
def listing() -> dict:
"""기준 목록 `{판, 공종, 줄, 준비}` — 메모리 → 파생 저장본 → 뒤에서 셈(그동안 빈 줄)."""
files, whole = m01.loaded()
docs = m01_doc.docs() # 수식 문서를 고치면 새 묶음(같은 내용이면 같은 묶음)
with _LOCK:
if _MEMO.get("whole") is not whole:
if _MEMO.get("whole") is not whole or _MEMO.get("docs") is not docs:
_MEMO.clear()
_MEMO.update(whole=whole, key=derived_key(KIND, SHAPE, _stamp()), value=None, job=None)
key = derived_key(KIND, SHAPE, _stamp())
_MEMO.update(whole=whole, docs=docs, key=key, value=None, job=None)
if _MEMO["value"] is None and _MEMO["job"] is None:
got = read_derived(layers.storage_root(), KIND, _MEMO["key"])
if got:
@@ -312,8 +363,8 @@ def _quiet(fn) -> None:
print(f"[M02 기준 목록] 데움 실패: {e}", file=sys.stderr)
def _given(whole: Any, logic: dict, change: dict) -> tuple[dict, list]:
base, ax = axes(whole, logic)
def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]:
base, ax = axes(whole, doc)
known = {name: dict(reps) for name, reps in ax}
for name, value in (change or {}).items():
if name not in known:
@@ -326,28 +377,19 @@ def _given(whole: Any, logic: 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)
except m01.cm.mf.FormulaError as e:
raise m01.StoreError(404, str(e)) from e
given, ax = _given(whole, logic, change)
filled = m01.cm.mf.fill_empty(logic, given)
got = msl.annotate(files, key, filled, m01.mtx.lines(files, key, filled)) # 줄 덧칸(714-1)
done = settle.settle(whole, key, filled)
if "결과" not in done: # 돈 로직 — 줄마다 버림(B09 산근 규칙)
settle.apply(got.get("groups") or [], m01.cm.mf.run(whole, key, filled), done)
got["계"] = done["계"]
groups = [
{
"비목": g["비목"],
"소계": g.get("소계"),
"끝수": g.get("끝수") or "",
"줄": [{k: line.get(k) for k in ("이름", "글", "금액", *msl.KEYS)} for line in g["줄"]],
}
for g in got.get("groups") or []
]
if doc is None:
raise m01.StoreError(404, f"수식 문서 없음 「{key}」")
given, ax = _given(whole, doc, change)
links = _links(whole)
got = _calc(doc, links, given) or {}
money = str(doc.get("결과단위") or "").startswith("원") and "결과" not in doc
return labor_inputs._num(
{
"키": key,
@@ -357,8 +399,8 @@ def sheet(key: str, change: dict) -> dict:
"출처": labor_inputs.sources(logic) or "",
"판": edition(files),
"입력": given,
"묶음": groups,
"계": got.get("계"),
"기준단위": got.get("기준단위"),
"묶음": mdt.sheet_groups(doc, got, links) if got and money else [],
"계": got.get("계") if money else got.get("결과"),
"기준단위": _unit(logic) or None,
}
)