Files
Aislo/resources/master_data/scripts/master_formula.py
T
eomsangdonandClaude Opus 5.5 d880392e5f refactor(855-E 2-E4 준비): 옛 엔진에서 바탕 기반을 master_base 로 가름 — 동작 불변
- 새 master_base.py: master_formula 의 바탕 기반(Master 색인 · find · FormulaError · EmptyInput · NoRow · _plain · GROUPS · TABLE_GROUPS · TABLE_IDS · COST_ITEMS · BUNDLE)을 글자 그대로 옮김 · 재료 이음 이름 · mp 다시 내보냄
- master_formula: 같은 이름을 master_base 에서 그대로 다시 내보냄(부르는 쪽 고침 0) · 파서 · 엔진 몸은 그대로(불러오기가 옛 파서를 더는 안 씀 → 2-E4 에서 지움)
- 새 계산기 쪽 scripts 다섯(master_material · master_pick · master_doc_link · master_doc_block · master_doc_record) import 를 master_base 로 — 새 계산기 셈에 엔진 몸 모듈 0
- 새 지킴 시험 test_855_e4a_base_only: 자식 해석기에서 master_base + 새 계산기만으로 견본 24 로직 셈 · 엔진 몸 읽힘 0 · 지문 = golden_855_engine
- 검증: 관련 + 관문 670 통과 · 빌더 --check 같음 · typecheck 0 · 서버 health 200 · M02 단가산출 셈 전후 같음 · 자료 변경 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 07:04:42 +09:00

526 lines
20 KiB
Python

