Files
Aislo/M02_MasterTemplete/M02_Hopyo_Sangeun.py
T
eomsangdonandClaude Opus 5.5 c76822f9b0 refactor(860-12): 용어 「고르-」 → 「선택」 — 화면 · 서버 안내 글 323 곳(면고르기 · 자료 열쇠는 그대로)
- 바꿈: 고르기 → 선택 · 다시 고르기 · 다시 고름 → 재선택 · 고름 풀기 → 선택 해제 · 고른 → 선택한 · 고를 → 선택할 · 고르세요 → 선택하세요 · 골라 → 선택해 · 안 고르면 → 선택하지 않으면 등(TS 280 · Python 43 · CAD 앱 글 포함)
- 남김: 「면고르기 · 노면고르기및다짐」 = 공종 이름(사용자 확정) · 수식 문서 칸 · 파일 · 판정 · 상태 값을 겸하는 글(「고름」 · 「고르기」 · 「고른자재」 · 「고른」 · 「고를 것」 · 「규격 없음 — 고르기」 · 「단위 다름 — 고르기」 · 그 칸 이름을 가리키는 검사 글) · 「고르게」(가지런 뜻) · 주석 · 이름 · 자료 파일
- 파이썬 짝: `master_unit_swap.ts` ↔ `resources/master_data/scripts/master_unit.py` 같은 글(「선택해야 셈」) — 자료 값 아님
- 시험: 바뀐 글을 기대하던 15 개를 새 글로(소스 글 대조 포함)
- 목록 · 남긴 자리 = sub1 tmp/s894/표_용어_선택.md · typecheck 0 · CAD 앱 다시 지음 · 관련 + 관문 3,250 중 바뀐 글 시험 고친 뒤 통과(남은 1 = test_442_2 · 다른 창 860-6 의 station_display 자리 · 이번 일 무관)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 10:19:48 +09:00

207 lines
9.6 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`) ·
남은 것 = 만든 SK 짝(`origins` · `by_file` · `made` — 860-3 출처 지문 · 번) · 옛 본뜬 읽기(`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 # noqa: F401 — scripts 길을 둠
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
KIND = "sangeun"
WAIT_WHY = "확인 전 — [단가산출]에서 블록 [확인] 뒤 [옮기기]"
SK = "SK" # 옛 차이 SK 갈래(바탕 기초 + 차이 · 옛 파일)
LEFT = "안 이은 줄이 남음 — 줄마다 이을 것을 선택"
WHY = {
"단가산출": "맞는 기초 없음 — 선택 대기",
"자재": "자재 후보 여럿 · 없음",
"별도계상": "자재 후보 여럿 · 없음",
"노임": "같은 이름 노임 없음",
"기계": "같은 기계(EQ) 없음 · 여럿",
"호표": "하위 호표 단위 다름 · 같은 하위 둘째",
"%": "밑수가 다른 줄 금액 합 아님",
}
import master_base as mb # noqa: E402 — 바탕만(855-E 2-E4)
mm_unit = mb.mp.mm.plain_unit
def mark(key: str, no: int) -> str:
return f"{key} 단산{no}"
def origins(doc: Any) -> list[tuple[str, int | None]]:
"""가져온 식 SK 출처 `[(파일 지문, 블록 번)]` — 만들 때 원본 `지문` · `번` + 같은 내용 다시씀 `또`
(860-3 · `M02_Sangeun_FromHopyo` 가 적음 · 번 없는 것 = 860-3 전에 만든 것)."""
head = doc.get("가져온") if isinstance(doc, dict) else None
src = head.get("원본") if isinstance(head, dict) else None
if not isinstance(src, dict):
return []
out = []
for one in [src, *(src.get("또") or [])]:
if isinstance(one, dict) and one.get("지문"):
no = one.get("번")
out.append((str(one["지문"]), int(no) if no is not None else None))
return out
def by_file(folder: str | Path) -> list[tuple[str, list[tuple[str, int | None]]]]:
"""이 층 가져온 식 SK `[(SK 키, 출처)]` — 만든 SK 짝 찾기 한 기준(목록 배지 · 칠 · [끝내기] 셈 ·
다시 쓰기 · 재료 고름 「이미 만든」 · 860-3)."""
out = []
for path in sorted((Path(folder) / KIND).glob("SK-*.json")):
try:
got = origins(json.loads(path.read_bytes()))
except (OSError, ValueError):
continue
if got:
out.append((path.stem, got))
return out
def made(folder: str | Path, key: str, src: str | Path | None = None) -> dict[str, str]:
"""이 층(`folder`) 가져온 식 SK 가운데 출처가 그 HP 파일(지문)인 것 `{「HP 단산N」: SK 키}` ·
`src` = HP 파일이 있는 폴더(없으면 `folder` · 층 이름 없는 B09 임시 폴더도 그대로)."""
from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store
fp = str(hopyo_store.read(src or folder, key).get("지문") or "")
out: dict[str, str] = {}
for sk, got in by_file(folder) if fp else []:
for f, no in got:
if f == fp and no is not None:
out.setdefault(mark(key, no), sk)
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.src)
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}