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:
@@ -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
|
||||
@@ -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,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.
|
||||
"""
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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["이름"])
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user