eomsangdon/Aislo
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

feat(M01): 읽는 식 줄에 변수 이름 꼴을 더함 — 두 칸 줄 맞춤

Browse Source 
POST /text 가 줄마다 「이름글」(석공노임 * 메쌓기인력.석공 * (1 + 증가율 %) = 석공비)과 「글」(값 꼴)을 같이 주고 짝 번호를 붙임 — 두 꼴이 한 줄 안에 있어 개수·차례가 늘 같음.

표 찾기·로직 부르기는 3-4 별칭 규칙 그대로(답에 별칭 목록 포함) · 단가 자리는 노임·손료·단가 꼬리 · 만약()은 두 꼴 모두 걸린 쪽만. 계약 3장 갱신 · 로직 1,291개 전수 점검(짝 어긋남 0 · 함수 샘 0) · 시험 20 통과.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JgUhN55Z3BCYhUJTjwTNfj
This commit is contained in:
eomsangdon
2026-09-21 23:24:39 +09:00
co-authored by Claude Opus 5
parent 9d6e60f08c
commit 241926e79f
4 changed files with 171 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
resources/master_data/scripts/master_copy.py
+17 -2
View File
@@ -93,10 +93,15 @@ def _taken(row: dict) -> set[str]:
# ── 별칭 짓기 ─────────────────────────────────────────────────────────
def plain(text) -> str:
"""이름에 쓸 수 있는 글자만 남김 — 별칭과 변수 이름이 같은 규칙을 씀."""
return _DROP.sub("", str(text or ""))
def _base(ref: str, master) -> str:
"""별칭 밑이름 — 표·로직의 `이름` 칸에서 · 비거나 너무 길면 키를 그대로 보임."""
try:
name = _DROP.sub("", str(master.get(ref).get("이름") or ""))
name = plain(master.get(ref).get("이름"))
except mf.FormulaError:
name = ""
if not name or len(name) > MAX_NAME or name[0].isdigit():
@@ -170,6 +175,16 @@ def _about(kind: str, ref: str, master) -> dict:
# ── 펴기 · 되돌리기 ────────────────────────────────────────────────────
def names(marks: list[dict]) -> dict[str, str]:
"""별칭 목록 → {원문 서명: 별칭 이름} — 식 글을 별칭으로 갈아 끼울 때 씀."""
return {_SPACE.sub(" ", str(one["원문"])): str(one["이름"]) for one in marks}
def mask(text, name_of: dict[str, str]) -> str:
"""부르기 한 덩이를 별칭 이름으로 — `spread` 와 같은 규칙(다른 모듈도 씀)."""
return _mask(str(text), name_of)
def _mask(text: str, name_of: dict[str, str]) -> str:
"""부르기 한 덩이를 별칭 이름으로 — 뒤에서부터 갈아 끼움(자리가 밀리지 않게)."""
out = text
@@ -206,7 +221,7 @@ def _unmask(text: str, raw_of: dict[str, str]) -> str:
def spread(master, row: dict) -> dict:
"""로직 한 줄 → 별칭 꼴 식 묶음. `로직` = 식만 별칭으로 바뀐 줄 통째 · `별칭` 에 원문."""
marks = aliases(row, master)
name_of = {_SPACE.sub(" ", one["원문"]): one["이름"] for one in marks}
name_of = names(marks)
shown = copy.deepcopy(row)
for _, _, _, col, box in slots(shown):
box[col] = _mask(box[col], name_of)
resources/master_data/scripts/master_text.py
+117 -28
View File
@@ -1,18 +1,25 @@
# -*- coding: utf-8 -*-
"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계.
수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`·중간 값·요소는
글자로 내보내지 않고 그 자리에서 나온 수로 적음 · 끝수는 줄이 아니라 소계에 녹여 적음.
계산 자체는 `master_formula.run` 이 한 벌만 함 — 이 글은 그 결과를 되읽어 적음.
줄마다 글 두 꼴 —
· `글` 값 꼴: 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`·
중간 값·요소는 글자로 내보내지 않고 그 자리에서 나온 수로 적음
· `이름글` 이름 꼴: 「석공노임 * 메쌓기인력.석공 * (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_TAIL = {"LB": "노임", "EQ": "손료"} # 식 안 요소 키의 이름 꼬리(그 밖은 「단가」)
_PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3}
_PREC |= {"+": 4, "-": 4, "*": 5, "/": 5}
_RIGHT_TIGHT = ("-", "/") # 오른쪽 짝은 같은 세기라도 괄호가 필요함
@@ -30,22 +37,60 @@ def fmt(value) -> str:
return sign + f"{int(whole):,}" + (f".{rest}" if rest else "")
# ── 식을 수로 풀어 글로 ────────────────────────────────────────────────
# ── 식을 글로 — 값 꼴과 이름 꼴 ────────────────────────────────────────
def render(node, env: dict, master, depth: int = 0) -> str:
"""식 한 마디 → 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜."""
kind = node[0]
"""식 한 마디 → 값 꼴 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜."""
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(node[1])
return fmt(show[1])
if kind == "str":
return f"'{node[1]}'"
return f"'{show[1]}'"
if kind == "neg":
return "-" + render(node[1], env, master, depth)
return "-" + _draw(show[1], real[1], env, master, depth)
if kind == "bin":
return _bin(node, env, master, depth)
if kind == "call" and node[1] == "만약": # 걸린 쪽만 적음
test = mf.evaluate(node[2][0], env, master, depth)
return render(node[2][1] if test else node[2][2], env, master, depth)
return _value(node, env, master, depth)
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:
"""식 안 요소 한 줄의 이름 — 「석공노임」 꼴(같은 이름의 중간 값과 헷갈리지 않게)."""
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:
@@ -55,21 +100,21 @@ def _value(node, env: dict, master, depth: int) -> str:
return fmt(value)
def _bin(node, env: dict, master, depth: int) -> str:
_, op, left, right = node
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, node, env, master, depth, False)} %"
return f"{_side(left, real[2], show, env, master, depth, draw, False)} %"
return (
f"{_side(left, node, env, master, depth, False)} {op} "
f"{_side(right, node, env, master, depth, True)}"
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(child, parent, env: dict, master, depth: int, right: bool) -> str:
text = render(child, env, master, depth)
if child[0] != "bin":
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[child[1]], _PREC[parent[1]]
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
@@ -118,26 +163,58 @@ def _line_text(item: dict, line: dict, env: dict, master, part: str | None) -> s
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['결과'])}"
one = {"이름": row.get("이름") or "", "글": text, "금액": 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 {"ok": True, "groups": [group], "계": result["결과"]}
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["이름"]}
@@ -148,11 +225,12 @@ def lines(files: dict, key: str, given: dict) -> dict:
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)
_extras(row, shown[len(items) :], made, env, master, name_of)
groups = [
{
"비목": name,
@@ -163,10 +241,20 @@ def lines(files: dict, key: str, given: dict) -> dict:
for name in mf.COST_ITEMS
if made[name]
]
return {"ok": True, "groups": groups, "계": result["계"]}
return _paired({"ok": True, "groups": groups, "계": result["계"], "별칭": marks})
def _extras(row: dict, shown: list, made: dict, env: dict, master) -> None:
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):
@@ -174,6 +262,7 @@ def _extras(row: dict, shown: list, made: dict, env: dict, master) -> None:
one = {
"이름": extra["이름"],
"글": _extra_text(extra, line, env, master),
"이름글": _extra_names(extra, env, master, name_of),
"금액": line["금액"],
}
made[extra["비목"]].append(one)