Files
Aislo/M02_MasterTemplete/M02_Sangeun_QtyLinks.py
T
eomsangdonandClaude Opus 5.5 ec761d0948 refactor(857-3b): 불러온 단가산출 정본 = 수식 문서 — 저장본 가져온.로직 걷음 · 고침 길 = 문서 연결 · 옛 꼴 = 까닭 하나
- 저장 꼴: SK `가져온` = {문서(불러온 그대로 수식 문서 · 정본), 원본, 단가기준, 검산, 연결?} · 가져온 줄(옛 로직 줄 꼴) 안 둠 · 다시 열기 = 저장 문서(Doc_Import.derive) · 고침 = 수식 따로 사본 · [초기화] = 가져온.문서
- 짓기: 불러올 때 한 번(Doc_Import.build · San_ToDoc · 줄 검사 = 문서 파서) · 검산 = 불러올 때 한 번(check_row · 옛 변환기 안 부름) · 뒤 저장 = 저장 파일 검산(화면 값 안 받음)
- 고침 길: 이음 고침 = 그 가져온 줄 값 변수 연결(자리 = 호표:i · 엑셀 값 기억) · 소요량 고름 = 문서 그 수 → 표 연결 변수 · 풂 = 수 되돌림(자리 = 문서 머리 가져온.자리) · [저장] 처음 = 고친 미리 보기 문서 위에 안쪽 산근 참조 · 내 기계만 얹음(FromHopyo._onto) · 재료 고름 판 = 문서 머리 재료
- 둘레: 형제 SK 참조 = 문서 연결(Labor_Ref refs_in · _move_doc → imp.refs_of · move_refs) · 값 사본 닿을 것 = 문서 연결 + 기계 판정 키(Sangeun_Copy.stamp · reach_of) · B09 굳힌 사본 = 가져온 늘 실음 · 단가 묶음에 사본 요소(Item_Sangeun) · Doc_Sk old_only 가져온 식도 · frozen 가져온 식 빼고 · old_fp 옛 꼴만 · 우리 단가 색인 = 받은 색인 위(B09 사본 단가 전파)
- 옛 꼴 저장본(가져온.로직) = 읽지 않음 · 지우지 않음 · 셈 · 검산 · 고침 = 까닭 「옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장」 · 가져온 식 옛 칸 고침(덮개 · 더한줄 · 식 칸) = 못 셈(2-C1 과 같게)
- 857-3a 더한줄 갈래(San_ToDoc 요소 · 로직 부름) 걷음 · test_857_3a_import_adds 지움(가져온 식 옛 칸 = 죽은 길 · 대신 test_793_2 옛_칸_고침_못_셈 · 옛_꼴_저장본_까닭_하나)
- 화면: 가져온 식 판정 = 문서 | 옛 로직 · 옛 꼴 = 이음 · 소요량 안 부름(Hopyo_Imported_Model · Hopyo_Imported · Sangeun_Origin)
- 뜻한 바뀜: 불러온 문서 다듬기가 글줄 이름으로(저장 길에서도 지은 「율」 → 엑셀 글 머리 · 704 · test_809_1 · 812_3) · golden_855_b09 daega_inputs 다시 뜸 = 가져온 식 단가산출 = 수식 문서만 · 가져온.로직 없음 → 옛 굳힘 ROW 가 줄을 못 지음(B09 대가 블록 가져온 식 줄 0 · 금액 calc_user · 수요 · 산근 그대로 · B9-5 문서 셈 줄 뒤 다시 확인) · test_792_3 실무 가져온 식 대가 = 금액만(ROW 번지 · 단계 = 옛 굳힘 꼴)
- 시험 고침: 옛 꼴 SK 손으로 짓던 견본 → imp.new_doc(793_2 · 797_1 · 797_2 · 802_4b1 · 809_1 · 810_2 · 857 도우미) · 로직 줄 읽던 단언 → 문서 변수 · 머리(793_3b · 821_4 · 827_3 · 835_1) · 옛 엔진 대조 · 옛 식 칸 가져온 식 길 걷음(802_4b1 · 796_2b)
- 지킴: 857 골든 전수 같음(블록 3,241 두 판 · 검산 · 이음) · 812_1 전수 31 · 793 · 848_6 · 848_7 · 851_2 · 855 112 통과 · 관련 694 통과(실패 = 719_1 둘 · 719_2 셋 · 826_1 — 고치기 전에도 같음 · 나머지 = 이 커밋에서 고침) · typecheck 0 · 화면 8010 엑셀 · STC 저장 · 다시 열기 · 두 판 · 이음 고침 · 시간당 식 · 초기화 · 내 일위대가로(안쪽 SK 새 꼴) · 콘솔 0 · 서버 오류 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 03:44:45 +09:00

