- git rm(부르는 곳 0 다시 셈 — import · import_module 글 · getattr 별칭 cm.mf · store.mau · mtx 포함): master_formula · master_formula_check · master_formula_sum · master_text · master_text_item · master_sheet_line · master_gate · master_auto · master_copy(−2,625 줄) - master_cut = down · row · sums 만(일위대가 반영 끝수 · TS 짝) — engine · settle · plain · _line · _sub · kept(손님 0) 지움 · 바탕 = master_base - master_bundle = BUNDLES · BY_ITEM · BY_KIND · is_machine(M01 목록 묶음) — called · bundle · tag 지움 · master_combo = 조합 칸만(run 지움) - check_master · check_master_body · compare_estx: import master_formula → master_base(바탕 이름만) · compare_estx 기계 · 일위대가 대조 = 수식 문서 셈(옛 mf.run · 로직 줄 고르기 덧붙임 걷음 · 일위대가 28 · 기계 207 건 그대로 나옴) - M01 Store: 다시 내보냄 mau · mtx 지움(부르는 곳 0) · cm.mf = master_base - 죽은 주석: master_material · master_pick · master_base · Item_Prices · San_Emit · check_master - test_855_sk_layers: 옛 엔진 안 돎 = 엔진 모듈 없음 확인 - 검증: 관련 146 파일 1,135 통과 · test_855_golden 전수 지문 같음 · 모든 제품 · scripts 모듈 읽기 깨짐 0 · typecheck 0 · 8008 health 200 · 로그 오류 0 · 서버 길 469 → 469 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
289 lines
14 KiB
Python
289 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""품셈재료 단가 — 연결을 따라 자재품목 줄의 값 열 다섯 가운데 낮은 값 (`_틀.md` 4장 재료 값).
|
||
|
||
⚠ 낮은 값 고르기는 **시험 계산용**. 최저가·견적 고르기는 프로젝트 몫 — 마스터는 값을 모으기만 함.
|
||
|
||
수식 문서 계산기 · `master_base` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_base` 는 끝에서 읽음.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
import unicodedata
|
||
from decimal import Decimal
|
||
|
||
import material_merge as mmerge
|
||
import master_unit as mu
|
||
|
||
LINKED = "MP" # 품셈재료 테이블ID
|
||
MARKET = "MT" # 자재품목 테이블ID
|
||
PRICED = "MO" # 유가전력 테이블ID — 값 한 칸
|
||
SLOTS = (
|
||
"물가자료",
|
||
"유통물가",
|
||
"물가정보",
|
||
"거래가격",
|
||
"일반가격",
|
||
) # 사급 값 열 — 가장 낮은 값 고르기 몫
|
||
GOVT = "조달청" # 관급 값 열 — 가장 낮은 값 고르기에 안 넣음(요구 826 · 830)
|
||
PICK_KEYS = (
|
||
"구분",
|
||
"상세구분",
|
||
"이름",
|
||
"규격",
|
||
"대표",
|
||
"지역",
|
||
"계약종별",
|
||
) # 재료 고르기 조건 칸 (`_틀.md` 7장)
|
||
REGION = "자재지역" # 로직 입력 — 「지역」 은 유가 고르기가 씀
|
||
TARIFF = "전력 계약종별" # 로직 입력 — 품셈·계약예규에 계약종별 규정 없음
|
||
|
||
|
||
def plain(s) -> str:
|
||
"""이름 맞대기 — NFKC · 소문자 · 빈칸 없앰 · 지름 기호 하나로."""
|
||
s = unicodedata.normalize("NFKC", str(s or "")).lower()
|
||
return re.sub(r"\s+", "", re.sub(r"[φΦ∅⌀]", "ø", s))
|
||
|
||
|
||
def label(row: dict) -> str:
|
||
"""맞대기 글 = 이름 + 시도 · 시군구 칸(요구 839 · 842 · 830-11) — 검색어 · 자재지역의 지역 낱말이 두 칸과 맞대짐."""
|
||
where = mmerge.where(row)
|
||
return plain(row.get("이름")) + ("" if where == mmerge.NONE else plain(where))
|
||
|
||
|
||
def plain_spec(s) -> str:
|
||
return plain(s).replace("×", "x").replace("*", "x")
|
||
|
||
|
||
def plain_unit(s) -> str:
|
||
return mu.plain(s) # 별칭 · 맞대기 꼴 한 벌(712-2)
|
||
|
||
|
||
def _offers(master: mf.Master, key: str) -> list[tuple[Decimal, str]]:
|
||
"""줄 하나의 (값, 출처) — 자재품목은 값이 있는 열마다 하나 · 그 밖(유가전력)은 「값」 한 칸."""
|
||
row = master.get(key)
|
||
if key[:2] != MARKET:
|
||
return [(row["값"], f"{row['키']}.값")] if row.get("값") is not None else []
|
||
return [(row[slot], f"{row['키']}.{slot}") for slot in SLOTS if row.get(slot) is not None]
|
||
|
||
|
||
def _lowest(master: mf.Master, key: str) -> tuple[object, str | None]:
|
||
"""자재품목 줄의 낮은 값 — ⚠ 시험 계산용."""
|
||
offers = _offers(master, key)
|
||
return min(offers, key=lambda x: x[0]) if offers else (None, None)
|
||
|
||
|
||
def _market_index(master: mf.Master) -> list[tuple[str, str, str, str, str]]:
|
||
"""(품명 뿌리, 이름 + 지역, 규격, 단위, 키) — 「레미콘(관급)」 뿌리 = 레미콘 · 지역 = 지역 칸(`label`)."""
|
||
if not hasattr(master, "_market"):
|
||
master._market = []
|
||
for key, row in master.index.get("MT", {}).items():
|
||
name = plain(row.get("이름"))
|
||
root = re.sub(r"\(.*?\)", "", name.split(",")[0]).split("-")[0]
|
||
master._market.append(
|
||
(root, label(row), plain_spec(row.get("규격")), plain_unit(row.get("단위")), key)
|
||
)
|
||
return master._market
|
||
|
||
|
||
def _tariff(master: mf.Master, label_ref, cond: dict, env: dict) -> list[str]:
|
||
"""후보 조건{이름 · 계약종별: 입력} — 유가전력 전력 줄 가운데 그 계약종별·이름으로 시작하는 줄.
|
||
`label_ref` 는 알림 글에 쓸 자리(호표 줄의 고르기 조건 · 또는 품셈재료 옛 키)."""
|
||
if TARIFF not in env:
|
||
raise mf.FormulaError(f"「{master.label(label_ref)}」 입력 「{TARIFF}」 없음")
|
||
want, kind = plain(cond["이름"]), plain(env[TARIFF])
|
||
hits = [
|
||
key
|
||
for key, one in master.index.get(PRICED, {}).items()
|
||
if one.get("구분") == "전력"
|
||
and plain(one.get("상세구분")) == kind
|
||
and plain(one.get("이름")).startswith(want)
|
||
and one.get("값") is not None
|
||
]
|
||
if not hits:
|
||
raise mf.FormulaError(f"「{master.label(label_ref)}」 계약종별 값 없음 — {env[TARIFF]}")
|
||
return hits
|
||
|
||
|
||
def _region(master: mf.Master, label_ref, cond: dict, env: dict, unit) -> list[str]:
|
||
"""후보 조건{이름 · 규격 · 지역: 입력} — 뿌리가 이름으로 끝나고 이름 · 지역 칸에 지역 글자 · 단위 같음."""
|
||
if cond.get("지역") == "입력" and REGION not in env:
|
||
raise mf.FormulaError(f"「{master.label(label_ref)}」 입력 「{REGION}」 없음")
|
||
region = plain(env.get(REGION, "")) if cond.get("지역") == "입력" else ""
|
||
want, spec, unit_p = plain(cond["이름"]), plain_spec(cond.get("규격")), plain_unit(unit)
|
||
hits = [
|
||
(s, key)
|
||
for root, name, s, u, key in _market_index(master)
|
||
if root.endswith(want) and region in name and u == unit_p and (not spec or s == spec)
|
||
]
|
||
hits = [(s, key) for s, key in hits if _offers(master, key)]
|
||
if not hits:
|
||
raise mf.FormulaError(f"「{master.label(label_ref)}」 지역 값 없음 — {env.get(REGION)}")
|
||
if len({s for s, _ in hits}) > 1:
|
||
raise mf.FormulaError(
|
||
f"「{master.label(label_ref)}」 후보 여럿 — 규격 선택 필요 ({len(hits)}줄)"
|
||
)
|
||
return [key for _, key in hits]
|
||
|
||
|
||
# ── 재료 고르기 ────────────────────────────────────────────────────────
|
||
def static(cond: dict) -> dict:
|
||
"""검사용 조건 — 값에 `{입력}` 이 든 칸은 뺌(계산 때 채워짐)."""
|
||
return {k: v for k, v in cond.items() if not (isinstance(v, str) and "{" in v)}
|
||
|
||
|
||
def cond_text(cond: dict) -> str:
|
||
"""고르기 조건 한 글자 열쇠 — 「구분|상세구분|규격|대표」 · 화면 단가 미리보기가 줄을 찾는 이름."""
|
||
return "|".join(str(cond.get(k) or "") for k in PICK_KEYS) + (
|
||
f"|{cond['검색어']}" if cond.get("검색어") else ""
|
||
)
|
||
|
||
|
||
def by_class(master: mf.Master) -> dict[str, dict]:
|
||
"""자재품목을 「구분」 으로 미리 갈라 둠(마스터마다 한 번) — 고르기 후보를 찾을 때
|
||
3만 줄을 다 훑지 않게. 가른 차례는 파일 차례 그대로."""
|
||
got = getattr(master, "_by_class", None)
|
||
if got is None:
|
||
got = {}
|
||
for key, row in master.index.get(MARKET, {}).items():
|
||
got.setdefault(row.get("구분"), {})[key] = row
|
||
master._by_class = got
|
||
return got
|
||
|
||
|
||
def candidates(
|
||
master: mf.Master, cond: dict, env: dict | None = None, unit: str | None = None
|
||
) -> list[str]:
|
||
"""고르기 조건 안 자재품목 키 — 구분 · 상세구분 · 이름 · 규격 낱말이 모두 든 줄 · 파일 차례대로.
|
||
`unit` 을 주면 그 단위(호표 줄 단위)와 같은 줄만 — 단위가 다르면 다른 물건.
|
||
입력 `자재지역` 이 있으면 이름 · 지역 칸에 그 지역이 든 줄만(그런 줄이 없으면 조건 안 전부).
|
||
조건에 `검색어` 가 있으면 기본 검색어 찾기(`master_pick`) ·
|
||
빈 검색어 = 자재표에 없는 품목(후보 없음)."""
|
||
if mp.empty_term(cond):
|
||
return []
|
||
if cond.get("검색어"):
|
||
return mp.search(master, cond, env, unit)
|
||
want = [plain_spec(w) for w in str(cond.get("규격") or "").split()]
|
||
want_name = [plain(w) for w in str(cond.get("이름") or "").split()]
|
||
detail = cond.get("상세구분")
|
||
need = plain_unit(unit) if unit else ""
|
||
hits = [
|
||
key
|
||
for key, row in by_class(master).get(cond.get("구분"), {}).items()
|
||
if (not detail or row.get("상세구분") == detail)
|
||
and all(w in plain(row.get("이름")) for w in want_name)
|
||
and all(w in plain_spec(row.get("규격")) for w in want)
|
||
and (not need or plain_unit(row.get("단위")) == need)
|
||
]
|
||
region = plain((env or {}).get(REGION, ""))
|
||
near = [k for k in hits if region in label(master.get(k))] if region else []
|
||
return near or hits
|
||
|
||
|
||
def pick(master: mf.Master, cond: dict, env: dict, unit: str | None = None) -> str:
|
||
"""시험 계산이 쓸 줄 — 관리자가 정한 `대표`, 없으면 조건 안 값 있는 첫 줄(단위 같은 줄만)."""
|
||
if cond.get("검색어"):
|
||
return mp.pick(master, cond, env, unit)
|
||
if cond.get("대표"):
|
||
return str(cond["대표"])
|
||
keys = candidates(master, cond, env, unit)
|
||
keys = [k for k in keys if _offers(master, k)] or keys
|
||
if not keys:
|
||
what = " · ".join(f"{k} {mf._plain(v)}" for k, v in cond.items())
|
||
raise mf.FormulaError(f"재료 고르기 후보 없음 — {what}")
|
||
return keys[0]
|
||
|
||
|
||
def check_unit(master: mf.Master, where: str, cond: dict, unit: str | None) -> list[str]:
|
||
"""단위 경고 — 호표 줄·품셈재료 줄 단위와 맞는 후보가 없거나 대표 줄 단위가 다름.
|
||
틀린 데이터가 아니라 좁혀야 할 조건이라 `check_pick` 과 따로 봄(`check_master 단위`)."""
|
||
if "검색어" in cond: # 빈 검색어(자재표에 없는 품목)도 이 길 — 구분 안 후보로 경고하지 않음
|
||
return mp.check_warn(master, where, cond, unit)
|
||
cond = static(cond)
|
||
rows = master.index.get(MARKET, {})
|
||
rep = str(cond.get("대표") or "")
|
||
if not unit or set(cond) - set(PICK_KEYS) or not cond.get("구분"):
|
||
return [] # 구분·규격이 `{입력}` 이면 좁힐 것이 없어 여기서 뺌
|
||
if rep in rows:
|
||
if plain_unit(rows[rep].get("단위")) != plain_unit(unit):
|
||
return [
|
||
f"{where} · 대표 줄 단위 「{rows[rep].get('단위')}」 이 줄 단위 「{unit}」 과 다름"
|
||
]
|
||
return []
|
||
if candidates(master, cond) and not candidates(master, cond, None, unit):
|
||
return [f"{where} · 단위 「{unit}」 후보 0 — 조건 안 줄은 모두 다른 단위"]
|
||
return []
|
||
|
||
|
||
def check_pick(master: mf.Master, where: str, cond: dict, unit: str | None = None) -> list[str]:
|
||
"""고르기 조건 검사 — 칸 이름 · 구분·상세구분이 자재품목에 있는지 · 대표 줄 · 후보 0.
|
||
값에 `{입력}` 이 든 칸(관경 등)은 계산 때 채워지므로 검사에서 뺌.
|
||
지역·계약종별 조건은 구분 없이 이름 하나로 자재품목·유가전력을 넓게 찾음(_region · _tariff)
|
||
— 여기서는 이름 칸만 있는지 봄(후보 0 은 계산 때 판단)."""
|
||
if cond.get("검색어") is not None and not set(cond) - {*PICK_KEYS, "검색어"}:
|
||
return mp.check_zero(master, where, cond)
|
||
if set(cond) - set(PICK_KEYS):
|
||
return [f"{where} · 재료 고르기 조건 모양 「{cond}」 — {' · '.join(PICK_KEYS)}"]
|
||
if ("지역" in cond and cond["지역"] != "입력") or (
|
||
"계약종별" in cond and cond["계약종별"] != "입력"
|
||
):
|
||
return [f"{where} · 재료 고르기 조건 모양 「{cond}」 — 지역·계약종별은 늘 「입력」"]
|
||
if cond.get("지역") == "입력" or cond.get("계약종별") == "입력":
|
||
return [] if cond.get("이름") else [f"{where} · 재료 고르기 조건 「{cond}」 — 이름 없음"]
|
||
if not cond.get("구분"):
|
||
return [f"{where} · 재료 고르기 조건 모양 「{cond}」 — {' · '.join(PICK_KEYS)}"]
|
||
cond = static(cond)
|
||
if not cond.get("구분"): # 구분 자체가 `{입력}` — 계산 때 채워져 여기서 좁힐 것이 없음
|
||
return []
|
||
out, rows = [], master.index.get(MARKET, {})
|
||
for slot in ("구분", "상세구분"):
|
||
if cond.get(slot) and not any(r.get(slot) == cond[slot] for r in rows.values()):
|
||
out.append(f"{where} · 자재품목에 없는 {slot} 「{cond[slot]}」")
|
||
rep = cond.get("대표")
|
||
if rep and str(rep) not in rows:
|
||
out.append(f"{where} · 대표 줄 「{rep}」 이 자재품목에 없음")
|
||
elif rep and str(rep) not in candidates(master, cond):
|
||
out.append(f"{where} · 대표 줄 「{rep}」 이 고르기 조건 밖")
|
||
if not out and not candidates(master, cond):
|
||
out.append(f"{where} · 재료 고르기 후보 0")
|
||
return out
|
||
|
||
|
||
def element(
|
||
master: mf.Master, ref, env: dict, unit: str | None = None
|
||
) -> tuple[object, str | None]:
|
||
"""요소 값과 출처 — 자재품목은 제 줄, 품셈재료는 연결을 따라가 낮은 값 · 그 밖은 줄의 `값`.
|
||
`ref` 가 고르기 조건 묶음이면 대표 줄(없으면 단위 같은 조건 안 첫 줄)로 풂.
|
||
조건에 지역·계약종별 이 「입력」 이면 구분·상세구분 없이 이름 하나로 넓게 찾음(_region · _tariff)
|
||
— 호표 줄에 바로 써도 품셈재료 간접 없이 풀림(PLAN 7-4b 뒤 절반)."""
|
||
if isinstance(ref, dict) and (ref.get("계약종별") == "입력" or ref.get("지역") == "입력"):
|
||
keys = (
|
||
_tariff(master, ref, ref, env)
|
||
if ref.get("계약종별") == "입력"
|
||
else _region(master, ref, ref, env, unit)
|
||
)
|
||
offers = [x for key in keys for x in _offers(master, key)]
|
||
return min(offers, key=lambda x: x[0]) if offers else (None, None)
|
||
if isinstance(ref, dict):
|
||
ref = pick(master, ref, env, unit)
|
||
row = master.get(ref)
|
||
if ref[:2] == MARKET: # 자재품목을 바로 가리키는 호표 줄
|
||
return _lowest(master, ref)
|
||
if ref[:2] != LINKED:
|
||
return master.value(ref)
|
||
link = row.get("연결")
|
||
if not link:
|
||
return None, None
|
||
if isinstance(link, str):
|
||
keys = [link]
|
||
elif link.get("계약종별") == "입력":
|
||
keys = _tariff(master, ref, link, env)
|
||
else:
|
||
keys = _region(master, ref, link, env, row["단위"])
|
||
offers = [x for key in keys for x in _offers(master, key)]
|
||
return min(offers, key=lambda x: x[0]) if offers else (None, None)
|
||
|
||
|
||
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||
import master_pick as mp # noqa: E402 — 검색어 찾기
|