diff --git a/B08_Quantity/B08_Quantity_Router_Material.py b/B08_Quantity/B08_Quantity_Router_Material.py index 7f27fdd93..68631747b 100644 --- a/B08_Quantity/B08_Quantity_Router_Material.py +++ b/B08_Quantity/B08_Quantity_Router_Material.py @@ -123,11 +123,11 @@ def _folder_units(root: str | Path, folder: str, meta: dict[str, dict]) -> dict[ """사본 하나 = 집계 항목 1 단위의 자재 `{키: 수량}` — 일위대가 자재(키 = MT 코드) + 로직 재료 (키 = 고른 품목 MT 코드 · 없으면 이름|단위 · 재료 수량 × 줄 수량 ÷ 배) + 참조 줄 안 재료 (160-3) · 줄 수량 빈칸 · 0 · 파형강관 · 기계 연료는 안 담음 · 셈 못 하면 빈 것.""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Item_Copy as copies from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete.M02_Doc_B09 import FILE as FORMULA_FILE - from M02_MasterTemplete.M02_Item_Prices import load_prices from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, PRICE_FILE, read_json try: @@ -176,7 +176,7 @@ def _folder_units(root: str | Path, folder: str, meta: dict[str, dict]) -> dict[ if qty is None: continue if isinstance(line.get("참조"), dict): # 참조 줄 = 배 1 - whole = load_prices(bundle) if whole is None else whole + whole = item_bundle.load(bundle, docs) if whole is None else whole for mat, per in _ref_mats(whole, read, line["참조"], given=given, docs=docs): logic_mat(mat, per * qty) continue diff --git a/B09_Estimation/B09_Estimation_Bill_Library.py b/B09_Estimation/B09_Estimation_Bill_Library.py index f8c89b2a9..2a14b4436 100644 --- a/B09_Estimation/B09_Estimation_Bill_Library.py +++ b/B09_Estimation/B09_Estimation_Bill_Library.py @@ -97,17 +97,15 @@ def _precombo_files(layer: str, owner: str | None, key: str, kind: str = "precom raise LookupError(f"{refs.TITLE[kind]} {key} 이 {layer} 층에 없음") line = {"참조": ref, "수량": {"손": 1}} labor = labor_doc_rows({"이름": doc.get("이름"), "단위": doc.get("단위"), "담은로직": [line]}) - return { - LABOR_FILE: labor, - PRICE_FILE: price_bundle(labor, refs.folder_of(layer, owner)), - "_원본": {"참조": ref, "name": doc.get("이름") or key, "단위": doc.get("단위") or ""}, - } + files = {LABOR_FILE: labor, PRICE_FILE: price_bundle(labor, refs.folder_of(layer, owner))} + origin = {"참조": ref, "name": doc.get("이름") or key, "단위": doc.get("단위") or ""} + return {**doc_b09.attach(files), "_원본": origin} # 수식 문서 사본 = 로직 몫(855-F B9-6) def source_version(files: dict[str, Any]) -> str: - """서고 사본 원본판(719-1) = 일위대가.json 지문 — 굳힌 SC · SK 문서(SK = 수식 사본) · - 단가는 뺌(단가 바뀜은 [업데이트] 단가 굳힘 몫) · 값 덮기 전에 셈.""" - return version_of(files.get(LABOR_FILE)) + """서고 사본 원본판(719-1) = 일위대가.json + 수식 문서(로직 몫 · 855-F B9-6) 지문 — 굳힌 SC · SK + 문서(SK = 수식 사본) · 단가는 뺌(단가 바뀜은 [단가 갱신] 몫) · 값 덮기 전에 셈.""" + return version_of([files.get(LABOR_FILE), (files.get(doc_b09.FILE) or {}).get("문서")]) def _build(kind: str, layer: str, owner: str | None, key: str) -> tuple[dict, dict]: diff --git a/B09_Estimation/B09_Estimation_Daega_Personal.py b/B09_Estimation/B09_Estimation_Daega_Personal.py index 9495f7dad..68a4641e9 100644 --- a/B09_Estimation/B09_Estimation_Daega_Personal.py +++ b/B09_Estimation/B09_Estimation_Daega_Personal.py @@ -10,10 +10,9 @@ 복사본 `K:`(703-2) = 원본까지 따라감(이름 · 덮개 = 복사본 것) 같은 이름 = 409 `{같은이름: 키, 이름}` → 부르는 쪽이 덮어쓰기(`overwrite` = 그 키) · 새 이름 · 쓰기 = 지금 층(`store.at` · 층 권한 · 폴더는 부르는 쪽). -품셈 블록(`P:` · 굳힌 SK 포함 · 719-2) = 개인 층 단가산출(SK · `sangeun`) — 바탕 = 그 M01 로직 · -원본 SK 문서(바탕 · 덮개 · 더한줄 · 뺀줄) · 넣을 값 · 고른 자재(cid) · B09 품 · 단가 덮개 = -SK 덮개(같은 cid · 굳힌 SK = `정체` 로 원본 cid · 더한줄 줄 = 그 더한줄 수량 · 단가) · -못 옮긴 칸 = 안담음 수 · +품셈 블록(`P:` · 사본 SK 포함 · 719-2) = 개인 층 단가산출(SK · `sangeun` · 855-F B9-6 수식 문서) — +바탕 = 그 M01 로직(넣을 값 · 켜쌓기율) · 사본 SK = 그 칸 + 수식 사본 문서 · B09 품 · 단가 덮개 · +고른 재료 = 수식 문서 금액 줄 고침(따로 · 옛 칸 덮개 안 씀) · 못 옮긴 칸 = 안담음 수 · 내 자료집 SK 불러오기 = B09 서고 사본 `sangeun`(`Bill_Library`). 불러온 공사 일위대가(707-7 · 참조 층 `project`) = 하위 호표 굳힌 문서를 문서 `_하위` 에 실어 보내고 쓸 때 지금 층에 같이 씀(새 키 · `본뜬.복사원본` = 그 참조 · 같은 하위는 한 번만 · @@ -43,7 +42,7 @@ from M02_MasterTemplete.M02_Item_Source import LABOR_FILE, PRICE_FILE, read_json KIND = "precombo" SK_KIND = "sangeun" -SK_KEEP = ("바탕", "입력값", "열린입력", "켜쌓기율", "고름", "자재표시", "덮개", "더한줄", "뺀줄") +SK_KEEP = ("바탕", "입력값", "켜쌓기율", "환산", "가져온") # 사본 SK 에서 옮기는 칸(수식 = 고침) SUBS = "_하위" PRICE_KEYS = ("labor", "material", "expense") @@ -53,9 +52,11 @@ def _combo(folder: Path) -> tuple[list[dict], list[dict]]: labor = read_json(folder / LABOR_FILE) or {} values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} - got = item_prices.calc( - labor, read_json(folder / PRICE_FILE) or {}, values, picks, read_json(folder / AREA_FILE) - ) + prices = read_json(folder / PRICE_FILE) or {} + formula = read_json( + folder / "수식.json" + ) # 사본 수식 문서(855-F B9-6 · 단가.json 에 로직 줄 없음) + got = item_prices.calc(labor, prices, values, picks, read_json(folder / AREA_FILE), formula) doc = item_prices.with_values(labor.get("줄") or {}, values, picks) lines = [ {**one, "수량": {"손": done.get("수량")}} @@ -176,67 +177,81 @@ def build(root: Path, cover_key: str, cover: dict[str, Any], name: str | None = def _sangeun(root: Path, block: dict, mine: dict, name: str | None) -> dict[str, Any]: - """품셈 블록 → 개인 층 SK 문서 `{문서, 담음, 안담음}` — 블록 줄 차례 = 엔진 줄 차례 = - cid 차례.""" - from M01_MasterData import M01_MasterData_Store as m01 + """품셈 블록 → 개인 층 SK 문서 `{문서, 담음, 안담음}`(855-F B9-6 · 수식 문서 꼴) — 바탕 = 그 M01 + 로직(입력값 · 켜쌓기율) · 사본 SK 블록 = 그 SK 칸 + 수식 사본 문서 · 블록 줄 차례 = 문서 금액 줄 + 차례 → B09 품 · 단가 덮개 = 그 금액 줄 수량 · 단가 글(한 비목 줄만) · 고른 재료 = 줄 규칙 · + 고친 것은 쓴 뒤 수식 길로 저장(`write` · `_수식`) · 못 옮긴 칸 = 안담음 수.""" + from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Sangeun_Doc as sd origin = block.get("origin") or {} rid = origin.get("단가산출") - if rid: # 굳힌 SK = 원본 문서 위에 · cid = 정체(굳힌 줄 차례 → 원본 cid) + fix: dict[str, Any] = {"줄": {}} + if rid: # 사본 SK = 그 칸 + 수식 사본 문서(855-F B9-5) frozen = _frozen(root, rid) - if frozen is None or not isinstance(frozen.get("원본"), dict): + if frozen is None or not isinstance((frozen.get("수식") or {}).get("문서"), dict): raise LookupError(f"단가산출 원천을 못 찾음 「{rid}」") - doc = {k: copy.deepcopy(frozen["원본"][k]) for k in SK_KEEP if k in frozen["원본"]} - ids = list(frozen.get("정체") or []) - unit = str(frozen["원본"].get("단위") or "") - else: # M01 로직 한 줄 = 바탕 · 고름 차례 → cid - try: - row = m01.loaded()[1].logic(str(origin.get("로직"))) - except Exception as e: # noqa: BLE001 — 엔진 FormulaError - raise LookupError(f"로직을 못 찾음 「{origin.get('로직')}」") from e - ids, unit = sd.line_ids(row), sg._unit(row)[0] - chosen = (origin.get("고름") or {}).items() - picks = {ids[int(n)]: mt for n, mt in chosen if int(n) < len(ids)} - doc = {"바탕": {"로직": origin.get("로직")}, "입력값": dict(origin.get("입력값") or {})} - doc |= {"고름": picks} if picks else {} + doc = {k: copy.deepcopy(frozen[k]) for k in SK_KEEP if k in frozen} + fix["문서"] = copy.deepcopy(frozen["수식"]["문서"]) + unit = str(frozen.get("단위") or "") + else: # M01 로직 한 줄 = 바탕 · 넣을 값 · 켜쌓기율 · 고른 재료(줄 차례) = 줄 규칙 + code = str(origin.get("로직") or "") + live = dc.folder().get(code) + if live is None: + raise LookupError(f"로직을 못 찾음 「{code}」") + unit = sg._unit({"결과단위": live.get("결과단위")})[0] + doc = {"바탕": {"로직": code}, "입력값": dict(origin.get("입력값") or {})} if origin.get("켜쌓기율") is not None: doc["켜쌓기율"] = origin["켜쌓기율"] - covers, added = doc.setdefault("덮개", {}), doc.setdefault("더한줄", []) + if origin.get("고름"): + fix["고름"] = {str(n): mt for n, mt in origin["고름"].items()} kept, skip = {"품": 0, "단가": 0}, {"품": 0, "단가": 0} for n, line in enumerate(block["lines"]): cell = {k: v for k, v in (mine.get(line.get("cid")) or {}).items() if k in COVER_KEYS} - cid = ids[n] if n < len(ids) else "" if not cell: continue - if cid.startswith("add:#"): # 더한줄 = 그 줄 수량 · 단가(한 비목 줄만) - one = added[int(cid[5:])] - if "qty" in cell: - one["수량"], kept["품"] = cell["qty"], kept["품"] + 1 - prices = [cell[k] for k in PRICE_KEYS if k in cell] - ok = len(prices) == 1 and "참조" not in one and "고정" not in one - if ok: - one["단가"], kept["단가"] = prices[0], kept["단가"] + 1 - skip["단가"] += len(prices) - (1 if ok else 0) - continue - if not cid or ("qty" in cell and doc.get("열린입력")): # 열어 둔 SK = 품 배율만 - skip["품"] += "qty" in cell - cell.pop("qty", None) - if not cell: - continue - if not cid: - skip["단가"] += len(cell) - continue - was = {k: v for k, v in (covers.get(cid) or {}).items() if k != "원값"} + one: dict[str, Any] = {} if "qty" in cell: - was.pop("배율", None) - covers[cid] = {**was, **cell} - kept["품"] += "qty" in cell - kept["단가"] += sum(k in cell for k in PRICE_KEYS) - if not covers: - doc.pop("덮개") + one["수량"], kept["품"] = cell["qty"], kept["품"] + 1 + prices = [cell[k] for k in PRICE_KEYS if k in cell] + if len(prices) == 1 and line.get("kind") in ("labor", "material", "fixed"): + one["단가"], kept["단가"] = prices[0], kept["단가"] + 1 + else: + skip["단가"] += len(prices) + if one: + fix["줄"][str(n)] = one head = {"종류": sd.TITLE, "이름": (name or block.get("name") or "").strip(), "단위": unit} - return {"문서": {**head, **doc}, "담음": kept, "안담음": skip} + head["더한줄"] = [] # SK 양식 뼈대(빈 목록 · 옛 칸 값 없음) + has_fix = fix["줄"] or fix.get("문서") or fix.get("고름") + made = {**head, **doc, **({FIX: fix} if has_fix else {})} + return {"문서": made, "담음": kept, "안담음": skip} + + +FIX = "_수식" # 쓴 뒤 수식 길로 저장할 고침(`write` 가 뗌) + + +def _num_text(value: Any) -> str: + from decimal import Decimal + + return format(Decimal(str(value)).normalize(), "f") + + +def _apply(key: str, fix: dict[str, Any]) -> None: + """새 SK 에 고침 — 문서(사본 SK 수식 문서 · 없으면 쓴 SK 문서) · 고른 재료 = 줄 규칙 · 줄 수량 · + 단가 글 → 수식 길 저장(`M02_Doc_Sk_Path.save` · 따로).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path + + read = sk_path.read(key) + base = copy.deepcopy(fix.get("문서") or read["문서"]) + base = {**base, "키": read["문서"].get("키", base.get("키"))} + if fix.get("고름"): + base = dc.line_doc(base, None, {int(n): mt for n, mt in fix["고름"].items()}) + for n, one in (fix.get("줄") or {}).items(): + lines = base.get("금액") or [] + if int(n) < len(lines): + lines[int(n)].update({k: _num_text(v) for k, v in one.items()}) + sk_path.save(key, {"문서": base, "판": read["판"]}) def _own(lines: Any) -> list[dict[str, Any]]: @@ -317,8 +332,8 @@ def write( """지금 층(`store.at` 안)에 씀 — 같은 이름이면 409 · `overwrite` = 같은 이름 그 키를 덮음 · 같은 내용(733-2) = 409 `{같은것, 까닭}`(같은 이름도 있으면 `같은이름 · 이름` 함께) → `new` 그래도 새로 · `use` 그 키(새로 안 만듦 · 답 `씀`).""" - subs = doc.get(SUBS) or {} - doc = {k: v for k, v in doc.items() if k != SUBS} + subs, fix = doc.get(SUBS) or {}, doc.get(FIX) + doc = {k: v for k, v in doc.items() if k not in (SUBS, FIX)} kind = SK_KIND if doc.get("종류") == refs.TITLE[SK_KIND] else KIND same = [ path.stem @@ -341,5 +356,9 @@ def write( doc = {**doc, "담은로직": _carry(doc["담은로직"], subs, {})} if overwrite: old = store.read(kind, overwrite) - return store.write(kind, overwrite, old["판"], {**doc, "키": overwrite}) - return refs.create(kind, doc) + got = store.write(kind, overwrite, old["판"], {**doc, "키": overwrite}) + else: + got = refs.create(kind, doc) + if fix: # 855-F B9-6 — SK 고침 = 수식 문서(옛 칸 덮개 안 씀) + _apply(str(got.get("이름") or overwrite), fix) + return got diff --git a/B09_Estimation/B09_Estimation_Doc_Run.py b/B09_Estimation/B09_Estimation_Doc_Run.py index e75b4a36e..a299aae80 100644 --- a/B09_Estimation/B09_Estimation_Doc_Run.py +++ b/B09_Estimation/B09_Estimation_Doc_Run.py @@ -315,6 +315,13 @@ def _shown(doc: dict, shown: dict[str, int]) -> dict: return doc +def load(bundle: dict[str, Any], docs: dict[str, dict]) -> Any: + """사본 셈 색인 = 단가 묶음 + 문서 이름표(`M02_Item_Bundle.load` · 855-F B9-6).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + return item_bundle.load(bundle, docs) + + class Shelf: """값 색인(`whole`) → 문서 묶음 — 같은 색인 = 같은 묶음(사본 `수식.json` · 없으면 셈 때 그 자리).""" @@ -325,6 +332,12 @@ class Shelf: self._got.append((whole, docs)) return docs + def put_whole(self, bundle: dict[str, Any], docs: dict[str, dict]) -> Any: + """단가 묶음 + 문서 → 셈 색인(`load`)을 짓고 그 문서 묶음을 둠 — 색인.""" + whole = load(bundle, docs) + self.put(whole, docs) + return whole + def of(self, whole: Any) -> dict[str, dict]: got = next((d for w, d in self._got if w is whole), None) return self.put(whole, {}) if got is None else got diff --git a/B09_Estimation/B09_Estimation_Labor_Source.py b/B09_Estimation/B09_Estimation_Labor_Source.py index b547f173a..09fbbc388 100644 --- a/B09_Estimation/B09_Estimation_Labor_Source.py +++ b/B09_Estimation/B09_Estimation_Labor_Source.py @@ -432,8 +432,8 @@ class Builder: prices = bundle(folder) # 841-1 미리 보기 덮개 values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} - whole = item_prices.load_prices(prices) - docs = self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + docs = dr.docs_of(folder) # 사본 수식 문서(855-F B9-3) + whole = self.shelf.put_whole(prices, docs) # 색인 = 단가 묶음 + 문서 이름표(B9-6) area = read_json(folder / AREA_FILE) result = item_prices.calc(labor, prices, values, picks, area, {"문서": docs}) use = (labor_doc.area_values(area), cover or f"S:{folder.name}") # SC 안 줄 알약(723-4) @@ -488,8 +488,9 @@ class Builder: doc = copies.get(refs.ref_id(ref)) if isinstance(ref, dict) else None if not isinstance(doc, dict): return None - whole = item_prices.load_prices(bundle(folder)) - self.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + whole = self.shelf.put_whole( + bundle(folder), dr.docs_of(folder) + ) # 사본 수식 문서(B9-3 · B9-6) if manifest["종류"] == "sangeun": # 내 자료집 단가산출(719-2) return self.sangeun(whole, ref, doc, copies, 1) return self.precombo(whole, ref, doc, copies, 1) diff --git a/B09_Estimation/B09_Estimation_Linked.py b/B09_Estimation/B09_Estimation_Linked.py index 755df9188..fc26d152c 100644 --- a/B09_Estimation/B09_Estimation_Linked.py +++ b/B09_Estimation/B09_Estimation_Linked.py @@ -39,11 +39,11 @@ def used_keys(folder: Path) -> list[str]: labor = read_json(folder / LABOR_FILE) if not isinstance(labor, dict): return [] - snapshot = item_prices.load_prices(bundle(folder)) + docs = dr.docs_of(folder) # 사본 수식 문서 — 셈 기록의 자원 키(855-F B9-3) + snapshot = dr.load(bundle(folder), docs) values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} seen: list[str] = [] - docs = dr.docs_of(folder) # 사본 수식 문서 — 셈 기록의 자원 키(855-F B9-3) # 사본 셈 한 벌(142-1)과 같은 길 — 빈 입력 = 자동값 · 켜쌓기율 · 고름 · # 굳힌 참조사본 안 로직까지 doc = item_prices.with_values(labor.get("줄") or {}, values, picks) diff --git a/B09_Estimation/B09_Estimation_Sangeun.py b/B09_Estimation/B09_Estimation_Sangeun.py index 1544dbb57..f4b252da2 100644 --- a/B09_Estimation/B09_Estimation_Sangeun.py +++ b/B09_Estimation/B09_Estimation_Sangeun.py @@ -113,9 +113,9 @@ def rows_of(folder: Path, whole: Any = None, docs: dict | None = None) -> list[d labor = read_json(folder / LABOR_FILE) if not isinstance(labor, dict): return [] - if whole is None: - whole = item_prices.load_prices(bundle(folder)) docs = dr.docs_of(folder) if docs is None else docs + if whole is None: + whole = dr.load(bundle(folder), docs) values = read_json(folder / VALUES_FILE) or {} picks = read_json(folder / PICKS_FILE) or {} copies = labor.get("참조사본") or {} @@ -515,9 +515,14 @@ def hand_sources(user: dict[str, Any] | None) -> list[tuple[str, str, dict[str, def hand_whole(hands: list[tuple[str, str, dict[str, Any]]]) -> Any: - """손 줄 로직의 닫힌 단가 묶음(사본 `단가.json` 꼴 · 마스터 캐시는 안 건드림).""" + """손 줄 로직의 닫힌 묶음 — 지금 M01 수식 문서 + 그 문서가 잇는 자원 · 표 줄(사본 꼴 · 855-F B9-6 · + 마스터 캐시는 안 건드림).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + codes = list(dict.fromkeys(src["code"] for _k, _u, src in hands)) - return item_prices.load_prices(item_prices.to_json(item_prices.collect(codes))) + docs = dc.closure(item_prices.master()[1], codes) + return dr.load(item_prices.to_json(item_bundle.collect(docs)), docs) def hand_resource_keys(user: dict[str, Any] | None) -> list[str]: @@ -552,8 +557,8 @@ def collect( return copy.deepcopy(memo["sg"]) solver = Solver(supply) for owner, folder in entries: - whole = item_prices.load_prices(bundle(folder)) - docs = solver.shelf.put(whole, dr.docs_of(folder)) # 사본 수식 문서(855-F B9-3) + docs = dr.docs_of(folder) # 사본 수식 문서(855-F B9-3) + whole = solver.shelf.put_whole(bundle(folder), docs) for src in rows_of(folder, whole, docs): solver.add(whole, src, owner) hand_keys: dict[str, str] = {} diff --git a/M02_MasterTemplete/M02_Doc_B09.py b/M02_MasterTemplete/M02_Doc_B09.py index 3143da594..ad2c067eb 100644 --- a/M02_MasterTemplete/M02_Doc_B09.py +++ b/M02_MasterTemplete/M02_Doc_B09.py @@ -13,35 +13,17 @@ from __future__ import annotations from typing import Any -from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Sk as dsk FILE = "수식.json" GROUP = "수식문서" -def logic_keys(bundle: dict[str, Any]) -> list[str]: - """단가 묶음의 로직 줄 키(그룹 「로직」 파일).""" - return [ - str(row.get("키")) - for data in bundle.values() - if isinstance(data, dict) and data.get("그룹") == "로직" - for row in data.get("줄") or [] - if isinstance(row, dict) and row.get("키") - ] - - def build(bundle: dict[str, Any], labor: dict[str, Any] | None = None) -> dict[str, Any]: - """`단가.json` 묶음 → `수식.json` 내용.""" - from M02_MasterTemplete import M02_Item_Prices as prices + """사본 일위대가 → `수식.json` 내용(`M02_Item_Source.formula_docs` · 단가 묶음 = 안 읽음).""" + from M02_MasterTemplete import M02_Item_Source as source - keys = logic_keys(bundle) - if not keys: - return {"그룹": GROUP, "문서": {}} - doc = (labor or {}).get("줄") or {} - have = (doc.get(dc.KEY) or {}).get("부름") if dc.has(doc) else None - whole = prices.load_prices(bundle) - return dsk.norm({"그룹": GROUP, "문서": dc.closure(whole, keys, have)}) + return dsk.norm({"그룹": GROUP, "문서": source.formula_docs(labor)}) def attach(files: dict[str, Any]) -> dict[str, Any]: diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index b053f1112..3f4b861f3 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -96,8 +96,23 @@ def _live(key: str) -> Any: return whole.index.get(key[:2], {}).get(key) +def _carried(whole: Any, key: str) -> dict | None: + """색인이 실어 온 문서(사본 셈 색인 `M02_Item_Bundle.Index.docs` · 감싼 색인 안쪽까지).""" + for _ in range(8): + own = vars(whole) if hasattr(whole, "__dict__") else {} + if key in (own.get("docs") or {}): + return own["docs"][key] + whole = own.get("_whole") + if whole is None: + return None + return None + + def doc_of(whole: Any, key: str) -> dict | None: - """키 하나의 문서 — 값 사본 줄 = 지금 M01 줄이면 M01 문서 · 다르면 그 줄 변환 · 없으면 None.""" + """키 하나의 문서 — 색인이 실어 온 사본 문서 › 값 사본 줄 = 지금 M01 줄이면 M01 문서 · 다르면 그 줄 + 변환 · 없으면 None.""" + if (got := _carried(whole, str(key))) is not None: + return cp.deepcopy(got) try: row = whole.logic(key) except _ERR: diff --git a/M02_MasterTemplete/M02_Item_Bundle.py b/M02_MasterTemplete/M02_Item_Bundle.py new file mode 100644 index 000000000..2bd426671 --- /dev/null +++ b/M02_MasterTemplete/M02_Item_Bundle.py @@ -0,0 +1,153 @@ +"""프로젝트 사본 단가 묶음(`단가.json`) — 수식 문서 묶음이 잇는 자원 · 표 줄만(PLAN 855-F B9-6). + +사본 = `수식.json`(셈 정본 · 닫힌 문서 묶음) + `단가.json`(자원 · 표 줄 — [단가 갱신] 이 바꾸는 자리) · +M01 로직 줄은 사본에 안 실음. 모으기 = 문서 변수 연결을 훑음(옛 로직 줄 식 글 훑기 대신): + 표 = 그 표 · 요소 키 = 그 줄(`{변수}` 틀 구멍 = 그 변수 고르기 목록으로 끼움 · 못 끼우면 그 + 테이블 전부 · 자재품목 뺌) · 재료 조건 = 후보 줄(구멍 = 목록 · 못 끼우면 구멍 칸 뺀 조건 · + 지역 · 계약종별 「입력」 = 넓게) · 준용 · 연결 줄도(`M02_Item_Prices._Collector.add`). +셈 색인(`load`) = 묶음 색인 + 문서 이름표 — `logic(키)` = 문서의 이름 · 결과단위 · 입력 이름(SK 배 · +B09 줄 꼴이 읽음 · 로직 줄 셈 칸 없음) · `docs` = 그 문서 묶음(`M02_Doc_Copy.doc_of` 가 먼저 읽음). +""" + +from __future__ import annotations + +import re +from typing import Any + +import master_doc as md # noqa: E402 — scripts 길 = prices(m01) + +from M02_MasterTemplete import M02_Item_Prices as prices + +_HOLE = re.compile(r"\{([^{}]+)\}") + + +def _options(ids: dict, hole: str) -> list | None: + opts = ((ids.get(hole) or {}).get("연결") or {}).get("목록") + return [str(x).strip("'") for x in opts] if opts else None + + +class _Docs(prices._Collector): + """수식 문서가 잇는 자원 · 표 줄 키 모음.""" + + def doc(self, doc: dict) -> None: + ids = {md.var_id(v): v for v in doc.get("변수") or []} + for v in ids.values(): + link = v.get("연결") or {} + if link.get("갈래") == "표" and link.get("표"): + self.add(str(link["표"])) + elif link.get("갈래") == "요소" and isinstance(link.get("재료"), dict): + self.cond(link["재료"], link.get("단위"), ids) + elif link.get("갈래") == "요소" and link.get("키"): + for ref in self.fill(str(link["키"]), ids): + self.add(ref) + + def fill(self, text: str, ids: dict) -> list[str]: + """틀 글 `{변수}` 구멍 → 고르기 목록으로 끼운 글들 · 목록 없는 구멍 = 그 테이블 전부(빈 목록).""" + out = [text] + for hole in sorted(set(_HOLE.findall(text))): + opts = _options(ids, hole) + if opts is None: + tid = prices.mk.id_of(text) + if tid and tid not in prices._TOO_BIG: + self.keys.update(self.whole.index.get(tid, {})) + return [] + out = [one.replace(f"{{{hole}}}", x) for one in out for x in opts] + return out + + def cond(self, cond: dict, unit: Any, ids: dict) -> None: + if cond.get("지역") == "입력" or cond.get("계약종별") == "입력": + self.widely(cond, unit) + return + variants = [cond] + holes = {h for v in cond.values() if isinstance(v, str) for h in _HOLE.findall(v)} + for hole in sorted(holes): + opts = _options(ids, hole) + if opts is None: + variants = [prices.mm.static(cond)] + break + variants = [ + { + k: v.replace(f"{{{hole}}}", x) if isinstance(v, str) else v + for k, v in one.items() + } + for one in variants + for x in opts + ] + for one in variants: + if one.get("대표"): + self.add(str(one["대표"])) + if one.get("구분") or one.get("검색어"): + for key in prices._candidates(self.whole, one): + self.add(key) + + +def collect( + docs: dict[str, dict], materials: list[str] | None = None, over: list[dict] | None = None +) -> dict[str, Any]: + """문서 묶음 `docs` 가 잇는 자원 · 표 줄 + 자재(MT)의 닫힌 단가 묶음 — 로직 줄 없음 · + `over` = M02 값 사본 줄(795-4 · 같은 키는 M01 줄 대신 · M01 에 없는 키 = `COPY_FILE`).""" + from M02_MasterTemplete import M02_Material_Own as mat + + files, whole = prices.master() + whole = mat.whole(prices.mym.whole(whole)) # 지금 층 내 기계(821-1) · 내 재료(840-4) + own = {str(r.get("키")): r for r in (*prices.mym.added(whole), *mat.added(whole))} + mine = {str(r.get("키")): r for r in over or [] if "호표" not in r and "흐름" not in r} + if mine: + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + whole = skc.Copy(whole, skc._rows({"로직": list(mine.values())})) + got = _Docs(whole) + for doc in docs.values(): + got.doc(doc) + for code in materials or []: + got.add(code) + out: dict[str, Any] = {} + seen: set[str] = set() + for name, data in files.items(): + if data.get("그룹") == "로직": + continue + slot = prices.m01.items_key(data) + rows = [ + mine.get(str(row.get("키")), row) + for row in data.get(slot) or [] + if str(row.get("키")) in got.keys + ] + seen.update(str(row.get("키")) for row in rows) + if rows: + out[name] = {**{k: v for k, v in data.items() if k != slot}, slot: rows} + left = [r for k, r in {**own, **mine}.items() if k in got.keys and k not in seen] + if left: + out[prices.COPY_FILE] = {"그룹": "사본", "줄": left} + if got.missing: + out["_빠진"] = sorted(set(got.missing)) + return out + + +class Index: + """사본 셈 색인 — 단가 묶음 색인 위 문서 이름표(`logic`) · 문서 묶음(`docs`) · 그 밖 그대로.""" + + def __init__(self, whole: Any, docs: dict[str, dict]) -> None: + self._whole, self.docs = whole, docs + + def logic(self, key: str) -> dict: + doc = self.docs.get(str(key)) + if doc is None: + return self._whole.logic(key) + names = prices.doc_inputs(doc) + row = {k: doc.get(k) for k in ("키", "이름", "결과단위", "출처")} + return {**row, "입력": [{"이름": n} for n in names], "호표": [], "중간": [], "덧줄": []} + + def __getattr__(self, name: str) -> Any: + return getattr(self._whole, name) + + def __setattr__(self, name: str, value: Any) -> None: + if name in ("_whole", "docs"): + object.__setattr__(self, name, value) + else: + setattr(self._whole, name, value) + + +def load(bundle: dict[str, Any], docs: dict[str, dict] | None) -> Any: + """`단가.json` + 문서 묶음 → 사본 셈 색인(문서 없음 = 묶음 색인 그대로).""" + whole = prices.load_prices(bundle) + return Index(whole, docs) if docs else whole diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 83bd69728..263c05b4e 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -452,11 +452,12 @@ def calc( (`formula`) 문서 셈(`line` · 855-F B9-2) · 단가 = 사본 `단가.json` · 참조 = 굳힌 `참조사본` · 알약 = 가져온 때 것 · 수량 칸 = 사본 `면적.json` · 빈 입력 = 자동값. 답 = 층 셈 꼴(`줄` · `자재` · `기준합` · `반영합`) + `알약` + `빠진입력`(「빈 값 n」 표시).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs - snapshot = load_prices(prices) docs = dict((formula or {}).get("문서") or {}) + snapshot = item_bundle.load(prices, docs) # 단가 묶음 + 문서 이름표(855-F B9-6) doc = with_values(labor.get("줄") or {}, values or {}, picks or {}) copies = labor.get("참조사본") or {} saved = labor.get("알약") diff --git a/M02_MasterTemplete/M02_Item_Snapshot.py b/M02_MasterTemplete/M02_Item_Snapshot.py index a6315b09e..efe468cbc 100644 --- a/M02_MasterTemplete/M02_Item_Snapshot.py +++ b/M02_MasterTemplete/M02_Item_Snapshot.py @@ -117,16 +117,14 @@ def seed_picks(labor: Any) -> dict[str, Any]: def build_snapshot(item: dict[str, Any]) -> dict[str, Any]: """원본 내용 + 프로젝트 값(입력값 · 고른자재 첫 값 = 일위대가 문서 것) — `{파일 이름: 내용}` · SS 줄이 없으면 LookupError.""" - from M02_MasterTemplete import M02_Doc_B09 as doc_b09 - - files = doc_b09.attach(build_source(item)) # 수식 문서 사본(802-4a) + files = build_source(item) # 수식 문서 사본(802-4a) 포함 labor = files.get(LABOR_FILE) return {**files, VALUES_FILE: seed_values(labor), PICKS_FILE: seed_picks(labor)} def source_files(files: dict[str, Any]) -> dict[str, Any]: - """원본판 몫 — 수식 문서 사본(802-4a · 로직은 `단가.json` 이 잼)은 뺌.""" - return {k: v for k, v in files.items() if k not in (*LOCAL_FILES, "수식.json")} + """원본판 몫 — 프로젝트 값 빼고 전부(수식 문서 사본 = 로직 몫 · 855-F B9-6).""" + return {k: v for k, v in files.items() if k not in LOCAL_FILES} def write_snapshot(target: Path, item: dict[str, Any], owner_id: str, extra: dict) -> dict: diff --git a/M02_MasterTemplete/M02_Item_Source.py b/M02_MasterTemplete/M02_Item_Source.py index 0ef96b1bc..241c337c5 100644 --- a/M02_MasterTemplete/M02_Item_Source.py +++ b/M02_MasterTemplete/M02_Item_Source.py @@ -103,33 +103,44 @@ def labor_doc_rows(doc: dict[str, Any]) -> dict[str, Any]: def logic_rows(row: dict[str, Any]) -> dict[str, Any]: - """`{줄: row, 로직: 담은 로직 줄(M01 시스템), 빠진로직: 없는 로직 키}`.""" - from M01_MasterData import M01_MasterData_Store as m01 + """`{줄: row, 빠진로직: M01 수식 문서에 없는 로직 키}` — 로직 줄 사본 안 실음(855-F B9-6 · + 셈 = 사본 `수식.json`).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + have = dc.folder() 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], - } + return {"줄": row, "빠진로직": [key for key in wanted if key not in have]} + + +def formula_keys(labor: dict[str, Any] | None) -> list[str]: + """사본 셈이 부르는 로직 키 — 담은 로직 · 굳힌 참조사본 안 로직 줄 · SK 바탕 · 수식 사본 부름.""" + from M02_MasterTemplete import M02_Item_Sangeun as sk + from M02_MasterTemplete import M02_Labor_Ref as refs + + doc = (labor or {}).get("줄") or {} + copies = (labor or {}).get("참조사본") or {} + keys = [ + str(one["로직"]) + for one in doc.get("담은로직") or [] + if isinstance(one, dict) and one.get("로직") + ] + return list(dict.fromkeys([*keys, *refs.frozen_logics(copies), *sk.bundle_keys(copies)[0]])) + + +def formula_docs(labor: dict[str, Any] | None) -> dict[str, dict]: + """사본 수식 문서 닫힌 묶음(`수식.json` 몫) — 원본 일위대가 문서의 수식 사본 부름이 먼저(만든 때 것) · + M02 값 사본 로직 줄(795-4) = 그 줄 문서 · 그 밖 = 지금 M01 문서(`M02_Doc_Copy.closure`).""" + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Prices as prices + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + doc = (labor or {}).get("줄") or {} + copies = (labor or {}).get("참조사본") or {} + have = (doc.get(dc.KEY) or {}).get("부름") if dc.has(doc) else None + rows = [r for r in copy_rows([doc, *copies.values()]) if "호표" in r or "흐름" in r] + whole = prices.master()[1] + whole = skc.Copy(whole, skc._rows({"로직": rows})) if rows else whole + return dc.closure(whole, formula_keys(labor), have) def build_source(item: dict[str, Any]) -> dict[str, Any]: @@ -156,23 +167,23 @@ def build_source(item: dict[str, Any]) -> dict[str, Any]: if labor is not None: files[LABOR_FILE] = labor files[PRICE_FILE] = price_bundle(labor, root) - return files + from M02_MasterTemplete import M02_Doc_B09 as doc_b09 + + return doc_b09.attach(files) # 수식 문서 사본(802-4a · 로직 몫 · 원본판에 듦 · 855-F B9-6) 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).""" + """사본 단가 묶음(`단가.json`) — 수식 문서 묶음이 잇는 자원 · 표 줄 · 자재 · 고른 자재 · 사전조합 + 자재 · 개인 자재(`root` = 원본 층 · B09 설계내역서 서고 사본도 이 길 · 204-2) · M01 로직 줄 없음 + (855-F B9-6 · 셈 = `수식.json`).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle 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.bundle_keys(copies) # SK 수식 사본 셈이 읽는 줄(855-F B9-5) - logic_keys += sk_logic + _logic, sk_res = sk.bundle_keys(copies) # SK 수식 사본 셈이 읽는 자원 줄(855-F B9-5) doc = (labor or {}).get("줄") or {} materials = [str(m.get("코드")) for m in doc.get("자재") or []] materials += [ # 고른 로직 자재(103-1) 품목 줄도 — 복사본 계산이 그 단가를 씀 @@ -181,9 +192,10 @@ def price_bundle(labor: dict[str, Any] | None, root: Path) -> dict[str, Any]: 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, None, over)) if wanted else {} + docs = formula_docs(labor) # 855-F B9-6 — 자원 · 표 줄 = 수식 문서가 잇는 것(로직 줄 없음) + wanted = list(docs) + [code for code in materials if code] + over = copy_rows([doc, *copies.values()]) # M02 값 사본(795-4) = 만든 때 줄 먼저 + bundle = prices.to_json(item_bundle.collect(docs, materials, over)) if wanted else {} if mine := own.bundle( [c for c in materials if own.is_own(c)], root ): # 개인 자재(148-3 · 사전조합 것도 175-2) — 원본 목록이 바뀌어도 사본 그대로 diff --git a/resources/tester/test_145_1_b09_sangeun.py b/resources/tester/test_145_1_b09_sangeun.py index 772417bbd..2caa85cdc 100644 --- a/resources/tester/test_145_1_b09_sangeun.py +++ b/resources/tester/test_145_1_b09_sangeun.py @@ -22,7 +22,6 @@ if str(ROOT) not in sys.path: from B09_Estimation import B09_Estimation_Router as router_mod # noqa: E402 from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 from M02_MasterTemplete import M02_Item_Prices as item_prices # noqa: E402 -from M02_MasterTemplete import M02_Labor_Doc as labor_doc # noqa: E402 STONE = "GF000219" # 돌쌓기 메쌓기(인력) — 석공 0.195 · 보통인부 0.156 / ㎡ NET = "GC000337" # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋 @@ -37,8 +36,15 @@ def _snapshot(folder: Path, rows, values=None, copies=None) -> Path: "줄": {"종류": "일위대가", "담은로직": rows}, **({"참조사본": copies} if copies else {}), } + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure( + item_prices.master()[1], [STONE, NET] + ) # 사본 = 수식 문서 + 자원 줄(855-F B9-6) files = { - "단가.json": item_prices.to_json(item_prices.collect([STONE, NET])), + "수식.json": item_prices.to_json({"그룹": "수식문서", "문서": docs}), + "단가.json": item_prices.to_json(item_bundle.collect(docs)), "일위대가.json": labor, "입력값.json": {k: {n: {"값": v} for n, v in d.items()} for k, d in (values or {}).items()}, } @@ -48,9 +54,16 @@ def _snapshot(folder: Path, rows, values=None, copies=None) -> Path: def _engine(folder: Path, code: str, given=None) -> dict: - """M02 엔진 기준(사본 단가 묶음 · 날 값 줄 · 끝수 뒤 기준).""" - whole = item_prices.load_prices(json.loads((folder / "단가.json").read_text(encoding="utf-8"))) - return labor_doc.run_line(whole, code, given or {}) + """M02 셈 기준(사본 수식 문서 셈 · 끝수 뒤 기준 · 855-F B9-6).""" + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = json.loads((folder / "수식.json").read_text(encoding="utf-8"))["문서"] + bundle = json.loads((folder / "단가.json").read_text(encoding="utf-8")) + from B09_Estimation import B09_Estimation_Doc_Run as dr + from M02_MasterTemplete import M02_Doc_Copy as dc + + got = dr.solve(item_bundle.load(bundle, docs), docs, code, given or {}) + return {"기준": dc.money(got.ans)} def test_단가산출_줄만_산근_블록_단가는_M02_엔진(tmp_path): diff --git a/resources/tester/test_145_2_b09_labor_calc.py b/resources/tester/test_145_2_b09_labor_calc.py index c9ec97f1a..06ecb9edd 100644 --- a/resources/tester/test_145_2_b09_labor_calc.py +++ b/resources/tester/test_145_2_b09_labor_calc.py @@ -260,7 +260,12 @@ def _snap(root, owner, key, lines, values, copies=None): for doc in (copies or {}).values(): codes += [one["로직"] for one in doc["담은로직"] if "로직" in one] write(snapshots.MANIFEST_NAME, {"원본": {**_item(key), "경로": ["기슭막이", key]}}) - write("단가.json", item_prices.to_json(item_prices.collect(codes))) + from M02_MasterTemplete import M02_Doc_Copy as dc + from M02_MasterTemplete import M02_Item_Bundle as item_bundle + + docs = dc.closure(item_prices.master()[1], codes) # 사본 = 수식 문서 + 자원 줄(855-F B9-6) + write("수식.json", item_prices.to_json({"그룹": "수식문서", "문서": docs})) + write("단가.json", item_prices.to_json(item_bundle.collect(docs))) doc = {"종류": "일위대가", "단위": "m", "담은로직": lines, "자재": []} write("일위대가.json", {"줄": doc, **({"참조사본": copies} if copies else {})}) write("입력값.json", values) diff --git a/resources/tester/test_719_2_sk_project.py b/resources/tester/test_719_2_sk_project.py index 058ce82cb..c32d51746 100644 --- a/resources/tester/test_719_2_sk_project.py +++ b/resources/tester/test_719_2_sk_project.py @@ -180,3 +180,24 @@ def test_SK_하위_단가산출_줄_산근(world, tmp_path): subs = [ln for ln in lines if ln["kind"] == "sangeun"] assert subs and all(ln["key"] in sg_rows for ln in subs) assert {ln["key"].split(":")[1] for ln in subs} == {"GF000160"} + + +def test_내_자료집_SK_수식_문서로(world, tmp_path): + """B09 품셈 블록(사본 SK) → [내 자료집] = 개인 층 SK · 고친 품 = 수식 문서 금액 줄(따로 · 옛 칸 + 덮개 없음) · 그 SK M02 셈 = B09 덮은 블록 금액(855-F B9-6).""" + from B09_Estimation import B09_Estimation_Daega_Personal as personal + + key = _mine(world) + root, folder = _lib(world, tmp_path, key) + daega, done, _ = _b09(root) + block = done[daega["libs"][folder]] + cover = {block["cover"]: {block["lines"][0]["cid"]: {"qty": 0.05}}} + made = personal.build(root, block["cover"], cover, "sub1임시 내 SK") + assert made["담음"]["품"] == 1 and "덮개" not in made["문서"] + with store.at(world["personal"]): + new = personal.write(made["문서"])["이름"] + saved = store.read("sangeun", new)["문서"] + assert saved["수식"]["따로"] and saved["수식"]["문서"]["금액"][0]["수량"] == "0.05" + _, covered, _ = _b09(root, cover) + live = _calc(world["personal"], new) + assert float(live["1단위"]["계"]) == pytest.approx(covered[daega["libs"][folder]]["sum"], abs=5) diff --git a/resources/tester/test_795_4_b09_copy.py b/resources/tester/test_795_4_b09_copy.py index 9b13b5888..97f3ac7f5 100644 --- a/resources/tester/test_795_4_b09_copy.py +++ b/resources/tester/test_795_4_b09_copy.py @@ -47,8 +47,13 @@ def _m01(monkeypatch, rows=(), drop=()): monkeypatch.setattr(m01, "loaded", lambda: (out, fake)) -def _amount(labor_rows, bundle): - got = item_prices.calc(labor_rows, bundle, {}, {}) +def _copy(labor_rows, me): + """사본 = 단가 묶음(자원 줄) + 수식 문서(855-F B9-6 · 로직 몫).""" + return source.price_bundle(labor_rows, me), {"문서": source.formula_docs(labor_rows)} + + +def _amount(labor_rows, made): + got = item_prices.calc(labor_rows, made[0], {}, {}, None, made[1]) return _json(got["반영합"]) @@ -58,28 +63,30 @@ def test_bundle_is_m02_copy_then_frozen(world, monkeypatch): doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) assert skc.held(doc) # 값 사본 = 수식 쪽 한 벌(855 2-D) rows = source.labor_doc_rows(doc) - was = _amount(rows, source.price_bundle(rows, me)) # 지금 M01 = 사본 만든 때 - bundle = source.price_bundle(rows, me) + was = _amount(rows, _copy(rows, me)) # 지금 M01 = 사본 만든 때 + bundle = _copy(rows, me) _m01(monkeypatch, [_changed(_live().logic(PCT)), _double(LB)]) assert _amount(rows, bundle) == was # 굳힌 묶음 = M01 안 읽음 - late = source.price_bundle(source.labor_doc_rows(doc), me) # 구조물 지정이 M01 바뀐 뒤 + late = _copy(source.labor_doc_rows(doc), me) # 구조물 지정이 M01 바뀐 뒤 assert _amount(rows, late) == was # M02 사본 = 만든 때 old = { k: v for k, v in doc.items() if k not in (skc.KEY, skc.FORM) } # ② 값 사본 없음 = 지금 M01 old_rows = source.labor_doc_rows(old) - assert _amount(old_rows, source.price_bundle(old_rows, me)) != was + assert _amount(old_rows, _copy(old_rows, me)) != was def test_deleted_m01_key_kept_in_copy(world, monkeypatch): - """① M01 에서 지워진 로직 키 = 사본 줄 그대로(`사본_남은줄.json`) · 같은 금액.""" + """① M01 에서 지워진 로직 키 = 사본 수식 문서 그대로(만든 때 부름 · 855-F B9-6) · 같은 금액.""" me = world["personal"] doc = _labor(me, [{"로직": PCT, "수량": {"손": 1}}]) rows = source.labor_doc_rows(doc) - was = _amount(rows, source.price_bundle(rows, me)) + was = _amount(rows, _copy(rows, me)) _m01(monkeypatch, drop=[PCT]) - late = source.price_bundle(rows, me) - assert [r["키"] for r in late[item_prices.COPY_FILE]["줄"]] == [PCT] + late = _copy(rows, me) + assert PCT in late[1]["문서"] and not any( + isinstance(v, dict) and v.get("그룹") == "로직" for v in late[0].values() + ) assert _amount(rows, late) == was diff --git a/resources/tester/test_802_4a_m02_doc.py b/resources/tester/test_802_4a_m02_doc.py index 73bc230ad..7a1dfa208 100644 --- a/resources/tester/test_802_4a_m02_doc.py +++ b/resources/tester/test_802_4a_m02_doc.py @@ -215,14 +215,15 @@ def test_line_rules_in_doc(code, rate, picks, marks): def test_b09_copy_has_doc_file(world, monkeypatch): - """⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판엔 안 듦 · M01 바뀌어도 그대로.""" + """⑦ B09 사본 = 단가 묶음 옆 `수식.json`(만든 때 부름) · 원본판에 듦(로직 몫 · 855-F B9-6) · + M01 바뀌어도 그대로.""" me = world["personal"] doc = _labor(me, [{"로직": PCT, "수량": {"손": 2}}]) rows = source.labor_doc_rows(doc) files = doc_b09.attach({"일위대가.json": rows, "단가.json": source.price_bundle(rows, me)}) made = files[doc_b09.FILE] assert made["그룹"] == "수식문서" and PCT in made["문서"] - assert doc_b09.FILE not in snap.source_files(files) + assert doc_b09.FILE in snap.source_files(files) assert doc_b09.attach(files) is files # 이미 있음 = 그대로 _fake(monkeypatch, [_changed(_live().logic(PCT))]) again = doc_b09.build(source.price_bundle(rows, me), rows) diff --git a/resources/tester/test_841_1_b09_m02_values.py b/resources/tester/test_841_1_b09_m02_values.py index c225b41c9..4d71c2c6e 100644 --- a/resources/tester/test_841_1_b09_m02_values.py +++ b/resources/tester/test_841_1_b09_m02_values.py @@ -13,13 +13,14 @@ import re import tempfile from pathlib import Path +from B09_Estimation import B09_Estimation_Doc_Run as dr from B09_Estimation import B09_Estimation_Router as router from B09_Estimation import B09_Estimation_Supply as supply from B09_Estimation.B09_Estimation_Labor_Source import _Loose, daega_inputs +from M02_MasterTemplete import M02_Item_Bundle as item_bundle from M02_MasterTemplete import M02_Item_Prices as item_prices from M02_MasterTemplete import M02_Item_Snapshot as snapshots from M02_MasterTemplete import M02_Item_Source as source -from M02_MasterTemplete import M02_Labor_Doc as labor_doc from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_MasterTemplete_Store as store from resources.tester.test_145_2_b09_labor_calc import _project, _snap @@ -50,8 +51,9 @@ def test_기계_대가_블록_M02_엔진_값(): sheets = router.compute_sheets(root, inputs, {}) block = next(b for b in sheets["daega"] if b["kind"] == "품셈") folder = next(snapshots.structures_dir(root).rglob("단가.json")).parent - whole = item_prices.load_prices(source.read_json(folder / "단가.json")) - want = labor_doc.run_line(whole, MACHINE, {})["기준"] + docs = dr.docs_of(folder) # 855-F B9-6 — 사본 = 자원 줄 + 수식 문서(견본 사본엔 없음 = 그 자리) + whole = item_bundle.load(source.read_json(folder / "단가.json"), docs) + want = item_prices.line(whole, docs, {"로직": MACHINE})["기준"] # M02 문서 셈 assert [block[p] for p in ("labor", "material", "expense", "sum")] == [ float(want[k]) for k in ("노무비", "재료비", "경비", "계") ] @@ -91,11 +93,14 @@ def test_기계_덮음_SK_사본까지(world): {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} ) bundle = source.price_bundle(rows, me) - got = item_prices.calc(rows, bundle, {}, {}) # 구조물 · 서고 사본 = 같은 굳히기 · 같은 셈 + docs = source.formula_docs(rows) # 사본 수식 문서(855-F B9-6) + got = item_prices.calc( + rows, bundle, {}, {}, None, {"문서": docs} + ) # 구조물 · 서고 사본 = 같은 셈 assert float(got["반영합"]["계"]) == now rid = refs.ref_id(ref) copies = rows["참조사본"] - whole = item_prices.load_prices(bundle) + whole = item_bundle.load(bundle, docs) expand = _Loose(whole, lambda r: copies.get(refs.ref_id(r))) b09 = supply.sk_money(copies[rid], whole, expand, rid) assert sum(b09.values()) == now diff --git a/resources/tester/test_855_b09_golden.py b/resources/tester/test_855_b09_golden.py index 2d1daf1b3..8acdbb7c5 100644 --- a/resources/tester/test_855_b09_golden.py +++ b/resources/tester/test_855_b09_golden.py @@ -4,7 +4,8 @@ 임시 storage(개인 층 7/42) · 견본을 시험이 지음 → 사본 만들기(지금 길) → 답 지문: - 층 견본 — 단가산출(SK): 바탕 로직 · 율 더한줄 · 형제(바탕 참조) · 「따로」 · 가져온 식 · 기계 · 재료 / 일위대가(SC): SK 참조 · 고정 · 로직 줄 + 자재 -- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle` +- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle` · + `Doc_B09.attach`(수식.json · 실제 사본 길과 같게 · 855-F B9-6) · B09 서고 사본 = `Bill_Library.import_copy`(SK 따로 · SK 가져온 식 · SC) - 손 줄 = 설계내역서 로직 줄(율 · 고른 재료 · 입력) + 운반공(거리 채움) - 답 = B09 `calc_user` · `daega_inputs` · 단가 수요 키(`_demand`) · 산근(`Sangeun.build` · 관급 있음 · 없음) @@ -37,6 +38,7 @@ from B09_Estimation import B09_Estimation_Router as b09 from B09_Estimation import B09_Estimation_Sangeun as sangeun from B09_Estimation import B09_Estimation_Store as b09_store from B09_Estimation.B09_Estimation_Labor_Source import daega_inputs +from M02_MasterTemplete import M02_Doc_B09 as doc_b09 from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path from M02_MasterTemplete import M02_Item_Snapshot as snapshots from M02_MasterTemplete import M02_Item_Source as source @@ -132,8 +134,9 @@ def _structure(world, keys: dict[str, str], root: Path) -> None: ) rows = source.labor_doc_rows(doc) files = { - source.LABOR_FILE: rows, - source.PRICE_FILE: source.price_bundle(rows, me), + **doc_b09.attach( + {source.LABOR_FILE: rows, source.PRICE_FILE: source.price_bundle(rows, me)} + ), snapshots.VALUES_FILE: {STONE: {"높이": {"값": 1.5}}}, snapshots.PICKS_FILE: {TWO_MATS: {"1": "MT003196", "2": "MT003173"}}, snapshots.MANIFEST_NAME: {"원본": {**_item("SS000901"), "경로": ["x"]}}, diff --git a/resources/tester/test_item_copy_complete.py b/resources/tester/test_item_copy_complete.py index 046bf5f8d..5a657b2f2 100644 --- a/resources/tester/test_item_copy_complete.py +++ b/resources/tester/test_item_copy_complete.py @@ -92,12 +92,16 @@ def _stuck(got: dict) -> list: def _auto_values(root: Path) -> dict[str, Any]: """담은 로직마다 자동값을 확인한 값으로 — 사용자가 다 채운 것과 같게.""" - labor = _read(root / "templates/structures" / FOLDER / "일위대가.json") + from M02_MasterTemplete import M02_Doc_Copy as dc + + folder = root / "templates/structures" / FOLDER + docs = _read(folder / "수식.json")["문서"] # 855-F B9-6 — 입력 = 사본 수식 문서 + lines = _read(folder / "일위대가.json")["줄"]["담은로직"] _, whole = m01.loaded() out: dict[str, Any] = {} - for row in labor["로직"]: - values = m01.mau.values(whole, whole.logic(row["키"])) - out[row["키"]] = {k: {"값": prices.to_json(v), "확인": True} for k, v in values.items()} + for key in (one["로직"] for one in lines if one.get("로직")): + values = dc.auto_of(docs[key], whole) # 옛 master_auto 와 같은 자동값(문서) + out[key] = {k: {"값": prices.to_json(v), "확인": True} for k, v in values.items()} return out @@ -121,7 +125,8 @@ def test_지정하면_새_파일까지_복사(world): rows = {k: len(v.get("줄") or v.get("표")) for k, v in price.items()} assert rows["인력.json"] >= 2 and rows["재료_자재품목.json"] > 0 and "_빠진" not in price keys = {row["키"] for data in price.values() for row in data.get("줄") or data.get("표")} - assert {"GF000176", "GC000088", "GF000113", "GC000267", LABOR_PRICE} <= keys + docs = _read(folder / "수식.json")["문서"] # 로직 = 사본 수식 문서(855-F B9-6) + assert {"GF000176", "GC000088", "GF000113", "GC000267"} <= set(docs) and LABOR_PRICE in keys manifest = _read(folder / "manifest.json") assert manifest["가져온날"] and len(manifest["원본판"]) == 16 assert copies.list_items(root) == [ diff --git a/resources/tester/test_m02_item_labor.py b/resources/tester/test_m02_item_labor.py index 03049d04e..9d4eab6ef 100644 --- a/resources/tester/test_m02_item_labor.py +++ b/resources/tester/test_m02_item_labor.py @@ -137,12 +137,13 @@ def test_스냅샷_일위대가는_문서_알약_자재_단가(world): folder = root / "templates/structures" / FOLDER labor = _read(folder / "일위대가.json") assert labor["줄"] == world["doc"] - assert [row["키"] for row in labor["로직"]] == list(LOGICS) and labor["빠진로직"] == [] + assert labor["빠진로직"] == [] and "로직" not in labor # 로직 줄 사본 없음(855-F B9-6) + assert set(LOGICS) <= set(_read(folder / "수식.json")["문서"]) # 셈 = 사본 수식 문서 assert {p["키"] for p in labor["알약"]} == set(world["pills"]) keys = { row["키"] for data in _read(folder / "단가.json").values() for row in data.get("줄", []) } - assert MATERIAL in keys and set(LOGICS) <= keys + assert MATERIAL in keys and not set(LOGICS) & keys # 단가 묶음 = 자원 · 표 줄만 def test_입력값_첫_값은_문서_입력값(world): diff --git a/resources/tester/test_structures_summary_snapshot.py b/resources/tester/test_structures_summary_snapshot.py index bae53e40a..ed8b3c2c4 100644 --- a/resources/tester/test_structures_summary_snapshot.py +++ b/resources/tester/test_structures_summary_snapshot.py @@ -150,9 +150,11 @@ def test_지정하면_폴더가_생기고_내용이_원본과_같음(world): # 일위대가 UA 줄 + 담은 로직 줄(M01 시스템) labor = json.loads((_items(root) / "pipe@40.0/일위대가.json").read_text(encoding="utf-8")) assert labor["줄"]["키"] == "UA000036" - assert [row["키"] for row in labor["로직"]] + labor["빠진로직"] == [ + wanted = [ entry["로직"] for entry in labor["줄"]["담은로직"] - ] + ] # 로직 = 사본 수식 문서(855-F B9-6) + docs = json.loads((_items(root) / "pipe@40.0/수식.json").read_text(encoding="utf-8"))["문서"] + assert "로직" not in labor and set(wanted) - set(labor["빠진로직"]) <= set(docs) def test_원본을_바꿔도_프로젝트_값은_그대로(world):