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,
}
)
@@ -0,0 +1,327 @@
# -*- coding: utf-8 -*-
"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음).
쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4).
⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`:
`A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) ·
`ui_template/ui_template_equation.ts`(`eqText`) ·
`common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) ·
`common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄).
금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 ·
계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」.
수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) ·
줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음).
옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 ·
작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) ·
계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만).
"""
from __future__ import annotations
import re
from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation
import master_doc as md
import master_doc_calc as mc
COSTS = md.COSTS # 노무비 · 재료비 · 경비
COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"}
AMOUNT_UNIT = "원"
LONG_SUM = 4
_HIDE = ("반올림", "올림", "버림")
_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L"))
# ── 수 꼴 ─────────────────────────────────────────────────────────────
def _dec(v) -> Decimal | None:
if isinstance(v, bool) or v is None:
return None
try:
d = Decimal(str(v)) if not isinstance(v, Decimal) else v
except InvalidOperation:
return None
return d if d.is_finite() else None
def _group(d: Decimal, places: int, keep: bool) -> str:
q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP)
sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」
whole, _, frac = f"{abs(q):f}".partition(".")
frac = frac if keep else frac.rstrip("0")
head = f"{int(whole):,}"
return f"{sign}{head}.{frac}" if frac else f"{sign}{head}"
def eq_text(v) -> str:
"""`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로."""
if v is None or v == "":
return ""
if isinstance(v, bool):
return "true" if v else "false"
d = _dec(v)
if d is None or (isinstance(v, str) and not v.strip()):
return str(v)
return _group(d, 6, False)
def one(v) -> str:
"""줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」)."""
return _group(_dec(v) or Decimal(0), 1, True)
def won(v) -> str:
"""비목 · 합계 — 원(JS `Math.round` = 0.5 올림)."""
d = _dec(v) or Decimal(0)
r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR)
return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0
# ── 단위 ─────────────────────────────────────────────────────────────
def unit_text(u) -> str:
"""자료 단위 글 → 화면 단위(메타 단위 = 빈 글)."""
s = str(u if u is not None else "").strip()
if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s):
return ""
s = re.sub(r"^%\(.*\)$", "%", s)
return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h")
def _same(a: str, b: str) -> bool:
return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME)
def is_atom(n) -> bool:
"""한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함)."""
if not n:
return False
if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2:
return is_atom(n[2][0])
return n[0] in ("var", "num", "field", "str")
def node_of(text):
if text is None or str(text).strip() == "":
return None
try:
return md.parse(text)
except md.DocError:
return None
def money_units(
line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None
) -> dict:
"""금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 ·
단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글."""
has = line.get("수량") not in (None, "")
q = unit_text(line.get("단위")) if has else ""
wrap = bool(q) and bool(qty) and not is_atom(qty)
own = next(
(
u
for u in (
unit_text((sub or {}).get("결과단위")),
unit_text((price_var or {}).get("단위")),
)
if u.startswith("원")
), # fmt: skip
None,
)
mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own
fallback = f"{AMOUNT_UNIT}/{q}" if q else ""
price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else ""
return {"price": price_unit, "qty": q, "wrap": wrap}
def price_sym(line: dict) -> str | None:
n = node_of(line.get("단가"))
if not n:
return None
if n[0] == "var":
return n[1]
if n[0] == "field" and n[1][0] == "var":
return n[1][1]
return None
def line_name(line: dict) -> str:
"""이름에 규격이 들면 한 번만(814-1)."""
name, spec = str(line.get("이름") or ""), line.get("규격")
return f"{name} {spec}".strip() if spec and spec not in name else name
# ── 선택으로 꺼진 줄(`offLine`) ───────────────────────────────────────
class _Look:
"""셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움."""
def __init__(self, doc: dict, answer: dict, links):
self.run = mc._Run(doc, links, None, (), {})
got = answer.get("값") or {}
names = {md.var_id(v) for v in doc.get("변수") or []}
names |= {str(x.get("기호") or "") for x in doc.get("식") or []}
for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음)
have = got.get(name)
self.run.values[name] = mc.Blank("모름") if have is None else have
self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []}
def value(self, n):
try:
v = self.run.ev(n, None, "")
except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음
return None
return None if isinstance(v, (mc.Blank, mc.Stop)) else v
def taken(self, n) -> int:
if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3):
return 0
t = self.value(n[2][0])
return 0 if t is None else (1 if t else 2)
def off_zero(self, n, path: frozenset = frozenset()) -> bool:
if not n:
return False
at, hop = n, 0
while pick := self.taken(at):
at, hop = at[2][pick], hop + 1
if hop and at[0] == "num":
return at[1] == 0
kind = at[0]
if kind == "var":
name = at[1]
if name not in self.lines or name in path:
return False
return self.off_zero(node_of(self.lines[name]), path | {name})
if kind in ("neg", "pct"):
return self.off_zero(at[1], path)
if kind == "bin":
if at[1] == "*":
return self.off_zero(at[2], path) or self.off_zero(at[3], path)
if at[1] == "/":
return self.off_zero(at[2], path)
if at[1] in ("+", "-"):
return self.off_zero(at[2], path) and self.off_zero(at[3], path)
return False
def off_line(self, line: dict) -> bool:
return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가"))
# ── 줄 글 ────────────────────────────────────────────────────────────
def _num(v) -> Decimal | None:
return _dec(v)
def _u(text: str, unit: str) -> str:
return f"{text} {unit}" if unit else text
def money_lines(doc: dict, answer: dict, links) -> list[dict]:
"""금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` ·
묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참)."""
look = _Look(doc, answer, links)
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
rows = answer.get("줄") or []
out: list[dict] = []
for i, line in enumerate(doc.get("금액") or []):
got = rows[i] if i < len(rows) else {}
name = line_name(line)
ps = price_sym(line)
pv = vars_.get(ps) if ps else None
link = (pv or {}).get("연결") or {}
sub = None
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
try:
sub = links.doc(str(link["키"]))
except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이
sub = None
mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub)
qty = got.get("수량")
base = {
"i": i,
"이름": name,
"수량": _num(qty),
"단위": mu,
"꺼짐": look.off_line(line),
"합밖": bool(got.get("합밖")),
"묶음": line.get("묶음") or "",
}
tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"])
if got.get("까닭") and got.get("금액") is None:
why = got["까닭"]
out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why,
"글": f"{name} : — {why}"}) # fmt: skip
continue
if line.get("비목") == "묶음":
bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {}
for c in COSTS:
part = (got.get("비목") or {}).get(c)
if _dec(part) is None or (not part and not bundle.get(c)):
continue
price = _u(eq_text(bundle.get(c)), mu["price"])
text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}"
out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)),
"금액": _num(part), "글": text}) # fmt: skip
continue
amt, price = got.get("금액"), got.get("단가")
text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt),
"글": text}) # fmt: skip
return out
def total_lines(answer: dict, lines: list[dict]) -> list[str]:
"""계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) ·
「합계 : 금액 원」."""
out = []
for c in COSTS:
terms = [
x["금액"]
for x in lines
if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액")
]
v = answer.get(c)
if _dec(v) is None:
body = "—"
elif 1 < len(terms) <= LONG_SUM:
body = f"{' + '.join(one(t) for t in terms)} = {won(v)}"
else:
body = won(v) if terms or v else ""
unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else ""
out.append(f"{COST_SHOW[c]} : {body}{unit}")
total = answer.get("계")
out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}")
return out
def sheet_groups(doc: dict, answer: dict, links) -> list[dict]:
"""공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄
`{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` ·
소계 = 셈 답 비목 값(끝수 뒤) ·
합 밖 줄 · 비목 없는 줄 = 뺌."""
groups: dict[str, list] = {c: [] for c in COSTS}
for x in money_lines(doc, answer, links):
c = x.get("비목")
if c not in groups or x["합밖"]:
continue
mu = x["단위"]
if x.get("까닭"):
text = f"— {x['까닭']}"
else:
price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"])
qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"])
text = f"{price}{qty} = {one(x['금액'] or 0)}"
groups[c].append(
{
"이름": x["이름"],
"글": text,
"금액": x["금액"],
"묶음": x["묶음"] or None,
"장비": bool(x.get("묶음줄")) or None,
"옵션꺼짐": x["꺼짐"] or None,
}
)
return [
{"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]}
for c in COSTS
if groups[c] or _dec(answer.get(c))
]
@@ -0,0 +1,71 @@
/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝).
* stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]}
* stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits],
* 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM}
* `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const cache = new Map();
function load(at) {
if (cache.has(at)) return cache.get(at);
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
}).outputText;
const box = { exports: {} };
cache.set(at, box.exports);
const need = (p) => {
if (p.endsWith(".css")) return {};
return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
};
new Function("exports", "module", "require", js)(box.exports, box, need);
return box.exports;
}
const ROOT = path.join(__dirname, "..", "..");
const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts"));
const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts"));
const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts"));
const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts"));
// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림
const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8");
const grab = (re) => {
const m = out.match(re);
if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`);
return m[0];
};
const defs = [
grab(/const COST_SHOW: Record<string, string> = \{[^}]*\};/),
grab(/const won = \(n: number\): string => [^;]*;/),
grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/),
grab(/const LONG_SUM = \d+;/),
].join("\n");
const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, {
compilerOptions: { target: ts.ScriptTarget.ES2020 },
}).outputText;
const local = new Function("eqText", js)(eq.eqText);
const input = JSON.parse(fs.readFileSync(0, "utf8"));
const res = {
eq: (input.수 || []).map((v) => eq.eqText(v)),
one: (input.원 || []).map((v) => local.one(v)),
won: (input.원 || []).map((v) => local.won(v)),
단위: (input.단위 || []).map((u) => unit.unitText(u)),
금액줄: (input.금액줄 || []).map((x) =>
unit.moneyUnits(
x.줄,
view.tryParse(x.줄.단가),
view.tryParse(x.줄.수량),
x.단가변수 || undefined,
x.부름 || null,
),
),
기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)),
꺼짐: (input.꺼짐 || []).map((x) =>
(x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))),
),
비목: local.COST_SHOW,
항: local.LONG_SUM,
};
process.stdout.write(JSON.stringify(res));
+10 -6
View File
@@ -11,10 +11,12 @@
from __future__ import annotations
import json
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 M01_MasterData.M01_MasterData_Store_Find import hit
from M02_MasterTemplete import M02_Logic_Standard as st
@@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]:
def _given(key: str, change: dict) -> dict:
whole = m01.loaded()[1]
return st._given(whole, whole.logic(key), change)[0]
return st._given(whole, m01_doc.docs()[key], change)[0]
@pytest.mark.parametrize("key", THREE)
def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None:
def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None:
"""855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기)."""
rows = _rows(key)
assert rows
doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서
for row in rows:
got = m01.calc(key, _given(key, row["바꿈"]))
assert got["ok"], got
gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원
assert -0.01 <= gap < 3.2, row["규격"]
given = st.labor_inputs._num(_given(key, row["바꿈"]))
got = m01_doc.preview(doc, given)["셈"]
assert got["셈됨"], row["규격"]
assert float(got["계"]) == row["금액"], row["규격"]
def test_대표_규격_펼침() -> None:
+4 -4
View File
@@ -13,6 +13,7 @@ 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
@@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음():
for row in data.get("줄") or []:
if not _plain(row) or checked >= 60:
continue
base, _ = ls.axes(whole, row)
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
given = mf.fill_empty(row, base)
got = mf.run(whole, row["키"], given)
lines = []
@@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림():
assert group["소계"] == int(group["소계"])
assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"]
assert got["계"] == sum(g["소계"] for g in got["묶음"])
assert got["계"] == ls._money(
whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0]
)
doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값)
assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0])
+2 -16
View File
@@ -1,5 +1,5 @@
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와
M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`)."""
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`.
(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)"""
from __future__ import annotations
@@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT))
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402
from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402
msl = sheet.msl
num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙)
def _text(key: str) -> dict:
@@ -61,15 +59,3 @@ def test_basis_note_tenfold():
assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10"
ten = _text("GF000124")
assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten))
def test_two_routes_same_shape():
"""M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음)."""
for key in ("GF000169", "GF000103", "GF000219"):
m01 = _lines(_text(key))
m02 = _lines(standard.sheet(key, {}), "묶음")
assert len(m01) == len(m02)
for a, b in zip(m01, m02):
assert set(b) == {"이름", "글", "금액", *msl.KEYS}
assert a["이름"] == b["이름"]
assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS]
+155
View File
@@ -0,0 +1,155 @@
"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈.
① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`):
수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호
(`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부
(기본 입력 셈 답)로.
② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 ·
줄 글 「단가 원/단위 * 수량 단위 = 금액」.
③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계.
"""
from __future__ import annotations
import importlib
import json
import os
import subprocess
from decimal import Decimal
from functools import lru_cache
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_Logic_Standard as st
mc = importlib.import_module("master_doc_calc")
md = importlib.import_module("master_doc")
mdt = importlib.import_module("master_doc_text")
HERE = os.path.dirname(os.path.abspath(__file__))
NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95,
-0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142,
123456789012.345, 26890.75, 1502.04999] # fmt: skip
def _js(v):
if isinstance(v, Decimal):
return float(v)
if isinstance(v, dict):
return {k: _js(x) for k, x in v.items()}
if isinstance(v, (list, tuple)):
return [_js(x) for x in v]
if isinstance(v, (mc.Blank, mc.Stop)):
return None
return v
@lru_cache(maxsize=1)
def world():
"""(문서들, 연결, {키: 기본 셈 답})."""
whole = m01.loaded()[1]
docs = m01_doc.docs()
links = st._links(whole)
answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")}
return docs, links, answers
def _helper(payload: dict) -> dict:
run = subprocess.run(
["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")],
input=json.dumps(payload, ensure_ascii=False),
capture_output=True,
text=True,
encoding="utf-8",
check=True,
)
return json.loads(run.stdout)
@lru_cache(maxsize=1)
def mirror():
docs, links, answers = world()
nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []}
for key, a in answers.items():
doc = docs[key]
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
units |= {str(v.get("단위") or "") for v in doc.get("변수") or []}
units.add(str(doc.get("결과단위") or ""))
for row in a.get("줄") or []:
nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")]
for line in doc["금액"]:
units.add(str(line.get("단위") or ""))
sym = mdt.price_sym(line)
pv = vars_.get(sym) if sym else None
link = (pv or {}).get("연결") or {}
sub = None
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
got = links.doc(str(link["키"]))
sub = {"결과단위": got.get("결과단위")} if got else None
lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub})
nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량")))
py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym))
look = mdt._Look(doc, a, links)
vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None}
part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])}
offs.append({"문서": part, "값": _js(vals)})
py["꺼짐"].append([look.off_line(line) for line in doc["금액"]])
nums = [x for x in nums if isinstance(x, (int, float))]
units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"}
units = sorted(units)
ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs})
return nums, units, py, ts
def test_수_꼴_eqText_한자리_원():
nums, _, _, ts = mirror()
assert len(nums) > 5000
assert [mdt.eq_text(v) for v in nums] == ts["eq"]
assert [mdt.one(v) for v in nums] == ts["one"]
assert [mdt.won(v) for v in nums] == ts["won"]
texts = ("5401-0017", "", " ", "1048")
assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"]
def test_단위_글_금액줄_단위_자리_단가_기호():
_, units, py, ts = mirror()
assert [mdt.unit_text(u) for u in units] == ts["단위"]
assert len(py["줄"]) > 5000
assert [u for u, _ in py["줄"]] == ts["금액줄"]
assert [s for _, s in py["줄"]] == ts["기호"]
assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"])
def test_선택으로_꺼진_줄_비목_이름():
_, _, py, ts = mirror()
assert py["꺼짐"] == ts["꺼짐"]
assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함)
assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"]
@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101"))
def test_계산서_문서_셈_답_그대로(key):
got = st.sheet(key, {})
docs, links, _ = world()
answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0])
assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"])
for g in got["묶음"]:
assert g["소계"] == float(answer[g["비목"]])
for line in g["줄"]:
assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}")
assert " * " in line["글"] or line["글"].startswith("—")
first = got["묶음"][0]["줄"][0]
if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」
assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ")
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):
given = st._given(whole, docs[key], row["바꿈"])[0]
want = mc.calc(docs[key], links, given)
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])