Files
Aislo/M02_MasterTemplete/M02_Labor_Expand.py
T
eomsangdonandClaude Opus 5.5 0308333e71 refactor(855-2-C5): 나머지 옛 엔진 셈 자리 — 로직 줄 · 옛 단가승격 · 호표 들이기 재료 · 줄 덮개 · 복사 배를 문서 셈으로
- `Labor_Copy.line` = 층 셈 문서 한 길 — 사본 있음 = 사본 · 없음(저장 전 새 문서) = 지금 M01 문서 · 셈 기록(`master_doc_trace`)으로 로직 자재 차례 · 품목 키(`재료`) · 줄 단위 · 별도계상 줄은 상세에서 뺌 · 프로젝트 층 · OLD 시험 = 옛 길(B9)
- `Labor_Expand._promote`(옛 단가승격) = 층 = 같은 문서 셈(로직 자재 직접계산 = 옛 셈 꼴) · 프로젝트 사본 = 옛 길(B9) · `_logic` 굳힌 덮개 줄 = 옛 길(B9)
- `Hopyo_Build._inside`(호표 들이기 로직 자재 같은 품목) = `Labor_Copy.line` 재료(옛 엔진 안 돎)
- `Labor_Patch.run` · `ref`(일위대가 줄 덮개) = 못 셈 + 까닭 하나(옛 칸 고침 · 저장소 0 · 올림 없음)
- `Doc_Take._sk` 복사 펼침 배 = `ratio_of`(문서 셈 안 돎)
- M02 옛 엔진 셈 부르는 자리(정적 · census_calls) 13 → 10 · 층 길 0 — 남은 것 = `Labor_Doc.run_line` 몸 · 프로젝트 사본 길(`_frozen` · `Labor_Copy.line` · `_promote` · `_logic` 굳힌 줄 — B9) · `Logic_Settle`(B09 짝)
- 로직 1,521 사본 없는 길 옛 대 새: 기준 같음 1,420 · 둘 다 못 셈 68 · 옛만 못 셈 → 새 셈 31 · 다름 2(GC000001 · GC000939 = 값 없는 자재(27 년 보강) + 일위대가 기본 별도계상 — 사본 길과 같은 규칙) · 재료 품목 키 같음 1,313 · 새 쪽이 더 찾음 140
- 시험: 802_4a ⑥ 문서 셈 확인 = `Labor_Copy._traced` · 747_1 줄 덮개 시험 지움(못 셈) · m02_858_shelf_golden 다시 뜸(서고 SK 견본 = 더한줄 고정 = 옛 칸 → 2-C1 뒤 기준금액 없음 · 2-C1 때 놓침)

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

281 lines
14 KiB
Python

