From fab6ad68ac13d49152d4c1162e24bb0a1f2f9f9d Mon Sep 17 00:00:00 2001 From: umsangdon Date: Tue, 17 Nov 2026 23:19:13 +0900 Subject: [PATCH] =?UTF-8?q?refactor(857-3a):=20=EA=B0=80=EC=A0=B8=EC=98=A8?= =?UTF-8?q?=20=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EC=A7=93=EA=B8=B0=20=3D=20?= =?UTF-8?q?=EB=B6=88=EB=9F=AC=EC=98=A4=EA=B8=B0=20=EC=9E=90=EA=B8=B0=20?= =?UTF-8?q?=EB=AA=A8=EB=93=88(M02=5FSan=5FToDoc)=20=E2=80=94=20=EB=B3=80?= =?UTF-8?q?=ED=99=98=EA=B8=B0=20=C2=B7=20=EC=83=89=EC=9D=B8=20.logic=20?= =?UTF-8?q?=C2=B7=20=EC=98=9B=20=EC=8B=9D=20=ED=8C=8C=EC=84=9C=20=EC=95=88?= =?UTF-8?q?=20=EB=B6=80=EB=A6=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 새 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 --- M02_MasterTemplete/M02_Doc_Import.py | 104 ++++---- M02_MasterTemplete/M02_San_ToDoc.py | 343 +++++++++++++++++++++++++++ 2 files changed, 399 insertions(+), 48 deletions(-) create mode 100644 M02_MasterTemplete/M02_San_ToDoc.py diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index 2b558fa89..5e462657a 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -1,7 +1,7 @@ """M02 가져온 식(엑셀 불러오기) 단가산출 = 수식 문서(PLAN 802-4b-1 · 요구 664 · 665) — 서버 단독. -경쟁사 산근 블록도 같은 꼴(식 + 값)로 들어옴 — 엑셀 단가 그대로 엔진 줄(`가져온.로직` + SK 고침)을 -`master_doc_convert` 로 문서로 옮기고(손 값 = 숫자 연결 · 중간 = 식 줄 · 덧줄 = 금액 줄 식 · 끝수 · +경쟁사 산근 블록도 같은 꼴(식 + 값)로 들어옴 — 엑셀 단가 그대로 고친 줄(`가져온.로직` + SK 고침)을 +`M02_San_ToDoc` 으로 문서로 짓고(손 값 = 숫자 연결 · 중간 = 식 줄 · 덧줄 = 금액 줄 식 · 끝수 · 단계 · 조정 · 합밖 · 자리 그대로) 이은 것을 연결로 얹음 · 연결마다 엑셀 값을 기억(`엑셀` 칸): 인력 · 재료 · 유가 · 전력 · 환율 이음 = 요소 {키} · 기계 이음(EQ) = 기계경비 단가산출 {키 GC, 입력 기계 …, 칸 = 그 줄 비목}(시간당 자료 없음 = 숫자 그대로 · 설명) · @@ -16,6 +16,7 @@ from __future__ import annotations import copy as cp +import re from decimal import Decimal from typing import Any @@ -24,6 +25,7 @@ from M02_MasterTemplete import M02_Doc_Import_Q as qt from M02_MasterTemplete import M02_Doc_Import_Shape as shape from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_San_MatPick as mp +from M02_MasterTemplete import M02_San_ToDoc as todoc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sangeun_Imported as imp @@ -80,7 +82,7 @@ def _engine_adds(doc: dict) -> bool: def _ctx(sk: dict, whole: Any) -> tuple: """엑셀 단가 기준 고친 줄(855 2-C2) — 가져온 로직 줄(`row_of`) + 수식 고침 · SK 고침(`sd.patched`) · - 더한줄 고정 값(`fixed.line`) → (색인, 키, 입력, {정체}, None) · 옛 엔진 안 돎. + 더한줄 고정 값(`fixed.line`) → (색인, 키, 입력, {정체, 고친 줄(`ROW`)}, None) · 옛 엔진 안 돎. 안쪽 산근(형제 SK) 줄 값 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음). `_engine_adds` 인 SK 만 옛 셈 길(그 더한줄 값이 엔진 답 — 2-C1 · 2-C5 몫).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc @@ -110,7 +112,10 @@ def _ctx(sk: dict, whole: Any) -> tuple: key = str(doc.get("키") or "SK-000000") names = {str(i.get("이름")) for i in row.get("입력") or []} values = {k: v for k, v in (doc.get("입력값") or {}).items() if k in names} - return _Row(w, key, {**row, "키": key}), key, values, {"정체": got["정체"]}, None + return w, key, values, {"정체": got["정체"], ROW: {**row, "키": key}}, None + + +ROW = "고친줄" # `_ctx` 가 넘기는 엑셀 단가 기준 고친 줄(857-3a — 색인 `.logic` 안 부름) def _old_ctx(raw: dict, whole: Any) -> tuple: @@ -128,25 +133,28 @@ def _old_ctx(raw: dict, whole: Any) -> tuple: # ── 소요량 · 계수 고른 칸 → 수 자리에 기호 ────────────────────────────── +CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자 — 수 세기에서 뺌(`QtyLinks._literals`) + + def _swap_nth(node: Any, n: int, new: tuple, seen: list) -> Any: - """`M02_Sangeun_QtyLinks._literals` 차례의 n 번째 수 → `new` 마디(같은 걸음 규칙).""" - mf = dc.cv.mf + """`M02_Sangeun_QtyLinks._literals` 차례의 n 번째 수 → `new` 마디(같은 걸음 규칙 · 문서 식 나무) · + 다른 수 = 끝 0 뗀 글(옛 엔진 글과 같게).""" if not isinstance(node, tuple): return node kind = node[0] if kind == "num": seen[0] += 1 - return new if seen[0] - 1 == n else node + return new if seen[0] - 1 == n else ("num", node[1].normalize()) if kind == "bin": - cmp_ = node[1] in mf._OPS + cmp_ = node[1] in CMP sides = [ - side - if cmp_ and isinstance(side, tuple) and side[0] == "num" + ("num", side[1].normalize()) + if cmp_ and side[0] == "num" else _swap_nth(side, n, new, seen) for side in node[2:] ] return (kind, node[1], *sides) - if kind in ("neg", "field"): + if kind in ("neg", "pct", "field"): return (kind, _swap_nth(node[1], n, new, seen), *node[2:]) if kind == "call": return ("call", node[1], [_swap_nth(a, n, new, seen) for a in node[2]]) @@ -177,9 +185,8 @@ def _conds(table: dict, at: int) -> dict | None: def _picks(row: dict, ids: list[str], base: list[str], meta: dict, master: Any) -> dict: - """고른 칸(`가져온.연결.고름`) → 중간 줄(표 찾기 하나 · 연결 기호) · 수 자리에 그 기호 ÷ 배 · + """고른 칸(`가져온.연결.고름`) → 중간 줄(표 연결 바로 · `San_ToDoc`) · 수 자리에 그 기호 ÷ 배 · 돌려줌 = {중간 이름: 엑셀 칸 값}. 자리 줄이 SK 고침으로 바뀌었으면 건너뜀.""" - mf, mee = dc.cv.mf, dc.cv.mee src = meta["로직"] picked = ((meta.get("연결") or {}).get("고름")) or [] out: dict[str, Any] = {} @@ -203,7 +210,7 @@ def _picks(row: dict, ids: list[str], base: list[str], meta: dict, master: Any) try: table = master.get(str(one.get("표"))) conds = _conds(table, int(one.get("줄"))) - node = mf.parse(str(mine[field])) + node = dc.md.parse(str(mine[field])) except Exception: # noqa: BLE001 — 표 · 식 못 읽음 = 수 그대로 continue if conds is None: @@ -216,15 +223,14 @@ def _picks(row: dict, ids: list[str], base: list[str], meta: dict, master: Any) if scale is None: continue ref = ( - ("name", name) + ("var", name) if scale == 1 - else ("bin", "/", ("name", name), ("num", Decimal(str(scale)))) - ) - mine[field] = mee.raw_text(_swap_nth(node, int(n), ref, [0])) - args = ", ".join(f"{k}={_lit(v)}" for k, v in conds.items()) - mids.append( - {"이름": name, "식": f"찾기({one['표']}{', ' if args else ''}{args}).{_q(one['칸'])}"} + else ("bin", "/", ("var", name), ("num", Decimal(str(scale)))) ) + mine[field] = dc.md.text_of(_swap_nth(node, int(n), ref, [0])) + link = {"갈래": "표", "표": str(one["표"]).strip()} + link |= {"조건": {k: _lit(v) for k, v in conds.items()}, "칸": str(one["칸"])} + mids.append({"이름": name, "연결": link}) out[name] = Decimal(str(one.get("값"))) return out @@ -236,12 +242,15 @@ def _near(one: dict, m: float) -> bool: def _lit(v: Any) -> str: if isinstance(v, (int, float, Decimal)) and not isinstance(v, bool): - return dc.cv.mf._plain(Decimal(str(v))) + return format(Decimal(str(v)).normalize(), "f") return "'" + str(v).replace("'", "") + "'" +_BARE = re.compile(r"[^\W\d]\w*") # 따옴표 없이 쓰는 이름 + + def _q(name: Any) -> str: - return dc.cv.mee._q(str(name)) + return str(name) if _BARE.fullmatch(str(name)) else f"'{name}'" # ── 이음 → 연결 ──────────────────────────────────────────────────────── @@ -263,15 +272,24 @@ def hourly_link(eq: str, part: str) -> dict | None: return {"갈래": "단가산출", "키": str(logic["키"]), "입력": given, "칸": part} +_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])") +_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))") + + def _logic_link(text: str) -> dict | None: - """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None.""" - try: - node = dc.cv.mf.parse(text) - except Exception: # noqa: BLE001 + """「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(불러오기가 짓는 글 꼴).""" + s = str(text) + head = _HEAD.match(s) + if head is None: return None - if node[0] != "logic" or any(v[0] not in ("num", "str") for _, v in node[2]): + at, given = head.end(), {} + while arg := _ARG.match(s, at): + name = arg[1] if arg[1] is not None else arg[2] + given[name] = f"'{arg[3]}'" if arg[3] is not None else _lit(Decimal(arg[4])) + at = arg.end() + if not re.fullmatch(r"\s*\)\s*", s[at:]): return None - return {"갈래": "단가산출", "키": node[1], "입력": {k: _lit(v[1]) for k, v in node[2]}} + return {"갈래": "단가산출", "키": head[1], "입력": given} def _link_of(item: dict) -> tuple[dict | None, str]: @@ -294,10 +312,12 @@ def _link_of(item: dict) -> tuple[dict | None, str]: return got, "" if got else f"기계 {key} 시간당 경비 자료 없음 — 엑셀 단가 그대로" if key.startswith("MO") and (got := _oil(key)): return got, "" + import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤 + link = {"갈래": "요소", "키": key} - if key[:2] == dc.cv.mm.LINKED: # 품셈재료 = 줄 단위로 값이 갈림(M01 변환과 같음) + if key[:2] == mm.LINKED: # 품셈재료 = 줄 단위로 값이 갈림(M01 변환과 같음) link["단위"] = str(item.get("단위") or "") - if key[:2] == dc.cv.mm.MARKET and (unit := str(item.get("단위") or "")): + if key[:2] == mm.MARKET and (unit := str(item.get("단위") or "")): link["단위"] = unit # 840-3 자재품목 = 셈이 줄 단위로 환산(`master_pick.priced`) return link, _unit_note(key, unit) return link, "" @@ -305,7 +325,9 @@ def _link_of(item: dict) -> tuple[dict | None, str]: def _unit_note(key: str, unit: str) -> str: """840-3 자재 단위 ↔ 줄 단위 글 — 같음 · 1 : 1 = 빈 글 · 같은 성격 = 환산 · 성격 다름 = 경고(사람이 고른 줄도).""" - mu = dc.cv.mm.mu + import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤 + + mu = mm.mu try: have = str(imp._whole().get(key).get("단위") or "") except Exception: # noqa: BLE001 — 없는 키 = 셈이 끊김 표지 @@ -453,14 +475,13 @@ def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict: if ctx is None: ctx = _ctx(sk, whole or imp._whole()) master, key, values, got, _ = ctx - row = cp.deepcopy(master.logic(key)) + row = cp.deepcopy(got.get(ROW) or master.logic(key)) # 옛 셈 길이 넘긴 ctx = 그 색인 줄 ids = list(got.get("정체") or []) bare = imp.row_of({**sk, imp.KEY: {**meta, "단가기준": "엑셀"}}) or {} base = sd.line_ids(bare) src = dict(zip(base, meta["로직"].get("호표") or [])) keep = _picks(row, ids, base, meta, master) - given = dc.given_of(master, key, values) - doc, notes = dc.cv.convert(_Row(master, key, row), row, given) + doc, notes = todoc.build(row, master, values) # 857-3a 불러오기 자기 문서 짓기(변환기 안 부름) _attach(doc, row, ids, src) _numbers(doc, keep) native = bool((meta.get("원본") or {}).get("원파일")) @@ -519,19 +540,6 @@ def _empty(doc: dict) -> None: doc["금액"] = [{"이름": "빈 산근", "단위": "식", "비목": "묶음", "단가": "P_빈"}] -class _Row: - """변환 색인 — 이 SK 줄만 고친 줄(소요량 중간 더함)로 · 그 밖 그대로.""" - - def __init__(self, master: Any, key: str, row: dict) -> None: - self._m, self._k, self._r = master, key, row - - def logic(self, ref: str) -> dict: - return self._r if ref == self._k else self._m.logic(ref) - - def __getattr__(self, name: str) -> Any: - return getattr(self._m, name) - - # ── 셈 ──────────────────────────────────────────────────────────────── def view(doc: dict, basis: str) -> dict: """단가기준 엑셀 = 엑셀 값 기억 연결(형제 SK 빼고)을 숫자로 · 우리 = 그대로 · 기계 줄(입력 「기계」)은 diff --git a/M02_MasterTemplete/M02_San_ToDoc.py b/M02_MasterTemplete/M02_San_ToDoc.py new file mode 100644 index 000000000..a4acf2a37 --- /dev/null +++ b/M02_MasterTemplete/M02_San_ToDoc.py @@ -0,0 +1,343 @@ +"""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])