"""M02 가져온 식 로직 줄 → 수식 문서(PLAN 857-3a · 857-3b · 걸음 4 설계 3 절) — 서버 단독. 불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 가져온 줄을 불러올 때 한 번 문서로 지음 (저장 = 그 문서) — 옛 변환기(`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 FROM = "가져온줄" # 857-3b 문서 금액 줄 · 값 변수 ↔ 가져온 줄 자리(`호표:i` · `덧줄:i`) KIND = "가져온종류" # 금액 줄 ↔ 가져온 줄 종류(인력 · 재료 · 기계 · 로직) 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, "?") _HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") _ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") def logic_call(text: Any) -> tuple[str, list[tuple[str, tuple]]] | None: """「로직(GC…, 이름='값', 이름=수)」 → (키, [(이름, ('str' | 'num', 값))]) · 그 밖 꼴 = None.""" s = str(text) head = _HEAD.match(s) if head is None: return None at, args = head.end(), [] while arg := _ARG.match(s, at): name = arg[1] if arg[1] is not None else arg[2] args.append((name, ("str", arg[3]) if arg[3] is not None else ("num", Decimal(arg[4])))) at = arg.end() return (head[1], args) if re.fullmatch(r"\s*\)\s*", s[at:]) else None class _Doc: def __init__(self, row: dict, master: Any = None) -> None: self.row, self.reg, self.master = row, _Reg(), master 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["단가"])) got = self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value}) self.links[("손", at)][FROM] = f"호표:{at}" # 857-3b 가져온 줄 자리(이음 · 소요량 고침) return got def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str: """값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙.""" if key not in self.links: self.reg.want(key, msym.lookup(label, "요소")) self.order.append(key) self.links[key] = {"이름": label, "단위": unit, "연결": link} self.links[key]["연결"] = link return self.reg.id(key) def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]: """가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값.""" c = _Doc(row, master) 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} line |= {FROM: f"호표:{at}", KIND: str(item.get("종류") or "")} 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} line[FROM] = f"덧줄:{len(out) - len(items)}" 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])