From 654b75b5cc088dea17e616ba301fd01d46ec923a Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 12:27:37 +0900 Subject: [PATCH] =?UTF-8?q?refactor(853-1):=20M01=20=ED=99=94=EB=A9=B4=200?= =?UTF-8?q?=20=EC=84=9C=EB=B2=84=20=EA=B8=B8=2015=20=EC=99=80=20=EB=B3=B8?= =?UTF-8?q?=EC=B2=B4=20=EA=B1=B7=EC=9D=8C=20=E2=80=94=20=EB=AC=B6=EC=9D=8C?= =?UTF-8?q?=20=E2=91=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 길 지움(화면 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 --- M01_MasterData/M01_MasterData_Sheet.py | 70 -- resources/master_data/scripts/master_draft.py | 641 ------------------ resources/tester/test_m01_draft.py | 302 --------- 3 files changed, 1013 deletions(-) delete mode 100644 M01_MasterData/M01_MasterData_Sheet.py delete mode 100644 resources/master_data/scripts/master_draft.py delete mode 100644 resources/tester/test_m01_draft.py diff --git a/M01_MasterData/M01_MasterData_Sheet.py b/M01_MasterData/M01_MasterData_Sheet.py deleted file mode 100644 index 60169d6ba..000000000 --- a/M01_MasterData/M01_MasterData_Sheet.py +++ /dev/null @@ -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} diff --git a/resources/master_data/scripts/master_draft.py b/resources/master_data/scripts/master_draft.py deleted file mode 100644 index 8f26ba194..000000000 --- a/resources/master_data/scripts/master_draft.py +++ /dev/null @@ -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)) diff --git a/resources/tester/test_m01_draft.py b/resources/tester/test_m01_draft.py deleted file mode 100644 index 660cd76c9..000000000 --- a/resources/tester/test_m01_draft.py +++ /dev/null @@ -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()