refactor(855-E 2-E4 ㉯-4 ⑥): 옛 계산 엔진 몸 지움 — master_formula 무리 아홉 · 계산기 하나

- git rm(부르는 곳 0 다시 셈 — import · import_module 글 · getattr 별칭 cm.mf · store.mau · mtx 포함): master_formula · master_formula_check · master_formula_sum · master_text · master_text_item · master_sheet_line · master_gate · master_auto · master_copy(−2,625 줄)
- master_cut = down · row · sums 만(일위대가 반영 끝수 · TS 짝) — engine · settle · plain · _line · _sub · kept(손님 0) 지움 · 바탕 = master_base
- master_bundle = BUNDLES · BY_ITEM · BY_KIND · is_machine(M01 목록 묶음) — called · bundle · tag 지움 · master_combo = 조합 칸만(run 지움)
- check_master · check_master_body · compare_estx: import master_formula → master_base(바탕 이름만) · compare_estx 기계 · 일위대가 대조 = 수식 문서 셈(옛 mf.run · 로직 줄 고르기 덧붙임 걷음 · 일위대가 28 · 기계 207 건 그대로 나옴)
- M01 Store: 다시 내보냄 mau · mtx 지움(부르는 곳 0) · cm.mf = master_base
- 죽은 주석: master_material · master_pick · master_base · Item_Prices · San_Emit · check_master
- test_855_sk_layers: 옛 엔진 안 돎 = 엔진 모듈 없음 확인
- 검증: 관련 146 파일 1,135 통과 · test_855_golden 전수 지문 같음 · 모든 제품 · scripts 모듈 읽기 깨짐 0 · typecheck 0 · 8008 health 200 · 로그 오류 0 · 서버 길 469 → 469

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 16:02:20 +09:00
co-authored by Claude Opus 5.5
parent 4c17c8ff13
commit dd8759edc5
22 changed files with 48 additions and 2931 deletions
-2
View File
@@ -19,10 +19,8 @@ SCRIPTS = Path(__file__).resolve().parents[1] / "resources/master_data/scripts"
sys.path.insert(0, str(SCRIPTS))
import check_master as cm # noqa: E402
import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀)
import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀)
import master_keys as mk # noqa: E402
import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀)
from M01_MasterData import M01_MasterData_Store_Cache as cache # noqa: E402
from M01_MasterData.M01_MasterData_Store_Find import hit as _hit # noqa: E402
+1 -1
View File
@@ -10,7 +10,7 @@
일위대가 자재(MT · 39-1c)도 그 줄(+ 준용 · 연결)을 담음.
`단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_formula.Master` 가
`단가.json` = `{파일 이름: {그룹 · 머리 칸 …, 줄|표: [줄]}}` — `master_base.Master` 가
그대로 읽는 꼴.
계산(`calc`)은 이 묶음과 `입력값.json` · `고른자재.json` · `면적.json`(알약 칸 값) 만 씀 — 마스터
현재값을 읽지 않음. 셈은 층 일위대가 셈 한 벌(`M02_Labor_Doc.calc` · 142-1 · 빈 입력 = 자동값).
+2 -2
View File
@@ -1,8 +1,8 @@
"""경쟁사 산근 → 우리 엔진 로직 줄 꼴 내보내기(PLAN 793-2a · 요구서_652 · eval 없음).
793-1 줄 나무(`M02_San_Stmate`) → `{로직, 원본}`(EST = 원파일 · 엑셀 둘 다 `M02_Doc_NativeEst` · 812-1) — 꼴 = 793-2 가져온 식 SK
만들기 몸(`M02_Sangeun_Imported.py` 머리) · 로직 = `_틀.md` 7 장 꼴(셈 = `master_formula.run` →
`master_cut.engine` · `요소` 는 SK 서버가 채움).
만들기 몸(`M02_Sangeun_Imported.py` 머리) · 로직 = `_틀.md` 7 장 꼴(셈 = 불러온 그대로 수식 문서 ·
`M02_Doc_Import` · `요소` 는 SK 서버가 채움).
- 로직 = {이름, 결과단위, 입력 [], 중간 [{이름, 식, 표시?}], 호표,
덧줄 [{이름, 식, 비목, 번지?, 합밖?, 자리?}], 단계? [{이름, 단, 줄, 제외?}], 끝전, 조정?} ·
STmate 변수 = 식(다시 대입 = `이름_2`) · EST 변수 = 얼린 값 · EST 는 블록 성분을 낸 줄만 합
@@ -31,7 +31,7 @@ import master_basis as mbs # noqa: E402
import master_combo as mcb # noqa: E402
import master_doc_block as mb # noqa: E402
import master_doc_link as ml # noqa: E402
import master_formula as mf # noqa: E402
import master_base as mf # noqa: E402
import master_keys as mk # noqa: E402
import master_machine_crew as mcrew # noqa: E402
import master_machine_files as mmf # noqa: E402
@@ -426,7 +426,7 @@ def check_docs(files: dict[str, dict], whole: mf.Master, book: dict | None = Non
def duplicate_keys(files: dict[str, dict], book: dict | None = None) -> list[str]:
"""키 겹침(전체) · 원문번호 겹침(인력·재료 — 번호가 곧 그 줄의 이름) · 대장 대조.
표·로직·기계의 원문번호는 절 번호·분류번호라 한 절에 여럿이 겹쳐도 됨
(겹친 번호를 「ID:원문번호」 로 부르면 `master_formula` 가 잡음)."""
(겹친 번호를 「ID:원문번호」 로 부르면 `master_base.Master` 가 잡음)."""
book = mk.load_book() if book is None else book
first, numbers, out = {}, {}, []
for name, data in files.items():
@@ -17,7 +17,7 @@ COST = ROOT / "resources/knowledge/original/원가계산"
sys.path.insert(0, str(HERE))
sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline"))
import master_formula as mf # noqa: E402
import master_base as mf # noqa: E402
from pum_md_tool import _NUM, md_lines # noqa: E402
DIVISIONS = {
+22 -23
View File
@@ -17,7 +17,9 @@ from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent))
import check_master as cm # noqa: E402
import master_formula as mf # noqa: E402
import master_base as mf # noqa: E402
import master_doc_calc as mc # noqa: E402
import master_doc_link as ml # noqa: E402
ROOT = Path(__file__).resolve().parents[3]
ESTX = ROOT / "resources/knowledge/original/경쟁사 프로그램/EST Plus 2/다산소프트/2026-07-main.estx"
@@ -244,23 +246,19 @@ def mach_key(name, size) -> str:
return norm(n) + "|" + size
def _names(doc: dict) -> set[str]:
return {str(v.get("열쇠")) for v in doc.get("변수") or []}
def machine_cost(master: mf.Master, mid: str, region="전국평균"):
"""로직으로 계산 — 고르기 밖 기계는 메모리에서만 고르기에 더함."""
"""수식 문서로 계산(옛 엔진 = 855-E 2-E4 걷음) — 목록 밖 기계도 원문번호로 받음."""
docs = ml.load_all()
links = ml.Links(master, docs)
for key in LOGICS:
row = master.logic(key)
spec = next(i for i in row["입력"] if i["이름"] == "기계")
added = mid not in spec["고르기"]
if added:
spec["고르기"].append(mid)
try:
given = {"기계": mid, "지역": region}
given = {k: v for k, v in given.items() if any(i["이름"] == k for i in row["입력"])}
return key, mf.run(master, key, given)
except (mf.FormulaError, ArithmeticError, KeyError, TypeError):
continue
finally:
if added:
spec["고르기"].remove(mid)
given = {k: v for k, v in {"기계": mid, "지역": region}.items() if k in _names(docs[key])}
res = mc.calc(docs[key], links, given)
if res.get("셈됨"):
return key, res
return None, None
@@ -449,15 +447,16 @@ def unit_price(estx: Estx, master: mf.Master):
h = heads[code]
k = Decimal(scale[0]) if scale else Decimal(1)
temp, put = with_estx_materials(master, estx, code)
row = temp.logic(key)
given = {k: v for k, v in given.items() if any(i["이름"] == k for i in row.get("입력", []))}
docs = ml.load_all()
row = docs[key] # 수식 문서(옛 엔진 = 855-E 2-E4 걷음)
given = {k: v for k, v in given.items() if k in _names(row)}
given = {k: Decimal(str(v)) if isinstance(v, (int, float)) else v for k, v in given.items()}
try:
res = mf.run(temp, key, given)
res = {c: res[c] * k for c in ("계", *mf.COST_ITEMS)}
except (mf.FormulaError, ArithmeticError, KeyError, TypeError) as e:
print(f" {code} {h['Name']} {h.get('Size')} | {key} | 멈춤: {str(e)[:120]}")
res = mc.calc(row, ml.Links(temp, docs), given)
if not res.get("셈됨"):
why = res.get("까닭") or res.get("표지")
print(f" {code} {h['Name']} {h.get('Size')} | {key} | 멈춤: {str(why)[:120]}")
continue
res = {c: res[c] * k for c in ("계", *mf.COST_ITEMS)}
r = rate(h["TC"], res["계"])
rates.append(r)
print(
@@ -1,152 +0,0 @@
# -*- coding: utf-8 -*-
"""견본 입력 — 마스터 화면 보기용 자동값(프로젝트 기본값 아님 · 저장 안 함).
고르기 = 목록 첫째 · 범위 = 최솟값 · 찾기 조건 값으로 쓰이는 수 = 그 표 그 칸 가장 낮은 줄 값
(범위 줄이면 그 줄에 드는 아래 끝) · 나누는 자리에 오는 수 = 1 · 그 밖 0
(「만약(X > 0, X, 기본)」 의 X 는 나누는 자리여도 0 = 기본).
찾기·나누기 쓰임은 로직 식(중간 · 결과 · 호표 수량·요소 · 덧줄)을 풀어 알아냄.
"""
from __future__ import annotations
import re
from decimal import Decimal
import master_formula as mf
def _texts(row: dict):
for step in row.get("중간", []):
yield step["식"]
if "결과" in row:
yield row["결과"]["식"]
for item in row.get("호표", []):
yield item["수량"]
if isinstance(item.get("요소"), str):
yield item["요소"]
for extra in row.get("덧줄", []):
yield extra["식"]
def _names(node) -> set:
return {part[1] for part in mf.walk(node) if part[0] == "name"}
def _uses(row: dict) -> tuple[dict, set]:
"""(찾기 조건 값으로 바로 쓰인 이름 → [(표, 조건)], 나누는 자리에 든 이름)
— 나누는 자리에 든 중간의 식에 쓰인 이름도 나누는 자리로 봄."""
finds, divs = {}, set()
for text in _texts(row):
try:
node = mf.parse(text)
except mf.FormulaError:
continue
for part in mf.walk(node):
if part[0] == "bin" and part[1] == "/":
divs |= _names(part[3])
if part[0] == "find":
for cond, arg in part[2]:
if arg[0] == "name":
finds.setdefault(arg[1], []).append((part[1], cond))
guard = guards(row) # 「0 = 기본」 칸은 나누는 자리로 안 퍼뜨림(자동값 0 = 기본)
for step in reversed(row.get("중간", [])):
if step["이름"] in divs:
divs |= _names(mf.parse(step["식"])) - guard
return finds, divs
_GUARD = re.compile(r"만약\(\s*(\w+)\s*>\s*0\s*,\s*\1\s*,")
def guards(row: dict) -> set:
"""「만약(X > 0, X, 기본)」 꼴 중간 식의 X — 0 이면 원문 기본(25㎏ · 450분 · 식 · 표)."""
return {m for s in row.get("중간", []) for m in _GUARD.findall(s["식"])}
def _fits(master: mf.Master, ref: str, cond: str) -> list:
"""표 `ref` 조건 칸 `cond` 에 드는 수 — 낮은 차례 · 범위 칸이면 줄마다 그 줄에 드는 끝
(아래 끝이 열린 줄 「60 미만」 은 0)."""
try:
table = master.get(ref)
except mf.FormulaError:
return []
ranged = table.get("조건", {}).get(cond) == "범위"
out = set()
for r in table.get("줄", []):
if r.get(cond) is None: # 빈 조건 칸은 무엇이든 맞음 — 값을 정하지 않음
continue
low, high = r[cond] if ranged else (r[cond], None)
ends = [Decimal(0) if low is None else low, high]
out |= {v for v in ends if isinstance(v, Decimal) and mf._match(table, r, cond, v)}
return sorted(out)
def _lowest(master: mf.Master, uses: list):
"""찾기 여럿이 같은 입력을 쓰면 모든 표에 드는 가장 낮은 수 · 없으면 첫 표의 가장 낮은 수."""
sets = [_fits(master, ref, cond) for ref, cond in uses]
both = sorted(set.intersection(*map(set, sets))) if sets else []
return (both or next((s for s in sets if s), [None]))[0]
def _first_row(master: mf.Master, uses: list):
"""찾기 조건 칸의 표 첫 줄 값 — 범위 줄이면 아래 끝(열린 아래 끝 = 위 끝) · 빈 칸 줄은 건넘."""
for ref, cond in uses:
try:
rows = master.get(ref).get("줄", [])
except mf.FormulaError:
continue
for r in rows:
got = r.get(cond)
if isinstance(got, list):
got = next((v for v in got if v is not None), None)
if got is not None:
return got
return None
def _holds_zero(span) -> bool:
low, high = span[0], span[1]
return (low is None or Decimal(str(low)) <= 0) and (high is None or Decimal(str(high)) >= 0)
def defaults(master: mf.Master, row: dict) -> dict:
"""「기본」 제안(PLAN 785-2 · 639-1a) — 「기본」 칸 › 고르기 첫째 › 가드 0 › 0 을 품은 범위 0 ›
찾기 조건 표 첫 줄 › None(못 정함 = 사용자 입력). 1 을 지어 넣지 않음 · `values` 와 따로."""
specs = mf.inputs_of(row) if isinstance(row.get("흐름"), dict) else row.get("입력", [])
finds = {} if isinstance(row.get("흐름"), dict) else _uses(row)[0]
guard = guards(row)
out = {}
for spec in specs:
name, span = spec["이름"], spec.get("범위")
if spec.get("기본") not in (None, ""):
out[name] = spec["기본"]
elif spec.get("고르기"):
out[name] = spec["고르기"][0]
elif name in guard:
out[name] = Decimal(0)
elif span and _holds_zero(span):
out[name] = Decimal(0)
else:
out[name] = _first_row(master, finds.get(name, []))
return out
def values(master: mf.Master, row: dict) -> dict:
"""로직 줄 하나의 입력마다 자동값 · 흐름 로직은 「설계 때 정할 것」 예시값."""
if isinstance(row.get("흐름"), dict):
return {s["이름"]: s.get("예시") for s in mf.inputs_of(row)}
finds, divs = _uses(row)
out = {}
for spec in row.get("입력", []):
name = spec["이름"]
if spec.get("고르기"):
out[name] = spec["고르기"][0]
elif spec.get("범위"):
out[name] = spec["범위"][0]
else:
got = _lowest(master, finds.get(name, []))
if got is None and "원" in str(spec.get("단위") or ""):
out[name] = None # 가격 입력 — 0 원처럼 보이지 않게 비워 둠
else:
out[name] = got if got is not None else Decimal(1 if name in divs else 0)
return out
+2 -2
View File
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
수식 문서 계산기(`master_doc_*`) · 불러오기 · 서고 · M01 · M02 가 같이 씀(옛 엔진 `master_formula` 는
855-E 2-E4 에서 지움 — 이 이름들의 자리).
"""
from __future__ import annotations
+2 -38
View File
@@ -3,20 +3,15 @@
규칙 한 줄:
- 호표 · 덧줄 = `비목` 따라(노무비 → 인력 · 재료비 → 재료 · 경비 → 경비).
- 비목 없는 로직 줄 = 부르는 로직이 기계경비(`is_machine`)면 경비 + `장비` · 아니면 하위.
두 줄 모두 엔진 줄 `비목` 에 노무비 · 재료비 · 경비 세 몫이 그대로 남음(한 줄 · 흩어 넣기 둘 다).
- 부르는 문서가 기계경비(`is_machine`)면 경비 · 아니면 하위(M01 목록 묶음 셈 `M01_MasterData_Store_List`).
기계경비 판별 = `is_machine` 한 곳 — M01 엔진 · M02 엑셀 맞춤(`M02_Hopyo_Ours`) ·
B09 산근(`B09_Estimation_Sangeun` · `_Text`)이 같이 씀.
엔진 줄 덧칸 = `묶음`(출력 꼬리표만 · 입력 값 덧칸 `값묶음` 은 715-1b 몫) · 기계경비 줄 `장비` true.
기계경비 판별 = `is_machine` 한 곳. 옛 엔진 줄 꼬리표(`called` · `bundle` · `tag`)는 855-E 2-E4 에서 걷음.
"""
from __future__ import annotations
import re
import master_formula as mf
BUNDLES = ("인력", "재료", "경비", "하위")
BY_ITEM = {"노무비": "인력", "재료비": "재료", "경비": "경비"}
BY_KIND = {"인력": "인력", "재료": "재료", "기계": "경비"} # 비목 빈 옛 줄 받침
@@ -27,34 +22,3 @@ def is_machine(row: dict | None) -> bool:
if not row or "결과" in row or isinstance(row.get("흐름"), dict):
return False
return re.sub(r"\s", "", str(row.get("결과단위") or "")) == "원/시간"
def called(master, item: dict, env: dict | None = None) -> dict | None:
"""로직 줄이 부르는 로직 줄(정본) — 못 찾으면 None."""
try:
node = mf.parse(item.get("요소") or "")
if not node or node[0] != "logic":
return None
key = mf.fill(node[1], env) if env is not None and "{" in node[1] else node[1]
return master.logic(key)
except (mf.FormulaError, mf.EmptyInput, KeyError, TypeError):
return None
def bundle(master, item: dict, env: dict | None = None) -> tuple[str, bool]:
"""줄 하나(호표 · 덧줄 정본 줄) → (묶음, 장비인가)."""
if item.get("비목") in BY_ITEM:
return BY_ITEM[item["비목"]], False
if item.get("종류") == "로직":
return ("경비", True) if is_machine(called(master, item, env)) else ("하위", False)
return BY_KIND.get(str(item.get("종류")), "하위"), False
def tag(master, row: dict, lines: list[dict], env: dict | None = None) -> list[dict]:
"""엔진 `run` 줄에 `묶음`(+ 기계경비 줄 `장비`) — 줄 차례 = 호표 줄 하나씩 뒤 덧줄 하나씩."""
for item, line in zip([*row.get("호표", []), *row.get("덧줄", [])], lines):
name, machine = bundle(master, item, env)
line["묶음"] = name
if machine:
line["장비"] = True
return lines
+1 -44
View File
@@ -2,16 +2,11 @@
"""일위대가 조합 — 단가산출 로직을 골라 담은 묶음 (`_틀.md` 10장 · 계약 `_화면_계약.md` 9장).
조합은 **담은 로직 목록만** 지님 — 수량 · 비율 · 계산은 두지 않음(프로젝트 몫).
미리 보기(`run`)는 담은 로직마다 그 자리에서 받은 입력값으로 값을 뽑아
비목별로 갈라 합침 — 저장하지 않음.
옛 엔진 미리 보기(`run`)는 855-E 2-E4 에서 걷음.
"""
from __future__ import annotations
from decimal import Decimal
import master_formula as mf
GROUP = "일위대가조합"
FILE = "일위대가조합.json"
TID = "UA"
@@ -63,41 +58,3 @@ def using(files: dict[str, dict], key: str) -> list[dict]:
# ── 미리 보기 ─────────────────────────────────────────────────────────
def run(master: mf.Master, row: dict, given: dict[str, dict] | None = None) -> dict:
"""담은 로직마다 그 자리의 입력값으로 값을 뽑아 비목별로 갈라 합침 — 저장하지 않음.
`given` = {로직 키: {입력 이름: 값}} · 못 도는 줄은 까닭을 적고 합계에서 뺌(통째로 멈추지 않음).
돈이 아닌 로직(결과 수 하나)은 비목이 없어 합계에 얹지 않고 결과만 보임.
"""
given = given or {}
sums = dict.fromkeys(mf.COST_ITEMS, Decimal(0))
lines, stuck = [], []
for at, one in enumerate(items(row), start=1):
key = str(one.get("로직") or "") if isinstance(one, dict) else ""
head = {"차례": at, "로직": key, "메모": one.get("메모") if isinstance(one, dict) else None}
try:
target = master.logic(key)
except mf.FormulaError as e:
lines.append({**head, "ok": False, "까닭": str(e)})
stuck.append(f"{key} · {e}")
continue
head.update(
{k: target.get(k) for k in ("이름", "원문번호", "결과단위", "구분", "상세구분", "출처")}
)
try:
import master_cut as mcut # 끝수(751-3) = 시험 계산(`check_master.calc`)과 같음
got = mcut.engine(master, key, mf.run(master, key, dict(given.get(key) or {})))
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
reason = str(e) or type(e).__name__
lines.append({**head, "ok": False, "까닭": reason})
stuck.append(f"{key} {target.get('이름')} · {reason}")
continue
if "결과" in got: # 돈 아닌 로직 — 비목이 없어 합계에 안 얹음
lines.append({**head, "ok": True, "갈래": "결과", "결과": got["결과"]})
continue
part = {k: got[k] for k in mf.COST_ITEMS}
for k, v in part.items():
sums[k] += v
lines.append({**head, "ok": True, "갈래": "돈", **part, "계": got["계"]})
return {"줄": lines, **sums, "계": sum(sums.values()), "멈춤": stuck}
@@ -1,435 +0,0 @@
# -*- coding: utf-8 -*-
"""정본 로직을 식 줄로 펴 보이고, 고친 식을 되돌려 자체 로직으로 저장 (PLAN 3-4).
규칙은 `resources/master_data/ref/_설계_식_복사.md` 그대로 —
`찾기(…)`·`로직(…)` 부르기 한 덩이를 이름 하나(별칭)로 바꿔 보이고 뒤에 원문을 둠.
별칭은 저장하지 않음(겉치레) — 되돌릴 때 별칭표의 원문으로 갈아 끼워 원래 식이 됨.
식 자르기는 `master_formula` 파서를 그대로 씀 — 정규식으로 괄호를 세지 않음.
"""
from __future__ import annotations
import copy
import re
import master_formula as mf
MAX_NAME = 12 # 짧은 이름의 길이 상한
MAX_WORD = 8 # 별칭 꼬리(찾은 줄 값) 한 낱말의 길이 상한
_DROP = re.compile(r"[^\w]", re.UNICODE) # 별칭에 못 쓰는 글자(빈칸 · 괄호 · 가운뎃점 …)
_SPACE = re.compile(r"\s+")
_PAREN = re.compile(r"\([^()]*\)")
_WORDS = re.compile(r"[\s·・,/:+×*~∼]+")
_QUOTED = re.compile(r"'[^']*'")
RESERVED = frozenset((*mf.FUNCS, *mf.COST_ITEMS, "찾기", "로직", "그리고", "또는", "계", "줄"))
# ── 부르기 자리 자르기 ─────────────────────────────────────────────────
class _Catch(mf._Parser):
"""식을 읽으면서 `찾기(…)`·`로직(…)` 한 덩이의 자리를 적어 둠(겹친 것 포함)."""
def __init__(self, text: str):
super().__init__(text)
self.spots: list[tuple[int, int, str, str]] = []
def primary(self):
self.ws()
at = self.i
node = super().primary()
if node[0] in ("find", "logic"):
self.spots.append((at, self.i, node[0], node[1]))
return node
def spots(text: str) -> list[tuple[int, int, str, str]]:
"""식 글 안 부르기 한 덩이 — (처음, 끝, 종류, 참조).
겹친 것은 바깥만 · 못 읽는 글은 빈 목록.
"""
try:
found = _Catch(str(text))
found.parse()
except (mf.FormulaError, RecursionError):
return []
out = [
one
for one in found.spots
if not any(o[0] <= one[0] and one[1] <= o[1] and o[:2] != one[:2] for o in found.spots)
]
return sorted(out)
def _holes(text: str) -> list[tuple[int, int]]:
"""별칭을 갈아 끼우면 안 되는 자리 — 이미 원문으로 적힌 부르기 안 · 작은따옴표 안."""
return [(s, e) for s, e, _, _ in spots(text)] + [
(m.start(), m.end()) for m in _QUOTED.finditer(text)
]
# ── 식이 든 자리 ───────────────────────────────────────────────────────
def slots(row: dict):
"""(자리표, 갈래, 차례, 칸 이름, 그 칸을 담은 묶음) — 번호 매기는 차례(호표 → 중간 → 덧줄)."""
for i, one in enumerate(row.get("호표") or []):
for col in ("수량", "요소"):
if isinstance(one.get(col), str):
yield f"호표[{i}].{col}", "호표", i, col, one
for i, one in enumerate(row.get("중간") or []):
if isinstance(one.get("식"), str):
yield f"중간[{i}].식", "중간", i, "식", one
for i, one in enumerate(row.get("덧줄") or []):
if isinstance(one.get("식"), str):
yield f"덧줄[{i}].식", "덧줄", i, "식", one
end = row.get("결과")
if isinstance(end, dict) and isinstance(end.get("식"), str):
yield "결과.식", "결과", 0, "식", end
def _taken(row: dict) -> set[str]:
"""이미 식에서 쓰는 이름 — 입력 · 중간 · 덧줄 · 비목 · 함수 이름."""
out = set(RESERVED)
for part in ("입력", "중간", "덧줄"):
for one in row.get(part) or []:
name = str(one.get("이름") or "")
if name:
out.add(name)
return out
# ── 별칭 짓기 ─────────────────────────────────────────────────────────
def plain(text) -> str:
"""이름에 쓸 수 있는 글자만 남김 — 별칭과 변수 이름이 같은 규칙을 씀."""
return _DROP.sub("", str(text or ""))
def _unparen(text: str, keep: bool) -> str:
"""괄호 묶음을 벗김 — `keep` 이면 숫자 없는 묶음(공기식 · 건설)만 글로 남김."""
while True:
got = _PAREN.sub(
lambda m: f" {m.group()[1:-1]} " if keep and not re.search(r"\d", m.group()) else " ",
text,
)
if got == text:
return got
text = got
def _core(text: str) -> list[str]:
"""앞 핵심 낱말 — 머리 번호(1급 · 5-3)는 건너뛰고, 그 뒤 숫자 든 낱말(규격)에서 끊음."""
out: list[str] = []
for word in _WORDS.split(text):
word = plain(word)
if not word:
continue
if re.search(r"\d", word):
if out:
break
continue
out.append(word)
return out
def _fit(words: list[str], cap: int) -> str:
"""낱말들을 이어 이름 하나로 — 길면 첫 낱말 + 끝 낱말 · 그래도 길면 첫 낱말을 자름."""
tries = ["".join(words), *([words[0] + words[-1], words[0][:cap]] if words else [])]
return next((one for one in tries if one and len(one) <= cap), "")
def short(text, cap: int = MAX_NAME) -> str:
"""사람이 읽는 짧은 이름 — 규격·코드를 떼고, 길면 괄호 속 · 가운데 낱말 순으로 버림.
늘 같은 글이면 같은 이름 · 글자 · 숫자 · 밑줄만 · 숫자로 시작하지 않음(못 지으면 빈 글)."""
text = str(text or "")
kept = "".join(_core(_unparen(text, True)))
return kept if kept and len(kept) <= cap else _fit(_core(_unparen(text, False)), cap)
def _base(ref: str, master) -> str:
"""별칭 밑이름 — 표·로직 이름을 짧게 · 이름이 없으면 공종 · 상세구분 · 그래도 없으면 키."""
try:
row = master.get(ref)
except mf.FormulaError:
row = {}
use = row.get("용도") if isinstance(row.get("용도"), dict) else {}
for text in (row.get("이름"), use.get("공종"), row.get("상세구분")):
got = short(text)
if got:
return got
return _DROP.sub("", ref) or "표"
def _words(node, master) -> list[str]:
"""부르기 인자 하나의 낱말 — 글은 그 값(요소 코드면 품명 + 규격) · 수 · 이름은 그대로."""
kind = node[0]
if kind == "name":
return [node[1]]
if kind == "num":
return [plain(node[1])]
if kind != "str": # 만약(…) 따위 — 안에 적힌 글 가운데 처음 읽히는 것
return next(filter(None, (_core(_unparen(one, False)) for one in _texts(node))), [])
for ref in (node[1], f"EQ:{node[1]}"): # 기계 입력은 원문번호(0201-0020)
try:
row = master.get(ref)
except mf.FormulaError:
continue
if row.get("이름"):
return [short(row["이름"]), *filter(None, [plain(row.get("규격"))])]
return _core(_unparen(str(node[1]), False)) or [plain(node[1])]
def _texts(node):
"""마디 안의 글 값(작은따옴표) — 적힌 차례로."""
if isinstance(node, tuple) and node[:1] == ("str",):
yield str(node[1])
elif isinstance(node, (tuple, list)):
for one in node:
yield from _texts(one)
def _columns(signs: list[str], refs: list[str], master) -> list[dict[str, str]]:
"""부르기마다 {칸: 꼬리 낱말} — 다른 표가 섞이면 표 제목도 한 칸(`""`).
한 칸 값들이 모두 가진 낱말(`구체콘크리트`)은 떼어 서로 가르는 낱말만 남김."""
rows: list[dict[str, list[str]]] = [{} for _ in signs]
if len(set(refs)) > 1:
for one, ref in zip(rows, refs):
try:
one[""] = _core(_unparen(str(master.get(ref).get("이름") or ""), False))
except mf.FormulaError:
one[""] = []
for one, sign in zip(rows, signs):
try:
args = mf.parse(sign)[2]
except (mf.FormulaError, IndexError, TypeError):
args = []
one.update({key: _words(value, master) for key, value in args})
out: list[dict[str, str]] = [{} for _ in signs]
for key in dict.fromkeys(key for one in rows for key in one):
lists = [one.get(key, []) for one in rows]
common = set.intersection(*map(set, lists))
if not all(set(words) - common for words in lists):
common = set()
for got, words in zip(out, lists):
got[key] = _fit([w for w in words if w not in common], MAX_WORD)
return out
def _tails(signs: list[str], refs: list[str], master) -> list[str]:
"""같은 밑이름의 부르기들 — 서로 가르는 인자 값만 이어 꼬리로(`철망` · `외업_고급기술자`).
가르는 칸은 적게 — 가장 잘 가르는 칸부터 모두 갈릴 때까지 고르고, 줄마다 없어도 되는 칸은 뺌."""
cols = _columns(signs, refs, master)
order = list(dict.fromkeys(key for one in cols for key in one))
def seen(one: dict, keys: list[str]) -> tuple:
return tuple(one.get(key, "") for key in keys)
picked: list[str] = []
left = list(order)
while len({seen(one, picked) for one in cols}) < len(cols) and left:
best = max(left, key=lambda key: len({seen(one, [*picked, key]) for one in cols}))
if len({seen(one, [*picked, best]) for one in cols}) == len(
{seen(o, picked) for o in cols}
):
break
picked.append(best)
left.remove(best)
out = []
for at, one in enumerate(cols):
mine = list(picked)
for key in reversed(picked): # 늦게 고른(덜 가르는) 칸부터 빼 봄
rest = [k for k in mine if k != key]
others = (seen(o, rest) for j, o in enumerate(cols) if j != at)
if not rest or seen(one, rest) in set(others):
break
mine = rest
out.append("_".join(filter(None, seen(one, sorted(mine, key=order.index)))))
return out
def _free(want: str, taken: set[str]) -> str:
name, at = want, 1
while name in taken:
at += 1
name = f"{want}_{at}"
taken.add(name)
return name
def aliases(row: dict, master) -> list[dict]:
"""부르기마다 별칭 하나 — 완전히 같은 부르기는 합치고, 갈리면 등장 차례로 번호."""
order: list[str] = []
seen: dict[str, tuple[str, str]] = {} # 서명 → (종류, 참조)
raw_of: dict[str, str] = {} # 서명 → 원문(처음 나온 글 그대로)
where_of: dict[str, list[str]] = {}
for where, _, _, col, box in slots(row):
text = box[col]
for start, end, kind, ref in spots(text):
raw = text[start:end]
sign = _SPACE.sub(" ", raw)
if sign not in seen:
order.append(sign)
seen[sign] = (kind, ref)
raw_of[sign] = raw
where_of.setdefault(sign, []).append(where)
bunch: dict[str, list[str]] = {}
for sign in order:
bunch.setdefault(_base(seen[sign][1], master), []).append(sign)
taken, name_of = _taken(row), {}
for kind, ref in seen.values(): # 표의 값 칸 이름과 헷갈리지 않게
if kind == "find":
taken |= set(_about(kind, ref, master)["값칸"])
for base, signs in bunch.items():
gap = "_" if base[-1:].isdigit() else "" # 키를 밑이름으로 쓴 자리 — 번호가 붙지 않게
tails = _tails(signs, [seen[s][1] for s in signs], master) if len(signs) > 1 else [""]
for at, (sign, tail) in enumerate(zip(signs, tails)):
alone = len(signs) == 1 or any(tails) # 꼬리 없는 하나는 밑이름만
want = f"{base}_{tail}" if tail else base if alone else f"{base}{gap}{at + 1}"
name_of[sign] = _free(want, taken)
out = []
for sign in order:
kind, ref = seen[sign]
out.append(
{
"이름": name_of[sign],
"종류": "찾기" if kind == "find" else "로직",
"참조": ref,
"원문": raw_of[sign],
**_about(kind, ref, master),
"자리": where_of[sign],
}
)
return out
def _about(kind: str, ref: str, master) -> dict:
"""모달에 보일 한 마디 — 표는 표 이름과 값 칸 · 로직은 로직 이름과 결과 단위."""
try:
row = master.get(ref)
except mf.FormulaError:
return {"밑이름": "", "값칸": {}, "결과단위": ""}
if kind == "find":
return {"밑이름": row.get("이름") or "", "값칸": row.get("값칸") or {}, "결과단위": ""}
return {"밑이름": row.get("이름") or "", "값칸": {}, "결과단위": row.get("결과단위") or ""}
# ── 펴기 · 되돌리기 ────────────────────────────────────────────────────
def names(marks: list[dict]) -> dict[str, str]:
"""별칭 목록 → {원문 서명: 별칭 이름} — 식 글을 별칭으로 갈아 끼울 때 씀."""
return {_SPACE.sub(" ", str(one["원문"])): str(one["이름"]) for one in marks}
def mask(text, name_of: dict[str, str]) -> str:
"""부르기 한 덩이를 별칭 이름으로 — `spread` 와 같은 규칙(다른 모듈도 씀)."""
return _mask(str(text), name_of)
def _mask(text: str, name_of: dict[str, str]) -> str:
"""부르기 한 덩이를 별칭 이름으로 — 뒤에서부터 갈아 끼움(자리가 밀리지 않게)."""
out = text
for start, end, _, _ in reversed(spots(text)):
name = name_of.get(_SPACE.sub(" ", text[start:end]))
if name:
out = out[:start] + name + out[end:]
return out
def _glued(text: str, m: re.Match) -> bool:
"""앞뒤가 낱말 글자면 다른 이름의 한 토막 · 점 뒤면 표의 값 칸 이름 — 갈아 끼우지 않음."""
side = text[m.start() - 1 : m.start()] + text[m.end() : m.end() + 1]
return any(ch.isalnum() or ch == "_" for ch in side) or text[: m.start()].rstrip().endswith(".")
def _unmask(text: str, raw_of: dict[str, str]) -> str:
"""별칭 이름을 원문 부르기로 — 이미 원문인 부르기 안과 따옴표 안은 안 건드림."""
if not raw_of:
return text
holes = _holes(text)
catch = re.compile("|".join(re.escape(n) for n in sorted(raw_of, key=len, reverse=True)))
out, at = [], 0
for m in catch.finditer(text):
if any(s <= m.start() and m.end() <= e for s, e in holes) or _glued(text, m):
continue
out.append(text[at : m.start()])
out.append(raw_of[m.group()])
at = m.end()
out.append(text[at:])
return "".join(out)
def spread(master, row: dict) -> dict:
"""로직 한 줄 → 별칭 꼴 식 묶음. `로직` = 식만 별칭으로 바뀐 줄 통째 · `별칭` 에 원문."""
marks = aliases(row, master)
name_of = names(marks)
shown = copy.deepcopy(row)
for _, _, _, col, box in slots(shown):
box[col] = _mask(box[col], name_of)
return {"로직": shown, "별칭": marks, "줄": lines(shown)}
def lines(row: dict) -> list[dict]:
"""화면에 쌓을 식 줄 — 읽는 차례(중간 → 호표 → 덧줄 → 결과)."""
out = []
for i, one in enumerate(row.get("중간") or []):
out.append(_line(f"중간[{i}].식", "중간", i, one, one.get("식")))
for i, one in enumerate(row.get("호표") or []):
got = _line(f"호표[{i}].수량", "호표", i, one, one.get("수량"))
out.append({**got, "종류": one.get("종류") or "", "요소": one.get("요소")})
for i, one in enumerate(row.get("덧줄") or []):
out.append(_line(f"덧줄[{i}].식", "덧줄", i, one, one.get("식")))
end = row.get("결과")
if isinstance(end, dict):
out.append(_line("결과.식", "결과", 0, end, end.get("식")))
return out
def _line(where: str, kind: str, at: int, one: dict, text) -> dict:
return {
"자리": where,
"갈래": kind,
"차례": at,
"이름": one.get("이름") or "",
"단위": one.get("단위") or "",
"비목": one.get("비목") or "",
"식": text,
"출처": one.get("출처") or "",
}
def gather(shown: dict, marks: list[dict]) -> dict:
"""별칭 꼴 식 묶음 → 저장할 로직 한 줄. 별칭 원문은 부르기 하나여야 함(아무 글이나 못 넣음).
사용자가 편집 중 별칭과 같은 이름의 입력·중간·덧줄을 새로 만들면(예: `메쌓기인력 = 1`)
그 뒤로는 식 글 속 그 이름이 사용자 것인지 별칭인지 가릴 수 없음(둘 다 같은 토큰) —
자동으로 별칭 쪽만 다시 이름 지어 피하려 하면 사용자가 실제로 쓴 자리를 건드릴 위험이
있어(화면 개입 없이는 안전하게 못 가림) 조용히 바꾸지 않고 저장을 막음.
"""
raw_of: dict[str, str] = {}
taken = _taken(shown) # 지금 입력·중간·덧줄에 실제로 있는 이름(사용자 것이 우선)
for one in marks or []:
name, raw = str(one.get("이름") or ""), str(one.get("원문") or "")
if not name or not raw:
raise mf.FormulaError("별칭에 「이름」 과 「원문」 이 있어야 함")
if mf.parse(raw)[0] not in ("find", "logic"):
raise mf.FormulaError(f"별칭 「{name}」 의 원문이 찾기·로직 부르기가 아님 — 「{raw}」")
if name in raw_of and raw_of[name] != raw:
raise mf.FormulaError(f"별칭 「{name}」 이 두 가지 원문을 가리킴")
if name in taken:
raise mf.FormulaError(
f"「{name}」 을 입력·중간·덧줄 이름으로도 쓰고 별칭으로도 씀 — "
"어느 쪽 식이 그 이름을 가리키는지 가릴 수 없음 · 이름을 바꿀 것"
)
raw_of[name] = raw
out = copy.deepcopy(shown)
for _, _, _, col, box in slots(out):
box[col] = _unmask(box[col], raw_of)
return out
def check(master, row: dict) -> list[str]:
"""펴고 그대로 되돌리면 원래 식으로 돌아오는지 — 어긋난 자리 글 목록(비면 됨)."""
view = spread(master, row)
again = gather(view["로직"], view["별칭"])
out = []
for (where, _, _, col, box), (_, _, _, _, was) in zip(slots(again), slots(row)):
if box[col] != was[col]:
out.append(f"{row.get('키')} {where} — 「{was[col]}」 → 「{box[col]}」")
return out
+7 -180
View File
@@ -3,16 +3,11 @@
(일위대가 금액란 0.1 원 · 계금 1 원 · 미만버림).
규칙 = B09 일위대가 · 산근과 같은 함수 `rounddown`(`B09_Estimation_Calc_Base` · 엑셀 ROUNDDOWN):
줄 금액 = 비목마다 ROUNDDOWN(·, 1) · 금액 = 그 합
하위 로직 줄(값묶음 없음) = 하위 로직도 같은 끝수로 다시 셈한 노 · 재 · 경 × 수량
덧줄 = 버린 줄 합(노무비 · 재료비 · 경비 · `줄.'이름'`)으로 식을 다시 셈 → ROUNDDOWN 1
비목 합 = ROUNDDOWN(Σ 줄, 0)(+ 로직 `끝수` 묶음) · 계 = 셋 합
엔진 줄 덧칸(단위 · 수량 · 단가 · 출처 · 까닭 · 묶음 · 옵션꺼짐 …) · 수량 · 품 자리는 그대로.
쓰는 곳 = M01 시험 계산(`check_master.calc`) · 읽는 식(`master_text.lines`) · M02 로직 줄
(`M02_Labor_Doc.run_line` — 단가산출 · 일위대가 · 펼침이 모두 거침) · 일위대가 반영(`row` · `sums` ·
TS 짝 `M02_MasterTemplete_Labor_Calc.ts` · 거울 시험 `test_m02_labor_calc_mirror.py`).
B09 는 제 단가로 다시 버리므로 엔진 날 값(`run_line(raw=True)`)을 받음.
ponytail: 흐름 로직 · 돈 결과 로직(결과 하나)은 끝수 없음 — 그 로직이 돈을 내면 여기에 더함.
반영 한 줄 = 비목마다 ROUNDDOWN(·, 1) · 계 = 셋 합 · 비목 합 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합.
쓰는 곳 = 일위대가 반영(`M02_Labor_Doc` · `M02_Labor_Fixed` · `M02_Labor_Expand` · TS 짝
`M02_MasterTemplete_Labor_Calc.ts` · 거울 시험 `test_m02_labor_calc_mirror.py`).
옛 엔진 답 끝수(`engine` · `settle` · `plain` · 줄 `자리`)는 855-E 2-E4 에서 걷음 — 단가산출 끝수 = 수식 문서
계산기(`master_doc_calc`).
"""
from __future__ import annotations
@@ -21,16 +16,14 @@ import sys
from decimal import Decimal
from pathlib import Path
import master_formula as mf
import master_formula_sum as ms
import master_base as mb
_ROOT = str(Path(__file__).resolve().parents[3])
if _ROOT not in sys.path: # 스크립트 · 시험 길 — 서버는 이미 뿌리에서 돎
sys.path.insert(0, _ROOT)
from B09_Estimation.B09_Estimation_Calc_Base import rounddown # noqa: E402
COSTS = mf.COST_ITEMS
_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
COSTS = mb.COST_ITEMS
def down(value, places: int):
@@ -40,49 +33,6 @@ def down(value, places: int):
return Decimal(str(rounddown(float(value), places)))
def _line(value, rule: dict | None):
"""줄 값 끝수 — 줄 `자리` {방법, 자리}(791-1) · 없으면 0.1 원 버림."""
if value is None or not rule:
return down(value, 1)
way, places = rule.get("방법"), int(rule.get("자리") or 0)
if way == "버림":
return down(value, places)
return mf._round(Decimal(str(value)), places, mf.ROUND_WAYS[way])
def _host(items: list[dict], n: int) -> int | None:
"""부착 호표(848-4 · `부착: true`) → 같은 묶음 앞쪽 주 기계 로직 줄 차례 · 아님 = None."""
item = items[n] if n < len(items) else {}
if not item.get("부착"):
return None
for j in range(n - 1, -1, -1):
x = items[j]
if not x.get("부착") and x.get("묶음") == item.get("묶음") and x.get("종류") == "로직":
return j
return None
def _joined(split: dict, rule, held: tuple) -> tuple[dict, Decimal | None]:
"""부착 줄 끝수 = 묶음 한 덩이(주 기계 줄 + 이 줄) 끝수 − 주 기계 줄 끝수(848-4 · 계산기와 같음)."""
h, h_rule = held
zero = Decimal(0)
cut = {
k: None
if v is None
else _line((h.get(k) or zero) + v, rule) - _line(h.get(k) or zero, h_rule)
for k, v in split.items()
}
kept = [v for v in cut.values() if v is not None]
return cut, (sum(kept, zero) if kept else None)
def _parts(split: dict, rule: dict | None = None) -> tuple[dict, Decimal | None]:
"""줄 비목 → (비목마다 0.1 원 버림 · 줄 `자리` 면 그것, 금액 = 그 합 · 모두 빈 = None)."""
cut = {k: _line(v, rule) for k, v in split.items()}
kept = [v for v in cut.values() if v is not None]
return cut, (sum(kept, Decimal(0)) if kept else None)
def row(money: dict | None) -> dict | None:
"""반영 한 줄 `{노무비, 재료비, 경비, 계}` — 비목마다 0.1 원 버림 · 계 = 셋 합."""
if money is None:
@@ -95,126 +45,3 @@ def sums(rows: list) -> dict:
"""비목 합 — 비목마다 ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합(빈 줄 = 뺌)."""
cut = {k: down(sum((Decimal(str(r[k])) for r in rows if r), Decimal(0)), 0) for k in COSTS}
return {**cut, "계": sum(cut.values(), Decimal(0))}
def _sub(master, item: dict, env: dict, depth: int) -> dict | None:
"""하위 로직 줄 노 · 재 · 경 — 같은 끝수로 다시 셈 · 로직 부르기가 아니거나 못 셈 = None."""
if item.get("값묶음") is not None or item.get("종류") != "로직":
return None
try:
node = mf.parse(item["요소"])
if node[0] != "logic":
return None
given = {k: mf.evaluate(v, env, master, depth) for k, v in node[2]}
ref = mf.fill(node[1], env)
got = engine(master, ref, mf.run(master, ref, given, depth + 1), depth + 1)
except _ERRORS:
return None
return None if "결과" in got else got
def engine(master, ref: str, got: dict, depth: int = 0) -> dict:
"""엔진 답(`mf.run` 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}`) → 끝수 입힌 답(새 묶음)."""
if "결과" in got or "줄" not in got:
return got
logic = master.logic(ref)
if isinstance(logic.get("흐름"), dict):
return got
items, adds = logic.get("호표") or [], logic.get("덧줄") or []
rules = [x.get("자리") for x in (*items, *adds)] # 줄 자리(791-1)
new = ms.uses(logic)
skip = ms.skipped(logic) if new else set()
env = dict(got.get("중간") or {})
total = dict.fromkeys(COSTS, Decimal(0))
lines, raws = [], {} # raws = 줄 차례 → (끝수 전 비목, 줄 자리) — 848-4 부착 줄 묶음 끝수
for n, line in enumerate(got["줄"]):
split, more = dict(line.get("비목") or {}), {}
if n == len(items): # 덧줄이 부르는 `줄.'이름'` = 버린 호표 줄 금액(엔진과 같이 한 번)
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
if n < len(items):
sub = _sub(master, items[n], env, depth) if line.get("수량") is not None else None
if sub is not None:
qty, one = line["수량"], items[n].get("비목")
split = {one: qty * sub["계"]} if one else {k: qty * sub[k] for k in COSTS}
more = {"단가": sub["계"]} # 하위 로직 계(1 원 버림) = 이 줄 단가
elif n - len(items) < len(adds) and line.get("금액") is not None:
add = adds[n - len(items)]
env.update(total)
if new: # 덧줄이 부르는 번지 · 단계 = 버린 줄로
env.update(ms.scope(logic, lines))
try:
value = mf.evaluate(mf.parse(add["식"]), env, master, depth)
except _ERRORS:
value = line["금액"]
env[add["이름"]] = _line(value, rules[n]) # 뒤 덧줄 · 중간 칸 = 버린 값
split = {add["비목"]: value}
rule = rules[n] if n < len(rules) else None
host = _host(items, n)
cut, money = _joined(split, rule, raws[host]) if host in raws else _parts(split, rule)
raws[n] = (split, rule)
for k, v in cut.items():
total[k] += 0 if n in skip else v or 0
if n >= len(items) and money is not None:
more = {"단가": money}
out = {"합밖": True} if n in skip else {} # 합계에 안 드는 줄 표지(796-2d · 보이기만)
lines.append({**line, "비목": cut, "금액": money, **more, **out})
if not new:
costs = {k: mf.cut(logic, down(v, 0), "계") for k, v in total.items()}
# 중간 = 덧줄이 본 값(버린 줄 합 · 덧줄 값 · `줄`) — 시험 계산 중간 칸
return {**got, "줄": lines, **costs, "계": sum(costs.values()), "중간": env}
costs = settle(logic, total)
more = {"단계": ms.steps(logic, lines), "셈법": ms.rule(logic)}
return {**got, "줄": lines, **costs, "계": sum(costs.values()), "중간": env, **more}
def settle(logic: dict, total: dict) -> dict:
"""블록 끝전(791-1) — `끝전` 비목버림(비목마다 원 버림 · 옛 규칙) · 큰나머지(계 원 버림 뒤
모자란 원을 소수 큰 비목부터 · 같으면 경 › 재 › 노) → 로직 `끝수` 묶음 → `조정` → 원 버림."""
costs = {k: down(v, 0) for k, v in total.items()}
if logic.get("끝전") == "큰나머지":
rest = int(down(sum(total.values()), 0) - sum(costs.values()))
order = sorted(COSTS, key=lambda k: (costs[k] - total[k], COSTS[::-1].index(k)))
for k in order[:rest]:
costs[k] += 1
costs = ms.adjust(logic, {k: mf.cut(logic, v, "계") for k, v in costs.items()})
return {k: down(v, 0) for k, v in costs.items()}
def kept(got: dict) -> dict:
"""`run_line` 이 엔진 답에서 그대로 넘기는 덧칸(792-3) — 단계 · 셈법."""
return {k: got[k] for k in ("단계", "셈법") if k in got}
def plain(got: dict, gone=()) -> dict:
"""로직 줄 답(`run_line` 꼴 `{기준, 줄, 재료}`)을 줄만 다시 버림 —
켜쌓기율 곱 · 별도계상 뺀 뒤(`gone` = 뺄 줄 차례) · 기준 = 남은 줄 비목 합 ROUNDDOWN 0 ·
답 `셈법`(791-1 새 의미 로직) = 줄 자리 · 합밖 · 단계 · 블록 끝전 · 조정 그대로(`settle`)."""
if not got.get("기준"):
return got
rule = got.get("셈법")
places = [x.get("자리") for x in ms.items(rule)] if rule else []
skip = set(gone) | (ms.skipped(rule) if rule else set())
def at(n):
return places[n] if isinstance(n, int) and 0 <= n < len(places) else None
lines, total = [], dict.fromkeys(COSTS, Decimal(0))
for n, line in enumerate(got.get("줄") or []):
cut, money = _parts(dict(line.get("비목") or {}), at(n))
for k, v in cut.items():
total[k] += 0 if n in skip else Decimal(str(v or 0))
lines.append({**line, "비목": cut, "금액": money})
mats = [{**m, "금액": _line(m.get("금액"), at(m.get("차례")))} for m in got.get("재료") or []]
kept = [x for n, x in enumerate(lines) if n not in gone]
if not rule:
base = {k: down(v, 0) for k, v in total.items()}
return {**got, "줄": kept, "재료": mats, "기준": {**base, "계": sum(base.values())}}
base = settle(rule, total)
steps = ms.steps(rule, [{} if n in gone else x for n, x in enumerate(lines)])
return {
**got,
"줄": kept,
"재료": mats,
"기준": {**base, "계": sum(base.values())},
"단계": steps,
}
@@ -1,525 +0,0 @@
# -*- coding: utf-8 -*-
"""마스터 로직 식 — 읽기 · 검사 · 시험 계산 (`_틀.md` 6~7장).
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
import itertools
import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
BUNDLE,
COST_ITEMS,
GROUPS,
TABLE_GROUPS,
TABLE_IDS,
EmptyInput,
FormulaError,
Master,
NoRow,
_match,
_name,
_plain,
find,
)
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
_HOLE = re.compile(r"\{([^{}]+)\}")
_OPS = ("<=", ">=", "==", "!=", "<", ">")
_ARITH = re.compile(r"[\d.\s+\-*/()]*\d[\d.\s+\-*/()]*") # 분수·식 값 칸(「1/1.30」)
CALC_FIELDS = ("중간", "호표", "결과", "덧줄") # 계산 칸
FLOW_GONE = "흐름도 로직은 걷음 — M01 시트로 다시 만듦" # 794-1b · 저장된 흐름 로직 0
def inputs_of(row: dict) -> list[dict]:
"""옛 흐름 로직(줄에 「흐름」) 입력 — 흐름도를 걷어 늘 못 셈."""
raise FormulaError(FLOW_GONE)
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
def __init__(self, why: str):
self.why = why
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
self.s, self.i = text, 0
def fail(self, why: str):
raise FormulaError(f"{why} — 「{self.s}」 {self.i}자")
def ws(self):
while self.i < len(self.s) and self.s[self.i].isspace():
self.i += 1
def peek(self, word: str) -> bool:
self.ws()
return self.s.startswith(word, self.i)
def take(self, word: str) -> bool:
if self.peek(word):
self.i += len(word)
return True
return False
def need(self, word: str):
if not self.take(word):
self.fail(f"「{word}」 없음")
def parse(self):
node = self.expr()
self.ws()
if self.i != len(self.s):
self.fail("식 끝에 남은 글자")
return node
def expr(self):
node = self.both()
while self.take("또는"):
node = ("bin", "또는", node, self.both())
return node
def both(self):
node = self.compare()
while self.take("그리고"):
node = ("bin", "그리고", node, self.compare())
return node
def compare(self):
node = self.add()
for op in _OPS:
if self.take(op):
return ("bin", op, node, self.add())
return node
def add(self):
node = self.mul()
while True:
if self.take("+"):
node = ("bin", "+", node, self.mul())
elif self.take("-"):
node = ("bin", "-", node, self.mul())
else:
return node
def mul(self):
node = self.unary()
while True:
if self.take("*"):
node = ("bin", "*", node, self.unary())
elif self.take("/"):
node = ("bin", "/", node, self.unary())
else:
return node
def unary(self):
if self.take("-"):
return ("neg", self.unary())
node = self.primary()
while self.take("."):
node = ("field", node, self.quoted() if self.take("'") else self.name())
return node
def quoted(self) -> str:
end = self.s.find("'", self.i)
if end < 0:
self.fail("작은따옴표 안 닫힘")
text, self.i = self.s[self.i : end], end + 1
return text
def name(self) -> str:
self.ws()
m = _NAME.match(self.s, self.i)
if not m:
self.fail("이름 없음")
self.i = m.end()
return m.group()
def ref(self, head: bool = False) -> str:
"""키·원문번호 글자 — 괄호 밖의 `,` · `)` · `.칸` · ` 연산자 ` 앞에서 멈춤(원문번호에 빈칸·괄호가 들어감).
head = 찾기·로직 머리 — `,` · `)` 에서만 멈춤."""
start, depth = self.i, 0
while self.i < len(self.s):
ch = self.s[self.i]
if ch in "({":
depth += 1
elif ch in ")}":
if depth == 0:
break
depth -= 1
elif depth == 0 and ch == ",":
break
elif head:
pass
elif depth == 0 and ch == "." and not self.s[self.i + 1 : self.i + 2].isdigit():
# 「K.P」「T.S」 처럼 영문자 사이 점은 원문번호 글자
around = self.s[self.i - 1 : self.i + 2 : 2]
if not (len(around) == 2 and around.isascii() and around.isalpha()):
break
elif depth == 0 and re.match(r"\s[-+*/<>=!]", self.s[self.i : self.i + 2]):
break
self.i += 1
return self.s[start : self.i].strip()
def args(self) -> list[tuple[str, object]]:
out = []
while self.take(","):
key = self.quoted() if self.take("'") else self.name()
self.need("=")
out.append((key, self.expr()))
self.need(")")
return out
def primary(self):
self.ws()
if self.take("("):
node = self.expr()
self.need(")")
return node
if self.take("'"):
end = self.s.find("'", self.i)
if end < 0:
self.fail("작은따옴표 안 닫힘")
text, self.i = self.s[self.i : end], end + 1
return ("str", text)
m = _NUMBER.match(self.s, self.i)
if m:
self.i = m.end()
return ("num", Decimal(m.group()))
word = self.name()
if word == "찾기":
self.need("(")
self.ws()
return ("find", self.ref(True), self.args())
if word == "로직":
self.need("(")
self.ws()
return ("logic", self.ref(True), self.args())
if word in FUNCS:
self.need("(")
items = [self.expr()]
while self.take(","):
items.append(self.expr())
self.need(")")
return ("call", word, items)
if mk.KEY.fullmatch(word):
return ("ref", word)
if word in mk.IDS and self.s.startswith(":", self.i): # ID:원문번호 — {이름} 낀 원문번호
self.i += 1
return ("ref", f"{word}:{self.ref()}")
return ("name", word)
def parse(text) -> tuple:
if isinstance(text, (int, float, Decimal)):
return ("num", Decimal(str(text)))
return _Parser(str(text)).parse()
def walk(node):
"""식 나무의 모든 마디."""
yield node
kind = node[0]
if kind == "bin":
yield from walk(node[2])
yield from walk(node[3])
elif kind in ("neg",):
yield from walk(node[1])
elif kind == "field":
yield from walk(node[1])
elif kind == "call":
for item in node[2]:
yield from walk(item)
elif kind in ("find", "logic"):
for _, item in node[2]:
yield from walk(item)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
raise FormulaError(f"원문번호의 {{{m.group(1)}}} 값 없음")
value = env[m.group(1)]
if isinstance(value, Blank):
raise EmptyInput(value.why)
return _plain(value)
return _HOLE.sub(one, template)
# ── 계산 ──────────────────────────────────────────────────────────────
def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
return node[1]
if kind == "name":
if node[1] not in env:
raise FormulaError(f"모르는 이름 「{node[1]}」")
if env[node[1]] is None:
raise EmptyInput(f"입력 「{node[1]}」 비어 있음")
if isinstance(env[node[1]], Blank):
raise EmptyInput(env[node[1]].why)
return env[node[1]]
if kind == "ref":
value = element(master, fill(node[1], env), env)[0]
if value is None:
raise FormulaError(f"「{master.label(fill(node[1], env))}」 값 없음 — 관리자가 채울 값")
if isinstance(value, list):
raise FormulaError(
f"「{master.label(fill(node[1], env))}」 값이 범위 — 입력으로 받아야 함"
)
return value
if kind == "field":
if node[1][0] == "find":
table = master.get(fill(node[1][1], env))
conds = {k: evaluate(v, env, master, depth) for k, v in node[1][2]}
base = find(table, conds, node[2])
else:
base = evaluate(node[1], env, master, depth)
if not isinstance(base, dict) or node[2] not in base:
raise FormulaError(f"칸 「{node[2]}」 없음")
value = base[node[2]]
if isinstance(value, list):
raise FormulaError(f"칸 「{node[2]}」 값이 범위 — 입력으로 받아야 함")
if isinstance(value, str) and _ARITH.fullmatch(value):
return evaluate(parse(value), env, master, depth)
return value
if kind == "neg":
return -evaluate(node[1], env, master, depth)
if kind == "bin":
op, a = node[1], evaluate(node[2], env, master, depth)
if op == "그리고":
return a and evaluate(node[3], env, master, depth)
if op == "또는":
return a or evaluate(node[3], env, master, depth)
b = evaluate(node[3], env, master, depth)
return {
"+": lambda: a + b,
"-": lambda: a - b,
"*": lambda: a * b,
"/": lambda: a / b,
"<": lambda: a < b,
"<=": lambda: a <= b,
">": lambda: a > b,
">=": lambda: a >= b,
"==": lambda: a == b,
"!=": lambda: a != b,
}[op]()
if kind == "call":
name, items = node[1], node[2]
if name == "만약":
test = evaluate(items[0], env, master, depth)
return evaluate(items[1] if test else items[2], env, master, depth)
values = [evaluate(x, env, master, depth) for x in items]
if name in ("최소", "최대"):
return (min if name == "최소" else max)(values)
mode = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP}[name]
return _round(values[0], values[1] if len(values) > 1 else 0, mode)
if kind == "find":
table = master.get(fill(node[1], env))
return find(table, {k: evaluate(v, env, master, depth) for k, v in node[2]})
if kind == "logic":
if depth > 20:
raise FormulaError("로직 부르기가 너무 깊음 — 돌고 도는 참조")
given = {k: evaluate(v, env, master, depth) for k, v in node[2]}
result = run(master, fill(node[1], env), given, depth + 1)
return result["결과"] if "결과" in result else {k: result[k] for k in BUNDLE}
raise FormulaError(f"모르는 마디 {kind}")
ROUND_WAYS = {"올림": ROUND_UP, "버림": ROUND_DOWN, "반올림": ROUND_HALF_UP}
ROUND_ON = ("계", "결과")
def cut(row: dict, value: Decimal, on: str) -> Decimal:
"""줄의 `끝수` 를 붙임 — 묶음 `{대상, 자리, 방법}` 만 · 글자 끝수는 원문 근거를 적은 설명."""
rule = row.get("끝수")
if not isinstance(rule, dict) or rule.get("대상") != on:
return value
way = ROUND_WAYS.get(str(rule.get("방법")))
if way is None:
raise FormulaError(f"「{_name(row)}」 끝수 방법 「{rule.get('방법')}」")
return _round(value, rule.get("자리") or 0, way)
def fill_empty(row: dict, given: dict) -> dict:
"""화면이 안 보낸 가격 입력(단위에 「원」)은 null 로 채움 — 빈 입력과 같이 그 줄만 비움."""
gap = {
s["이름"]: None
for s in row.get("입력", [])
if s["이름"] not in given and "원" in str(s.get("단위") or "")
}
return {**given, **gap}
def _inputs(row: dict, given: dict, master=None) -> dict:
env = {}
for spec in row.get("입력", []):
name = spec["이름"]
if name not in given:
raise FormulaError(f"「{_name(row)}」 입력 「{name}」 없음")
value = given[name]
if isinstance(value, str): # 화면이 글로 보낸 수 — 고르기 원래 값 · 아니면 수로
if "고르기" in spec:
value = next((o for o in spec["고르기"] if str(o) == value.strip()), value)
else:
try:
value = Decimal(value.strip())
except ArithmeticError:
pass
if isinstance(value, (int, float)):
value = Decimal(str(value))
value = mp.resolve(spec, value, master) # 기계 EQ 키 → 원문 분류번호
if "고르기" in spec and value not in spec["고르기"] and not mp.machine(spec, value, master):
raise FormulaError(f"입력 「{name}」={value} 고르기 밖")
if "범위" in spec:
low, high = spec["범위"]
if value is not None and not low <= value <= high:
raise FormulaError(f"입력 「{name}」={value} 범위 [{low}, {high}] 밖")
env[name] = value
unknown = set(given) - set(env)
if unknown:
raise FormulaError(f"「{_name(row)}」 모르는 입력 {sorted(unknown)}")
return env
def _shown(env: dict) -> dict:
"""돌려줄 중간값 — 못 구한 값은 null."""
return {k: None if isinstance(v, Blank) else v for k, v in env.items()}
def _blank_line(item: dict, why: str) -> dict:
"""비어 있는 입력·못 구한 값을 쓰는 호표 줄 — 단가·금액만 비우고 까닭."""
return {
"이름": item.get("이름", ""),
"단위": item.get("단위", ""),
"수량": None,
"단가": None,
"금액": None,
"비목": {item["비목"]: None} if "비목" in item else {},
"까닭": why,
}
def run(master: Master, ref: str, given: dict, depth: int = 0) -> dict:
"""로직 한 줄 계산 — 돈 로직은 호표 줄 · 비목 합 · 계, 돈 아닌 로직은 결과 수 하나."""
row = master.logic(ref)
if isinstance(row.get("흐름"), dict):
raise FormulaError(FLOW_GONE)
env = _inputs(row, given, master)
for step in row.get("중간", []):
try:
value = evaluate(parse(step["식"]), env, master, depth)
env[step["이름"]] = ms.shown(step, value) # `표시` 자리 반올림(791-1)
except EmptyInput as e: # 못 구한 중간값 — 쓰는 줄만 비움
env[step["이름"]] = Blank(str(e))
if "결과" in row:
value = evaluate(parse(row["결과"]["식"]), env, master, depth)
return {"결과": cut(row, value, "결과"), "중간": _shown(env)}
sums = dict.fromkeys(COST_ITEMS, Decimal(0))
lines = []
for n, item in enumerate(row.get("호표", [])):
source = why = extra = None
try:
qty = evaluate(parse(item["수량"]), env, master, depth)
except EmptyInput as e: # 비어 있는 입력을 쓰는 줄만 비움
lines.append(_blank_line(item, str(e)))
continue
if item["종류"] == "로직":
try:
bundle = mp.bundled(item, lambda: evaluate(parse(item["요소"]), env, master, depth))
except EmptyInput as e:
lines.append(_blank_line(item, str(e)))
continue
price = bundle["계"]
split = (
{k: qty * bundle[k] for k in COST_ITEMS}
if "비목" not in item
else {item["비목"]: qty * price}
)
else:
# 고르기 조건 묶음은 그대로 넘김 — `element` 가 대표 줄·첫 줄로 풂
# 조건 값의 `{입력}`(관경 등)도 채움 — 규격이 입력 따라 바뀌는 관 줄
try:
ref = (
{k: fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()}
if isinstance(item["요소"], dict)
else fill(item["요소"], env)
)
except EmptyInput as e:
lines.append(_blank_line(item, str(e)))
continue
# 후보 0 · 값 빈 품목은 그 줄만 단가·금액을 비우고 까닭을 닮 — 로직은 계속 · 합에서 뺌
# (없는 키는 틀린 로직 — 지금처럼 멈춤) · 검색어 · 고름 · 단위 환산은 `master_pick`
if isinstance(ref, str) and qty != 0:
master.get(ref)
price, source, why, extra = mp.priced(master, item, ref, env, n if depth == 0 else None)
if price is None and qty == 0:
price, why = Decimal(0), None # 안 쓰는 재료 줄 — 값이 비어도 금액 0
split = {item["비목"]: None if price is None else qty * price}
for k, v in split.items():
sums[k] += v or 0
lines.append(
{
"이름": item.get("이름", ""),
"단위": item.get("단위", ""),
"수량": qty,
"단가": price,
"금액": None if price is None else qty * price,
"비목": split,
**({"출처": source} if source else {}),
**({"까닭": why} if why else {}),
**(extra or {}),
}
)
# 덧줄 · 비목 합 끊기 · 번지 · 단계 · 조정(791-1) = `master_formula_sum.extras`
sums, more = ms.extras(master, row, lines, env, sums, depth)
mb.tag(master, row, lines, env) # 줄마다 인력 · 재료 · 경비 · 하위 묶음(712-1)
mg.tag(master, row, lines, env) # 옵션으로 빠진 줄 `옵션꺼짐`(753-1)
return {"줄": lines, **sums, "계": sum(sums.values()), "중간": _shown(env), **more}
# 품셈재료 단가 — 서로 부르는 모듈이라 끝에서 읽음
from master_material import ( # noqa: E402, F401
LINKED,
PICK_KEYS,
REGION,
SLOTS,
TARIFF,
candidates,
check_pick,
check_unit,
static,
cond_text,
element,
pick,
)
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
import master_bundle as mb # noqa: E402 — 인력 · 재료 · 경비 묶음
import master_gate as mg # noqa: E402 — 옵션으로 빠진 줄
import master_formula_sum as ms # noqa: E402 — 덧줄 · 번지 · 단계 · 조정 · 표시(791-1)
from master_formula_check import ( # noqa: E402, F401 — 검사는 나눈 파일 · 이름은 여기서 그대로
_check_cut,
_check_node,
_choices,
_expand,
check_logic,
find_loops,
)
@@ -1,237 +0,0 @@
# -*- coding: utf-8 -*-
"""마스터 로직 식 — 검사 (`master_formula` 에서 나눔 · 밖에서는 `master_formula` 로 부름).
`master_formula` 끝에서만 읽힘 — 먼저 읽으면 서로 부르다 막힘.
"""
from __future__ import annotations
import itertools
from decimal import Decimal
import master_formula_sum as ms
import master_keys as mk
import master_machine_crew as mcrew
from master_formula import (
_HOLE,
BUNDLE,
COST_ITEMS,
ROUND_ON,
ROUND_WAYS,
TABLE_IDS,
FormulaError,
fill,
parse,
walk,
)
from master_material import REGION, TARIFF, check_pick
# ── 검사 ──────────────────────────────────────────────────────────────
def _vals(row: dict):
"""줄 값 — 기계 = 인력 · 잡품 목록을 식이 읽는 칸으로(842-3 `master_machine_crew.view`)."""
value = row.get("값")
return mcrew.view(value) if str(row.get("키"))[:2] == "EQ" else value
def _choices(row: dict, name: str, master: Master):
"""이름이 가질 수 있는 값 — 고르기 입력, 또는 고르기 입력만 끼운 요소 칸인 중간. 모르면 None."""
for spec in row.get("입력", []):
if spec["이름"] == name:
return spec.get("고르기")
for step in row.get("중간", []):
if step["이름"] == name:
node = parse(step["식"])
if node[0] == "field" and node[1][0] == "ref":
out = set()
for ref in _expand(row, node[1][1], master) or []:
try:
out.add(str(_vals(master.get(ref))[node[2]]))
except (FormulaError, KeyError, TypeError):
pass
return sorted(out)
return None
def _expand(row: dict, template: str, master: Master):
"""원문번호 틀의 {이름} 을 고를 수 있는 값으로 모두 끼움 — 못 정하면 None."""
holes = _HOLE.findall(template)
options = [_choices(row, h, master) for h in holes]
if any(o is None for o in options):
return None
return [
fill(template, {h: v for h, v in zip(holes, combo)})
for combo in itertools.product(*options)
]
def _check_node(row, node, known: set, master: Master, where: str, out: list, calls: set):
for part in walk(node):
kind = part[0]
if kind == "name" and part[1] not in known:
out.append(f"{where} · 모르는 이름 「{part[1]}」")
if kind in ("ref", "find", "logic"):
for hole in _HOLE.findall(part[1]):
if hole not in known:
out.append(f"{where} · 원문번호 {{{hole}}} 가 입력·중간 아님")
if kind == "ref":
refs = _expand(row, part[1], master) or []
for ref in refs:
try:
link = master.get(ref).get("연결")
except FormulaError as e:
out.append(f"{where} · {e}")
continue
if isinstance(link, dict) and link.get("지역") == "입력" and REGION not in known:
out.append(f"{where} · 「{master.label(ref)}」 는 입력 「{REGION}」 필요")
if (
isinstance(link, dict)
and link.get("계약종별") == "입력"
and TARIFF not in known
):
out.append(f"{where} · 「{master.label(ref)}」 는 입력 「{TARIFF}」 필요")
if kind == "field" and part[1][0] == "ref":
for ref in _expand(row, part[1][1], master) or []:
try:
value = _vals(master.get(ref))
except FormulaError:
continue
if not isinstance(value, dict) or part[2] not in value:
out.append(f"{where} · 「{master.label(ref)}」 에 칸 「{part[2]}」 없음")
if kind == "find":
if mk.id_of(part[1]) not in TABLE_IDS:
out.append(f"{where} · 찾기 대상 「{part[1]}」 이 표 아님")
continue
try:
table = master.get(part[1])
except FormulaError as e:
out.append(f"{where} · {e}")
continue
for cond, _ in part[2]:
if cond not in table.get("조건", {}):
out.append(f"{where} · 「{master.label(part[1])}」 에 조건 「{cond}」 없음")
if kind == "field" and part[1][0] == "find":
try:
table = master.get(part[1][1])
except FormulaError:
continue
if part[2] not in table.get("값칸", {}):
out.append(f"{where} · 「{master.label(part[1][1])}」 에 값 칸 「{part[2]}」 없음")
if kind == "logic":
calls.add(part[1])
try:
target = master.logic(part[1])
except FormulaError as e:
out.append(f"{where} · {e}")
continue
names = {s["이름"] for s in target.get("입력", [])}
given = {k for k, _ in part[2]}
for extra in sorted(given - names):
out.append(f"{where} · 「{master.label(part[1])}」 에 입력 「{extra}」 없음")
for lack in sorted(names - given):
out.append(f"{where} · 「{master.label(part[1])}」 입력 「{lack}」 안 줌")
if kind == "field" and part[1][0] == "logic":
try:
target = master.logic(part[1][1])
except FormulaError:
continue
if "결과" in target:
out.append(
f"{where} · 돈 아닌 로직 「{master.label(part[1][1])}」 은 수 하나 — 칸 「{part[2]}」 못 씀"
)
elif part[2] not in BUNDLE:
out.append(f"{where} · 로직 결과 칸 「{part[2]}」 은 {BUNDLE} 가운데 하나여야 함")
def check_logic(master: Master, row: dict) -> tuple[list[str], set]:
"""(문제 목록, 부르는 로직 키) — 변수 · 찾기 조건 · 로직 입력."""
out, calls, key = [], set(), f"{row.get('키')} {row.get('원문번호')}"
known = {s["이름"] for s in row.get("입력", [])}
def one(text, where, names):
try:
_check_node(row, parse(text), names, master, where, out, calls)
except FormulaError as e:
out.append(f"{where} · 식 못 읽음: {e}")
for step in row.get("중간", []):
one(step["식"], f"{key} 중간 {step['이름']}", known)
known = known | {step["이름"]}
if "결과" in row:
one(row["결과"]["식"], f"{key} 결과", known)
for item in row.get("호표", []):
where = f"{key} 호표 {item.get('이름', '')}"
one(item["수량"], where + " 수량", known)
if item.get("종류") not in ("인력", "재료", "기계", "로직"):
out.append(f"{where} · 종류 「{item.get('종류')}」")
if item.get("비목") not in (*COST_ITEMS, None) or (
item.get("종류") != "로직" and "비목" not in item
):
out.append(f"{where} · 비목 「{item.get('비목')}」")
if isinstance(item["요소"], dict): # 재료 고르기 조건
if item.get("종류") != "재료":
out.append(f"{where} · 고르기 조건은 종류 「재료」 만")
# 조건 칸의 {이름} 은 계산 때 채워짐 — 그 이름이 실제 입력·중간인지만 봄
for value in item["요소"].values():
for hole in _HOLE.findall(value) if isinstance(value, str) else []:
if hole not in known:
out.append(f"{where} 요소 · 고르기 조건 {{{hole}}} 가 입력·중간 아님")
out += check_pick(master, where + " 요소", item["요소"])
continue
one(item["요소"], where + " 요소", known)
group = mk.GROUP_OF.get(mk.id_of(str(item["요소"])))
if item.get("종류") != "로직" and group != item.get("종류"):
out.append(f"{where} · 요소 그룹이 종류와 다름")
names = known | set(COST_ITEMS) | {"줄"} # 「줄」 = 호표 줄 금액 묶음(덧줄에서만)
if ms.uses(row): # 금액번지 · 소계 단계(791-1) — 덧줄에서만
names = names | {ms.ADDR, ms.STEP}
for extra in row.get("덧줄", []):
one(extra["식"], f"{key} 덧줄 {extra['이름']}", names)
names = names | {extra["이름"]}
if extra.get("비목") not in COST_ITEMS:
out.append(f"{key} 덧줄 {extra['이름']} · 비목 「{extra.get('비목')}」")
out += _check_cut(row, key) + ms.check(row, key)
return out, calls
def _check_cut(row: dict, key: str) -> list[str]:
"""끝수 — 묶음이면 칸·대상·방법·자리 · 글자는 설명(검사 안 함)."""
rule = row.get("끝수")
if rule is None or isinstance(rule, str):
return []
if not isinstance(rule, dict):
return [f"{key} 끝수 · 묶음도 글자도 아님"]
out = []
unknown = set(rule) - {"대상", "자리", "방법", "출처", "비고"}
if unknown:
out.append(f"{key} 끝수 · 모르는 칸 {sorted(unknown)}")
on = rule.get("대상")
if on not in ROUND_ON:
out.append(f"{key} 끝수 · 대상 「{on}」 — {' · '.join(ROUND_ON)}")
elif ("결과" in row) != (on == "결과"):
out.append(f"{key} 끝수 · 대상 「{on}」 이 로직 갈래와 안 맞음")
if rule.get("방법") not in ROUND_WAYS:
out.append(f"{key} 끝수 · 방법 「{rule.get('방법')}」 — {' · '.join(ROUND_WAYS)}")
place = rule.get("자리", 0)
if not isinstance(place, (int, Decimal)) or place != int(place) or not 0 <= int(place) <= 6:
out.append(f"{key} 끝수 · 자리 「{place}」 — 0∼6 정수")
return out
def find_loops(graph: dict[str, set]) -> list[list[str]]:
"""로직 부르기의 돌고 도는 길."""
loops, state = [], {}
def visit(node, path):
state[node] = 1
for nxt in sorted(graph.get(node, ())):
if state.get(nxt) == 1:
loops.append(path[path.index(nxt) :] + [nxt])
elif nxt not in state:
visit(nxt, path + [nxt])
state[node] = 2
for node in sorted(graph):
if node not in state:
visit(node, [node])
return loops
@@ -1,278 +0,0 @@
# -*- coding: utf-8 -*-
"""로직 셈 의미 넓힘(PLAN 791-1 · `_틀.md` 7장 「셈 의미」) — 덧줄 고리 · 금액번지 · 소계 단계 ·
제외 · 결과금액 조정 · 변수 표시 반올림 · 검사.
`master_formula.run` 이 부름(덧줄 고리를 여기로 옮김) · 끝전(줄 자리 · 블록 끝전)은 `master_cut`.
새 칸을 안 쓰는 로직은 옛 셈 그대로 — 지킴 = M01 로직 지문(`test_791_1_engine_semantics.py`).
eval 없음 · 수는 Decimal.
"""
from __future__ import annotations
from decimal import ROUND_HALF_UP, Decimal
import master_formula as mf
COSTS = mf.COST_ITEMS
ROW_KEYS = ("단계", "끝전", "조정") # 로직 줄 칸
LINE_KEYS = ("번지", "합밖", "자리") # 호표 · 덧줄 칸
ENDS = ("비목버림", "큰나머지")
MAX_PLACE = 3 # 줄 자리 0~3
MAX_SHOW = 6 # 변수 표시 0~6
MAX_STEP = 5 # 소계 단 1~5(STmate `(=)`~`(=====)`)
ADDR, STEP = "번지", "단계" # 덧줄 식 이름 — `번지.A01.재료비` · `단계.'소계'.계`
def items(row: dict) -> list[dict]:
"""엔진 줄 차례 = 호표 하나씩 뒤 덧줄 하나씩."""
return [*row.get("호표", []), *row.get("덧줄", [])]
def uses(row: dict) -> bool:
"""새 의미(번지 · 단계 · 끝전 · 조정 · 합밖 · 줄 자리)를 쓰는 로직 — 아니면 옛 셈 그대로."""
return any(k in row for k in ROW_KEYS) or any(k in x for x in items(row) for k in LINE_KEYS)
def rule(row: dict) -> dict:
"""셈법(792-3) — 새 의미 칸만 뗀 작은 로직 꼴(이 모듈 · `master_cut.settle` 이 읽음) ·
엔진 답 `셈법` 으로 실어 켜쌓기율 · 별도계상 뒤 다시 버림(`master_cut.plain`)이 씀."""
keep = ("이름", *LINE_KEYS)
lines = {
k: [{x: one[x] for x in keep if x in one} for one in row.get(k, [])]
for k in ("호표", "덧줄")
}
return {**lines, **{k: row[k] for k in (*ROW_KEYS, "끝수") if k in row}}
def shown(step: dict, value):
"""중간 `표시` = 값을 n 자리 반올림해 뒤 줄에 넘김(STmate `X = 식 =`)."""
if step.get("표시") is None or not isinstance(value, Decimal):
return value
return mf._round(value, step["표시"], ROUND_HALF_UP)
def _add(acc: dict, money: dict | None) -> None:
for k, v in (money or {}).items():
if k in acc:
acc[k] += v or 0
def _bundle(acc: dict) -> dict:
return {**acc, "계": sum(acc[k] for k in COSTS)}
def _cover(row: dict) -> list[tuple[dict, set]]:
"""단계마다 (단계, 담은 줄 차례) — 단 1 = 제 `줄` · 단 k = 제 `줄` + 아직 안 담긴 아래 단 단계.
제외 단계는 위로 안 올라감."""
where = {x.get("이름"): i for i, x in enumerate(items(row)) if x.get("이름")}
out, open_ = [], []
for st in row.get(STEP) or []:
level, mine = int(st.get("단") or 1), {where[n] for n in st.get("줄") or [] if n in where}
keep = []
for low, got in open_:
if low < level:
mine |= got
else:
keep.append((low, got))
open_ = keep if st.get("제외") else [*keep, (level, mine)]
out.append((st, mine))
return out
def skipped(row: dict) -> set:
"""비목 합에서 빼는 줄 차례 — `합밖` 줄(번지엔 쌓음) · 제외 단계가 담은 줄."""
out = {i for i, x in enumerate(items(row)) if x.get("합밖")}
for st, mine in _cover(row):
if st.get("제외"):
out |= mine
return out
def total(row: dict, lines: list[dict]) -> dict:
"""비목 합 — 뺄 줄을 빼고 지금까지 줄."""
skip, acc = skipped(row), dict.fromkeys(COSTS, Decimal(0))
for i, line in enumerate(lines):
if i not in skip:
_add(acc, line.get("비목"))
return acc
def steps(row: dict, lines: list[dict]) -> list[dict]:
"""단계 값 — 지금까지 셈한 줄만(뒤 줄은 0)."""
out = []
for st, mine in _cover(row):
acc = dict.fromkeys(COSTS, Decimal(0))
for i in sorted(mine):
if i < len(lines):
_add(acc, lines[i].get("비목"))
out.append(
{"이름": st.get("이름"), "단": st.get("단"), **_bundle(acc)}
| ({"제외": True} if st.get("제외") else {})
)
return out
def scope(row: dict, lines: list[dict]) -> dict:
"""덧줄 식 이름 — `번지` {A01: 묶음} · `단계` {이름: 묶음} (지금까지 줄)."""
places = {}
for item, line in zip(items(row), lines):
if item.get(ADDR):
_add(places.setdefault(item[ADDR], dict.fromkeys(COSTS, Decimal(0))), line.get("비목"))
return {
ADDR: {k: _bundle(v) for k, v in places.items()},
STEP: {x["이름"]: {k: x[k] for k in (*COSTS, "계")} for x in steps(row, lines)},
}
def adjust(row: dict, sums: dict) -> dict:
"""결과금액 조정 — `배율` {비목: 수} 곱 → `옮김` 비목으로 계 전부(STmate 「경비로 적용」)."""
rule = row.get("조정")
if not rule:
return sums
out = dict(sums)
for k, rate in (rule.get("배율") or {}).items():
out[k] = out[k] * Decimal(str(rate))
if rule.get("옮김"):
whole = sum(out.values())
out = {k: whole if k == rule["옮김"] else Decimal(0) for k in COSTS}
return out
def extras(master, row: dict, lines: list[dict], env: dict, sums: dict, depth: int):
"""덧줄 셈(옛 `run` 고리 그대로) + 새 의미 → (비목 합, 덧칸 `{단계}`)."""
new = uses(row)
# 덧줄이 호표 줄 금액 하나를 빼고 더할 수 있게 — `줄.'호표 줄 이름'`(빈 줄은 뺌)
env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None}
blank = {x["이름"]: x["까닭"] for x in lines if x.get("까닭")}
for extra in row.get("덧줄", []):
if new:
sums = total(row, lines)
env.update(scope(row, lines))
env.update(sums)
try: # 덧줄도 값 빈 품목·빈 줄을 부르면 그 줄만 비움
value, why = mf.evaluate(mf.parse(extra["식"]), env, master, depth), None
env[extra["이름"]] = value
except mf.FormulaError as e:
gone = next((n for n in blank if n in extra["식"]), None)
value, why = None, f"「{gone}」 줄 비어 못 셈 — {blank[gone]}" if gone else str(e)
blank[extra["이름"]] = why
sums[extra["비목"]] += value or 0
lines.append(
{
"이름": extra["이름"],
"단위": "식",
"수량": Decimal(1),
"단가": value,
"금액": value,
"비목": {extra["비목"]: value},
**({"까닭": why} if why else {}),
}
)
if new:
sums = total(row, lines)
sums = {k: mf.cut(row, v, "계") for k, v in sums.items()} # 비목 합마다 끊고 계는 그 합
if not new:
return sums, {}
return adjust(row, sums), {STEP: steps(row, lines)}
# ── 검사 ──────────────────────────────────────────────────────────────
def _whole(v, low: int, high: int) -> bool:
return isinstance(v, (int, Decimal)) and v == int(v) and low <= int(v) <= high
def _refs(node):
"""식 안 `번지.X.칸` · `단계.'X'.칸` → (이름, X, 칸)."""
for part in mf.walk(node):
if part[0] == "field" and part[1][0] == "field" and part[1][1][0] == "name":
head = part[1][1][1]
if head in (ADDR, STEP):
yield head, part[1][2], part[2]
def check(row: dict, key: str) -> list[str]:
"""새 의미 칸 — 끝전 · 조정 · 줄 자리 · 번지 · 표시 · 단계 · 덧줄이 부르는 번지 · 단계 차례."""
out, lines = [], items(row)
end = row.get("끝전")
if end is not None and end not in ENDS:
out.append(f"{key} 끝전 「{end}」 — {' · '.join(ENDS)}")
rule = row.get("조정")
if rule is not None:
if not isinstance(rule, dict) or set(rule) - {"옮김", "배율"}:
out.append(f"{key} 조정 · 칸은 옮김 · 배율만")
else:
if rule.get("옮김") not in (None, *COSTS):
out.append(f"{key} 조정 옮김 「{rule['옮김']}」 — {' · '.join(COSTS)}")
for k, rate in (rule.get("배율") or {}).items():
if k not in COSTS or not isinstance(rate, (int, Decimal)) or rate < 0:
out.append(f"{key} 조정 배율 「{k}」={rate}")
for step in row.get("중간", []):
if step.get("표시") is not None and not _whole(step["표시"], 0, MAX_SHOW):
out.append(f"{key} 중간 {step['이름']} · 표시 「{step['표시']}」 — 0∼{MAX_SHOW} 정수")
names = [x.get("이름") for x in lines]
for item in lines:
where = f"{key} 줄 {item.get('이름', '')}"
place = item.get("자리")
if place is not None and (
not isinstance(place, dict)
or set(place) - {"방법", "자리"}
or place.get("방법") not in mf.ROUND_WAYS
or not _whole(place.get("자리", 0), 0, MAX_PLACE)
):
out.append(
f"{where} · 자리 「{place}」 — {{방법: 버림·반올림·올림, 자리: 0∼{MAX_PLACE}}}"
)
if ADDR in item and not (isinstance(item[ADDR], str) and mf._NAME.fullmatch(item[ADDR])):
out.append(f"{where} · 번지 「{item[ADDR]}」 — 글자 · 숫자만")
if "합밖" in item and not isinstance(item["합밖"], bool):
out.append(f"{where} · 합밖 「{item['합밖']}」 — 참 · 거짓")
out += _check_steps(row, key, names)
return out
def _check_steps(row: dict, key: str, names: list) -> list[str]:
out, seen, taken = [], set(), {}
for st in row.get(STEP) or []:
name = st.get("이름") if isinstance(st, dict) else None
where = f"{key} 단계 {name}"
if not isinstance(name, str) or not name.strip():
out.append(f"{key} 단계 · 이름 없음")
continue
if name in seen:
out.append(f"{where} · 같은 이름")
seen.add(name)
if set(st) - {"이름", "단", "줄", "제외"}:
out.append(f"{where} · 모르는 칸 {sorted(set(st) - {'이름', '단', '줄', '제외'})}")
if not _whole(st.get("단"), 1, MAX_STEP):
out.append(f"{where} · 단 「{st.get('단')}」 — 1∼{MAX_STEP} 정수")
for line in st.get("줄") or []:
if line not in names:
out.append(f"{where} · 없는 줄 「{line}」")
elif names.count(line) > 1:
out.append(f"{where} · 줄 이름 「{line}」 겹침 — 줄 이름을 가를 것")
elif line in taken:
out.append(f"{where} · 줄 「{line}」 이 단계 「{taken[line]}」 에도 있음")
taken.setdefault(line, name)
if out:
return out
cover = {st["이름"]: mine for st, mine in _cover(row)}
places = {}
for i, item in enumerate(items(row)):
if item.get(ADDR):
places.setdefault(item[ADDR], set()).add(i)
first = len(row.get("호표", []))
for n, extra in enumerate(row.get("덧줄", [])):
try:
node = mf.parse(extra["식"])
except mf.FormulaError:
continue # 못 읽는 식은 `check_logic` 이 알림
for head, name, slot in _refs(node):
where = f"{key} 덧줄 {extra.get('이름')}"
group = (places if head == ADDR else cover).get(name)
if group is None:
out.append(f"{where} · 없는 {head} 「{name}」")
elif any(i >= first + n for i in group):
out.append(f"{where} · {head} 「{name}」 에 이 줄이나 뒤 줄이 듦 — 단계 순서")
if slot not in mf.BUNDLE:
out.append(f"{where} · {head} 칸 「{slot}」 — {' · '.join(mf.BUNDLE)}")
return out
@@ -1,90 +0,0 @@
# -*- coding: utf-8 -*-
"""옵션으로 빠진 줄 — **셈 때 파생**(정본에 칸 없음 · PLAN 753-1 · 요구 588-4).
엔진 `run` 호표 줄 덧칸 `옵션꺼짐` = True — 그 줄 수량 0 이 조건 `만약` 의 간 갈래(상수 0) 탓
(폼타이 12.7 · 9.5 · 7.9 셋 중 고른 규격 아닌 줄 · 폼타이 「아님」 이면 셋 다 ·
타설길이 문턱으로 고른 장비 아닌 줄). 화면이 숨김(753-2).
셈 · 금액 · 줄 차례 그대로 · 덧칸만.
가름(0 을 낸 마디를 거슬러 감):
- `만약` = 간 갈래가 상수 0 → 꺼짐(조건 = 고르기 · 수 입력 문턱 · 중간값 모두) ·
아니면 간 갈래 안으로.
- 곱 = 0 인 인수 중 하나라도 꺼짐 · 나눗셈 = 분자 · 더하기 · 빼기 = 두 쪽 다 0 이고 하나라도 꺼짐 ·
끝수 함수 = 첫 인수 · 최소 · 최대 = 0 인 인수 중 꺼짐 · 중간값 이름 = 그 식으로.
- 입력 값 · 표 값 · 요소 · 로직 부름 · 원문 0 = 진짜 0(안 꺼짐 · 구멍땜 개소 0 · 표 칸 0 등).
"""
from __future__ import annotations
from decimal import Decimal
import master_formula as mf
KEY = "옵션꺼짐"
_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, RecursionError)
_SOURCES = ("name", "find", "field", "ref", "logic") # 값이 입력 · 표에서 오는 마디
class _Trace:
def __init__(self, master, row: dict, env: dict):
self.master, self.env = master, env
self.steps = {s["이름"]: s["식"] for s in row.get("중간") or []}
self.memo: dict[str, bool] = {}
def zero(self, node) -> bool:
value = mf.evaluate(node, self.env, self.master)
return not isinstance(value, bool) and value == 0
def off(self, node, depth: int = 0) -> bool:
"""이 마디 값 0 이 옵션 갈래 탓인지."""
kind = node[0]
if depth > 40:
return False
if kind == "name":
name = node[1]
if name not in self.steps:
return False
if name not in self.memo:
self.memo[name] = False # 돌고 도는 이름 막음
self.memo[name] = self.off(mf.parse(self.steps[name]), depth + 1)
return self.memo[name]
if kind == "neg":
return self.off(node[1], depth + 1)
if kind == "bin":
sides = node[2:4]
if node[1] == "*":
return any(self.zero(x) and self.off(x, depth + 1) for x in sides)
if node[1] == "/":
return self.off(node[2], depth + 1)
if node[1] in ("+", "-"):
both = all(self.zero(x) for x in sides)
return both and any(self.off(x, depth + 1) for x in sides)
return False
if kind != "call" or not node[2]:
return False
items = node[2]
if node[1] == "만약":
taken = items[1] if mf.evaluate(items[0], self.env, self.master) else items[2]
fixed = not any(x[0] in _SOURCES for x in mf.walk(taken))
if fixed and self.zero(taken):
return True
return self.off(taken, depth + 1)
if node[1] in ("최소", "최대"):
return any(self.zero(x) and self.off(x, depth + 1) for x in items)
return self.off(items[0], depth + 1)
def tag(master, row: dict, lines: list[dict], env: dict) -> list[dict]:
"""엔진 `run` 호표 줄(덧줄 앞)에 `옵션꺼짐` — 수량 0 인 줄만 가름 · 못 가름 = 안 붙임."""
trace = None
for item, line in zip(row.get("호표") or [], lines):
qty = line.get("수량")
if not isinstance(qty, Decimal) or qty != 0:
continue
trace = trace or _Trace(master, row, env)
try:
if trace.off(mf.parse(item["수량"])):
line[KEY] = True
except _ERRORS:
continue
return lines
@@ -3,7 +3,7 @@
⚠ 낮은 값 고르기는 **시험 계산용**. 최저가·견적 고르기는 프로젝트 몫 — 마스터는 값을 모으기만 함.
`master_formula` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음.
수식 문서 계산기 · `master_base` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_base` 는 끝에서 읽음.
"""
from __future__ import annotations
+2 -2
View File
@@ -1,8 +1,8 @@
# -*- coding: utf-8 -*-
"""재료 줄의 기본 검색어 찾기 · 고른 품목 · 단위 환산 · 단위 경고 (PLAN 8-1 계약).
`master_formula.run` 이 재료 줄 단가를 풀 때 부름 — 요소 객체에 `검색어` 가 있으면 여기서 찾고,
없으면 옛 길(`master_material` 조건 · 대표). 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음.
수식 문서 계산기가 재료 줄 단가를 풀 때 부름 — 요소 객체에 `검색어` 가 있으면 여기서 찾고,
없으면 옛 길(`master_material` 조건 · 대표). 서로 부르는 모듈이라 `master_base` 는 끝에서 읽음.
"""
from __future__ import annotations
@@ -1,199 +0,0 @@
# -*- coding: utf-8 -*-
"""계산서 줄 덧칸 — 「쓰는 입력」 · 묶음 · 기준단위 · 환산 근거(PLAN 714-1 · 요구서 4장 5 · 8).
`master_text.lines` 답(비목 묶음 줄)에 줄마다 덧칸을 얹음 — M01 `/text` 와 M02 `/logic-lib/sheet`
두 길이 같은 함수(`annotate`)를 거쳐 같은 줄 꼴(`KEYS`)을 냄. 셈은 `master_formula.run` 한 벌.
- `쓰는입력` = 그 줄 값(수량 식 · 요소 · 덧줄 식)에 쓰인 로직 입력 이름 — 중간값을 거슬러 감 ·
덧줄이 부르는 비목 합 · 줄 금액은 거스르지 않음(율 식에 직접 쓴 입력만).
- `묶음` · `장비` = 712-1 `master_bundle`(엔진 줄 덧칸 그대로).
- `펼침`(장비 줄만 · 714-1b) = 부른 기계경비 로직의 계산서 줄(조종원 · 주연료 · 잡재료비 · 기계손료 …) ·
시간당 비목 소계 · 계 · 부른 키 · 인자 — 셈 결과를 그대로 실음(환산 규칙을 여기 두지 않음).
- `옵션꺼짐` = 엔진 줄 덧칸 그대로(753-1 `master_gate` · 옵션 갈래로 0 인 줄 · 화면이 숨김).
- `기준단위` = 그 줄 수량 식이 찾는 표의 기준(「10㎡」 · 712-3 `master_basis.basis`) · 답 머리
`기준단위` = 로직 결과단위 분모(「10㎡」 · 여럿이면 「㎡ · ㎥」).
- `환산근거` = 표 기준배 ↔ 결과단위 배(「10㎡당 → 1㎡당 ÷10」) · 재료 품목 단위 ↔ 줄 단위
(712-2 `master_unit.note`) · 없으면 「」.
줄 차례 맞춤 = `master_text.lines` 와 같은 차례(호표 줄마다 `_shares` 비목 · 뒤 덧줄).
`files` 자리 = 파일 묶음 또는 Master(M02 SK 고친 줄 `_Over` · 750-1 · `_spread` 도 그대로 넘김).
"""
from __future__ import annotations
import re
from decimal import Decimal
import master_basis as mbs
import master_bundle as mb
import master_formula as mf
import master_gate as mg
import master_text as mtx
import master_unit as mu
KEYS = ("쓰는입력", "묶음", "장비", "기준단위", "환산근거", "펼침", "옵션꺼짐")
_HOLE = re.compile(r"\{([^{}]+)\}")
_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
def _names(expr) -> tuple[set[str], set[str]]:
"""식 하나의 (이름 · 찾는 표 키) — `{입력}` 구멍 이름도 셈."""
if isinstance(expr, dict): # 재료 고르기 조건 묶음 — 값 글의 구멍만
return {h for v in expr.values() for h in _HOLE.findall(str(v))}, set()
if expr in (None, ""):
return set(), set()
try:
tree = mf.parse(expr)
except mf.FormulaError:
return set(_HOLE.findall(str(expr))), set()
names, tables = set(), set()
for node in mf.walk(tree):
if node[0] == "name":
names.add(node[1])
elif node[0] in ("find", "logic", "ref"):
names |= set(_HOLE.findall(node[1]))
if node[0] == "find":
tables.add(node[1])
return names, tables
def _closure(row: dict, exprs: list) -> tuple[list[str], list[str]]:
"""식들이 쓰는 (입력 이름 · 표 키) — 중간값은 그 식으로 거슬러 감 · 입력 차례대로."""
steps = {s["이름"]: s["식"] for s in row.get("중간", [])}
inputs = [s["이름"] for s in row.get("입력", [])]
seen, tables, todo = set(), [], list(exprs)
while todo:
names, found = _names(todo.pop())
tables += [t for t in sorted(found) if t not in tables]
for name in names - seen:
seen.add(name)
if name in steps:
todo.append(steps[name])
return [n for n in inputs if n in seen], tables
def _times(x: Decimal) -> str:
return format(x.normalize(), "f")
def _per_text(per: list[tuple[Decimal, str]]) -> str:
return " · ".join(dict.fromkeys(f"{_times(n) if n != 1 else ''}{u}" for n, u in per))
def _basis(master, tables: list[str], env: dict) -> dict | None:
for ref in tables:
try:
got = mbs.basis(master.get(mf.fill(ref, env) if "{" in ref else ref))
except (*_ERRORS, mf.EmptyInput):
continue
if got["갈래"] == "단위":
return got
return None
def _note(basis: dict | None, per: list, line: dict) -> str:
notes = []
if basis and len(per) == 1:
times, one = per[0]
if mu.plain(basis["기준단위"]) == mu.plain(mbs.unit(one)) and basis["기준배"] != times:
ratio = basis["기준배"] / times
how = f"÷{_times(ratio)}" if ratio > 1 else f"×{_times(1 / ratio)}"
notes.append(
f"{_times(basis['기준배'])}{basis['기준단위']}당 → {_times(times)}{one}당 {how}"
)
goods = line.get("품목") or {}
if goods.get("단위") and line.get("단위"):
notes.append(mu.note(goods["단위"], line["단위"]))
return " · ".join(n for n in notes if n)
def _fields(master, row, exprs, env, per, line: dict, bundle: tuple[str, bool] | None) -> dict:
uses, tables = _closure(row, exprs)
basis = _basis(master, tables, env)
out = {
"쓰는입력": uses,
"기준단위": f"{_times(basis['기준배']) if basis['기준배'] != 1 else ''}{basis['기준단위']}"
if basis
else None,
"환산근거": _note(basis, per, line),
}
if bundle:
out["묶음"] = bundle[0]
if bundle[1]:
out["장비"] = True
return out
def _spread(files: dict, master, item: dict, env: dict) -> dict:
"""장비 줄이 부른 기계경비 로직 한 장 — `{키, 이름, 단위, 입력, 줄, 소계, 계}` · 못 셈 = 까닭."""
node = mf.parse(item["요소"])
key = node[1]
try:
key = mf.fill(key, env) if "{" in key else key
given = {k: mf.evaluate(v, env, master, 1) for k, v in node[2]}
got = mtx.lines(files, key, given)
except (*_ERRORS, mf.EmptyInput) as e:
return {"키": key, "까닭": str(e) or type(e).__name__}
if not got.get("ok"):
return {"키": key, "입력": given, "까닭": got.get("reason")}
groups = got.get("groups") or []
return {
"키": key,
"이름": master.logic(key).get("이름") or "",
"단위": _per_text(mbs.result_per(master.logic(key).get("결과단위"))) or None,
"입력": given,
"줄": [
{"비목": g["비목"], **{k: one.get(k) for k in ("이름", "글", "금액")}}
for g in groups
for one in g["줄"]
],
"소계": {g["비목"]: g.get("소계") for g in groups},
"계": got.get("계"),
}
def annotate(files: dict, key: str, given: dict, answer: dict) -> dict:
"""`master_text.lines` 답에 줄마다 `KEYS` 덧칸 · 머리 `기준단위` — 못 셈이면 답 그대로."""
if not answer.get("ok") or "groups" not in answer:
return answer
master = files if hasattr(files, "logic") else mf.Master(files)
row = master.logic(key)
per = mbs.result_per(row.get("결과단위"))
answer["기준단위"] = _per_text(per) or None
try:
env = mtx._env_of(master, row, given)
except _ERRORS:
env = {}
if "결과" in row:
for line in answer["groups"][0]["줄"]:
line.update(_fields(master, row, [row["결과"]["식"]], env, per, {}, None))
return answer
try:
result = mf.run(master, key, given)
except _ERRORS:
result = None
slots = {g["비목"]: iter(g["줄"]) for g in answer["groups"]}
items = row.get("호표") or []
for n, item in enumerate(items):
line = result["줄"][n] if result else {}
if result:
parts = [p for p, _ in mtx._shares(line)]
elif item.get("종류") == "로직" and "비목" not in item:
parts = list(mf.COST_ITEMS)
else:
parts = [item.get("비목")]
exprs = [item.get("수량"), item.get("요소")]
got = _fields(master, row, exprs, env, per, line, mb.bundle(master, item, env))
if line.get(mg.KEY): # 옵션으로 빠진 줄(753-1 · 엔진 줄 덧칸 그대로)
got[mg.KEY] = True
if got.get("장비"):
got["펼침"] = _spread(files, master, item, env)
for part in parts:
target = next(slots.get(part, iter(())), None)
if target is not None:
target.update(got)
for extra in row.get("덧줄") or []:
target = next(slots.get(extra["비목"], iter(())), None)
if target is not None:
target.update(
_fields(master, row, [extra["식"]], env, per, {}, mb.bundle(master, extra))
)
return answer
@@ -1,671 +0,0 @@
# -*- coding: utf-8 -*-
"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계.
줄마다 글 두 꼴 —
· `글` 값 꼴: 수는 화면과 같은 자릿수(소수 넷째 자리까지 · 천 단위 쉼표) · `찾기`·`로직`·
중간 값·요소는 글자로 내보내지 않고 그 자리에서 나온 수로 적음
· `이름글` 이름 꼴: 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」 — 표 찾기·로직
부르기는 별칭 이름(`master_copy` 3-4 규칙) · 중간 값·입력은 그 이름 그대로
두 꼴은 같은 줄에 나란히 있고 `짝` 번호가 붙음 — 화면 두 칸이 줄 맞춤으로 놓임.
줄마다 `조각`(PLAN 2-1 조각 계약) 도 같이 줌 — kind(요소·표·로직·값·기호·글) · 글 · 참조.
알약(요소·표·로직)이 될 자리는 구조만 보고 짓고, `만약()` 갈래만 골라야 해서 계산이 필요함 —
계산이 안 되면(FormulaError 따위) 갈래 양쪽을 다 내보내고 깊이를 적어 접을 수 있게 함.
호표 줄 계산 자체가 막혀도(재료 단가 없음 따위) 이름 식·조각은 `row` 구조만으로 그리고
`글`·`금액`만 비움 — `만약() 과 무관` 인 그 60개 로직도 이름 식은 보이게.
금액 = 품셈 1-2-2 끝수 입힌 엔진 답(`master_cut.engine` · 줄 0.1 원 · 소계 1 원 버림) · 수 꼴 =
`common_util_money`(줄 금액 `fmt_line_money` · 단가 `fmt_price` · 수량 `fmt`).
계산은 `master_formula.run` 한 벌.
"""
from __future__ import annotations
from decimal import Decimal
import master_copy as mc
import master_cut as mcut # 끝수(751-3) — 뿌리 길도 둠(아래 common_util)
import master_formula as mf
import master_text_item as mti
from common_util.common_util_money import fmt, fmt_line_money, fmt_money, fmt_price # noqa: F401
PRICE_TAIL = {"인력": "노임", "기계": "손료"} # 단가 자리의 이름 꼬리(그 밖은 「단가」)
ELEM_KEYS = ("LB", "EQ", "MT", "MP", "MO") # 요소 테이블 — 그 밖의 열쇠(QC · QF …)는 별칭 이름
ELEM_TAIL = {"LB": "노임", "EQ": "손료"} # 식 안 요소 키의 이름 꼬리(그 밖은 「단가」)
_PREC = {"또는": 1, "그리고": 2, "==": 3, "!=": 3, "<": 3, "<=": 3, ">": 3, ">=": 3}
_PREC |= {"+": 4, "-": 4, "*": 5, "/": 5}
_RIGHT_TIGHT = ("-", "/") # 오른쪽 짝은 같은 세기라도 괄호가 필요함
_CALC_ERRORS = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) # 계산 못 함
# ── 식을 글로 — 값 꼴과 이름 꼴 ────────────────────────────────────────
def render(node, env: dict, master, depth: int = 0) -> str:
"""식 한 마디 → 값 꼴 글. 값이 정해지는 마디(요소 · 찾기 · 로직 · 이름)는 그 수로 바뀜."""
return _draw(node, node, env, master, depth)
def _draw(show, real, env: dict, master, depth: int) -> str:
kind = show[0]
if kind == "num":
return fmt(show[1])
if kind == "str":
return f"'{show[1]}'"
if kind == "neg":
return "-" + _draw(show[1], real[1], env, master, depth)
if kind == "bin":
return _bin(show, real, env, master, depth, _draw)
if kind == "call" and show[1] == "만약": # 걸린 쪽만 적음
at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2
return _draw(show[2][at], real[2][at], env, master, depth)
return _value(real, env, master, depth)
def named(show, real, env: dict, master, depth: int = 0) -> str:
"""식 한 마디 → 이름 꼴 글. `show` = 부르기를 별칭으로 갈아 끼운 나무 · `real` = 원래 나무.
이름·중간 값은 그대로 · 표 찾기·로직 부르기는 별칭 이름 · 요소는 그 이름."""
kind = show[0]
if kind == "name":
return show[1]
if kind == "ref":
return _elem_name(master, show[1], env)
if kind == "field":
return f"{named(show[1], real[1], env, master, depth)}.{show[2]}"
if kind == "neg":
return "-" + named(show[1], real[1], env, master, depth)
if kind == "bin":
return _bin(show, real, env, master, depth, named)
if kind == "call":
if show[1] == "만약": # 값 꼴과 같은 쪽만 적어 두 칸이 짝이 되게
try:
at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2
except _CALC_ERRORS: # 조건 입력이 비면 식 그대로(아래 부르기 꼴)
at = 0
if at:
return named(show[2][at], real[2][at], env, master, depth)
args = ", ".join(named(s, r, env, master, depth) for s, r in zip(show[2], real[2]))
return f"{show[1]}({args})"
if kind in ("num", "str"):
return _draw(show, real, env, master, depth)
return _value(real, env, master, depth) # 별칭이 안 붙은 부르기 — 값으로
def _hole(master, ref: str, env: dict | None) -> tuple[list[str], dict | None]:
"""자리 표시(`XX:품목:{입력}` · `XX:{입력}`) 든 참조 → (읽는 글 조각들, 입력으로 풀린 요소 줄).
글 = 앞 글 + 지금 입력값(「휘발유 · 전국평균」) · 구멍뿐이면 입력 이름이 앞(「장비 · 굴착기」).
입력이 비면 입력 이름만(「휘발유 · 지역」) · 못 풀면 줄은 None."""
env = env or {}
tail = ref[3:]
holes = mf._HOLE.findall(tail)
words = [w.strip(": ") for w in mf._HOLE.split(tail)[::2] if w.strip(": ")]
try:
row = master.get(mf.fill(ref, env))
except mf.FormulaError:
row = None
pure = not words and len(holes) == 1
shown = []
for name in holes:
value = env.get(name)
if value is None:
shown.append(name)
elif pure and row is not None: # 입력 하나가 요소 자리 전부 — 그 요소 이름 + 규격
shown.append(f"{row.get('이름') or value} {row.get('규격') or ''}".strip())
else:
shown.append(fmt(value) if isinstance(value, Decimal) else str(value))
head = words or holes[:1]
return head + [one for one in shown if one not in head], row
def _elem_name(master, ref: str, env: dict | None = None) -> str:
"""식 안 요소 한 줄의 이름 — 「석공노임」 꼴(같은 이름의 중간 값과 헷갈리지 않게)."""
if (
str(ref)[:2] not in ELEM_KEYS
): # 별칭 이름이 표 열쇠 그대로인 것(QC…) — 밑이름을 풀어쓰지 않음
return ref
tail = ELEM_TAIL.get(str(ref)[:2], "단가")
try:
if "{" in str(ref): # 입력으로 풀린 요소 이름 · 못 풀면 입력 이름
parts, row = _hole(master, ref, env)
name = mc.short(row.get("이름")) if row is not None else mc.plain("".join(parts))
else:
name = mc.short(master.get(ref).get("이름"))
except mf.FormulaError:
name = ""
return f"{name}{tail}" if name else ref
def _value(node, env: dict, master, depth: int) -> str:
value = mf.evaluate(node, env, master, depth)
if isinstance(value, dict): # 로직 부르기 묶음 — 줄 금액에 쓰는 것은 「계」
value = value.get("계")
return fmt(value)
def _bin(show, real, env: dict, master, depth: int, draw) -> str:
_, op, left, right = show
if op == "/" and right[0] == "num" and right[1] == 100: # 「… / 100」 은 퍼센트로
return f"{_side(left, real[2], show, env, master, depth, draw, False)} %"
return (
f"{_side(left, real[2], show, env, master, depth, draw, False)} {op} "
f"{_side(right, real[3], show, env, master, depth, draw, True)}"
)
def _shown(show, real, env: dict, master, depth: int):
"""만약() 은 걸린 갈래만 글이 됨 — 괄호를 정할 때는 그 갈래의 마디로 봄(못 가리면 그대로)."""
while show[0] == "call" and show[1] == "만약":
try:
at = 1 if mf.evaluate(real[2][0], env, master, depth) else 2
except _CALC_ERRORS:
break
show, real = show[2][at], real[2][at]
return show
def _side(show, real, parent, env: dict, master, depth: int, draw, right: bool) -> str:
text = draw(show, real, env, master, depth)
show = _shown(show, real, env, master, depth)
if show[0] != "bin":
return text
mine, up = _PREC[show[1]], _PREC[parent[1]]
if mine < up or (mine == up and right and parent[1] in _RIGHT_TIGHT):
return f"({text})"
return text
# ── 조각(알약) — PLAN 2-1 조각 계약 · 2-2 「이름 식을 계산 없이」 ──────────
_PIECE_SYM = {"+": "+", "-": "-", "*": "×", "/": "÷"}
def _p_val(text: str) -> dict:
return {"kind": "값", "글": text}
def _p_sym(text: str) -> dict:
return {"kind": "기호", "글": text}
def _alias_index(marks: list[dict]) -> dict[str, dict]:
"""별칭 이름 → 별칭 한 줄(`master_copy.aliases` 결과) — 조각이 참조를 되찾을 때 씀."""
return {m["이름"]: m for m in marks}
def _elem_piece(master, ref: str, env: dict | None = None) -> dict:
"""요소 알약 — 글은 이름(못 찾아도 이름만). 자리 표시 든 참조는 글 = 이름 + 지금 입력값 ·
참조 = 입력으로 풀린 실제 키(못 풀면 참조 없음)."""
if "{" in str(ref):
parts, row = _hole(master, ref, env)
piece = {"kind": "요소", "글": " · ".join(parts)}
if row is not None:
key = str(row.get("키") or ref)
piece["참조"] = {"테이블": key[:2], "키": key}
return piece
piece = {"kind": "요소", "글": _elem_name(master, ref)}
try:
row = master.get(ref)
except mf.FormulaError:
return piece
key = str(row.get("키") or ref)
piece["참조"] = {"테이블": key[:2], "키": key}
return piece
def _row_label(table: dict, row: dict, conds: dict) -> list[str]:
"""찾은 줄의 이름 — 조건마다 그 줄의 값(범위 칸은 찾은 범위)."""
out = []
for cond, want in conds.items():
have = row.get(cond, want)
if table.get("조건", {}).get(cond) == "범위" and isinstance(have, list):
low, high = ("" if x is None else fmt(x) for x in have)
out.append(f"{low}~{high}")
else:
out.append(fmt(have))
return out
def _alias_piece(mark: dict, env: dict, master, column: str | None) -> dict:
"""표 찾기·로직 부르기 알약 — 표는 글 = 「찾은 줄 · 칸」 · 참조.행 = 찾기 조건.
다시 못 찾으면(입력이 비어서 따위) 별칭 이름만 남김."""
piece = {"kind": "표" if mark["종류"] == "찾기" else "로직", "글": mark["이름"]}
try:
node = mf.parse(mark["원문"])
ref = mf.fill(node[1], env)
if mark["종류"] == "찾기":
table = master.get(ref)
conds = {k: mf.evaluate(v, env, master, 0) for k, v in node[2]}
row = mf.find(table, conds, column)
tail = column.rpartition("_")[2] if column else ""
piece["글"] = " · ".join([*_row_label(table, row, conds), *([tail] if tail else [])])
at = next(i for i, one in enumerate(table["줄"]) if one is row) # find 가 고른 줄
piece["참조"] = {"테이블": ref[:2], "키": ref, "행": conds, "열": column, "줄": at}
else:
piece["글"] = str(master.logic(ref).get("이름") or ref) # 요소조각처럼 로직 이름
piece["참조"] = {"테이블": ref[:2], "키": ref}
except _CALC_ERRORS:
pass # 다시 못 찾음 — 별칭 이름만 남김(값 자리 비움)
return piece
def _ga(word: str) -> str:
"""받침이 없으면 「가」 · 있으면 「이」."""
last = word[-1:]
return "이" if "가" <= last <= "힣" and (ord(last) - 0xAC00) % 28 else "가"
def _easy(show, real, env: dict, master) -> str:
if show[0] == "str":
return show[1]
try:
return named(show, real, env, master)
except _CALC_ERRORS:
return ""
def _cond_text(show, real, env: dict, master) -> str:
"""만약 조건 → 쉬운 말 — 「폼타이 가 사용 이면」(같음) · 그 밖은 「식 이면」."""
if show[0] == "bin" and show[1] == "==":
left = _easy(show[2], real[2], env, master)
return f"{left} {_ga(left)} {_easy(show[3], real[3], env, master)} 이면"
return f"{_easy(show, real, env, master)} 이면"
def _if_pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int) -> list[dict]:
"""만약() 조각 — 「조건 이면 A · 아니면 B」 · 안 걸린 갈래는 흐림 ·
조건이 안 셈해지면(입력이 비어서 따위) 흐림 없이 두 갈래 다(깊이를 적어 접을 수 있게)."""
try:
taken = bool(mf.evaluate(real[2][0], env, master, 0))
except _CALC_ERRORS:
taken = None
deeper = ifdepth if taken is not None else ifdepth + 1
then = _pieces(show[2][1], real[2][1], env, master, alias_by_name, deeper)
other = _pieces(show[2][2], real[2][2], env, master, alias_by_name, deeper)
other.insert(0, {"kind": "글", "글": "· 아니면"})
for one in then if taken is None else ():
one["깊이"] = deeper
for one in other if taken is None else ():
one["깊이"] = deeper
for one in then if taken is False else other if taken else ():
one["흐림"] = True
cond = {"kind": "글", "글": _cond_text(show[2][0], real[2][0], env, master)}
return [cond, *then, *other]
def _side_pieces(
show, real, parent_show, env: dict, master, alias_by_name: dict, ifdepth: int, right: bool
):
inner = _pieces(show, real, env, master, alias_by_name, ifdepth)
if show[0] != "bin":
return inner
mine, up = _PREC[show[1]], _PREC[parent_show[1]]
if mine < up or (mine == up and right and parent_show[1] in _RIGHT_TIGHT):
return [_p_sym("("), *inner, _p_sym(")")]
return inner
def _bin_pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int) -> list[dict]:
op = show[1]
if op == "/" and show[3][0] == "num" and show[3][1] == 100: # 「… / 100」 은 퍼센트로
left = _side_pieces(show[2], real[2], show, env, master, alias_by_name, ifdepth, False)
return [*left, {"kind": "글", "글": "%"}]
left = _side_pieces(show[2], real[2], show, env, master, alias_by_name, ifdepth, False)
right = _side_pieces(show[3], real[3], show, env, master, alias_by_name, ifdepth, True)
return [*left, _p_sym(_PIECE_SYM.get(op, op)), *right]
def _pieces(show, real, env: dict, master, alias_by_name: dict, ifdepth: int = 0) -> list[dict]:
"""식 한 마디 → 조각 목록. 요소·표·로직 부르기는 알약(참조가 됨) · 나머지는 값·기호·글."""
kind = show[0]
if kind == "num":
return [_p_val(fmt(show[1]))]
if kind == "str":
return [_p_val(f"'{show[1]}'")]
if kind == "neg":
return [_p_sym("-"), *_pieces(show[1], real[1], env, master, alias_by_name, ifdepth)]
if kind == "bin":
return _bin_pieces(show, real, env, master, alias_by_name, ifdepth)
if kind == "call" and show[1] == "만약":
return _if_pieces(show, real, env, master, alias_by_name, ifdepth)
if kind == "ref":
return [_elem_piece(master, show[1], env)]
if kind == "field" and show[1][0] == "name" and show[1][1] in alias_by_name:
return [_alias_piece(alias_by_name[show[1][1]], env, master, show[2])]
if kind == "name" and show[1] in alias_by_name:
return [_alias_piece(alias_by_name[show[1]], env, master, None)]
piece = _p_val(show[1] if kind == "name" else "") # 중간 값은 글에 그 이름
if kind == "field" and show[1] == ("name", "줄"): # 덧줄이 부른 호표 줄 — 비면 그 줄 이름
piece["글"] = show[2]
try:
value = _value(real, env, master, 0)
if value in ("None", ""): # 값이 빈 줄 — 빈 글 · 「None」 을 글로 안 찍음
raise mf.FormulaError("값 없음")
piece.update({"값": value} if kind == "name" else {"글": value})
except _CALC_ERRORS:
pass # 값 계산 자체가 막힘 — 이름만(그 밖은 빈 글) 남겨 줄이 안 죽게
return [piece]
def _formula_pieces(text, env: dict, master, name_of: dict, alias_by_name: dict) -> list[dict]:
"""식 글 한 줄의 조각 — 별칭을 씌운 나무와 원래 나무를 나란히 읽음(`_names` 와 짝)."""
real = mf.parse(text)
try:
show = mf.parse(mc.mask(text, name_of))
except mf.FormulaError:
show = real
return _pieces(show, real, env, master, alias_by_name)
# ── 줄 세우기 ─────────────────────────────────────────────────────────
def _env_of(master, row: dict, given: dict, depth: int = 0) -> dict:
"""입력 + 중간 — `run` 과 같은 차례로 다시 셈(덧줄 전 상태).
아직 안 고른 입력이 있으면(값 넣기 전) 받은 것만 담아 돌려줌 — 이름 식은 값 없이도 지어짐
(고른 값이 틀린 경우(고르기·범위 밖)는 지금처럼 그대로 막힘 — `mf._inputs` 가 걸러냄)."""
specs = row.get("입력", [])
if any(spec["이름"] not in given for spec in specs):
return {spec["이름"]: given[spec["이름"]] for spec in specs if spec["이름"] in given}
env = mf._inputs(row, given)
for step in row.get("중간", []):
try:
env[step["이름"]] = mf.evaluate(mf.parse(step["식"]), env, master, depth)
except mf.EmptyInput as e: # 못 구한 중간값 — `run` 과 같이 쓰는 줄만 비움
env[step["이름"]] = mf.Blank(str(e))
return env
def _why(item: dict, line: dict) -> str:
"""단가를 못 구했거나 0 인 줄의 까닭 한 마디."""
if line["수량"] == 0:
return "수량 0 — 이 조건에서는 안 쓰는 줄"
if line["단가"] not in (0, None):
return ""
where = item.get("요소")
where = "재료 고르기 조건" if isinstance(where, dict) else f"「{where}」"
return f"단가 0 — {where} 값이 아직 없음"
def _label(item: dict, line: dict) -> str:
spec = str(item.get("규격") or "").strip()
name = str(line.get("이름") or item.get("이름") or "")
return f"{name}({spec})" if spec else name
def _shares(line: dict) -> list[tuple[str, Decimal]]:
"""글로 적을 (비목, 몫) — 비목이 나뉜 로직 줄은 몫이 없는 비목을 건너뜀.
몫이 전부 0 이면 호표 줄이 사라지지 않게 첫 비목에 0 원 한 줄을 남김."""
parts = list(line["비목"].items())
if len(parts) <= 1:
return parts
return [(part, money) for part, money in parts if money != 0] or parts[:1]
def _loose(node, env: dict, master) -> bool:
"""수량식 맨 위가 덧셈·뺄셈이면(곱 뒤에 오면 괄호가 필요함) · 만약은 걸린 갈래 기준."""
if node[0] == "bin":
return _PREC[node[1]] < _PREC["*"]
if node[0] == "call" and node[1] == "만약":
try:
at = 1 if mf.evaluate(node[2][0], env, master, 0) else 2
except _CALC_ERRORS:
return False # 이름 꼴은 「만약(…)」 부르기 그대로라 괄호 불필요
return _loose(node[2][at], env, master)
return False
def _times(text: str, item: dict, env: dict, master) -> str:
"""「단가 * 수량식」 의 수량식 — 덧셈·뺄셈 묶음이면 괄호."""
return f"({text})" if _loose(mf.parse(item["수량"]), env, master) else text
def _line_text(item: dict, line: dict, env: dict, master, part: str | None) -> str:
"""「단가 * 수량식 = 금액」 — 비목이 나뉜 로직 줄은 그 비목 몫만 · 빈 줄(금액 null)은 빈 글."""
if line["금액"] is None:
return ""
qty = _times(render(mf.parse(item["수량"]), env, master), item, env, master)
money = line["비목"][part] if part else line["금액"]
price = line["단가"] if part is None or line["수량"] == 0 else money / line["수량"]
return f"{fmt_price(price)} * {qty} = {fmt_line_money(money)}"
def _item_names(items: list) -> list[tuple[str, str]]:
"""호표 줄마다 (짧은 품명(규격·코드 뗌), 겹침 꼬리) — 한 로직 안에서 겹치면 꼬리 `_2`."""
taken: set[str] = set()
out = []
for item in items:
name = mc.short(item.get("이름")) or "값"
out.append((name, mc._free(name, taken)[len(name) :]))
return out
def _line_names(
item: dict, env: dict, master, part: str | None, name_of: dict, label: tuple[str, str]
) -> str:
"""같은 줄을 변수 이름으로 — 「석공노임 * 메쌓기인력.석공 * (1 + 증가율) = 석공비」."""
name, dup = label
tail = PRICE_TAIL.get(str(item.get("종류") or ""), "단가")
price = f"{name}{part or ''}{tail}{dup}"
money = f"{name}{part}{dup}" if part else f"{name}비{dup}"
qty = _times(_names(item["수량"], env, master, name_of), item, env, master)
return f"{price} * {qty} = {money}"
def _extra_text(extra: dict, line: dict, env: dict, master) -> str:
if line["금액"] is None: # 빈 덧줄 — 식을 다시 셈하지 않음
return ""
return f"{render(mf.parse(extra['식']), env, master)} = {fmt_line_money(line['금액'])}"
def _extra_names(extra: dict, env: dict, master, name_of: dict) -> str:
got = mc.short(extra.get("이름")) or "덧줄"
return f"{_names(extra['식'], env, master, name_of)} = {got}"
def _names(text, env: dict, master, name_of: dict) -> str:
"""식 글 한 줄을 이름 꼴로 — 별칭을 씌운 나무와 원래 나무를 나란히 읽음."""
real = mf.parse(text)
try:
show = mf.parse(mc.mask(text, name_of))
except mf.FormulaError: # 별칭을 씌우면 못 읽는 글 — 값 꼴로 물러남
show = real
return named(show, real, env, master)
def lines(files: dict, key: str, given: dict) -> dict:
"""로직 한 줄의 읽는 식 — 비목 묶음마다 줄과 소계 · 돈 아닌 로직은 「결과」 묶음 하나.
호표 줄 계산이 막히면(재료 단가 없음 따위) `row` 구조만으로 이름 식·조각을 짓고
`글`·`금액`은 비움(입력 자체가 없는 경우는 지금처럼 그대로 막힘 — `_env_of` 에서 걸림)."""
master = files if hasattr(files, "logic") else mf.Master(files) # Master 째(750-1)
row = master.logic(key)
env = _env_of(master, row, given)
marks = mc.aliases(row, master)
name_of = mc.names(marks)
alias_by_name = _alias_index(marks)
try:
result = mcut.engine(master, key, mf.run(master, key, given))
except _CALC_ERRORS:
result = None
if "결과" in row:
조각 = _formula_pieces(row["결과"]["식"], env, master, name_of, alias_by_name)
got = mc.short(row.get("이름")) or "결과"
shown = (
fmt_money if str(row.get("결과단위") or "").startswith("원") else fmt
) # 돈 결과만 정수
이름글 = f"{_names(row['결과']['식'], env, master, name_of)} = {got}"
if result is not None:
one = {
"이름": row.get("이름") or "",
"글": f"{render(mf.parse(row['결과']['식']), env, master)} = "
f"{shown(result['결과'])}",
"이름글": 이름글,
"금액": result["결과"],
"조각": 조각,
}
group = {
"비목": "결과",
"줄": [one],
"소계": result["결과"],
"끝수": _cut_note(row, "결과"),
}
계 = result["결과"]
else:
one = {
"이름": row.get("이름") or "",
"글": "",
"이름글": 이름글,
"금액": None,
"조각": 조각,
}
group = {"비목": "결과", "줄": [one], "소계": None, "끝수": ""}
계 = None
return _paired({"ok": True, "groups": [group], "계": 계, "별칭": marks})
made: dict[str, list] = {name: [] for name in mf.COST_ITEMS}
items = row.get("호표") or []
labels = _item_names(items)
if result is not None:
shown = result["줄"]
env["줄"] = {r["이름"]: r["금액"] for r in shown if r["이름"]}
for n, (item, line, label) in enumerate(zip(items, shown, labels)):
조각 = _formula_pieces(item["수량"], env, master, name_of, alias_by_name)
요소 = _item_pieces(item, env, master, line, n)
for part, money in _shares(line):
split = part if len(line["비목"]) > 1 else None
one = {
"이름": _label(item, line),
"글": _line_text(item, line, env, master, split),
"이름글": _line_names(item, env, master, split, name_of, label),
"금액": money,
"조각": 조각,
"요소조각": 요소,
}
why = _why(item, line)
made[part].append({**one, "까닭": why} if why else one)
_extras(row, shown[len(items) :], made, env, master, name_of, alias_by_name)
소계 = {name: result[name] for name in mf.COST_ITEMS}
끝수 = _cut_note(row)
계 = result["계"]
else:
for n, (item, label) in enumerate(zip(items, labels)):
parts = (
list(mf.COST_ITEMS)
if item.get("종류") == "로직" and "비목" not in item
else [item.get("비목")]
)
조각 = _formula_pieces(item["수량"], env, master, name_of, alias_by_name)
요소 = _item_pieces(item, env, master, None, n)
for part in parts:
if part not in mf.COST_ITEMS:
continue
split = part if len(parts) > 1 else None
made[part].append(
{
"이름": _label(item, {}),
"글": "",
"이름글": _line_names(item, env, master, split, name_of, label),
"금액": None,
"조각": 조각,
"요소조각": 요소,
}
)
for extra in row.get("덧줄") or []:
made[extra["비목"]].append(
{
"이름": extra["이름"],
"글": "",
"이름글": (
f"{_names(extra['식'], env, master, name_of)} = "
f"{mc.short(extra.get('이름')) or '덧줄'}"
),
"금액": None,
"조각": _formula_pieces(extra["식"], env, master, name_of, alias_by_name),
}
)
소계 = dict.fromkeys(mf.COST_ITEMS, None)
끝수 = ""
계 = None
groups = [
{"비목": name, "줄": made[name], "소계": 소계[name], "끝수": 끝수}
for name in mf.COST_ITEMS
if made[name]
]
return _paired({"ok": True, "groups": groups, "계": 계, "별칭": marks})
def _arg_text(node, env: dict, master) -> str:
"""로직 부르기 인자 값을 사람이 읽는 글로 — 요소 키는 이름 · 입력 자리는 지금 값."""
try:
value = mf.evaluate(node, env, master, 0)
except _CALC_ERRORS: # 값 없는 입력 자리 — 이름만
return str(node[1]) if node[0] in ("name", "str") else ""
if isinstance(value, str):
for ref in (value, f"EQ:{value}"): # 기계 입력은 원문번호(0602-0025)
try:
return mc.plain(master.get(ref).get("이름")) or value
except mf.FormulaError:
pass
return value
return fmt(value)
def _item_pieces(
item: dict, env: dict, master, line: dict | None = None, index: int = 0
) -> list[dict]:
"""줄의 단가 자리(요소 · 로직 부르기) 조각 — PLAN 3-1 요소조각."""
ref = item.get("요소")
if item.get("종류") != "로직":
name = str(item.get("이름") or "")
if isinstance(ref, dict): # 재료 고르기 조건 — 잡힌 품목 이름 · 참조(고름 · 검색어 · 대표)
found = mti.piece(item, line, index, env, master)
return [found or {"kind": "요소", "글": name}]
piece = _elem_piece(master, ref, env)
return [{**piece, "글": name or piece["글"]}]
try:
node = mf.parse(ref)
key = mf.fill(node[1], env)
name = str(master.logic(key).get("이름") or key)
except _CALC_ERRORS:
return [{"kind": "로직", "글": str(item.get("이름") or "")}]
args = " · ".join(f"{k} {_arg_text(v, env, master)}" for k, v in node[2])
out = [{"kind": "로직", "글": name, "참조": {"테이블": key[:2], "키": key}}]
return out + ([{"kind": "글", "글": args}] if args else [])
def _paired(answer: dict) -> dict:
"""줄마다 짝 번호 — 두 칸(이름 꼴 · 값 꼴)이 같은 차례로 놓이게 1 부터."""
at = 0
for group in answer["groups"]:
for one in group["줄"]:
at += 1
one["짝"] = at
one.setdefault("요소조각", [])
return answer
def _extras(
row: dict, shown: list, made: dict, env: dict, master, name_of: dict, alias_by_name: dict
) -> None:
"""덧줄 — 앞선 줄까지의 비목 합을 넣고 한 줄씩(식 안의 비목 이름은 그 수로 바뀜)."""
sums = {
name: sum((one["금액"] or 0 for one in made[name]), Decimal(0)) for name in mf.COST_ITEMS
}
for extra, line in zip(row.get("덧줄") or [], shown):
env.update(sums)
one = {
"이름": extra["이름"],
"글": _extra_text(extra, line, env, master),
"이름글": _extra_names(extra, env, master, name_of),
"금액": line["금액"],
"조각": _formula_pieces(extra["식"], env, master, name_of, alias_by_name),
}
made[extra["비목"]].append(one)
if line["금액"] is not None: # 빈 덧줄은 합·이름 값에 안 넣음
sums[extra["비목"]] += line["금액"]
env[extra["이름"]] = line["금액"]
def _cut_note(row: dict, on: str = "계") -> str:
"""소계에 붙일 끝수 한 마디 — 끝수는 따로 줄로 보이지 않음."""
rule = row.get("끝수")
if not isinstance(rule, dict) or rule.get("대상") != on:
return ""
place = int(rule.get("자리") or 0)
where = "원 미만" if place == 0 else f"소수 {place + 1}째 자리에서"
return f"{where} {rule.get('방법')}"
@@ -1,38 +0,0 @@
# -*- coding: utf-8 -*-
"""재료 줄 요소조각 — 잡힌 자재품목 이름 · 참조(PLAN 8-5). `master_text._item_pieces` 가 부름."""
from __future__ import annotations
import re
import master_formula as mf
import master_pick as mp
_ERRORS = (mf.FormulaError, KeyError, TypeError)
def picked(item: dict, line: dict | None, index: int, env: dict, master) -> dict | None:
"""재료 줄이 잡은 자재품목 줄 — 계산한 줄의 출처(`MT000018.거래가격`) 먼저 ·
빈 줄이면 고름 · 검색어 · 대표로 다시 찾음. 못 찾으면 None."""
got = str((line or {}).get("출처") or "")[:8]
try:
if got[:2] == "MT":
return master.get(got)
cond = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in item["요소"].items()}
key = (mp.CHOSEN.get() or {}).get(str(index))
if not key and cond.get("검색어"):
key = mp.pick(master, cond, env, item.get("단위"))
key = key or cond.get("대표")
return master.get(str(key)) if key and str(key)[:2] == "MT" else None
except _ERRORS:
return None
def piece(item: dict, line: dict | None, index: int, env: dict, master) -> dict | None:
"""요소조각 — 글 = 품목 이름(지역 포함) · 참조 = 테이블 MT · 그 키. 못 찾으면 None."""
row = picked(item, line, index, env, master)
if row is None:
return None
key = str(row["키"])
name = re.sub(r"\s+", " ", str(row.get("이름") or "")).strip()
return {"kind": "요소", "글": name, "참조": {"테이블": key[:2], "키": key}}
+5 -8
View File
@@ -85,19 +85,16 @@ def test_층_SK_한_길_줄_합_기준(world, body):
_one_path(_run(me, _doc(me, key)), _screen(me, key))
def test_옛_엔진_안_돎(world, monkeypatch):
"""한 번 셈에 옛 엔진(`master_formula.run`) 부름 0 · 옛 줄 셈 함수 없음(855-E 2-E4)."""
import importlib
def test_옛_엔진_안_돎(world):
"""옛 엔진 모듈(`master_formula` 무리) 없음 · 옛 줄 셈 함수 없음 · 한 번 셈 됨(855-E 2-E4)."""
import importlib.util
me = world["personal"]
key = _sk(me, 바탕={"로직": FORM})
hits = []
eng = importlib.import_module("master_formula")
real = eng.run
monkeypatch.setattr(eng, "run", lambda *a, **k: hits.append(1) or real(*a, **k))
gone = ("master_formula", "master_formula_sum", "master_auto", "master_text", "master_equation")
assert [m for m in gone if importlib.util.find_spec(m)] == []
assert not hasattr(labor, "run_line")
_one_path(_run(me, _doc(me, key)))
assert hits == []
@pytest.mark.parametrize(