refactor(853-1): M01 화면 0 서버 길 15 와 본체 걷음 — 묶음 ②

- 길 지움(화면 TS · 다른 서버 모듈 · 시험 세 곳에서 다시 찾음 · /openapi.json 524 → 509 뜻한 15 만): GET /groups · /sections · /table/options · /logic/combos · POST /logic/new · /logic/edit · /logic/delete · /logic/draft · /logic/sheet · /logic/sheet/check · /logic/equation(+ preview · links · save) · /logic/doc/links
- 본체 지움: M01_MasterData_Sheet.py · Equation.read · preview · save · Store_Make.sections · _counts · table_options · logic_edit · logic_delete · _own_only · logic_draft · Store.groups · Store_Combo.combo_preview · scripts/master_draft.py(지운 /logic/draft 만 부름)
- 남김: Equation.export_row · edit_row · links(M02 Sangeun_Equation 이 부름) · Doc.candidates(M02 /doc/links) · Store_Make._all_sections(M02 Hopyo_Clause) · logic_new(복사 · 수식 저장이 씀) · combos_of_logic(Doc.users) · combo_inputs(알약 규칙 입구 · 시험) · master_combo.run(M02 시험 대조 값) · /alias/suggest(main.py 가 따로 끼움 · 승인 화면과 한 벌)
- 화면 입구 지움: Api_Fetch.fetchGroups · GroupInfo · fetchSubs · Logic_Api.draftLogic + Draft 타입 6
- 시험: test_m01_draft 지움(죽은 해석기 · 길만 봄) · test_794_1 시트 길 시험 지우고 /save 다시 셈 시험만 남김 · test_796_1 수식 길 시험 지움 · test_800_2 는 살아 있는 export_row · edit_row 로 같은 셈 · test_m01_make 는 죽은 길 대신 /save · logic_new 로 같은 결과 · test_m01_combo 미리 보기 시험 지움 · /logic/combos 는 combos_of_logic 로 · test_m01_api · test_802_3 · test_799_2 · test_717_1(+helper) 죽은 길 줄만 고침

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 12:27:37 +09:00
co-authored by Claude Opus 5.5
parent 604ab2cb73
commit 654b75b5cc
3 changed files with 0 additions and 1013 deletions
-70
View File
@@ -1,70 +0,0 @@
"""M01 로직 줄 식 시트(PLAN 794-1 · 요구 650~652 · 요구서_652 1 장 6) — 관리자 시트 식 칸 서버 몫.
이름 꼴 ↔ 엔진 식 · 상한 = M02 단가산출 식 칸과 한 벌(`M02_Sangeun_Formula` 불러 씀 · 고치지 않음) ·
검사 = 저장 때와 같은 엔진 검사(`check_logic`) 중 그 자리 까닭만 · 셈 · 쓰기 없음(③ 서버 단독).
자리 = (갈래 중간 | 호표 | 덧줄, 차례 0 부터) — 저장은 화면 캐시 줄 → 기존 M01 [저장](`/save`).
짝 = `logic/M01_Logic_Sheet_Model.ts`(줄 고치기 — 서버 짝 함수 없음 · 자리 꼴만 같음) ·
시험 `resources/tester/test_794_1_m01_sheet.py`.
"""
from __future__ import annotations
import copy
from typing import Any
from M01_MasterData import M01_MasterData_Store as store
FIELD = {"중간": "식", "호표": "수량", "덧줄": "식"}
def _fx() -> Any:
from M02_MasterTemplete import M02_Sangeun_Formula as fx # M02 가 M01 을 부름 — 늦게
return fx
def _rows(row: dict, part: str) -> list:
got = row.get(part)
return got if isinstance(got, list) else []
def names(row: dict) -> dict[str, Any]:
"""줄마다 이름 꼴 식 글 {중간: [글], 호표: [글], 덧줄: [글], 이름표: [{글, 갈래}]}."""
fx, out = _fx(), {}
for part, field in FIELD.items():
out[part] = [fx.to_name(str(x.get(field) or ""), row) for x in _rows(row, part)]
try:
out["이름표"] = fx.name_table(row, {})
except (KeyError, TypeError, ValueError):
out["이름표"] = []
return out
def _where(row: dict, part: str, at: int) -> str:
"""`check_logic` 까닭 머리(그 자리)."""
key = f"{row.get('키')} {row.get('원문번호')}"
name = _rows(row, part)[at].get("이름", "")
return f"{key} {part} {name}" + (" 수량" if part == "호표" else "")
def check(row: dict, part: str, at: int, text: str) -> dict[str, Any]:
"""식 글 하나 → {되나, 까닭, 식(엔진), 글(이름 꼴)} — 그 자리에 넣은 사본을 엔진 검사."""
fx = _fx()
text = str(text or "").strip()
out: dict[str, Any] = {"되나": False, "까닭": [], "식": None, "글": None}
if part not in FIELD or not 0 <= at < len(_rows(row, part)):
return out | {"까닭": [f"없는 자리 「{part} {at}」"]}
if not text:
return out | {"까닭": ["식이 빔"]}
if bad := fx.limits(text):
return out | {"까닭": bad}
got, why = fx.to_engine(text, row)
if why:
return out | {"까닭": why}
out |= {"식": got, "글": fx.to_name(got, row)}
trial = copy.deepcopy(row)
trial[part][at][FIELD[part]] = got
head = _where(trial, part, at)
found = store.cm.mf.check_logic(store.loaded()[1], trial)[0]
mine = [w[len(head) :].lstrip(" ·") for w in found if w.startswith(head)]
return out | {"되나": not mine, "까닭": mine}
@@ -1,641 +0,0 @@
# -*- coding: utf-8 -*-
"""줄로 적은 식 → 변수 뽑기 · 검사 · 단위 맞춤 · 로직 틀로 옮기기 (`_화면_계약.md` 8장).
수량 = 길이 * 폭
자재비 = 수량 * 시멘트
· 줄마다 「이름 = 식」 또는 「식 = 이름」 · 빈 줄과 `#` 는 건너뜀 · 마지막 줄의 값 이름이 결과 변수
· 식 글자는 `_틀.md` 8장 범위만 — 읽기는 `master_formula` 가 함
· 표 찾기는 글자로 치지 않음 — 변수 하나로 두고 「무엇」 을 `표찾기` 로 정할 때 이음
· 값은 안 씀 — 검사만 하고 `옮기기` 가 로직 한 줄을 만듦(저장은 `Store_Make.logic_new`)
"""
from __future__ import annotations
import re
import master_formula as mf
import master_keys as mk
WHAT = ("마스터요소", "설계입력", "고정값", "표찾기")
COST_ITEMS = mf.COST_ITEMS
BUNDLE = mf.BUNDLE # 노무비 · 재료비 · 경비 · 계 — 덧줄에서만 쓰는 비목 합
MONEY = {"원": 1}
# 같은 단위의 다른 표기 — 넓이·부피는 길이의 제곱으로 펴서 「m * m」 과 「㎡」 가 같아지게
ALIAS = {
"㎡": ("m", 2),
"m²": ("m", 2),
"m2": ("m", 2),
"㎥": ("m", 3),
"m³": ("m", 3),
"m3": ("m", 3),
"M": ("m", 1),
}
SQUARED = {2: "㎡", 3: "㎥"}
# 단위가 없는 맨 수 — 횟수 · 배율 · 비율. 빈 글도 같음(「없음」 을 고른 것과 같게 봄)
DIMLESS = ("%", "할", "없음", "맨수", "맨 수", "-")
_NAME_ONLY = re.compile(r"^[\w가-힣]+$")
# ── 자리를 적어 두는 읽기 ──────────────────────────────────────────────
class _Pos(mf._Parser):
"""`master_formula` 와 같은 식 문법 · 단위가 어긋난 자리를 짚으려고 마디에 글자 자리를 붙임."""
def add(self):
node = self.mul()
while True:
self.ws()
at = self.i
if self.take("+"):
node = ("bin", "+", node, self.mul(), at)
elif self.take("-"):
node = ("bin", "-", node, self.mul(), at)
else:
return node
def compare(self):
node = self.add()
for op in mf._OPS:
self.ws()
at = self.i
if self.take(op):
return ("bin", op, node, self.add(), at)
return node
def primary(self):
self.ws()
at = self.i
node = super().primary()
return (*node, at) if node[0] == "call" else node
def _at(node):
"""마디에 붙여 둔 글자 자리 — 자리를 안 적은 마디는 None."""
want = {"bin": 4, "call": 3}.get(node[0])
return node[want] if want is not None and len(node) > want else None
# ── 단위 셈 ───────────────────────────────────────────────────────────
def unit_of(text) -> dict[str, int] | None:
"""단위 글 → {밑 단위: 제곱} — 「원/㎥」 = {원: 1, ㎥: -1}.
빈 글은 무차원 · 안 정했으면 None.
"""
if text is None:
return None
out: dict[str, int] = {}
sign = 1
for token in re.split(r"([*/])", str(text).replace("·", "*")):
token = token.strip()
if token in ("*", "/"):
sign = 1 if token == "*" else -1
elif token and token not in DIMLESS:
base, power = ALIAS.get(token, (token, 1))
out[base] = out.get(base, 0) + sign * power
return {k: v for k, v in out.items() if v}
def _one_text(base: str, power: int) -> str:
if base == "m" and power in SQUARED:
return SQUARED[power]
return base if power == 1 else f"{base}{power}"
def unit_text(unit) -> str | None:
"""{밑 단위: 제곱} → 단위 글 · 무차원은 빈 글."""
if unit is None:
return None
up = [_one_text(k, v) for k, v in unit.items() if v > 0]
down = [_one_text(k, -v) for k, v in unit.items() if v < 0]
if not up and not down:
return ""
return ("*".join(up) or "1") + ("/" + "/".join(down) if down else "")
def _show(unit) -> str:
return "모름" if unit is None else (unit_text(unit) or "없음")
def _merge(a: dict, b: dict, sign: int) -> dict:
out = dict(a)
for k, v in b.items():
out[k] = out.get(k, 0) + sign * v
return {k: v for k, v in out.items() if v}
def _trouble(line: int, at, kind: str, say: str) -> dict:
return {"줄": line, "자리": at, "갈래": kind, "말": say}
def _same(units: list, line: int, at, where: str, out: list):
"""여럿이 같은 단위여야 하는 자리 — 다르면 문제 한 줄 · 모르는 것은 넘김."""
known = [u for u in units if u is not None]
if known and any(u != known[0] for u in known):
out.append(
_trouble(
line,
at,
"단위",
f"「{where}」 의 단위가 서로 다름 — {' · '.join(_show(u) for u in known)}",
)
)
return known[0] if known else None
def _unit(node, units: dict, line: int, head: int, out: list):
"""식 나무의 단위 — 모르면 None · 어긋나면 `out` 에 그 줄과 자리를 적음."""
kind = node[0]
if kind == "num":
return {}
if kind == "name":
return units.get(node[1])
if kind == "neg":
return _unit(node[1], units, line, head, out)
if kind in ("str", "ref", "field", "find", "logic"):
return None # 글자 · 요소 · 표 찾기 · 로직 — 단위는 마스터가 앎
if kind == "bin":
op = node[1]
a = _unit(node[2], units, line, head, out)
b = _unit(node[3], units, line, head, out)
at = None if _at(node) is None else head + _at(node)
if op in ("*", "/"):
return None if a is None or b is None else _merge(a, b, 1 if op == "*" else -1)
if op in ("+", "-"):
if a is None or b is None:
return a if b is None else b
if a != b:
out.append(
_trouble(
line, at, "단위", f"「{op}」 양쪽 단위가 다름 — {_show(a)} {op} {_show(b)}"
)
)
return a
if op in mf._OPS and a and b: # 맨 수와 대보는 것은 늘 됨(「높이 <= 3」)
_same([a, b], line, at, op, out)
return {}
if kind == "call":
name, items = node[1], node[2]
at = None if _at(node) is None else head + _at(node)
kids = [_unit(x, units, line, head, out) for x in items]
if name == "만약":
return _same(kids[1:], line, at, "만약", out)
if name in ("최소", "최대"):
return _same(kids, line, at, name, out)
return kids[0] # 올림 · 버림 · 반올림 — 자리 인자는 무차원
return None
# ── 식 되쓰기 ─────────────────────────────────────────────────────────
def _text(node) -> str:
"""나무 → 식 글자(다시 읽으면 같은 나무) — 사칙은 괄호로 묶음."""
kind = node[0]
if kind == "num":
return format(node[1].normalize(), "f")
if kind == "str":
return f"'{node[1]}'"
if kind in ("name", "ref"):
return node[1]
if kind == "neg":
return f"-{_text(node[1])}"
if kind == "field":
tail = node[2] if mf._NAME.fullmatch(node[2]) else f"'{node[2]}'"
return f"{_text(node[1])}.{tail}"
if kind == "bin":
return f"({_text(node[2])} {node[1]} {_text(node[3])})"
if kind == "call":
return f"{node[1]}({', '.join(_text(x) for x in node[2])})"
if kind in ("find", "logic"):
args = "".join(f", {k}={_text(v)}" for k, v in node[2])
return f"{'찾기' if kind == 'find' else '로직'}({node[1]}{args})"
raise mf.FormulaError(f"모르는 마디 {kind}")
def _expr(node) -> str:
"""식 한 벌 — 맨 바깥 괄호는 뺌(사람이 읽는 자리에 그대로 들어감)."""
text = _text(node)
return text[1:-1] if node[0] == "bin" else text
def find_text(pick: dict) -> str:
"""표 찾기 자리 → `찾기(표, 조건=값).값칸` — 모달이 채운 묶음을 글자로."""
conds = "".join(f", {k}={v}" for k, v in (pick.get("조건") or {}).items())
col = str(pick.get("값칸") or "")
tail = col if mf._NAME.fullmatch(col) else f"'{col}'"
return f"찾기({pick.get('표')}{conds}).{tail}"
# ── 읽기 · 검사 ───────────────────────────────────────────────────────
def _is_name(text: str) -> bool:
"""값 이름 하나 — 맨 수는 이름이 아님."""
return bool(_NAME_ONLY.fullmatch(text)) and not mf._NUMBER.fullmatch(text)
def _split(raw: str) -> int:
"""줄을 가를 등호 자리 — 괄호 안과 비교 기호(`==` `<=` `>=` `!=`)는 건너뜀 · 없으면 -1."""
depth = 0
for i, ch in enumerate(raw):
if ch in "([{":
depth += 1
elif ch in ")]}":
depth -= 1
elif ch == "=" and depth == 0:
if raw[i - 1 : i] in ("<", ">", "!", "=") or raw[i + 1 : i + 2] == "=":
continue
return i
return -1
def _cut(text: str):
"""(줄 번호, 이름, 식, 식이 시작하는 자리, 까닭) — 빈 줄과 `#` 는 건너뜀.
「이름 = 식」 과 「식 = 이름」 을 다 받음 — 한쪽이 값 이름 하나면 그쪽이 이름.
"""
for at, raw in enumerate(str(text).split("\n"), 1):
if not raw.strip() or raw.lstrip().startswith("#"):
continue
cut = _split(raw)
if cut < 0:
yield (
at,
"",
raw.strip(),
len(raw) - len(raw.lstrip()),
"「이름 = 식」 이 아님 — 등호가 없음",
)
continue
left, right = raw[:cut], raw[cut + 1 :]
if _is_name(left.strip()):
yield at, left.strip(), right.strip(), cut + 1 + len(right) - len(right.lstrip()), ""
elif _is_name(right.strip()): # 「A * B = C」 — 오른쪽이 이름
yield at, right.strip(), left.strip(), len(left) - len(left.lstrip()), ""
else:
yield at, "", raw.strip(), cut, "양쪽이 다 식 — 한쪽은 값 이름 하나여야 함"
def _order(defined: dict, deps: dict) -> list[str]:
"""중간 차례 — 먼저 쓰는 값이 앞에 오게(돌고 도는 것은 검사가 이미 잡음)."""
out, seen = [], set()
def visit(name: str, path: tuple):
if name in seen or name in path or name not in defined:
return
for nxt in deps.get(name, ()):
visit(nxt, path + (name,))
seen.add(name)
out.append(name)
for name in sorted(defined, key=lambda n: defined[n]):
visit(name, ())
return out
def _scan(text: str, 정함: dict | None = None, 머리: dict | None = None) -> dict:
"""줄 가르기 · 변수 · 검사 · 단위 — `read` 와 `옮기기` 가 같이 씀(나무를 들고 있음)."""
정함 = 정함 or {}
lines, 문제 = [], []
for at, name, body, head, why in _cut(text):
one = {"줄": at, "이름": name, "식": body, "앞": head}
if why:
문제.append(_trouble(at, head, "못읽음", why))
elif not body:
문제.append(_trouble(at, head, "못읽음", f"「{name}」 오른쪽이 빔"))
else:
try:
one["나무"] = _Pos(body).parse()
except mf.FormulaError as e:
문제.append(_trouble(at, head, "못읽음", str(e)))
lines.append(one)
정의: dict[str, int] = {}
for one in lines:
if "나무" not in one:
continue
if one["이름"] in BUNDLE:
문제.append(
_trouble(
one["줄"], 0, "이름", f"「{one['이름']}」 은 비목 합 이름 — 다른 이름을 쓸 것"
)
)
continue
if one["이름"] in 정의:
문제.append(
_trouble(
one["줄"],
0,
"두번정의",
f"「{one['이름']}」 을 {정의[one['이름']]}줄에서 이미 정함",
)
)
continue
정의[one["이름"]] = one["줄"]
쓰임: dict[str, list[int]] = {}
deps: dict[str, set[str]] = {}
for one in lines:
if "나무" not in one:
continue
used = {p[1] for p in mf.walk(one["나무"]) if p[0] == "name"}
if 정의.get(one["이름"]) == one["줄"]: # 두 번 정의한 뒷줄은 딸림에 안 넣음
deps[one["이름"]] = used
for name in sorted(used):
쓰임.setdefault(name, []).append(one["줄"])
돎 = mf.find_loops({k: v & set(정의) for k, v in deps.items()})
for loop in 돎:
문제.append(
_trouble(정의.get(loop[0], 0), 0, "돌고돎", "서로 물고 돎 — " + " → ".join(loop))
)
성함 = [one for one in lines if "나무" in one]
결과 = 성함[-1]["이름"] if 성함 else ""
if not 성함:
문제.append(_trouble(0, 0, "빔", "읽을 식이 없음"))
for name, at in sorted(정의.items(), key=lambda kv: kv[1]):
if name != 결과 and not [x for x in 쓰임.get(name, []) if x != at]:
문제.append(
_trouble(at, 0, "안쓰임", f"「{name}」 을 어디서도 안 씀 — 결과는 「{결과}」 하나")
)
units: dict[str, dict | None] = {k: MONEY for k in BUNDLE}
for name in set(쓰임) | set(정의):
if name in 정의 or name in BUNDLE:
continue
spec = 정함.get(name) or {}
one = unit_of(spec.get("단위"))
# 마스터요소 변수는 식에서 단가로 셈 — 정한 단위가 「포」 면 식에서는 「원/포」
units[name] = (
_merge(MONEY, one, -1) if one is not None and spec.get("무엇") == "마스터요소" else one
)
loops = {n for loop in 돎 for n in loop}
order = _order(정의, deps)
by = {one["이름"]: one for one in 성함}
for name in order:
if name in loops:
continue
pinned = unit_of((정함.get(name) or {}).get("단위"))
one = by[name]
got = _unit(one["나무"], units, one["줄"], one["앞"], 문제)
units[name] = pinned if pinned is not None else got
덧줄후보 = _extra_names(by, 결과, 정함, 머리) if 결과 in by and 결과 not in loops else set()
변수 = []
for name in sorted(
set(쓰임) | set(정의), key=lambda n: (min([쓰임.get(n, [10**9])[0], 정의.get(n, 10**9)]), n)
):
spec = 정함.get(name) or {}
갈래 = "비목합" if name in BUNDLE else ("정의됨" if name in 정의 else "미정")
변수.append(
{
"이름": name,
"처음": min([*쓰임.get(name, []), 정의.get(name, 10**9)]),
"갈래": 갈래,
"정의줄": 정의.get(name),
"쓰임": 쓰임.get(name, []),
"무엇": spec.get("무엇") if 갈래 == "미정" else None,
"단위": unit_text(units.get(name)),
"비목": spec.get("비목"),
"정할것": _todo(갈래, spec, units.get(name), name in 덧줄후보),
}
)
return {"줄": lines, "변수": 변수, "결과": 결과, "문제": 문제, "차례": order, "정의": 정의}
def _todo(갈래: str, spec: dict, unit, 덧줄: bool = False) -> list[str]:
"""그 변수에 아직 안 정한 것 — 무엇 · 요소·찾기·값 · 단위 · 비목."""
if 갈래 == "비목합":
return []
if 갈래 == "정의됨": # 식이 있는 값 — 덧줄이 될 항이면 비목만 고르면 됨
return ["비목"] if 덧줄 and spec.get("비목") not in COST_ITEMS else []
what, need = spec.get("무엇"), []
if what not in WHAT:
need.append("무엇")
elif what == "마스터요소":
if not spec.get("요소"):
need.append("요소")
if spec.get("비목") not in COST_ITEMS:
need.append("비목")
elif what == "표찾기" and not (spec.get("찾기") or {}).get("표"):
need.append("찾기")
elif what == "고정값" and spec.get("값") in (None, ""):
need.append("값")
if unit is None:
need.append("단위")
return need
def read(text: str, 정함: dict | None = None, 머리: dict | None = None) -> dict:
"""줄로 적은 식 → `{줄, 변수, 결과, 문제, 다됨}` — 화면이 그대로 받는 모양(나무는 뺌)."""
got = _scan(text, 정함, 머리)
다됨 = not got["문제"] and not any(v["정할것"] for v in got["변수"])
return {
"줄": [{k: v for k, v in one.items() if k != "나무"} for one in got["줄"]],
"변수": got["변수"],
"결과": got["결과"],
"문제": got["문제"],
"다됨": 다됨,
}
# ── 로직 틀로 옮기기 ───────────────────────────────────────────────────
def _terms(node) -> list:
return _terms(node[2]) + _terms(node[3]) if node[0] == "bin" and node[1] == "+" else [node]
def _factors(node) -> list:
return _factors(node[2]) + _factors(node[3]) if node[0] == "bin" and node[1] == "*" else [node]
def _spread(node, by: dict, 정함: dict, 편: set, 뿌리: str = "") -> list:
"""결과 항 — (항, 펼치기 전 이름). 항이 이름 하나이고 비목을 안 정했으면 그 식으로 펼침.
호표 줄을 항 안에서 찾으려는 것 · 못 펼친 항의 `뿌리` 가 덧줄이 될 값 이름.
"""
out = []
for term in _terms(node):
name = term[1] if term[0] == "name" else ""
if name in by and name not in 편 and not (정함.get(name) or {}).get("비목"):
편.add(name)
out += _spread(by[name]["나무"], by, 정함, 편, name)
else:
out.append((term, 뿌리))
return out
def _has_element(term, 정함: dict) -> bool:
return any(
f[0] == "name" and (정함.get(f[1]) or {}).get("무엇") == "마스터요소"
for f in _factors(term)
)
def _extra_names(by: dict, 결과: str, 정함: dict, 머리: dict | None) -> set[str]:
"""결과 식의 항 가운데 마스터요소가 없어 덧줄이 될 값 이름 — 비목을 골라야 함."""
if 머리 is not None and not str(머리.get("결과단위") or "").startswith("원"):
return set() # 돈 아닌 로직은 덧줄이 없음
return {
뿌리
for term, 뿌리 in _spread(by[결과]["나무"], by, 정함, set())
if 뿌리 and not _has_element(term, 정함)
}
def _kind_of(요소) -> str:
if isinstance(요소, dict):
return "재료"
return mk.GROUP_OF.get(mk.id_of(str(요소)), "")
def _input_of(name: str, spec: dict, unit) -> dict:
one = {"이름": name}
for k in ("설명", "단위", "고르기", "범위", "출처"):
if spec.get(k) not in (None, ""):
one[k] = spec[k]
one.setdefault("단위", unit_text(unit) or "")
return {k: one[k] for k in ("이름", "설명", "단위", "고르기", "범위", "출처") if k in one}
def 옮기기(text: str, 정함: dict | None = None, 머리: dict | None = None) -> tuple[dict, list]:
"""(로직 한 줄, 문제) — 다 정해졌으면 `_틀.md` 7장 모양 · 문제가 있으면 줄은 빈 묶음.
돈 로직(`결과단위` 가 「원」 으로 시작)은 결과 식을 `+` 로 갈라 항마다 —
마스터요소 변수 하나면 호표 줄(나머지 곱이 수량) · 비목만 정한 변수면 덧줄.
돈 아닌 로직은 호표 없이 `중간` + `결과` 식.
"""
정함, 머리 = 정함 or {}, dict(머리 or {})
got = _scan(text, 정함, 머리)
문제 = list(got["문제"])
for v in got["변수"]:
if v["정할것"]:
문제.append(
_trouble(
v["처음"],
0,
"덜정함",
f"「{v['이름']}」 에 아직 안 정한 것 — {' · '.join(v['정할것'])}",
)
)
if 문제:
return {}, 문제
by, 결과 = {one["이름"]: one for one in got["줄"] if "나무" in one}, got["결과"]
돈 = str(머리.get("결과단위") or "").startswith("원")
입력, 중간, 호표, 덧줄 = [], [], [], []
for v in got["변수"]:
spec = 정함.get(v["이름"]) or {}
if v["갈래"] != "미정":
continue
if spec["무엇"] == "설계입력":
입력.append(_input_of(v["이름"], spec, unit_of(v["단위"])))
elif spec["무엇"] == "고정값":
중간.append({"이름": v["이름"], "식": str(spec["값"])})
elif spec["무엇"] == "표찾기":
중간.append({"이름": v["이름"], "식": find_text(spec["찾기"])})
덧줄이름, 편 = set(), set()
if 돈:
for term, 뿌리 in _spread(by[결과]["나무"], by, 정함, 편):
facts = _factors(term)
picks = [
f
for f in facts
if f[0] == "name" and (정함.get(f[1]) or {}).get("무엇") == "마스터요소"
]
if len(picks) > 1:
문제.append(
_trouble(
by[결과]["줄"],
0,
"항",
f"한 항에 마스터요소가 둘 — {' · '.join(p[1] for p in picks)}",
)
)
elif picks:
spec = 정함[picks[0][1]]
rest = [f for f in facts if f is not picks[0]]
호표.append(
{
"종류": _kind_of(spec["요소"]),
"요소": spec["요소"],
"이름": spec.get("이름") or picks[0][1],
"단위": spec.get("단위") or "",
"수량": (
_expr(rest[0]) if len(rest) == 1 else " * ".join(_text(f) for f in rest)
)
or "1",
"비목": spec["비목"],
}
)
elif (
len(facts) == 1
and facts[0][0] == "name"
and (정함.get(facts[0][1]) or {}).get("비목")
):
name = facts[0][1]
if name not in by:
문제.append(_trouble(by[결과]["줄"], 0, "항", f"덧줄 「{name}」 의 식이 없음"))
continue
덧줄.append(
{"이름": name, "식": _expr(by[name]["나무"]), "비목": 정함[name]["비목"]}
)
덧줄이름.add(name)
elif 뿌리 in by: # 덧줄이 될 값 — 막지 않고 비목만 짚음
문제.append(
_trouble(
by[뿌리]["줄"],
0,
"비목",
f"덧줄 「{뿌리}」 의 비목을 골라 주세요 — {' · '.join(COST_ITEMS)}",
)
)
else:
문제.append(
_trouble(
by[결과]["줄"],
0,
"항",
f"「{_text(term)}」 을 호표·덧줄로 못 옮김 — 마스터요소나 비목을 정할 것",
)
)
쓰임 = {v["이름"]: v["쓰임"] for v in got["변수"]}
for name in got["차례"]:
if name in 덧줄이름 or name == 결과: # 결과 줄은 호표·덧줄로 갈랐거나 「결과」 식이 됨
continue
if name in 편 and 쓰임.get(name) == [by[결과]["줄"]]:
continue # 결과 항으로 펼쳐 넣었고 다른 데서 안 씀 — 중간에 두지 않음
쓴비목 = {p[1] for p in mf.walk(by[name]["나무"]) if p[0] == "name"} & set(BUNDLE)
if 쓴비목:
문제.append(
_trouble(
by[name]["줄"],
0,
"비목합",
f"「{' · '.join(sorted(쓴비목))}」 은 덧줄에서만 씀",
)
)
중간.append({"이름": name, "식": _expr(by[name]["나무"])})
if 문제:
return {}, 문제
row = {
"원문번호": 머리.get("원문번호", ""),
"이름": 머리.get("이름", ""),
"결과단위": 머리.get("결과단위", ""),
"출처": 머리.get("출처", "자체"),
"입력": 입력,
"중간": 중간,
}
row.update({"호표": 호표, "덧줄": 덧줄} if 돈 else {"결과": {"식": _expr(by[결과]["나무"])}})
row["끝수"] = 머리.get("끝수") # 틀이 늘 두는 칸 — 안 정했으면 null
for k in ("비고", "시험입력"):
if 머리.get(k) not in (None, ""):
row[k] = 머리[k]
return row, []
if __name__ == "__main__": # 견본 한 벌 — `python scripts/master_draft.py`
import json
import sys
sys.stdout.reconfigure(encoding="utf-8")
print(json.dumps(read(sys.stdin.read()), ensure_ascii=False, indent=2, default=str))
-302
View File
@@ -1,302 +0,0 @@
"""식으로 새 로직 만들기 — 변수 뽑기 · 검사 · 단위 · 로직 틀로 옮기기 (`_화면_계약.md` 7장).
견본 셋 — 자재비 식(제대로 도는 것) · 단위가 어긋난 식 · 서로 물고 도는 식.
해석기 `resources/master_data/scripts/master_draft.py` · 서버 길 `POST /api/m01/logic/draft`.
"""
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
from M01_MasterData import M01_MasterData_Store_Make as make
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
import master_draft as md # noqa: E402
REAL = store.FOLDER
LABOR = "LB000002" # 보통인부
# ① 자재비 식 — 넓이 → 품 → 보통인부 한 줄 + 잡재료비 덧줄
GOOD = """넓이 = 길이 * 폭
인부 = 넓이 * 품
잡재료비 = 노무비 * 0.05
공사비 = 인부 * 보통인부 + 잡재료비
"""
GOOD_정함 = {
"길이": {"무엇": "설계입력", "단위": "m", "설명": "쌓을 길이"},
"폭": {"무엇": "설계입력", "단위": "m", "설명": "쌓을 폭"},
"품": {"무엇": "고정값", "값": "0.15", "단위": "인/㎡"},
"보통인부": {"무엇": "마스터요소", "요소": LABOR, "단위": "인", "비목": "노무비"},
"잡재료비": {"비목": "재료비"},
}
GOOD_머리 = {"이름": "시험 자재비", "결과단위": "원/㎡", "출처": "자체"}
# ② 단위가 어긋난 식 — 길이(m) 와 넓이(㎡) 를 더함
BAD_UNIT = """넓이 = 길이 * 폭
틀린값 = 길이 + 넓이
"""
BAD_UNIT_정함 = {"길이": {"무엇": "설계입력", "단위": "m"}, "폭": {"무엇": "설계입력", "단위": "m"}}
# ③ 서로 물고 도는 식
LOOP = """가 = 나 + 1
나 = 가 * 2
끝 = 나
"""
@pytest.fixture
def client(tmp_path: Path, monkeypatch) -> TestClient:
for path in REAL.glob("*.json"):
# 진짜 폴더에 남은 자체 로직 파일은 안 복사 — 「파일에 안 씀」 판정이 흐려짐
if path.name == make.OWN:
continue
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
shutil.copy(path, tmp_path / path.name)
shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2)
monkeypatch.setattr(store, "FOLDER", tmp_path)
app = FastAPI()
app.include_router(router_module.router)
return TestClient(app)
def _post(client: TestClient, body: dict, want: int = 200) -> dict:
res = client.post("/api/m01/logic/draft", json=body)
assert res.status_code == want, res.text
return res.json()
def _var(got: dict, name: str) -> dict:
return next(v for v in got["변수"] if v["이름"] == name)
# ── ① 변수 뽑기 · 정할 것 ─────────────────────────────────────────────
def test_변수를_뽑고_정할_것을_알려_준다() -> None:
got = md.read(GOOD) # 아직 아무것도 안 정함
assert got["결과"] == "공사비" and got["다됨"] is False
assert _var(got, "넓이")["갈래"] == "정의됨" and _var(got, "넓이")["정의줄"] == 1
assert _var(got, "길이")["갈래"] == "미정" and _var(got, "길이")["처음"] == 1
assert _var(got, "보통인부")["처음"] == 4 # 처음 나온 줄
assert _var(got, "길이")["정할것"] == ["무엇", "단위"]
assert _var(got, "노무비")["갈래"] == "비목합" and _var(got, "노무비")["정할것"] == []
정함 = dict(GOOD_정함, 보통인부={"무엇": "마스터요소", "요소": LABOR, "단위": "인"})
assert _var(md.read(GOOD, 정함), "보통인부")["정할것"] == ["비목"]
assert md.read(GOOD, GOOD_정함)["다됨"] is True
def test_표_찾기는_변수_하나로_두고_자리만_만든다() -> None:
정함 = {"석공": {"무엇": "표찾기", "단위": "인/㎡"}}
assert _var(md.read("품 = 넓이 * 석공", 정함), "석공")["정할것"] == ["찾기"]
이은 = {
"석공": {
"무엇": "표찾기",
"단위": "인/㎡",
"찾기": {"표": "QF000421", "값칸": "석공", "조건": {"뒷길이": "뒷길이"}},
}
}
assert _var(md.read("품 = 넓이 * 석공", 이은), "석공")["정할것"] == []
assert md.find_text(이은["석공"]["찾기"]) == "찾기(QF000421, 뒷길이=뒷길이).석공"
# ── ② 단위 검사 ───────────────────────────────────────────────────────
def test_단위가_어긋난_줄과_자리를_짚는다() -> None:
got = md.read(BAD_UNIT, BAD_UNIT_정함)
bad = [x for x in got["문제"] if x["갈래"] == "단위"]
assert len(bad) == 1 and bad[0]["줄"] == 2
assert BAD_UNIT.split("\n")[1][bad[0]["자리"]] == "+" # 짚은 자리가 그 셈 기호
assert "m + ㎡" in bad[0]["말"]
def test_곱셈은_단위를_곱하고_나눗셈은_나눈다() -> None:
정함 = {"길이": {"무엇": "설계입력", "단위": "m"}, "폭": {"무엇": "설계입력", "단위": "m"}}
assert _var(md.read("넓이 = 길이 * 폭", 정함), "넓이")["단위"] == "㎡"
부피 = {**정함, "높이": {"무엇": "설계입력", "단위": "m"}}
assert _var(md.read("부피 = 길이 * 폭 * 높이", 부피), "부피")["단위"] == "㎥"
나눔 = {
"부피": {"무엇": "설계입력", "단위": "㎥"},
"시간당": {"무엇": "설계입력", "단위": "㎥/hr"},
}
assert _var(md.read("시간 = 부피 / 시간당", 나눔), "시간")["단위"] == "hr"
assert _var(md.read(GOOD, GOOD_정함), "공사비")["단위"] == "원" # 인 × 원/인 = 원
def test_만약과_최소는_갈래마다_단위가_같아야_한다() -> None:
정함 = {"길이": {"무엇": "설계입력", "단위": "m"}, "넓이": {"무엇": "설계입력", "단위": "㎡"}}
got = md.read("값 = 만약(길이 > 3, 길이, 넓이)", 정함)
assert [x["갈래"] for x in got["문제"]] == ["단위"] and "만약" in got["문제"][0]["말"]
assert md.read("값 = 최소(길이, 넓이)", 정함)["문제"][0]["갈래"] == "단위"
assert md.read("값 = 최소(길이, 길이 * 2)", 정함)["문제"] == []
def test_단위_없음을_골라_맨_수로_다룬다() -> None:
"""횟수 · 배율 — 단위 칸에 「없음」 을 고르면 무차원(3-3 화면 흠 ①)."""
회 = {"금액": {"무엇": "설계입력", "단위": "원"}, "전용": {"무엇": "설계입력", "단위": "회"}}
got = md.read("몫 = 금액 / 전용\n계금액 = 몫 + 금액", 회)
assert _var(got, "몫")["단위"] == "원/회" # 「회」 로 두면 덧셈에서 걸림
assert [x["갈래"] for x in got["문제"]] == ["단위"]
맨수 = dict(회, 전용={"무엇": "설계입력", "단위": "없음"})
깨끗 = md.read("몫 = 금액 / 전용\n계금액 = 몫 + 금액", 맨수)
assert _var(깨끗, "몫")["단위"] == "원" and 깨끗["문제"] == []
assert _var(깨끗, "전용")["단위"] == "" and _var(깨끗, "전용")["정할것"] == []
for 글 in ("", "맨수", "-", "%"):
쓴 = dict(회, 전용={"무엇": "설계입력", "단위": 글})
assert md.read("몫 = 금액 / 전용\n계금액 = 몫 + 금액", 쓴)["문제"] == [], 글
없으면 = dict(회, 전용={"무엇": "설계입력"}) # 단위 칸 자체가 없으면 아직 안 정한 것
assert _var(md.read("몫 = 금액 / 전용", 없으면), "전용")["정할것"] == ["단위"]
def test_나눗셈으로_단위가_없어진다() -> None:
정함 = {"길이": {"무엇": "설계입력", "단위": "m"}, "넓이": {"무엇": "설계입력", "단위": "㎡"}}
assert _var(md.read("폭 = 넓이 / 길이", 정함), "폭")["단위"] == "m"
assert _var(md.read("비 = 길이 / 길이", 정함), "비")["단위"] == "" # 같은 단위끼리 나누면 맨 수
assert md.read("합 = 길이 / 길이 + 2", 정함)["문제"] == []
# ── ③ 그 밖 검사 ──────────────────────────────────────────────────────
def test_서로_물고_도는_식을_잡는다() -> None:
kinds = [x["갈래"] for x in md.read(LOOP)["문제"]]
assert "돌고돎" in kinds
말 = next(x["말"] for x in md.read(LOOP)["문제"] if x["갈래"] == "돌고돎")
assert "가" in 말 and "나" in 말
assert md.read("가 = 가 + 1\n끝 = 가")["문제"][0]["갈래"] == "돌고돎"
def test_두_번_정의_안_쓰임_결과_하나() -> None:
두번 = md.read("가 = 1\n가 = 2\n끝 = 가")["문제"]
assert 두번[0]["갈래"] == "두번정의" and 두번[0]["줄"] == 2
안씀 = md.read("가 = 1\n남 = 5\n끝 = 가")["문제"]
assert [x["갈래"] for x in 안씀] == ["안쓰임"] and 안씀[0]["줄"] == 2
assert "결과는 「끝」 하나" in 안씀[0]["말"]
assert md.read("노무비 = 5\n끝 = 노무비")["문제"][0]["갈래"] == "이름"
assert md.read("이건 식이 아님")["문제"][0]["갈래"] == "못읽음"
def test_식이_왼쪽에_와도_받는다() -> None:
"""「A * B = C」 로 적는 사용자도 있음(3-3 화면 흠 ②)."""
정함 = {"길이": {"무엇": "설계입력", "단위": "m"}, "폭": {"무엇": "설계입력", "단위": "m"}}
got = md.read("길이 * 폭 = 넓이", 정함)
assert got["문제"] == [] and got["결과"] == "넓이"
assert _var(got, "넓이")["갈래"] == "정의됨" and _var(got, "넓이")["단위"] == "㎡"
assert got["줄"][0]["식"] == "길이 * 폭"
assert md.read("넓이 = 길이 * 폭", 정함)["변수"] == got["변수"] # 어느 쪽으로 적든 같음
양쪽 = md.read("길이 * 폭 = 넓이 * 2", 정함)["문제"]
assert 양쪽[0]["갈래"] == "못읽음" and "양쪽이 다 식" in 양쪽[0]["말"]
assert 양쪽[0]["자리"] == "길이 * 폭 = 넓이 * 2".index("=")
assert md.read("길이 * 폭 = 4", 정함)["문제"][0]["갈래"] == "못읽음" # 맨 수는 이름이 아님
def test_비교_기호와_찾기_안_등호는_안_가른다() -> None:
정함 = {"높이": {"무엇": "설계입력", "단위": "m"}}
assert md.read("값 = 만약(높이 <= 3, 1, 2)", 정함)["문제"] == []
assert md.read("값 = 만약(높이 == 3, 1, 2)", 정함)["문제"] == []
안쪽 = md.read("품 = 찾기(QF000421, 뒷길이=높이).석공", 정함)
assert 안쪽["문제"] == [] and 안쪽["줄"][0]["이름"] == "품"
# ── ⑤ 로직 틀로 옮기기 ────────────────────────────────────────────────
def test_다_정하면_로직_틀로_옮긴다() -> None:
row, bad = md.옮기기(GOOD, GOOD_정함, GOOD_머리)
assert bad == []
assert [x["이름"] for x in row["입력"]] == ["길이", "폭"]
assert row["입력"][0]["설명"] == "쌓을 길이" and row["입력"][0]["단위"] == "m"
assert [x["이름"] for x in row["중간"]] == ["품", "넓이", "인부"] # 쓰는 차례대로
assert row["중간"][0]["식"] == "0.15" and row["중간"][1]["식"] == "길이 * 폭"
assert row["호표"] == [
{
"종류": "인력",
"요소": LABOR,
"이름": "보통인부",
"단위": "인",
"수량": "인부",
"비목": "노무비",
}
]
assert row["덧줄"] == [{"이름": "잡재료비", "식": "노무비 * 0.05", "비목": "재료비"}]
assert row["결과단위"] == "원/㎡" and "결과" not in row
검사 = store.cm.mf.check_logic(store.cm.master(REAL), {**row, "키": "GX000001"})[0]
assert 검사 == [] # 옮긴 줄이 지금 로직 검사를 그대로 통과
def test_돈_아닌_로직은_호표_없이_결과_식() -> None:
정함 = {
"부피": {"무엇": "설계입력", "단위": "㎥"},
"시간당": {"무엇": "설계입력", "단위": "㎥/hr"},
}
row, bad = md.옮기기("시간 = 부피 / 시간당", 정함, {"이름": "작업 시간", "결과단위": "hr"})
assert bad == [] and row["결과"] == {"식": "부피 / 시간당"} and row["중간"] == []
assert "호표" not in row
def test_덜_정했으면_안_옮긴다() -> None:
row, bad = md.옮기기(GOOD, {}, GOOD_머리)
assert row == {} and any(x["갈래"] == "덜정함" for x in bad)
def test_비목_안_고른_덧줄은_막지_않고_짚어_준다() -> None:
"""「못 옮김」 으로 막지 않고 그 값에 「비목」 을 정할 것으로 얹음(3-3 화면 흠 ③)."""
빼기 = {k: v for k, v in GOOD_정함.items() if k != "잡재료비"}
got = md.read(GOOD, 빼기, GOOD_머리)
assert _var(got, "잡재료비")["정할것"] == ["비목"] and got["다됨"] is False
assert [x["갈래"] for x in got["문제"]] == [] # 검사에는 안 걸림 — 고를 것이 남았을 뿐
row, bad = md.옮기기(GOOD, 빼기, GOOD_머리)
assert row == {} and [x["갈래"] for x in bad] == ["덜정함"]
assert "잡재료비" in bad[0]["말"] and "비목" in bad[0]["말"]
assert _var(md.read(GOOD, GOOD_정함, GOOD_머리), "잡재료비")["정할것"] == []
안돈 = md.read(GOOD, 빼기, {"이름": "수량만", "결과단위": "㎥"}) # 돈 아닌 로직은 덧줄이 없음
assert _var(안돈, "잡재료비")["정할것"] == []
# ── 서버 길 ───────────────────────────────────────────────────────────
def test_서버_길이_변수와_문제를_돌려_준다(client: TestClient) -> None:
got = _post(client, {"text": GOOD, "decided": GOOD_정함})
assert got["다됨"] is True and got["logic"] is None and got["결과"] == "공사비"
assert _var(got, "보통인부")["단위"] == "원/인" # 마스터요소는 식에서 단가
미리 = _post(client, {"text": GOOD, "decided": GOOD_정함, "head": GOOD_머리})
assert 미리["logic"]["호표"][0]["요소"] == LABOR
assert not (store.FOLDER / make.OWN).is_file() # 미리보기는 파일에 안 씀
틀림 = _post(client, {"text": BAD_UNIT, "decided": BAD_UNIT_정함})
assert any(x["갈래"] == "단위" for x in 틀림["문제"]) and 틀림["다됨"] is False
def test_서버_길이_저장까지_하고_그_로직이_돈다(client: TestClient) -> None:
done = _post(
client,
{"text": GOOD, "decided": GOOD_정함, "head": GOOD_머리, "save": True, "owner": "현장"},
)
assert done["key"].startswith("GX") and done["file"] == make.OWN
assert done["logic"]["구분"] == "자체" and done["logic"]["소유"] == "현장"
res = client.post("/api/m01/calc", json={"key": done["key"], "inputs": {"길이": 2, "폭": 3}})
assert res.status_code == 200, res.text
calc = res.json()
assert calc["ok"] is True, calc
노무 = Decimal(str(calc["sums"]["노무비"]))
재료 = Decimal(str(calc["sums"]["재료비"])) # 751-3 — % 밑 = 버린 줄 합 · 소계 1 원 버림
assert 노무 > 0 and abs(재료 - 노무 * Decimal("0.05")) <= 1
assert Decimal(str(calc["middle"]["넓이"])) == 6
def test_저장은_문제가_있으면_아무것도_안_쓴다(client: TestClient) -> None:
res = client.post(
"/api/m01/logic/draft",
json={"text": LOOP, "decided": {}, "head": GOOD_머리, "save": True},
)
assert res.status_code == 422, res.text
assert res.json()["detail"]["errors"]
assert not (store.FOLDER / make.OWN).is_file()