eomsangdonandClaude Sonnet 5
f50bf7e494
별칭 이름이 QC001882 처럼 표 열쇠 그대로면 요소 열쇠로 읽혀 밑이름 풀어쓴 글자가 나옴. 요소 테이블(LB·EQ·MT·MP·MO)만 이름으로 풀고 그 밖은 별칭 이름 그대로. 로직 전수 1,291 — 새는 줄 0 (옛 동작과 다른 로직 196) · 값 식·계 그대로 · 시험 추가(21 통과). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JgUhN55Z3BCYhUJTjwTNfj
286 lines
13 KiB
Python
286 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계.
|
|
|
|
줄마다 글 두 꼴 —
|
|
· `글` 값 꼴: 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`·
|
|
중간 값·요소는 글자로 내보내지 않고 그 자리에서 나온 수로 적음
|
|
· `이름글` 이름 꼴: 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」 — 표 찾기·로직
|
|
부르기는 별칭 이름(`master_copy` 3-4 규칙) · 중간 값·입력은 그 이름 그대로
|
|
두 꼴은 같은 줄에 나란히 있고 `짝` 번호가 붙음 — 화면 두 칸이 줄 맞춤으로 놓임.
|
|
끝수는 줄이 아니라 소계에 녹여 적음. 계산 자체는 `master_formula.run` 이 한 벌만 함.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from decimal import Decimal
|
|
|
|
import master_copy as mc
|
|
import master_formula as mf
|
|
|
|
PLACES = Decimal("0.0001") # 화면 `formatNumber` 와 같음(소수 넷째 자리까지)
|
|
PRICE_TAIL = {"인력": "노임", "기계": "손료"} # 단가 자리의 이름 꼬리(그 밖은 「단가」)
|
|
ELEM_KEYS = ("LB", "EQ", "MT", "MP", "MO") # 요소 테이블 — 그 밖의 열쇠(QC · QF …)는 별칭 이름
|
|
ELEM_TAIL = {"LB": "노임", "EQ": "손료"} # 식 안 요소 키의 이름 꼬리(그 밖은 「단가」)
|
|
_PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3}
|
|
_PREC |= {"+": 4, "-": 4, "*": 5, "/": 5}
|
|
_RIGHT_TIGHT = ("-", "/") # 오른쪽 짝은 같은 세기라도 괄호가 필요함
|
|
|
|
|
|
def fmt(value) -> str:
|
|
"""화면에 보이는 자릿수 그대로 — 소수 넷째 자리까지 · 뒤 0 은 떼고 · 천 단위 쉼표."""
|
|
if not isinstance(value, Decimal):
|
|
return str(value)
|
|
cut = value.quantize(PLACES) if value.as_tuple().exponent < -4 else value
|
|
sign, digits = ("-", -cut) if cut < 0 else ("", cut)
|
|
whole, _, rest = f"{digits.normalize():f}".partition(".")
|
|
if "E" in whole or "e" in whole: # 아주 큰 수 — 지수 꼴을 펴서 씀
|
|
whole, _, rest = f"{digits:f}".rstrip("0").rstrip(".").partition(".")
|
|
return sign + f"{int(whole):,}" + (f".{rest}" if rest else "")
|
|
|
|
|
|
# ── 식을 글로 — 값 꼴과 이름 꼴 ────────────────────────────────────────
|
|
def render(node, env: dict, master, depth: int = 0) -> str:
|
|
"""식 한 마디 → 값 꼴 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜."""
|
|
return _draw(node, node, env, master, depth)
|
|
|
|
|
|
def _draw(show, real, env: dict, master, depth: int) -> str:
|
|
kind = show[0]
|
|
if kind == "num":
|
|
return fmt(show[1])
|
|
if kind == "str":
|
|
return f"'{show[1]}'"
|
|
if kind == "neg":
|
|
return "-" + _draw(show[1], real[1], env, master, depth)
|
|
if kind == "bin":
|
|
return _bin(show, real, env, master, depth, _draw)
|
|
if kind == "call" and show[1] == "만약": # 걸린 쪽만 적음
|
|
at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2
|
|
return _draw(show[2][at], real[2][at], env, master, depth)
|
|
return _value(real, env, master, depth)
|
|
|
|
|
|
def named(show, real, env: dict, master, depth: int = 0) -> str:
|
|
"""식 한 마디 → 이름 꼴 글. `show` = 부르기를 별칭으로 갈아 끼운 나무 · `real` = 원래 나무.
|
|
이름·중간 값은 그대로 · 표 찾기·로직 부르기는 별칭 이름 · 요소는 그 이름."""
|
|
kind = show[0]
|
|
if kind == "name":
|
|
return show[1]
|
|
if kind == "ref":
|
|
return _elem_name(master, show[1])
|
|
if kind == "field":
|
|
return f"{named(show[1], real[1], env, master, depth)}.{show[2]}"
|
|
if kind == "neg":
|
|
return "-" + named(show[1], real[1], env, master, depth)
|
|
if kind == "bin":
|
|
return _bin(show, real, env, master, depth, named)
|
|
if kind == "call":
|
|
if show[1] == "만약": # 값 꼴과 같은 쪽만 적어 두 칸이 짝이 되게
|
|
at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2
|
|
return named(show[2][at], real[2][at], env, master, depth)
|
|
args = ", ".join(named(s, r, env, master, depth) for s, r in zip(show[2], real[2]))
|
|
return f"{show[1]}({args})"
|
|
if kind in ("num", "str"):
|
|
return _draw(show, real, env, master, depth)
|
|
return _value(real, env, master, depth) # 별칭이 안 붙은 부르기 — 값으로
|
|
|
|
|
|
def _elem_name(master, ref: str) -> str:
|
|
"""식 안 요소 한 줄의 이름 — 「석공노임」 꼴(같은 이름의 중간 값과 헷갈리지 않게)."""
|
|
if (
|
|
str(ref)[:2] not in ELEM_KEYS
|
|
): # 별칭 이름이 표 열쇠 그대로인 것(QC…) — 밑이름을 풀어쓰지 않음
|
|
return ref
|
|
try:
|
|
name = mc.plain(master.get(ref).get("이름"))
|
|
except mf.FormulaError:
|
|
name = ""
|
|
return f"{name}{ELEM_TAIL.get(str(ref)[:2], '단가')}" if name else ref
|
|
|
|
|
|
def _value(node, env: dict, master, depth: int) -> str:
|
|
value = mf.evaluate(node, env, master, depth)
|
|
if isinstance(value, dict): # 로직 부르기 묶음 — 줄 금액에 쓰는 것은 「계」
|
|
value = value.get("계")
|
|
return fmt(value)
|
|
|
|
|
|
def _bin(show, real, env: dict, master, depth: int, draw) -> str:
|
|
_, op, left, right = show
|
|
if op == "/" and right[0] == "num" and right[1] == 100: # 「… / 100」 은 퍼센트로
|
|
return f"{_side(left, real[2], show, env, master, depth, draw, False)} %"
|
|
return (
|
|
f"{_side(left, real[2], show, env, master, depth, draw, False)} {op} "
|
|
f"{_side(right, real[3], show, env, master, depth, draw, True)}"
|
|
)
|
|
|
|
|
|
def _side(show, real, parent, env: dict, master, depth: int, draw, right: bool) -> str:
|
|
text = draw(show, real, env, master, depth)
|
|
if show[0] != "bin":
|
|
return text
|
|
mine, up = _PREC[show[1]], _PREC[parent[1]]
|
|
if mine < up or (mine == up and right and parent[1] in _RIGHT_TIGHT):
|
|
return f"({text})"
|
|
return text
|
|
|
|
|
|
# ── 줄 세우기 ─────────────────────────────────────────────────────────
|
|
def _env_of(master, row: dict, given: dict, depth: int = 0) -> dict:
|
|
"""입력 + 중간 — `run` 과 같은 차례로 다시 셈(덧줄 전 상태)."""
|
|
env = mf._inputs(row, given)
|
|
for step in row.get("중간", []):
|
|
env[step["이름"]] = mf.evaluate(mf.parse(step["식"]), env, master, depth)
|
|
return env
|
|
|
|
|
|
def _why(item: dict, line: dict) -> str:
|
|
"""단가를 못 구했거나 0 인 줄의 까닭 한 마디."""
|
|
if line["수량"] == 0:
|
|
return "수량 0 — 이 조건에서는 안 쓰는 줄"
|
|
if line["단가"] not in (0, None):
|
|
return ""
|
|
where = item.get("요소")
|
|
where = "재료 고르기 조건" if isinstance(where, dict) else f"「{where}」"
|
|
return f"단가 0 — {where} 값이 아직 없음"
|
|
|
|
|
|
def _label(item: dict, line: dict) -> str:
|
|
spec = str(item.get("규격") or "").strip()
|
|
name = str(line.get("이름") or item.get("이름") or "")
|
|
return f"{name}({spec})" if spec else name
|
|
|
|
|
|
def _shares(line: dict) -> list[tuple[str, Decimal]]:
|
|
"""글로 적을 (비목, 몫) — 비목이 나뉜 로직 줄은 몫이 없는 비목을 건너뜀.
|
|
몫이 전부 0 이면 호표 줄이 사라지지 않게 첫 비목에 0 원 한 줄을 남김."""
|
|
parts = list(line["비목"].items())
|
|
if len(parts) <= 1:
|
|
return parts
|
|
return [(part, money) for part, money in parts if money != 0] or parts[:1]
|
|
|
|
|
|
def _line_text(item: dict, line: dict, env: dict, master, part: str | None) -> str:
|
|
"""「단가 * 수량식 = 금액」 — 비목이 나뉜 로직 줄은 그 비목 몫만."""
|
|
qty = render(mf.parse(item["수량"]), env, master)
|
|
money = line["비목"][part] if part else line["금액"]
|
|
price = line["단가"] if part is None or line["수량"] == 0 else money / line["수량"]
|
|
return f"{fmt(price)} * {qty} = {fmt(money)}"
|
|
|
|
|
|
def _line_names(item: dict, line: dict, env: dict, master, part: str | None, name_of: dict) -> str:
|
|
"""같은 줄을 변수 이름으로 — 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」."""
|
|
name = mc.plain(item.get("이름") or line.get("이름")) or "값"
|
|
tail = PRICE_TAIL.get(str(item.get("종류") or ""), "단가")
|
|
price = f"{name}{part or ''}{tail}"
|
|
money = f"{name}{part}" if part else f"{name}비"
|
|
return f"{price} * {_names(item['수량'], env, master, name_of)} = {money}"
|
|
|
|
|
|
def _extra_text(extra: dict, line: dict, env: dict, master) -> str:
|
|
return f"{render(mf.parse(extra['식']), env, master)} = {fmt(line['금액'])}"
|
|
|
|
|
|
def _extra_names(extra: dict, env: dict, master, name_of: dict) -> str:
|
|
got = mc.plain(extra.get("이름")) or "덧줄"
|
|
return f"{_names(extra['식'], env, master, name_of)} = {got}"
|
|
|
|
|
|
def _names(text, env: dict, master, name_of: dict) -> str:
|
|
"""식 글 한 줄을 이름 꼴로 — 별칭을 씌운 나무와 원래 나무를 나란히 읽음."""
|
|
real = mf.parse(text)
|
|
try:
|
|
show = mf.parse(mc.mask(text, name_of))
|
|
except mf.FormulaError: # 별칭을 씌우면 못 읽는 글 — 값 꼴로 물러남
|
|
show = real
|
|
return named(show, real, env, master)
|
|
|
|
|
|
def lines(files: dict, key: str, given: dict) -> dict:
|
|
"""로직 한 줄의 읽는 식 — 비목 묶음마다 줄과 소계 · 돈 아닌 로직은 「결과」 묶음 하나."""
|
|
master = mf.Master(files)
|
|
row = master.logic(key)
|
|
result = mf.run(master, key, given)
|
|
env = _env_of(master, row, given)
|
|
marks = mc.aliases(row, master)
|
|
name_of = mc.names(marks)
|
|
if "결과" in row:
|
|
text = f"{render(mf.parse(row['결과']['식']), env, master)} = {fmt(result['결과'])}"
|
|
got = mc.plain(row.get("이름")) or "결과"
|
|
one = {
|
|
"이름": row.get("이름") or "",
|
|
"글": text,
|
|
"이름글": f"{_names(row['결과']['식'], env, master, name_of)} = {got}",
|
|
"금액": result["결과"],
|
|
}
|
|
group = {
|
|
"비목": "결과",
|
|
"줄": [one],
|
|
"소계": result["결과"],
|
|
"끝수": _cut_note(row, "결과"),
|
|
}
|
|
return _paired({"ok": True, "groups": [group], "계": result["결과"], "별칭": marks})
|
|
made: dict[str, list] = {name: [] for name in mf.COST_ITEMS}
|
|
shown = result["줄"]
|
|
env["줄"] = {r["이름"]: r["금액"] for r in shown if r["이름"]}
|
|
items = row.get("호표") or []
|
|
for item, line in zip(items, shown):
|
|
for part, money in _shares(line):
|
|
split = part if len(line["비목"]) > 1 else None
|
|
one = {
|
|
"이름": _label(item, line),
|
|
"글": _line_text(item, line, env, master, split),
|
|
"이름글": _line_names(item, line, env, master, split, name_of),
|
|
"금액": money,
|
|
}
|
|
why = _why(item, line)
|
|
made[part].append({**one, "까닭": why} if why else one)
|
|
_extras(row, shown[len(items) :], made, env, master, name_of)
|
|
groups = [
|
|
{
|
|
"비목": name,
|
|
"줄": made[name],
|
|
"소계": result[name],
|
|
"끝수": _cut_note(row),
|
|
}
|
|
for name in mf.COST_ITEMS
|
|
if made[name]
|
|
]
|
|
return _paired({"ok": True, "groups": groups, "계": result["계"], "별칭": marks})
|
|
|
|
|
|
def _paired(answer: dict) -> dict:
|
|
"""줄마다 짝 번호 — 두 칸(이름 꼴 · 값 꼴)이 같은 차례로 놓이게 1 부터."""
|
|
at = 0
|
|
for group in answer["groups"]:
|
|
for one in group["줄"]:
|
|
at += 1
|
|
one["짝"] = at
|
|
return answer
|
|
|
|
|
|
def _extras(row: dict, shown: list, made: dict, env: dict, master, name_of: dict) -> None:
|
|
"""덧줄 — 앞선 줄까지의 비목 합을 넣고 한 줄씩(식 안의 비목 이름은 그 수로 바뀜)."""
|
|
sums = {name: sum((one["금액"] for one in made[name]), Decimal(0)) for name in mf.COST_ITEMS}
|
|
for extra, line in zip(row.get("덧줄") or [], shown):
|
|
env.update(sums)
|
|
one = {
|
|
"이름": extra["이름"],
|
|
"글": _extra_text(extra, line, env, master),
|
|
"이름글": _extra_names(extra, env, master, name_of),
|
|
"금액": line["금액"],
|
|
}
|
|
made[extra["비목"]].append(one)
|
|
sums[extra["비목"]] += line["금액"]
|
|
env[extra["이름"]] = line["금액"]
|
|
|
|
|
|
def _cut_note(row: dict, on: str = "계") -> str:
|
|
"""소계에 붙일 끝수 한 마디 — 끝수는 따로 줄로 보이지 않음."""
|
|
rule = row.get("끝수")
|
|
if not isinstance(rule, dict) or rule.get("대상") != on:
|
|
return ""
|
|
place = int(rule.get("자리") or 0)
|
|
where = "원 미만" if place == 0 else f"소수 {place + 1}째 자리에서"
|
|
return f"{where} {rule.get('방법')}"
|