- 저장 꼴: 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>
510 lines
25 KiB
Python
510 lines
25 KiB
Python
"""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),
|
||
}
|