Merge remote-tracking branches 'origin/main_desktop_1' and 'origin/sub_laptop_1' into sub_laptop_3

2026-09-21 19:41:49 +09:00
parent e36376d6f6 efe521f6cd d12f471c93
commit b99585da59
7 changed files with 533 additions and 0 deletions
@@ -0,0 +1,155 @@
+"""로직 복사 설계용 — 호표·중간·덧줄 식 속 찾기()·로직() 전수 세기 (읽기 전용 · 아무것도 안 씀).
+
+resources/master_data/ref/_설계_식_복사.md 의 ② 수치 근거.
+
+사용: ./venv/Scripts/python.exe resources/master_data/scripts/analyze_식_복사.py
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+NAME_OF = re.compile(r"(찾기|로직)\(\s*([A-Za-z0-9]+)")
+
+
+def find_calls(text: str) -> list[tuple[str, str, str]]:
+    """text 안 찾기(...)·로직(...) 전부 — (종류, 키, 괄호 안 전체 글) 목록. 중첩 괄호는 짝을 맞춰 끊음."""
+    out = []
+    for m in NAME_OF.finditer(text):
+        kind, key = m.group(1), m.group(2)
+        start = m.start() + len(kind)  # '(' 위치 — 찾기·로직 바로 뒤
+        depth = 0
+        i = start
+        while i < len(text):
+            if text[i] == "(":
+                depth += 1
+            elif text[i] == ")":
+                depth -= 1
+                if depth == 0:
+                    break
+            i += 1
+        args = text[start + 1 : i]
+        out.append((kind, key, args.strip()))
+    return out
+
+
+def row_lines(row: dict) -> list[tuple[str, str]]:
+    """(자리표, 식 글) 목록 — 호표 수량 · 호표 요소(문자열일 때) · 중간 식 · 덧줄 식."""
+    out = []
+    for i, h in enumerate(row.get("호표") or []):
+        if isinstance(h.get("수량"), str):
+            out.append((f"호표[{i}].수량", h["수량"]))
+        if isinstance(h.get("요소"), str):
+            out.append((f"호표[{i}].요소", h["요소"]))
+    for i, m in enumerate(row.get("중간") or []):
+        if isinstance(m.get("식"), str):
+            out.append((f"중간[{i}].식", m["식"]))
+    for i, m in enumerate(row.get("덧줄") or []):
+        if isinstance(m.get("식"), str):
+            out.append((f"덧줄[{i}].식", m["식"]))
+    return out
+
+
+def load_table_names() -> dict[str, str]:
+    """표 키 → 표 이름 (소요량_*.json · 계수_*.json)."""
+    names = {}
+    for path in list(ROOT.glob("소요량_*.json")) + list(ROOT.glob("계수_*.json")):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        for t in data.get("표", []):
+            names[t["키"]] = t.get("이름", "")
+    return names
+
+
+def load_logic_names() -> dict[str, str]:
+    names = {}
+    for path in ROOT.glob("로직_*.json"):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        for row in data.get("줄", []):
+            names[row["키"]] = row.get("이름", "")
+    return names
+
+
+def main() -> None:
+    sys.stdout.reconfigure(encoding="utf-8")
+    table_names = load_table_names()
+    logic_names = load_logic_names()
+
+    total_rows = 0
+    total_찾기 = 0
+    total_로직 = 0
+    rows_with_call = 0
+    multi_call_lines = 0  # 한 줄(자리표 하나)에 찾기·로직 합쳐 2번 이상
+    rows_with_dup_call = 0  # 같은 행 안에서 (종류,키,인자) 짝이 완전히 같은 호출이 2번 이상
+    dup_call_examples = []
+    name_collisions = {}  # 표이름 -> {키, 키, ...}  (다른 키가 같은 이름을 씀 — 별칭 지을 때 번호 필요)
+    rows_with_collision = 0
+
+    for path in sorted(ROOT.glob("로직_*.json")):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        for row in data.get("줄", []):
+            total_rows += 1
+            row_calls = []
+            has_call = False
+            for place, text in row_lines(row):
+                calls = find_calls(text)
+                if not calls:
+                    continue
+                has_call = True
+                if len(calls) >= 2:
+                    multi_call_lines += 1
+                for kind, key, args in calls:
+                    if kind == "찾기":
+                        total_찾기 += 1
+                    else:
+                        total_로직 += 1
+                    row_calls.append((kind, key, args, place))
+            if has_call:
+                rows_with_call += 1
+
+            sig_count = {}
+            for kind, key, args, place in row_calls:
+                sig = (kind, key, args)
+                sig_count[sig] = sig_count.get(sig, 0) + 1
+            dups = [s for s, c in sig_count.items() if c >= 2]
+            if dups:
+                rows_with_dup_call += 1
+                if len(dup_call_examples) < 8:
+                    dup_call_examples.append((row["키"], dups[0][0], dups[0][1], sig_count[dups[0]]))
+
+            keys_in_row = {key for kind, key, args, place in row_calls if kind == "찾기"}
+            names_seen = {}
+            collided = False
+            for key in keys_in_row:
+                nm = table_names.get(key, key)
+                names_seen.setdefault(nm, set()).add(key)
+            for nm, keys in names_seen.items():
+                if len(keys) >= 2:
+                    collided = True
+                    name_collisions.setdefault(nm, set()).update(keys)
+            if collided:
+                rows_with_collision += 1
+
+    print(f"로직 전체 줄 수: {total_rows}")
+    print(f"찾기() 호출 수: {total_찾기}")
+    print(f"로직() 호출 수: {total_로직}")
+    print(f"찾기·로직 호출이 1개 이상 있는 줄: {rows_with_call}")
+    print(f"한 자리(호표 수량 1칸·중간 식 1줄 등)에 호출이 2번 이상 겹친 자리 수: {multi_call_lines}")
+    print(f"같은 행 안에서 (표·인자)가 완전히 같은 호출이 2번 이상 반복되는 행 수: {rows_with_dup_call}")
+    print("  보기:")
+    for key, kind_str, args, count in dup_call_examples:
+        print(f"    {key} — {kind_str}({args[:40]}...) 를 {count}번")
+    print(
+        f"표 이름이 겹쳐(다른 키가 같은 표이름) 별칭에 번호가 필요한 행 수: {rows_with_collision}"
+    )
+    print("  겹치는 표이름 보기:")
+    for nm, keys in list(name_collisions.items())[:10]:
+        print(f"    '{nm}' <- {sorted(keys)}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계.
+
+수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`·중간 값·요소는
+글자로 내보내지 않고 그 자리에서 나온 수로 적음 · 끝수는 줄이 아니라 소계에 녹여 적음.
+계산 자체는 `master_formula.run` 이 한 벌만 함 — 이 글은 그 결과를 되읽어 적음.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+import master_formula as mf
+
+PLACES = Decimal("0.0001")  # 화면 `formatNumber` 와 같음(소수 넷째 자리까지)
+_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:
+    """식 한 마디 → 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜."""
+    kind = node[0]
+    if kind == "num":
+        return fmt(node[1])
+    if kind == "str":
+        return f"'{node[1]}'"
+    if kind == "neg":
+        return "-" + render(node[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)
+
+
+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(node, env: dict, master, depth: int) -> str:
+    _, op, left, right = node
+    if op == "/" and right[0] == "num" and right[1] == 100:  # 「… / 100」 은 퍼센트로
+        return f"{_side(left, node, env, master, depth, False)} %"
+    return (
+        f"{_side(left, node, env, master, depth, False)} {op} "
+        f"{_side(right, node, env, master, depth, True)}"
+    )
+
+
+def _side(child, parent, env: dict, master, depth: int, right: bool) -> str:
+    text = render(child, env, master, depth)
+    if child[0] != "bin":
+        return text
+    mine, up = _PREC[child[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["단가"] not in (0, None):
+        return ""
+    if line["수량"] == 0:
+        return "수량 0 — 이 조건에서는 안 쓰는 줄"
+    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 _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 _extra_text(extra: dict, line: dict, env: dict, master) -> str:
+    return f"{render(mf.parse(extra['식']), env, master)} = {fmt(line['금액'])}"
+
+
+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)
+    if "결과" in row:
+        text = f"{render(mf.parse(row['결과']['식']), env, master)} = {fmt(result['결과'])}"
+        one = {"이름": row.get("이름") or "", "글": text, "금액": result["결과"]}
+        group = {
+            "비목": "결과",
+            "줄": [one],
+            "소계": result["결과"],
+            "끝수": _cut_note(row, "결과"),
+        }
+        return {"ok": True, "groups": [group], "계": result["결과"]}
+    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 line["비목"].items():
+            if money == 0 and len(line["비목"]) > 1:
+                continue  # 비목이 나뉜 로직 줄 — 몫이 없는 비목엔 안 적음
+            split = part if len(line["비목"]) > 1 else None
+            one = {
+                "이름": _label(item, line),
+                "글": _line_text(item, line, env, master, split),
+                "금액": money,
+            }
+            why = _why(item, line)
+            made[part].append({**one, "까닭": why} if why else one)
+    _extras(row, shown[len(items) :], made, env, master)
+    groups = [
+        {
+            "비목": name,
+            "줄": made[name],
+            "소계": result[name],
+            "끝수": _cut_note(row),
+        }
+        for name in mf.COST_ITEMS
+        if made[name]
+    ]
+    return {"ok": True, "groups": groups, "계": result["계"]}
+
+
+def _extras(row: dict, shown: list, made: dict, env: dict, master) -> 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),
+            "금액": 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('방법')}"