Merge remote-tracking branch 'origin/sub_laptop_1' into sub_laptop_7
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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]:
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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] = {}
|
||||
|
||||
@@ -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]:
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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
|
||||
@@ -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("알약")
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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` 몫) — 원본 일위대가 · 굳힌 참조사본의 수식 사본 부름(만든 때
|
||||
것 · 키 겹침 = 원본 문서 것) 먼저 · 그 밖 = 지금 M01 문서(`M02_Doc_Copy.closure` · 값 사본 로직 줄
|
||||
안 읽음 · 855-F B9-6)."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Item_Prices as prices
|
||||
|
||||
doc = (labor or {}).get("줄") or {}
|
||||
copies = (labor or {}).get("참조사본") or {}
|
||||
have: dict[str, dict] = {}
|
||||
for one in [*copies.values(), doc]:
|
||||
if dc.has(one):
|
||||
have.update(one[dc.KEY].get("부름") or {})
|
||||
return dc.closure(prices.master()[1], 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) — 원본 목록이 바뀌어도 사본 그대로
|
||||
|
||||
@@ -49,7 +49,8 @@ def stamp(doc: dict) -> dict | None:
|
||||
links += [
|
||||
str(m["코드"]) for m in doc.get("자재") or [] if isinstance(m, dict) and m.get("코드")
|
||||
]
|
||||
return skc.snap(list(dict.fromkeys(keys)), list(dict.fromkeys(links)))
|
||||
got = skc.snap(list(dict.fromkeys(keys)), list(dict.fromkeys(links)))
|
||||
return got and skc._plain(got) # 로직 줄 안 담음(855-F B9-6 · 셈 = 수식 부름)
|
||||
|
||||
|
||||
def _file(doc: dict) -> dict:
|
||||
|
||||
@@ -398,7 +398,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
|
||||
|
||||
|
||||
def summary(
|
||||
folder: Path, kind: str, key: str, expand: Expand | None = None, files: UseFiles | None = None
|
||||
folder: Path, kind: str, key: str, expand: Expand | None = None, files: list | None = None
|
||||
) -> dict[str, Any]:
|
||||
"""층 목록 한 줄에 붙일 것 — `{제목, 단위, 구분, 상세구분, 연결}`(51-12) · `expand` 면
|
||||
1 단위 기준 계(`기준금액` · 51-4)."""
|
||||
@@ -422,14 +422,16 @@ def summary(
|
||||
top, (layer, owner) = doc.get("바탕") or {}, where(folder)
|
||||
logic = top.get("로직")
|
||||
out["바탕"] = logic or (top.get("참조") or {}).get("키")
|
||||
if logic and expand is not None:
|
||||
try:
|
||||
out["바탕"] = f"{logic} {expand.whole.logic(logic).get('이름') or ''}".strip()
|
||||
except Exception: # noqa: BLE001 — 없는 로직 = 키만(셈 때 까닭)
|
||||
pass
|
||||
if logic and expand is not None: # 이름 = M01 수식 문서(로직 줄 안 읽음 · 855 L2 ⓑ)
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
|
||||
name = (m01doc.docs().get(str(logic)) or {}).get("이름") or ""
|
||||
out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭)
|
||||
out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄"))
|
||||
# SK 마다 모든 층 훑음(users) — 파일 읽기는 판 기억(`_ids_of`)이라 처음 한 번만 무거움
|
||||
out["쓰는곳수"] = len(users({"층": layer, "주인": owner, "키": key}, files))
|
||||
# SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
out["쓰는곳수"] = len(uses.users({"층": layer, "주인": owner, "키": key}, files))
|
||||
return out
|
||||
|
||||
|
||||
@@ -439,66 +441,20 @@ def summaries(folder: Path, rows: list[dict[str, Any]]) -> None:
|
||||
from M02_MasterTemplete.M02_Labor_Expand import Expand
|
||||
|
||||
expand = Expand(m01.loaded()[1])
|
||||
files = use_files() if any(row["종류"] == "sangeun" for row in rows) else None
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
files = uses.files() if any(row["종류"] == "sangeun" for row in rows) else None
|
||||
for row in rows:
|
||||
if row["종류"] in layers.LIBRARY_KINDS:
|
||||
row.update(summary(folder, row["종류"], row["이름"], expand, files))
|
||||
|
||||
|
||||
# ── 쓰는 곳 · 지우기 ──────────────────────────────────────────────────
|
||||
UseFiles = list[tuple[str, str, Path]]
|
||||
|
||||
|
||||
def use_files() -> UseFiles:
|
||||
"""쓰는 곳을 찾을 파일 — (무엇, 어디, 파일) · 목록 한 번에 한 번 찾음(818-1)."""
|
||||
# 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」
|
||||
kinds = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
|
||||
return [(what, at, path) for kind, what in kinds for at, path in layers.layer_files(kind)]
|
||||
|
||||
|
||||
def users(ref: Ref, files: UseFiles | None = None) -> list[str]:
|
||||
"""`ref` 를 담은 일위대가 · 사전조합 · 단가산출(바탕 · 더한줄) — 「어디 이름」 목록(모든 층 훑음 ·
|
||||
프로젝트 뺌)."""
|
||||
rid, out = ref_id(ref), []
|
||||
for what, at, path in use_files() if files is None else files:
|
||||
got = _ids_of(path)
|
||||
if got and rid in got[1]:
|
||||
out.append(f"{what} {at} 「{got[0]}」")
|
||||
return out
|
||||
|
||||
|
||||
_IDS: dict[Path, tuple[tuple[int, int], tuple[str, frozenset[str]]]] = {}
|
||||
|
||||
|
||||
def _ids_of(path: Path) -> tuple[str, frozenset[str]] | None:
|
||||
"""파일 하나의 (이름, 참조 이름표들) — 판(고친 때 · 크기)이 같으면 기억한 것(818-1 · 로직 사본으로
|
||||
SK 파일이 MB 단위라 목록 줄마다 모든 층을 다시 읽으면 분 단위)."""
|
||||
try:
|
||||
st = path.stat()
|
||||
stamp = (st.st_mtime_ns, st.st_size)
|
||||
if (hit := _IDS.get(path)) and hit[0] == stamp:
|
||||
return hit[1]
|
||||
doc = json.loads(path.read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
name = (
|
||||
(doc.get("일위대가번") or doc.get("이름") or path.stem)
|
||||
if isinstance(doc, dict)
|
||||
else path.stem
|
||||
)
|
||||
got = (str(name), frozenset(ref_id(one) for one in refs_in(doc)))
|
||||
_IDS[path] = (stamp, got)
|
||||
return got
|
||||
|
||||
|
||||
def refuse_used(folder: Path, kind: str, key: str) -> None:
|
||||
"""쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
|
||||
if kind not in PREFIX:
|
||||
return
|
||||
layer, owner = where(folder)
|
||||
found = users({"층": layer, "주인": owner, "키": key})
|
||||
if found:
|
||||
raise _bad(f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found), 409)
|
||||
"""쓰는 곳이 있으면 409 — 쓰는 곳 색인 한 벌(`M02_Library_Uses` · 858 5-5)."""
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
uses.refuse_used(folder, kind, key)
|
||||
|
||||
|
||||
# ── 층 사이 복사 ──────────────────────────────────────────────────────
|
||||
|
||||
@@ -175,7 +175,9 @@ def own_materials(
|
||||
return {"줄": []}
|
||||
folder = _root(session, layer, owner)
|
||||
rows = own.rows(folder)
|
||||
used = own.usage(folder, [str(r.get("키")) for r in rows])
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
|
||||
used = library_uses.materials(folder, [str(r.get("키")) for r in rows])
|
||||
return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]}
|
||||
|
||||
|
||||
|
||||
@@ -6,9 +6,9 @@
|
||||
요약 서고 줄 `M02_Labor_Ref.summary`(쓰는곳수 뺌) — 자국 · 바탕 · 기댐이 모두 같을 때만 씀
|
||||
바탕 셈 코드 내용 · M01 폴더 · 층 곁 파일(내 기계 등 — 항목 폴더 · manifest 뺌) 자국 지문
|
||||
기댐 셈 때 읽은 참조 파일(SC · SK) 자국(`refs.SEEN`)
|
||||
쓰는곳수 = 요청마다 쓰는 곳 파일을 한 번 훑어 거꾸로 셈(`refs._ids_of` 기억 · 파일당 stat 한 번).
|
||||
쓰는곳수 = 요청마다 쓰는 곳 색인을 한 번 훑어 거꾸로 셈(`M02_Library_Uses.counts` · 파일당 stat 한 번).
|
||||
자리 = 프로세스 메모리 + storage `_derived/m02_layer_index/`(파생 저장본 · 층마다 한 파일 ·
|
||||
참조 이름표 기억 `ids.json`) — 없거나 깨지면 다시 지음 · 지워도 됨 · 다른 PC · 옛 코드는 안 읽음.
|
||||
참조 이름표 기억 `ids.json` 은 `M02_Library_Uses` 몫) — 없거나 깨지면 다시 지음 · 지워도 됨.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -28,11 +28,9 @@ from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
KIND = "m02_layer_index"
|
||||
SHAPE = 1 # 기록 꼴이 바뀌면 올림(옛 기록 = 다시 셈)
|
||||
IDS = "ids"
|
||||
CODE_DIRS = ("M02_MasterTemplete", "M01_MasterData", "resources/master_data/scripts", "common_util")
|
||||
_LOCK = threading.RLock()
|
||||
_MEM: dict[str, dict[str, Any]] = {} # 층 열쇠 → {항목: 기록}
|
||||
_IDS_LOADED: list[bool] = []
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
@@ -175,47 +173,9 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None:
|
||||
_save(key, recs)
|
||||
sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row]
|
||||
if sk:
|
||||
uses, (layer, owner) = _uses(), refs.where(folder)
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
|
||||
uses, (layer, owner) = library_uses.counts(), refs.where(folder)
|
||||
for row in sk:
|
||||
rid = refs.ref_id({"층": layer, "주인": owner, "키": row["이름"]})
|
||||
row["쓰는곳수"] = uses.get(rid, 0)
|
||||
|
||||
|
||||
# ── 쓰는 곳 수 ────────────────────────────────────────────────────────
|
||||
def _uses() -> dict[str, int]:
|
||||
"""참조 이름표 → 담은 파일 수(`refs.users` 개수와 같음) — 쓰는 곳 파일 한 번 훑음."""
|
||||
_load_ids()
|
||||
before = {path: hit[0] for path, hit in refs._IDS.items()}
|
||||
files = [path for _what, _at, path in refs.use_files()]
|
||||
count: dict[str, int] = {}
|
||||
for path in files:
|
||||
got = refs._ids_of(path)
|
||||
for rid in got[1] if got else ():
|
||||
count[rid] = count.get(rid, 0) + 1
|
||||
if any(before.get(path) != refs._IDS[path][0] for path in files if path in refs._IDS):
|
||||
_save_ids()
|
||||
return count
|
||||
|
||||
|
||||
def _load_ids() -> None:
|
||||
"""참조 이름표 기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 자국은 `_ids_of` 가 다시 봄."""
|
||||
if _IDS_LOADED:
|
||||
return
|
||||
_IDS_LOADED.append(True)
|
||||
got = read_derived(layers.storage_root(), KIND, IDS)
|
||||
for text, one in ((got or {}).get("value") or {}).items():
|
||||
try:
|
||||
mtime, size, name, ids = one
|
||||
refs._IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids))))
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
|
||||
|
||||
def _save_ids() -> None:
|
||||
"""지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌."""
|
||||
got = read_derived(layers.storage_root(), KIND, IDS)
|
||||
value = dict((got or {}).get("value") or {})
|
||||
for path, ((mtime, size), (name, ids)) in list(refs._IDS.items()):
|
||||
value[str(path)] = [mtime, size, name, sorted(ids)]
|
||||
value = {text: one for text, one in value.items() if Path(text).is_file()}
|
||||
_save(IDS, value)
|
||||
|
||||
@@ -25,12 +25,11 @@ from typing import Any
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Layer_Access as access
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Tree as tree
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
GONE = "_합친것"
|
||||
USER_KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
|
||||
_ADD = re.compile(r"^add:#(\d+)(.*)$")
|
||||
_PATCH = ("덮개", "고름", "자재표시")
|
||||
|
||||
@@ -66,42 +65,44 @@ def _columns(folder: Path, memo: dict[Path, dict[str, str]]) -> dict[str, str]:
|
||||
|
||||
|
||||
def users(session: dict[str, Any] | None, kind: str, gone: list[str]) -> list[dict[str, Any]]:
|
||||
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌)."""
|
||||
"""지금 층(`store.at`) 지울 문서를 쓰는 줄 — 모든 층(프로젝트 뺌 · 지우는 것끼리 뺌) ·
|
||||
쓰는 파일 = 쓰는 곳 색인(`M02_Library_Uses.index`)에 걸린 것만 열어 줄 자리를 셈."""
|
||||
mine = refs.here()
|
||||
rids = {refs.ref_id({"층": mine[0], "주인": mine[1], "키": k}): k for k in gone}
|
||||
skip = {(store.root() / kind / f"{k}.json").resolve() for k in gone}
|
||||
found = uses.index()
|
||||
hit_files = {path for rid in rids for path, _k, _l in found.get(rid, [])}
|
||||
rows, memo = [], {}
|
||||
for ukind, what in USER_KINDS:
|
||||
for where, path in layers.layer_files(ukind):
|
||||
if path.resolve() in skip:
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(path.read_bytes())
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
hits = _hits(doc, rids) if isinstance(doc, dict) else []
|
||||
if not hits:
|
||||
continue
|
||||
at = refs.where(path.parent.parent)
|
||||
ok = can_write(session, at)
|
||||
name = doc.get("일위대가번") or doc.get("이름") or path.stem
|
||||
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
|
||||
name = f"{title} · {name}"
|
||||
for line, key in hits:
|
||||
rows.append(
|
||||
{
|
||||
"층": at[0],
|
||||
"주인": at[1],
|
||||
"어디": where,
|
||||
"종류": what,
|
||||
"문서종류": ukind,
|
||||
"문서": path.stem,
|
||||
"이름": name,
|
||||
"키": key,
|
||||
"줄": line,
|
||||
"쓰기": ok,
|
||||
}
|
||||
)
|
||||
for ukind, what, where, path in uses.files():
|
||||
if path not in hit_files or path.resolve() in skip:
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(path.read_bytes())
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
hits = _hits(doc, rids) if isinstance(doc, dict) else []
|
||||
if not hits:
|
||||
continue
|
||||
at = refs.where(path.parent.parent)
|
||||
ok = can_write(session, at)
|
||||
name = doc.get("일위대가번") or doc.get("이름") or path.stem
|
||||
if ukind == "labor" and (title := _columns(path.parent.parent, memo).get(path.stem)):
|
||||
name = f"{title} · {name}"
|
||||
for line, key in hits:
|
||||
rows.append(
|
||||
{
|
||||
"층": at[0],
|
||||
"주인": at[1],
|
||||
"어디": where,
|
||||
"종류": what,
|
||||
"문서종류": ukind,
|
||||
"문서": path.stem,
|
||||
"이름": name,
|
||||
"키": key,
|
||||
"줄": line,
|
||||
"쓰기": ok,
|
||||
}
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
|
||||
@@ -36,16 +36,15 @@ from M02_MasterTemplete import M02_Layer_Access as access
|
||||
from M02_MasterTemplete import M02_Library_Delete as deleting
|
||||
from M02_MasterTemplete import M02_Library_Flat as flat
|
||||
from M02_MasterTemplete import M02_Library_Same as same
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _root
|
||||
|
||||
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Library Same"])
|
||||
|
||||
Kind = Literal["precombo", "sangeun"]
|
||||
GONE = deleting.GONE
|
||||
USER_KINDS = deleting.USER_KINDS
|
||||
_ORDER = {"system": 0, "company": 1, "personal": 2}
|
||||
|
||||
|
||||
@@ -89,21 +88,6 @@ def _docs(at: refs.Here, kind: str) -> list[tuple[str, dict[str, Any]]]:
|
||||
|
||||
|
||||
# ── 쓰는 곳 ───────────────────────────────────────────────────────────
|
||||
def _user_index() -> dict[str, list[tuple[Path, str, str]]]:
|
||||
"""모든 층(프로젝트 뺌) 훑기 한 번 — {ref_id: [(파일, 종류, 「어디 이름」)]}."""
|
||||
out: dict[str, list[tuple[Path, str, str]]] = {}
|
||||
for kind, what in USER_KINDS:
|
||||
for where, path in layers.layer_files(kind):
|
||||
try:
|
||||
doc = json.loads(path.read_bytes())
|
||||
except (OSError, ValueError):
|
||||
continue
|
||||
name = doc.get("일위대가번") or doc.get("이름") or path.stem
|
||||
for rid in {refs.ref_id(one) for one in refs.refs_in(doc)}:
|
||||
out.setdefault(rid, []).append((path, kind, f"{what} {where} 「{name}」"))
|
||||
return out
|
||||
|
||||
|
||||
def _can_write(session: Session, at: refs.Here) -> bool:
|
||||
return access.can_write(session, at)
|
||||
|
||||
@@ -177,7 +161,7 @@ def _gone_rows(folder: Path, kind: str) -> list[dict[str, Any]]:
|
||||
def find(folder: Path, kind: str) -> dict[str, Any]:
|
||||
"""이 층 + 위 층 같은 지문 묶음 — 이 층 문서가 든 묶음 · 둘 이상만."""
|
||||
mine = refs.where(folder)
|
||||
index = _user_index()
|
||||
index = uses.index()
|
||||
groups: dict[str, list[tuple[refs.Here, str, dict[str, Any]]]] = {}
|
||||
marks = same.Same() # 한 요청 안 참조 지문 메모
|
||||
for at in [mine, *same.above(mine)]:
|
||||
@@ -235,7 +219,7 @@ def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[s
|
||||
rids = {refs.ref_id(_ref(mine, k)): k for k in gone}
|
||||
by_file: dict[Path, tuple[str, set[str]]] = {}
|
||||
labels: dict[Path, str] = {}
|
||||
index = _user_index()
|
||||
index = uses.index()
|
||||
for rid in rids:
|
||||
for path, ukind, label in index.get(rid, []):
|
||||
by_file.setdefault(path, (ukind, set()))[1].add(rid)
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
"""M02 서고 쓰는 곳 색인 한 벌(858 5-5 · 설계 `설계_858_서고한벌.md` 부품 ⑦) — 「이 문서를 누가 쓰나」.
|
||||
|
||||
참조 찾기(단가산출 · 일위대가 · 구조물 조합 · 사본 블록 안 산근 — `M02_Labor_Ref.refs_in`):
|
||||
쓰는 파일 = 모든 층(마스터 · 회사 · 개인 · 프로젝트 뺌) `labor` · `precombo` · `sangeun` 파일(`files`) ·
|
||||
파일마다 (이름, 참조 이름표들) 을 판(고친 때 · 크기)으로 기억(`ids_of` · 818-1) — 같은 판이면 안 엶 ·
|
||||
기억은 파생 저장본 `_derived/m02_layer_index/ids.json` 에도 둠(서버를 다시 띄워도 처음부터 안 읽음 ·
|
||||
지워도 다시 셈) · `users` = 「무엇 어디 「이름」」 목록 · `index` = {이름표: [(파일, 종류, 글)]} ·
|
||||
`counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409.
|
||||
자원 키 찾기(층 안):
|
||||
`machines` = 내 기계 키 → 이 층 단가산출(사본 · 수식 사본 단가 줄에 그 키) ·
|
||||
`materials` = 내 재료 키 → 이 층 모든 문서(글에 그 키 · `_` `.` 폴더 · 내 재료 파일 뺌).
|
||||
지우기 · 합치기는 `store.batch` 한 잠금 안에서 이 색인을 씀(`M02_Library_Delete` · `M02_Library_Same_Router`).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from common_util.common_util_derived_store import derived_dir, read_derived
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
|
||||
#: 쓰는 쪽 종류 — 「일위대가」 = 사전조합 새 이름(내역 14 확정 1) · 구조물 조합 일위대가 = 「구조물 조합」
|
||||
KINDS = (("labor", "구조물 조합"), ("precombo", "일위대가"), ("sangeun", "단가산출"))
|
||||
DERIVED, IDS = "m02_layer_index", "ids" # 파생 저장본 자리(826-1 층 목록 색인과 같은 폴더)
|
||||
|
||||
UseFiles = list[tuple[str, str, str, Path]] # (종류, 무엇, 어디, 파일)
|
||||
Ids = tuple[str, frozenset[str]]
|
||||
|
||||
_IDS: dict[Path, tuple[tuple[int, int], Ids]] = {}
|
||||
_LOADED: list[bool] = []
|
||||
|
||||
|
||||
# ── 참조 ──────────────────────────────────────────────────────────────
|
||||
def files() -> UseFiles:
|
||||
"""쓰는 곳을 찾을 파일 — 종류 차례 · 층 차례(마스터 → 회사 → 개인)."""
|
||||
return [(kind, what, at, path) for kind, what in KINDS for at, path in layers.layer_files(kind)]
|
||||
|
||||
|
||||
def ids_of(path: Path) -> Ids | None:
|
||||
"""파일 하나의 (이름, 참조 이름표들) — 판이 같으면 기억한 것(로직 사본으로 SK 파일이 커서)."""
|
||||
_load()
|
||||
try:
|
||||
st = path.stat()
|
||||
stamp = (st.st_mtime_ns, st.st_size)
|
||||
if (hit := _IDS.get(path)) and hit[0] == stamp:
|
||||
return hit[1]
|
||||
doc = json.loads(path.read_bytes())
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
name = (
|
||||
(doc.get("일위대가번") or doc.get("이름") or path.stem) if isinstance(doc, dict) else None
|
||||
)
|
||||
got = (str(name or path.stem), frozenset(refs.ref_id(one) for one in refs.refs_in(doc)))
|
||||
_IDS[path] = (stamp, got)
|
||||
return got
|
||||
|
||||
|
||||
def _scan(found: UseFiles | None) -> list[tuple[str, str, str, Path, Ids]]:
|
||||
"""쓰는 파일마다 (종류, 무엇, 어디, 파일, 이름표) — 기억이 바뀌었으면 파생 저장본에 덧씀."""
|
||||
found = files() if found is None else found
|
||||
_load()
|
||||
before = {path: hit[0] for path, hit in _IDS.items()}
|
||||
out = [(*one, got) for one in found if (got := ids_of(one[3]))]
|
||||
if any(before.get(one[3]) != _IDS[one[3]][0] for one in found if one[3] in _IDS):
|
||||
_save()
|
||||
return out
|
||||
|
||||
|
||||
def users(ref: refs.Ref, found: UseFiles | None = None) -> list[str]:
|
||||
"""`ref` 를 담은 구조물 조합 · 일위대가 · 단가산출 — 「무엇 어디 「이름」」(프로젝트 뺌)."""
|
||||
rid = refs.ref_id(ref)
|
||||
return [f"{what} {at} 「{ids[0]}」" for _k, what, at, _p, ids in _scan(found) if rid in ids[1]]
|
||||
|
||||
|
||||
def index(found: UseFiles | None = None) -> dict[str, list[tuple[Path, str, str]]]:
|
||||
"""한 번 훑어 {이름표: [(파일, 종류, 「무엇 어디 「이름」」)]}."""
|
||||
out: dict[str, list[tuple[Path, str, str]]] = {}
|
||||
for kind, what, at, path, (name, rids) in _scan(found):
|
||||
for rid in rids:
|
||||
out.setdefault(rid, []).append((path, kind, f"{what} {at} 「{name}」"))
|
||||
return out
|
||||
|
||||
|
||||
def counts(found: UseFiles | None = None) -> dict[str, int]:
|
||||
"""{이름표: 담은 파일 수} — `users` 개수와 같음."""
|
||||
return {rid: len(hits) for rid, hits in index(found).items()}
|
||||
|
||||
|
||||
def refuse_used(folder: Path, kind: str, key: str) -> None:
|
||||
"""쓰는 곳이 있으면 409 + 이름(서고 종류만)."""
|
||||
if kind not in refs.PREFIX:
|
||||
return
|
||||
layer, owner = refs.where(folder)
|
||||
if found := users({"층": layer, "주인": owner, "키": key}):
|
||||
raise store.StoreError(409, f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found))
|
||||
|
||||
|
||||
def _load() -> None:
|
||||
"""기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 판은 `ids_of` 가 다시 봄."""
|
||||
if _LOADED:
|
||||
return
|
||||
_LOADED.append(True)
|
||||
got = read_derived(layers.storage_root(), DERIVED, IDS)
|
||||
for text, one in ((got or {}).get("value") or {}).items():
|
||||
try:
|
||||
mtime, size, name, ids = one
|
||||
_IDS.setdefault(Path(text), ((int(mtime), int(size)), (str(name), frozenset(ids))))
|
||||
except (TypeError, ValueError):
|
||||
continue
|
||||
|
||||
|
||||
def _save() -> None:
|
||||
"""지금 기억을 디스크 것에 덧씀(다른 서버 몫 유지) · 없어진 파일 뺌 · 못 써도 다음에 다시 셈."""
|
||||
got = read_derived(layers.storage_root(), DERIVED, IDS)
|
||||
value = dict((got or {}).get("value") or {})
|
||||
for path, ((mtime, size), (name, ids)) in list(_IDS.items()):
|
||||
value[str(path)] = [mtime, size, name, sorted(ids)]
|
||||
value = {text: one for text, one in value.items() if Path(text).is_file()}
|
||||
try:
|
||||
path = derived_dir(layers.storage_root(), DERIVED) / f"{IDS}.json"
|
||||
atomic_write_json(path, {"key": IDS, "value": value})
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
# ── 자원 키(층 안) ─────────────────────────────────────────────────────
|
||||
def machines(folder: Path | None = None) -> dict[str, list[dict[str, Any]]]:
|
||||
"""{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것."""
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
|
||||
out: dict[str, list[dict[str, Any]]] = {}
|
||||
for path in sorted(Path(folder or store.root()).joinpath(sd.KIND).glob("SK-*.json")):
|
||||
raw = path.read_bytes()
|
||||
if mym.PREFIX.encode() not in raw:
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(raw)
|
||||
except ValueError:
|
||||
continue
|
||||
keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번
|
||||
str(row["키"])
|
||||
for part in (skc.KEY, "수식")
|
||||
for row in (doc.get(part) or {}).get("단가") or []
|
||||
if mym.mine(row.get("키"))
|
||||
}
|
||||
for key in sorted(keys):
|
||||
out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")})
|
||||
return out
|
||||
|
||||
|
||||
def materials(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]:
|
||||
"""{내 재료 키: [{종류, 키, 이름}]} — 그 층 문서 글에 키가 든 것(파일은 한 번씩 읽음)."""
|
||||
from M02_MasterTemplete import M02_Material_Own as own
|
||||
|
||||
folder = Path(folder)
|
||||
out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys}
|
||||
for path in sorted(folder.rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌
|
||||
if path.name == own.FILE or _aside(path, folder):
|
||||
continue
|
||||
try:
|
||||
text = path.read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
continue
|
||||
if not (hit := [k for k in keys if k in text]):
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(text)
|
||||
except ValueError:
|
||||
continue
|
||||
name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem
|
||||
for k in hit:
|
||||
out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name})
|
||||
return out
|
||||
|
||||
|
||||
def _aside(path: Path, folder: Path) -> bool:
|
||||
"""밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님."""
|
||||
return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])
|
||||
@@ -135,36 +135,11 @@ def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]
|
||||
return got
|
||||
|
||||
|
||||
def _aside(path: Path, folder: str | Path) -> bool:
|
||||
"""밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님."""
|
||||
return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1])
|
||||
|
||||
|
||||
def usage(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]:
|
||||
"""그 층에서 키마다 쓰는 문서(단가산출 · 일위대가 …) {키: [{종류, 키, 이름}]} — 파일은 한 번씩 읽음."""
|
||||
out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys}
|
||||
for path in sorted(Path(folder).rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌
|
||||
if path.name == FILE or _aside(path, folder):
|
||||
continue
|
||||
try:
|
||||
text = path.read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
continue
|
||||
hit = [k for k in keys if k in text]
|
||||
if not hit:
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(text)
|
||||
except ValueError:
|
||||
continue
|
||||
name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem
|
||||
for k in hit:
|
||||
out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name})
|
||||
return out
|
||||
|
||||
|
||||
def uses(folder: str | Path, key: str) -> list[dict[str, Any]]:
|
||||
return usage(folder, [key])[key]
|
||||
"""쓰는 문서 — 쓰는 곳 색인 한 벌(`M02_Library_Uses.materials` · 858 5-5)."""
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
|
||||
return library_uses.materials(folder, [key])[key]
|
||||
|
||||
|
||||
def remove(folder: str | Path, key: str) -> None:
|
||||
|
||||
@@ -259,13 +259,26 @@ def hourly(row: dict, index: Any) -> dict[str, Any]:
|
||||
key = logic_key(row)
|
||||
if key is None:
|
||||
return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"}
|
||||
logic = index.logic(key)
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3 · 855 2-B2)
|
||||
|
||||
got = mh.hour(row, logic, index)
|
||||
got = mh.hour(row, _head(key), index)
|
||||
return {"ok": got["ok"], **head, **got}
|
||||
|
||||
|
||||
def _head(key: str) -> dict[str, Any]:
|
||||
"""식 머리 {키, 입력} — M01 수식 문서에서(로직 줄 안 읽음 · 855 L2 ⓑ) · 입력 = 고르기 · 입력 변수
|
||||
(옛 로직 줄 「입력」 과 1,521 문서 같음) · 문서 없음 = 빈 입력(`hour` 가 「식 문서 없음」)."""
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
|
||||
doc = m01doc.docs().get(key) or {}
|
||||
opens = [
|
||||
{"이름": v.get("이름")}
|
||||
for v in doc.get("변수") or []
|
||||
if isinstance(v, dict) and (v.get("연결") or {}).get("갈래") in ("선택", "입력")
|
||||
]
|
||||
return {"키": key, "입력": opens}
|
||||
|
||||
|
||||
# ── 검사 ──────────────────────────────────────────────────────────────
|
||||
def _num(value: Any, name: str) -> float | None:
|
||||
if value in (None, ""):
|
||||
@@ -479,36 +492,18 @@ def delete(key: str) -> dict[str, Any]:
|
||||
"""지움 — 이미 만든 단가산출은 사본의 마지막 값 그대로(「지운키」)."""
|
||||
_user()
|
||||
_old(key)
|
||||
used = uses().get(key, [])
|
||||
used = _uses().get(key, [])
|
||||
with _LOCK:
|
||||
_old(key)
|
||||
(_dir() / f"{key}.json").unlink(missing_ok=True)
|
||||
return {"지움": key, "쓰는곳": used}
|
||||
|
||||
|
||||
def uses() -> dict[str, list[dict]]:
|
||||
"""{내 기계 키: [{키, 이름}]} — 이 층 단가산출 가운데 사본(옛 칸 · 수식) 단가 줄에 그 키를 가진 것."""
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
def _uses() -> dict[str, list[dict]]:
|
||||
"""{내 기계 키: [{키, 이름}]} — 쓰는 곳 색인 한 벌(`M02_Library_Uses.machines` · 858 5-5)."""
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
|
||||
out: dict[str, list[dict]] = {}
|
||||
for path in sorted((store.root() / sd.KIND).glob("SK-*.json")):
|
||||
raw = path.read_bytes()
|
||||
if PREFIX.encode() not in raw:
|
||||
continue
|
||||
try:
|
||||
doc = json.loads(raw)
|
||||
except ValueError:
|
||||
continue
|
||||
keys = { # 옛 칸 사본 · 수식 길 사본(827-1) — 한 SK 한 번
|
||||
str(row["키"])
|
||||
for part in (skc.KEY, "수식")
|
||||
for row in (doc.get(part) or {}).get("단가") or []
|
||||
if mine(row.get("키"))
|
||||
}
|
||||
for key in sorted(keys):
|
||||
out.setdefault(key, []).append({"키": doc.get("키"), "이름": doc.get("이름")})
|
||||
return out
|
||||
return library_uses.machines()
|
||||
|
||||
|
||||
def same(name: Any, spec: Any, skip: str = "") -> list[dict]:
|
||||
@@ -542,12 +537,12 @@ def one(key: str) -> dict[str, Any]:
|
||||
got = next((r for r in rows() if r["키"] == key), None)
|
||||
if got is None:
|
||||
raise _bad(f"없는 내 기계 「{key}」", 404)
|
||||
return answer(got, uses().get(key, []))
|
||||
return answer(got, _uses().get(key, []))
|
||||
|
||||
|
||||
def listing() -> dict[str, Any]:
|
||||
"""목록 — 줄마다 시간당 · 쓰는곳수(넣은 차례)."""
|
||||
index, used = whole(), uses()
|
||||
index, used = whole(), _uses()
|
||||
return {
|
||||
"줄": [
|
||||
{**r, "시간당": hourly(engine(r), index), "쓰는곳수": len(used.get(r["키"], []))}
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -86,9 +86,10 @@ def test_구조물_사본_수식_사본_값_같음_원본_지우고_고쳐도(wo
|
||||
assert not [r for r in _rows(bundle) if str(r.get("키")).startswith("GX9")]
|
||||
json.dumps(rows["참조사본"], ensure_ascii=False) # 사본 파일로 쓸 수 있는 꼴(Decimal 없음)
|
||||
saved = json.loads(json.dumps(bundle, ensure_ascii=False))
|
||||
formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6 · 로직 몫)
|
||||
edit(world["personal"], key, 3) # M02 에서 다시 고침 → 사본 그대로
|
||||
(world["personal"] / "sangeun" / f"{key}.json").unlink() # 원본이 사라져도 사본만 봄
|
||||
got = prices.calc(rows, saved, {}, {}, None)
|
||||
got = prices.calc(rows, saved, {}, {}, None, formula)
|
||||
line = got["줄"][0]
|
||||
assert not line["까닭"]
|
||||
for part in ("노무비", "재료비", "경비", "계"):
|
||||
@@ -104,7 +105,10 @@ def test_재생성은_M02_새_값(world):
|
||||
_, live = _top(ref)
|
||||
again = source.labor_doc_rows(doc)
|
||||
bundle = source.price_bundle(again, world["personal"])
|
||||
got = prices.calc(again, json.loads(json.dumps(bundle, ensure_ascii=False)), {}, {}, None)
|
||||
formula = {"문서": source.formula_docs(again)}
|
||||
got = prices.calc(
|
||||
again, json.loads(json.dumps(bundle, ensure_ascii=False)), {}, {}, None, formula
|
||||
)
|
||||
assert got["줄"][0]["기준"]["계"] == pytest.approx(live["기준"]["계"], rel=1e-9)
|
||||
rid = refs.ref_id(ref["ref"])
|
||||
assert first["참조사본"][rid]["수식"]["문서"] != again["참조사본"][rid]["수식"]["문서"]
|
||||
@@ -131,11 +135,16 @@ def test_B09_서고_사본_값_같음_원본판(world, tmp_path):
|
||||
assert made["만듦"] and _print(world["personal"]) == before
|
||||
folder = library.library_dir(root) / made["폴더"]
|
||||
read = {p.name: json.loads(p.read_text(encoding="utf-8")) for p in folder.glob("*.json")}
|
||||
bare = prices.calc(read[source.LABOR_FILE], read[source.PRICE_FILE], {}, {}, None)["줄"][0]
|
||||
labor_file, price_file, formula = (
|
||||
read[source.LABOR_FILE],
|
||||
read[source.PRICE_FILE],
|
||||
read["수식.json"],
|
||||
)
|
||||
bare = prices.calc(labor_file, price_file, {}, {}, None, formula)["줄"][0]
|
||||
assert bare["기준"]["계"] == pytest.approx(
|
||||
live["기준"]["계"], rel=1e-9
|
||||
) # 이은 값 없음 = 저장 2
|
||||
got = prices.calc(read[source.LABOR_FILE], read[source.PRICE_FILE], {}, {}, area)["줄"][0]
|
||||
got = prices.calc(labor_file, price_file, {}, {}, area, formula)["줄"][0]
|
||||
assert not got["까닭"] and not live["까닭"]
|
||||
assert got["기준"]["계"] == pytest.approx(live["기준"]["계"], rel=1e-9)
|
||||
mark = read["manifest.json"]["원본판"]
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -21,6 +21,7 @@ from fastapi.testclient import TestClient
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
from M02_MasterTemplete import M02_Library_Same as same
|
||||
from M02_MasterTemplete import M02_Library_Same_Router as same_router
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
@@ -112,7 +113,7 @@ def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world):
|
||||
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
|
||||
with store.at(me):
|
||||
(me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움
|
||||
assert refs.users({**MINE, "키": inner}) == []
|
||||
assert library_uses.users({**MINE, "키": inner}) == []
|
||||
store.delete("precombo", inner)
|
||||
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -20,6 +20,7 @@ import pytest
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Hopyo_Store as hs
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as machine
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_San_Emit as em
|
||||
@@ -142,7 +143,7 @@ def test_nested_stmate_follows_inner(world) -> None:
|
||||
assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383
|
||||
assert _money(doc) == 67383
|
||||
assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK
|
||||
assert refs.users(ref) # 쓰는 곳에 바깥 SK
|
||||
assert library_uses.users(ref) # 쓰는 곳에 바깥 SK
|
||||
with pytest.raises(store.StoreError) as why:
|
||||
refs.refuse_used(folder, "sangeun", ref["키"])
|
||||
assert why.value.status == 409
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -11,6 +11,7 @@ import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
from M02_MasterTemplete import M02_Layer_Index as index
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
@@ -26,15 +27,15 @@ LIB = ("sangeun", "precombo", "labor")
|
||||
def fresh(world, monkeypatch): # noqa: F811
|
||||
"""색인 기억 비움 — 시험끼리 안 섞임."""
|
||||
monkeypatch.setattr(index, "_MEM", {})
|
||||
monkeypatch.setattr(index, "_IDS_LOADED", [])
|
||||
monkeypatch.setattr(refs, "_IDS", {})
|
||||
monkeypatch.setattr(library_uses, "_LOADED", [])
|
||||
monkeypatch.setattr(library_uses, "_IDS", {})
|
||||
return world
|
||||
|
||||
|
||||
def _forget():
|
||||
index._MEM.clear()
|
||||
index._IDS_LOADED.clear()
|
||||
refs._IDS.clear()
|
||||
library_uses._LOADED.clear()
|
||||
library_uses._IDS.clear()
|
||||
|
||||
|
||||
def _sk(folder, name, extra=None):
|
||||
|
||||
@@ -18,6 +18,7 @@ from fastapi import HTTPException
|
||||
from M02_MasterTemplete import M02_Doc_Router as doc_route
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
@@ -104,7 +105,7 @@ def test_save_creates_links_and_stamps(world):
|
||||
assert f"'개인 {key}'" in text
|
||||
assert key in [r["키"] for r in saved["단가"]] # 사본에 박힘
|
||||
assert after["셈"]["계"] == look["셈"]["계"] and after["사본"]["단가새값"] is False
|
||||
assert _at(me, mym.uses)[key] == [{"키": sk, "이름": "sub1임시"}]
|
||||
assert _at(me, library_uses.machines)[key] == [{"키": sk, "이름": "sub1임시"}]
|
||||
|
||||
|
||||
def test_same_draft_two_lines(world):
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -177,7 +177,8 @@ def _freeze(me, key):
|
||||
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
|
||||
)
|
||||
bundle = source.price_bundle(rows, me)
|
||||
return lambda: float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
|
||||
formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6)
|
||||
return lambda: float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"])
|
||||
|
||||
|
||||
def test_프로젝트_사본(world, docs_tmp):
|
||||
|
||||
@@ -318,14 +318,17 @@ def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world):
|
||||
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
|
||||
)
|
||||
bundle = source.price_bundle(rows, me)
|
||||
formula = {"문서": source.formula_docs(rows)} # 사본 수식.json(855-F B9-6)
|
||||
frozen = rows["참조사본"][refs.ref_id(ref)]["수식"]
|
||||
assert _norm(frozen[mcv.UPPER]) == _norm(upper)
|
||||
was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
|
||||
was = float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"])
|
||||
assert was == float(after["셈"]["계"])
|
||||
_save_m01(_upper(d, D(2))) # 기초 고침이 바뀜
|
||||
now = _at(me, path.read, key)
|
||||
assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것
|
||||
assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것
|
||||
assert (
|
||||
float(item_prices.calc(rows, bundle, {}, {}, None, formula)["반영합"]["계"]) == was
|
||||
) # 사본 = 굳은 것
|
||||
_save_m01(upper)
|
||||
# ㉢ ② 를 위 층 값으로 = ② 0
|
||||
now = _at(me, path.read, key)
|
||||
|
||||
@@ -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"]}},
|
||||
|
||||
@@ -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) == [
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -13,6 +13,7 @@ import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
from resources.tester.test_m02_labor_calc_mirror import _same, _ts
|
||||
@@ -324,10 +325,12 @@ def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world):
|
||||
ref = {**SYS, "키": sc}
|
||||
with store.at(world["personal"]):
|
||||
store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []})
|
||||
assert len(refs.users(ref)) == 1 and refs.users(ref) == refs.users(ref, refs.use_files())
|
||||
assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users(
|
||||
ref, library_uses.files()
|
||||
)
|
||||
ver = store.read("labor", "x1")["판"]
|
||||
store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []})
|
||||
assert refs.users(ref) == []
|
||||
assert library_uses.users(ref) == []
|
||||
|
||||
|
||||
def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):
|
||||
|
||||
@@ -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):
|
||||
|
||||
Reference in New Issue
Block a user