- 저장 꼴: 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>
495 lines
20 KiB
Python
495 lines
20 KiB
Python
"""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
|