Files
Aislo/resources/master_data/scripts/master_doc_convert.py
T
eomsangdonandClaude Opus 5.5 7b1985b693 feat(848-4): 기계 한 대 = 줄 하나 — 조합 줄 나눔 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더 모르는 문서 지킴
- 옛 로직 JSON(한 번 돌림 build_로직_기계줄나눔_848_4.py) → 빌더 → 수식 문서
  · 새 식 GC001202 굴착기(무한궤도) 부착 조합 시간당 기계경비(잡재료 16 % · 8-4 주⑤ · 부품 조합 = 기계 식 고름에서 뺌)
  · 조합 식 부름 69 줄(문서 67) → 같은 묶음 아래 주 기계 줄(GC001202) + 부착 손료 줄(GC000273 · 부착 true)
  · 치즐 소모재료 6 문서 = 두 식 값의 합 · GF000011 · 012 · 320 덧줄 두 기계 손료 = 줄 둘(GF000312 · 313 = 기종 고르기 한 대 — 안 나눔)
  · GC001147 K입력(0 = 표) · GX000004 부름에 K입력=0
- 엔진 짝(master_doc_work ↔ TS) 부착 줄 = 같은 묶음 주 기계 줄 수량 · 답 꼴 따름 · 부착 줄 작업량 고침 안 걸림(저장 정리에서 지움)
- 계산기 짝 · 옛 엔진(master_cut) 부착 줄 끝수 = 묶음 한 덩이 끝수 − 주 기계 줄 몫(줄 둘로 1 원 흔들림 없앰)
- 변환 호표 묶음 · 부착 칸 · 빌더 = 옛 로직 줄 없는 저장본 문서를 안 지우고 제 파일 그대로 · 목록 알림
- 불러오기 조합 첫 줄 = GC001202 부름 · 둘째 줄 값 0 분기 걷음(두 줄 각자 셈)
- 시험 test_848_4 새로 · test_848_1 바이트 비교 → 글 비교(CRLF 체크아웃)
- 금액 전후 = 수식 문서 15 파일 493 문서 9,018 대조 다름 0 · 빌더 1,521 같음(채택 3 그대로)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 22:02:37 +09:00