# -*- coding: utf-8 -*-
"""마스터 로직 식 — 읽기 · 검사 · 시험 계산 (`_틀.md` 6~7장).
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
import itertools
import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
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,
)
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
_HOLE = re.compile(r"\{([^{}]+)\}")
_OPS = ("<=", ">=", "==", "!=", "<", ">")
_ARITH = re.compile(r"[\d.\s+\-*/()]*\d[\d.\s+\-*/()]*") # 분수·식 값 칸(「1/1.30」)
CALC_FIELDS = ("중간", "호표", "결과", "덧줄") # 계산 칸
FLOW_GONE = "흐름도 로직은 걷음 — M01 시트로 다시 만듦" # 794-1b · 저장된 흐름 로직 0
def inputs_of(row: dict) -> list[dict]:
"""옛 흐름 로직(줄에 「흐름」) 입력 — 흐름도를 걷어 늘 못 셈."""
raise FormulaError(FLOW_GONE)
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
def __init__(self, why: str):
self.why = why
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
self.s, self.i = text, 0
def fail(self, why: str):
raise FormulaError(f"{why} — 「{self.s}」 {self.i}자")
def ws(self):
while self.i < len(self.s) and self.s[self.i].isspace():
self.i += 1
def peek(self, word: str) -> bool:
self.ws()
return self.s.startswith(word, self.i)
def take(self, word: str) -> bool:
if self.peek(word):
self.i += len(word)
return True
return False
def need(self, word: str):
if not self.take(word):
self.fail(f"「{word}」 없음")
def parse(self):
node = self.expr()
self.ws()
if self.i != len(self.s):
self.fail("식 끝에 남은 글자")
return node
def expr(self):
node = self.both()
while self.take("또는"):
node = ("bin", "또는", node, self.both())
return node
def both(self):
node = self.compare()
while self.take("그리고"):
node = ("bin", "그리고", node, self.compare())
return node
def compare(self):
node = self.add()
for op in _OPS:
if self.take(op):
return ("bin", op, node, self.add())
return node
def add(self):
node = self.mul()
while True:
if self.take("+"):
node = ("bin", "+", node, self.mul())
elif self.take("-"):
node = ("bin", "-", node, self.mul())
else:
return node
def mul(self):
node = self.unary()
while True:
if self.take("*"):
node = ("bin", "*", node, self.unary())
elif self.take("/"):
node = ("bin", "/", node, self.unary())
else:
return node
def unary(self):
if self.take("-"):
return ("neg", self.unary())
node = self.primary()
while self.take("."):
node = ("field", node, self.quoted() if self.take("'") else self.name())
return node
def quoted(self) -> str:
end = self.s.find("'", self.i)
if end < 0:
self.fail("작은따옴표 안 닫힘")
text, self.i = self.s[self.i : end], end + 1
return text
def name(self) -> str:
self.ws()
m = _NAME.match(self.s, self.i)
if not m:
self.fail("이름 없음")
self.i = m.end()
return m.group()
def ref(self, head: bool = False) -> str:
"""키·원문번호 글자 — 괄호 밖의 `,` · `)` · `.칸` · ` 연산자 ` 앞에서 멈춤(원문번호에 빈칸·괄호가 들어감).
head = 찾기·로직 머리 — `,` · `)` 에서만 멈춤."""
start, depth = self.i, 0
while self.i < len(self.s):
ch = self.s[self.i]
if ch in "({":
depth += 1
elif ch in ")}":
if depth == 0:
break
depth -= 1
elif depth == 0 and ch == ",":
break
elif head:
pass
elif depth == 0 and ch == "." and not self.s[self.i + 1 : self.i + 2].isdigit():
# 「K.P」「T.S」 처럼 영문자 사이 점은 원문번호 글자
around = self.s[self.i - 1 : self.i + 2 : 2]
if not (len(around) == 2 and around.isascii() and around.isalpha()):
break
elif depth == 0 and re.match(r"\s[-+*/<>=!]", self.s[self.i : self.i + 2]):
break
self.i += 1
return self.s[start : self.i].strip()
def args(self) -> list[tuple[str, object]]:
out = []
while self.take(","):
key = self.quoted() if self.take("'") else self.name()
self.need("=")
out.append((key, self.expr()))
self.need(")")
return out
def primary(self):
self.ws()
if self.take("("):
node = self.expr()
self.need(")")
return node
if self.take("'"):
end = self.s.find("'", self.i)
if end < 0:
self.fail("작은따옴표 안 닫힘")
text, self.i = self.s[self.i : end], end + 1
return ("str", text)
m = _NUMBER.match(self.s, self.i)
if m:
self.i = m.end()
return ("num", Decimal(m.group()))
word = self.name()
if word == "찾기":
self.need("(")
self.ws()
return ("find", self.ref(True), self.args())
if word == "로직":
self.need("(")
self.ws()
return ("logic", self.ref(True), self.args())
if word in FUNCS:
self.need("(")
items = [self.expr()]
while self.take(","):
items.append(self.expr())
self.need(")")
return ("call", word, items)
if mk.KEY.fullmatch(word):
return ("ref", word)
if word in mk.IDS and self.s.startswith(":", self.i): # ID:원문번호 — {이름} 낀 원문번호
self.i += 1
return ("ref", f"{word}:{self.ref()}")
return ("name", word)
def parse(text) -> tuple:
if isinstance(text, (int, float, Decimal)):
return ("num", Decimal(str(text)))
return _Parser(str(text)).parse()
def walk(node):
"""식 나무의 모든 마디."""
yield node
kind = node[0]
if kind == "bin":
yield from walk(node[2])
yield from walk(node[3])
elif kind in ("neg",):
yield from walk(node[1])
elif kind == "field":
yield from walk(node[1])
elif kind == "call":
for item in node[2]:
yield from walk(item)
elif kind in ("find", "logic"):
for _, item in node[2]:
yield from walk(item)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
raise FormulaError(f"원문번호의 {{{m.group(1)}}} 값 없음")
value = env[m.group(1)]
if isinstance(value, Blank):
raise EmptyInput(value.why)
return _plain(value)
return _HOLE.sub(one, template)
# ── 계산 ──────────────────────────────────────────────────────────────
def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
return node[1]
if kind == "name":
if node[1] not in env:
raise FormulaError(f"모르는 이름 「{node[1]}」")
if env[node[1]] is None:
raise EmptyInput(f"입력 「{node[1]}」 비어 있음")
if isinstance(env[node[1]], Blank):
raise EmptyInput(env[node[1]].why)
return env[node[1]]
if kind == "ref":
value = element(master, fill(node[1], env), env)[0]
if value is None:
raise FormulaError(f"「{master.label(fill(node[1], env))}」 값 없음 — 관리자가 채울 값")
if isinstance(value, list):
raise FormulaError(
f"「{master.label(fill(node[1], env))}」 값이 범위 — 입력으로 받아야 함"
)
return value
if kind == "field":
if node[1][0] == "find":
table = master.get(fill(node[1][1], env))
conds = {k: evaluate(v, env, master, depth) for k, v in node[1][2]}
base = find(table, conds, node[2])
else:
base = evaluate(node[1], env, master, depth)
if not isinstance(base, dict) or node[2] not in base:
raise FormulaError(f"칸 「{node[2]}」 없음")
value = base[node[2]]
if isinstance(value, list):
raise FormulaError(f"칸 「{node[2]}」 값이 범위 — 입력으로 받아야 함")
if isinstance(value, str) and _ARITH.fullmatch(value):
return evaluate(parse(value), env, master, depth)
return value
if kind == "neg":
return -evaluate(node[1], env, master, depth)
if kind == "bin":
op, a = node[1], evaluate(node[2], env, master, depth)
if op == "그리고":
return a and evaluate(node[3], env, master, depth)
if op == "또는":
return a or evaluate(node[3], env, master, depth)
b = evaluate(node[3], env, master, depth)
return {
"+": lambda: a + b,
"-": lambda: a - b,
"*": lambda: a * b,
"/": lambda: a / b,
"<": lambda: a < b,
"<=": lambda: a <= b,
">": lambda: a > b,
">=": lambda: a >= b,
"==": lambda: a == b,
"!=": lambda: a != b,
}[op]()
if kind == "call":
name, items = node[1], node[2]
if name == "만약":
test = evaluate(items[0], env, master, depth)
return evaluate(items[1] if test else items[2], env, master, depth)
values = [evaluate(x, env, master, depth) for x in items]
if name in ("최소", "최대"):
return (min if name == "최소" else max)(values)
mode = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP}[name]
return _round(values[0], values[1] if len(values) > 1 else 0, mode)
if kind == "find":
table = master.get(fill(node[1], env))
return find(table, {k: evaluate(v, env, master, depth) for k, v in node[2]})
if kind == "logic":
if depth > 20:
raise FormulaError("로직 부르기가 너무 깊음 — 돌고 도는 참조")
given = {k: evaluate(v, env, master, depth) for k, v in node[2]}
result = run(master, fill(node[1], env), given, depth + 1)
return result["결과"] if "결과" in result else {k: result[k] for k in BUNDLE}
raise FormulaError(f"모르는 마디 {kind}")
ROUND_WAYS = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP}
ROUND_ON = ("계", "결과")
def cut(row: dict, value: Decimal, on: str) -> Decimal:
"""줄의 `끝수` 를 붙임 — 묶음 `{대상, 자리, 방법}` 만 · 글자 끝수는 원문 근거를 적은 설명."""
rule = row.get("끝수")
if not isinstance(rule, dict) or rule.get("대상") != on:
return value
way = ROUND_WAYS.get(str(rule.get("방법")))
if way is None:
raise FormulaError(f"「{_name(row)}」 끝수 방법 「{rule.get('방법')}」")
return _round(value, rule.get("자리") or 0, way)
def fill_empty(row: dict, given: dict) -> dict:
"""화면이 안 보낸 가격 입력(단위에 「원」)은 null 로 채움 — 빈 입력과 같이 그 줄만 비움."""
gap = {
s["이름"]: None
for s in row.get("입력", [])
if s["이름"] not in given and "원" in str(s.get("단위") or "")
}
return {**given, **gap}
def _inputs(row: dict, given: dict, master=None) -> dict:
env = {}
for spec in row.get("입력", []):
name = spec["이름"]
if name not in given:
raise FormulaError(f"「{_name(row)}」 입력 「{name}」 없음")
value = given[name]
if isinstance(value, str): # 화면이 글로 보낸 수 — 고르기 원래 값 · 아니면 수로
if "고르기" in spec:
value = next((o for o in spec["고르기"] if str(o) == value.strip()), value)
else:
try:
value = Decimal(value.strip())
except ArithmeticError:
pass
if isinstance(value, (int, float)):
value = Decimal(str(value))
value = mp.resolve(spec, value, master) # 기계 EQ 키 → 원문 분류번호
if "고르기" in spec and value not in spec["고르기"] and not mp.machine(spec, value, master):
raise FormulaError(f"입력 「{name}」={value} 고르기 밖")
if "범위" in spec:
low, high = spec["범위"]
if value is not None and not low <= value <= high:
raise FormulaError(f"입력 「{name}」={value} 범위 [{low}, {high}] 밖")
env[name] = value
unknown = set(given) - set(env)
if unknown:
raise FormulaError(f"「{_name(row)}」 모르는 입력 {sorted(unknown)}")
return env
def _shown(env: dict) -> dict:
"""돌려줄 중간값 — 못 구한 값은 null."""
return {k: None if isinstance(v, Blank) else v for k, v in env.items()}
def _blank_line(item: dict, why: str) -> dict:
"""비어 있는 입력·못 구한 값을 쓰는 호표 줄 — 단가·금액만 비우고 까닭."""
return {
"이름": item.get("이름", ""),
"단위": item.get("단위", ""),
"수량": None,
"단가": None,
"금액": None,
"비목": {item["비목"]: None} if "비목" in item else {},
"까닭": why,
}
def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict:
"""로직 한 줄 계산 — 돈 로직은 호표 줄 · 비목 합 · 계, 돈 아닌 로직은 결과 수 하나."""
row = master.logic(ref)
if isinstance(row.get("흐름"), dict):
raise FormulaError(FLOW_GONE)
env = _inputs(row, given, master)
for step in row.get("중간", []):
try:
value = evaluate(parse(step["식"]), env, master, depth)
env[step["이름"]] = ms.shown(step, value) # `표시` 자리 반올림(791-1)
except EmptyInput as e: # 못 구한 중간값 — 쓰는 줄만 비움
env[step["이름"]] = Blank(str(e))
if "결과" in row:
value = evaluate(parse(row["결과"]["식"]), env, master, depth)
return {"결과": cut(row, value, "결과"), "중간": _shown(env)}
sums = dict.fromkeys(COST_ITEMS, Decimal(0))
lines = []
for n, item in enumerate(row.get("호표", [])):
source = why = extra = None
try:
qty = evaluate(parse(item["수량"]), env, master, depth)
except EmptyInput as e: # 비어 있는 입력을 쓰는 줄만 비움
lines.append(_blank_line(item, str(e)))
continue
if item["종류"] == "로직":
try:
bundle = mp.bundled(item, lambda: evaluate(parse(item["요소"]), env, master, depth))
except EmptyInput as e:
lines.append(_blank_line(item, str(e)))
continue
price = bundle["계"]
split = (
{k: qty * bundle[k] for k in COST_ITEMS}
if "비목" not in item
else {item["비목"]: qty * price}
)
else:
# 고르기 조건 묶음은 그대로 넘김 — `element` 가 대표 줄·첫 줄로 풂
# 조건 값의 `{입력}`(관경 등)도 채움 — 규격이 입력 따라 바뀌는 관 줄
try:
ref = (
{k: fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()}
if isinstance(item["요소"], dict)
else fill(item["요소"], env)
)
except EmptyInput as e:
lines.append(_blank_line(item, str(e)))
continue
# 후보 0 · 값 빈 품목은 그 줄만 단가·금액을 비우고 까닭을 닮 — 로직은 계속 · 합에서 뺌
# (없는 키는 틀린 로직 — 지금처럼 멈춤) · 검색어 · 고름 · 단위 환산은 `master_pick`
if isinstance(ref, str) and qty != 0:
master.get(ref)
price, source, why, extra = mp.priced(master, item, ref, env, n if depth == 0 else None)
if price is None and qty == 0:
price, why = Decimal(0), None # 안 쓰는 재료 줄 — 값이 비어도 금액 0
split = {item["비목"]: None if price is None else qty * price}
for k, v in split.items():
sums[k] += v or 0
lines.append(
{
"이름": item.get("이름", ""),
"단위": item.get("단위", ""),
"수량": qty,
"단가": price,
"금액": None if price is None else qty * price,
"비목": split,
**({"출처": source} if source else {}),
**({"까닭": why} if why else {}),
**(extra or {}),
}
)
# 덧줄 · 비목 합 끊기 · 번지 · 단계 · 조정(791-1) = `master_formula_sum.extras`
sums, more = ms.extras(master, row, lines, env, sums, depth)
mb.tag(master, row, lines, env) # 줄마다 인력 · 재료 · 경비 · 하위 묶음(712-1)
mg.tag(master, row, lines, env) # 옵션으로 빠진 줄 `옵션꺼짐`(753-1)
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": _shown(env), **more}
# 품셈재료 단가 — 서로 부르는 모듈이라 끝에서 읽음
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 — 검색어 · 고름 · 단위
import master_bundle as mb # noqa: E402 — 인력 · 재료 · 경비 묶음
import master_gate as mg # noqa: E402 — 옵션으로 빠진 줄
import master_formula_sum as ms # noqa: E402 — 덧줄 · 번지 · 단계 · 조정 · 표시(791-1)
from master_formula_check import ( # noqa: E402, F401 — 검사는 나눈 파일 · 이름은 여기서 그대로
_check_cut,
_check_node,
_choices,
_expand,
check_logic,
find_loops,
)