Merge remote-tracking branch 'origin/dev' into sub_desktop_1

resources/master_data/_틀.md

@@ -5,7 +5,7 @@
 ## 1. 용어
 
 - **요소** = 원문에 적힌 이름·수 그대로. 계산하지 않음.
-- **일위대가 로직** = 요소를 변수로 끌어와 조립한 단위당 계산법. 설계 값 자리는 비움.
+- **단가산출 로직** = 요소를 변수로 끌어와 조립한 단위당 계산법. 설계 값 자리는 비움.
 - 다른 것을 끌어와 계산하면 로직(기계 시간당 경비 · 기계 작업량 식 포함).
 
 ## 2. 파일
@@ -200,7 +200,7 @@
 }
 ```
 
-- `호표` 줄 = 실무 일위대가표 한 줄(종류 · 이름·규격 · 단위 · 수량 · 단가 · 금액). 단가는 적지 않음 — `요소` 에서 옴. 금액 = 수량 × 단가.
+- `호표` 줄 = 실무 단가산출 상세 한 줄(종류 · 이름·규격 · 단위 · 수량 · 단가 · 금액). 단가는 적지 않음 — `요소` 에서 옴. 금액 = 수량 × 단가.
 - `종류` = 인력 · 재료 · 기계 · 로직(하위 로직의 결과를 단가로 씀) — 요소 키의 테이블ID 그룹과 같음.
 - `비목` = 노무비 · 재료비 · 경비. `덧줄` 식에서 비목 합을 이름으로 씀.
 - `결과단위` 가 돈이 아닌 로직(㎥/시간)은 `호표` 없이 `중간` + `결과` 식.

resources/master_data/_화면_계약.md

@@ -58,8 +58,14 @@
 
 `POST /text` — 몸은 `/calc` 와 같고, 같은 계산을 **사람이 읽는 식 줄**로 돌려줌(화면은 받은 글을 그대로 찍음).
 
-- 됨 — `{ok: true, groups: [{비목, 줄: [{이름, 글, 금액, 까닭?}], 소계, 끝수}], 계}` · 멈춤은 `/calc` 와 같은 `{ok: false, reason}`.
+- 됨 — `{ok: true, groups: [{비목, 줄: [{이름, 글, 이름글, 짝, 금액, 까닭?}], 소계, 끝수}], 계, 별칭: […]}` · 멈춤은 `/calc` 와 같은 `{ok: false, reason}`.
 - `글` = 호표 줄은 「단가 \* 수량식 = 금액」 · 덧줄은 「식 = 금액」. 중간 값 · 요소 · `찾기()` · `로직()` · `만약()` 은 글자로 안 나오고 **그 자리에서 나온 수**로 · 「… / 100」 은 「… %」 로 · 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표).
+- `이름글` = 같은 줄을 **변수 이름으로** 적은 것(「석공노임 \* 메쌓기인력.석공 \* (1 + 증가율 %) = 석공비」) — 화면 왼쪽 칸 · `글` 은 오른쪽 칸.
+  - 단가 자리 = 「요소 이름 + 노임(인력) · 손료(기계) · 단가(그 밖)」 · 비목이 나뉜 줄은 「이름 + 비목 + 단가」.
+  - 금액 자리 = 「이름 + 비」 · 비목이 나뉜 줄은 「이름 + 비목」 · 덧줄·결과는 그 줄 이름.
+  - 표 찾기 · 로직 부르기 = **별칭 이름**(7장 규칙 그대로 · 값 칸은 `.석공` 처럼 뒤에 붙음) · 중간 값 · 입력 · 비목 이름은 그대로 · `만약()` 은 두 꼴 모두 **걸린 쪽만** 적어 줄이 어긋나지 않음.
+- `짝` = 1 부터 매긴 줄 번호(답 전체에서 하나씩 · 묶음을 가로질러 차례대로) — 두 칸을 줄 맞춰 놓고 한쪽을 누르면 다른 쪽을 밝히는 데 씀. 두 꼴은 한 줄 안에 나란히 오므로 **줄 수와 차례가 늘 같음**.
+- `별칭` = `이름글` 에 쓰인 표·로직 이름 목록 — 7장 `별칭` 과 같은 모양(`{이름, 종류, 참조, 원문, 밑이름, 값칸, 결과단위, 자리}`).
 - `비목` = `노무비` · `재료비` · `경비`(돈 아닌 로직은 묶음 하나 `결과`) · 줄이 없는 비목은 빠짐 · `소계` 는 끝수까지 붙은 값이고 `끝수` 는 그 한 마디(「원 미만 버림」 · 없으면 "") — 끝수는 따로 줄로 안 보임.
 - 하위 로직 줄처럼 한 줄이 여러 비목에 걸리면 비목마다 한 줄씩 · 그 비목 몫으로 단가를 되계산해 적음.
 - `까닭` = 단가가 0 이거나 못 구한 줄의 한 마디(「수량 0 — 이 조건에서는 안 쓰는 줄」 · 「단가 0 — 「MP000082」 값이 아직 없음」).

resources/master_data/scripts/master_copy.py

@@ -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

@@ -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)