Files
Aislo/M02_MasterTemplete/M02_San_ToDoc.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

372 lines
16 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 857-3a · 857-3b · 걸음 4 설계 3 절) — 서버 단독.
불러오기 읽기기(둘 꼴 · 로직 줄 꼴 블록)가 낸 가져온 줄을 불러올 때 한 번 문서로 지음
(저장 = 그 문서) — 옛 변환기(`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
FROM = "가져온줄" # 857-3b 문서 금액 줄 · 값 변수 ↔ 가져온 줄 자리(`호표:i` · `덧줄:i`)
KIND = "가져온종류" # 금액 줄 ↔ 가져온 줄 종류(인력 · 재료 · 기계 · 로직)
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, "?")
_HEAD = re.compile(r"\s*로직\(\s*([^,()'{}]+?)\s*(?=[,)])")
_ARG = re.compile(r"\s*,\s*(?:'([^']*)'|(\w+))\s*=\s*(?:'([^']*)'|(\d+(?:\.\d+)?))")
def logic_call(text: Any) -> tuple[str, list[tuple[str, tuple]]] | None:
"""「로직(GC…, 이름='값', 이름=수)」 → (키, [(이름, ('str' | 'num', 값))]) · 그 밖 꼴 = None."""
s = str(text)
head = _HEAD.match(s)
if head is None:
return None
at, args = head.end(), []
while arg := _ARG.match(s, at):
name = arg[1] if arg[1] is not None else arg[2]
args.append((name, ("str", arg[3]) if arg[3] is not None else ("num", Decimal(arg[4]))))
at = arg.end()
return (head[1], args) if re.fullmatch(r"\s*\)\s*", s[at:]) else None
class _Doc:
def __init__(self, row: dict, master: Any = None) -> None:
self.row, self.reg, self.master = row, _Reg(), master
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["단가"]))
got = self.var(("손", at), f"{name}단가", {"갈래": "숫자", "값": value})
self.links[("손", at)][FROM] = f"호표:{at}" # 857-3b 가져온 줄 자리(이음 · 소요량 고침)
return got
def var(self, key: tuple, label: str, link: dict, unit: str = "") -> str:
"""값 변수 하나(열쇠마다 한 기호) — 기호 = 이름 끝말 규칙."""
if key not in self.links:
self.reg.want(key, msym.lookup(label, "요소"))
self.order.append(key)
self.links[key] = {"이름": label, "단위": unit, "연결": link}
self.links[key]["연결"] = link
return self.reg.id(key)
def build(row: dict, master: Any, given: dict | None = None) -> tuple[dict, list[str]]:
"""가져온 로직 줄 → (수식 문서, 알림) · `master` = 단위 채움 색인 · given = 입력 값."""
c = _Doc(row, master)
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}
line |= {FROM: f"호표:{at}", KIND: str(item.get("종류") or "")}
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}
line[FROM] = f"덧줄:{len(out) - len(items)}"
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])