"""M02 서고 참조 펼침(계산) — `M02_Labor_Ref.Expand` 를 떼어 둠(PLAN 715-2 · 700 줄).
참조 → `{이름, 단위, 기준(1 단위), 까닭, 안?}` — 단가승격(옛 SP) · 사전조합(SC) · 단가산출(SK ·
`M02_Sangeun_Calc.unit`). 이름은 `M02_Labor_Ref.Expand` 로 그대로 부름.
사전조합 안 줄 수량(742-1) 차례 — 층 문서 = 알약 값(쓰는 쪽 `given` 「참조|층|주인|키#차례」 · 자재 =
「…#자재|코드」 · `inner_pills`) → 저장 손 · 굳힌 사본(`hands` · 프로젝트) = 굳힌 손(옛 사본 · 707-7) →
알약 값 → 저장(`refs.SAVED`) · 비율 줄 = 율 · 모두 없으면 「수량 없음」(1 아님 · 그 사전조합 기준 없음).
"""
from __future__ import annotations
from collections.abc import Callable
from decimal import Decimal
from typing import Any
from M02_MasterTemplete import M02_Labor_Copy as lc
from M02_MasterTemplete import M02_Labor_Fixed as fixed
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Sangeun_Calc as calc
Ref = dict[str, Any]
NO_QTY = "수량 없음"
MAT = "자재|"
class Expand:
"""참조 → `{이름, 단위, 기준(1 단위), 까닭, 안?}` — 한 번 셈 안에서 키별 캐시 ·
깊이 상한 · 순환은 까닭(통째로 멈추지 않음). `read` = 참조 → 문서(프로젝트는 굳힌 사본)."""
def __init__(
self,
whole: Any,
read: Callable[[Ref], dict | None] = refs.read_ref,
given: dict[str, Any] | None = None,
hands: bool | None = None,
) -> None:
self.whole, self.read, self.memo = whole, read, {}
self.given = given or {}
self.hands = (
read is not refs.read_ref if hands is None else hands
) # 층 원본 손 = 옛 값(안 씀)
def _qty(self, one: dict, key: str) -> Decimal | None:
"""안 줄 수량 — 굳힌 손(사본) · 비율 줄 율 → 알약 값(given) → 저장 수량(층 손 · 사본 `저장`)."""
from M02_MasterTemplete import M02_Labor_Doc as labor
qty = one.get("수량") if isinstance(one.get("수량"), dict) else {}
hand = labor._number(qty.get("손"))
if hand is not None and (self.hands or refs.is_rate(one)):
return hand
got = labor._number(self.given.get(key))
if got is not None:
return got
return labor._number(qty.get(refs.SAVED)) if self.hands else hand
def __call__(
self, ref: Ref, trail: tuple[str, ...] = (), basis: str | None = None
) -> dict[str, Any]:
"""`basis` = 가져온 식 SK(797-1 산근 속 산근)를 부르는 쪽 단가기준(엑셀 | 우리)으로 셈."""
rid = refs.ref_id(ref)
if rid in trail:
keys = [t.rsplit("|", 1)[-1] for t in (*trail, rid)]
return self._stop(ref, "순환 — " + " → ".join(keys))
if len(trail) >= refs.DEPTH:
return self._stop(ref, f"참조가 {refs.DEPTH}단을 넘음")
memo = f"{rid}|{basis}" if basis else rid
if memo not in self.memo:
doc = self.read(ref)
if not isinstance(doc, dict):
return self._stop(ref, f"없는 참조 「{ref['키']}」")
if refs.kind_of(ref["키"]) == "promote":
self.memo[memo] = self._promote(doc)
elif refs.kind_of(ref["키"]) == "sangeun": # 단가산출(715-2) = 고친 줄 셈 1 단위
if basis and isinstance((doc.get("가져온") or {}).get("로직"), dict):
doc = {**doc, "가져온": {**doc["가져온"], "단가기준": basis}}
self.memo[memo] = calc.unit(doc, self.whole, self, (*trail, rid))
else: # 사전조합 = 그 SC 로직 사본(795-2)
self.memo[memo] = lc.combo(self, doc, (*trail, rid))
return self.memo[memo]
@staticmethod
def _stop(ref: Ref, why: str) -> dict[str, Any]:
return {"이름": ref["키"], "단위": None, "기준": None, "까닭": why}
def _promote(self, doc: dict) -> dict[str, Any]:
"""옛 단가승격(SP · 134-2 앞 꼴) — 층 = 로직 줄과 같은 문서 셈(`Labor_Copy.line` · 옛 엔진 안 돎 ·
855 2-C5) · 프로젝트 사본 = 옛 길(B9 걸음 몫)."""
from M02_MasterTemplete import M02_Labor_Doc as labor
line = (doc.get("담은로직") or [{}])[0]
if lc._project() or self.hands:
got = labor.run_line(
self.whole,
str(line.get("로직") or ""),
line.get("입력값"),
line.get("켜쌓기율"),
line.get("고름"),
)
else: # 옛 승격 = 로직 자재 직접계산(별도계상 안 뺌 · 옛 셈과 같음)
code = str(line.get("로직") or "")
try:
items = self.whole.logic(code).get("호표") or []
except Exception: # noqa: BLE001 — 없는 로직 = 셈이 까닭
items = []
direct = {"별도계상": "직접계산"}
marks = {str(n): direct for n, x in enumerate(items) if x.get("종류") == "재료"}
got = lc.line(self.whole, {}, {**line, "로직": code, "자재표시": marks})
times = labor._number(doc.get("배")) or Decimal(1)
base = got.get("기준")
why = got.get("까닭") or (None if base else "돈 아닌 로직")
return {
"이름": doc.get("이름"),
"단위": doc.get("단위"),
"로직": line.get("로직"),
"기준": {k: Decimal(str(v)) / times for k, v in base.items()} if base else None,
"까닭": why,
# 원 로직 줄(줄 누름 하위 행 · 51-2) — 1 단위로 나눔(하위 합 = 기준)
"줄": [
{
**x,
**{
k: None if x.get(k) is None else Decimal(str(x[k])) / times
for k in ("수량", "금액")
}, # 문서 줄 = 빈 값 있음
"비목": {k: Decimal(str(v)) / times for k, v in (x.get("비목") or {}).items()},
}
for x in got.get("줄") or []
],
}
def _logic(self, one: dict, pill: dict | None, doc: dict | None = None) -> dict[str, Any]:
"""사전조합 안 로직 줄 — 일위대가 로직 줄과 같은 `Labor_Copy.line`(문서 셈) · 배는 물량 알약 것 ·
굳힌 덮개 줄(프로젝트 사본) = 옛 길(B9 걸음 몫)."""
from M02_MasterTemplete import M02_Labor_Doc as labor
pill, fz = pill or {}, one.get("굳힌")
if isinstance(fz, dict) and fz.get("키"): # 사본 굳힌 덮개 줄(740-1 · `Item_Sangeun`)
got = labor.run_line(
self.whole, fz["키"], fz.get("입력값"), fz.get("켜쌓기율"), fz.get("고름") or None
)
got = labor.drop_apart(got, fz.get("자재표시"))
elif one.get(patch.FIELD): # 줄 덮개(715-3) = 이름 없는 단가산출 · 별도계상까지
got = patch.run(self.whole, one, self.read)
else: # 별도계상 로직 자재 뺌(222-1) · 수식 사본 SC = 문서 셈(802-4a)
got = lc.line(self.whole, doc or {}, one)
times = labor._number(pill.get("배")) or Decimal(1)
base = got.get("기준")
return {
"이름": pill.get("이름") or one["로직"],
"단위": pill.get("단위"),
"기준": {k: Decimal(str(v)) / times for k, v in base.items()} if base else None,
"까닭": got.get("까닭") or (None if base else "돈 아닌 로직"),
}
def _combo(self, doc: dict, trail: tuple[str, ...]) -> dict[str, Any]:
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
from M02_MasterTemplete import M02_Labor_Doc as labor
lines = [one for one in doc.get("담은로직") or [] if isinstance(one, dict)]
kept = doc.get("알약") # 프로젝트 참조사본 = 가져온 때 굳힌 알약(142-2) · 층 = 지금 M01
pills = kept if isinstance(kept, list) else None
by_logic = {
code: pill
for pill in pills or combo_store.combo_pills({"담은로직": lines})["물량"]
for code in pill["로직"]
}
inner, rows, why, rid = [], [], None, trail[-1] if trail else ""
keyed: list[dict] = [] # 율 밑 줄(778-4 · `fixed.rate_base`)
for at, one in enumerate(lines):
ref = one.get("참조")
if isinstance(ref, dict): # 줄 덮개(715-3) 있는 SK 참조 = 그 줄만 다시 셈
head = {"참조": ref}
sub = self(ref, trail) if not one.get(patch.FIELD) else patch.ref(one, self)
elif one.get("로직"): # 로직 줄(51-11) = 1 단위 값(기준 ÷ 배 · 승격과 같음) · 덮개 있음
head, sub = {"로직": one["로직"]}, self._logic(one, by_logic.get(one["로직"]), doc)
elif fixed.is_fixed(one): # 고정 줄(705-3) = 줄 단가 · 비율 줄 = 끝에(`ratio_row`)
head, sub = {"고정": one["고정"]}, fixed.line(self.whole, one["고정"])
else:
continue
qty = self._qty(one, f"{rid}#{at}")
keep = ("이름", "단위", "기준", "까닭")
inner.append({**head, "수량": qty, **{k: sub.get(k) for k in keep}})
if sub.get("기준") is None:
why = why or f"「{sub.get('이름')}」 {sub.get('까닭')}"
continue
if qty is None: # 742-1 — 저장 · 이은 값 없음 = 금액 빠짐(1 로 안 셈)
inner[-1]["까닭"] = NO_QTY
why = why or f"「{sub.get('이름')}」 {NO_QTY}"
continue
rows.append(labor.mcut.row({k: v * qty for k, v in sub["기준"].items()}))
if not refs.is_rate(head):
keyed.append(fixed.rate_row(head, labor.line_id(head), rows[-1]))
for mat in doc.get("자재") or []: # 사용자 자재(175-2) = 기준단가 × 수량(이은 값)
if labor.apart(mat): # 별도계상 = 안 셈 · 안 줄에도 없음(222-1)
continue
qty = self._qty(mat, f"{rid}#{MAT}{mat['코드']}")
got = labor.material_price(self.whole, mat["코드"], mat.get("단위"))
price = labor._number(got["기준단가"])
zero = dict.fromkeys(labor.COSTS, Decimal(0))
base = None if price is None else {**zero, "재료비": price, "계": price}
name = mat.get("이름") or mat["코드"]
inner.append(
{
"자재": mat["코드"],
"수량": qty,
"이름": name,
"단위": mat.get("단위"),
"기준": base,
"까닭": got["까닭"],
}
)
if qty is None or base is None:
inner[-1]["까닭"] = got["까닭"] or NO_QTY # 단가 까닭 먼저
why = why or f"「{name}」 {inner[-1]['까닭']}"
continue
rows.append(labor.mcut.row({k: v * qty for k, v in base.items()}))
keyed.append({"키": None, "묶음": "재료", "비목": rows[-1]})
for one in inner: # 비율 고정 줄(705-3) — 밑 = `rate_base`(778-4)
if rate := (one.get("고정") or {}).get("비율"):
under = fixed.rate_base(rate["기준"], keyed)
one["기준"], row = fixed.ratio_row(rate, one["수량"], under)
rows.append(row)
if row:
keyed.append(fixed.rate_row(one, labor.line_id(one), row, True))
return {
"이름": doc.get("이름"),
"단위": doc.get("단위"),
"머리": head_of(doc),
"기준": None if why else labor.mcut.sums(rows), # 줄 0.1 원 · 합 1 원 버림(751-3)
"까닭": why,
"안": inner,
}
def head_of(doc: dict) -> str | None:
"""상세 머리 「1 ㎡ 당」(715-3 · 일위대가 = 기준단위 1 당) — 단위 빈 옛 문서는 None."""
unit = str(doc.get("단위") or "").strip()
return f"1 {unit} 당" if unit else None
def inner_pills(
ref: Ref, read: Callable[[Ref], dict | None] = refs.read_ref, depth: int = 1
) -> list[dict[str, Any]]:
"""사전조합 안 줄 알약(723-1) — 키 「참조|…#차례」 · 「참조|…#자재|코드」 · 이름 = 「일위대가 · 줄」 ·
단위 = 그 줄 분모 · 비율 줄 뺌 · 안의 사전조합도 한 번씩(깊이 상한) · 사전조합 아니면 빈 것."""
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
doc = read(ref) if refs.kind_of(ref["키"]) == "precombo" and depth <= refs.DEPTH else None
if not isinstance(doc, dict):
return []
rid, top = refs.ref_id(ref), doc.get("이름") or ref["키"]
lines = [one for one in doc.get("담은로직") or [] if isinstance(one, dict)]
by_logic = {
code: pill
for pill in combo_store.combo_pills({"담은로직": lines})["물량"]
for code in pill["로직"]
}
out: list[dict[str, Any]] = []
for at, one in enumerate(lines):
if refs.is_rate(one):
continue
sub = one.get("참조")
if isinstance(sub, dict):
got = read(sub) or {}
name, unit = got.get("이름") or sub["키"], got.get("단위")
out += inner_pills(sub, read, depth + 1)
elif fixed.is_fixed(one):
name, unit = one["고정"].get("이름"), one["고정"].get("단위")
else:
pill = by_logic.get(one.get("로직")) or {}
name, unit = pill.get("이름") or one.get("로직"), pill.get("단위")
name = one.get("별칭") or name
out.append({"키": f"{rid}#{at}", "이름": f"{top} · {name}", "단위": unit or "", "로직": [], "참조": ref}) # fmt: skip
for mat in doc.get("자재") or []:
name = mat.get("이름") or mat.get("코드")
key = f"{rid}#{MAT}{mat.get('코드')}"
out.append({"키": key, "이름": f"{top} · {name}", "단위": mat.get("단위") or "", "로직": [], "참조": ref}) # fmt: skip
seen: set[str] = set()
return [p for p in out if not (p["키"] in seen or seen.add(p["키"]))]