495 lines
20 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.
"""M02 가져온 식 소요량 · 계수 이음(PLAN 797-2 · 요구 655-3 · 요구서_655) — 서버 단독.
가져온 식 줄(엑셀 그대로)에 쓰인 수가 M01 소요량(QC/QF) · 계수(CC/CF) 표 칸의 값인지 **값 역색인**
(`M02_San_Basis_Index.lookup` 한 벌)으로 후보를 냄 — 같은 값 + 같은 단위 성격 + 이름 · 공종 문맥이
맞는 칸만 후보 · 유일해도 자동 확정 없음(사람이 고름) · 값을 지어 넣지 않음.
- 자리(slot) = `호표:i:n` | `덧줄:i:n` — 로직 줄 i 의 식(수량 | 식)의 n 번째 수(중간 변수는 단위 ·
이름 문맥이 없어 자리 아님). 일반 수(1 · 10 · 60 · 100 · 1000 · 8) · 비교 글자 · 찾기 · 로직 부름
인자는 안 셈.
- 고름 = 엑셀 수와 표 칸 값이 같을 때만(같은 값 · 율 ↔ 소수 · t ↔ kg) — 다르면 못 고름 + 까닭.
기록(`가져온.연결` = {고름 [..], 버림 [..]}) + 문서 고침(857-3b) — 그 금액 줄 식의 그 수 자리 = 표 연결
변수(`소요량k` · 엑셀 칸 값 기억 · 금액 그대로) · 풂 = 수로 되돌림 · 자리 = 불러올 때 문서 머리
`가져온.자리`(가져온 줄 수 차례 · 앞 수 `앞` → 문서 식 수 차례로 맞춤).
- 고름 = {자리, 수, 층 「M01」, 표, 줄, 칸, 값, 꼴 eq|pct|kgt} · 로직이 바뀌어 자리의 수가 달라지면
그 기록은 버려진 것으로 보고 화면에 안 내놓음.
길(`M02_Sangeun_Router` `imported/{qty|qty-pick|qty-drop}`) · 표지(`flags` · 가져온 식 만들 때).
"""
from __future__ import annotations
import copy as cp
import re
from decimal import Decimal
from typing import Any
from M02_MasterTemplete import M02_San_Basis_Index as bi
from M02_MasterTemplete import M02_San_Emit as em
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
KEY = "연결"
LAYER = "M01"
GENERAL = (0, 1, 8, 10, 60, 100, 1000) # 일반 수(793-3a N9)
SHOWN = 12 # 자리마다 화면에 내는 후보 상한(후보 수는 전부 셈)
FORMS = ("eq", "pct", "kgt")
FIELDS = (("호표", "수량"), ("덧줄", "식")) # 중간 변수 = 단위 · 이름 문맥 없음 → 자리 아님
_ctx: dict[int, dict[str, set[str]]] = {}
def _flat(s: Any) -> str:
return re.sub(r"[^가-힣A-Za-z0-9]", "", str(s or ""))
CMP = ("<=", ">=", "==", "!=", "<", ">") # 비교 글자
def _literals(node: Any, out: list[Decimal]) -> None:
"""식 나무(문서 파서) → 수 글자(차례대로) — 비교 글자는 뺌."""
if not isinstance(node, tuple):
return
kind = node[0]
if kind == "num":
out.append(node[1])
elif kind == "bin":
cmp_ = node[1] in CMP
for side in node[2:]:
if not (cmp_ and isinstance(side, tuple) and side[0] == "num"):
_literals(side, out)
elif kind in ("neg", "pct", "field"):
_literals(node[1], out)
elif kind == "call":
for arg in node[2]:
_literals(arg, out)
def literals(text: Any) -> list[Decimal]:
out: list[Decimal] = []
try:
_literals(todoc.md.parse(str(text)), out)
except todoc.md.DocError:
pass
return out
def slots(row: dict) -> list[dict]:
"""가져온 로직 줄 → 소요량 · 계수 자리 `[{자리, 갈래, 줄, 이름, 단위, 수, d, 직종?}]`."""
out = []
for kind, field in FIELDS:
for i, one in enumerate(row.get(kind) or []):
if not isinstance(one, dict):
continue
labor = kind == "호표" and one.get("종류") == "인력"
nums = literals(one.get(field))
for n, x in enumerate(nums):
if float(x) in GENERAL:
continue
out.append(
{
"자리": f"{kind}:{i}:{n}",
"앞": [str(v) for v in nums[:n]],
"갈래": kind,
"종류": str(one.get("종류") or ""),
"줄": str(one.get("이름") or ""),
"단위": "인" if labor else str(one.get("단위") or ""),
"수": float(x),
"d": max(0, -x.as_tuple().exponent),
"직종": str(one.get("이름") or "") if labor else None,
}
)
return out
def _context(idx: bi.Index) -> dict[str, set[str]]:
"""표 → 이름 · 공종 · 구분 글(한글만) — 역색인 한 판마다 한 번."""
got = _ctx.get(id(idx))
if got is None:
_ctx.clear()
got = _ctx[id(idx)] = {
k: _tokens(
" ".join(
str(x or "")
for x in (t.get("이름"), (t.get("용도") or {}).get("공종"), t.get("상세구분"))
)
)
for k, t in idx.tables.items()
}
return got
STOP = re.compile(
"및|설치|해체|운반|조립|가공|제작|시공|공사|현장|작업|기계|인력|보통|일반|사용|적용|기준|표준|구간|공통"
)
def _tokens(s: str) -> set[str]:
return {t for t in re.split(r"[^가-힣]+", STOP.sub(" ", _hangul_keep(s))) if len(t) >= 2}
def _hangul_keep(s: Any) -> str:
"""한글 · 공백만 남김(낱말 가름 유지)."""
return re.sub(r"[^가-힣]+", " ", str(s or ""))
def _on_topic(title: set[str], table: set[str]) -> bool:
"""공종 맞음 — 블록 이름 낱말과 표 이름 · 공종 낱말이 같거나 한쪽이 다른 쪽에 들어 있음."""
return any(
a == b or min(len(a), len(b)) >= 3 and (a in b or b in a) for a in title for b in table
)
def _near(a: str, b: str) -> bool:
x, y = _flat(a), _flat(b)
return len(x) >= 2 and len(y) >= 2 and (x in y or y in x)
def _same(how: str, cell: float, v: float) -> bool:
"""엑셀 수와 칸 값이 같은 꼴(eq 같음 · pct 율 ↔ 소수 · kgt t ↔ kg)."""
scale = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)}[how]
return any(abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell)) for m in scale)
def _named(slot: dict, cell: dict, table: dict) -> bool:
"""줄 이름이 칸 이름(칸 · 같은 줄 글 칸)과 맞는가 — 인력 = 직종 맞음."""
name = slot["직종"] or slot["줄"]
if _near(name, str(cell["칸"]).split("/")[0]):
return True
row = (table.get("줄") or [{}])[cell["줄"]] if cell["줄"] < len(table.get("줄") or []) else {}
return any(isinstance(v, str) and _near(name, v) for v in row.values())
def find(idx: bi.Index, slot: dict, title: str) -> list[dict]:
"""자리 하나 → 후보 칸 `[{표, 줄, 칸, 값, 단위, 꼴, 맥락, 이름, 번호, 갈래}]`(이름 맥락 먼저)"""
k = {"v": slot["수"], "d": slot["d"], "단위": slot["단위"], "직종": slot["직종"]}
ctx, want = _context(idx), _tokens(title.split("(")[0]) # 이름 앞부분(규격 괄호 앞)
out, seen = [], set()
for cid, how in idx.lookup(k):
c = idx.cells[cid]
t = idx.tables.get(c["표"])
if t is None or c["종류"] in ("eq", "cond") or how not in FORMS:
continue
if not _same(how, c["v"], slot["수"]) or (c["표"], c["줄"], c["칸"]) in seen:
continue
if not _on_topic(want, ctx.get(c["표"], set())):
continue # 공종 문맥이 맞아야 후보
named = slot["직종"] is not None or _named(slot, c, t) # 인력 = lookup 이 직종 맞춤
if not named and slot["종류"] == "재료":
continue # 재료는 칸 이름도 맞아야
why = "이름 · 공종" if named else "공종"
seen.add((c["표"], c["줄"], c["칸"]))
out.append(
{
"표": c["표"],
"줄": c["줄"],
"칸": c["칸"],
"값": c["v"],
"단위": c["단위"],
"꼴": how,
"맥락": why,
"이름": t.get("이름"),
"번호": t.get("원문번호"),
"갈래": "소요량" if c["표"].startswith("Q") else "계수",
}
)
return sorted(out, key=lambda x: (x["맥락"] == "공종", x["표"], x["줄"]))
def scan(row: dict, idx: bi.Index | None = None) -> list[dict]:
"""로직 줄 → 자리마다 `후보`(전부) · 수 — 순수(저장 안 함)."""
idx = idx or bi.get()
title = str(row.get("이름") or "")
return [{**s, "후보": find(idx, s, title)} for s in slots(row)]
def flags(row: dict, idx: bi.Index | None = None) -> list[str]:
"""만들 때 표지(「참고 · …」) — 자리마다 한 줄 · 사람 확인 · 후보 0 = 표 칸 없음."""
out = []
for s in scan(row, idx):
n = len(s["후보"])
what = f"소요량 후보 {n} · 사람 확인" if n else "표 칸 없음"
out.append(f"{em.NOTE}{what} — {s['줄']} {s['수']:g}")
return out
def tally(scanned: list[dict]) -> dict[str, int]:
"""자리 수 · 줄 수 · 후보 유일 | 여럿 | 없음 자리 수."""
return {
"자리": len(scanned),
"줄": len({s["자리"].rsplit(":", 1)[0] for s in scanned}),
"유일": sum(len(s["후보"]) == 1 for s in scanned),
"여럿": sum(len(s["후보"]) > 1 for s in scanned),
"없음": sum(not s["후보"] for s in scanned),
}
# ── 고름 · 버림(문서 기록) ─────────────────────────────────────────────
def _need(doc: Any) -> dict:
if not imp.is_imported(doc) or imp.old_form(doc):
raise sd.DocError("가져온 식 단가산출만(옛 꼴 = 다시 불러오기)")
return doc
def _slots(doc: dict) -> list[dict]:
"""불러올 때 적은 자리(문서 머리 `가져온.자리`)."""
return list(((doc[imp.KEY][imp.FIRST].get(imp.KEY) or {}).get("자리")) or [])
def _state(doc: dict) -> dict[str, list]:
meta = doc[imp.KEY].get(KEY) or {}
return {"고름": list(meta.get("고름") or []), "버림": list(meta.get("버림") or [])}
def _with(doc: dict, state: dict) -> dict:
meta = {k: v for k, v in state.items() if v}
rest = {k: v for k, v in doc[imp.KEY].items() if k != KEY}
return {**doc, imp.KEY: rest | ({KEY: meta} if meta else {})}
def view(doc: Any, idx: bi.Index | None = None) -> dict[str, Any]:
"""화면 답 — 자리마다 {자리, 줄, 수, 단위, 후보수, 후보, 상태 후보|없음|고름|버림, 고른}."""
doc = _need(doc)
state, rows = _state(doc), []
idx = idx or bi.get()
title = str(doc[imp.KEY][imp.FIRST].get("이름") or "")
scanned = [{**s, "후보": find(idx, s, title)} for s in _slots(doc)]
picked = {x["자리"]: x for x in state["고름"] if x.get("수") is not None}
dropped = set(state["버림"])
for s in scanned:
mine = picked.get(s["자리"])
if mine: # M01 칸 값이 그새 바뀌었으면 알림(기록은 그대로)
now = next(
(
c["v"]
for c in idx.cells_of_table.get(mine["표"], [])
if c["줄"] == mine["줄"] and c["칸"] == mine["칸"]
),
None,
)
mine = {
**mine,
"지금": now,
"같음": now is not None and _same(mine["꼴"], now, s["수"]),
}
rows.append(
{
**{k: s[k] for k in ("자리", "갈래", "줄", "단위", "수")},
"후보수": len(s["후보"]),
"후보": s["후보"][:SHOWN],
"고른": mine,
"상태": (
"고름"
if mine
else "버림"
if s["자리"] in dropped
else "후보"
if s["후보"]
else "없음"
),
}
)
count = tally(scanned) | {
"고름": sum(r["상태"] == "고름" for r in rows),
"버림": sum(r["상태"] == "버림" for r in rows),
}
return {"줄": rows, "집계": count}
def pick(doc: Any, spot: str, cell: dict, idx: bi.Index | None = None) -> dict[str, Any]:
"""후보 칸 고름 — 엑셀 수 = 칸 값일 때만(다르면 400 까닭) · 기록 + 문서 그 수 자리 = 표 연결 변수
(엑셀 칸 값 기억 · 금액 그대로)."""
doc = cp.deepcopy(_need(doc))
idx = idx or bi.get()
slot = next((s for s in _slots(doc) if s["자리"] == spot), None)
if slot is None:
raise sd.DocError(f"없는 자리 「{spot}」")
table = idx.tables.get(str((cell or {}).get("표")))
rows = (table or {}).get("줄") or []
at, col = (cell or {}).get("줄"), (cell or {}).get("칸")
found = next(
(
c
for c in idx.cells_of_table.get(str((cell or {}).get("표")), [])
if c["줄"] == at and c["칸"] == col and c["종류"] not in ("eq", "cond")
),
None,
)
if table is None or found is None or not isinstance(at, int) or at >= len(rows):
raise sd.DocError("없는 표 칸")
how = next((h for h in FORMS if _same(h, found["v"], slot["수"])), None)
if how is None:
raise sd.DocError(
f"엑셀 수 {slot['수']:g} ≠ 표 칸 값 {found['v']:g} — 같은 값인 칸만 고를 수 있음"
)
one = {
"자리": spot,
"수": slot["수"],
"층": LAYER,
"표": found["표"],
"줄": at,
"칸": col,
"값": found["v"],
"꼴": how,
}
conds = _conds(table, at)
for target in imp.docs_of(doc):
_unpick(target, spot)
if conds is not None:
_apply(target, slot, one, conds)
state = _state(doc)
state["고름"] = [x for x in state["고름"] if x.get("자리") != spot] + [one]
state["버림"] = [x for x in state["버림"] if x != spot]
return {"문서": _with(doc, state)}
def drop(doc: Any, spot: str, undo: bool = False) -> dict[str, Any]:
"""자리 후보 버림(또는 [되돌리기]) — 고른 것이 있으면 같이 풂(문서 수 되돌림)."""
doc = cp.deepcopy(_need(doc))
if not any(s["자리"] == spot for s in _slots(doc)):
raise sd.DocError(f"없는 자리 「{spot}」")
for target in imp.docs_of(doc):
_unpick(target, spot)
state = _state(doc)
state["고름"] = [x for x in state["고름"] if x.get("자리") != spot]
state["버림"] = [x for x in state["버림"] if x != spot] + ([] if undo else [spot])
return {"문서": _with(doc, state)}
# ── 문서 고침(857-3b) — 그 수 자리 ↔ 표 연결 변수 ─────────────────────────
SPOT = "가져온자리" # 고른 칸 변수 — 자리 · 되돌릴 수 글
SCALE = {"eq": (1,), "pct": (100, 0.01), "kgt": (1000, 0.001)}
def _field(spot: str) -> str:
return "수량" if spot.startswith("호표:") else "단가"
def _line_of(doc: dict, spot: str) -> dict | None:
head = spot.rsplit(":", 1)[0]
return next((x for x in doc.get("금액") or [] if x.get(todoc.FROM) == head), None)
def _doc_nth(node: Any, before: list[str]) -> int | None:
"""가져온 줄 n 번째 수(앞 수 `before`) → 문서 식 수 차례 — 문서 = 가져온 줄 수에서 군더더기
(0 · 1 · 100)만 빠진 차례."""
doc_nums: list[Decimal] = []
_literals(node, doc_nums)
j = 0
for v in (Decimal(x) for x in before):
if j < len(doc_nums) and doc_nums[j] == v:
j += 1
return j if j < len(doc_nums) else None
def _swap(node: Any, n: int, new: tuple, seen: list) -> Any:
"""`_literals` 차례의 n 번째 수 → `new` 마디."""
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
if kind == "bin":
cmp_ = node[1] in CMP
sides = [
side if cmp_ and side[0] == "num" else _swap(side, n, new, seen) for side in node[2:]
]
return (kind, node[1], *sides)
if kind in ("neg", "pct", "field"):
return (kind, _swap(node[1], n, new, seen), *node[2:])
if kind == "call":
return ("call", node[1], [_swap(a, n, new, seen) for a in node[2]])
return node
def _conds(table: dict, at: int) -> dict | None:
"""표 줄 차례 → 그 줄 하나만 맞는 조건 {조건: 값}(범위 = 위 끝 › 아래 끝) · 못 가림 = None."""
from M02_MasterTemplete import M02_Doc_Copy as dc
rows = table.get("줄") or []
if not (0 <= at < len(rows)):
return None
row, out = rows[at], {}
for cond, how in (table.get("조건") or {}).items():
if cond not in row:
continue
have = row[cond]
if how == "범위":
low, high = have
have = high if high is not None else low
if have is None:
return None
out[cond] = have
try:
hit = dc.ml.find(table, out)
except Exception: # noqa: BLE001 — 못 가림 = 수 그대로
return None
return out if hit is row else None
def _times(one: dict, m: float) -> bool:
"""칸 값 = 엑셀 수 × 배 m."""
cell, v = float(one.get("값") or 0), float(one.get("수") or 0)
return abs(cell - v * m) <= 1e-9 * max(1.0, abs(cell))
def _apply(doc: dict, slot: dict, one: dict, conds: dict) -> None:
"""문서 그 금액 줄 식의 그 수 → 표 연결 변수(÷ 배) · 줄 · 수가 안 맞으면 그대로(기록만)."""
from M02_MasterTemplete import M02_Doc_Import as dim
spot = slot["자리"]
line, field = _line_of(doc, spot), _field(spot)
if line is None:
return
try:
node = todoc.md.parse(str(line.get(field)))
except todoc.md.DocError:
return
n = _doc_nth(node, list(slot.get("앞") or []))
nums: list[Decimal] = []
_literals(node, nums)
scale = next((m for m in SCALE.get(str(one["꼴"]), (1,)) if _times(one, m)), None)
if n is None or float(nums[n]) != float(slot["수"]) or scale is None:
return
taken = {str(v.get("열쇠")) for v in doc.get("변수") or []}
taken |= {todoc.md.var_id(v) for v in doc.get("변수") or []}
name = next(f"{dim.PICK}{k}" for k in range(1, 999) if f"{dim.PICK}{k}" not in taken)
ref = ("var", name) if scale == 1 else ("bin", "/", ("var", name), ("num", Decimal(str(scale))))
line[field] = todoc.md.text_of(_swap(node, n, ref, [0]))
link = {"갈래": "표", "표": str(one["표"]), "조건": {k: dim._lit(v) for k, v in conds.items()}}
link |= {"칸": str(one["칸"]), dim.XL: Decimal(str(one["값"]))}
var = {"열쇠": name, "기호": name, "아래": "", "위": "", "이름": name, "단위": "", "연결": link}
doc.setdefault("변수", []).append(var | {SPOT: {"자리": spot, "수": str(nums[n])}})
def _unpick(doc: dict, spot: str) -> None:
"""그 자리 고른 칸 변수 → 원래 수로 되돌림 · 변수 지움."""
mine = [v for v in doc.get("변수") or [] if (v.get(SPOT) or {}).get("자리") == spot]
if not mine:
return
line, field = _line_of(doc, spot), _field(spot)
for var in mine:
name, num = todoc.md.var_id(var), ("num", Decimal(var[SPOT]["수"]))
if line is not None:
try:
node = todoc.md.parse(str(line.get(field)))
line[field] = todoc.md.text_of(_back(node, name, num))
except todoc.md.DocError:
pass
doc["변수"] = [v for v in doc["변수"] if v is not var]
def _back(node: Any, name: str, num: tuple) -> Any:
if not isinstance(node, tuple):
return node
if node == ("var", name) or (node[0] == "bin" and node[1] == "/" and node[2] == ("var", name)):
return num
if node[0] == "bin":
return ("bin", node[1], _back(node[2], name, num), _back(node[3], name, num))
if node[0] in ("neg", "pct", "field"):
return (node[0], _back(node[1], name, num), *node[2:])
if node[0] == "call":
return ("call", node[1], [_back(a, name, num) for a in node[2]])
return node