Files
Aislo/M02_MasterTemplete/M02_Hopyo_Sangeun.py
T
eomsangdonandClaude Opus 5.5 7fd47cf727 chore(853-3): 호표 계보 죽은 것 걷음 — 묶음 ①
- 지움(부르는 곳 다시 찾음 — 저장소 전체 · 조립 주소 · 라우터 · 시험 · 도우미)
  · M02_Hopyo_SkUnit(import 0 · 시험 778-5 · 780-1 만) · M02_Hopyo_Item(길 hopyo-item 하나만)
  · 길 GET hopyo/{키}/{번}/siblings · POST hopyo-item(TS · JS 0 — 화면 [구조물 조합으로]는 구조물 조합 길을 바로 부름) + 그 몸 Build* 다섯
  · Library_Ask.ask_item · labor_finger(Hopyo_Item 만 부름)
  · Hopyo_Sangeun.Maker · _doc(만드는 곳 0) · Hopyo_Elem.prices · Hopyo_Units.hopyo_unit · summary(부르는 곳 0 · 시험만)
- 시험: test_572_hopyo_same 지움(Maker 만 봄) · test_705_2 구조물 조합으로 넷 지움 · test_778_5 단위 SK 셈 줄 뺌(줄 잇기 결과는 그대로 · 연결 표 셈은 시험 안에서) · test_780_1 단위 SK 판정 뺌(블록 · 부름 수 · 빈 블록 밖은 그대로)
- helper_728_2_cover_unit.cjs 는 SkUnit 안 부름(Cover_Model 을 봄) — 남김
- 서버 길 484 → 482(뜻한 둘만)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 14:47:45 +09:00

184 lines
8.5 KiB
Python

