feat(796-1): 수식 모델 — 엔진 로직 ↔ 수식 나무 양방향 · 변수 표 · 추가 · 삭제 · 이름 전파 · 검사 · M01 길
- scripts/master_equation.py: 로직 줄 → 그림용 나무(이름식 · 값식 · 분수 · 퍼센트 · 조건 · 블록) · 풀이 · 변수 표 · 원문 「여기서」 기호 후보 - scripts/master_equation_edit.py: 나무 · 키보드 한 줄 식 → 엔진 식 · 더함 · 지움(쓰는 곳 막음) · 이름 · 기호 · 첨자(변수표 칸 · 식 그대로) · 고친 중간 줄 표시 4 자리 · 검사 - M01 길 셋(/logic/equation · preview · save — 기존 /save · 개정확인) · M02 사본 이음 export_row · edit_row - _틀.md 로직 열 차례 끝 변수표 · 셈 값 바뀜 0(791-1 지문 같음) - 시험 test_796_1_formula_model.py 17 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,471 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""수식 고침 → 로직(PLAN 796-1 · 요구 657) — 나무 · 키보드 한 줄 식 → 엔진 식 · 변수 추가 · 삭제 ·
|
||||
이름 · 기호 · 첨자 바꿈 · 표시 자리 · 식 검사.
|
||||
|
||||
로직 줄(dict) 한 벌만 고침 — 저장은 부르는 쪽(M01 = `/save` · M02 사본 = 795-1 사본 길)이 함.
|
||||
고침 요청 `고침` = 목록 · 차례대로:
|
||||
{할일: 식, 자리: 중간:<열쇠> | 결과 | 호표:<n> | 덧줄:<n>, 식: 글 | 나무: 나무}
|
||||
{할일: 더함, 갈래: 입력 | 중간, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?, 설명?, 기본값?(입력),
|
||||
식(중간), 뒤?(중간 열쇠 · "" = 맨 위 · 없으면 끝)}
|
||||
{할일: 지움, 열쇠} — 쓰는 식이 있으면 막고 쓰는 곳 목록
|
||||
{할일: 변수, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?} — 식은 열쇠로 부르니 안 깨짐
|
||||
{할일: 표시, 열쇠, 표시: 0~6 | null}
|
||||
고친 중간 줄은 `표시` 없으면 `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_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 _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 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)
|
||||
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
|
||||
Reference in New Issue
Block a user