- 바꿈: 고르기 → 선택 · 다시 고르기 · 다시 고름 → 재선택 · 고름 풀기 → 선택 해제 · 고른 → 선택한 · 고를 → 선택할 · 고르세요 → 선택하세요 · 골라 → 선택해 · 안 고르면 → 선택하지 않으면 등(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>
207 lines
9.6 KiB
Python
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}
|