650 lines
26 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# -*- coding: utf-8 -*-
"""옛 M01 로직 줄 → 수식 문서 변환 (PLAN 802-2 · 요구서_664 1 장 3 · 꼴 `_수식문서_틀.md`).
빌더 `build_수식문서_802_2.py` 가 부름 · 다시 돌리면 같은 결과.
- 기호 = 800-1 · 800-5 기호(수식 탭이 보이는 것
· `master_equation.export` + `master_equation_sign.settle`) ·
못 내보내는 로직은 같은 규칙(`master_symbol`)으로 · 한 문서 안 겹침 = 아래첨자 끝 숫자.
- 입력 = 선택(고르기) · 입력 · 값 = 기본 옵션(`master_equation.given_of`) · 중간 = 식 줄
· 한 마디 중간
(표 찾기 · 요소 · 로직 부름 하나) = 그 기호에 바로 연결 · 표 찾기 · 요소
· 로직 부름 = 기호 + 연결.
- 호표 = 금액 줄(수량 × 단가 · 단가 = 요소 · 재료 고르기 · 단가산출 묶음)
· 덧줄 = 금액 줄(단가 = 식) ·
`줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 결과 · 표시 = 식 안 반올림
· 금액 끝수 = 문서 `끝수`.
- 변수 단위 = 끝에 `master_doc_unit.fill`(845-1 · 빈 단위를 원본 · 식 셈 · 금액 줄 역산으로)
· 앞뒤 `master_doc_unit_rule`(847-2 · 일당 /일 · 기계 기준 글 · 금액 줄 표기).
옛 엔진 셈은 안 함(기호 · 이름 보기만 export 를 씀).
"""
from __future__ import annotations
import re
from decimal import Decimal
import master_doc as md
import master_doc_unit as mdu
import master_doc_unit_rule as mdr
import master_equation as meq
import master_equation_edit as mee
import master_equation_sign as mes
import master_formula as mf
import master_material as mm
import master_symbol as msym
_ERR = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, IndexError)
SUBMAX = msym.SUBMAX
def _harvest(master, key: str) -> dict:
"""수식 탭 내보내기 기호 — (꼴, 갈래, 식 | 열쇠) → 마디 · 못 내보내면 빈 것."""
try:
ex = mes.settle(meq.export(master, key))
except _ERR:
return {}
out: dict = {}
def visit(t):
if isinstance(t, list):
for x in t:
visit(x)
elif isinstance(t, dict):
if t.get("꼴") in ("변수", "블록"):
out.setdefault((t["꼴"], t.get("갈래"), str(t.get("식") or t.get("열쇠"))), t)
for k, v in t.items():
if k != "나무" and isinstance(v, (dict, list)):
visit(v)
for line in ex.get("줄") or []:
visit(line.get("이름식"))
if isinstance(line.get("결과"), dict):
head = line["결과"]
out.setdefault(("머리", line.get("갈래"), str(head.get("열쇠"))), head)
return out
_CODE = re.compile(r"^(?:EQ|MT|LB)\d")
def res_low(master, link: dict, low: str) -> str:
"""요소 키가 아래첨자로 샌 것(`k_EQ0006` · 804-7 · 요구 687-18) → 자원 이름 끝 낱말(`k_하베스터`) ·
괄호 · 쉼표 뒤 · 숫자로 시작하는 규격 낱말 뺌 · 겹침은 부른 쪽이 2 · 3."""
if not _CODE.match(low or "") or (link or {}).get("갈래") != "요소":
return low
try:
row = master.get(str(link.get("키") or ""))
except _ERR:
return low
name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0]
words = [w for w in name.split() if not w[:1].isdigit()]
got = msym.short(words[-1]) if words else ""
return got if got and got != "·" else low
def _clean(text: str) -> str:
"""기호 · 첨자 글 다듬기 — 낱말 아닌 글 뺌."""
return re.sub(r"[^\w′'·]|_", "", str(text or ""))
class _Reg:
"""기호 자리 — 열쇠마다 (기호, 아래, 위) 제안 → 겹침 없는 이름."""
def __init__(self):
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 "")[: 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 _Conv:
def __init__(self, master, row: dict, given: dict):
self.master, self.row, self.given = master, row, given
self.key = str(row["키"])
self.found = _harvest(master, self.key)
self.table = {v["열쇠"]: v for v in meq.table(row, master)}
self.reg = _Reg()
self.links: dict[tuple, dict] = {} # 열쇠 → 변수 칸(이름 · 단위 · 연결)
self.order: list[tuple] = []
self.alias: dict[str, tuple] = {} # 한 마디 중간 식 → ('중간', 이름)
self.names = {s["이름"] for s in row.get("입력") or []} | {
s["이름"] for s in row.get("중간") or []
}
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() # 식이 부른 금액 줄 — ('합' | '덧', 이름)
self.quiet = "" # 한 마디 중간 연결만 뜰 때(그 마디 식) — 기호 자리 안 잡음
self.last: dict = {}
# 기호 제안
def _look(self, kind: str, raw: str) -> dict | None:
for k in (("변수", kind, raw), ("블록", None, raw), ("변수", "요소", raw)):
if k in self.found:
return self.found[k]
return None
def _var(self, key: tuple, family: str, raw: str, name: str, link: dict, unit: str = "") -> str:
if self.quiet and self.quiet == raw:
self.quiet, self.last = "", link
return "?"
if key not in self.links:
node = self._look(family, raw) or {}
sign = str(node.get("기호") or "")
if sign and node.get("기호") != node.get("열쇠"):
parts = _merge(sign, str(node.get("아래") or ""), str(node.get("위") or ""))
else:
fam = {"블록": "결과"}.get(family, family)
parts = msym.lookup(name or raw, fam if fam in msym.FAMILY else "요소")
parts = (parts[0], res_low(self.master, link, parts[1]), parts[2])
self.reg.want(key, parts)
self.order.append(key)
label = str(node.get("이름") or name or raw)
self.links[key] = {
"이름": label,
"단위": str(node.get("단위") or unit or ""),
"연결": link,
}
self.links[key]["연결"] = link # 두 번째 돌이 = 겹침 가른 이름으로 쓴 연결
return self.reg.id(key)
def own(self, name: str) -> str:
"""입력 · 중간 이름 → 기호."""
if name not in self.names:
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 holes(self, text):
if not isinstance(text, str):
return text
return md.HOLE.sub(lambda m: "{" + self.own(m.group(1)) + "}", text)
def _place(self) -> dict:
out = {}
if mm.REGION in self.kinds:
out["지역"] = self.own(mm.REGION)
if mm.TARIFF in self.kinds:
out["계약종별"] = self.own(mm.TARIFF)
return out
# 식
def emit(self, node, money: dict | None = None):
kind = node[0]
if kind in ("num", "str"):
return node
if kind == "name":
name = node[1]
if money is not None and name in md.COSTS:
return ("var", name)
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 == "ref":
return ("var", self.element(node[1]))
if kind == "neg":
return ("neg", 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 == "find":
return ("var", self.find(node, None))
if kind == "logic":
return ("var", self.block(node, None))
base, col = node[1], node[2]
if base[0] == "find":
return ("var", self.find(base, col))
if base[0] == "logic":
return ("var", self.block(base, col))
if base[0] == "ref":
return ("var", self.element(base[1], col))
if base[0] == "name" and base[1] == "줄" and money is not None:
self.used_lines.add(("합", col))
return ("var", self.reg.id(("합", col)))
if base[0] == "field" and base[1][0] == "name" and base[1][1] in ("번지", "단계"):
return ("field", ("field", ("var", base[1][1]), base[2]), col)
return ("field", self.emit(base, money), col)
def text(self, raw, money: dict | None = None) -> str:
return md.text_of(self.emit(mf.parse(raw), money))
# 연결 마디
def find(self, node, col) -> str:
raw = mee.raw_text(node if col is None else ("field", node, col))
if raw in self.alias:
return self.reg.id(self.alias[raw])
link = {"갈래": "표", "표": self.holes(node[1])}
link["조건"] = {k: md.text_of(self.emit(v)) for k, v in node[2]}
if col is None:
self.notes.append(f"칸 없는 찾기 「{raw}」")
else:
link["칸"] = col
return self._var(("찾기", raw), "찾기", raw, col or raw, link)
def block(self, node, col) -> str:
raw = mee.raw_text(node if col is None else ("field", node, col))
if raw in self.alias:
return self.reg.id(self.alias[raw])
link = {"갈래": "단가산출", "키": self.holes(node[1])}
link["입력"] = {k: md.text_of(self.emit(v)) for k, v in node[2]}
if col is not None:
link["칸"] = col
try:
sub = self.master.logic(mf.fill(node[1], {})) if "{" not in node[1] else {}
except _ERR:
sub = {}
unit = str(sub.get("결과단위") or "")
return self._var(("블록", raw), "블록", raw, str(sub.get("이름") or node[1]), link, unit)
def element(self, ref: str, col: str | None = None, unit: str | None = None) -> str:
raw = ref if col is None else mee.raw_text(("field", ("ref", ref), col))
if raw in self.alias and unit is None:
return self.reg.id(self.alias[raw])
link = {"갈래": "요소", "키": self.holes(ref)}
if col is not None:
link["칸"] = col
if unit is not None:
link["단위"] = unit
link |= self._place()
try:
label = self.master.label(ref) if "{" not in ref else ref
except _ERR:
label = ref
return self._var(("요소", raw, unit), "요소", raw, label, link)
def material(self, at: int, item: dict) -> str:
cond = {k: self.holes(v) for k, v in item["요소"].items()}
link = {"갈래": "요소", "재료": cond, "단위": item.get("단위") or ""} | self._place()
name = str(item.get("이름") or "")
return self._var(("재료", at), "요소", f"단가:{name}", f"{name}단가", link)
def lone(self, raw: str):
"""한 마디 식(표 찾기 · 요소 · 로직 부름 하나) — 마디 · 아니면 None."""
try:
node = mf.parse(raw)
except mf.FormulaError:
return None
if node[0] in ("ref", "logic"):
return node
if node[0] == "field" and node[1][0] in ("find", "logic", "ref"):
return node
return None
def _merge(sign: str, low: str, up: str) -> tuple[str, str, str]:
"""기호 칸에 첨자까지 든 것(「t_1」 · 「C_m」)을 가름."""
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 _parts(var: dict) -> tuple[str, str, str]:
return _merge(
str(var.get("기호") or var["열쇠"]), str(var.get("아래") or ""), str(var.get("위") or "")
)
def _line_parts(c: _Conv, name: str) -> tuple[str, str, str]:
head = c.found.get(("머리", "호표", name)) or c.found.get(("머리", "덧줄", name)) or {}
if head.get("기호") and head.get("기호") != name:
return str(head["기호"]), str(head.get("아래") or ""), str(head.get("위") or "")
return msym.lookup(name, "합")
def convert(master, row: dict, given: dict | None = None) -> tuple[dict, list[str]]:
"""로직 줄 → (수식 문서, 알림). given = 기본 옵션(없으면 `given_of`)."""
given = meq.given_of(master, row) if given is None else given
c = _Conv(master, row, given)
for spec in row.get("입력") or []:
c.reg.want(
("입력", spec["이름"]), _parts(c.table.get(spec["이름"], {"열쇠": spec["이름"]}))
)
for step in row.get("중간") or []:
c.reg.want(
("중간", step["이름"]), _parts(c.table.get(step["이름"], {"열쇠": step["이름"]}))
)
for item in row.get("호표") or []:
c.reg.want(("합", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or "")))
for item in row.get("덧줄") or []:
c.reg.want(("덧", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or "")))
lone_steps = {}
for step in row.get("중간") or []:
node = c.lone(step["식"])
if node is not None and step.get("표시") is None:
raw = mee.raw_text(node)
if raw not in c.alias:
c.alias[raw] = ("중간", step["이름"])
lone_steps[step["이름"]] = node
doc = None
for _ in range(2): # 한 번 = 기호 모음 · 두 번 = 겹침 가른 이름으로 글
c.reg.settle()
doc = _build(c, row, given, lone_steps)
c.notes += c.reg.notes
doc = slim_doc(doc)
if hasattr(master, "numbers"): # 빌더 · 실행 중 변환 한 벌 — 변수 단위 채움(845-1)
mdr.before(doc, master) # 847-2 일당 /일 · 기계 기준 글
mdu.fill(doc, master)
mdr.after(doc) # 847-2 금액 줄 kg · L 표기
return doc, sorted(set(c.notes))
def _is(node, value) -> bool:
return node[0] == "num" and node[1] == value
def slim(node):
"""옮김 군더더기 걷기(802-3) — `+ 0` · `- 0` · `× 1` · `÷ 1` 지움 · `A × k ÷ 100` → `A × k%`(값 같음)."""
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):
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) -> dict:
"""식 줄 · 금액 줄(수량 · 단가) 글에 `slim`."""
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])
return doc
def _link_of(c: _Conv, node) -> dict:
"""한 마디 중간의 연결 — 찾기 · 요소 · 로직 부름."""
alias = dict(c.alias)
c.alias, c.quiet, c.last = {}, mee.raw_text(node), {}
try:
c.emit(node)
return dict(c.last)
finally:
c.alias, c.quiet = alias, ""
def _build(c: _Conv, row: dict, given: dict, lone_steps: dict) -> dict:
variables: list[dict] = []
for spec in row.get("입력") or []:
name = spec["이름"]
look = c.table.get(name, {})
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}
if spec.get("범위"):
link["범위"] = list(spec["범위"])
variables.append(_var_row(c.reg.id(("입력", name)), name, look, spec, link))
lines: list[dict] = []
for step in row.get("중간") or []:
name = step["이름"]
look = c.table.get(name, {})
me = c.reg.id(("중간", name))
if name in lone_steps:
variables.append(_var_row(me, name, look, step, _link_of(c, lone_steps[name])))
continue
try:
text = c.text(step["식"])
except mf.FormulaError 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, look, step, {"갈래": "식"}))
lines.append({"기호": me, "식": text})
doc = {
"꼴": "수식문서",
"판": 1,
"키": c.key,
"이름": row.get("이름") or "",
"결과단위": row.get("결과단위") or "",
"출처": row.get("출처") or "",
**({"부품": row["부품"]} if row.get("부품") else {}), # 813-2 부품 표지
}
money: list[dict] = []
if "결과" in row:
head = c.found.get(("머리", "결과", "결과")) or {}
sign = head.get("기호") if msym.is_symbol(str(head.get("기호") or "")) else ""
parts = (sign, str(head.get("아래") or ""), str(head.get("위") or "")) if sign else None
parts = parts or msym.rule(str(row.get("결과단위") or ""), "결과")[:3]
c.reg.want(("결과", "결과"), parts)
text = c.text(row["결과"]["식"])
rule = row.get("끝수")
if isinstance(rule, dict) and rule.get("대상") == "결과":
text = f"{rule['방법']}({text}, {int(rule.get('자리') or 0)})"
me = c.reg.id(("결과", "결과"))
variables.append(
{
"열쇠": "결과",
**_split(me),
"이름": "결과",
"단위": row.get("결과단위") or "",
"연결": {"갈래": "식"},
}
)
lines.append({"기호": me, "식": text})
doc["결과"] = me
else:
money = _money(c, row)
for key in c.order:
if key[0] in ("입력", "중간") or key in [("결과", "결과")]:
continue
if any(alias == key for alias in c.alias.values()):
continue
one = c.links[key]
me = c.reg.id(key)
variables.append(
{
"열쇠": me,
**_split(me),
"이름": one["이름"],
"단위": one["단위"],
"연결": 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 _split(me: str) -> dict:
sign, low, up = md.split_id(me)
return {"기호": sign, "아래": low, "위": up}
def _var_row(me: str, name: str, look: dict, spec: dict, link: dict) -> dict:
out = {
"열쇠": name,
**_split(me),
"이름": look.get("이름") or name,
"단위": spec.get("단위") or "",
}
for k in ("설명", "출처"):
if spec.get(k):
out[k] = spec[k]
out["연결"] = link
return out
def _hand(c: _Conv, at: int, item: dict) -> str:
"""손 값 줄 — 값묶음(노 · 재 · 경) 또는 손 단가 = 숫자 연결."""
name = str(item.get("이름") or "")
given = item.get("값묶음")
if given:
if set(given) < set(md.COSTS):
c.notes.append(f"호표 「{name}」 값묶음 일부 — 빠진 비목 0")
value = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS}
else:
value = Decimal(str(item["단가"]))
link = {"갈래": "숫자", "값": value}
return c._var(("손", at), "요소", f"단가:{name}", f"{name}단가", link)
def _group_name(items: list[dict]) -> str:
kinds = []
for x in items:
k = x.get("종류") or str(x.get("이름") or "")
if k not in kinds:
kinds.append(k)
return " · ".join(kinds)
def _money(c: _Conv, 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 = {"이름": name}
if item.get("규격"):
line["규격"] = item["규격"]
line["단위"] = item.get("단위") or ""
try:
qty = c.text(item["수량"])
except mf.FormulaError as e:
c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}")
qty = str(item["수량"])
kind = item.get("종류")
if item.get("값묶음") or item.get("단가") is not None: # M02 손 값(값묶음 · 손 단가)
price, line["비목"] = _hand(c, at, item), item.get("비목") or "묶음"
if line["비목"] != "묶음" and item.get("값묶음"):
price = f"{price}.계"
elif kind == "로직":
node = mf.parse(str(item["요소"]))
price = md.text_of(c.emit(node))
bundle = node[0] == "logic"
if "비목" in item:
line["비목"] = item["비목"]
if bundle:
price = f"{price}.계"
else:
line["비목"] = "묶음"
elif isinstance(item.get("요소"), dict):
line["비목"] = item["비목"]
price = c.material(at, item)
else:
line["비목"] = item["비목"]
ref = str(
item["요소"]
) # 품셈재료(MP)만 줄 단위로 값이 갈림 — 그 밖은 식 속 요소와 한 기호
price = c.element(
ref, None, str(item.get("단위") or "") if ref[:2] == mm.LINKED else None
)
line |= {"수량": qty, "단가": price}
for k in (
"번지",
"합밖",
"자리",
"출처",
"부착",
): # 부착 = 같은 묶음 주 기계 줄을 따름(848-4)
if k in item:
line[k] = item[k]
out.append(line)
seen: dict[str, tuple] = {}
for add in adds:
name = str(add.get("이름") or "")
try:
price = c.text(add["식"], dict(seen))
except mf.FormulaError as e:
c.notes.append(f"덧줄 「{name}」 식 못 읽음 — {e}")
price = str(add["식"])
line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price}
for k in ("번지", "합밖", "자리", "출처"):
if k in add:
line[k] = add[k]
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:
label = name or _group_name([items[i] for i in members])
for i in members:
out[i]["묶음"] = label