eomsangdonandClaude Opus 5.5
bed35e3bc3
- 3 연결 찾기 = 엑셀 이름 규격 · 단위 꼬리 뗀 이름으로 맞댐(`M02_Doc_Match_Note.bare` · 보이는 이름 그대로) · STmate 블록 규격도 가져온 칸에
- 4 기계 세 줄 = 기계 한 줄 — STmate X 코드 노 · 재 · 경 세 참조 줄(같은 수량 · 번지) 묶음(묶어서 셈 못 하는 세 줄만 그대로) ·
문서 단계 묶기 넓힘(차례 아무렇게 · 시간당 경비 이음 없으면 엑셀 값 묶음 · 번지 같을 때) · 조합 다음 줄 = 세 줄 뒤 · 같은 기계 한 항목
- 6 공구손료 율 비목 차이(재료비 ↔ 경비) = 참고(`M02_Doc_Match_Value.tool_cost`) — 확정 안 막음
- 7 못 이은 줄 까닭(`M02_San_Link.why` — 자재 없음 · 운임표 없음 · 기계 표에 없음 · 별칭 대기 · 후보 여럿 · 시간당 경비 없음 · 조합) =
문서 설명 · 이음 없는 자원 띠 · 연결 「없음」 띠 = 「우리 기초 없음 — 우리 정보로 셈 n/m 줄」 · 형제만 = 「조합」
- 8 유가 = 전국평균 줄 + 지역 옵션(`MO:경유:{S_지역}`) · 전력 = 일반용(갑)Ⅰ 저압 + 계약종별 옵션 · 엑셀 값 = 검산 칸
- 9 재료 = 지역 꼬리 뗀 이름 · 규격 정확 일치면 이음(지역 여럿 = 줄 지역 › 서울)
- 10 조합 첫 줄 규격 = 그 기계 · 얼린 줄도 소계 식에(북부청임도 33) · 기계 줄 찾기 판정 늘 붙음 · 올린 직후 409(HP 보이기 전 산근 보관) ·
엑셀 블록 「엑셀 읽기 확정」 글 · 전수 도우미 str() 뗌 · 줄 쌓기 이름에 규격이 들면 한 번만
- M02_San_Link 새 파일(San_Emit 700 줄 막음 — 요소 잇기 · 시간당 · 조합 · 까닭)
- 시험: 새 test_814_1 · 812-2 · 810-4 거푸집 41 = 근접 → 확정(공구손료 비목 = 값 · 요구 744 C1) · 바꾸기 거절 견본 = 19 ·
812-9 조합 첫 줄 규격 「0.7+브레이카」 → 「0.7」(칩 글 · 요구 738 흠 12)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
480 lines
20 KiB
Python
480 lines
20 KiB
Python
"""가져온 단가산출 줄 쌓기 차림(PLAN 812-3 · 요구 713 · 669~677) — 경쟁사 산출근거 꼴.
|
|
|
|
금액 · 셈 그대로. `M02_Doc_Import_Shape.shape` 가 부름(`tag` = 다듬기 앞 · `apply` = 끝) ·
|
|
원본 `차림` 표지 있는 블록만(EST = `M02_Doc_NativeEst` · STmate = `M02_San_Emit.stmate`):
|
|
항목 = 머리 줄(글줄 `차림` 「머리」 · 「1. …」 「가. …」 글) · 번호 글은 떼고 화면이 매김 ·
|
|
가 · 나 = `가나다` · STmate 는 계 줄(`단계:`)마다 끊고 그 뒤 첫 글 줄 = 제목 ·
|
|
머리 앞 줄 = 제목 없는 항목 · 합계 줄(「합계」 · 「소계」 절)만 있는 머리 = 뺌
|
|
(화면 소계 · 합계가 냄)
|
|
금액 줄 = 그 자리(원본 행 차례) — EST 는 셈이 같을 때만 금액 차례를 원본 차례로
|
|
(단계 · 누계 이름 없고 기호 부름이 앞 줄일 때)
|
|
공식 묶음 = 변수 대입 줄(`mid:` · 쓰는 차례) · 글 줄 = 근거 · 메모(글줄 `차림` 「글」)
|
|
저장 = 금액 줄 `묶음` = 항목 제목 + 문서 `쌓기`(기본 차림과 다를 때만).
|
|
파이썬 · TS 짝 — `common_util/common_util_line_stack.ts` `stackOf` · `saveOf` ·
|
|
`hiddenOf`(안 놓인 기호 자리 · 기본 차림)의 거울 · 거울 시험
|
|
`resources/tester/test_812_3_native_layout.py`(TS 왕복). 고칠 때 둘을 같이 고침.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
import sys
|
|
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
|
|
|
|
from M02_MasterTemplete import M02_Sangeun_Doc as sd # noqa: E402
|
|
|
|
TAG = "차림" # 글줄 칸 — 머리 | 합계 | 글 · 원본 칸 = 차림 낼 블록
|
|
KEEP = "_로직줄" # 문서 금액 줄 ↔ 로직 줄 차례(다듬기 사이 임시)
|
|
GANADA = "가나다라마바사아자차카타파하"
|
|
NUMBERED = re.compile(rf"^\s*'?\s*(\d{{1,2}}|[{GANADA}])\s*[.)]\s*(?!\d)(\S.*)$")
|
|
_TOTAL = {"합계", "소계", "계"}
|
|
|
|
|
|
def tag(doc: dict, meta: dict) -> None:
|
|
"""다듬기(이름 · 기계 합침) 앞 — 금액 줄마다 로직 줄 차례(호표 → 덧줄)를 적어 둠."""
|
|
row = meta.get("로직") or {}
|
|
n = len(row.get("호표") or []) + len(row.get("덧줄") or [])
|
|
money = doc.get("금액") or []
|
|
if (meta.get("원본") or {}).get(TAG) and money and len(money) == n:
|
|
for k, line in enumerate(money):
|
|
line[KEEP] = k
|
|
|
|
|
|
def title_of(text: str) -> tuple[str, bool]:
|
|
"""「 1. 기 계(100%)」 → (「기 계(100%)」, 거짓) · 「'가. 굴삭기'」 → (「굴삭기」, 가나다)."""
|
|
flat = " ".join(str(text or "").replace("'", " ").split())
|
|
m = NUMBERED.match(flat)
|
|
if not m:
|
|
return flat, False
|
|
return m.group(2).strip(), m.group(1) in GANADA
|
|
|
|
|
|
# ── 차림 ──────────────────────────────────────────────────────────────
|
|
def apply(doc: dict, meta: dict) -> None:
|
|
money = doc.get("금액") or []
|
|
keys = [line.pop(KEEP, None) for line in money]
|
|
src = meta.get("원본") or {}
|
|
if not src.get(TAG) or not money or None in keys:
|
|
return
|
|
from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
|
|
|
row = meta.get("로직") or {}
|
|
ids = sd.line_ids(
|
|
imp.row_of({imp.KEY: {"로직": row}}) or {}
|
|
) # 글줄 자리 = 줄 정체(`imp._named`)
|
|
lines = [*(row.get("호표") or []), *(row.get("덧줄") or [])]
|
|
by: dict[str, int] = {}
|
|
for k, (cid, one) in enumerate(zip(ids, lines)):
|
|
by.setdefault(cid, k)
|
|
by.setdefault(str(one.get("이름")), k)
|
|
inv = {k: j for j, k in enumerate(keys)}
|
|
texts = sorted(
|
|
(t for t in src.get("글줄") or [] if isinstance(t.get("행"), int)), key=lambda t: t["행"]
|
|
)
|
|
at: dict[int, int] = {} # 문서 금액 줄 → 원본 행
|
|
for t in texts:
|
|
for spot in t.get("자리들") or ([t["자리"]] if t.get("자리") else []):
|
|
j = inv.get(by.get(str(spot), -1))
|
|
if j is not None:
|
|
at[j] = min(at.get(j, t["행"]), t["행"])
|
|
rows = _fill([at.get(j) for j in range(len(money))])
|
|
for j in range(1, len(rows)): # 조합 다음 줄을 세 줄 뒤로 옮긴 것(814-1 `Import_Shape.regroup`)
|
|
if money[j].get("_뒤"):
|
|
rows[j] = max(rows[j], rows[j - 1])
|
|
order = sorted(range(len(money)), key=lambda j: (rows[j], j))
|
|
if order != list(range(len(money))) and _safe(doc, order):
|
|
doc["금액"] = money = [money[j] for j in order]
|
|
rows = [rows[j] for j in order]
|
|
else:
|
|
for j in range(1, len(rows)): # 차례 그대로 — 앞 줄보다 위면 앞 줄 자리로
|
|
rows[j] = max(rows[j], rows[j - 1])
|
|
items = _items(doc, texts, rows, src.get("갈래") == "STmate")
|
|
for it in items:
|
|
for kind, j in it["줄"]:
|
|
if kind == "금액":
|
|
money[j].pop("묶음", None)
|
|
money[j] |= {"묶음": it["제목"]} if it["제목"] else {}
|
|
raw = [_save_item(it, money) for it in items]
|
|
doc.pop("쌓기", None)
|
|
plain = save_of(stack_of(doc), money)
|
|
got = save_of(stack_of({**doc, "쌓기": raw}), money)
|
|
if got != plain:
|
|
doc["쌓기"] = got
|
|
|
|
|
|
def _fill(rows: list[int | None]) -> list[int]:
|
|
"""원본 행 없는 줄(글줄에 안 붙은 소계 덧줄 등) = 다음 줄 행 · 없으면 앞 줄 행."""
|
|
out = list(rows)
|
|
for j in range(len(out) - 1, -1, -1):
|
|
if out[j] is None and j + 1 < len(out):
|
|
out[j] = out[j + 1]
|
|
for j in range(len(out)):
|
|
if out[j] is None:
|
|
out[j] = out[j - 1] if j else 0
|
|
return [int(x or 0) for x in out]
|
|
|
|
|
|
def _safe(doc: dict, order: list[int]) -> bool:
|
|
"""금액 차례를 바꿔도 셈이 같음 — 단계 없음 · 누계 · 번지 · 단계 이름 안 씀 ·
|
|
줄 기호 부름 = 앞 줄."""
|
|
if doc.get("단계"):
|
|
return False
|
|
money = doc.get("금액") or []
|
|
pos = {j: p for p, j in enumerate(order)}
|
|
sym = {str(x["기호"]): pos[j] for j, x in enumerate(money) if x.get("기호")}
|
|
for j, line in enumerate(money):
|
|
for text in (line.get("수량"), line.get("단가")):
|
|
if text is None or str(text).strip() == "":
|
|
continue
|
|
try:
|
|
got = md.names(md.parse(text))
|
|
except md.DocError:
|
|
return False
|
|
if any(n in md.MONEY_NAMES or n == "계" for n in got):
|
|
return False
|
|
if any(n in sym and sym[n] >= pos[j] for n in got):
|
|
return False
|
|
return True
|
|
|
|
|
|
def _items(doc: dict, texts: list[dict], rows: list[int], stm: bool) -> list[dict]:
|
|
"""원본 행 차례로 항목 · 줄을 쌓음 — 줄 = (금액, 문서 줄) | (공식, [기호]) | (글, 글)."""
|
|
have = set(symbols(doc))
|
|
hidden = hidden_of(doc)
|
|
ev: list[tuple[int, int, int, str, Any]] = []
|
|
for t in texts:
|
|
mark, text = t.get(TAG), str(t.get("글") or "")
|
|
spots = t.get("자리들") or ([t["자리"]] if t.get("자리") else [])
|
|
mids = [s[4:] for s in spots if str(s).startswith("mid:")]
|
|
if any(str(s).startswith("단계:") for s in spots):
|
|
ev.append((t["행"], 0, 0, "끝", None))
|
|
elif mark == "합계":
|
|
ev.append((t["행"], 0, 0, "합계", None))
|
|
elif not spots and (mark == "머리" or (mark == "글" and NUMBERED.match(text))):
|
|
ev.append((t["행"], 0, 0, "머리", title_of(text)))
|
|
elif not spots and mark == "글" and text.strip():
|
|
ev.append((t["행"], 1, 0, "글", " ".join(text.replace("'", " ").split())))
|
|
ids = [m for m in mids if m in have and m not in hidden]
|
|
if ids:
|
|
ev.append((t["행"], 1, 0, "공식", ids))
|
|
ev += [(r, 2, j, "금액", j) for j, r in enumerate(rows)]
|
|
ev.sort(key=lambda e: e[:3])
|
|
items: list[dict] = []
|
|
cur: dict | None = None
|
|
cut = False # STmate 계 줄 뒤 — 다음 첫 글 줄 = 제목
|
|
money = doc.get("금액") or []
|
|
mach = {
|
|
str(x.get("기호")): x
|
|
for x in (doc.get("가져온") or {}).get("기계") or []
|
|
if isinstance(x, dict) and (x.get("조합") or x.get("조합첫"))
|
|
} # 조합 기계(812-9 · 요구 738-3) = 기계마다 항목 하나 · 제목 = 그 기계
|
|
|
|
def new(title: str = "", sub: bool = False) -> dict:
|
|
it = {"제목": title, "가나다": sub, "줄": [], "합계": False}
|
|
items.append(it)
|
|
return it
|
|
|
|
for _, _, _, kind, val in ev:
|
|
if kind == "끝":
|
|
cur, cut = None, stm
|
|
elif kind == "합계":
|
|
if cur is not None:
|
|
cur["합계"] = True
|
|
elif kind == "머리" or (kind == "글" and cut and cur is None):
|
|
title, sub = val if kind == "머리" else title_of(val)
|
|
if cur is not None and not cur["줄"] and not cur["제목"]:
|
|
cur["제목"], cur["가나다"] = title, sub
|
|
else:
|
|
cur = new(title, sub)
|
|
cut = False
|
|
else:
|
|
one = mach.get(price_sym(money[val]) or "") if kind == "금액" else None
|
|
if one and one.get("조합") and not (cur and cur.get("_조합") == _mach_title(one)):
|
|
cur = new(_mach_title(one), bool(cur and cur["가나다"]))
|
|
cur["_조합"] = _mach_title(one) # 같은 기계 다음 줄(비목 셋)은 한 항목
|
|
elif one and cur is not None and "+" in cur["제목"]:
|
|
cur["제목"] = _mach_title(one)
|
|
cur = cur if cur is not None else new()
|
|
if kind == "공식" and cur["줄"] and cur["줄"][-1][0] == "공식":
|
|
cur["줄"][-1][1].extend(x for x in val if x not in cur["줄"][-1][1])
|
|
else:
|
|
cur["줄"].append((kind, list(val) if kind == "공식" else val))
|
|
keep = []
|
|
for it in items:
|
|
flat = re.sub(r"\s+", "", it["제목"])
|
|
if not it["줄"] and (it["합계"] or not flat or flat in _TOTAL):
|
|
continue
|
|
keep.append(it)
|
|
return keep
|
|
|
|
|
|
def _mach_title(one: dict) -> str:
|
|
"""조합 기계 항목 제목 — 이은 우리 기계 이름 · 규격 › 가져온 이름 · 규격."""
|
|
first = (one.get("후보") or [{}])[0] if one.get("키") else {}
|
|
said = first or {
|
|
"이름": (one.get("원래") or {}).get("이름"),
|
|
"규격": (one.get("원래") or {}).get("규격"),
|
|
}
|
|
return " ".join(str(said.get(k) or "") for k in ("이름", "규격")).strip()
|
|
|
|
|
|
def _save_item(it: dict, money: list[dict]) -> dict:
|
|
out: dict[str, Any] = {}
|
|
if it["제목"]:
|
|
out["제목"] = it["제목"]
|
|
if it["가나다"]:
|
|
out["가나다"] = True
|
|
lines = []
|
|
for kind, val in it["줄"]:
|
|
if kind == "금액":
|
|
lines.append({"금액": val, "이름": money[val].get("이름") or ""})
|
|
elif kind == "공식":
|
|
lines.append({"공식": val})
|
|
else:
|
|
lines.append({"글": val})
|
|
return out | {"줄": lines}
|
|
|
|
|
|
# ── 줄 쌓기 모델 거울(`common_util_line_stack.ts`) ──────────────────────
|
|
def _names_in(text: Any) -> list[str]:
|
|
if text is None or str(text).strip() == "":
|
|
return []
|
|
try:
|
|
return md.names(md.parse(text))
|
|
except md.DocError:
|
|
return []
|
|
|
|
|
|
def symbols(doc: dict) -> list[str]:
|
|
out = [md.var_id(v) for v in doc.get("변수") or []]
|
|
for line in doc.get("식") or []:
|
|
sid = str(line.get("기호") or "")
|
|
if sid and sid not in out:
|
|
out.append(sid)
|
|
return out
|
|
|
|
|
|
def _is_option(v: dict | None) -> bool:
|
|
return bool(v and v.get("열쇠") and (v.get("연결") or {}).get("갈래") in ("선택", "입력"))
|
|
|
|
|
|
def uses_of(doc: dict) -> dict[str, list[str]]:
|
|
out: dict[str, list[str]] = {}
|
|
|
|
def add(sid: str, more: list[str]) -> None:
|
|
now = out.setdefault(sid, [])
|
|
now += [n for n in more if n not in now]
|
|
|
|
for v in doc.get("변수") or []:
|
|
add(md.var_id(v), md.link_names(v["연결"]) if v.get("연결") else [])
|
|
for line in doc.get("식") or []:
|
|
add(str(line.get("기호") or ""), _names_in(line.get("식")))
|
|
return out
|
|
|
|
|
|
def price_sym(line: dict) -> str | None:
|
|
text = line.get("단가")
|
|
if text is None or str(text).strip() == "":
|
|
return None
|
|
try:
|
|
n = md.parse(text)
|
|
except md.DocError:
|
|
return None
|
|
if n[0] == "var":
|
|
return n[1]
|
|
if n[0] == "field" and n[1][0] == "var":
|
|
return n[1][1]
|
|
return None
|
|
|
|
|
|
def machine_syms(doc: dict) -> set[str]:
|
|
"""가져온 기계 줄 단가 기호(812-9 `가져온.기계`) — 못 이어 숫자 연결이어도 그 줄 기계(이름 단추 · 고르기)."""
|
|
got = (doc.get("가져온") or {}).get("기계") if isinstance(doc.get("가져온"), dict) else None
|
|
return {str(x.get("기호")) for x in got or [] if isinstance(x, dict)}
|
|
|
|
|
|
def owned_of(doc: dict) -> dict[int, str]:
|
|
count: dict[str, int] = {}
|
|
for ns in (
|
|
*(_names_in(x.get("수량")) + _names_in(x.get("단가")) for x in doc.get("금액") or []),
|
|
*uses_of(doc).values(),
|
|
*([[doc["결과"]]] if doc.get("결과") else []),
|
|
):
|
|
for n in ns:
|
|
count[n] = count.get(n, 0) + 1
|
|
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
|
lines = {str(x.get("기호") or "") for x in doc.get("식") or []}
|
|
mach = machine_syms(doc)
|
|
out = {}
|
|
for i, line in enumerate(doc.get("금액") or []):
|
|
s = price_sym(line)
|
|
kind = ((vars_.get(s) or {}).get("연결") or {}).get("갈래") if s else None
|
|
if (
|
|
s
|
|
and (kind in ("요소", "단가산출") or s in mach)
|
|
and count.get(s) == 1
|
|
and s not in lines
|
|
):
|
|
out[i] = s
|
|
return out
|
|
|
|
|
|
def hidden_of(doc: dict) -> set[str]:
|
|
"""차림에 안 넣는 기호 — 옵션 · 금액 줄이 가진 연결(가져온 값 옵션 칸은 공식 묶음에도 보임)."""
|
|
out = set(owned_of(doc).values())
|
|
out |= {md.var_id(v) for v in doc.get("변수") or [] if _is_option(v)}
|
|
return out
|
|
|
|
|
|
def _post_order(doc: dict, roots: list[str], uses: dict[str, list[str]]) -> list[str]:
|
|
out: list[str] = []
|
|
seen: set[str] = set()
|
|
stack: list[tuple[str, int]] = []
|
|
for start in [*roots, *symbols(doc)]: # 되부름 없이(깊은 식 사슬)
|
|
if start in seen:
|
|
continue
|
|
seen.add(start)
|
|
stack.append((start, 0))
|
|
while stack:
|
|
sid, k = stack.pop()
|
|
kids = uses.get(sid) or []
|
|
if k < len(kids):
|
|
stack.append((sid, k + 1))
|
|
if kids[k] not in seen:
|
|
seen.add(kids[k])
|
|
stack.append((kids[k], 0))
|
|
else:
|
|
out.append(sid)
|
|
return out
|
|
|
|
|
|
def _reach(line: dict, uses: dict[str, list[str]]) -> set[str]:
|
|
out: set[str] = set()
|
|
todo = _names_in(line.get("수량")) + _names_in(line.get("단가"))
|
|
while todo:
|
|
sid = todo.pop()
|
|
if sid in out:
|
|
continue
|
|
out.add(sid)
|
|
todo += uses.get(sid) or []
|
|
return out
|
|
|
|
|
|
def stack_of(doc: dict) -> list[dict]:
|
|
"""`stackOf` — 저장 차림 + 안 놓인 것은 기본 자리 ·
|
|
줄 = {꼴 금액 i | 꼴 공식 기호 틀? | 꼴 글 글}."""
|
|
money = doc.get("금액") or []
|
|
all_ = set(symbols(doc))
|
|
hidden = hidden_of(doc)
|
|
items: list[dict] = []
|
|
where: dict[int, dict] = {}
|
|
placed: set[str] = set()
|
|
saved = doc.get("쌓기") if isinstance(doc.get("쌓기"), list) else []
|
|
taken: set[int] = set()
|
|
for s in saved:
|
|
s = s if isinstance(s, dict) else {}
|
|
it: dict[str, Any] = {
|
|
"제목": str(s.get("제목") if s.get("제목") is not None else ""),
|
|
"줄": [],
|
|
}
|
|
if s.get("가나다"):
|
|
it["가나다"] = True
|
|
for line in s.get("줄") if isinstance(s.get("줄"), list) else []:
|
|
if isinstance(line, dict) and "금액" in line:
|
|
i = int(line["금액"])
|
|
name = line.get("이름")
|
|
if not (
|
|
0 <= i < len(money) and (money[i].get("이름") or "") == name and i not in taken
|
|
):
|
|
free = (k for k, m in enumerate(money) if k not in taken)
|
|
i = next((k for k in free if (money[k].get("이름") or "") == name), -1)
|
|
if i < 0 or i in taken:
|
|
continue
|
|
taken.add(i)
|
|
where[i] = it
|
|
it["줄"].append({"꼴": "금액", "i": i})
|
|
elif isinstance(line, dict) and "공식" in line:
|
|
got = [
|
|
x
|
|
for x in line["공식"] or []
|
|
if x in all_ and x not in hidden and x not in placed
|
|
]
|
|
placed |= set(got)
|
|
one: dict[str, Any] = {"꼴": "공식", "기호": got}
|
|
if line.get("틀"):
|
|
one["틀"] = str(line["틀"])
|
|
if line.get("틀꼴"):
|
|
one["틀꼴"] = str(line["틀꼴"])
|
|
it["줄"].append(one)
|
|
elif isinstance(line, dict) and "글" in line:
|
|
it["줄"].append(
|
|
{"꼴": "글", "글": str(line["글"] if line["글"] is not None else "")}
|
|
)
|
|
items.append(it)
|
|
for i, m in enumerate(money):
|
|
if i in taken:
|
|
continue
|
|
title = str(m.get("묶음") if m.get("묶음") is not None else "")
|
|
prev = where.get(i - 1)
|
|
if prev is not None and prev["제목"] == title:
|
|
it = prev
|
|
at = next(k for k, x in enumerate(prev["줄"]) if x["꼴"] == "금액" and x["i"] == i - 1)
|
|
prev["줄"].insert(at + 1, {"꼴": "금액", "i": i})
|
|
else:
|
|
it = next((x for x in items if x["제목"] == title), None) if saved else None
|
|
if it is None:
|
|
it = {"제목": title, "줄": []}
|
|
items.append(it)
|
|
it["줄"].append({"꼴": "금액", "i": i})
|
|
taken.add(i)
|
|
where[i] = it
|
|
uses = uses_of(doc)
|
|
reach = [_reach(m, uses) for m in money]
|
|
for sid in _post_order(doc, [doc["결과"]] if doc.get("결과") else [], uses):
|
|
if sid not in all_ or sid in hidden or sid in placed:
|
|
continue
|
|
i = next((k for k, r in enumerate(reach) if sid in r), -1)
|
|
it = where.get(i) if i >= 0 else (items[0] if items else None)
|
|
if it is None:
|
|
it = {"제목": "", "줄": []}
|
|
items.append(it)
|
|
block = next((x for x in it["줄"] if x["꼴"] == "공식"), None)
|
|
if block is None:
|
|
block = {"꼴": "공식", "기호": []}
|
|
it["줄"].insert(0, block)
|
|
block["기호"].append(sid)
|
|
placed.add(sid)
|
|
return items
|
|
|
|
|
|
def save_of(items: list[dict], money: list[dict]) -> list[dict]:
|
|
"""`saveOf`(차례 그대로)."""
|
|
out = []
|
|
for it in items:
|
|
one: dict[str, Any] = {}
|
|
if it["제목"]:
|
|
one["제목"] = it["제목"]
|
|
if it.get("가나다"):
|
|
one["가나다"] = True
|
|
lines = []
|
|
for x in it["줄"]:
|
|
if x["꼴"] == "금액":
|
|
lines.append({"금액": x["i"], "이름": money[x["i"]].get("이름") or ""})
|
|
elif x["꼴"] == "글":
|
|
lines.append({"글": x["글"]})
|
|
else:
|
|
lines.append(
|
|
{"공식": list(x["기호"])}
|
|
| ({"틀": x["틀"]} if x.get("틀") else {})
|
|
| ({"틀꼴": x["틀꼴"]} if x.get("틀꼴") else {})
|
|
)
|
|
out.append(one | {"줄": lines})
|
|
return out
|