From d12f471c937bd528fae2d1bf29ebe8136dbdab35 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 21 Sep 2026 19:37:55 +0900 Subject: [PATCH 1/2] =?UTF-8?q?feat(M01):=20=EC=82=AC=EB=9E=8C=EC=9D=B4=20?= =?UTF-8?q?=EC=9D=BD=EB=8A=94=20=EC=8B=9D=20=EC=A4=84=20API=20=E2=80=94=20?= =?UTF-8?q?=EB=B9=84=EB=AA=A9=20=EB=AC=B6=EC=9D=8C=EB=A7=88=EB=8B=A4=20?= =?UTF-8?q?=E3=80=8C=EB=8B=A8=EA=B0=80=20*=20=EC=88=98=EB=9F=89=EC=8B=9D?= =?UTF-8?q?=20=3D=20=EA=B8=88=EC=95=A1=E3=80=8D=20=EA=B3=BC=20=EC=86=8C?= =?UTF-8?q?=EA=B3=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 엔진 `resources/master_data/scripts/master_text.py` — 식 마디를 그 자리에서 나온 수로 풀어 한 줄 글로(찾기·로직·만약·중간 값·요소는 글자로 안 나감 · 「… / 100」 은 「… %」 · 수는 화면과 같은 자릿수) - `POST /text` — 몸은 `/calc` 와 같음 · 답 `{ok, groups: [{비목, 줄, 소계, 끝수}], 계}` · 멈추면 까닭 한 줄 - 중간 값·끝수는 따로 줄로 안 보임(끝수는 소계 옆 한 마디) · 덧줄은 그 비목의 한 줄 · 하위 로직 줄은 비목마다 한 줄 - 단가 0 이거나 안 쓰는 줄은 까닭 한 마디 - 시험 `resources/tester/test_m01_text.py` 6 통과(13-4-1 · 12-4 · 12-17-1 · 계가 `/calc` 와 같음) · M01 시험 41 통과 · typecheck 통과 · 일괄 시험 계산 1,291 그대로 Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01JgUhN55Z3BCYhUJTjwTNfj --- M01_MasterData/M01_MasterData_Router.py | 6 + M01_MasterData/M01_MasterData_Store.py | 13 ++ resources/master_data/_화면_계약.md | 8 + resources/master_data/scripts/master_text.py | 184 +++++++++++++++++++ resources/tester/test_m01_text.py | 112 +++++++++++ 5 files changed, 323 insertions(+) create mode 100644 resources/master_data/scripts/master_text.py create mode 100644 resources/tester/test_m01_text.py diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index 2edbe080..aea8f757 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -185,6 +185,12 @@ def post_calc(body: CalcBody) -> dict: return _call(store.calc, body.key, body.inputs, body.row, body.file) +@router.post("/text") +def post_text(body: CalcBody) -> dict: + """읽는 식 줄 — 몸은 `/calc` 와 같음.""" + return _call(store.text, body.key, body.inputs, body.row, body.file) + + @router.post("/save") def post_save(body: SaveBody) -> dict: return {"files": _call(store.save, [f.model_dump() for f in body.files])} diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index aa4b2a7a..f1624c9d 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -20,6 +20,7 @@ sys.path.insert(0, str(SCRIPTS)) import check_master as cm # noqa: E402 import master_keys as mk # noqa: E402 +import master_text as mtx # noqa: E402 from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape # noqa: E402 @@ -540,6 +541,18 @@ def calc(key: str, inputs: dict, row: dict | None = None, file: str | None = Non } +def text(key: str, inputs: dict, row: dict | None = None, file: str | None = None): + """사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계(`master_text`).""" + given = {k: _dec(v) for k, v in inputs.items()} + files = cm.load(folder=FOLDER) + if row is not None: + key = _swap(files, str(row.get("키") or key), row, file) + try: + return mtx.lines(files, key, given) + except (cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: + return {"ok": False, "reason": str(e) or type(e).__name__} + + # ── 저장 ────────────────────────────────────────────────────────────── def _dec(v): """화면이 보낸 수 → Decimal(파일을 읽은 모양과 같게).""" diff --git a/resources/master_data/_화면_계약.md b/resources/master_data/_화면_계약.md index e2c32f6b..dab73f7e 100644 --- a/resources/master_data/_화면_계약.md +++ b/resources/master_data/_화면_계약.md @@ -56,6 +56,14 @@ - 저장 안 한 새 초안 = `key` "" · `row` 에 로직 한 줄 통째 · `file` 은 안 보내도 됨(서버가 메모리에만 얹음). 「만들기」 모달의 [시험 계산] 이 이 길을 씀 — 키를 미리 받지 않음. - `끝수` 가 묶음이면 계산 끝에 붙음(6장) · 글자면 설명일 뿐 계산에 안 붙음. +`POST /text` — 몸은 `/calc` 와 같고, 같은 계산을 **사람이 읽는 식 줄**로 돌려줌(화면은 받은 글을 그대로 찍음). + +- 됨 — `{ok: true, groups: [{비목, 줄: [{이름, 글, 금액, 까닭?}], 소계, 끝수}], 계}` · 멈춤은 `/calc` 와 같은 `{ok: false, reason}`. +- `글` = 호표 줄은 「단가 \* 수량식 = 금액」 · 덧줄은 「식 = 금액」. 중간 값 · 요소 · `찾기()` · `로직()` · `만약()` 은 글자로 안 나오고 **그 자리에서 나온 수**로 · 「… / 100」 은 「… %」 로 · 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표). +- `비목` = `노무비` · `재료비` · `경비`(돈 아닌 로직은 묶음 하나 `결과`) · 줄이 없는 비목은 빠짐 · `소계` 는 끝수까지 붙은 값이고 `끝수` 는 그 한 마디(「원 미만 버림」 · 없으면 "") — 끝수는 따로 줄로 안 보임. +- 하위 로직 줄처럼 한 줄이 여러 비목에 걸리면 비목마다 한 줄씩 · 그 비목 몫으로 단가를 되계산해 적음. +- `까닭` = 단가가 0 이거나 못 구한 줄의 한 마디(「수량 0 — 이 조건에서는 안 쓰는 줄」 · 「단가 0 — 「MP000082」 값이 아직 없음」). + ## 4. 저장 `POST /save` 받음 `{files: [{file, version, changes: [{op, key, row}]}]}` diff --git a/resources/master_data/scripts/master_text.py b/resources/master_data/scripts/master_text.py new file mode 100644 index 00000000..6b6c33d9 --- /dev/null +++ b/resources/master_data/scripts/master_text.py @@ -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('방법')}" diff --git a/resources/tester/test_m01_text.py b/resources/tester/test_m01_text.py new file mode 100644 index 00000000..f1839073 --- /dev/null +++ b/resources/tester/test_m01_text.py @@ -0,0 +1,112 @@ +"""M01 읽는 식 줄(`POST /text`) — 계약 `resources/master_data/_화면_계약.md` 3장. + +견본 셋: 산림 13-4-1 메쌓기 · 12-4 합판거푸집 · 12-17-1 펌프카 타설. +""" + +from __future__ import annotations + +import shutil +import sys +from decimal import Decimal +from pathlib import Path + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as store + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts")) + +import master_text as mt # noqa: E402 + +REAL = store.FOLDER +STACK = "GF000219" # 13-4-1 메쌓기(인력) — 증가율이 걸린 줄 +FORM = "GF000160" # 12-4 합판거푸집 — 재료 여럿 · 수량 0 줄 +PUMP = "GF000182" # 12-17-1 펌프카 타설 — 하위 로직이 세 비목에 걸리고 덧줄이 있음 + + +@pytest.fixture +def client(tmp_path: Path, monkeypatch) -> TestClient: + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + monkeypatch.setattr(store, "FOLDER", tmp_path) + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _inputs(key: str) -> dict: + """그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`).""" + row = store.cm.master(REAL).logic(key) + return {k: str(v) for k, v in store.cm.시험입력(row).items()} + + +def _both(client: TestClient, key: str) -> tuple[dict, dict]: + body = {"key": key, "inputs": _inputs(key)} + text = client.post("/api/m01/text", json=body) + calc = client.post("/api/m01/calc", json=body) + assert text.status_code == 200 and calc.status_code == 200, text.text + return text.json(), calc.json() + + +def _all_lines(got: dict) -> list[dict]: + return [one for group in got["groups"] for one in group["줄"]] + + +def test_자릿수는_화면과_같다() -> None: + assert mt.fmt(Decimal("31500")) == "31,500" + assert mt.fmt(Decimal("2803.50")) == "2,803.5" + assert mt.fmt(Decimal("1") / Decimal(3)) == "0.3333" + assert mt.fmt(Decimal("-1234.5")) == "-1,234.5" + + +def test_메쌓기_줄은_수로만_적히고_계가_시험계산과_같다(client: TestClient) -> None: + got, calc = _both(client, STACK) + assert got["ok"] is True and Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"])) + rows = _all_lines(got) + assert [one["이름"] for one in rows] == ["석공", "보통인부"] + for one in rows: + assert "찾기(" not in one["글"] and "만약(" not in one["글"] and "로직(" not in one["글"] + assert one["글"].count("=") == 1 and " * " in one["글"] + assert "%" in rows[0]["글"] # 증가율은 따로 줄이 아니라 이 줄의 식에 녹아 있음 + assert rows[0]["글"].startswith("268,908 * ") + + +def test_합판거푸집은_비목마다_묶이고_안_쓰는_줄에_까닭이_있다(client: TestClient) -> None: + got, calc = _both(client, FORM) + assert [g["비목"] for g in got["groups"]] == ["노무비", "재료비"] + for group in got["groups"]: + assert Decimal(str(group["소계"])) == Decimal(str(calc["sums"][group["비목"]])) + assert sum(Decimal(str(one["금액"])) for one in group["줄"]) == Decimal(str(group["소계"])) + why = [one for one in _all_lines(got) if one.get("까닭")] + assert why and all("0" in one["까닭"] for one in why) + + +def test_펌프카는_하위로직이_비목마다_한_줄씩이고_덧줄이_섞인다(client: TestClient) -> None: + got, calc = _both(client, PUMP) + assert [g["비목"] for g in got["groups"]] == ["노무비", "재료비", "경비"] + assert Decimal(str(got["계"])) == Decimal(str(calc["sums"]["계"])) + pump = [one for one in _all_lines(got) if one["이름"] == "콘크리트펌프차"] + assert len(pump) == 3 # 노무비 · 재료비 · 경비 몫이 따로 + extra = next(one for one in _all_lines(got) if one["이름"].startswith("공구손료")) + assert extra["글"].endswith(f"= {mt.fmt(Decimal(str(extra['금액'])))}") and "%" in extra["글"] + + +def test_멈추는_로직은_까닭_한_줄(client: TestClient) -> None: + got = client.post("/api/m01/text", json={"key": STACK, "inputs": {}}).json() + assert got["ok"] is False and "입력" in got["reason"] + + +def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None: + got = client.get("/api/m01/logic", params={"key": STACK}).json() + row = dict(got["logic"], 끝수={"대상": "계", "자리": 0, "방법": "버림"}) + body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]} + cut = client.post("/api/m01/text", json=body).json() + assert cut["ok"] is True + group = cut["groups"][0] + assert group["끝수"] == "원 미만 버림" + assert Decimal(str(group["소계"])) == Decimal(str(group["소계"])).to_integral_value() + assert not any("버림" in one["글"] for one in group["줄"]) From efe521f6cdb401f3207111634c1dae979f927efc Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 21 Sep 2026 19:38:39 +0900 Subject: [PATCH 2/2] =?UTF-8?q?knowledge(=EB=A1=9C=EC=A7=81):=20PLAN=203-4?= =?UTF-8?q?=20=EB=B3=B5=EC=82=AC=ED=95=B4=EC=84=9C=20=EB=A7=8C=EB=93=A4?= =?UTF-8?q?=EA=B8=B0=20=EC=84=A4=EA=B3=84=20=EB=B0=91=EA=B7=B8=EB=A6=BC=20?= =?UTF-8?q?=E2=80=94=20=EB=B3=84=EC=B9=AD=20=EA=B7=9C=EC=B9=99=C2=B7?= =?UTF-8?q?=EC=A0=84=EC=88=98=20=EC=88=98=EC=B9=98=C2=B7=EB=A1=9C=EC=A7=81?= =?UTF-8?q?=EB=B6=80=EB=A5=B4=EA=B8=B0=20=EA=B0=88=EB=9E=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 찾기()·로직() 을 이름 하나로 보이는 규칙(겹치면 번호) · 로직 1,354개 전수 조사(찾기 7,500· 로직부르기 1,022 · 같은 표 다른 인자로 겹치는 행 507건은 예외가 아니라 흔한 경우) · 로직 부르기 참조냐 복사냐 두 갈래 비교와 브레인 판정 제안(기본은 참조 유지) · 복사본은 원본이 나중에 바뀌어도 안 따라감(스냅숏) 및 까닭. 화면 코드는 안 만듦 — 설계 문서만. --- resources/master_data/ref/_설계_식_복사.md | 55 +++++++ .../master_data/scripts/analyze_식_복사.py | 155 ++++++++++++++++++ 2 files changed, 210 insertions(+) create mode 100644 resources/master_data/ref/_설계_식_복사.md create mode 100644 resources/master_data/scripts/analyze_식_복사.py diff --git a/resources/master_data/ref/_설계_식_복사.md b/resources/master_data/ref/_설계_식_복사.md new file mode 100644 index 00000000..073f2162 --- /dev/null +++ b/resources/master_data/ref/_설계_식_복사.md @@ -0,0 +1,55 @@ +# 「복사해서 만들기」(PLAN 3-4) 설계 밑그림 — 식과 데이터만 + +대상: PLAN.md 3-4. 화면은 안 만듦 — 규칙과 수치 근거만 정리. 3-0 전제 그대로 따름: **정본 로직은 원문 그대로 · 화면에서 못 고침 · 개선은 복사한 새 컨테이너(자체 로직 `GX`)에서만.** + +수치는 새 `resources/master_data/scripts/analyze_식_복사.py`(읽기 전용 · 아무것도 안 씀)로 냄 — 로직 54개 파일 · 1,354줄 전수, 호표[].수량·호표[].요소·중간[].식·덧줄[].식 안의 `찾기(...)`·`로직(...)` 을 괄호 짝 맞춰 전부 뽑음. + +## ① 별칭 규칙 — 같은 표 찾기를 이름 하나로 + +**보이는 자리**: 식 문자열 속 `찾기(QC001210, '시공높이(m)'=최소(시공높이m, 7.2), 벽두께=벽두께)` 처럼 표 키+인자로 된 부분만 통째로 별칭으로 바꿔 보임 — 뒤에 붙는 `.시공량`·`.조적공` 같은 값칸 이름은 그대로 둠(이미 그 값칸 이름 자체가 뜻을 담고 있어 안 건드림). + +**이름 짓기**: +1. 기본 이름 = 그 표(`소요량_*.json`·`계수_*.json`)의 `이름` 칸, 로직 부르기는 그 로직(`로직_*.json`)의 `이름` 칸. +2. 같은 행(줄) 안에서 **같은 표를 같은 인자로 두 번 이상** 쓰면 → 별칭 하나로 합쳐 보임(번호 안 붙임 — 완전히 같은 호출이라 겹치는 게 아니라 중복 제거 대상). 예: `GC000575`(벽돌 쌓기)의 중간 3줄이 전부 `찾기(QC001210, '시공높이(m)'=최소(시공높이m, 7.2), 벽두께=벽두께)` — 별칭 `벽돌 쌓기` 하나만 만들고 세 곳 다 그걸 씀. +3. 같은 행 안에서 **같은 표를 다른 인자로** 쓰거나(아래 ② 507건 — 매우 흔함) **다른 표가 같은 표이름을 우연히 씀**(전체 3,030개 표 중 37개 이름이 92개 표에 겹침 — 예: `재료량` 이름이 표 6개에서 씀 · 행 안에서 실제로 부딪힌 경우는 이번 조사 0건이나 앞으로 생길 수 있음) → 처음 나온 순서대로 번호를 붙임: `벽돌 쌓기1`·`벽돌 쌓기2`… 순서는 그 로직 안에서 처음 등장하는 자리(호표 → 중간 → 덧줄 순) 기준으로 고정. +4. 이름이 비거나(표에 `이름` 칸이 없음) 너무 길면(대략 12자 넘으면) 표 키를 그대로 보임 — 억지로 줄이지 않음. + +**되돌리는 법**: 별칭은 저장하지 않음 — 화면에 보일 때 식 문자열에서 그때그때 만들어 씌우는 겉치레(파생물)일 뿐, JSON에 저장되는 식 원문은 항상 `찾기(원래 키, 원래 인자)` 그대로. 그래서 "되돌리기"는 별도 동작이 필요 없음 — 별칭 보기를 끄면(또는 그 값칸을 표에서 다른 표로 바꾸면) 그냥 다시 원문을 그대로 보여주거나 새 인자로 새 별칭을 다시 만들면 끝. + +## ② 로직 1,354개 전수 — 찾기·로직 부르기 수 + +| 항목 | 수 | +|---|---| +| 로직 전체 줄 | 1,354 | +| `찾기()` 호출 | 7,500 | +| `로직()` 호출(다른 로직 부르기) | 1,022 | +| 호출이 하나라도 있는 줄 | 1,319 / 1,354 | +| 한 자리(호표 수량 한 칸·중간 식 한 줄)에 호출이 2번 이상 겹친 자리 | 801 | +| 같은 행 안에서 **완전히 같은** 호출(표+인자 동일)이 2번 이상 반복 | 843줄(62%) — ①의 규칙3 "번호 안 붙임" 대상 | +| 같은 행 안에서 **같은 표를 다른 인자로** 2번 이상 | 507줄(37%) — ①의 규칙3 "번호 붙임" 대상, 흔한 경우로 봐야 함 | +| 같은 행 안에서 **같은 로직을 다른 인자로** 2번 이상 | 129줄 | +| 표이름이 겹쳐 번호가 필요한 행(다른 표 키가 같은 표이름) | 0건(이번 자료 기준 — 전체 3,030개 표 중 37개 이름이 92개 표에서 겹치나, 한 행 안에서 동시에 부딪힌 사례는 없음) | + +요지: 같은 표를 여러 번 부르는 건 예외가 아니라 절반 이상에서 일어나는 보통 경우(범위형 표를 여러 단·여러 회차에 걸쳐 부르는 산림토목 로직이 다수) — 번호 붙이는 규칙(①-3)은 장식이 아니라 필수 경로로 설계해야 함. + +## ③ 로직 부르기(`로직(...)`)를 복사할 때 — 그대로 부를지 같이 복사할지 + +로직이 다른 로직을 부르는 중첩은 얕음 — 로직이 부르는 로직이 또 다른 로직을 부르는 경우는 전체에서 4건뿐(`GF000170`·`GF000171` → `GF000185` → `GC000268`, `GF000177`·`GF000178` → `GF000168` → `GC000267`). 트리가 깊어질 걱정은 크지 않음. + +**갈래 A — 그대로 부름(참조 유지)** +- 좋은 점: 하나만 관리하면 됨 · 정본이 품셈 개정으로 갱신되면 복사본도 최신 계산을 따라감 · 로직이 로직을 부르는 자리(1,022건)를 전부 펼쳐 복사할 필요가 없어 복사량이 작음. +- 나쁜 점: 복사본이 완전히 "내 것"은 아님 — 부른 로직 쪽 계산까지 내가 바꾸고 싶으면 결국 그 로직도 복사해야 함(갈래 B로 전환 필요). + +**갈래 B — 같이 복사(펼쳐서 자체 로직으로 통째로 복사)** +- 좋은 점: 복사 시점 값을 완전히 고정 · 부르는 로직의 계산식까지 마음대로 고칠 수 있음. +- 나쁜 점: 여러 로직이 같은 하위 로직(예: `GC000268` 굴삭기 계열 — 위 4건 포함 자주 불림)을 부르면 복사할 때마다 따로따로 자체 로직이 생겨 같은 계산이 여러 벌로 벌어짐 · 하위 로직에서 나중에 원문 오류가 고쳐져도 복사본은 못 따라가 옛 값을 계속 씀. + +**브레인 판정 제안**: 기본은 **갈래 A(그대로 부름)**. 까닭 — 3-0 전제상 정본 로직 자체는 「원문 그대로 · 안 바뀜」이 원칙이라 참조해도 계산이 몰래 바뀔 위험이 원래 없음(바뀌는 유일한 경우는 품셈 개정판 반영인데, 그때는 오히려 참조 전부가 최신 법령을 따라가는 쪽이 맞음). 다만 PLAN 3-4 문구대로 **부르는 자리마다 선택은 사용자에게 맡김** — 그 하위 로직 자체를 고치고 싶다는 뜻이 분명한 경우(예: 인자만 바꾸는 게 아니라 계산식을 바꾸려 할 때)만 그 호출 하나를 갈래 B로 펼침. + +## ④ 복사한 뒤 원본이 바뀌면 복사본은? + +**안 따라감이 맞음.** 까닭: + +- 「복사해서 만들기」를 쓰는 목적 자체가 정본을 안 건드리고 내 것을 만드는 것 — 복사 시점 값을 그대로 박아 넣는 스냅숏이어야 사용자가 그 뒤 손댄 내용과 원본 개정이 뒤섞여 충돌하지 않음. +- 데이터 3층 원칙(§5)의 결과 같음 — 확정된 값은 그 뒤 원천이 바뀌어도 조용히 안 바뀜(초기값 스냅숏과 같은 결). 설계를 확정해 둔 뒤 원본이 나중에 바뀌었다고 계산 결과가 몰래 달라지면 이미 넘긴 견적이 어긋나는 사고로 이어짐. +- ③의 갈래 A(그대로 부름)와는 층위가 다름 — ③은 "로직 안에서 하위 로직을 참조냐 복사냐"의 선택이고, ④는 "복사라는 행위 자체가 끝난 뒤 원본-복사본 관계"라 복사인 이상 독립이 자연스러움. ③에서 그대로 부르기를 고른 자리는 계속 정본을 참조하므로 정본이 갱신되면 그 자리만 같이 갱신됨 — 이건 ③의 선택이 그렇게 되도록 만든 것이지 ④가 뒤집는 게 아님. diff --git a/resources/master_data/scripts/analyze_식_복사.py b/resources/master_data/scripts/analyze_식_복사.py new file mode 100644 index 00000000..168c470f --- /dev/null +++ b/resources/master_data/scripts/analyze_식_복사.py @@ -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()