- M02_Item_Sangeun: freeze = SK 마다 지금 M02 셈 사본(Doc_Sk.copy_of · 덮음 반영)을 수식에 따로 · 굳힘 표지로 굳힘 · 원본 · 처음 · 덮음바탕(M01 따라옴 기록) 뺌 · 옛 GX9 키 · 굳힌줄 · 정체 · 원본 · SC 굳힌 덮개 줄 지움 · bundle_keys = SK 셈이 읽는 바탕 로직 · 부름 문서 키 · 값 사본 자원 키 · 가져온 식 줄 - M02_Item_Source: 단가.json 에 로직_단가산출.json(GX9) 없음 · SK 줄은 bundle_keys 로 모음 - B09 Labor_Source.sangeun: SK 대가 블록 = 수식 사본 문서 답(줄 이름 · 단위 · 종류 · 자원 키 · 하위 부름) · 셈법(792-4)은 줄이 기초 줄과 맞을 때만 · cid 열쇠 = SK 이름표 · 줄 덮개(패치) = M02 처럼 못 셈 - B09 Linked: sk_answer(사본 SK 문서 셈 · 가져온 식 = 단가기준) · 수요 키 = 셈 기록 - B09 Refresh: 바뀐 SK = SK 문서 · 수식 사본 대조 · Supply.sk_money: 배 = 바탕 줄(바탕 없음 = 1) - 골든 test_855_b09_golden 다시 뜸 — daega_inputs · 수요 두 갈래만(calc_user · 산근 · 미리보기 · B08 같음): SK 블록 origin · cid 열쇠(GX9 → SK 이름표) · 재료 단위 = 문서 표기(kg → ㎏) · 따로 고친 SK 줄 수량 = M02 문서(0.018 → 0.036 · 옛 굳힘은 고친 문서를 못 봄) · 옛 칸(율 더한줄) SK = M02 처럼 못 셈 → 그 SK 자원 키 둘(LB000038 · EQ000153) 빠짐 - 시험: test_719_1 · 719_2 견본을 수식 사본 있는 SK(M02 에서 고친 문서)로 · 단언을 새 사본 꼴로 · 719_2 옛 칸 견본 셋 지움(단가 덮개 · SC 더한줄 펼침 · 내 자료집 둘 — 옛 칸 SK 만들기 = 2-C1 셈 은퇴) · test_778_4 옛 칸 율 더한줄 SK 블록 하나 지움 · test_792_3 ⑤ · test_793_2 = 새 사본 꼴(793_2 우리 단가 = 사본 굳힘) - 검증: 관련 + 핵심 672 — 통과 671 · test_848_1 ㉦ 하나 = sub4 2-D 굳힘 표지 읽기 두 줄 뒤 통과(브레인 정함) · 사본 칸(골든 견본) SK 굳힌줄 · GX9 10 → 0 · 수식 따로 2 → 9 · typecheck 0 · 빌더 --check 같음 · 서버 뜸 로그 오류 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
209 lines
9.7 KiB
Python
209 lines
9.7 KiB
Python
"""집계 항목 원본 — 층(시스템 · 회사 · 개인)에서 항목 내용을 모음 (PLAN 21-1 · 25-1b · 25-2b).
|
|
|
|
모으는 것 = `{파일 이름: 내용}`:
|
|
`집계.json` SS 줄 + 열 정의 · `도면.json` SD · `면적.json` SA ·
|
|
`일위대가.json` = 층 `labor/<열id>.json` 문서(39-1c · 없으면 옛 UA 조합 줄 ·
|
|
규격 열 = summary_item `spec` 열 수량을 손으로 굳힘 · 704-4)
|
|
+ 담은 로직 줄(M01 시스템) + 알약(가져온 때 그대로) +
|
|
참조사본(단가승격 · 사전조합을 값으로 굳힘 · 단가산출 SK = 수식 문서 사본 따로 · 855-F B9-5) ·
|
|
`단가.json` 계산에 닿는 마스터 줄 전부(담은 로직 + 일위대가 자재 MT)
|
|
`원본판` = 모은 내용의 해시 — 지금 층 · 마스터에서 다시 모은 판과 대어 「마스터가 바뀜」 을 앎.
|
|
프로젝트가 고치는 값(`입력값.json` · `고른자재.json`)은 원본이 아니라 여기서 안 모음.
|
|
원본 층 자리 = `M02_Template_Layers` 경로 · 일위대가 · 단가는 M01 시스템 것.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from M02_MasterTemplete import M02_Material_Own as own
|
|
from M02_MasterTemplete import M02_Template_Layers as layers
|
|
|
|
TABLE_NAME = "구조물집계표"
|
|
#: 열 id → 스냅샷 파일(구조물 도면 · 면적산출)
|
|
PART_FILES = (("structure", "도면.json"), ("area", "면적.json"))
|
|
LABOR_KIND = "labor" # 열 id → 일위대가 문서(39-1c) — 스냅샷은 `LABOR_FILE` 에 감싸서
|
|
PRICE_FILE = "단가.json"
|
|
LABOR_FILE = "일위대가.json"
|
|
|
|
|
|
def layer_root(item: dict[str, Any]) -> Path:
|
|
"""항목 원본 층 뿌리 — 시스템 · 회사 · 개인."""
|
|
if item["layer"] == "system":
|
|
return layers.system_dir()
|
|
if item["layer"] == "company":
|
|
return layers.company_dir(item["owner"])
|
|
company, user = str(item["owner"]).split("/")
|
|
return layers.personal_dir(company, user)
|
|
|
|
|
|
def read_json(path: Path) -> Any:
|
|
try:
|
|
return json.loads(path.read_text(encoding="utf-8"))
|
|
except (OSError, ValueError):
|
|
return None
|
|
|
|
|
|
def row_of(document: Any, key: str) -> dict[str, Any] | None:
|
|
rows = document.get("줄") if isinstance(document, dict) else None
|
|
for row in rows or []:
|
|
# 옛 키로도 — 회사 · 개인 층 SS 키는 새 모양(SC · SP)으로 옮기며 `옛키` 에 남김(PLAN 26-4a)
|
|
if isinstance(row, dict) and (row.get("키") == key or key in (row.get("옛키") or [])):
|
|
return row
|
|
return None
|
|
|
|
|
|
def row_path(row: dict[str, Any]) -> list[str]:
|
|
"""SS 줄의 경로(26-1) — `경로` 칸이 있으면 그것 · 옛 줄은 종류 · 분류1~3(빈 분류는 건너뜀)."""
|
|
if isinstance(row.get("경로"), list):
|
|
return [str(p) for p in row["경로"] if str(p or "").strip()]
|
|
return [str(row[k]) for k in ("종류", "분류1", "분류2", "분류3") if row.get(k)]
|
|
|
|
|
|
def item_path(item: dict[str, Any]) -> list[str]:
|
|
"""층 SS 줄의 경로 — 없으면 LookupError."""
|
|
row = row_of(read_json(layer_root(item) / layers.COMBO_FILE), str(item.get("key")))
|
|
if row is None:
|
|
raise LookupError(f"집계 항목 {item.get('key')} 이 {item.get('layer')} 층에 없음")
|
|
return row_path(row) or [str(row["키"])]
|
|
|
|
|
|
def item_name(item: dict[str, Any]) -> str:
|
|
"""층 SS 줄의 보이는 이름(경로를 이은 글) — 없으면 LookupError."""
|
|
return " ".join(item_path(item))
|
|
|
|
|
|
def version_of(content: Any) -> str:
|
|
raw = json.dumps(content, ensure_ascii=False, sort_keys=True).encode("utf-8")
|
|
return hashlib.sha256(raw).hexdigest()[:16]
|
|
|
|
|
|
def labor_rows(ua_key: str) -> dict[str, Any] | None:
|
|
"""옛 조합 줄(마스터 UA · 회사 UC · 개인 UP) + 담은 로직 줄 — labor 문서가 없는 열
|
|
(옮기기 전)."""
|
|
from M02_MasterTemplete import M02_MasterTemplete_Combo_Store as combos
|
|
|
|
ua = combos.find(ua_key)
|
|
return None if ua is None else logic_rows(ua)
|
|
|
|
|
|
def labor_doc_rows(doc: dict[str, Any]) -> dict[str, Any]:
|
|
"""일위대가 문서(39-1a) + 담은 로직 줄 + 알약(`M02_Labor_Doc.pills` · 가져온 때 그대로 —
|
|
복사본 계산이 마스터를 안 읽게) + 참조사본 `{ref_id: 문서}`(50-3 · 원본이 바뀌어도 그대로)."""
|
|
from M02_MasterTemplete import M02_Item_Sangeun as sk
|
|
from M02_MasterTemplete import M02_Labor_Doc as labor_doc
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
|
|
rows = {**logic_rows(doc), "알약": labor_doc.pills(doc)}
|
|
copies = sk.freeze(refs.frozen(doc)) # 단가산출(SK) = 수식 문서 사본(855-F B9-5)
|
|
return {**rows, "참조사본": copies} if copies else rows
|
|
|
|
|
|
def logic_rows(row: dict[str, Any]) -> dict[str, Any]:
|
|
"""`{줄: row, 로직: 담은 로직 줄(M01 시스템), 빠진로직: 없는 로직 키}`."""
|
|
from M01_MasterData import M01_MasterData_Store as m01
|
|
|
|
wanted = [str(entry.get("로직")) for entry in row.get("담은로직") or [] if entry.get("로직")]
|
|
found: dict[str, dict[str, Any]] = {}
|
|
raw: dict[str, Any] = {} # M01 적재본은 수가 Decimal — 줄은 원본 파일 JSON 그대로 담음
|
|
# 로직 키 → 파일 이름만(`m01.logic` 은 검사 · 단가 미리보기까지 돌아 느림 · 156-2)
|
|
files, _ = m01.loaded()
|
|
where = {
|
|
str(one.get("키")): name
|
|
for name, data in m01._logic_files(files)
|
|
for one in data.get("줄") or []
|
|
}
|
|
for key in wanted:
|
|
file = where.get(key)
|
|
if file is None:
|
|
continue
|
|
if file not in raw:
|
|
raw[file] = read_json(Path(m01.FOLDER) / file)
|
|
got = row_of(raw[file], key)
|
|
if got is not None:
|
|
found[key] = got
|
|
return {
|
|
"줄": row,
|
|
"로직": [found[key] for key in wanted if key in found],
|
|
"빠진로직": [key for key in wanted if key not in found],
|
|
}
|
|
|
|
|
|
def build_source(item: dict[str, Any]) -> dict[str, Any]:
|
|
"""원본 층 · 마스터에서 항목 내용을 모음 — SS 줄이 없으면 LookupError."""
|
|
root = layer_root(item)
|
|
row = row_of(read_json(root / layers.COMBO_FILE), item["key"])
|
|
if row is None:
|
|
raise LookupError(f"집계 항목 {item['key']} 이 {item['layer']} 층에 없음")
|
|
column_id = str(row.get("열") or "")
|
|
table = read_json(root / "table" / f"{TABLE_NAME}.json") or {}
|
|
column = next((c for c in table.get("열") or [] if c.get("id") == column_id), None)
|
|
files: dict[str, Any] = {"집계.json": {"줄": row, "열": column}}
|
|
for kind, name in PART_FILES:
|
|
part = read_json(root / kind / f"{column_id}.json") if column_id else None
|
|
if part is not None:
|
|
files[name] = part
|
|
doc = read_json(root / LABOR_KIND / f"{column_id}.json") if column_id else None
|
|
if isinstance(doc, dict):
|
|
from M02_MasterTemplete import M02_Labor_Spec as labor_spec
|
|
|
|
labor = labor_doc_rows(labor_spec.freeze(doc, item.get("spec"))) # 고른 규격 열(704-4)
|
|
else:
|
|
labor = labor_rows(str(row["일위대가"])) if row.get("일위대가") else None
|
|
if labor is not None:
|
|
files[LABOR_FILE] = labor
|
|
files[PRICE_FILE] = price_bundle(labor, root)
|
|
return files
|
|
|
|
|
|
def price_bundle(labor: dict[str, Any] | None, root: Path) -> dict[str, Any]:
|
|
"""사본 단가 묶음(`단가.json`) — 담은 로직 · 굳힌 참조 로직 · SK 바탕 로직 · 자재 · 고른 자재 ·
|
|
사전조합 자재 · 개인 자재(`root` = 원본 층 · B09 설계내역서 서고 사본도 이 길 · 204-2) ·
|
|
SK 셈 = 그 수식 사본(굳힌 SK 로직 줄 없음 · 855-F B9-5)."""
|
|
from M02_MasterTemplete import M02_Item_Prices as prices
|
|
from M02_MasterTemplete import M02_Item_Sangeun as sk
|
|
from M02_MasterTemplete import M02_Labor_Fixed as fixed
|
|
from M02_MasterTemplete import M02_Labor_Ref as refs
|
|
|
|
copies = (labor or {}).get("참조사본") or {}
|
|
logic_keys = [str(one.get("키")) for one in (labor or {}).get("로직", [])]
|
|
logic_keys += refs.frozen_logics(copies) # 굳힌 단가승격 로직
|
|
sk_logic, sk_res, sk_rows = sk.bundle_keys(copies) # SK 수식 사본 셈이 읽는 줄(855-F B9-5)
|
|
logic_keys += sk_logic
|
|
doc = (labor or {}).get("줄") or {}
|
|
materials = [str(m.get("코드")) for m in doc.get("자재") or []]
|
|
materials += [ # 고른 로직 자재(103-1) 품목 줄도 — 복사본 계산이 그 단가를 씀
|
|
str(key) for one in doc.get("담은로직") or [] for key in (one.get("고름") or {}).values()
|
|
]
|
|
materials += refs.frozen_materials((labor or {}).get("참조사본") or {}) # 175-2 사전조합 자재
|
|
materials += fixed.link_keys(doc) # 705-1 고정 줄이 잇는 노임 · 자재 · 기계
|
|
materials += sk_res
|
|
wanted = logic_keys + [code for code in materials if code]
|
|
over = copy_rows([doc, *copies.values()]) # M02 로직 사본(795-4) = 만든 때 줄 먼저
|
|
bundle = (
|
|
prices.to_json(prices.collect(logic_keys, materials, sk_rows, over))
|
|
if wanted or sk_rows
|
|
else {}
|
|
)
|
|
if mine := own.bundle(
|
|
[c for c in materials if own.is_own(c)], root
|
|
): # 개인 자재(148-3 · 사전조합 것도 175-2) — 원본 목록이 바뀌어도 사본 그대로
|
|
bundle[own.BUNDLE] = mine
|
|
return bundle
|
|
|
|
|
|
def copy_rows(docs: list[Any]) -> list[dict[str, Any]]:
|
|
"""문서 · 굳힌 참조사본(SK 는 `원본`)의 로직 사본 줄(795-4) — 키 겹침 = 앞 문서 것."""
|
|
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
|
|
|
out: dict[str, dict] = {}
|
|
for doc in docs:
|
|
for one in (doc, doc.get("원본") if isinstance(doc, dict) else None):
|
|
if skc.has(one):
|
|
for row in [*one[skc.KEY]["로직"], *(one[skc.KEY].get("단가") or [])]:
|
|
out.setdefault(str(row.get("키")), row)
|
|
return list(out.values())
|