- 새 M02_San_ToDoc.build — 가져온 로직 줄(입력 · 결과 없음 · 호표 손 값 · 중간 식 · 덧줄 · 끝수 · 단계 · 조정)을 문서 파서(master_doc.parse)로 읽어 수식 문서로 지음 · 기호 = master_symbol 규칙 · 단위 채움 = master_doc_unit(_rule) - Doc_Import.derive — master_doc_convert.convert 부름 지움 · _Row(가짜 마스터) 지움 · _ctx 가 고친 줄을 got[ROW] 로 바로 넘김(밖 ctx = 옛 셈 길만 그 색인 줄) · given_of(자동값) 대신 입력값 그대로(가져온 줄 입력 0) - _picks · _swap_nth · _lit · _q · _logic_link · _link_of · _unit_note — mf.parse · mee.raw_text · mf._plain · dc.cv.mm 안 씀(문서 파서 · 작은 글 읽기 · master_material 직접) · 고른 칸 중간 = 표 연결 바로 - 세기(3,241 블록 derive): 변환기 3,241 → 0 · 색인 .logic 73,229 → 3,564 · mf.parse 648,142 → 37,442(남은 것 모두 _ctx 의 sd.clean → Sangeun_Imported 검사 · 2-C3 몫) · 전수 셈 182 → 52 초 - 뜻한 바뀜: 문서 지문 3,241 중 6 블록 금액 줄 기호 번호만 다름(옛 수식 내보내기가 문서에 없는 요소 이름으로 번호 자리를 잡던 것 — C_트럭트랙터3,4 → 2,3 · 금액 · 줄 수 · 이름 · 비목 같음) · 고른 칸 56 중 3 = 옛 흠 고침(조건 이름에 빈칸 · 괄호 → 옛 파서 「식 못 읽음」 · 깨진 변수 → 이제 표 연결) - 지킴: test_857_import_golden 전수 2 통과 · test_812_1 전수 31 · 핵심 시험 98 · 관련 시험 162 · 빌더 --check 같음 · typecheck 0 · 화면(8010 · 봉화 엑셀 · STC 단산21 두 판 2,346 / 2,659 · 시간당 식 · 저장 · 다시 열기 · 지움 · 콘솔 0) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
344 lines
14 KiB
Python
344 lines
14 KiB
Python
"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 걸음 4 설계 3 절) — 서버 단독.
|
||
|
||
불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 `가져온.로직` 줄(+ SK 고침 · 고른 칸 중간)을 불러오기
|
||
자기 모듈에서 문서로 지음 — 옛 변환기(`master_doc_convert`) · 색인 `.logic` · 옛 식 파서
|
||
(`master_formula.parse`) 안 부름 · 식 글 = 문서 파서(`master_doc.parse`).
|
||
가져온 줄 꼴: 입력 · 결과 없음 · 호표 = 손 값(값묶음 · 단가) = 숫자 연결 ·
|
||
중간 = 식 줄(표시 = 반올림) · 고른 칸 중간(`연결` 든 줄) = 그 기호에 바로 연결 ·
|
||
덧줄 = 금액 줄(단가 = 식) · `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 ·
|
||
끝수 · 끝전 · 단계 · 조정 그대로.
|
||
기호 = `master_symbol` 규칙(이름 끝말) · 한 문서 안 겹침 = 아래첨자 끝 숫자.
|
||
변수 단위 = 끝에 `master_doc_unit_rule.before` · `master_doc_unit.fill` · `after`
|
||
(M01 문서와 같은 채움).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
import sys
|
||
from decimal import Decimal
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
_SCRIPTS = Path(__file__).resolve().parents[1] / "resources" / "master_data" / "scripts"
|
||
if str(_SCRIPTS) not in sys.path:
|
||
sys.path.insert(0, str(_SCRIPTS))
|
||
|
||
import master_doc as md # noqa: E402
|
||
import master_doc_unit as mdu # noqa: E402
|
||
import master_doc_unit_rule as mdr # noqa: E402
|
||
import master_symbol as msym # noqa: E402
|
||
|
||
LINE_KEYS = ("번지", "합밖", "자리", "출처", "부착") # 호표 → 금액 줄 그대로 옮기는 칸
|
||
ADD_KEYS = ("번지", "합밖", "자리", "출처") # 덧줄 → 금액 줄
|
||
|
||
|
||
def _clean(text: str) -> str:
|
||
return re.sub(r"[^\w′'·]|_", "", str(text or ""))
|
||
|
||
|
||
def _merge(sign: str, low: str, up: str) -> tuple[str, str, str]:
|
||
"""기호 칸에 첨자까지 든 것(「t_1」)을 가름."""
|
||
if "_" in sign or "^" in sign:
|
||
head, low0, up0 = md.split_id(sign)
|
||
if head != sign:
|
||
return head, low0 + low, up or up0
|
||
return sign, low, up
|
||
|
||
|
||
def _split(me: str) -> dict:
|
||
sign, low, up = md.split_id(me)
|
||
return {"기호": sign, "아래": low, "위": up}
|
||
|
||
|
||
class _Reg:
|
||
"""기호 자리 — 열쇠마다 (기호, 아래, 위) 제안 → 겹침 없는 이름(차례 = 제안 차례)."""
|
||
|
||
def __init__(self) -> None:
|
||
self.props: dict[tuple, tuple[str, str, str]] = {}
|
||
self.ids: dict[tuple, str] = {}
|
||
self.used: set[str] = set()
|
||
self.notes: list[str] = []
|
||
|
||
def want(self, key: tuple, parts: tuple[str, str, str]) -> None:
|
||
self.props.setdefault(key, parts)
|
||
|
||
def settle(self) -> None:
|
||
for key, (sign, low, up) in self.props.items():
|
||
if key in self.ids:
|
||
continue
|
||
if not md.good_id(md.sym_id(sign, "", "")):
|
||
fixed = _clean(sign)
|
||
fixed = fixed if fixed and md.good_id(fixed) else "X"
|
||
self.notes.append(f"기호 「{sign}」 → 「{fixed}」")
|
||
sign = fixed
|
||
n, base = 1, low
|
||
while md.sym_id(sign, low, up) in self.used or not md.good_id(md.sym_id(sign, low, up)):
|
||
n += 1
|
||
low = (base or "")[: msym.SUBMAX - len(str(n))] + str(n)
|
||
if n > 99:
|
||
raise ValueError(f"기호 못 가름 {key}")
|
||
self.used.add(md.sym_id(sign, low, up))
|
||
self.ids[key] = md.sym_id(sign, low, up)
|
||
|
||
def id(self, key: tuple) -> str:
|
||
return self.ids.get(key, "?")
|
||
|
||
|
||
class _Doc:
|
||
def __init__(self, row: dict) -> None:
|
||
self.row, self.reg = row, _Reg()
|
||
self.links: dict[tuple, dict] = {} # 손 값 열쇠 → 변수 칸(이름 · 단위 · 연결)
|
||
self.order: list[tuple] = []
|
||
self.kinds = {s["이름"]: "입력" for s in row.get("입력") or []}
|
||
self.kinds |= {s["이름"]: "중간" for s in row.get("중간") or []}
|
||
self.notes: list[str] = []
|
||
self.used_lines: set[tuple] = set() # 식이 부른 금액 줄 — ('합' | '덧', 이름)
|
||
|
||
def own(self, name: str) -> str:
|
||
if name not in self.kinds:
|
||
self.notes.append(f"모르는 이름 「{name}」")
|
||
return name if md.good_id(name) else "X_" + _clean(name)
|
||
return self.reg.id((self.kinds[name], name))
|
||
|
||
def emit(self, node: tuple, money: dict | None = None) -> tuple:
|
||
kind = node[0]
|
||
if kind == "var":
|
||
name = node[1]
|
||
if money is not None and name in md.COSTS:
|
||
return node
|
||
if money is not None and name in money:
|
||
self.used_lines.add(money[name])
|
||
return ("var", self.reg.id(money[name]))
|
||
return ("var", self.own(name))
|
||
if kind in ("neg", "pct"):
|
||
return (kind, self.emit(node[1], money))
|
||
if kind == "bin":
|
||
return ("bin", node[1], self.emit(node[2], money), self.emit(node[3], money))
|
||
if kind == "call":
|
||
return ("call", node[1], [self.emit(x, money) for x in node[2]])
|
||
if kind == "field":
|
||
base, col = node[1], node[2]
|
||
if base == ("var", "줄") and money is not None:
|
||
self.used_lines.add(("합", col))
|
||
return ("var", self.reg.id(("합", col)))
|
||
if base[0] == "field" and base[1][0] == "var" and base[1][1] in ("번지", "단계"):
|
||
return ("field", ("field", ("var", base[1][1]), base[2]), col)
|
||
return ("field", self.emit(base, money), col)
|
||
return node # num · str
|
||
|
||
def text(self, raw: Any, money: dict | None = None) -> str:
|
||
return md.text_of(self.emit(md.parse(raw), money))
|
||
|
||
def hand(self, at: int, item: dict) -> str:
|
||
"""손 값 줄 — 값묶음(노 · 재 · 경) 또는 손 단가 = 숫자 연결."""
|
||
name = str(item.get("이름") or "")
|
||
given = item.get("값묶음")
|
||
if given:
|
||
if set(given) < set(md.COSTS):
|
||
self.notes.append(f"호표 「{name}」 값묶음 일부 — 빠진 비목 0")
|
||
value: Any = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS}
|
||
else:
|
||
value = Decimal(str(item["단가"]))
|
||
key = ("손", at)
|
||
if key not in self.links:
|
||
self.reg.want(key, msym.lookup(f"{name}단가", "요소"))
|
||
self.order.append(key)
|
||
self.links[key] = {"이름": f"{name}단가", "단위": "", "연결": {}}
|
||
self.links[key]["연결"] = {"갈래": "숫자", "값": value}
|
||
return self.reg.id(key)
|
||
|
||
|
||
def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]:
|
||
"""가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값."""
|
||
c = _Doc(row)
|
||
for kind in ("입력", "중간"):
|
||
for spec in row.get(kind) or []:
|
||
c.reg.want((kind, spec["이름"]), _merge(str(spec["이름"]), "", ""))
|
||
for kind, part in (("합", "호표"), ("덧", "덧줄")):
|
||
for item in row.get(part) or []:
|
||
name = str(item.get("이름") or "")
|
||
c.reg.want((kind, name), msym.lookup(name, "합"))
|
||
doc: dict = {}
|
||
for _ in range(2): # 한 번 = 기호 모음 · 두 번 = 겹침 가른 이름으로 글
|
||
c.reg.settle()
|
||
doc = _build(c, row, given or {})
|
||
c.notes += c.reg.notes
|
||
_slim_doc(doc)
|
||
mdr.before(doc, master) # 847-2 일당 /일 · 기계 기준 글
|
||
mdu.fill(doc, master) # 845-1 빈 단위
|
||
mdr.after(doc) # 847-2 금액 줄 kg · L 표기
|
||
return doc, sorted(set(c.notes))
|
||
|
||
|
||
def _var_row(me: str, name: str, spec: dict, link: dict) -> dict:
|
||
out = {"열쇠": name, **_split(me), "이름": name, "단위": spec.get("단위") or ""}
|
||
for k in ("설명", "출처"):
|
||
if spec.get(k):
|
||
out[k] = spec[k]
|
||
out["연결"] = link
|
||
return out
|
||
|
||
|
||
def _build(c: _Doc, row: dict, given: dict) -> dict:
|
||
variables: list[dict] = []
|
||
for spec in row.get("입력") or []:
|
||
name = spec["이름"]
|
||
value = given.get(name)
|
||
if isinstance(value, (int, float)) and not isinstance(value, bool):
|
||
value = Decimal(str(value))
|
||
if "고르기" in spec:
|
||
link = {"갈래": "선택", "목록": list(spec["고르기"]), "값": value}
|
||
else:
|
||
link = {"갈래": "입력", "값": value} | (
|
||
{"범위": list(spec["범위"])} if spec.get("범위") else {}
|
||
)
|
||
variables.append(_var_row(c.reg.id(("입력", name)), name, spec, link))
|
||
lines: list[dict] = []
|
||
for step in row.get("중간") or []:
|
||
name = step["이름"]
|
||
me = c.reg.id(("중간", name))
|
||
if isinstance(step.get("연결"), dict): # 고른 칸 중간 = 표 연결 바로
|
||
variables.append(_var_row(me, name, step, step["연결"]))
|
||
continue
|
||
try:
|
||
text = c.text(step["식"])
|
||
except md.DocError as e:
|
||
c.notes.append(f"중간 「{name}」 식 못 읽음 — {e}")
|
||
text = str(step["식"])
|
||
if step.get("표시") is not None:
|
||
text = f"반올림({text}, {int(step['표시'])})"
|
||
variables.append(_var_row(me, name, step, {"갈래": "식"}))
|
||
lines.append({"기호": me, "식": text})
|
||
doc = {
|
||
"꼴": "수식문서",
|
||
"판": 1,
|
||
"키": str(row["키"]),
|
||
"이름": row.get("이름") or "",
|
||
"결과단위": row.get("결과단위") or "",
|
||
"출처": row.get("출처") or "",
|
||
}
|
||
money = _money(c, row)
|
||
for key in c.order:
|
||
one, me = c.links[key], c.reg.id(key)
|
||
variables.append({"열쇠": me, **_split(me), **one})
|
||
doc |= {"변수": variables, "식": lines, "금액": money}
|
||
cut = {k: (dict(v) if isinstance(v, dict) else v) for k, v in md.CUT.items()}
|
||
rule = row.get("끝수")
|
||
if isinstance(rule, dict) and rule.get("대상") == "계":
|
||
cut["계"] = {"방법": rule["방법"], "자리": int(rule.get("자리") or 0)}
|
||
if row.get("끝전"):
|
||
cut["끝전"] = row["끝전"]
|
||
doc["끝수"] = cut
|
||
for k in ("단계", "조정"):
|
||
if row.get(k):
|
||
doc[k] = row[k]
|
||
return doc
|
||
|
||
|
||
def _money(c: _Doc, row: dict) -> list[dict]:
|
||
items, adds = row.get("호표") or [], row.get("덧줄") or []
|
||
out: list[dict] = []
|
||
for at, item in enumerate(items):
|
||
name = str(item.get("이름") or "")
|
||
line: dict = {"이름": name}
|
||
if item.get("규격"):
|
||
line["규격"] = item["규격"]
|
||
line["단위"] = item.get("단위") or ""
|
||
try:
|
||
qty = c.text(item["수량"])
|
||
except md.DocError as e:
|
||
c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}")
|
||
qty = str(item["수량"])
|
||
price, line["비목"] = c.hand(at, item), item.get("비목") or "묶음"
|
||
if line["비목"] != "묶음" and item.get("값묶음"):
|
||
price = f"{price}.계"
|
||
line |= {"수량": qty, "단가": price}
|
||
line |= {k: item[k] for k in LINE_KEYS if k in item}
|
||
out.append(line)
|
||
seen: dict[str, tuple] = {}
|
||
for add in adds:
|
||
name = str(add.get("이름") or "")
|
||
try:
|
||
price = c.text(add["식"], dict(seen))
|
||
except md.DocError as e:
|
||
c.notes.append(f"덧줄 「{name}」 식 못 읽음 — {e}")
|
||
price = str(add["식"])
|
||
line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price}
|
||
line |= {k: add[k] for k in ADD_KEYS if k in add}
|
||
out.append(line)
|
||
seen[name] = ("덧", name)
|
||
last = {str(x.get("이름") or ""): i for i, x in enumerate(items)} # 같은 이름 = 뒤 줄
|
||
for i, line in enumerate(out):
|
||
key = ("합", line["이름"]) if i < len(items) else ("덧", line["이름"])
|
||
if key in c.used_lines and (i >= len(items) or last[line["이름"]] == i):
|
||
line["기호"] = c.reg.id(key)
|
||
_groups(out, [*items, *adds])
|
||
return out
|
||
|
||
|
||
def _groups(out: list[dict], items: list[dict]) -> None:
|
||
"""묶음 — 로직 줄마다 한 묶음 · 그 사이 다른 줄은 이어진 것끼리 · 묶음 하나면 안 둠 ·
|
||
호표 `묶음`(848-4) = 그 제목 · 이어진 같은 제목 로직 줄은 한 묶음."""
|
||
runs: list[tuple[str, list[int]]] = []
|
||
for i, item in enumerate(items):
|
||
title = str(item.get("묶음") or "")
|
||
if item.get("종류") == "로직" and title and runs and runs[-1][0] == title:
|
||
runs[-1][1].append(i)
|
||
elif item.get("종류") == "로직":
|
||
runs.append((title or str(item.get("이름") or ""), [i]))
|
||
elif runs and runs[-1][0] == "" and items[runs[-1][1][-1]].get("종류") != "로직":
|
||
runs[-1][1].append(i)
|
||
else:
|
||
runs.append(("", [i]))
|
||
if len(runs) < 2:
|
||
return
|
||
for name, members in runs:
|
||
kinds = [items[i].get("종류") or str(items[i].get("이름") or "") for i in members]
|
||
for i in members:
|
||
out[i]["묶음"] = name or " · ".join(dict.fromkeys(kinds))
|
||
|
||
|
||
# ── 군더더기 걷기(`+ 0` · `× 1` · `A × k ÷ 100` → `A × k%`) ──────────────
|
||
def _is(node: tuple, value: int) -> bool:
|
||
return node[0] == "num" and node[1] == value
|
||
|
||
|
||
def _slim(node: tuple) -> tuple:
|
||
kind = node[0]
|
||
if kind == "bin":
|
||
op, a, b = node[1], node[2], node[3]
|
||
if op == "/" and _is(b, 100) and a[0] == "bin" and a[1] == "*" and a[3][0] == "num":
|
||
return ("bin", "*", _slim(a[2]), ("pct", a[3]))
|
||
a, b = _slim(a), _slim(b)
|
||
if (op in ("+", "-") and _is(b, 0)) or (op in ("*", "/") and _is(b, 1)):
|
||
return a
|
||
if (op == "+" and _is(a, 0)) or (op == "*" and _is(a, 1)):
|
||
return b
|
||
return ("bin", op, a, b)
|
||
if kind in ("neg", "pct"):
|
||
return (kind, _slim(node[1]))
|
||
if kind == "field":
|
||
return ("field", _slim(node[1]), node[2])
|
||
if kind == "call":
|
||
return ("call", node[1], [_slim(x) for x in node[2]])
|
||
return node
|
||
|
||
|
||
def _slim_text(text: Any) -> Any:
|
||
if not isinstance(text, str) or not text.strip():
|
||
return text
|
||
try:
|
||
return md.text_of(_slim(md.parse(text)))
|
||
except md.DocError:
|
||
return text
|
||
|
||
|
||
def _slim_doc(doc: dict) -> None:
|
||
for line in doc.get("식") or []:
|
||
line["식"] = _slim_text(line.get("식"))
|
||
for line in doc.get("금액") or []:
|
||
for k in ("수량", "단가"):
|
||
if k in line:
|
||
line[k] = _slim_text(line[k])
|