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

510 lines
25 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 802-4b-1 · 요구 664 · 665) — 서버 단독.
경쟁사 산근 블록도 같은 꼴(식 + 값)로 들어옴 — 엑셀 단가 그대로 고친 줄(`가져온.로직` + SK 고침)을
`M02_San_ToDoc` 으로 문서로 짓고(손 값 = 숫자 연결 · 중간 = 식 줄 · 덧줄 = 금액 줄 식 · 끝수 ·
단계 · 조정 · 합밖 · 자리 그대로) 이은 것을 연결로 얹음 · 연결마다 엑셀 값을 기억(`엑셀` 칸):
인력 · 재료 · 유가 · 전력 · 환율 이음 = 요소 {키} · 기계 이음(EQ) = 기계경비 단가산출
{키 GC, 입력 기계 …, 칸 = 그 줄 비목}(시간당 자료 없음 = 숫자 그대로 · 설명) ·
로직 이음 「로직(GC…)」 = 단가산출 {키, 입력} · 산근 속 산근(797-1 참조) = 단가산출
{키 형제 SK, 참조 {층, 주인}, 칸?} ·
소요량 · 계수 고른 것(797-2 `가져온.연결.고름`) = 그 수 자리에 표 연결 기호(pct · kgt = ÷ 배).
문서 머리 `가져온` = {파일, 시트, 행, 갈래, 코드?, 표지(797-1a · 못 읽음 까닭 그대로), 알림?}.
셈(`run`) — 단가기준 엑셀(기본) = 엑셀 값 기억 연결을 숫자로 보고 셈 · 우리 = 연결 값으로 셈 ·
형제 SK 는 늘 연결(부르는 쪽 단가기준으로 · 안쪽이 바뀌면 따라감).
"""
from __future__ import annotations
import copy as cp
import re
from decimal import Decimal
from typing import Any
from M02_MasterTemplete import M02_Doc_Copy as dc
from M02_MasterTemplete import M02_Doc_Import_Q as qt
from M02_MasterTemplete import M02_Doc_Import_Shape as shape
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_San_MatPick as mp
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
XL = "엑셀" # 연결 칸 — 엑셀 값 기억
HEAD = (
"파일",
"시트",
"행",
"갈래",
"코드",
"원파일",
"원코드",
"규격",
"확정",
"지문",
) # 규격 · 확정 = 원파일(810-3) · 지문 = 올린 파일(827-3 재료 고름)
GUESS = "추정" # 원파일 품셈 조건 글 표지(810-2 `M02_Doc_NativeEst.GUESS`)
SUB = "원파일 소계" # 원파일 소계 덧줄(810-2 `M02_Doc_NativeEst`) — 합 밖 · 비목 칸 비움
PICK = "소요량" # 고른 표 칸 기호 이름 머리
def is_imported(sk: Any) -> bool:
return imp.is_imported(sk)
def basis_of(sk: dict) -> str:
return "우리" if (sk.get(imp.KEY) or {}).get("단가기준") == "우리" else "엑셀"
def swapped(doc: Any) -> int:
"""바꿔 끼운 가져온 줄 수(823-1 · 연결 `바꿈` = 원래 · 엑셀 값 뗌 = 우리 값)."""
vars_ = (doc or {}).get("변수") or [] if isinstance(doc, dict) else []
return sum(1 for v in vars_ if isinstance(v.get("연결"), dict) and v["연결"].get("바꿈"))
def _index(sk: dict, master: Any = None, doc: Any = None) -> Any:
"""셈 색인 — 우리 · 바꾼 줄 있음(823-1) = 로직 사본 위(822-1 · 이음 값이 M01 따라 안 바뀜 ·
[단가 갱신] 으로만) · 엑셀 = 받은 색인 · 없으면 지금 M01."""
from M02_MasterTemplete import M02_Sangeun_Copy as skc
if basis_of(sk) == "우리" or swapped(doc):
return skc.over(sk, master or imp._whole()) # 받은 색인(B09 사본 단가) 위 · 없으면 지금 M01
return master or imp._whole()
# ── 불러올 때 문서 한 번 짓기(857-3b) ───────────────────────────────────
OLD_FORM = "옛 꼴로 저장된 불러온 단가산출 — 엑셀 · 원파일을 다시 불러와 저장"
FIRST = "문서" # `가져온` 칸 — 불러온 그대로 문서(정본 · 고침 = `수식` 따로 사본)
LIST = "이음없음" # 문서 머리 `가져온` — 이음 없는 가져온 줄 [{자리, 이름, 까닭, 견적?, 종?}]
def bare_row(row: dict, key: str = "SK-000000") -> dict:
"""가져온 줄(읽기기 꼴 · 엑셀 판) → 문서 짓는 줄 — 요소 = 이음 | {이름}(로직 줄 = 이음 | None) ·
안쪽 산근(형제 SK) 줄 = 0 자리값(`_attach` 가 형제 SK 연결 + 엑셀 값으로 갈음)."""
items = []
for one in row.get("호표") or []:
link = one.get("이음")
item = {k: v for k, v in one.items() if k != "이음"}
item["요소"] = link or (None if one.get("종류") == "로직" else {"이름": one.get("이름")})
if one.get("참조"):
item |= {"요소": None, "값묶음": dict.fromkeys(imp.COSTS, Decimal(0)), "기준": "엑셀"}
items.append(item)
return {"입력": [], "중간": [], "덧줄": [], **row, "키": key, "호표": items}
def _unlinked(row: dict) -> list[dict]:
"""이음 없는 자원 줄 — 자리 = 가져온 줄 자리(`호표:i`) · 까닭 = 814-1 `M02_San_Link.why` ·
견적 = 815-1 K5 그대로 쓰는 견적 · 운임 · 수수료 줄 · 종 = 827-3 재료 종 열쇠."""
from M02_MasterTemplete import M02_San_Link as link
return [
{"자리": f"호표:{n}", "이름": one.get("이름") or "", "까닭": link.why(one)}
| ({"견적": True} if (one.get("자원") or {}).get("갈래") == "고정" else {})
| ({"종": mp.kind_of(one["자원"])} if (one.get("자원") or {}).get("재료찾기") else {})
for n, one in enumerate(row.get("호표") or [])
if not one.get("이음") and not one.get("참조") and not (one.get("자원") or {}).get("내기계")
]
def _lit(v: Any) -> str:
if isinstance(v, (int, float, Decimal)) and not isinstance(v, bool):
return format(Decimal(str(v)).normalize(), "f")
return "'" + str(v).replace("'", "") + "'"
_BARE = re.compile(r"[^\W\d]\w*") # 따옴표 없이 쓰는 이름
def _q(name: Any) -> str:
return str(name) if _BARE.fullmatch(str(name)) else f"'{name}'"
# ── 이음 → 연결 ────────────────────────────────────────────────────────
def hourly_link(eq: str, part: str) -> dict | None:
"""기계(EQ) 시간당 그 비목 = 기계경비 단가산출 부름(`M02_Machine_Hourly` 와 같은 짝 고름) ·
자료 없음 = None."""
from M02_MasterTemplete import M02_Machine_Hourly as machine
if part not in imp.COSTS or not imp.hourly_of(eq).get("ok"):
return None
code = str(imp._whole().get(eq).get("원문번호") or "")
logic = machine.logic_of(code)
if not logic:
return None
given = {"기계": _lit(code)} if machine.takes_machine(logic) else {}
for spec in logic.get("입력") or []:
if spec.get("이름") != "기계":
given[spec["이름"]] = _lit((spec.get("고르기") or [""])[0])
return {"갈래": "단가산출", "키": str(logic["키"]), "입력": given, "칸": part}
def _logic_link(text: str) -> dict | None:
"""「로직(GC…, 이름='값')」 → 단가산출 연결 · 인자가 수 · 글 아니면 None(`San_ToDoc.logic_call`)."""
got = todoc.logic_call(text)
if got is None:
return None
given = {k: f"'{v[1]}'" if v[0] == "str" else _lit(v[1]) for k, v in got[1]}
return {"갈래": "단가산출", "키": got[0], "입력": given}
def _link_of(item: dict) -> tuple[dict | None, str]:
"""가져온 줄 하나의 연결(엑셀 값 기억 없이) · 설명(못 이은 까닭)."""
if item.get("참조"):
ref = item["참조"]
link = {
"갈래": "단가산출",
"키": ref["키"],
"참조": {"층": ref["층"], "주인": ref.get("주인")},
}
return link | ({"칸": item["참조비목"]} if item.get("참조비목") else {}), ""
key = str(item.get("이음") or "")
if not key:
return None, ""
if item.get("종류") == "로직":
return _logic_link(key), ""
if key.startswith("EQ"):
got = hourly_link(key, str(item.get("비목") or ""))
return got, "" if got else f"기계 {key} 시간당 경비 자료 없음 — 엑셀 단가 그대로"
if key.startswith("MO") and (got := _oil(key)):
return got, ""
import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤
link = {"갈래": "요소", "키": key}
if key[:2] == mm.LINKED: # 품셈재료 = 줄 단위로 값이 갈림(M01 변환과 같음)
link["단위"] = str(item.get("단위") or "")
if key[:2] == mm.MARKET and (unit := str(item.get("단위") or "")):
link["단위"] = unit # 840-3 자재품목 = 셈이 줄 단위로 환산(`master_pick.priced`)
return link, _unit_note(key, unit)
return link, ""
def _unit_note(key: str, unit: str) -> str:
"""840-3 자재 단위 ↔ 줄 단위 글 — 같음 · 1 : 1 = 빈 글 · 같은 성격 = 환산 · 성격 다름 = 경고(사람이 고른 줄도)."""
import master_material as mm # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤
mu = mm.mu
try:
have = str(imp._whole().get(key).get("단위") or "")
except Exception: # noqa: BLE001 — 없는 키 = 셈이 끊김 표지
return ""
if not have or mu.factor(have, unit) == 1:
return ""
if mu.same_kind(have, unit):
return f"단위 환산 {have} → {unit}"
return f"단위 다름 {unit} ↔ {have} — 값은 자재 단위 그대로"
OPTION = "_옵션" # 연결이 부르는 옵션 변수(문서에 없으면 `_attach` 가 더함)
def _oil(key: str) -> dict | None:
"""유가 · 전력 이음(814-1 · 요구 748) — 우리 기초 꼴: 유가 = `MO:경유:{S_지역}` + 지역 옵션(기본
전국평균) · 전력 = 전력량요금 계약종별 고르기 + 계약종별 옵션(기본 일반용(갑)Ⅰ 저압)."""
whole = imp._whole()
try:
row = whole.get(key)
except Exception: # noqa: BLE001 — 없는 키 = 보통 요소 연결
return None
rows = list(whole.index.get("MO", {}).values())
if row.get("구분") == "전력":
kinds = list(dict.fromkeys(str(r.get("상세구분")) for r in rows if r.get("구분") == "전력" and r.get("이름") == row.get("이름"))) # fmt: skip
var = _choice("전력 계약종별", "전력계약종별", kinds, str(row.get("상세구분")))
link = {
"갈래": "요소",
"재료": {"이름": row.get("이름"), "계약종별": "입력"},
"단위": "㎾h",
}
return link | {"계약종별": dc.md.var_id(var), OPTION: var}
head = str(row.get("원문번호") or "").split(":")[0]
if not head or row.get("구분") != "유류":
return None
places = [
str(r.get("상세구분")) for r in rows if str(r.get("원문번호") or "").split(":")[0] == head
]
places.sort(key=lambda x: x != "전국평균")
var = _choice("지역", "지역", places, str(row.get("상세구분")))
return {"갈래": "요소", "키": f"MO:{head}:{{{dc.md.var_id(var)}}}", OPTION: var}
def _choice(key: str, below: str, items: list[str], value: str) -> dict:
link = {"갈래": "선택", "목록": items, "값": value}
return {
"열쇠": key,
"기호": "S",
"아래": below,
"위": "",
"이름": key,
"단위": "",
"연결": link,
}
MACHINES = "_기계" # 문서 셈 동안 잠깐 — `derive` 가 머리 `가져온.기계` 로 옮김
MATS = "_재료" # 같은 꼴 — 머리 `가져온.재료`(827-3 `M02_San_MatPick.entry`)
def _machine_entry(item: dict, sym: str) -> dict:
"""기계 줄 찾기 판정 한 칸 — {기호, 원래 {이름, 규격, 단위}, 판정, 키, 후보, 찾기어, 까닭, 조합?}."""
res = item["자원"]
got = res["찾기"]
one = {
"기호": sym,
"원래": {"이름": got["이름"], "규격": got["규격"], "단위": item.get("단위")},
}
one |= {k: got.get(k) for k in ("판정", "키", "후보", "찾기어", "까닭")}
return one | {k: True for k in ("조합", "조합첫") if res.get(k)}
def _excel(item: dict) -> Any:
if item.get("값묶음"):
return {k: Decimal(str(item["값묶음"].get(k) or 0)) for k in imp.COSTS}
return Decimal(str(item["단가"])) if item.get("단가") is not None else None
def _attach(doc: dict, row: dict, ids: list[str], src: dict[str, dict]) -> None:
"""금액 줄 단가 숫자(엑셀 값) → 이은 연결 + 엑셀 값 기억(SK 고침으로 바뀐 값 = 숫자 그대로) ·
기계 찾기 판정(812-9) = 문서 `가져온.기계`(단가 기호마다 · 화면 고르기 · 저장 때 별칭)."""
by_id = {dc.md.var_id(v): v for v in doc.get("변수") or []}
found: list[dict] = doc.setdefault(MACHINES, [])
mats: list[dict] = doc.setdefault(MATS, [])
for at, line in enumerate((doc.get("금액") or [])[: len(row["호표"])]):
item = src.get(ids[at]) if at < len(ids) else None
price = str(line.get("단가") or "")
var = by_id.get(price.removesuffix(".계"))
if item is not None and var is not None and (item.get("자원") or {}).get("찾기"):
found.append(_machine_entry(item, dc.md.var_id(var)))
if item is not None and var is not None and (one := mp.entry(item, dc.md.var_id(var), _excel(item))): # fmt: skip
mats.append(one) # 827-3 재료 찾기 판정 · 그 파일 고름
if item is None or var is None or (var.get("연결") or {}).get("갈래") != "숫자":
continue
excel = _excel(item)
if not item.get("참조") and var["연결"].get("값") != excel:
continue # SK 덮개 단가 = 사용자 값
link, note = _link_of(item)
if mine := (item.get("자원") or {}).get("내기계"): # 821-4 꼬리표 「내 기계」
note = f"내 기계 {mine}" + ("" if link else " · 시간당 값 직접 — 엑셀 단가 그대로")
if note:
var["설명"] = note
if link is None:
if not note and not item.get("이음"): # 못 이은 까닭(814-1 — 흠 아님 · 우리 정보 없음)
from M02_MasterTemplete import M02_San_Link as san_link
why = san_link.why(item)
var["설명"] = (
why if why == san_link.QUOTE else f"이음 없음 — {why} · 엑셀 단가 그대로"
)
continue
if (opt := link.pop(OPTION, None)) and opt["열쇠"] not in {
v.get("열쇠") for v in doc["변수"]
}:
doc["변수"].append(opt) # 유가 지역 · 전력 계약종별 옵션(문서에 하나)
if item.get("참조비목") and isinstance(excel, dict):
excel = excel[item["참조비목"]]
line["단가"], line["비목"] = dc.md.var_id(var), item["참조비목"]
var["연결"] = link if mp.chosen(item) else {**link, XL: excel} # 827-3 고른 줄 = 우리 값
def _numbers(doc: dict, keep: dict) -> None:
"""수 하나뿐인 식 줄(EST 얼린 변수) → 숫자 연결 · 고른 칸 중간 → 엑셀 칸 값 기억."""
by_id = {dc.md.var_id(v): v for v in doc.get("변수") or []}
lines = []
for one in doc.get("식") or []:
var = by_id.get(str(one.get("기호")))
try:
node = dc.md.parse(one.get("식"))
except dc.md.DocError:
node = None
if var is not None and node is not None and node[0] == "num":
var["연결"] = {"갈래": "숫자", "값": node[1]}
continue
lines.append(one)
doc["식"] = lines
for var in doc.get("변수") or []:
if var.get("열쇠") in keep and (var.get("연결") or {}).get("갈래") == "표":
var["연결"][XL] = keep[var["열쇠"]]
def derive(sk: dict, ctx: tuple | None = None, whole: Any = None) -> dict:
"""가져온 식 SK → 수식 문서(키 = SK 키) = 불러온 그대로 문서(`가져온.문서` · 857-3b) ·
옛 꼴(`가져온.로직`) = 읽지 않음(`OLD_FORM`)."""
meta = sk[imp.KEY]
got = meta.get(FIRST)
if not isinstance(got, dict):
raise sd.DocError(OLD_FORM)
doc = cp.deepcopy(got)
return {
**doc,
"키": str(sk.get("키") or doc.get("키")),
"이름": str(sk.get("이름") or doc.get("이름")),
}
def build(row: dict, src: dict, whole: Any = None) -> dict:
"""가져온 줄(읽기기 꼴 · 깨끗한 줄) + 원본 → 불러온 그대로 수식 문서 — 불러올 때 한 번(857-3b ·
`M02_San_ToDoc` · 변환기 · 색인 `.logic` · 옛 식 파서 안 부름)."""
whole = whole or imp._whole()
row, src = cp.deepcopy(row), cp.deepcopy(src) # 다듬기가 단계 · 글줄을 제자리에서 고침
meta = {"로직": row, "원본": src}
bare = bare_row(row)
ids = sd.line_ids(bare)
doc, notes = todoc.build(bare, whole, {})
_attach(doc, bare, ids, dict(zip(ids, row.get("호표") or [])))
_numbers(doc, {})
native = bool(src.get("원파일"))
if native or src.get("엑셀"): # 810-2 · 812-1 — 소계 비목 칸 비움 · 값 변수 출처
_native(doc, native)
head = {k: src.get(k) for k in HEAD if src.get(k)}
marks = list(src.get("표지") or [])
if native or src.get("엑셀"): # 810-3 — 품셈 조건 글(값 없음) = 「추정」 칸
head["추정"] = [
{"행": x.get("행"), "글": " ".join(str(x.get("글") or "").split())}
for x in src.get("글줄") or []
if GUESS in str(x.get("표지") or "")
]
if not (doc.get("금액") or doc.get("결과") or bare["호표"] or bare.get("덧줄")):
_empty(doc) # 빈 산근 = 엑셀 0 원(줄 없음 합) — 「—」 아님
marks.append(EMPTY)
found = doc.pop(MACHINES, None)
mats = doc.pop(MATS, None)
head |= {"기계": found} if found else {} # 812-9 기계 찾기 판정(줄 쌓기 고르기 · 저장 때 별칭)
doc["가져온"] = head | {"표지": marks} | ({"알림": notes} if notes else {})
shape.shape(doc, meta) # 809-1 · 요구 704 — 지은 이름 → 엑셀 글 머리 · EST 기계 세 줄 = 한 줄
alive = {dc.md.var_id(v) for v in doc.get("변수") or []}
if found: # 세 줄을 한 줄로 합쳐 사라진 기호의 기계 판정은 뺌
doc["가져온"]["기계"] = [x for x in found if x["기호"] in alive]
if mats: # 827-3 재료 찾기 판정(줄 쌓기 풍선말 · 이미 만든 SK 고름 얹기)
doc["가져온"]["재료"] = [x for x in mats if x["기호"] in alive]
if gaps := _unlinked(row):
doc["가져온"][LIST] = gaps
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty # 서로 부름 — 늦게
if spots := qty.slots(row): # 797-2 소요량 · 계수 자리(가져온 줄 수 차례 · 고름 = 문서 고침)
doc["가져온"]["자리"] = spots
qt.tidy(doc, meta) # 848-6 원문 단위 · Q 값 글자
return doc
def _native(doc: dict, native: bool = True) -> None:
"""원파일 · 엑셀 읽기기 문서 — 소계 덧줄(합 밖) 비목 칸 비움(금액만) · 수 하나 변수(옵션 칸) 출처
「원파일」(엑셀 = 출처 없음 → 화면 꼬리표 「엑셀」)."""
for line in doc.get("금액") or []:
if line.get("출처") == SUB and line.get("합밖"):
line.pop("비목", None)
for var in doc.get("변수") or []:
if native and (var.get("연결") or {}).get("갈래") == "숫자" and XL not in var["연결"]:
var["출처"] = "원파일"
EMPTY = "참고 · 빈 산근 — 엑셀 줄 없음 · 금액 0 그대로"
def _empty(doc: dict) -> None:
"""줄 없는 엑셀 산근 — 0 묶음 줄 하나(엑셀 금액 0 = 줄 없는 합 · 지은 값 아님)."""
doc["변수"].append(
{"열쇠": "P_빈", "기호": "P", "아래": "빈", "위": "", "이름": "빈 산근", "단위": "",
"연결": {"갈래": "숫자", "값": dict.fromkeys(imp.COSTS, Decimal(0))}}
) # fmt: skip
doc["금액"] = [{"이름": "빈 산근", "단위": "식", "비목": "묶음", "단가": "P_빈"}]
# ── 셈 ────────────────────────────────────────────────────────────────
def view(doc: dict, basis: str) -> dict:
"""단가기준 엑셀 = 엑셀 값 기억 연결(형제 SK 빼고)을 숫자로 · 우리 = 그대로 · 기계 줄(입력 「기계」)은
`입력`(기계 정체 — 작업량 엔진)을 남김(848-7 · 850-2 잠금 없음) ·
TS 짝 = `common_util/common_util_formula_doc_import.ts` `importView`(거울 시험 test_802_4b1)."""
if basis == "우리":
return doc
out = cp.deepcopy(doc)
for var in out.get("변수") or []:
link = var.get("연결") or {}
if XL in link and not str(link.get("키") or "").startswith("SK-"):
given = link.get("입력") if isinstance(link.get("입력"), dict) else {}
mine = {"입력": given} if "기계" in given else {}
var["연결"] = {"갈래": "숫자", "값": link[XL], **mine}
return out
class Links(dc.ml.Links):
"""M01 연결(지금 M01 · 수식 문서 폴더) + 형제 가져온 식 SK(부르는 쪽 단가기준)."""
def __init__(self, master: Any, basis: str, trail: tuple = ()) -> None:
super().__init__(master, dc.folder())
self.basis, self.trail, self.mine = basis, trail, {}
def doc(self, key: str) -> dict | None:
if not str(key).startswith("SK-"):
return super().doc(key)
return self.mine.get(key)
def learn(self, doc: dict) -> None:
"""문서의 형제 SK 연결 → 그 SK 문서를 읽어 둠(깊이 · 순환 = 못 읽음 · 표지는 계산기)."""
for var in doc.get("변수") or []:
link = var.get("연결") or {}
key, ref = str(link.get("키") or ""), link.get("참조")
if not key.startswith("SK-") or key in self.mine or not isinstance(ref, dict):
continue
full = {**ref, "키": key}
rid = refs.ref_id(full)
if rid in self.trail or len(self.trail) >= refs.DEPTH:
continue
sib = refs.read_ref(full)
mine = ((sib or {}).get(dc.KEY) or {}).get(
"문서"
) # 우리 기초 사본으로 바꾼 형제(810-4)
if not is_imported(sib) and not isinstance(mine, dict):
continue
self.mine[key] = None # 순환 막음
try:
sub = view(of(sib), self.basis) if is_imported(sib) else {**mine, "키": key}
except Exception: # noqa: BLE001 — 못 지음 = 없는 단가산출(연결 끊김 표지)
continue
self.mine[key] = sub
self.trail = (*self.trail, rid)
self.learn(sub)
def of(sk: dict) -> dict:
"""SK 의 문서 — 수식 길로 고친 것(따로) = 저장본 · 아니면 지금 줄에서 지음."""
got = sk.get(dc.KEY) if dc.has(sk) else None
if got and got.get("따로") and isinstance(got.get("문서"), dict):
return got["문서"]
return derive(sk)
def record(doc: dict, sk: dict) -> dict[str, Any]:
"""수식 탭 화면 캐시(`M02_Doc_Screen.record` 짝) — 단가기준 보기 문서 셈이 쓴 연결 · 형제 SK 문서."""
import master_doc_record as mr # `M02_Doc_Copy` 가 scripts 를 길에 둔 뒤
basis = basis_of(sk)
links = Links(_index(sk, None, doc), basis)
mine = view(doc, basis)
rec = mr.Rec(links)
try:
links.learn(mine)
rec.prefetch(mine)
dc.mc.calc(mine, rec)
if mine is not doc: # 848-7 엑셀 판 기계 줄 제어 구역 = 연결 문서 · 값도 화면 캐시에
rec.prefetch(doc)
dc.mc.calc(doc, rec)
except Exception: # noqa: BLE001 — 셈 틀림 = 셈 답 표지 · 기록은 모은 데까지
pass
return rec.out()
def run(doc: dict, sk: dict, master: Any = None, index: Any = None, upper: Any = None) -> dict:
"""가져온 식 문서 셈(SK 단가기준) — 계산기 = M01 과 같은 `master_doc_calc` ·
`index` = 셈 색인 갈음(빈틈 적기 · 823-1) · `upper` = ① 가져온 값 층(848-7 · 사본 `위덮음`)."""
basis = basis_of(sk)
links = Links(index or _index(sk, master, doc), basis)
mine = view(doc, basis)
try:
links.learn(mine)
return dc.mc.calc(
mine, links, cover=dc.mc.mcv.merge_layers(upper, dc.mc.mcv.cover_of(mine))
)
except Exception as e: # noqa: BLE001 — 계산기 예외 없음이 원칙 · 남은 틈도 「—」
return {
"셈됨": False,
"표지": [{"갈래": "셈 틀림", "글": str(e)}],
**dict.fromkeys(dc.COSTS),
}