From 4c17c8ff13fb746d5f36c7ec3d76bccd791a3253 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 15:23:01 +0900 Subject: [PATCH] =?UTF-8?q?refactor(855-E=202-E4=20=E3=89=AF-3=20=E2=91=A4?= =?UTF-8?q?):=20=EC=98=9B=20=EC=88=98=EC=8B=9D=20=ED=83=AD=20=EB=AC=B4?= =?UTF-8?q?=EB=A6=AC=20=EC=A7=80=EC=9B=80=20=E2=80=94=20M01=20Equation=20?= =?UTF-8?q?=C2=B7=20Sangeun=5FFormula=20=C2=B7=20master=5Fequation=20?= =?UTF-8?q?=EB=8B=A4=EC=84=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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 --- M01_MasterData/M01_MasterData_Equation.py | 57 -- M02_MasterTemplete/M02_Sangeun_Copy.py | 2 +- M02_MasterTemplete/M02_Sangeun_Equation.py | 2 +- M02_MasterTemplete/M02_Sangeun_Formula.py | 205 ------- .../master_data/scripts/master_doc_trace.py | 2 +- .../master_data/scripts/master_equation.py | 522 ------------------ .../scripts/master_equation_edit.py | 503 ----------------- .../scripts/master_equation_group.py | 68 --- .../scripts/master_equation_link.py | 2 +- .../scripts/master_equation_sign.py | 99 ---- .../scripts/master_equation_view.py | 133 ----- .../master_data/scripts/master_symbol.py | 82 +-- .../tester/test_792_1_sangeun_formula.py | 35 +- resources/tester/test_796_1_formula_model.py | 309 ----------- resources/tester/test_799_1_subtotals.py | 100 ---- .../tester/test_800_2_equation_layout.py | 137 +---- resources/tester/test_800_5_copy_symbols.py | 48 -- resources/tester/test_801_3_groups.py | 122 ---- 18 files changed, 14 insertions(+), 2414 deletions(-) delete mode 100644 M01_MasterData/M01_MasterData_Equation.py delete mode 100644 M02_MasterTemplete/M02_Sangeun_Formula.py delete mode 100644 resources/master_data/scripts/master_equation.py delete mode 100644 resources/master_data/scripts/master_equation_edit.py delete mode 100644 resources/master_data/scripts/master_equation_group.py delete mode 100644 resources/master_data/scripts/master_equation_sign.py delete mode 100644 resources/master_data/scripts/master_equation_view.py delete mode 100644 resources/tester/test_796_1_formula_model.py delete mode 100644 resources/tester/test_799_1_subtotals.py delete mode 100644 resources/tester/test_800_5_copy_symbols.py delete mode 100644 resources/tester/test_801_3_groups.py diff --git a/M01_MasterData/M01_MasterData_Equation.py b/M01_MasterData/M01_MasterData_Equation.py deleted file mode 100644 index 2e67c9895..000000000 --- a/M01_MasterData/M01_MasterData_Equation.py +++ /dev/null @@ -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 diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index e907b108d..5f4e21e4c 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -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 diff --git a/M02_MasterTemplete/M02_Sangeun_Equation.py b/M02_MasterTemplete/M02_Sangeun_Equation.py index 82c6ee6a3..446e32dfa 100644 --- a/M02_MasterTemplete/M02_Sangeun_Equation.py +++ b/M02_MasterTemplete/M02_Sangeun_Equation.py @@ -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. """ diff --git a/M02_MasterTemplete/M02_Sangeun_Formula.py b/M02_MasterTemplete/M02_Sangeun_Formula.py deleted file mode 100644 index d8856562c..000000000 --- a/M02_MasterTemplete/M02_Sangeun_Formula.py +++ /dev/null @@ -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 []} diff --git a/resources/master_data/scripts/master_doc_trace.py b/resources/master_data/scripts/master_doc_trace.py index 7045c1942..d0b6a3d37 100644 --- a/resources/master_data/scripts/master_doc_trace.py +++ b/resources/master_data/scripts/master_doc_trace.py @@ -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 = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별") diff --git a/resources/master_data/scripts/master_equation.py b/resources/master_data/scripts/master_equation.py deleted file mode 100644 index 386a19c7f..000000000 --- a/resources/master_data/scripts/master_equation.py +++ /dev/null @@ -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 {}), - } diff --git a/resources/master_data/scripts/master_equation_edit.py b/resources/master_data/scripts/master_equation_edit.py deleted file mode 100644 index 2b35e6fe9..000000000 --- a/resources/master_data/scripts/master_equation_edit.py +++ /dev/null @@ -1,503 +0,0 @@ -# -*- coding: utf-8 -*- -"""수식 고침 → 로직(PLAN 796-1 · 요구 657) — 나무 · 키보드 한 줄 식 → 엔진 식 · 변수 추가 · 삭제 · -이름 · 기호 · 첨자 바꿈 · 표시 자리 · 식 검사. - -로직 줄(dict) 한 벌만 고침 — 저장은 부르는 쪽(M01 = `/save` · M02 사본 = 795-1 사본 길)이 함. -고침 요청 `고침` = 목록 · 차례대로: - {할일: 식, 자리: 중간:<열쇠> | 결과 | 호표: | 덧줄:, 식: 글 | 나무: 나무} - {할일: 더함, 갈래: 입력 | 중간, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?, 설명?, 기본값?(입력), - 식(중간), 뒤?(중간 열쇠 · "" = 맨 위 · 없으면 끝)} - {할일: 지움, 열쇠} — 쓰는 식이 있으면 막고 쓰는 곳 목록 - {할일: 변수, 열쇠, 이름?, 기호?, 위?, 아래?, 단위?} — 식은 열쇠로 부르니 안 깨짐 - {할일: 표시, 열쇠, 표시: 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 diff --git a/resources/master_data/scripts/master_equation_group.py b/resources/master_data/scripts/master_equation_group.py deleted file mode 100644 index 427f4c860..000000000 --- a/resources/master_data/scripts/master_equation_group.py +++ /dev/null @@ -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} diff --git a/resources/master_data/scripts/master_equation_link.py b/resources/master_data/scripts/master_equation_link.py index ed578c84b..7f8ebe0e0 100644 --- a/resources/master_data/scripts/master_equation_link.py +++ b/resources/master_data/scripts/master_equation_link.py @@ -8,7 +8,7 @@ 로직 {로직: 키, 인자?: {칸: 식}} → 중간 줄 「로직(키, 칸=식…)」 상수 {값: 수} → 중간 줄 수 후보 목록 = `candidates`(표 · 요소 · 로직) — 읽기만 · 값 · 열쇠는 이름 옆 보관용(화면은 이름만 보임). -셈 · 검사는 `master_equation_edit.apply` 가 한 벌로(여기는 글만 짓고 막을 것만 막음). +셈 · 검사는 수식 문서 계산기 몫(여기는 글만 짓고 막을 것만 막음). """ from __future__ import annotations diff --git a/resources/master_data/scripts/master_equation_sign.py b/resources/master_data/scripts/master_equation_sign.py deleted file mode 100644 index 503a8aa69..000000000 --- a/resources/master_data/scripts/master_equation_sign.py +++ /dev/null @@ -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 diff --git a/resources/master_data/scripts/master_equation_view.py b/resources/master_data/scripts/master_equation_view.py deleted file mode 100644 index 3027062f3..000000000 --- a/resources/master_data/scripts/master_equation_view.py +++ /dev/null @@ -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 diff --git a/resources/master_data/scripts/master_symbol.py b/resources/master_data/scripts/master_symbol.py index 9a69df121..4a1411a9c 100644 --- a/resources/master_data/scripts/master_symbol.py +++ b/resources/master_data/scripts/master_symbol.py @@ -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) diff --git a/resources/tester/test_792_1_sangeun_formula.py b/resources/tester/test_792_1_sangeun_formula.py index a1f56d227..28e1c2e28 100644 --- a/resources/tester/test_792_1_sangeun_formula.py +++ b/resources/tester/test_792_1_sangeun_formula.py @@ -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) diff --git a/resources/tester/test_796_1_formula_model.py b/resources/tester/test_796_1_formula_model.py deleted file mode 100644 index 298194f9f..000000000 --- a/resources/tester/test_796_1_formula_model.py +++ /dev/null @@ -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 diff --git a/resources/tester/test_799_1_subtotals.py b/resources/tester/test_799_1_subtotals.py deleted file mode 100644 index 41e29392e..000000000 --- a/resources/tester/test_799_1_subtotals.py +++ /dev/null @@ -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 diff --git a/resources/tester/test_800_2_equation_layout.py b/resources/tester/test_800_2_equation_layout.py index 079c35b7e..6957b61fd 100644 --- a/resources/tester/test_800_2_equation_layout.py +++ b/resources/tester/test_800_2_equation_layout.py @@ -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 # 풀이 · 줄 번호 걷음 diff --git a/resources/tester/test_800_5_copy_symbols.py b/resources/tester/test_800_5_copy_symbols.py deleted file mode 100644 index 9f48f0f89..000000000 --- a/resources/tester/test_800_5_copy_symbols.py +++ /dev/null @@ -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["이름"]) diff --git a/resources/tester/test_801_3_groups.py b/resources/tester/test_801_3_groups.py deleted file mode 100644 index 8d92722d4..000000000 --- a/resources/tester/test_801_3_groups.py +++ /dev/null @@ -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