"""M02 일위대가 불러오기 → 단가산출(PLAN 718-1 · 729-1 · 778-5 · 785-5 · 785-7 · 요구 621 · 623 · 642) — SK 쓰기 · 이음.
SK 쓰기 · 같은 내용 재사용(`Maker`)은 853-3 에서 지움(만드는 곳 0 — 단산 블록 SK = `M02_Sangeun_FromHopyo`) ·
남은 것 = 본뜬 읽기(`made` · `origin_of`) · 부름 표(`calls` · `callers`) · 이음.
SK 이음(729-2 · 일위대가 모두 고정 길 · `M02_Hopyo_Build.Builder` · `M02_Hopyo_Make.Lines` 가 부름 — 옛 `SkLink`) =
확인 안 한 단가산출 줄 → 이 층 · 같은 원본 그 블록 SK 참조(`sk_line` · 없으면 「확인 전」 고름 대기 · 단위 다름 ·
못옮김 남음 = 못 이음) · 확인한 로직 줄이 차이 SK 의 바탕 = 그 SK 참조(`kept`) · 남은 줄 = `left`.
"""
from __future__ import annotations
import json
from decimal import Decimal
from pathlib import Path
from typing import Any
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Elem as elem
from M02_MasterTemplete import M02_Hopyo_Fixed as hfix
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete.M02_Hopyo_Kids import _same_mark
ORIGIN = "실무자료"
KIND = "sangeun"
WAIT_WHY = "확인 전 — [단가산출]에서 블록 [확인] 뒤 [옮기기]"
SK = "SK" # 옛 차이 SK 갈래(바탕 기초 + 차이 · 옛 파일)
LEFT = "안 이은 줄이 남음 — 줄마다 이을 것을 고름"
WHY = {
"단가산출": "맞는 기초 없음 — 고름 대기",
"자재": "자재 후보 여럿 · 없음",
"별도계상": "자재 후보 여럿 · 없음",
"노임": "같은 이름 노임 없음",
"기계": "같은 기계(EQ) 없음 · 여럿",
"호표": "하위 호표 단위 다름 · 같은 하위 둘째",
"%": "밑수가 다른 줄 금액 합 아님",
}
mm_unit = m01.cm.mf.mp.mm.plain_unit
def mark(key: str, no: int) -> str:
return f"{key} 단산{no}"
def made(
folder: str | Path, key: str | None = None, source: refs.Here | None = None
) -> dict[str, str]:
"""이 층 실무자료 단가산출 `{본뜬 키: SK 키}`(`key` = 그 HP 것만 · `source` = 파일 층으로 거름)."""
out = {}
for path in sorted((Path(folder) / KIND).glob("SK-*.json")):
try:
got = json.loads(path.read_bytes()).get("본뜬")
except (OSError, ValueError, AttributeError):
continue
if not isinstance(got, dict) or got.get("층") != ORIGIN:
continue
for one in [got, *(got.get("또") or [])]: # 또 = 같은 내용으로 이 SK 를 쓴 뒤 출처(733-1)
mark_ = str((one or {}).get("키") or "") if isinstance(one, dict) else ""
if not mark_ or (key is not None and not mark_.startswith(f"{key} ")):
continue
if source is None or not one.get("원본") or tuple(one["원본"]) == tuple(source):
out[mark_] = path.stem
return out
def origin_of(doc: dict, mark_: str, source: refs.Here | None = None) -> dict[str, Any]:
"""그 블록 출처의 본뜬(갈래 · 못옮김 · 놓음 …) — 또 가운데 `mark_` · 없으면 제 본뜬."""
own = doc.get("본뜬") or {}
want = {"키": mark_, "원본": list(source) if source else None}
also = [x for x in own.get("또") or [] if isinstance(x, dict)]
return next((x for x in also if _same_mark(x, want)), own)
def calls(hp: dict[str, Any]) -> tuple[dict[int, dict], dict[int, dict]]:
"""(블록 {번: 블록}, 부르는 첫 줄 {번: 줄 + `_호표`})."""
blocks = {int(b["번"]): b for b in hp.get("단산") or [] if b.get("번") is not None}
first: dict[int, dict] = {}
for h in hp.get("호표") or []:
for line in h.get("줄") or []:
ref = line.get("참조") or {}
no = int(ref.get("번") or 0) if ref.get("종류") == "단산" else 0
if no in blocks and no not in first:
first[no] = {**line, "_호표": h.get("번")}
return blocks, first
def callers(hp: dict[str, Any]) -> dict[int, list]:
"""{단산 번: 부르는 호표 번 [차례대로 · 겹침 뺌]} — 없는 번 = 일위대가 밖."""
out: dict[int, list] = {}
for h in hp.get("호표") or []:
for line in h.get("줄") or []:
ref = line.get("참조") or {}
if ref.get("종류") == "단산" and ref.get("번"):
got = out.setdefault(int(ref["번"]), [])
if h.get("번") not in got:
got.append(h.get("번"))
return out
# ── SK 이음(일위대가 모두 고정 길 · 옛 `M02_Hopyo_SkLink`) ───────────────────────────
def _num(value: Decimal) -> int | float:
value = value.normalize()
return int(value) if value == value.to_integral_value() else float(value)
def sks(b: Any) -> dict[str, str]:
"""이 층 그 HP 의 SK `{본뜬 키: SK 키}`(한 번 읽어 둠 · `b` = `Builder`)."""
if b._sk is None:
b._sk = made(b.folder, b.key, b.source)
return b._sk
def sk_doc(b: Any, key: str) -> dict[str, Any]:
try:
got = json.loads((b.folder / KIND / f"{key}.json").read_bytes())
except (OSError, ValueError):
return {}
return got if isinstance(got, dict) else {}
def _ref(key: str, alias: Any, memo: str, qty: Decimal) -> dict[str, Any]:
head = {"층": refs.here()[0], "주인": refs.here()[1], "키": key}
return {"참조": head, "별칭": alias, "메모": memo, "수량": {"손": _num(qty)}}
def _lost(no: int, key: str, lost: list) -> dict[str, Any]:
why = f"단가산출 못옮김 {len(lost)} — [단가산출 만들기]에서 이음"
return {"까닭": why, "단산": no, "SK": key, "못옮김": lost}
def sk_line(b: Any, line: dict[str, Any], create: bool) -> tuple[dict | None, dict | None]:
"""단가산출 줄 → (그 블록 SK 참조 줄, 못 이은 까닭 {까닭, 후보?}) — SK 없음 + `create`(불러오기 길) =
부르는 블록이면 「확인 전」(SK 는 옮기기로만 만듦)."""
ref = line.get("참조") or {}
if ref.get("종류") != "단산":
return None, None
no = int(ref.get("번") or 0)
key = sks(b).get(mark(b.key, no))
if key is None:
if create and no in calls(b.doc)[1]:
return None, {"까닭": WAIT_WHY, "후보": []}
return None, None
doc = sk_doc(b, key)
lost = origin_of(doc, mark(b.key, no), b.source).get("못옮김") # 출처마다(733-1)
if lost: # 연결 안 되면 못 만듦(내역 20-4)
return None, _lost(no, key, lost)
unit = doc.get("단위") or line.get("단위")
if mm_unit(unit) != mm_unit(line.get("단위")):
return None, {"까닭": f"단가산출 단위 「{unit}」 다름"}
qty = Decimal(str(line.get("수량") or 0))
alias = str(line.get("이름") or "")[: labor.ALIAS_MAX].strip() or None
return _ref(key, alias, f"실무 {qty}{line.get('단위') or ''} · 단산{no}", qty), None
def kept(
b: Any, line: dict, one: dict, qty: Decimal, alias: Any, memo: str
) -> tuple[dict | None, dict | None]:
"""확인한 로직 줄이 그 블록 차이 SK 의 바탕 = (그 SK 참조, 못옮김 남으면 까닭) · 아니면 (None, None)."""
ref = line.get("참조") or {}
if ref.get("종류") != "단산" or one.get("몫") is not None:
return None, None
no = int(ref.get("번") or 0)
key = sks(b).get(mark(b.key, no))
doc = sk_doc(b, key) if key else {}
base = (doc.get("바탕") or {}).get("로직")
mine = origin_of(doc, mark(b.key, no), b.source) if doc else {}
if mine.get("갈래") != SK or base != one["로직"]:
return None, None
lost = mine.get("못옮김") # sk_line 과 같은 규칙 — 차이 잃지 않음(내역 20-4)
return _ref(key, alias, f"{memo} · 차이 SK", qty), _lost(no, key, lost) if lost else None
def left(line: dict[str, Any], why: dict | None) -> dict[str, Any]:
"""남은 줄 한 줄 — 엑셀 줄 · 갈래 · 까닭 · 후보(기계 = M01 EQ 셋 · 746-1)."""
kind = hfix.kind_of(line)
keep = ("차례", "이름", "규격", "단위", "수량")
out = {**{k: line.get(k) for k in keep}, "갈래": kind}
out["까닭"] = (why or {}).get("까닭") or WHY.get(kind, "이을 것 없음")
more = {k: v for k, v in (why or {}).items() if k not in ("까닭", "후보")}
cands = (why or {}).get("후보") or []
if not cands and kind == "기계":
cands = elem.machines(f"{line.get('이름') or ''} {line.get('규격') or ''}")
return {**out, "후보": cands, **more}