refactor(855-E 2-E4 ㉯-3 ⑤): 옛 수식 탭 무리 지움 — M01 Equation · Sangeun_Formula · master_equation 다섯

- git rm: M01_MasterData_Equation(서버 길 없음 · 제품 부름 0 · 시험만) · M02_Sangeun_Formula(_catch · _eng 파서 · 식 글 번역 — 부르는 곳 = M01 Equation 뿐) · scripts master_equation · _edit · _group · _view · _sign(서로 · 위 둘 · 시험만 부름)
- master_symbol: M02_San_ToDoc 이 쓰는 SUBMAX · lookup(+ rule · short) 만 남김 — 옛 수식 내보내기 기호 씌우기(apply · _walk · family_name · is_symbol · SYMBOL · FAMILY) 지움
- 남김: master_equation_link(M01 Doc 새 기호 연결 후보) · ui_template_equation*(새 줄 쌓기 eqText) · M02_Sangeun_Equation(옛 칸 수식고침 받으면 400 지킴 — 엔진 몸 아님 · 동작)
- 시험: test_796_1 · 799_1 · 800_5 · 801_3 git rm(옛 수식 나무 · 묶음 · 기호 모델만 봄) · 792_1 식 글 번역 · 상한 둘 지움(옛 SK 식 칸 막음 · 초기화 · 지문 그대로) · 800_2 = 새 기호 연결 후보만(로직 갈래 → 단가산출 갈래 · 옛 수식 탭 · 화면 소스 글자 시험 지움)
- 죽은 주석: Sangeun_Copy · Sangeun_Equation · master_doc_trace · master_equation_link
- 서버 길 469 → 469(길 없던 모듈) · typecheck 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 15:23:01 +09:00
co-authored by Claude Opus 5.5
parent 548fc3d00a
commit 4c17c8ff13
18 changed files with 14 additions and 2414 deletions
-57
View File
@@ -1,57 +0,0 @@
"""M01 수식 탭 서버 몫(PLAN 796-1 · 요구 655 · 657) — 수식 나무 읽기 · 고침 미리 셈 · 저장.
모델 = `scripts/master_equation.py`(나무 · 변수 표) · `master_equation_edit.py`(고침 · 검사) ·
키보드 글 번역 · 상한 = M02 단가산출 식 칸과 한 벌(`M02_Sangeun_Formula` 불러 씀 · 고치지 않음) ·
셈 = 엔진 한 벌(③ 서버 단독 · 브라우저 값 받아 적지 않음) · 저장 = 기존 M01 `/save`(개정확인) ·
M02 사본(795-1)은 `edit_row` 를 사본 줄로 부름 · `export_row` 는 시험(796-1 · 800-2)의 수식 모델 바탕(옛 엔진 은퇴 때 같이).
"""
from __future__ import annotations
from typing import Any
from M01_MasterData import M01_MasterData_Store as store
_ERR = (store.cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
import master_equation as meq # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
import master_equation_edit as me # noqa: E402
def _fx() -> Any:
from M02_MasterTemplete import M02_Sangeun_Formula as fx # M02 가 M01 을 부름 — 늦게
return fx
def words(text: str, row: dict) -> tuple[str, list[str]]:
"""층 번역 — 상한(길이 · 괄호) · `[노임 …]` · `[별칭]` → 엔진 식."""
fx = _fx()
if bad := fx.limits(text):
return text, bad
return fx.to_engine(text, row)
def _given(inputs: dict | None) -> dict:
return {k: store._dec(v) for k, v in (inputs or {}).items()}
def _typed(eq: dict, row: dict) -> dict:
"""줄마다 `입력글` = 키보드 한 줄 식(이름 꼴 · 변수 글) — 식 칸 처음 글."""
fx = _fx()
for line in eq.get("줄") or []:
if line.get("식"):
line["입력글"] = me.keyboard_of(fx.to_name(str(line["식"]), row), row)
return eq
def export_row(whole, row: dict, inputs: dict | None = None) -> dict:
"""로직 줄(정본 · 사본) → 수식 — 마스터에 그 줄을 얹어 셈."""
eq = meq.export(me.swap(whole, row), str(row.get("키")), _given(inputs))
return _typed(eq, row)
def edit_row(whole, row: dict, edits: list) -> tuple[dict, list[str]]:
"""고침 → (새 줄, 까닭) — 까닭 있으면 저장 안 됨(M01 · M02 사본 같은 함수)."""
new, why, _ = me.apply(whole, row, edits, words)
return new, why
+1 -1
View File
@@ -132,7 +132,7 @@ class Copy:
def __getattr__(self, name: str) -> Any:
return getattr(self._whole, name)
def __copy__(self) -> Copy: # 수식 고침(796-2b · `master_equation_edit.swap`) — 얕은 사본
def __copy__(self) -> Copy: # 얕은 사본(옛 수식 고침 796-2b 몫)
out = object.__new__(Copy)
out.__dict__.update(self.__dict__)
return out
+1 -1
View File
@@ -1,6 +1,6 @@
"""M02 단가산출(SK) 옛 칸 `수식고침`(PLAN 796-2b) — 받지 않음(855-E 2-E4).
옛 수식 탭 고침 = 바탕 로직 줄에 엔진 수식 고침(`master_equation_edit`)을 얹던 칸 · 화면 길은 894 에서 걷음 ·
옛 수식 탭 고침 = 바탕 로직 줄에 엔진 수식 고침(옛 `master_equation_edit` · 855-E 2-E4 지움)을 얹던 칸 · 화면 길은 894 에서 걷음 ·
저장본 0 · 고침은 단가산출 수식 문서(줄 쌓기 · 수식 길 저장)로 — 받으면 400.
"""
-205
View File
@@ -1,205 +0,0 @@
"""M02 단가산출 식 글 번역(PLAN 792-1 · 855 2-E2) — 이름 꼴 ↔ 엔진 식 · 식 글 상한.
M01 수식 탭(`M01_MasterData_Equation`) · 가져온 식(`M02_Sangeun_Imported`)이 부름.
이름 꼴 — `×` `÷`(= `*` `/`) · `[노임 형틀목공]`(요소 · 겹치면 키 덧붙임) · `[별칭]`(바탕 줄
`찾기` · `로직` 부르기 = `master_copy.aliases` · 별칭표는 바탕 줄에서만 지음 = 사용자 고침에
안 흔들림) · 맨 이름 = 입력 · 중간 · 변수 · 덧줄 · 비목 · 엔진 날식도 그대로 받음.
옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)은 셈 은퇴(855 2-C1) 뒤 받지 않음(`M02_Sangeun_Const.clean_more` · 855 2-E2).
보안 — eval 없음(엔진 파서만) · 식 길이 `LONG` · 괄호 깊이 `DEEP`.
"""
from __future__ import annotations
import functools
import json
import re
from typing import Any
LONG = 300 # 식 글 길이
DEEP = 12 # 괄호 깊이
WORD = {
"LB": "노임",
"EQ": "기계",
"MT": "자재",
"MP": "자재",
"MO": "유가",
"FX": "환율",
"RT": "요율",
}
def _eng() -> Any:
from M02_MasterTemplete import M02_Labor_Doc as labor
return labor.m01.cm.mf
def _whole() -> Any:
from M01_MasterData import M01_MasterData_Store as m01
return m01.loaded()[1]
# ── 식 글 상한 ────────────────────────────────────────────────────────
def limits(text: str) -> list[str]:
"""식 글 상한 — 길이 · 괄호 깊이(파서 앞 · 깊은 괄호 = 서버 500 막음)."""
out, depth, top, quoted = [], 0, 0, False
if len(text) > LONG:
out.append(f"식이 {LONG} 자를 넘음")
for ch in text:
if ch == "'":
quoted = not quoted
elif not quoted and ch in "([":
depth += 1
top = max(top, depth)
elif not quoted and ch in ")]":
depth -= 1
if top > DEEP:
out.append(f"괄호가 {DEEP} 겹을 넘음")
return out
# ── 이름 꼴 ↔ 엔진 식 ────────────────────────────────────────────────
@functools.lru_cache(maxsize=2)
def _labels(whole: Any) -> tuple[dict, dict]:
"""(키 → 이름 꼴 글, 글 → 키) — 같은 글이 여럿이면 글에 키를 덧붙임."""
base: dict[str, str] = {}
for tid, word in WORD.items():
for key, row in (whole.index.get(tid) or {}).items():
words = (word, str(row.get("이름") or ""), str(row.get("규격") or ""))
base[key] = re.sub(r"\s+", " ", re.sub(r"[\[\]]", "", " ".join(words))).strip()
count: dict[str, int] = {}
for label in base.values():
count[label] = count.get(label, 0) + 1
label_of = {k: v if count[v] == 1 else f"{v} {k}" for k, v in base.items()}
return label_of, {v: k for k, v in label_of.items()}
def _mc() -> Any:
_eng() # 엔진 길(scripts)이 sys.path 에 깔림
import master_copy
return master_copy
@functools.lru_cache(maxsize=512)
def _alias_of(raw: str) -> tuple[tuple[str, str], ...]:
"""바탕 줄 별칭표 ((이름, 원문)) — 줄 글마다 한 번."""
return tuple((a["이름"], a["원문"]) for a in _mc().aliases(json.loads(raw), _whole()))
def aliases(row: dict) -> dict[str, str]:
"""{별칭: 원문 부르기}(바탕 줄 · `master_copy.aliases`)."""
return dict(_alias_of(json.dumps(row, ensure_ascii=False, sort_keys=True, default=str)))
@functools.cache
def _catch() -> type:
"""엔진 파서 + 요소 키 · 부르기 글자 자리 기록."""
mf = _eng()
class Catch(mf._Parser):
def __init__(self, text: str) -> None:
super().__init__(text)
self.refs: list = []
self.calls: list = []
def primary(self): # noqa: ANN202
self.ws()
at = self.i
node = super().primary()
if node[0] == "ref" and mf.mk.KEY.fullmatch(node[1]):
self.refs.append((at, self.i, node[1]))
elif node[0] in ("find", "logic"):
self.calls.append((at, self.i))
return node
return Catch
def _spots(text: str) -> tuple[list, list] | None:
"""(요소 키 자리, 바깥 부르기 자리) · 못 읽음 = None."""
mf, p = _eng(), _catch()(text)
try:
p.parse()
except (mf.FormulaError, RecursionError):
return None
calls = [
c for c in p.calls if not any(o[0] <= c[0] and c[1] <= o[1] and o != c for o in p.calls)
]
return p.refs, calls
def to_name(text: str, row: dict) -> str:
"""엔진 식 → 이름 꼴(`*` → `×` · 요소 = `[노임 …]` · 바탕 별칭 부르기 = `[별칭]`)."""
got = _spots(text)
if got is None:
return text
refs, calls = got
label_of = _labels(_whole())[0]
raw_to = {re.sub(r"\s+", " ", v): k for k, v in aliases(row).items()}
cuts = []
for a, b in calls:
name = raw_to.get(re.sub(r"\s+", " ", text[a:b]))
if name:
cuts.append((a, b, f"[{name}]"))
for a, b, key in refs:
if key in label_of and not any(x <= a and b <= y for x, y in calls):
cuts.append((a, b, f"[{label_of[key]}]"))
out, at = [], 0
for a, b, word in sorted(cuts):
out += [_times(text[at:a]), word]
at = b
return "".join(out) + _times(text[at:])
def _times(part: str) -> str:
"""따옴표 밖 `*` → `×`."""
bits = part.split("'")
return "'".join(b.replace("*", "×") if i % 2 == 0 else b for i, b in enumerate(bits))
def to_engine(text: str, row: dict) -> tuple[str, list[str]]:
"""이름 꼴 → (엔진 식, 까닭) — `×` `÷` · `[…]` = 키 · 바탕 별칭 · 요소 글 · 맨 별칭 이름."""
names = aliases(row)
find = _labels(_whole())[1]
mk = _eng().mk
out, why, at, quoted = [], [], 0, False
while at < len(text):
ch = text[at]
if ch == "'":
quoted = not quoted
if quoted or ch not in "×÷[]":
out.append(ch)
at += 1
continue
if ch in "×÷":
out.append("*" if ch == "×" else "/")
at += 1
continue
end = text.find("]", at)
if ch == "]" or end < 0:
return text, ["대괄호 짝 안 맞음"]
word = re.sub(r"\s+", " ", text[at + 1 : end]).strip()
keys = mk.KEY.findall(word)
if word in names:
out.append(names[word])
elif word in find:
out.append(find[word])
elif keys and len(keys) == 1:
out.append(keys[0])
else:
why.append(f"없는 이름 「[{word}]」")
at = end + 1
got = "".join(out)
taken = _names(row)
bare = {k: v for k, v in names.items() if k not in taken}
return (_unmask(got, bare) if bare else got), why
def _unmask(text: str, raw_of: dict) -> str:
return _mc()._unmask(text, raw_of)
def _names(row: dict) -> set[str]:
return {str(x.get("이름")) for k in ("입력", "중간", "덧줄") for x in row.get(k) or []}
@@ -27,7 +27,7 @@ import master_doc as md
import master_doc_calc as mc
import master_doc_link as ml
CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"} # `master_equation_view.CAT` 같은 말
CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"}
_SLOTS = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별")
@@ -1,522 +0,0 @@
# -*- coding: utf-8 -*-
"""수식 나무(PLAN 796-1 · 요구 655 · 657 · 요구서_655 0 장) — 로직 줄 → 그림용 나무 · 변수 표.
수식 = 계산 로직 그 자체 — 나무는 엔진 식 나무(`master_formula.parse`)를 그대로 옮긴 것이고
`master_equation_edit.engine_text` 가 나무를 엔진 식 글로 되돌림(왕복 = 같은 금액).
줄마다 `이름식`(변수 = 이름 · 기호 · 첨자) · `값식`(같은 나무의 값 꼴) · `값` · 오른쪽 `풀이`(입력 ·
찾기 · 요소 값 + 표 · 행) · 하위 로직 부르기 = `블록`(접힘 · 노재경 소계 보이기만 · 금액 그대로).
나무 마디(`꼴`):
수 {글, 값} · 글 {글} · 변수 {열쇠, 이름, 기호, 위, 아래, 단위, 갈래, 값, 글, 식?}
(갈래 = 입력 · 중간 · 찾기 · 요소 · 합 — 찾기 · 요소 `식` = 엔진 원문 · 찾기 `표` · `행` · `칸`)
연산 {기호, 좌, 우} · 분수 {위, 아래, 사슬?} · 괄호 {안} · 퍼센트 {안} · 음 {안}
조건 {조건, 참, 거짓, 걸림(1 참 · 2 거짓 · 0 모름), 글} · 함수 {이름, 인자}
블록 {열쇠, 이름, 결과단위, 칸, 값, 묶음, 식, 접힘, 나무}
변수 표 = 입력 · 중간마다 {열쇠, 이름, 기호, 위, 아래, 단위, 갈래, 기본값, 설명} — 열쇠 = 엔진 이름
(안 바뀜) · 이름 · 기호 · 첨자 고침은 로직 줄 새 칸 `변수표` {열쇠: {이름?, 기호?, 위?, 아래?}}
(바꾼 것만 · 셈에 안 씀) · 기호 초기값 = 품셈 원문 「여기서 q : 버킷용량(㎥)」 후보(`symbols`).
셈 = `master_formula.run` · 끝수 `master_cut.engine` 한 벌 · eval 없음.
"""
from __future__ import annotations
import functools
import re
from decimal import Decimal
from pathlib import Path
import master_auto as ma
import master_cut as mcut
import master_equation_group as grp
import master_equation_view as view
import master_formula as mf
import master_material as mm
import master_symbol as msym
from common_util.common_util_money import fmt
FIELD = "변수표" # 로직 줄 새 칸(`_틀.md` 2 장 열 차례 끝)
LOOK = ("이름", "기호", "위", "아래") # 변수표에 두는 꼴 칸
SHOW = 4 # 값 칸 보이는 자리 — 고친 중간 줄 `표시`(보이는 자리에서 잘라 셈 · 요구 658)
DEEP = 1 # 블록 안 나무를 펼칠 깊이(그 아래는 값 · 묶음만)
PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3}
PREC |= {"+": 4, "-": 4, "*": 5, "/": 5}
SIGN = {"*": "×", "/": "÷", "-": "−"}
_ERR = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, IndexError)
_BOOK = Path(mf.mk.MASTER).parents[1] / "resources/knowledge/original/원가계산"
_DEF = re.compile(r"^(?:여기서\s*[,:]?\s*)?([A-Za-z][A-Za-z0-9′'ˊ]{0,5})\s*[::]\s*(.+?)\s*$")
# ── 변수 표 ────────────────────────────────────────────────────────────
def _norm(text: str) -> str:
"""원문 풀이 · 변수 이름 맞대기 — 괄호 · 빈칸 · 「1일 · 1회」 머리 뺌 · 「횟수」 = 「회수」."""
text = re.sub(r"\([^)]*\)|([^)]*)|\s", "", str(text or ""))
return re.sub(r"^(1일|1회|일|회당)", "", text).replace("횟수", "회수")
@functools.lru_cache(maxsize=256)
def _section(book: str, number: str) -> tuple[tuple[str, str], ...]:
"""원문 절의 「여기서 기호 : 풀이」 목록 — 절 머리(`### 8-2-3 …`) 아래 다음 머리까지."""
root = _BOOK / ("산림_표준품셈/본문" if book == "산림품셈" else "건설공사_표준품셈/본문")
head = re.compile(rf"^#+\s*{re.escape(number)}\s")
out: list[tuple[str, str]] = []
for path in sorted(root.rglob("*.md")) if number else []:
try:
text = path.read_text(encoding="utf-8")
except OSError:
continue
if number not in text:
continue
inside, block = False, False
for line in text.splitlines():
if line.startswith("#"):
if inside:
break
inside = bool(head.match(line))
continue
if not inside:
continue
line = re.sub(r"<!--.*?-->", "", line).strip()
m = _DEF.match(line) if (block or line.startswith("여기서")) else None
block = bool(m) or (block and not line)
if m:
out.append((m.group(1), m.group(2)))
if out:
break
return tuple(out)
def symbols(row: dict) -> dict[str, str]:
"""{열쇠: 원문 기호 후보} — 이름 · 설명 「(q)」 · 풀이 맞대기가 하나일 때만(796-3 확정 전)."""
book = "산림품셈" if str(row.get("구분") or "").startswith("산림") else "건설품셈"
defs = _section(book, str(row.get("원문번호") or ""))
keys = {str(s.get("이름")) for k in ("입력", "중간") for s in row.get(k) or []}
got: dict[str, list[tuple[str, str]]] = {} # 기호 → [(열쇠, 갈래)]
for kind in ("입력", "중간"):
for spec in row.get(kind) or []:
key = str(spec.get("이름"))
if re.fullmatch(r"[A-Za-z][\w′']{0,5}", key):
continue # 이름이 이미 기호(K · E · f · cm)
said = re.findall(
rf"{re.escape(key)}\(([A-Za-z][\w′']{{0,5}})\)", str(spec.get("설명") or "")
)
hits = {s for s, d in defs if s in said} or {
s for s, d in defs if _norm(d) == _norm(key)
}
if len(hits) == 1 and (sign := hits.pop()) not in keys:
got.setdefault(sign, []).append((key, kind))
out = {}
for sign, owners in got.items(): # 한 기호는 한 변수 — 여럿이면 중간 하나일 때만
mids = [k for k, kind in owners if kind == "중간"]
one = owners[0][0] if len(owners) == 1 else mids[0] if len(mids) == 1 else None
if one:
out[one] = sign
if "결과" in row and defs and defs[0][0] not in keys and defs[0][0] not in out.values():
out["결과"] = defs[0][0] # 「여기서 Q : 시간당 작업량」 — 첫 풀이 = 결과
return out
def table(row: dict, master=None) -> list[dict]:
"""변수 표 — 입력 · 중간 차례 · 기본값 = 입력 `기본` › 자동 제안(`master_auto.defaults`)."""
saved = row.get(FIELD) if isinstance(row.get(FIELD), dict) else {}
auto = ma.defaults(master, row) if master is not None else {}
found = symbols(row)
out = []
for kind in ("입력", "중간"):
for spec in row.get(kind) or []:
key = str(spec.get("이름"))
look = saved.get(key) if isinstance(saved.get(key), dict) else {}
out.append(
{
"열쇠": key,
"이름": look.get("이름") or key,
"기호": look.get("기호") or found.get(key) or key,
"위": look.get("위") or "",
"아래": look.get("아래") or "",
"단위": spec.get("단위") or "",
"갈래": kind,
"기본값": spec.get("기본", auto.get(key)) if kind == "입력" else None,
"설명": spec.get("설명") or "",
**({"표시": spec["표시"]} if spec.get("표시") is not None else {}),
}
)
return out
def token(var: dict) -> str:
"""키보드 한 줄 식의 변수 글 — 기호(_아래)(^위) · 기호가 열쇠와 같고 첨자 없으면 열쇠."""
out = str(var.get("기호") or var["열쇠"])
if var.get("아래"):
out += f"_{var['아래']}"
if var.get("위"):
out += f"^{var['위']}"
return out
# ── 나무 ──────────────────────────────────────────────────────────────
class _Ctx:
def __init__(self, master, row: dict, env: dict, depth: int):
self.master, self.row, self.env, self.depth = master, row, env, depth
self.vars = {v["열쇠"]: v for v in table(row)}
self.used: dict[str, dict] = {} # 풀이 — 쓰인 입력 · 찾기 · 요소
def value(self, node):
try:
got = mf.evaluate(node, self.env, self.master, self.depth)
except _ERR:
return None
return got
def _num(value) -> dict:
if isinstance(value, Decimal):
return {"꼴": "수", "글": fmt(value), "값": value}
return {"꼴": "글", "글": "" if value is None else str(value)}
def _var(ctx: _Ctx, key: str, kind: str, value, **more) -> dict:
look = ctx.vars.get(key) or {"열쇠": key, "이름": key, "기호": key, "위": "", "아래": ""}
node = {
"꼴": "변수",
"열쇠": key,
**{k: look.get(k, "") for k in LOOK},
"단위": look.get("단위", more.pop("단위", "")),
"갈래": kind,
"값": value if not isinstance(value, dict) else None,
"글": "" if value is None or isinstance(value, dict) else fmt(value),
**more,
}
if kind in ("입력", "찾기", "요소"):
ctx.used.setdefault(more.get("식") or key, {k: v for k, v in node.items() if k != "꼴"})
return node
def _raw(node) -> str:
"""마디 → 엔진 식 글(찾기 · 요소 · 로직 부르기 원문 보관용)."""
import master_equation_edit as me # 서로 부름 — 늦게
return me.raw_text(node)
def me_keyboard(ctx: _Ctx, node) -> str:
"""조건 식 마디 → 키보드 한 줄 글(변수 = 기호) — 정의 영역 「조건 규격 = 폼타이규격」."""
import master_equation_edit as me
return me.keyboard_of(_raw(node), ctx.row)
def _find(ctx: _Ctx, node, column: str) -> dict:
"""찾기(표, 조건).칸 → 찾기 변수 · 표 · 고른 행."""
raw = _raw(("field", node, column))
more = {"식": raw, "칸": column}
more["조건식"] = {k: me_keyboard(ctx, c) for k, c in node[2]}
try:
ref = mf.fill(node[1], ctx.env)
table_row = ctx.master.get(ref)
conds = {k: mf.evaluate(v, ctx.env, ctx.master, ctx.depth) for k, v in node[2]}
more |= {"표": ref, "표이름": table_row.get("이름") or "", "행": conds}
more["단위"] = (table_row.get("값칸") or {}).get(column) or ""
except _ERR:
pass
name = f"{more.get('표이름') or node[1]}.{column}"
look = {"열쇠": raw, "이름": name, "기호": column, "위": "", "아래": ""}
ctx.vars.setdefault(raw, look)
return _var(ctx, raw, "찾기", ctx.value(("field", node, column)), **more)
def _block(ctx: _Ctx | None, node, column: str | None) -> dict:
"""로직 부르기 → 블록 — 묶음(노 · 재 · 경 · 계) · 결과 수 · 접힌 하위 나무(`DEEP` 까지)."""
raw = _raw(node if column is None else ("field", node, column))
out = {"꼴": "블록", "열쇠": node[1], "칸": column, "식": raw, "접힘": True}
if ctx is None:
return out
try:
ref = mf.fill(node[1], ctx.env)
sub = ctx.master.logic(ref)
given = {k: mf.evaluate(v, ctx.env, ctx.master, ctx.depth) for k, v in node[2]}
out |= {"열쇠": ref, "이름": sub.get("이름") or ref, "결과단위": sub.get("결과단위") or ""}
except _ERR:
return out
got = ctx.value(node)
if isinstance(got, dict):
out["묶음"] = got
got = got.get(column) if column else got.get("계")
elif column is not None:
got = None
out |= {"값": got, "글": fmt(got) if isinstance(got, Decimal) else ""}
if ctx.depth < DEEP:
try:
out["나무"] = export(ctx.master, ref, given, ctx.depth + 1)
except _ERR:
out["나무"] = None
return out
def _paren(child: dict, op: str, right: bool) -> dict:
"""연산 자식 괄호 — 낮은 세기 · 오른쪽 같은 세기(엔진은 왼쪽부터 묶음 — 나무 그대로)."""
if child.get("꼴") != "연산":
return child
mine, up = PREC[child["_op"]], PREC[op]
if mine < up or (mine == up and right):
return {"꼴": "괄호", "안": child}
return child
def build(node, ctx: _Ctx | None) -> dict:
"""엔진 식 마디 → 나무 마디(이름 꼴) · ctx 없으면 값 · 풀이 없이 꼴만."""
kind = node[0]
if kind == "num":
return _num(node[1])
if kind == "str":
return {"꼴": "글", "글": node[1], "따옴": True}
if kind == "name":
key = node[1]
if ctx is None:
return {"꼴": "변수", "열쇠": key, "갈래": "합"}
where = ctx.vars.get(key, {}).get("갈래") or "합"
return _var(ctx, key, where, ctx.env.get(key) if ctx else None)
if kind == "ref":
if ctx is None:
return {"꼴": "변수", "열쇠": node[1], "갈래": "요소", "식": node[1]}
return _elem(ctx, node[1])
if kind == "neg":
inner = build(node[1], ctx)
return {"꼴": "음", "안": {"꼴": "괄호", "안": inner} if inner["꼴"] == "연산" else inner}
if kind == "field" and node[1][0] == "find":
if ctx is None:
return {"꼴": "변수", "갈래": "찾기", "식": _raw(node), "열쇠": _raw(node)}
return _find(ctx, node[1], node[2])
if kind == "field" and node[1][0] == "logic":
return _block(ctx, node[1], node[2])
if kind == "logic":
return _block(ctx, node, None)
if kind in ("field", "find"): # 그 밖의 칸 꺼냄(요소 묶음 · 찾기 줄째) — 원문 그대로 변수
raw = _raw(node)
if ctx is None:
return {"꼴": "변수", "갈래": "요소", "식": raw, "열쇠": raw}
return _var(ctx, raw, "요소", ctx.value(node), 식=raw)
if kind == "call" and node[1] == "만약":
cond, yes, no = (build(x, ctx) for x in node[2])
hit = ctx.value(node[2][0]) if ctx else None
at = 0 if hit is None else 1 if hit else 2
return {"꼴": "조건", "조건": cond, "참": yes, "거짓": no, "걸림": at}
if kind == "call":
return {"꼴": "함수", "이름": node[1], "인자": [build(x, ctx) for x in node[2]]}
if kind == "bin":
return _bin(node, ctx)
raise mf.FormulaError(f"모르는 마디 {kind}")
def _elem(ctx: _Ctx, ref: str) -> dict:
import master_text as mt
value = ctx.value(("ref", ref))
name = mt._elem_name(ctx.master, ref, ctx.env)
look = {"열쇠": ref, "이름": name, "기호": name, "위": "", "아래": ""}
ctx.vars.setdefault(ref, look)
return _var(ctx, ref, "요소", value, 식=ref)
def _bin(node, ctx: _Ctx | None) -> dict:
_, op, left, right = node
if op == "/" and right == ("num", Decimal(100)): # 「… / 100」 = 퍼센트
inner = _paren(build(left, ctx), "*", False)
return {"꼴": "퍼센트", "안": inner}
if op == "/":
if left[0] == "bin" and left[1] == "/" and left[3] != ("num", Decimal(100)):
top, mid = build(left[2], ctx), build(left[3], ctx) # a/b/c → a/(b×c) 모양만
low = {"꼴": "연산", "기호": "×", "_op": "*", "좌": mid, "우": build(right, ctx)}
low["좌"], low["우"] = _paren(mid, "*", False), _paren(low["우"], "*", True)
return {"꼴": "분수", "위": top, "아래": low, "사슬": True}
return {"꼴": "분수", "위": build(left, ctx), "아래": build(right, ctx)}
a, b = build(left, ctx), build(right, ctx)
return {
"꼴": "연산",
"기호": SIGN.get(op, op),
"_op": op,
"좌": _paren(a, op, False),
"우": _paren(b, op, True),
}
def values(tree: dict) -> dict:
"""이름 꼴 나무 → 값 꼴 나무 — 변수 · 블록은 값 수로(열쇠 남김) · 조건은 걸린 쪽만."""
kind = tree.get("꼴")
if kind in ("변수", "블록"):
value = tree.get("값")
got = _num(value) if value is not None else {"꼴": "글", "글": "?"}
return {**got, "열쇠": tree.get("열쇠"), "갈래": tree.get("갈래") or "블록"}
if kind == "조건":
if tree.get("걸림"):
return values(tree["참" if tree["걸림"] == 1 else "거짓"])
return {**tree, **{k: values(tree[k]) for k in ("조건", "참", "거짓")}}
out = dict(tree)
for k in ("좌", "우", "위", "아래", "안"):
if k in tree:
out[k] = values(tree[k])
if "인자" in tree:
out["인자"] = [values(x) for x in tree["인자"]]
return out
def _clean(tree):
"""밖으로 내보낼 나무 — 안쪽 칸(`_op`) 뺌."""
if isinstance(tree, dict):
return {k: _clean(v) for k, v in tree.items() if k != "_op"}
if isinstance(tree, list):
return [_clean(x) for x in tree]
return tree
# ── 로직 한 줄 → 수식 ─────────────────────────────────────────────────
def given_of(master, row: dict, given: dict | None = None) -> dict:
"""셈 입력 — 자동값 · 기본 제안 · 시험입력 · 받은 값 차례로 덮음."""
out = ma.values(master, row)
out.update({k: v for k, v in ma.defaults(master, row).items() if v is not None})
out.update(row.get("시험입력") or {})
out.update(given or {})
names = {s["이름"] for s in row.get("입력") or []}
return {k: v for k, v in out.items() if k in names}
def _line(ctx: _Ctx, kind: str, key: str, text: str, value, **more) -> dict:
try:
tree = build(mf.parse(text), ctx)
except mf.FormulaError as e:
return {"갈래": kind, "열쇠": key, "식": text, "까닭": str(e), **more}
head = _var(ctx, key, kind if kind in ("중간",) else "합", value)
if kind == "결과":
head |= {"이름": "결과", "기호": symbols(ctx.row).get("결과") or "결과"}
return {
"갈래": kind,
"열쇠": key,
"식": text,
"결과": head,
"이름식": tree,
"값식": values(tree),
"값": value,
"글": fmt(value) if isinstance(value, Decimal) else "",
**more,
}
def subtotals(logic: dict, cut: dict, total: dict) -> dict:
"""호표 줄 → 소계 묶음(799-1 · 801-3 · 보이기만) — 부른 단가산출 = 묶음 하나씩 · 직접 줄 = 한 묶음 + 끝수.
값 = `master_cut.engine` 이 버린 줄 비목(0.1 원) 그대로 · 합계 = 엔진 비목 합(1 원 버림) ·
끝수 = 합계 − 묶음 합(금액 셈은 안 바꿈 · 사용자 확정 뒤에 정함). 묶음 꼴 = `master_equation_group`.
"""
items = logic.get("호표") or []
skip = mcut.ms.skipped(logic) if mcut.ms.uses(logic) else set()
rows: list[dict] = []
for n, line in enumerate(cut.get("줄") or []):
if n in skip:
continue
split = {k: line.get("비목", {}).get(k) or Decimal(0) for k in mf.COST_ITEMS}
item = items[n] if n < len(items) else {}
kind = "블록" if item.get("종류") == "로직" else "자원" if item else "덧줄"
rows.append(
{"갈래": kind, "이름": str(item.get("이름") or ""), "종류": item.get("종류"), **split}
| {"계": sum(split.values(), Decimal(0))}
)
got = grp.bundles(rows)
rest = {
k: (total.get(k) or Decimal(0)) - sum((one[k] for one in got["줄"]), Decimal(0))
for k in mf.BUNDLE
}
return {"줄": got["줄"], "끝수": rest}
def export(master, key: str, given: dict | None = None, depth: int = 0) -> dict:
"""로직 키 → 수식 {열쇠, 이름, 결과단위, 줄, 풀이, 변수표, 합계 | 결과} — 셈은 엔진 한 벌."""
row = master.logic(key)
given = given_of(master, row, given) if depth == 0 else dict(given or {})
raw = mf.run(master, key, given, depth)
env = {k: v for k, v in (raw.get("중간") or {}).items()}
ctx = _Ctx(master, row, env, depth)
out_lines = []
for step in row.get("중간") or []:
name = step["이름"]
more = {"표시": step["표시"]} if step.get("표시") is not None else {}
out_lines.append(_line(ctx, "중간", name, step["식"], env.get(name), **more))
total: dict = {}
sub: dict = {}
if "결과" in row:
out_lines.append(_line(ctx, "결과", "결과", row["결과"]["식"], raw["결과"]))
total = {"결과": raw["결과"]}
else:
cut = mcut.engine(master, key, raw) if depth == 0 else raw
lines = raw.get("줄") or []
for at, item in enumerate(row.get("호표") or []):
out_lines.append(_item(ctx, at, item, lines[at] if at < len(lines) else {}))
for at, extra in enumerate(row.get("덧줄") or []):
got = env.get(extra["이름"])
one = _line(ctx, "덧줄", extra["이름"], extra["식"], got, 차례=at)
out_lines.append(one | {"비목": extra.get("비목")})
total = {k: cut.get(k) for k in mf.BUNDLE}
if depth == 0:
sub = {"소계": subtotals(row, cut, total)}
out = msym.apply( # 기호 먼저(800-1) → 정의는 기호 씌운 줄로(800-2)
{
"열쇠": row.get("키"),
"이름": row.get("이름") or "",
"결과단위": row.get("결과단위") or "",
"줄": out_lines,
"풀이": list(ctx.used.values()),
"변수표": table(row, master),
"합계": total,
**sub,
}
)
if depth == 0:
out["정의"] = view.definitions(out_lines, row, out["변수표"], _unused(row))
return _clean(out)
def _unused(row: dict):
"""열쇠 → 어느 식에도 안 쓰이나(정의 영역 · 지울 수 있는 입력)."""
import master_equation_edit as me
return lambda key: key != mm.REGION and not me.uses(row, key)
def _item(ctx: _Ctx, at: int, item: dict, line: dict) -> dict:
"""호표 줄 = 「단가 × 수량식 = 금액」 · 로직 줄 단가 = 블록."""
name = str(item.get("이름") or "")
try:
qty = build(mf.parse(item["수량"]), ctx)
except mf.FormulaError as e:
return {"갈래": "호표", "차례": at, "열쇠": name, "식": item["수량"], "까닭": str(e)}
if item.get("종류") == "로직":
price = build(mf.parse(str(item["요소"])), ctx)
elif isinstance(item.get("요소"), str):
price = _elem(ctx, item["요소"])
price |= {"값": line.get("단가"), "글": fmt(line["단가"]) if line.get("단가") else ""}
else: # 재료 고르기 조건 — 단가는 엔진 고름 값
key, label = f"단가:{name}", f"{name}단가"
ctx.vars.setdefault(key, {"열쇠": key, "이름": label, "기호": label, "위": "", "아래": ""})
price = _var(ctx, key, "요소", line.get("단가"), 고르기=item["요소"])
tree = {
"꼴": "연산",
"기호": "×",
"_op": "*",
"좌": price,
"우": _paren(qty, "*", True),
}
head = {"꼴": "변수", "열쇠": name, "이름": name, "기호": name, "갈래": "합"}
head |= {"값": line.get("금액"), "단위": item.get("단위") or ""}
return {
"갈래": "호표",
"차례": at,
"열쇠": name,
"식": item["수량"],
"결과": head,
"이름식": tree,
"값식": values(tree),
"값": line.get("금액"),
"글": fmt(line["금액"]) if isinstance(line.get("금액"), Decimal) else "",
"수량": line.get("수량"),
"비목": line.get("비목") or {},
**({"까닭": line["까닭"]} if line.get("까닭") else {}),
}
@@ -1,503 +0,0 @@
# -*- coding: utf-8 -*-
"""수식 고침 → 로직(PLAN 796-1 · 요구 657) — 나무 · 키보드 한 줄 식 → 엔진 식 · 변수 추가 · 삭제 ·
이름 · 기호 · 첨자 바꿈 · 표시 자리 · 식 검사.
로직 줄(dict) 한 벌만 고침 — 저장은 부르는 쪽(M01 = `/save` · M02 사본 = 795-1 사본 길)이 함.
고침 요청 `고침` = 목록 · 차례대로:
{할일: 식, 자리: 중간:<열쇠> | 결과 | 호표:<n> | 덧줄:<n>, 식: 글 | 나무: 나무}
{할일: 더함, 갈래: 입력 | 중간, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?, 설명?, 기본값?(입력),
식(중간), 뒤?(중간 열쇠 · "" = 맨 위 · 없으면 끝)}
{할일: 지움, 열쇠} — 쓰는 식이 있으면 막고 쓰는 곳 목록
{할일: 변수, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?} — 식은 열쇠로 부르니 안 깨짐
{할일: 표시, 열쇠, 표시: 0~6 | null}
{할일: 연결, 열쇠, 갈래: 입력|표|요소|로직|상수, …} — 새 기호의 연결 지정(`master_equation_link.py` 머리)
고친 중간 줄은 `표시` 없으면 `SHOW`(보이는 자리에서 잘라 셈 · 요구 658) — 고치지 않은 줄은 그대로.
키보드 한 줄 식 = 변수 글(기호_아래^위 · 이름 · 열쇠) · `× ÷ −` · 나머지는 엔진 식 말 그대로
(`[노임 …]` · `[별칭]` 은 M01 · M02 층이 `M02_Sangeun_Formula.to_engine` 으로 먼저 풂).
"""
from __future__ import annotations
import copy
import re
from decimal import Decimal, InvalidOperation
import master_equation as meq
import master_equation_link as link
import master_formula as mf
KEY_FORM = re.compile(r"^[^\W\d][\w]{0,19}$") # 열쇠 = 글자로 시작 · 20 자까지
SIGN_FORM = re.compile(r"^[^\W\d_]\w{0,9}$")
SUB_FORM = re.compile(r"^[\w′'*]{1,6}$")
RESERVED = {"찾기", "로직", "그리고", "또는", "계", "줄", "번지", "단계", *mf.FUNCS, *mf.COST_ITEMS}
_TOKEN = re.compile(r"[^\W\d][\w]*(?:\^[^\s()+\-*/×÷−,=<>\[\]]+)?")
_BARE = re.compile(r"^[^\W\d][\w]*$")
_OPS = {"×": "*", "÷": "/", "−": "-"}
# ── 엔진 마디 · 나무 → 엔진 식 글 ──────────────────────────────────────
def _q(word: str) -> str:
return word if _BARE.match(word) else f"'{word}'"
def raw_text(node) -> str:
"""엔진 식 마디 → 엔진 식 글(괄호는 세기대로만)."""
kind = node[0]
if kind == "num":
return mf._plain(node[1])
if kind == "str":
return f"'{node[1]}'"
if kind in ("name", "ref"):
return node[1]
if kind == "neg":
inner = raw_text(node[1])
return f"-({inner})" if node[1][0] == "bin" else f"-{inner}"
if kind == "field":
return f"{raw_text(node[1])}.{_q(node[2])}"
if kind in ("find", "logic"):
head = "찾기" if kind == "find" else "로직"
args = "".join(f", {_q(k)}={raw_text(v)}" for k, v in node[2])
return f"{head}({node[1]}{args})"
if kind == "call":
return f"{node[1]}({', '.join(raw_text(x) for x in node[2])})"
_, op, left, right = node
return (
f"{_wrap(raw_text(left), left, op, False)} {op} {_wrap(raw_text(right), right, op, True)}"
)
def _wrap(text: str, node, op: str, right: bool) -> str:
if node[0] != "bin":
return text
mine, up = meq.PREC[node[1]], meq.PREC[op]
return f"({text})" if mine < up or (mine == up and right) else text # 왼쪽 묶임 그대로
def engine_text(tree: dict) -> str:
"""나무(이름 꼴) → 엔진 식 글 — 변수 = 열쇠 · 찾기 · 요소 · 블록 = 원문 식 · 조건 = 만약 셋."""
kind = tree.get("꼴")
if kind == "수":
return mf._plain(Decimal(str(tree["값"])))
if kind == "글":
return f"'{tree['글']}'" if tree.get("따옴") else str(tree["글"])
if kind == "변수":
return str(tree.get("식") or tree["열쇠"])
if kind == "블록":
return str(tree["식"])
if kind == "괄호":
return f"({engine_text(tree['안'])})"
if kind == "음":
return f"-{_side(tree['안'], '*', True)}"
if kind == "퍼센트":
return f"{_side(tree['안'], '/', False)} / 100"
if kind == "분수":
low = tree["아래"]
if tree.get("사슬") and low.get("꼴") == "연산": # a/(b×c) 모양 = 원래 a / b / c
parts = [tree["위"], low["좌"], low["우"]]
first = _side(parts[0], "/", False)
return " / ".join([first, *(_side(p, "/", True) for p in parts[1:])])
return f"{_side(tree['위'], '/', False)} / {_side(low, '/', True)}"
if kind == "조건":
return f"만약({', '.join(engine_text(tree[k]) for k in ('조건', '참', '거짓'))})"
if kind == "함수":
return f"{tree['이름']}({', '.join(engine_text(x) for x in tree['인자'])})"
if kind == "연산":
op = _OPS.get(tree["기호"], tree["기호"])
return f"{_side(tree['좌'], op, False)} {op} {_side(tree['우'], op, True)}"
raise mf.FormulaError(f"모르는 나무 마디 「{kind}」")
def _strength(tree: dict) -> int | None:
kind = tree.get("꼴")
if kind == "연산":
return meq.PREC[_OPS.get(tree["기호"], tree["기호"])]
return meq.PREC["/"] if kind in ("분수", "퍼센트") else None
def _side(tree: dict, op: str, right: bool) -> str:
text, mine = engine_text(tree), _strength(tree)
if mine is None:
return text
up = meq.PREC[op]
return f"({text})" if mine < up or (mine == up and right) else text # 왼쪽 묶임 그대로
# ── 키보드 한 줄 식 ↔ 엔진 식 ─────────────────────────────────────────
def _names(row: dict) -> tuple[dict, dict]:
"""(변수 글 → 열쇠, 열쇠 → 변수 글) — 겹치는 글은 뺌(열쇠로 적어야 함)."""
rows = meq.table(row)
want: dict[str, set] = {}
for v in rows:
for word in {v["열쇠"], meq.token(v), v["이름"]}:
want.setdefault(word, set()).add(v["열쇠"])
to_key = {w: next(iter(ks)) for w, ks in want.items() if len(ks) == 1}
to_word = {v["열쇠"]: meq.token(v) for v in rows if to_key.get(meq.token(v)) == v["열쇠"]}
return to_key, to_word
def _swap_words(text: str, table: dict) -> str:
"""따옴표 · 대괄호 밖 변수 글만 바꿈 — 찾기 · 로직 인자 이름(「조건=」)은 그대로."""
out, at = [], 0
while at < len(text):
ch = text[at]
if ch in "'[":
end = text.find("'" if ch == "'" else "]", at + 1)
end = len(text) if end < 0 else end + 1
out.append(text[at:end])
at = end
continue
m = _TOKEN.match(text, at) if not (text[at - 1 : at].isalnum() and at) else None
if not m:
out.append(ch)
at += 1
continue
word, rest = m.group(), text[m.end() :].lstrip()
arg = rest.startswith("=") and not rest.startswith("==")
out.append(table.get(word, word) if not arg else word)
at = m.end()
return "".join(out)
def keyboard(text: str, row: dict) -> str:
"""키보드 한 줄 식 → 엔진 식 — 변수 글(첨자 `^'` 포함) → 열쇠 먼저 · 따옴표 밖 `× ÷ −`."""
bits = _swap_words(str(text), _names(row)[0]).split("'")
return "'".join(
"".join(_OPS.get(c, c) for c in b) if i % 2 == 0 else b for i, b in enumerate(bits)
)
def keyboard_of(text: str, row: dict) -> str:
"""엔진 · 이름 꼴 식 → 키보드 한 줄 식(열쇠 → 변수 글)."""
return _swap_words(str(text), _names(row)[1])
# ── 쓰는 곳 ───────────────────────────────────────────────────────────
def _spots(row: dict):
"""(자리 글, 자리 열쇠, 식 글) — 모든 식."""
for step in row.get("중간") or []:
yield f"중간 {step['이름']}", f"중간:{step['이름']}", step["식"]
if "결과" in row:
yield "결과", "결과", row["결과"]["식"]
for at, item in enumerate(row.get("호표") or []):
where = f"호표 {at + 1} {item.get('이름', '')}"
yield f"{where} 수량", f"호표:{at}", item["수량"]
elem = item.get("요소")
if isinstance(elem, dict):
yield f"{where} 요소", f"호표:{at}", " ".join(str(v) for v in elem.values())
else:
yield f"{where} 요소", f"호표:{at}", str(elem)
for at, extra in enumerate(row.get("덧줄") or []):
yield f"덧줄 {extra['이름']}", f"덧줄:{at}", extra["식"]
def _used(text: str) -> set[str]:
out = set(mf._HOLE.findall(text))
try:
for part in mf.walk(mf.parse(text)):
if part[0] == "name":
out.add(part[1])
except (mf.FormulaError, RecursionError):
pass
return out
def uses(row: dict, key: str) -> list[str]:
"""열쇠를 쓰는 식 자리(제 줄 빼고)."""
return [
where for where, spot, text in _spots(row) if spot != f"중간:{key}" and key in _used(text)
]
# ── 고침 ──────────────────────────────────────────────────────────────
def _all_keys(row: dict) -> set[str]:
return {str(x.get("이름")) for k in ("입력", "중간", "덧줄") for x in row.get(k) or []}
def _key_ok(row: dict, key: str) -> str | None:
if not KEY_FORM.match(key) or mf.mk.KEY.fullmatch(key) or key in RESERVED:
return f"열쇠 꼴 아님 「{key}」(글자로 시작 · 20 자까지 · 예약어 · 요소 키 안 됨)"
if key in _all_keys(row):
return f"같은 열쇠 「{key}」 가 이미 있음"
return None
def _text_of(ed: dict, row: dict, words) -> tuple[str, list[str]]:
"""고침 식 → 엔진 식 — 나무 · 키보드 글(`words` = 층 번역 `[노임 …]` · `[별칭]` · 상한)."""
if isinstance(ed.get("나무"), dict):
return engine_text(ed["나무"]), []
text = keyboard(str(ed.get("식") or "").strip(), row)
return words(text, row) if words and text else (text, [])
def unknown(text: str, row: dict) -> list[str]:
"""엔진 식 글 안 모르는 변수 글(변수 · 열쇠 · 예약어 · 함수 · 칸 · 인자 이름 · 요소 키 빼고)."""
known = set(_names(row)[0]) | _all_keys(row) | RESERVED
out, at = [], 0
while at < len(text):
if text[at] in "'[":
end = text.find("'" if text[at] == "'" else "]", at + 1)
at = len(text) if end < 0 else end + 1
continue
m = None if at and text[at - 1].isalnum() else _TOKEN.match(text, at)
if not m:
at += 1
continue
word, before, rest = m.group(), text[:at].rstrip(), text[m.end() :].lstrip()
at = m.end()
arg = rest.startswith("=") and not rest.startswith("==")
skip = before.endswith(".") or rest.startswith("(") or arg
if not (skip or word in known or mf.mk.KEY.fullmatch(word) or word in out):
out.append(word)
return out
def _set_formula(row: dict, ed: dict, why: list, spots: set, words=None) -> None:
spot = str(ed.get("자리") or "")
text, bad = _text_of(ed, row, words)
if bad:
why += [f"{spot} · {w}" for w in bad]
return
if not isinstance(ed.get("나무"), dict) and (miss := unknown(text, row)):
why.append(
f"{spot} · 모르는 기호 「{'」 「'.join(miss)}」 — 변수 정의 영역에서 연결을 지정"
)
return
if not text:
why.append(f"{spot} · 식이 빔")
return
part, _, at = spot.partition(":")
if part == "중간":
step = next((s for s in row.get("중간") or [] if s["이름"] == at), None)
if step is None:
why.append(f"없는 자리 「{spot}」")
return
step["식"] = text
step.setdefault("표시", meq.SHOW)
elif part == "결과" and "결과" in row:
row["결과"]["식"] = text
elif part in ("호표", "덧줄") and at.isdigit() and int(at) < len(row.get(part) or []):
row[part][int(at)]["수량" if part == "호표" else "식"] = text
else:
why.append(f"없는 자리 「{spot}」")
return
spots.add(spot)
def _look(row: dict, key: str, ed: dict, why: list) -> None:
"""이름 · 기호 · 첨자 → 변수표 · 단위 → 입력 · 중간 칸."""
spec = next((s for k in ("입력", "중간") for s in row.get(k) or [] if s["이름"] == key), None)
if spec is None:
why.append(f"없는 변수 「{key}」")
return
look = dict((row.get(meq.FIELD) or {}).get(key) or {})
for field, form in (("이름", None), ("기호", SIGN_FORM), ("위", SUB_FORM), ("아래", SUB_FORM)):
if field not in ed:
continue
got = str(ed[field] or "").strip()
if got and form is not None and not form.match(got):
why.append(f"「{key}」 {field} 꼴 아님 「{got}」")
return
if field == "이름" and len(got) > 40:
why.append(f"「{key}」 이름 40 자까지")
return
if got and got != (key if field in ("이름", "기호") else ""):
look[field] = got
else:
look.pop(field, None)
if "단위" in ed:
unit = str(ed["단위"] or "").strip()
spec.pop("단위", None) if not unit else spec.__setitem__("단위", unit)
table = dict(row.get(meq.FIELD) or {})
table.pop(key, None) if not look else table.__setitem__(key, look)
if table:
row[meq.FIELD] = table
else:
row.pop(meq.FIELD, None)
seen: dict[str, str] = {}
for v in meq.table(row): # 변수 글 겹침 — 키보드 식이 갈리지 않게
for word in {meq.token(v), v["이름"]}:
if seen.get(word, v["열쇠"]) != v["열쇠"]:
why.append(f"「{word}」 이 「{seen[word]}」 · 「{v['열쇠']}」 둘에 겹침")
seen.setdefault(word, v["열쇠"])
def _add(row: dict, ed: dict, why: list, spots: set, words=None) -> None:
kind, key = ed.get("갈래"), str(ed.get("열쇠") or ed.get("이름") or "").strip()
if kind not in ("입력", "중간"):
why.append(f"더함 갈래 「{kind}」 — 입력 · 중간")
return
if bad := _key_ok(row, key):
why.append(bad)
return
if kind == "입력":
spec: dict = {"이름": key}
for field in ("설명", "단위"):
if ed.get(field):
spec[field] = str(ed[field])
if ed.get("기본값") not in (None, ""):
try:
spec["기본"] = Decimal(str(ed["기본값"]))
except InvalidOperation:
spec["기본"] = str(ed["기본값"])
row.setdefault("입력", []).append(spec)
else:
mids = row.setdefault("중간", [])
after = ed.get("뒤")
at = len(mids) if after is None else 0 if after == "" else None
if at is None:
at = next((i + 1 for i, s in enumerate(mids) if s["이름"] == after), None)
if at is None:
why.append(f"더함 자리 「{after}」 없는 중간")
return
mids.insert(
at, {"이름": key, "식": "0", **({"단위": ed["단위"]} if ed.get("단위") else {})}
)
job = {"자리": f"중간:{key}", **{k: ed[k] for k in ("식", "나무") if k in ed}}
_set_formula(row, job, why, spots, words)
look = {k: ed[k] for k in ("이름", "기호", "위", "아래") if ed.get(k)}
if look:
_look(row, key, look, why)
def _drop(row: dict, key: str, why: list) -> None:
users = uses(row, key)
if users:
why.append(f"「{key}」 를 쓰는 곳이 있어 못 지움 — {' · '.join(users)}")
return
for kind in ("입력", "중간"):
got = [s for s in row.get(kind) or [] if s["이름"] != key]
if len(got) != len(row.get(kind) or []):
row[kind] = got
break
else:
why.append(f"없는 변수 「{key}」")
return
for field in (meq.FIELD, "시험입력"):
if isinstance(row.get(field), dict) and key in row[field]:
row[field] = {k: v for k, v in row[field].items() if k != key}
if not row[field]:
row.pop(field)
def _show(row: dict, key: str, ed: dict, why: list) -> None:
step = next((s for s in row.get("중간") or [] if s["이름"] == key), None)
show = ed.get("표시")
if step is None:
why.append(f"표시는 중간 줄만 — 「{key}」")
elif show is None:
step.pop("표시", None)
elif not isinstance(show, int) or isinstance(show, bool) or not 0 <= show <= 6:
why.append(f"「{key}」 표시는 0~6 자리")
else:
step["표시"] = show
def apply(master, row: dict, edits: list, words=None) -> tuple[dict, list[str], set]:
"""고침 목록 → (새 로직 줄, 까닭, 식 고친 자리) — 까닭 있으면 저장 안 됨.
`words(글, 줄) → (엔진 식, 까닭)` = 층 번역(`M02_Sangeun_Formula` 상한 · to_engine)."""
new, why, spots = copy.deepcopy(row), [], set()
if not isinstance(edits, list) or not edits:
return new, ["고침 없음"], spots
for ed in edits:
ed = ed if isinstance(ed, dict) else {}
job, key = ed.get("할일"), str(ed.get("열쇠") or "")
try:
if job == "식":
_set_formula(new, ed, why, spots, words)
elif job == "더함":
_add(new, ed, why, spots, words)
elif job == "지움":
_drop(new, key, why)
elif job == "변수":
_look(new, key, ed, why)
elif job == "표시":
_show(new, key, ed, why)
elif job == "연결":
add, bad = link.plan(master, ed)
_add(new, add, why, spots, words) if add else why.append(bad)
else:
why.append(f"모르는 할일 「{job}」")
except (mf.FormulaError, KeyError, TypeError, ValueError) as e:
why.append(f"{job} · {e}")
if not why:
why += check(master, row, new, spots)
return new, why, spots
# ── 검사 ──────────────────────────────────────────────────────────────
def swap(master, row: dict):
"""그 로직만 고친 줄로 바꾼 마스터 사본(얕은 · 다른 줄은 같이 씀)."""
out = copy.copy(master)
key = str(row.get("키"))
out.index = dict(master.index)
out.index[key[:2]] = {**master.index.get(key[:2], {}), key: row}
return out
def _loop(row: dict, spots: set) -> list[str]:
"""고친 중간 줄 — 자기 · 아래 줄 · 순환."""
mids = [s["이름"] for s in row.get("중간") or []]
deps = {s["이름"]: _used(s["식"]) & set(mids) for s in row.get("중간") or []}
out = []
for i, name in enumerate(mids):
if f"중간:{name}" not in spots:
continue
for used in sorted(deps[name] - set(mids[:i])):
if used == name:
out.append(f"중간 {name} · 순환 — 「{name}」 이 자기 자신을 씀")
else:
path = _path(deps, used, name)
out.append(
f"중간 {name} · 순환 — {' → '.join([name, *path])}"
if path
else f"중간 {name} · 「{used}」 은 아래 줄 — 위로 옮길 것"
)
return out
def _path(deps: dict, start: str, goal: str) -> list[str] | None:
seen, todo = {start}, [[start]]
while todo:
path = todo.pop()
if path[-1] == goal:
return path
for nxt in sorted(deps.get(path[-1], ())):
if nxt not in seen:
seen.add(nxt)
todo.append([*path, nxt])
return None
def _zero(text: str) -> bool:
try:
node = mf.parse(text)
except (mf.FormulaError, RecursionError):
return False
return any(n[0] == "bin" and n[1] == "/" and n[3] == ("num", 0) for n in mf.walk(node))
def check(master, old: dict, new: dict, spots: set) -> list[str]:
"""새로 생긴 문제만 — 식 못 읽음 · 없는 이름 · 0 나눔 · 순환 · 엔진 검사 · 견본 셈 막힘."""
texts = {spot: text for _, spot, text in _spots(new)}
out = [f"{s} · 0 으로 나눔" for s in sorted(spots) if _zero(texts.get(s, ""))]
out += _loop(new, spots)
head = f"{new.get('키')} {new.get('원문번호')} "
base = set(mf.check_logic(master, old)[0])
out += [w.removeprefix(head) for w in mf.check_logic(master, new)[0] if w not in base]
if out:
return out
before, after = _trial(master, old), _trial(swap(master, new), new)
if after and after != before:
out.append(f"견본 셈 막힘 — {after}")
return out
def _trial(master, row: dict) -> str | None:
"""견본 입력 셈 — 막히면 까닭(빈 입력 빼고)."""
try:
mf.run(master, str(row.get("키")), meq.given_of(master, row))
except mf.EmptyInput:
return None
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
return str(e) or type(e).__name__
return None
@@ -1,68 +0,0 @@
"""수식 탭 소계 묶음(PLAN 801-3 · 요구 662-3) — 돈 묶음 한 곳 · M01(`master_equation`) · M02(`M02_Sangeun_Equation_Full`) 같은 꼴.
묶음 = 부른 · 더한 단가산출(갈래 블록) 하나씩 + 직접 줄(인력 · 재료 · 기계 · 덧줄 · 율) 전부 한 묶음(갈래 직접).
돈 없는 줄(계 0 · 바탕) · 뺀 줄 = 묶음 아님(식 줄로만 보임) · 합계 밖 줄 = `밖` 으로만.
머리 · 소계 · 합계 · 계 글자 판정 = 화면 부품(`ui_template_equation_sum.ts`) — 묶음 둘 이상 = 머리 · 소계 ·
단가산출(블록) 둘 이상 = 합계 · 아니면 계.
시험 `resources/tester/test_801_3_groups.py`.
"""
from __future__ import annotations
from decimal import Decimal
COSTS = ("노무비", "재료비", "경비")
_WORDS = ("인력", "재료", "기계") # 직접 묶음 이름 차례
def _zero(row: dict) -> bool:
"""돈 없는 바탕 줄 · 뺀 줄 — 묶음 아님."""
if row.get("상태") == "뺌":
return True
return row["계"] == 0 and row.get("상태") in (None, "바탕")
def _name(direct: list[dict]) -> str:
"""직접 묶음 이름 — 자원 갈래 말(인력 · 재료 · 기계) · 율 줄 = 이름 (율 %) · 덧줄뿐 = 비목 말."""
words = [w for w in _WORDS if any(r.get("종류") == w for r in direct)]
words += [
f"{r['이름']} ({r['수량']}%)" if r.get("수량") not in (None, "") else str(r["이름"])
for r in direct
if r["갈래"] == "율"
]
if not words:
words = [k for k in COSTS if any(r[k] != 0 for r in direct)]
return " · ".join(words)
def bundles(rows: list[dict]) -> dict:
"""줄(갈래 블록 | 자원 | 덧줄 | 율 · 비목 칸 · 계) → `{줄: 묶음들, 밖: 합계 밖 줄들}` — 금액은 더하기만(셈 안 바꿈)."""
blocks: list[dict] = []
direct: list[dict] = []
out: list[dict] = []
for row in rows:
if row.get("합밖"):
out.append({"이름": row["이름"], "밖금액": row.get("밖금액")})
elif _zero(row):
continue
elif row["갈래"] == "블록":
blocks.append(row)
else:
direct.append(row)
lines = list(blocks)
if direct:
one = {
"갈래": "직접",
"이름": _name(direct),
**{k: sum((r[k] for r in direct), Decimal(0)) for k in COSTS},
}
one["계"] = sum((one[k] for k in COSTS), Decimal(0))
mine = [ # 더한 · 덮은 줄 — 묶음 속에 한 줄씩(고친 줄을 숨기지 않음)
{k: r[k] for k in ("이름", "상태", "계", "원래") if r.get(k) is not None}
for r in direct
if r.get("상태") in ("더함", "덮음")
]
if mine:
one["낱줄"] = mine
lines.append(one)
return {"줄": lines, "밖": out}
@@ -8,7 +8,7 @@
로직 {로직: 키, 인자?: {칸: 식}} → 중간 줄 「로직(키, 칸=식…)」
상수 {값: 수} → 중간 줄 수
후보 목록 = `candidates`(표 · 요소 · 로직) — 읽기만 · 값 · 열쇠는 이름 옆 보관용(화면은 이름만 보임).
셈 · 검사는 `master_equation_edit.apply` 가 한 벌로(여기는 글만 짓고 막을 것만 막음).
셈 · 검사는 수식 문서 계산기 몫(여기는 글만 짓고 막을 것만 막음).
"""
from __future__ import annotations
@@ -1,99 +0,0 @@
# -*- coding: utf-8 -*-
"""수식 마디 기호 다듬기(PLAN 801-1 · 801-2 · 요구 662-4) — 기호 씌운(`master_symbol.apply`) 뒤 · 정의 영역 앞.
보이기만 — 셈 · 엔진 열쇠 · 식(`식` 칸) 안 바꿈.
- 한 마디 줄: 중간 · 결과 줄 식이 표 찾기 · 요소 · 로직 부르기 한 마디뿐이면 그 마디 = 줄 기호 · 줄 `한마디`
(화면은 「q = 0.7」 — 표 칸 글 「적용」 · 로직 이름은 정의 영역에만).
- 로직 부르기 마디 = 기호(부른 로직 결과 기호 + 아래 = 로직 이름 앞말) — 이름은 정의 영역 · 펼침 머리.
- 뜻 없는 표 칸 글(`PLAIN` — 적용 · 값 · 기준)로 지은 표 찾기 기호 = 그 행 조건 값(없으면 표 이름)으로.
- 한 로직 안 겹침 = 아래첨자 끝 숫자(`master_symbol.apply` 와 같은 꼴).
"""
from __future__ import annotations
import master_symbol as msym
PLAIN = {"적용", "값", "기준"}
LEAF = ("찾기", "요소")
def _sign(n: dict) -> str:
return f"{n.get('기호') or ''}_{n.get('아래') or ''}^{n.get('위') or ''}"
def _nodes(tree, out: list[dict]) -> list[dict]:
"""변수 · 블록 마디(블록 속 나무는 따로 다듬음 — 안 들어감)."""
if isinstance(tree, list):
for one in tree:
_nodes(one, out)
elif isinstance(tree, dict):
if tree.get("꼴") in ("변수", "블록"):
out.append(tree)
for k, v in tree.items():
if k != "나무" and isinstance(v, (dict, list)):
_nodes(v, out)
return out
def lone(line: dict) -> bool:
"""줄 식이 표 찾기 · 요소 · 로직 부르기 한 마디뿐인 중간 · 결과 줄."""
tree = line.get("이름식") or {}
one = tree.get("꼴") == "블록" or (tree.get("꼴") == "변수" and tree.get("갈래") in LEAF)
return line.get("갈래") in ("중간", "결과") and one and isinstance(line.get("결과"), dict)
def _block_sign(node: dict) -> tuple[str, str, str]:
sub = node.get("나무") or {}
last = next((x for x in reversed(sub.get("줄") or []) if x.get("갈래") == "결과"), None)
head = (last or {}).get("결과") or {}
sign = head.get("기호") if msym.is_symbol(str(head.get("기호") or "")) else ""
sign = sign or msym.rule(str(node.get("결과단위") or ""), "결과")[0]
return sign, msym.short(str(node.get("이름") or node.get("열쇠") or "")), ""
def _find_sign(node: dict) -> tuple[str, str, str]:
said = [str(v) for v in (node.get("행") or {}).values() if isinstance(v, str) and v]
name = said[-1] if said else str(node.get("표이름") or "")
node["칸글"] = True # 정의 이름 = 표 · 조건 값(칸 글 아님)
node["이름"] = " ".join(x for x in (str(node.get("표이름") or ""), *said[-1:]) if x)
if msym.is_symbol(name):
return name, "", "표"
sign, low, _ = msym.lookup(name, "찾기")
return sign, low, "표"
def settle(out: dict) -> dict:
"""내보낸 수식 한 벌(한 깊이) 다듬기 — 제자리 고침 · 같은 것 돌려줌."""
lines = out.get("줄") or []
for line in lines:
if lone(line):
line["한마디"] = True
head = line["결과"]
line["이름식"] |= {k: head.get(k) or "" for k in ("기호", "아래", "위")}
nodes = _nodes(lines, [])
heads = [x["결과"] for x in lines if isinstance(x.get("결과"), dict)]
used = {_sign(n) for n in [*nodes, *heads, *(out.get("변수표") or [])]}
done: dict[str, tuple[str, str, str]] = {}
for line in lines:
skip = line["이름식"] if line.get("한마디") else None
for node in _nodes(line.get("이름식"), []):
if node is skip:
continue
if node.get("꼴") == "블록":
want = _block_sign
elif node.get("갈래") == "찾기" and node.get("칸") in PLAIN:
want = _find_sign
else:
continue
key = str(node.get("식") or node.get("열쇠"))
if key not in done:
used.discard(_sign(node))
sign, low, up = want(node)
n, base = 1, low
while _sign({"기호": sign, "아래": low, "위": up}) in used:
n += 1
low = base[: msym.SUBMAX - len(str(n))] + str(n)
used.add(_sign({"기호": sign, "아래": low, "위": up}))
done[key] = (sign, low, up)
node["기호"], node["아래"], node["위"] = done[key]
return out
@@ -1,133 +0,0 @@
# -*- coding: utf-8 -*-
"""수식 변수 정의 영역(PLAN 800-2 · 요구 660-2 · 3 · 6) — 수식 나무 → 오른쪽 「변수 정의」 목록.
줄 구분 없이 한 목록 · 같은 변수는 한 번만(겹침 합침) · 기호 : 국문 이름 — 연결(입력 · 표 찾기 ·
요소 · 로직 · 계산을 사람 말로) · 값 · 단위 · DB 열쇠 글은 담지 않음.
지금 고른 옵션 갈래만 — 만약의 탄 갈래 표지 `걸림`(1 참 · 2 거짓 · 0 모름 = 둘 다)을 그대로 씀(새 판정 없음) ·
`안씀` = 어느 식에도 안 쓰이는 입력(지울 수 있음) · 쓰는 변수 지움 막기는 `master_equation_edit._drop`.
"""
from __future__ import annotations
CAT = {"LB": "인력", "EQ": "기계", "MT": "재료", "MO": "재료"}
WHAT = {
"입력": "입력",
"중간": "계산",
"결과": "계산 결과",
"찾기": "표 찾기",
"요소": "요소",
"블록": "로직 부르기",
}
def visible(node: dict | None, out: list[dict]) -> list[dict]:
"""나무에서 보이는(탄 갈래) 변수 · 블록 마디를 차례대로."""
if not isinstance(node, dict):
return out
kind = node.get("꼴")
if kind in ("변수", "블록"):
out.append(node)
elif kind == "조건":
visible(node.get("조건"), out)
for key, at in (("참", 1), ("거짓", 2)):
if node.get("걸림") in (0, None, at):
visible(node.get(key), out)
else:
for key in ("좌", "우", "안", "위", "아래"):
visible(node.get(key), out)
for arg in node.get("인자") or []:
visible(arg, out)
return out
def _link(node: dict, spec: dict | None, leaf: dict | None) -> str:
"""연결 설명 — 사람 말(열쇠 · 값 · 단위 없음)."""
kind = node.get("갈래") or ("블록" if node.get("꼴") == "블록" else "")
if kind == "입력":
return "입력 — " + ("옵션에서 고름" if (spec or {}).get("고르기") else "직접 적음")
if kind == "중간" and leaf is not None and leaf is not node:
return _link(leaf, None, None)
if kind == "상수":
return f"상수 — {node.get('글')}"
if kind == "찾기":
cond = " · ".join(f"{k} = {v}" for k, v in (node.get("조건식") or {}).items())
head = f"표 찾기 — {node.get('표이름') or '표'}"
return head + (f" · 조건 {cond}" if cond else "") + f" · 칸 {node.get('칸') or ''}".rstrip()
if kind == "요소":
pick = node.get("고르기")
if isinstance(pick, dict):
return "요소 · 재료 고름 — " + " · ".join(str(v) for v in pick.values() if v)
return f"요소 · {CAT.get(str(node.get('식') or '')[:2], '단가')} — {node.get('이름') or ''}"
if kind == "블록":
return f"로직 부르기 — {node.get('이름') or ''}"
return WHAT.get(kind, "계산") + (" — 수식 영역의 식" if kind in ("중간", "결과") else "")
def definitions(lines: list[dict], row: dict, rows: list[dict], unused) -> list[dict]:
"""보이는 식의 변수 정의 목록 — `rows` = 변수 표 · `unused(열쇠)` = 어느 식에도 안 쓰임."""
specs = {str(s.get("이름")): s for k in ("입력", "중간") for s in row.get(k) or []}
table = {v["열쇠"]: v for v in rows}
got: dict[str, dict] = {}
leaf: dict[str, dict] = {}
for line in lines:
head, tree = line.get("결과"), line.get("이름식")
if line.get("갈래") in ("중간", "결과") and isinstance(tree, dict):
if tree.get("꼴") == "수": # 상수 — 연결 설명에 그 수
leaf[str(line.get("열쇠"))] = {"갈래": "상수", "글": tree.get("글")}
elif tree.get("갈래") in ("찾기", "요소") or tree.get("꼴") == "블록": # 한 마디 식
leaf[str(line.get("열쇠"))] = tree
found = ([head] if head and line.get("갈래") in ("중간", "결과") else []) + visible(
tree, []
)
for node in found:
key = str(node.get("열쇠") or "")
if key and key not in got and node.get("갈래") in (*WHAT, "합", None):
got[key] = node
out: dict[tuple, dict] = {} # 같은 기호 글 = 같은 정의(겹침 합침) — 연결은 모아 보임
for key, node in got.items():
mine = table.get(key)
look = mine or node
kind = node.get("갈래") or "블록"
if kind == "합":
kind = "결과" if key == "결과" else "중간"
if key.startswith("줄."): # 위 호표 줄 금액 부름
name, link = key[2:].strip("'"), f"호표 줄 금액 — {key[2:].strip(chr(39))}"
else:
link = _link({**node, "갈래": kind}, specs.get(key), leaf.get(key))
if kind == "블록" and not leaf.get(key):
link = "로직 부르기" # 이름이 곧 그 로직 — 되풀이 안 함
name = (look.get("이름") or key) if mine else look.get("이름") or ""
name = node.get("칸") or name if kind == "찾기" else name
one = {
"열쇠": key if mine else "",
"기호": look.get("기호") or name, # 줄 참조도 씌운 기호(master_symbol 한 곳)
"위": look.get("위") or "",
"아래": look.get("아래") or "",
"이름": name,
"갈래": kind,
"연결": [link],
"고침": bool(mine),
}
same = out.setdefault((one["기호"], one["위"], one["아래"]), one)
if same is not one:
same["연결"] += [x for x in one["연결"] if x not in same["연결"]]
if one["열쇠"] and not same["열쇠"]:
same |= {k: one[k] for k in ("열쇠", "이름", "갈래", "고침")}
out = list(out.values())
seen = {d["열쇠"] for d in out}
for v in rows: # 어느 식에도 안 쓰이는 입력 — 지울 수 있게
if v["갈래"] == "입력" and v["열쇠"] not in seen and unused(v["열쇠"]):
out.append(
{
"열쇠": v["열쇠"],
"기호": v["기호"],
"위": v["위"],
"아래": v["아래"],
"이름": v["이름"],
"갈래": "입력",
"연결": ["입력 — 쓰는 식 없음"],
"고침": True,
"안씀": True,
}
)
return out
+2 -80
View File
@@ -6,7 +6,7 @@
수량 · 소요량 · 품 Q · 길이 · 거리 L · 높이 H · 폭 B · 두께 t · 면적 A · 부피 V · 무게 W · 지름 D …
- 아래첨자 = 이름에서 끝말을 뺀 알맹이(6 자까지) · 같은 이름 = 같은 기호(로직이 달라도).
- 갈래별: 찾기(표 칸) = 위 「표」 · 요소 단가 P · 노임 w · 합(금액 줄) C · 결과 = 단위가 원이면 P 아니면 Q.
- 규칙만(자료 파일 없음) — 한 로직 안 겹침은 쓰는 쪽(빌더 · 내보내기)이 아래첨자 숫자로 가름.
- 규칙만(자료 파일 없음) — 한 문서 안 겹침은 쓰는 쪽(`M02_San_ToDoc`)이 아래첨자 숫자로 가름.
- 이미 기호 꼴(영문 · 그리스 ≤ 6 자)이거나 사용자가 정한 기호는 건드리지 않음.
"""
@@ -14,10 +14,8 @@ from __future__ import annotations
import re
SYMBOL = re.compile(r"^[A-Za-zα-ωΑ-Ω][A-Za-z0-9′']{0,5}(?:_[A-Za-z0-9′']{1,6})?$") # 이미 기호 꼴
LATIN_HEAD = re.compile(r"^([A-Za-zα-ω]{1,2})([가-힣].*)$") # 「E입력」 「f분류」 = 기호 + 말
FAMILY = ("변수", "찾기", "요소", "합", "결과")
SUBMAX = 6 # master_equation_edit.SUB_FORM 과 같게
SUBMAX = 6 # 아래첨자 글자 수 상한(`M02_San_ToDoc` 겹침 숫자)
# (끝말들, 머리글자) — 먼저 맞는 것이 이김(긴 끝말 · 특수 먼저)
SUFFIX: list[tuple[tuple[str, ...], str]] = [
@@ -187,79 +185,3 @@ def rule(name: str, family: str = "변수", hint: str = "") -> tuple[str, str, s
def lookup(name: str, family: str = "변수", hint: str = "") -> tuple[str, str, str]:
return rule(name, family, hint)[:3]
def is_symbol(sign: str) -> bool:
return bool(SYMBOL.match(sign or ""))
# ── 수식 내보내기 결과에 씌우기(찾기 · 요소 · 합 · 결과 — 정의 칸이 없는 것) ─────────────
def family_name(node: dict) -> tuple[str, str, str] | None:
"""변수 마디 → (갈래, 이름, 같은 것 가름 열쇠) — 찾기 · 요소 · 합만 · 아니면 None."""
kind = node.get("갈래")
if kind not in ("찾기", "요소", "합") or "기호" not in node or node.get("열쇠") == "결과":
return None
if kind == "찾기": # 칸이 같아도 표 · 조건이 다르면 다른 변수
return kind, str(node.get("칸") or ""), str(node.get("열쇠"))
name = str(node.get("이름") or node.get("열쇠") or "")
if kind == "요소":
if name.startswith("줄."): # 다른 호표 줄 금액 참조
name = name[2:].strip("'")
return "합", name, name
if m := re.match(
r"^[A-Z]{1,3}:\{(.+?)\}\.?(.*)$", name
): # EQ:{기계}.조종원 — 풀리지 않은 열쇠
return kind, m.group(1) + m.group(2).strip("'"), name
return kind, name, name
def _text(sign: str, low: str, up: str) -> str:
return sign + (f"_{low}" if low else "") + (f"^{up}" if up else "")
def apply(out: dict) -> dict:
"""내보낸 수식(export 결과) 안 변수 마디 기호가 한글 그대로면 기본 기호로 — 기호 꼴 · 고친 것은 그대로.
한 내보내기(= 한 로직) 안에서 다른 이름이 같은 글이 되면 뒤 것 아래에 숫자(`Q_크레인2`).
"""
seen: dict[str, tuple[str, str]] = {} # 글 → (갈래, 이름)
for v in out.get("변수표") or []:
seen.setdefault(
_text(str(v.get("기호") or ""), str(v.get("아래") or ""), str(v.get("위") or "")),
("변수", str(v.get("열쇠"))),
)
chosen: dict[tuple[str, str], tuple[str, str, str]] = {}
def pick(fam: str, name: str, got: tuple[str, str, str]) -> tuple[str, str, str]:
one = chosen.get((fam, name))
if one is None:
sign, low, up = got
n, base = 1, low
while seen.get(_text(sign, low, up), (fam, name)) != (fam, name):
n += 1
low = base[: SUBMAX - len(str(n))] + str(n)
seen[_text(sign, low, up)] = (fam, name)
one = chosen[(fam, name)] = (sign, low, up)
return one
for line in out.get("줄") or []:
head = line.get("결과") if line.get("갈래") == "결과" else None
if isinstance(head, dict) and not is_symbol(str(head.get("기호") or "")):
head["기호"], head["아래"], head["위"] = pick(
"결과", "결과", rule(out.get("결과단위") or "", "결과")[:3]
)
_walk(out, pick)
return out
def _walk(tree, pick) -> None:
if isinstance(tree, list):
for one in tree:
_walk(one, pick)
elif isinstance(tree, dict):
got = family_name(tree)
if got and got[1] and not is_symbol(str(tree["기호"])):
tree["기호"], tree["아래"], tree["위"] = pick(got[0], got[2], lookup(got[1], got[0]))
for v in tree.values():
if isinstance(v, (dict, list)):
_walk(v, pick)
+3 -32
View File
@@ -1,7 +1,7 @@
"""792-1 식 글 번역 · 옛 SK 식 칸 막음.
"""792-1 옛 SK 식 칸 막음.
- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음(M01 수식 탭 · 가져온 식이 씀)
- 식 글 상한 — 괄호 깊이 · 길이
- 식 글 번역(이름 꼴 ↔ 엔진 식 · `M02_Sangeun_Formula`) · 상한 시험은 옛 수식 탭과 함께
855-E 2-E4 에서 걷음
- 옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)과 상수 · 표값 덮개 = 셈 은퇴(855 2-C1) 뒤 받지 않음 400(855 2-E2)
- [초기화] = 덮개 · 뺀줄 · 그 까닭 걷음 · 빈 옛 식 칸 = 지문 그대로
"""
@@ -16,7 +16,6 @@ from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Formula as fx
FORM, CARRY = "GC000211", "GC001140" # 합판거푸집 · 인력운반(지게)
MAN = "labor:LB000002#0" # 인력운반 보통인부
@@ -53,34 +52,6 @@ def _sk_doc(code, given, **more):
return {**_doc(code, given), **more}
# ── 이름 꼴 ↔ 엔진 식 ────────────────────────────────────────────────
def test_이름_꼴_양방향():
whole = _whole()
row = whole.logic(FORM)
tool = row["덧줄"][0]["식"]
named = fx.to_name(tool, row)
assert named == "(형틀목공 × [노임 형틀목공] + 보통인부 × [노임 보통인부]) × 1 / 100"
mid = fx.to_name(row["중간"][2]["식"], row)
assert mid.startswith("[합판거푸집설치및해체일당].시공량 × (1 - ")
assert fx.to_engine("[LB000007] ÷ 2", row) == ("LB000007 / 2", [])
assert fx.to_engine("[노임 형틀목공 LB000007] × 2", row)[0] == "LB000007 * 2"
assert fx.to_engine("합판거푸집구멍땜.시멘트", row)[0] == "찾기(QC000430).시멘트" # 맨 별칭
assert fx.to_engine("'[가]' × 1", row)[0] == "'[가]' * 1" # 따옴표 안 그대로
assert fx.to_engine("[없는것] × 1", row)[1] == ["없는 이름 「[없는것]」"]
assert fx.to_engine("[노임 × 1", row)[1] == ["대괄호 짝 안 맞음"]
for code in (FORM, CARRY, "GC000374", "GC000360"): # 띄어 쓴 자재 이름 · 긴 덧줄
one = whole.logic(code)
for part, f in (("중간", "식"), ("호표", "수량"), ("덧줄", "식")):
for x in one.get(part) or []:
assert fx.to_engine(fx.to_name(str(x[f]), one), one) == (str(x[f]), [])
def test_식_글_상한():
assert fx.limits("(" * 13 + "1" + ")" * 13) == [f"괄호가 {fx.DEEP} 겹을 넘음"]
assert fx.limits("1" * (fx.LONG + 1)) == [f"식이 {fx.LONG} 자를 넘음"]
assert fx.limits("'((((((((((((('") == [] # 따옴표 글 안 괄호 안 셈
def test_옛_식_칸_받지_않음():
whole = _whole()
plain = sd.clean(_sk_doc(FORM, F211), None, whole)
@@ -1,309 +0,0 @@
"""796-1 수식 모델 지킴 — 엔진 로직 ↔ 수식 나무 양방향 · 변수 표 · 추가 · 삭제 · 이름 전파 · 검사.
① 예시 셋(요구서_655 · `_분석_655-B` 2 장) — GF000089 토사깍기(블록 GF000088 Q = 39.293 · GC000267 · 813-2 GC001148 지움 뒤) ·
GC001140 지게(N · M · 42,917) · GC000211 거푸집(시공량 45 · 형틀목공 5/45 · 공구손료 1 %).
② 왕복 — M01 로직 식 전부: 엔진 식 → 나무 → 엔진 식 = 같은 식 나무 · 예시 셋 = 같은 금액.
③ 고침 — 식 고침 = 금액 바뀜 · 변수 더함 · 지움(쓰는 곳 막음) · 이름 · 기호 · 첨자 전파(식 그대로) ·
표시 자리 셈(고친 줄만) · 검사 까닭(없는 이름 · 괄호 · 순환 · 0 나눔 · 상한).
변수표 칸 셈 값 바뀜 0 · M01 1,519 지문은 `test_791_1_engine_semantics.py`.
"""
from __future__ import annotations
import copy
import importlib
import json
from decimal import Decimal as D
from functools import lru_cache
import pytest
from M01_MasterData import M01_MasterData_Equation as eq_m01
from M01_MasterData import M01_MasterData_Store as store
mf = importlib.import_module("master_formula")
mcut = importlib.import_module("master_cut")
meq = importlib.import_module("master_equation")
me = importlib.import_module("master_equation_edit")
REAL = store.FOLDER
EXCAVATOR, AFRAME, FORM = "GF000089", "GC001140", "GC000211"
GIVEN = {AFRAME: {"운반회수": 0}, FORM: {"유형": "보통", "높이감률": 0}, EXCAVATOR: {}}
@lru_cache(maxsize=1)
def whole():
return store.loaded()[1]
def export(key: str, row: dict | None = None) -> dict:
w = whole()
return meq.export(me.swap(w, row) if row else w, key, GIVEN[key])
def line(eq: dict, key: str, kind: str = "중간") -> dict:
return next(x for x in eq["줄"] if x["열쇠"] == key and x["갈래"] == kind)
def raw(key: str, row: dict | None = None) -> dict:
w = me.swap(whole(), row) if row else whole()
r = row or w.logic(key)
return mf.run(w, key, meq.given_of(w, r, GIVEN[key]))
def vars_in(tree) -> list[dict]:
if isinstance(tree, dict):
own = [tree] if tree.get("꼴") == "변수" else []
return own + [v for x in tree.values() for v in vars_in(x)]
if isinstance(tree, list):
return [v for x in tree for v in vars_in(x)]
return []
def edit(key: str, edits: list) -> tuple[dict, list[str]]:
return eq_m01.edit_row(whole(), whole().logic(key), edits)
# ── ① 예시 셋 ─────────────────────────────────────────────────────────
def test_굴착기_블록_Q_노재경():
eq = export(EXCAVATOR)
block = line(eq, "작업량")["이름식"]
assert block["꼴"] == "블록" and block["열쇠"] == "GF000088" and block["값"] == D("39.293")
sub = block["나무"]
q = line(sub, "결과", "결과")
assert q["결과"]["기호"] == "Q" and q["값"] == D("39.293")
frac = q["이름식"]["인자"][0] # 반올림(분수, 3)
assert frac["꼴"] == "분수" and frac["아래"]["열쇠"] == "Cm"
assert [v["기호"] for v in vars_in(frac["위"])] == ["q", "K", "f", "E"]
nums = [x.get("글") for x in vars_in(q["값식"])] or []
shown = json.dumps(q["값식"], default=str, ensure_ascii=False)
assert all(f'"글": "{n}"' in shown for n in ("3,600", "0.7", "0.9", "0.77", "0.45", "20"))
assert nums == [] # 값 꼴엔 변수 없음
item = line(eq, "굴착기(무한궤도) 0.7㎥", "호표")
price = item["이름식"]["좌"]
assert price["꼴"] == "블록" and price["열쇠"] == "GC000267"
assert set(price["묶음"]) == {"노무비", "재료비", "경비", "계"}
assert item["이름식"]["우"]["꼴"] == "분수" # 1 / 작업량
cut = mcut.engine(whole(), EXCAVATOR, raw(EXCAVATOR))
assert eq["합계"] == {k: cut[k] for k in mf.BUNDLE}
assert eq["합계"]["계"] == D("2791.0") # 조종원 1/8 × 16/12 × 25/20(840-5 · 옛 2190)
def test_지게_N_M_42917():
eq = export(AFRAME)
n = line(eq, "일운반회수")
assert n["결과"]["기호"] == "N" and n["글"] == "92.2131"
assert n["이름식"]["꼴"] == "조건" and n["이름식"]["걸림"] == 2 # 운반회수 0 → 식
frac = n["이름식"]["거짓"]
assert frac["꼴"] == "분수"
assert [v["기호"] for v in vars_in(frac["위"])] == ["V", "T"]
m = line(eq, "보통인부", "호표")
qty = m["이름식"]["우"]
assert qty["꼴"] == "분수" and qty.get("사슬") # 무게 / 운반량 / N → 무게 / (운반량 × N)
assert [v["기호"] for v in vars_in(qty["아래"])] == ["Q", "N"]
assert m["수량"].quantize(D("0.0001")) == D("0.2494")
assert eq["합계"]["노무비"] == D("42917.0")
signs = {v["열쇠"]: v["기호"] for v in eq["변수표"]}
assert signs.items() >= {"운반거리": "L", "적재적하시간": "t", "평균왕복속도": "V"}.items()
assert signs["일운반회수"] == "N" and signs["운반회수"] == "n" # 한 기호 = 한 변수
table = next(p for p in eq["풀이"] if p.get("표") == "CC000343")
assert table["행"] == {"종류": "석재류", "운반로": "불량"}
assert {p["갈래"] for p in eq["풀이"]} >= {"입력", "찾기", "요소"}
def test_거푸집_시공량_형틀목공_공구손료():
eq = export(FORM)
s = line(eq, "시공량")
assert s["값"] == 45 and "퍼센트" in json.dumps(s["이름식"], default=str, ensure_ascii=False)
w = line(eq, "형틀목공")
assert w["이름식"]["꼴"] == "분수" and w["글"] == "0.1111"
tool = line(eq, "공구손료 및 경장비", "덧줄")
assert tool["이름식"]["꼴"] == "퍼센트" and tool["글"] == "382.908"
def test_기호_후보_원문():
w = whole()
assert meq.symbols(w.logic("GC001147")) == {"버킷용량": "q", "결과": "Q"}
got = meq.symbols(w.logic(AFRAME))
assert got == {"운반거리": "L", "실작업시간": "T", "적재적하시간": "t", "평균왕복속도": "V"} | {
"일운반회수": "N"
}
# ── ② 왕복 ────────────────────────────────────────────────────────────
def _texts(row: dict):
for step in row.get("중간") or []:
yield step["식"]
if "결과" in row:
yield row["결과"]["식"]
for item in row.get("호표") or []:
yield item["수량"]
if isinstance(item.get("요소"), str):
yield item["요소"]
for extra in row.get("덧줄") or []:
yield extra["식"]
def test_왕복_M01_식_전부_같은_나무():
files, _ = store.loaded()
count, bad = 0, []
for data in files.values():
if data.get("그룹") != "로직":
continue
for row in data.get("줄") or []:
for text in _texts(row):
try:
node = mf.parse(text)
except mf.FormulaError:
continue
back = me.engine_text(meq.build(node, None))
count += 1
if mf.parse(back) != node or mf.parse(me.raw_text(node)) != node:
bad.append((row["키"], text, back))
assert count > 9000 and not bad, bad[:5]
@pytest.mark.parametrize("key", [EXCAVATOR, AFRAME, FORM, "GC001147"])
def test_왕복_예시_같은_금액(key):
GIVEN.setdefault("GC001147", {})
w = whole()
eq = meq.export(w, key, GIVEN[key])
row = copy.deepcopy(w.logic(key))
for one in eq["줄"]:
tree = one["이름식"]["우"] if one["갈래"] == "호표" else one["이름식"]
text = me.engine_text(tree)
if one["갈래"] == "중간":
next(s for s in row["중간"] if s["이름"] == one["열쇠"])["식"] = text
elif one["갈래"] == "결과":
row["결과"]["식"] = text
else:
row[one["갈래"]][one.get("차례", 0)]["수량" if one["갈래"] == "호표" else "식"] = text
before, after = raw(key), raw(key, row)
pick = ("결과",) if "결과" in row else mf.BUNDLE
assert {k: after[k] for k in pick} == {k: before[k] for k in pick}
def test_변수표_칸은_셈_안_바꿈():
row = dict(whole().logic(AFRAME))
row[meq.FIELD] = {"일운반회수": {"기호": "n", "아래": "d", "이름": "하루 운반 횟수"}}
assert raw(AFRAME, row)["계"] == raw(AFRAME)["계"]
# ── ③ 고침 ────────────────────────────────────────────────────────────
def test_식_고침_금액_바뀜_표시_자리():
new, why = edit(AFRAME, [{"할일": "식", "자리": "중간:환산거리", "식": "환산계수 × L × 2"}])
assert not why
step = next(s for s in new["중간"] if s["이름"] == "환산거리")
assert step["식"] == "환산계수 * 운반거리 * 2" and step["표시"] == meq.SHOW
others = [s for s in new["중간"] if s["이름"] != "환산거리"]
assert all("표시" not in s for s in others) # 고친 줄만
eq = export(AFRAME, new)
assert line(eq, "환산거리")["값"] == 96
assert eq["합계"]["노무비"] > export(AFRAME)["합계"]["노무비"]
def test_표시_자리에서_잘라_셈():
old = line(export(AFRAME), "일운반회수")["식"]
new, why = edit(AFRAME, [{"할일": "식", "자리": "중간:일운반회수", "식": old}])
assert not why and new["중간"][-1]["표시"] == 4
got = raw(AFRAME, new)
assert got["중간"]["일운반회수"] == D("92.2131")
assert got["노무비"] == D(575) / D(25) / D("92.2131") * D(172068)
assert got["노무비"] != raw(AFRAME)["노무비"] # 보이는 자리 셈 = 금액 바뀜(요구 658)
def test_변수_더함_입력_중간_식에서_부름():
new, why = edit(
AFRAME,
[
{
"할일": "더함",
"갈래": "입력",
"열쇠": "할증",
"기호": "k",
"아래": "s",
"기본값": "1.1",
},
{"할일": "더함", "갈래": "중간", "열쇠": "할증무게", "식": "무게 × k_s", "뒤": "무게"},
{"할일": "식", "자리": "호표:0", "식": "할증무게 ÷ 운반량 ÷ N"},
],
)
assert not why, why
assert new["입력"][-1] == {"이름": "할증", "기본": D("1.1")}
mids = [s["이름"] for s in new["중간"]]
assert mids[:2] == ["무게", "할증무게"] and new["중간"][1]["식"] == "무게 * 할증"
assert new["호표"][0]["수량"] == "할증무게 / 운반량 / 일운반회수"
eq = export(AFRAME, new)
assert line(eq, "할증무게")["값"] == D("632.5")
base = export(AFRAME)["합계"]["노무비"]
assert abs(eq["합계"]["노무비"] - base * D("1.1")) <= 1
def test_변수_지움_쓰는_곳_막음():
new, why = edit(AFRAME, [{"할일": "지움", "열쇠": "무게"}])
assert why and "호표 1 보통인부 수량" in why[0]
new, why = edit(AFRAME, [{"할일": "지움", "열쇠": "운반회수"}])
assert why and "중간 일운반회수" in why[0]
new, why = edit(
AFRAME,
[
{"할일": "더함", "갈래": "중간", "열쇠": "임시", "식": "무게 × 2"},
{"할일": "지움", "열쇠": "임시"},
],
)
assert not why and "임시" not in {s["이름"] for s in new["중간"]}
assert new["중간"] == whole().logic(AFRAME)["중간"]
def test_이름_기호_첨자_바꿈_전파():
new, why = edit(
AFRAME,
[
{
"할일": "변수",
"열쇠": "일운반회수",
"기호": "n",
"아래": "d",
"이름": "하루 운반 횟수",
}
],
)
assert not why
assert new["호표"] == whole().logic(AFRAME)["호표"] # 식은 열쇠 — 그대로
assert new["중간"] == whole().logic(AFRAME)["중간"]
eq = export(AFRAME, new)
used = [v for v in vars_in(line(eq, "보통인부", "호표")["이름식"]) if v["열쇠"] == "일운반회수"]
assert used and used[0]["기호"] == "n" and used[0]["아래"] == "d"
assert used[0]["이름"] == "하루 운반 횟수"
assert eq["합계"] == export(AFRAME)["합계"]
typed = eq_m01.export_row(whole(), new, GIVEN[AFRAME])
assert "n_d" in line(typed, "보통인부", "호표")["입력글"]
again, why = eq_m01.edit_row(
whole(), new, [{"할일": "식", "자리": "호표:0", "식": "무게 ÷ 운반량 ÷ n_d"}]
)
assert not why and again["호표"][0]["수량"] == "무게 / 운반량 / 일운반회수"
_, why = edit(
AFRAME, [{"할일": "변수", "열쇠": "운반량", "기호": "N", "아래": ""}]
) # 겹침(운반량 기본 아래 · 800-1 을 비움)
assert why and "겹침" in why[0]
def test_검사_까닭():
cases = {
"없는 이름": ("중간:환산거리", "환산계수 × 없는값", "모르는 기호"),
"괄호": ("중간:환산거리", "(환산계수 × L", "없음"),
"아래 줄": ("중간:무게", "일운반회수 × 2", "아래 줄"),
"순환": ("중간:무게", "무게 + 1", "자기 자신"),
"0 나눔": ("중간:환산거리", "환산계수 / 0", "0 으로 나눔"),
"길이": ("중간:환산거리", "1 + " * 80 + "1", "자를 넘음"),
"깊이": ("중간:환산거리", "(" * 13 + "1" + ")" * 13, "겹을 넘음"),
}
for name, (spot, text, want) in cases.items():
_, why = edit(AFRAME, [{"할일": "식", "자리": spot, "식": text}])
assert why and any(want in w for w in why), (name, why)
_, why = edit(AFRAME, [{"할일": "더함", "갈래": "입력", "열쇠": "무게"}])
assert why and "같은 열쇠" in why[0]
_, why = edit(AFRAME, [{"할일": "더함", "갈래": "입력", "열쇠": "LB000001"}])
assert why and "꼴 아님" in why[0]
_, why = edit(AFRAME, [{"할일": "표시", "열쇠": "무게", "표시": 9}])
assert why
-100
View File
@@ -1,100 +0,0 @@
"""799-1 단가산출 소계 · 끝수 · 합계 지킴(보이기만 — 금액 셈은 그대로).
① 예시 셋 — 굴착기(블록 한 줄) · 거푸집(자원 + 덧줄) · 지게(자원) : 줄 합 + 끝수 = 합계(비목마다).
② 표본 — 호표 로직 여럿 : 합계 = 엔진 끝수 입힌 비목 합(전후 같음) · 줄 합 + 끝수 = 합계 · 결과 로직은 소계 없음.
③ 부품 짝 — `ui_template_equation_sum.ts` 가 서버 칸 이름을 그대로 읽음.
"""
from __future__ import annotations
import importlib
from decimal import Decimal as D
from pathlib import Path
from M01_MasterData import M01_MasterData_Store as store
mf = importlib.import_module("master_formula")
mcut = importlib.import_module("master_cut")
meq = importlib.import_module("master_equation")
COSTS = ("노무비", "재료비", "경비", "계")
def _whole():
return store.loaded()[1]
def _logics() -> list[dict]:
"""M01 로직 줄 전부(키 순)."""
w = _whole()
return [
r
for tid, rows in sorted(w.index.items())
if mf.mk.GROUP_OF.get(tid) == "로직"
for r in rows.values()
]
def _export(key: str) -> dict:
w = _whole()
return meq.export(w, key, meq.given_of(w, w.logic(key), None))
def _closes(eq: dict) -> None:
sub = eq["소계"]
for k in COSTS:
got = sum((r[k] for r in sub["줄"]), D(0)) + sub["끝수"][k]
assert got == eq["합계"][k], (eq["열쇠"], k, got, eq["합계"][k])
def test_굴착기_블록_한_줄_끝수():
eq = _export("GF000089")
rows = eq["소계"]["줄"]
assert [r["갈래"] for r in rows] == ["블록"] and rows[0]["이름"] == "굴착기(무한궤도) 0.7㎥"
w = _whole() # 블록 한 줄 = 엔진 줄 끝수 값(단가 갱신에 안 묶음)
got = mcut.engine(
w, "GF000089", mf.run(w, "GF000089", meq.given_of(w, w.logic("GF000089"), None))
)
assert all(rows[0][k] == got["줄"][0]["비목"].get(k, D(0)) for k in COSTS[:3])
assert eq["합계"]["계"] == got["계"] and eq["소계"]["끝수"]["계"] <= 0
_closes(eq)
def test_거푸집_자원_덧줄_지게_자원():
eq = _export("GC000211")
assert [r["갈래"] for r in eq["소계"]["줄"]] == ["직접"] # 801-3 직접 줄 한 묶음
_closes(eq)
eq = _export("GC001140")
assert [r["갈래"] for r in eq["소계"]["줄"]] == ["직접"]
_closes(eq)
def test_표본_합계는_엔진_끝수_그대로():
w = _whole()
keys = [x["키"] for x in _logics() if x.get("호표")][::25]
assert keys, "표본 없음"
seen = 0
for key in keys:
try:
eq = _export(key)
except mf.FormulaError:
continue
if "소계" not in eq:
continue
seen += 1
_closes(eq)
raw = mf.run(w, key, meq.given_of(w, w.logic(key), None))
cut = mcut.engine(w, key, raw)
assert {k: eq["합계"][k] for k in COSTS} == {k: cut[k] for k in COSTS}, key
assert seen >= 10
def test_결과_로직은_소계_없음():
key = next(x["키"] for x in _logics() if "결과" in x)
assert "소계" not in _export(key)
def test_화면_부품이_서버_칸을_읽음():
ts = Path("ui_template/ui_template_equation_sum.ts").read_text(encoding="utf-8")
for name in ("노무비", "재료비", "경비", "끝수", "합계"):
assert name in ts
+5 -132
View File
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
"""PLAN 800-2 · 800-3 — 수식 탭 변수 정의 영역 · 바로 고침 · 새 기호 연결 (서버 몫 · 임시 쓰기 없음)."""
"""PLAN 800-2 · 800-3 — 새 기호 연결 후보(M01 문서 `candidates` · 서버 몫 · 임시 쓰기 없음).
옛 수식 탭(로직 줄 ↔ 수식 나무 · 바로 고침 · 묶음 · 화면 글)은 855-E 2-E4 에서 걷음.
"""
import json
import re
import sys
from pathlib import Path
@@ -10,140 +10,13 @@ ROOT = Path(__file__).resolve().parents[2]
sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")]
from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402
from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
KEY = "GC000211"
OFF = {"폼타이": "아님", "측압": "3t/㎡"}
ON = {"폼타이": "사용", "측압": "4t/㎡"}
def _read(key, inputs):
"""로직 줄 → 수식(살아 있는 `export_row` — M02 사본과 한 벌)."""
whole = store.loaded()[1]
return eq.export_row(whole, whole.logic(key), inputs)
def _preview(key, edits, inputs):
"""고침 미리 셈 — `edit_row` 검사 뒤 전 · 후 합계(저장 없음)."""
whole = store.loaded()[1]
row = whole.logic(key)
new, why = eq.edit_row(whole, row, edits)
if why:
return {"되나": False, "까닭": why}
try:
before = eq.meq.export(whole, key, eq._given(inputs))["합계"]
got = eq.export_row(whole, new, inputs)
except eq._ERR as e:
return {"되나": False, "까닭": [f"셈 막힘 — {e}"]}
return {"되나": True, "까닭": [], "수식": got, "전": before, "후": got["합계"]}
def _defs(inputs):
return _read(KEY, inputs)["정의"]
def _text(defs):
return json.dumps(defs, ensure_ascii=False)
def test_defs_merge_and_clean():
defs = _defs(OFF)
signs = [(d["기호"], d["위"], d["아래"]) for d in defs]
assert len(signs) == len(set(signs)), "같은 변수는 한 번만"
assert not re.search(r"[A-Z]{2}\d{6}", _text(defs)), "DB 열쇠 글 0"
assert all(
set(d) <= {"열쇠", "기호", "위", "아래", "이름", "갈래", "연결", "고침", "안씀"}
for d in defs
)
by = {
(d["이름"], d["갈래"]): d for d in defs
} # 800-1 기호가 생겨 중간 · 표 찾기는 다른 기호 = 다른 정의
sign = lambda d: (d["기호"], d["위"], d["아래"])
assert sign(by[("보통인부", "중간")]) != sign(by[("보통인부", "찾기")])
assert by[("사용횟수", "입력")]["연결"] == ["입력 — 옵션에서 고름"]
def test_unpicked_branches_hidden():
off, on = _text(_defs(OFF)), _text(_defs(ON))
for col in ("4t/㎡", "5t/㎡", "6t/㎡", "폼타이 소요량"):
assert col not in off
assert "칸 4t/㎡" in on and "칸 3t/㎡" not in on and "칸 5t/㎡" not in on
assert "측압" in on and "측압" not in off # 폼타이 아님이면 측압 갈래도 안 탐
def test_live_edit_preview_changes_total():
spot = {"할일": "식", "자리": "호표:0", "식": "형틀목공 × 2"}
got = _preview(KEY, [spot], OFF)
assert got["되나"] and got["후"]["계"] > got["전"]["계"]
def test_unknown_symbol_asks_link_then_links():
spot = {"할일": "식", "자리": "호표:0", "식": "형틀목공 × 2 + Z"}
got = _preview(KEY, [spot], OFF)
assert not got["되나"] and "모르는 기호 「Z」" in got["까닭"][0]
for link in (
{"갈래": "상수", "값": "0"},
{"갈래": "입력", "기본값": "0"},
{"갈래": "표", "표": "QC000431", "칸": "형틀목공", "조건": {"유형": "유형"}},
{"갈래": "요소", "요소": "LB000007"},
):
add = {"할일": "연결", "열쇠": "Z", "이름": "새값", **link}
got = _preview(KEY, [add, spot], OFF)
assert got["되나"], (link, got["까닭"])
assert any(d["기호"] == "Z" for d in got["수식"]["정의"])
def test_link_bad_input_blocked():
bad = [
{"갈래": "표", "표": "QC000431", "칸": "없는칸", "조건": {"유형": "유형"}},
{"갈래": "표", "표": "QC000431", "칸": "형틀목공", "조건": {}},
{"갈래": "요소", "요소": "GC000211"},
{"갈래": "상수", "값": "abc"},
]
for link in bad:
got = _preview(KEY, [{"할일": "연결", "열쇠": "Z", **link}], OFF)
assert not got["되나"], link
def test_drop_guard_and_unused_input():
got = _preview(KEY, [{"할일": "지움", "열쇠": "사용횟수"}], OFF)
assert not got["되나"] and "쓰는 곳" in got["까닭"][0]
add = {"할일": "연결", "열쇠": "Y", "갈래": "입력"}
got = _preview(KEY, [add], OFF)
unused = [d for d in got["수식"]["정의"] if d["기호"] == "Y"]
assert unused and unused[0].get("안씀")
assert _preview(KEY, [add, {"할일": "지움", "열쇠": "Y"}], OFF)["되나"]
def test_candidates():
whole = store.loaded()[1]
got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
assert got["후보"] and "조건" in got["후보"][0]
assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
assert doc.candidates({"갈래": "단가산출", "검색": "합판거푸집", "분류": ""})["후보"]
assert whole is not None
def test_groups_add_up_to_total():
"""800-4 — 묶음(블록 · 자원 · 덧줄) 소계 합 + 끝수 = 합계(비목마다) · 한 묶음 소계 = 노 + 재 + 경."""
for key in ("GF000089", "GC000211"):
eqn = _read(key, {})
sub, total = eqn["소계"], eqn["합계"]
for k in ("노무비", "재료비", "경비"):
got = sum(float(r[k]) for r in sub["줄"]) + float(sub["끝수"][k])
assert abs(got - float(total[k])) < 1e-6, (key, k)
assert all(
abs(float(r["계"]) - sum(float(r[k]) for k in ("노무비", "재료비", "경비"))) < 1e-6
for r in sub["줄"]
)
def test_screen_source_groups_and_inline_edit():
ui = ROOT / "ui_template"
sum_ts = (ui / "ui_template_equation_sum.ts").read_text(encoding="utf-8")
line_ts = (ui / "ui_template_equation_line.ts").read_text(encoding="utf-8")
assert "ORDER" in sum_ts and "ui-eq__grp" in sum_ts # 가 · 나 · 다 묶음
assert "o.after?.(line)" in line_ts # 블록 식 줄 바로 아래
assert "block-key" not in line_ts # 줄 곁 DB 열쇠 글 없음
assert "ui-eq__solve" not in line_ts and "ui-eq__step" not in line_ts # 풀이 · 줄 번호 걷음
@@ -1,48 +0,0 @@
"""800-5 기호 남은 한글.
① 호표 줄 금액 참조(`줄.`) 기호 = 수식 영역 · 정의 영역 같은 글(한글 0) ④ M01 전수 한글 기호(하위 로직 칩 제외) 0.
옛 사본 변수표 새로 쓰기 도구(②③ · `M02_Copy_Symbols`)는 한 번 쓰고 끝나 894 에서 걷음.
"""
from __future__ import annotations
import importlib
import re
from M01_MasterData import M01_MasterData_Store as m01
meq = importlib.import_module("master_equation")
HAN = re.compile(r"[가-힣]")
def _walk(tree, out: list) -> None:
if isinstance(tree, dict):
if tree.get("꼴") == "변수":
out.append(tree)
for v in tree.values():
_walk(v, out)
elif isinstance(tree, list):
for v in tree:
_walk(v, out)
def test_줄_참조_기호_같은_글_한글_0():
eq = meq.export(m01.loaded()[1], "GC000211")
refs = []
_walk(eq["줄"], refs)
refs = [v for v in refs if str(v["열쇠"]).startswith("줄.")]
assert refs and all(not HAN.search(v["기호"]) and v["기호"] == "C" for v in refs)
defs = {(d["기호"], d["아래"]): d for d in eq["정의"]}
for v in refs:
d = defs[(v["기호"], v["아래"])]
assert d["갈래"] == "요소" and not HAN.search(d["기호"])
assert any("호표 줄 금액" in c for d in defs.values() for c in d["연결"])
def test_M01_전수_정의_한글_기호는_하위_로직_칩뿐():
whole = m01.loaded()[1]
keys = [r["키"] for d in m01.loaded()[0].values() if d.get("그룹") == "로직" for r in d["줄"]]
for code in keys[::25]:
for d in meq.export(whole, str(code))["정의"]:
assert d["갈래"] == "블록" or not HAN.search(d["기호"]), (code, d["이름"])
-122
View File
@@ -1,122 +0,0 @@
"""801-3 수식 탭 소계 묶음(요구 662-3) 지킴 — 금액 셈은 그대로 · 묶음만 다시.
① 묶음 = 부른 단가산출(갈래 블록) 하나씩 + 직접 줄 한 묶음(갈래 직접) · 돈 없는 줄 = 묶음 아님 · 안쪽 말 0
② M01 전수 — 묶음 합 + 끝수 = 합계(엔진 비목 합 그대로) · 직접 묶음 하나뿐
(기본 = 호표 로직 키 차례 고르게 600 · 전수 = `AISLO_TEST_ALL=1`)
③ 부품 — 묶음 하나 = 머리 없음 · 계 / 둘 이상 = 머리 · 소계 / 단가산출 둘 이상 = 합계 · 안쪽 말 글 0
"""
from __future__ import annotations
import importlib
from decimal import Decimal as D
from pathlib import Path
from helper_test_all import spread
from M01_MasterData import M01_MasterData_Store as store
mf = importlib.import_module("master_formula")
meq = importlib.import_module("master_equation")
grp = importlib.import_module("master_equation_group")
COSTS = ("노무비", "재료비", "경비", "계")
BAD = ("자기", "자원", "덧줄", "블록") # 코드 안쪽 말 — 화면 글에 0
def _w():
return store.loaded()[1]
def _export(key: str) -> dict:
w = _w()
return meq.export(w, key, meq.given_of(w, w.logic(key), None))
def _row(kind, name, cost=(0, 0, 0), **more):
got = dict(zip(COSTS[:3], (D(x) for x in cost), strict=True))
return {"갈래": kind, "이름": name, **got, "계": sum(got.values(), D(0))} | more
def test_묶음_함수_하나뿐_직접_한_묶음():
got = grp.bundles(
[
_row("블록", "굴착기", (1, 2, 3)),
_row("블록", "쉬는 단가산출"), # 돈 0 = 묶음 아님
_row("자원", "보통인부", (5, 0, 0), 종류="인력"),
_row("자원", "시멘트", (0, 7, 0), 종류="재료"),
_row("덧줄", "공구손료", (0, 0, 1)),
]
)
assert [r["갈래"] for r in got["줄"]] == ["블록", "직접"]
assert got["줄"][0]["이름"] == "굴착기" and got["줄"][1]["이름"] == "인력 · 재료"
assert (got["줄"][1]["노무비"], got["줄"][1]["재료비"], got["줄"][1]["경비"]) == (5, 7, 1)
only = grp.bundles([_row("덧줄", "공구손료", (0, 0, 1))])["줄"]
assert [r["이름"] for r in only] == ["경비"] and not grp.bundles([_row("블록", "빈")])["줄"]
def test_M02_상태_줄():
got = grp.bundles(
[
_row("자원", "보통인부", (5, 0, 0), 상태="더함", 종류="인력"),
_row("자원", "형틀목공", (4, 0, 0), 상태="덮음", 원래=D(9), 종류="인력"),
_row("자원", "지운 줄", 상태="뺌", 종류="인력"),
_row("자원", "밖 줄", 합밖=True, 밖금액=D(8)),
]
)
assert [x["이름"] for x in got["줄"][0]["낱줄"]] == ["보통인부", "형틀목공"]
assert got["밖"] == [{"이름": "밖 줄", "밖금액": D(8)}] and got["줄"][0]["계"] == 9
def test_거푸집_한_묶음_굴착기_한_묶음():
eq = _export("GC000211")
assert [r["갈래"] for r in eq["소계"]["줄"]] == ["직접"]
assert eq["소계"]["줄"][0]["이름"] == "인력 · 재료"
eq = _export("GF000089")
rows = eq["소계"]["줄"]
assert [(r["갈래"], r["이름"]) for r in rows] == [("블록", "굴착기(무한궤도) 0.7㎥")]
assert eq["합계"]["계"] == rows[0]["계"] + eq["소계"]["끝수"]["계"] > 0 # 금액은 M01 값 따라감
def test_M01_전수_묶음_합_끝수_합계_안쪽_말_0():
w = _w()
many = seen = 0
keys = [
logic["키"]
for tid, rows in sorted(w.index.items())
if mf.mk.GROUP_OF.get(tid) == "로직"
for logic in rows.values()
if logic.get("호표")
]
for key in spread(keys, 600):
try:
eq = _export(key)
except mf.FormulaError:
continue
sub = eq.get("소계")
if not sub:
continue
seen += 1
lines = sub["줄"]
assert sum(r["갈래"] == "직접" for r in lines) <= 1, key
assert all(r["계"] != 0 for r in lines), key
for r in lines:
assert not any(b in r["이름"] for b in BAD), (key, r["이름"])
for k in COSTS:
got = sum((r[k] for r in lines), D(0)) + sub["끝수"][k]
assert got == eq["합계"][k], (key, k)
many += sum(r["갈래"] == "블록" for r in lines) >= 2
assert seen > 400 and many >= 10, (seen, many)
def test_부품_머리_소계_합계_규칙_안쪽_말_0():
ts = Path("ui_template/ui_template_equation_sum.ts").read_text(encoding="utf-8")
assert "sub.줄.length >= 2" in ts # 묶음 하나 = 머리 · 소계 없음
assert '"합계" : "계"' in ts and '=== "블록").length >= 2' in ts # 합계 = 단가산출 둘 이상
ui = "".join(
line
for line in ts.splitlines(keepends=True)
if not line.lstrip().startswith(("*", "/*", "//", "/**"))
)
for word in ("자기 자원", "덧줄", "KIND"):
assert word not in ui, word