diff --git a/M02_MasterTemplete/DataFlow/M02_DF_Api.ts b/M02_MasterTemplete/DataFlow/M02_DF_Api.ts index ec9d43423..bad809f25 100644 --- a/M02_MasterTemplete/DataFlow/M02_DF_Api.ts +++ b/M02_MasterTemplete/DataFlow/M02_DF_Api.ts @@ -1,15 +1,14 @@ /* ============================================================================= * M02_DF_Api.ts - * 단위 · 금액 표준 표 읽기 — 서버 `GET /api/m02/df/standards`(`M02_DF_Router.py`) - * 부르는 곳 = 단위 고르기(`M02_DF_UnitPick`) · 끝수 표준(`M02_DF_Round`) · 옵션 기계 이름(`formula_doc_options`) + * 단위 표준 표 읽기 — 서버 `GET /api/m02/df/standards`(`M02_DF_Router.py`) + * 부르는 곳 = 단위 고르기(`M02_DF_UnitPick`) · 옵션 기계 이름(`formula_doc_options`) * ========================================================================== */ import { API_BASE_URL } from "@config/config_frontend"; -/** 단위 · 금액 표준 표 */ +/** 단위 표준 표 */ export interface CfStandards { unit: { 이름: string; 줄: Record[]; [k: string]: unknown }; - money: { 이름: string; 줄: Record[]; [k: string]: unknown }; saved: boolean; } diff --git a/M02_MasterTemplete/DataFlow/M02_DF_Round.ts b/M02_MasterTemplete/DataFlow/M02_DF_Round.ts deleted file mode 100644 index f13348e09..000000000 --- a/M02_MasterTemplete/DataFlow/M02_DF_Round.ts +++ /dev/null @@ -1,125 +0,0 @@ -/* ============================================================================= - * M02_DF_Round.ts - * 끝수 기본값 — 금액 단위 표준(산림품셈 1-2-2 「금액의 단위표준」)을 읽어 - * 출력(비용) 기본 = 일위대가표 금액란 · 원가 합계 기본 = 일위대가표 계금 (모두 미만 버림) - * 표 읽기 = 서버 `GET /api/m02/df/standards`(Api `cfStandards`) → {unit, money, saved} - * 모양은 docs/raw/M01_쉬운단가/흐름도_정함.md 11 · 12. - * ========================================================================== */ - -import { cfStandards } from "./M02_DF_Api"; - -/** 끝수 — 자리 · 방법 */ -export interface CfRound { - places: number; - method: "반올림" | "올림" | "버림"; -} - -/** 표 한 줄 — 원문 그대로(종목 · 단위 · 지위 · 비고) */ -export interface CfMoneyRow { - 종목: string; - 단위?: string; - 지위: number; - 비고?: string; -} - -/** 표 모양 둘(`{줄: […]}` · 줄 목록)을 줄 목록으로 */ -const rowsOf = (x: unknown): CfMoneyRow[] => { - const list = Array.isArray(x) ? x : (x as { 줄?: unknown } | null)?.줄; - return Array.isArray(list) ? (list as CfMoneyRow[]) : []; -}; - -let loaded: Promise | null = null; - -/** 금액 단위 표준 줄 — 서버가 고친 것(`_data`)이 있으면 그것 · 없으면 처음 값을 줌 */ -export function loadMoneyStandard(): Promise { - loaded ??= cfStandards().then( - (s) => rowsOf(s.money), - () => { - loaded = null; // 못 읽었으면 다음에 다시 — 지금은 정해 둔 기본값으로 - return []; - }, - ); - return loaded; -} - -/** 표를 다시 읽게(표를 고친 뒤) */ -export function resetStandard(): void { - loaded = null; -} - -/** 표 줄 → 끝수 — 지위 0.1 = 소수 1자리 · 1 이상 = 0자리 · 비고 「미만버림」 */ -export function roundOf(row: CfMoneyRow): CfRound { - const step = row.지위 > 0 ? row.지위 : 1; - const method = - /올림/.test(row.비고 ?? "") && !/버림/.test(row.비고 ?? "") - ? "올림" - : /반올림/.test(row.비고 ?? "") - ? "반올림" - : "버림"; - return { places: step >= 1 ? 0 : Math.round(-Math.log10(step)), method }; -} - -const find = (rows: CfMoneyRow[], word: string): CfMoneyRow | undefined => - rows.find((r) => r.종목.includes("일위대가표") && r.종목.includes(word)); - -/** 출력(비용) 기본 — 일위대가표 금액란 0.1원 미만 버림 */ -export async function defaultItemRound(): Promise { - const row = find(await loadMoneyStandard(), "금액란"); - return row ? roundOf(row) : { places: 1, method: "버림" }; -} - -/** 원가 합계 기본 — 일위대가표 계금 1원 미만 버림 */ -export async function defaultTotalRound(): Promise { - const row = find(await loadMoneyStandard(), "계금"); - return row ? roundOf(row) : { places: 0, method: "버림" }; -} - -/** 끝수 적용 — 소수 자리 · 방법(부동소수 오차는 아주 작은 값으로 눌러 줌) */ -export function roundBy(r: CfRound | null | undefined, v: number): number { - if (!r) return v; - const k = 10 ** r.places; - const x = v * k; - const eps = Math.abs(x) * 1e-12 + 1e-9; - const f = - r.method === "올림" - ? Math.ceil(x - eps) - : r.method === "반올림" - ? Math.round(x + eps) - : Math.floor(x + eps); - return f / k; -} - -/** 「0.1원 미만 버림」 꼴 쉬운 말 */ -export function roundText(r: CfRound | null): string { - if (!r) return "끝수 없음(값 그대로)"; - const step = r.places > 0 ? Number((10 ** -r.places).toFixed(r.places)) : 1; - return `${step}원 미만 ${r.method}`; -} - -/** 출력 기본 끝수(표를 읽어 오기 전에는 금액란 0.1원 미만 버림) — 화면이 바로 쓰는 값 */ -let itemNow: CfRound = { places: 1, method: "버림" }; -void defaultItemRound().then((r) => (itemNow = r)); -export const itemRoundNow = (): CfRound => itemNow; - -/** 끝수대로 자른 값을 그 자리 수만큼 보임(3,216.6) — 끝수가 없으면 소수 여섯째 자리까지 */ -export function showRounded(v: number, r?: CfRound): string { - if (!r) return v.toLocaleString("ko-KR", { maximumFractionDigits: 6 }); - return roundBy(r, v).toLocaleString("ko-KR", { - minimumFractionDigits: 0, - maximumFractionDigits: Math.max(0, r.places), - }); -} - -/** 원가 합계 기본 끝수(표를 읽어 오기 전에는 계금 1원 미만 버림) — 화면이 바로 쓰는 값 */ -let totalNow: CfRound = { places: 0, method: "버림" }; -void defaultTotalRound().then((r) => (totalNow = r)); -export const totalRoundNow = (): CfRound => totalNow; - -/** 그 로직의 합계 끝수 — 정본 = CfLogic.totalRound(옛 로직을 옮긴 흐름 = 자신의 끝수 · null = 끝수 없음) · - * 정하지 않았으면 fallback(새 로직 = 일위대가표 계금 1원 미만 버림) */ -export function totalRoundOf( - lg: { totalRound?: CfRound | null }, - fallback: CfRound = totalNow, -): CfRound | null { - return lg.totalRound === undefined ? fallback : lg.totalRound; -} diff --git a/M02_MasterTemplete/DataFlow/M02_DF_Router.py b/M02_MasterTemplete/DataFlow/M02_DF_Router.py index cf9f8c29d..3114536de 100644 --- a/M02_MasterTemplete/DataFlow/M02_DF_Router.py +++ b/M02_MasterTemplete/DataFlow/M02_DF_Router.py @@ -1,6 +1,6 @@ -"""단위 · 금액 표준 표 읽기 — `GET /api/m02/df/standards` → {unit, money, saved} · 기계 이름 `GET /machine-names`. +"""단위 표준 표 읽기 — `GET /api/m02/df/standards` → {unit, saved} · 기계 이름 `GET /machine-names`. -부르는 곳 = 단위 고르기(`M02_DF_UnitPick.ts`) · 끝수 표준(`M02_DF_Round.ts`). +부르는 곳 = 단위 고르기(`M02_DF_UnitPick.ts`) · 금액 표준(`M02_DF_Round.ts`)은 걷음(894). 표 = `_standard/` 파일(git 이 따라감) · 권한 = 로그인만(읽기만 · `main.py` 한 줄 · M02 줄 쌓기 단위 고르기). """ diff --git a/M02_MasterTemplete/DataFlow/M02_DF_Values.py b/M02_MasterTemplete/DataFlow/M02_DF_Values.py index 2d0224d59..df36fcc1d 100644 --- a/M02_MasterTemplete/DataFlow/M02_DF_Values.py +++ b/M02_MasterTemplete/DataFlow/M02_DF_Values.py @@ -1,85 +1,17 @@ -"""단가산출 흐름도 입력 값(PLAN 35-9 · 정함 5 · 6 · 11) — 서버 길은 `M02_DF_Router.py`. +"""옛 단가산출 흐름도 값 찾기에서 남은 바닥(PLAN 35-9) — 서버 길은 `M02_DF_Router.py`. -· 그룹 요소 값 — 인력 노임 · 재료(키 · 검색어 묶음) · 유가전력 · 환율 · 요율 · - 기계(값 칸 · 시간당 경비) · 소요량 / 계수 표(블록 · 한 줄) · 사용자 요소 - — 단가는 기존 `/calc`(`M01_MasterData_Store.calc`)와 같은 셈 -· 재료 자리 셋(고정 · 선택 · 조건 찾기) · 자재 찾기(띄어쓰기 AND · 쪽) · 단위 · 금액 표준 표 -마스터 파일은 읽기만. +· `_pick` · `_group_rows` · `GROUP_RULE` · `MACHINE_SEP` · `HOURLY` = 실무자료 이음(`M02_Item_Prices`)이 씀 +· 단위 표준 표(`standards` · 단위 고르기) — 마스터 파일은 읽기만. +흐름도 입력 값 길(값 · 재료 자리 · 그룹 찾기 · 자재 찾기)과 금액 표준 표는 화면 0 이라 894 에서 걷음. """ from __future__ import annotations import json -import re -from contextvars import ContextVar from typing import Any from M01_MasterData import M01_MasterData_Store as store -cm = store.cm -_UKEY = re.compile(r"^UE-(\d{4,})$") -RANGE_LOW, RANGE_HIGH = "·아래", "·위" -RANGE_RULE = "·범위규칙" # 표 블록 끝 칸 — 줄마다 경계 말(옛 find 와 같음 · 없으면 초과·이하) -FIELDS = (*cm.mf.COST_ITEMS, "계") - - -# 단가 자리 — `mf.run` 을 부른 쪽이 넘긴 Master(프로젝트 사본이면 그 단가) · 없으면 마스터 -# ponytail: 단가 · 값 · 표만 이 자리 · 찾기 목록(재료 조건 찾기 · 그룹 찾기 · 기계 짝)은 마스터에서 -SOURCE: ContextVar = ContextVar("df_price_source", default=None) -_DRAFT = "GX999998" # 단가 자리에 잠깐 얹는 견본 로직 키 - - -def _whole(): - return SOURCE.get() or store.loaded()[1] - - -def _calc(inputs: dict, row: dict) -> dict: - """`Store.calc("", inputs, row)` 와 같은 꼴 — 단가 자리가 넘겨졌으면 그 Master 로 셈.""" - whole = SOURCE.get() - if whole is None: - return store.calc("", inputs, row, None) - slot = whole.index.setdefault(_DRAFT[:2], {}) - slot[_DRAFT] = {**store._dec(row), "키": _DRAFT} - try: - given = cm.mf.fill_empty(slot[_DRAFT], {k: store._dec(v) for k, v in inputs.items()}) - got = cm.mf.run(whole, _DRAFT, given) - except (cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e: - return {"ok": False, "reason": str(e) or type(e).__name__} - finally: - slot.pop(_DRAFT, None) - if "결과" in got: - return {"ok": True, "result": got["결과"], "middle": got["중간"]} - sums = {k: got[k] for k in cm.mf.BUNDLE} - return {"ok": True, "lines": got["줄"], "sums": sums, "middle": got["중간"]} - - -# ── 입력 값 ──────────────────────────────────────────────────────────── -def _row(line: dict, names) -> dict: - """단가를 `/calc` 와 같은 셈으로 — 호표 한 줄(수량 1)짜리 저장 안 하는 견본 로직.""" - return { - "키": "", - "원문번호": "", - "이름": "입력 값", - "결과단위": "원/식", - "출처": "자체", - "입력": [{"이름": n} for n in names], - "중간": [], - "호표": [line], - "덧줄": [], - "끝수": None, - } - - -def _money(got: dict, field: str | None) -> dict: - if not got["ok"]: - return got - if "result" in got: - return {"ok": True, "value": got["result"]} - pick = field or "계" - if pick not in FIELDS: - return {"ok": False, "reason": f"모르는 칸 「{pick}」"} - return {"ok": True, "value": got["sums"][pick]} - def _pick(key: Any) -> dict | None: """재료 검색어 묶음 `{구분, 상세구분, 검색어, 규격?}` — 묶음 · 그 JSON 글 · 아니면 None.""" @@ -94,386 +26,10 @@ def _pick(key: Any) -> dict | None: return None -def _material(cond: dict, unit: str, inputs: dict | None = None) -> dict: - """검색어 묶음 재료 단가 — 기존 로직 재료 줄과 같은 길(검색어 · 자동값 차례 · 단위 환산) - · inputs = 로직 입력(자재지역 · 계약종별 · 검색어 {자리}) — 옛 셈이 읽는 그대로.""" - inputs = inputs or {} - line = {"종류": "재료", "요소": cond, "이름": cond.get("검색어") or "재료", "수량": "1"} - got = _calc(inputs, _row({**line, "단위": unit, "비목": "재료비"}, inputs)) - if not got["ok"]: - return got - one = got["lines"][0] - if one["단가"] is None: - word = cond.get("검색어") or "" - empty = "값 없음" in str(one.get("까닭") or "") - why = ( - "단가가 자료에 비어 있음 — 단가를 채우거나 다른 품목을 고름" - if empty - else "맞는 재료 없음" - ) - return {"ok": False, "blank": True, "reason": f"「{word}」 {why} — {one.get('까닭') or ''}"} - picked = one.get("품목") or {} - return {"ok": True, "value": one["단가"], "name": picked.get("이름"), "unit": unit or None} - - -def _brief(key: str, want: str) -> tuple[dict | None, str | None]: - """마스터 줄 하나 + 그룹 확인 — (줄, 까닭) · 유가전력은 재료 그룹 안 MO 키.""" - try: - row = _whole().get(key) - except cm.mf.FormulaError as e: - return None, str(e) - group = store.mk.GROUP_OF.get(store.mk.id_of(key)) - if not (group == want or (want == "유가전력" and key.startswith("MO"))): - return None, f"「{key}」 는 {want} 아님" - return row, None - - -def _price(group: str, key: str, unit: str = "", inputs: dict | None = None) -> dict: - """인력 노임 · 재료 단가 — 준용 · 낮은 값 · 출처는 엔진 그대로.""" - row, why = _brief(key, group) - if row is None: - return {"ok": False, "reason": why} - kind, cost = {"인력": ("인력", "노무비"), "재료": ("재료", "재료비")}[group] - line = {"종류": kind, "요소": key, "이름": row.get("이름") or key, "수량": "1"} - line = {**line, "단위": unit or row.get("단위") or "", "비목": cost} - inputs = inputs or {} - got = _calc(inputs, _row(line, inputs)) - if not got["ok"]: - return got - one = got["lines"][0] - out = {"ok": one["단가"] is not None, "value": one["단가"], "name": row.get("이름")} - out |= {"blank": True} if one["단가"] is None else {} # 옛 셈은 그 줄만 비우고 계속 - return {**out, "unit": row.get("단위"), **({"reason": one["까닭"]} if one.get("까닭") else {})} - - -def _plain_value(group: str, key: str, field: str | None) -> dict: - """유가전력 · 환율 · 요율 · 기계 값 칸 — 그 줄 값(묶음이면 field · 요율 기본 rate_percent).""" - row, why = _brief(key, group) - if row is None: - return {"ok": False, "reason": why} - value, unit = row.get("값"), row.get("단위") - if isinstance(value, dict): - pick = field or ("rate_percent" if group == "요율" else "") - if pick not in value: - return { - "ok": False, - "reason": f"「{row.get('이름')}」 에서 쓸 칸을 고름 — {', '.join(value)}", - } - value = value[pick] - unit = ( - unit.get(pick) if isinstance(unit, dict) else ("%" if pick == "rate_percent" else unit) - ) - if value is None: - return {"ok": False, "reason": f"「{row.get('이름')}」 값이 자료에 비어 있음"} - return {"ok": True, "value": value, "name": row.get("이름"), "unit": unit} - - -def _table(key: str, at: Any = None) -> dict: - """소요량 · 계수 표 → 머리 줄 + 줄(조건 칸 → 값 칸 · 범위가 있는 칸은 「·아래」 「·위」 두 칸 · - 그 칸에 수 하나면 아래 · 위 같은 수) · at = 줄 차례(0부터)면 머리 줄 + 그 줄 하나.""" - if SOURCE.get() is not None: # 단가 자리(프로젝트 사본)의 표 - try: - table = SOURCE.get().get(key) - except cm.mf.FormulaError: - table = None - return _table_of(table, key, at) - files = store.loaded()[0] - table = next( - ( - t - for d in files.values() - if d.get("그룹") in cm.mf.TABLE_GROUPS - for t in d.get("표") or [] - if str(t.get("키")) == key - ), - None, - ) - return _table_of(table, key, at) - - -def _table_of(table: dict | None, key: str, at: Any) -> dict: - if table is None: - return {"ok": False, "reason": f"없는 표 「{key}」"} - conds, lines = table.get("조건") or {}, table.get("줄") or [] - names = [*conds, *(table.get("값칸") or {})] - split = { - n for n in names if conds.get(n) == "범위" or any(isinstance(r.get(n), list) for r in lines) - } - head = [h for n in names for h in ((n + RANGE_LOW, n + RANGE_HIGH) if n in split else (n,))] - if at is not None: - if not isinstance(at, int) or not 0 <= at < len(lines): - return {"ok": False, "reason": f"「{table.get('이름')}」 에 {at} 번째 줄 없음"} - lines = [lines[at]] - rows, worth = [], set(table.get("값칸") or {}) - for r in lines: - line = [] - for n in names: - v = _arith(r.get(n)) if n in worth else r.get(n) - if n in split: - line += list(v) if isinstance(v, list) else [v, v] - else: - line.append(None if v == "" else v if not isinstance(v, dict) else str(v)) - rows.append(line) - if "범위" in conds.values(): # 끝 칸 「·범위규칙」 = 줄마다 그 줄 경계 말(lookup 이 읽음) - head, rows = [*head, RANGE_RULE], [[*r, _bound(table, x)] for r, x in zip(rows, lines)] - return {"ok": True, "rows": [head, *rows], "name": table.get("이름"), "unit": table.get("기준")} - - -def _bound(table: dict, row: dict) -> str: - """줄 경계 말 — 옛 `_match` 와 같음 · 첫 낱말 · 「이하 포함」 이면 맨 윗줄만 이상·이하.""" - rule, *more = str(table.get("범위규칙") or "초과·이하").split(" · ") - rule = rule.split(" (")[0] - if rule != "이상·미만" or not any("이하 포함" in x for x in more): - return rule - for c, kind in (table.get("조건") or {}).items(): # 옛 _match — 그 범위 칸 위 끝이 가장 큰 줄 - ups = [ - r[c][1] - for r in table.get("줄") or [] - if isinstance(r.get(c), list) and r[c][1] is not None - ] - if kind == "범위" and ups and isinstance(row.get(c), list) and row[c][1] == max(ups): - return "이상·이하" - return rule - - -def _arith(v: Any) -> Any: - """값 칸 수 식 글(「(0.05)」 「1/1.30」) — 옛 셈처럼 수로(사칙연산 · 괄호만 · 옛 엔진 파서).""" - if not isinstance(v, str) or not cm.mf._ARITH.fullmatch(v): - return v - try: - return cm.mf.evaluate(cm.mf.parse(v), {}, None, 0) - except (cm.mf.FormulaError, ArithmeticError): - return v - - -def _user(uid: str, local: list[dict]) -> dict: - """사용자 요소 값 — local = 다이어그램 안 것 + 공용 목록(부르는 쪽이 모음).""" - one = next((r for r in local if r.get("id") == uid), None) - if one is None: - return {"ok": False, "reason": f"없는 사용자 요소 「{uid}」"} - if one.get("value") is None: - return {"ok": False, "reason": f"「{one.get('name')}」 값이 비어 있음"} - return {"ok": True, "value": one["value"], "name": one.get("name"), "unit": one.get("unit")} - - MACHINE_SEP = "#" # 입력 판(sub3) 기계 요소 ref 「EQ키#칸」 HOURLY = "시간당 경비" # 기계 칸 이름 — 기계 시간당 경비 로직으로 셈(기종 → 로직 짝) -def _machine_hourly(key: str, inputs: dict) -> dict: - """기계 한 시간 값 — 식 고름 = `M02_Machine_Hourly.pick`(목록 › 꼴 · 822-2) · 빈 입력은 첫 고르기.""" - from M02_MasterTemplete import M02_Machine_Hourly as mh - - row, why = _brief(key, "기계") - if row is None: - return {"ok": False, "reason": why} - code = str(row.get("원문번호") or "") - logic = mh.pick(row) - if lack := mh.why(row, logic): - return {"ok": False, "reason": f"「{row.get('이름')}」 — {lack}"} - given = {} - for spec in logic.get("입력") or []: - name = spec.get("이름") - if name != "기계": - given[name] = inputs.get(name, (spec.get("고르기") or [None])[0]) - args = "".join(f", {n if n.isidentifier() else repr(n)}='{v}'" for n, v in given.items()) - mine = f", 기계='{code}'" if mh.takes_machine(logic) else "" - ref = f"로직({logic['키']}{mine}{args})" - line = {"종류": "로직", "요소": ref, "이름": "기계", "단위": "시간", "수량": "1"} - got = _money(_calc({}, _row(line, ())), "계") - return {**got, "name": row.get("이름"), "unit": "원/시간"} if got["ok"] else got - - -def one_value(item: dict, local: list[dict] | None = None) -> dict: - """물음 한 줄 `CfQuery {id, group, ref? · table? · unit? · field? · inputs?}` → `CfAnswer`. - - 기계 ref 「EQ키#칸」(입력 판 요소 ref)도 받음 · 칸 「시간당 경비」 = 기계경비 로직으로 셈. - """ - group, ref = item.get("group"), item.get("ref") - table, field = item.get("table") or {}, item.get("field") - if group == "기계" and isinstance(ref, str) and MACHINE_SEP in ref: - ref, _, field = ref.partition(MACHINE_SEP) - try: - if ( - isinstance(item.get("slot"), dict) and group in GROUP_RULE - ): # 인력 · 기계 · 유가 조건 찾기 - got = group_find(str(group), item["slot"], item.get("value")) - elif isinstance(item.get("slot"), dict): # 재료 자리(고정 · 선택 · 조건 찾기) - got = slot_price(item["slot"], item.get("value"), item.get("pick")) - elif isinstance(ref, str) and _UKEY.match(ref): - got = _user(ref, local or []) - elif group in ("소요량", "계수"): - got = _table(str(table.get("key") or ref or ""), table.get("row")) - elif group == "재료" and _pick(ref) is not None: - got = _material(_pick(ref), str(item.get("unit") or ""), item.get("inputs")) - elif group in ("인력", "재료"): - got = _price(group, str(ref or ""), str(item.get("unit") or ""), item.get("inputs")) - elif group == "기계" and str(ref or "").startswith("로직("): - inputs = item.get("inputs") or {} - line = {"종류": "로직", "요소": ref, "이름": "기계", "단위": "시간", "수량": "1"} - got = _money(_calc(inputs, _row(line, inputs)), field) - elif group == "기계" and field == HOURLY: - got = _machine_hourly(str(ref or ""), item.get("inputs") or {}) - elif group in ("기계", "유가전력", "환율", "요율"): - got = _plain_value(group, str(ref or ""), field) - else: - got = {"ok": False, "reason": f"모르는 그룹 「{group}」"} - except store.StoreError as e: - got = {"ok": False, "reason": str(e.detail)} - return {"id": item.get("id") or "", **got} - - -def values(items: list[dict], local: list[dict]) -> dict: - # ponytail: 하나씩 셈(단가 하나 0.3초쯤) — 입력 값이 수십이면 마스터 사본 한 벌로 묶어 셈 - return {"values": [one_value(i, local) for i in items]} - - -# ── 자재 찾기 · 재료 자리 ────────────────────────────────────────────── -MATERIALS = "재료_자재품목.json" -_LEDGER: dict[str, Any] = {} - - -def _numbers() -> dict[str, str]: - """자재품목 키 → 원문번호(품번) — 줄에 없고 키대장에만 있음 · 파일이 바뀌면 다시 읽음.""" - path = store.FOLDER / store.mk.BOOK.name - stamp = (str(path), path.stat().st_mtime if path.is_file() else 0) - if _LEDGER.get("stamp") != stamp: - book = json.loads(path.read_text(encoding="utf-8")) if path.is_file() else {"키": {}} - keys = book.get("키") or {} - found = {k: str(v.get("원문번호") or "") for k, v in keys.items() if k.startswith("MT")} - _LEDGER.update(stamp=stamp, map=found) - return _LEDGER["map"] - - -def _squash(text: Any) -> str: - return re.sub(r"\s+", "", str(text or "")).lower() - - -def _found(sub: str, detail: str, q: str) -> list[dict]: - """범위(구분 · 상세구분) 안 · 띄어쓰기로 나눈 말을 모두(AND) 이름 · 규격 · 키 · 원문번호에서. - - 품목 글 · 찾는 낱말 모두 띄어쓰기를 지우고 비교 — 「흄 관(B형)」 도 「흄관」 으로 걸림. - """ - words = [_squash(w) for w in str(q or "").split()] - numbers = _numbers() - rows = (store.loaded()[0].get(MATERIALS) or {}).get("줄") or [] - out = [] - for r in rows: - if (sub and r.get("구분") != sub) or (detail and r.get("상세구분") != detail): - continue - fields = (r.get("이름"), r.get("규격"), r.get("키"), numbers.get(r.get("키"))) - hay = "|".join(_squash(x) for x in fields) - if all(w in hay for w in words): - out.append(r) - return out - - -def _brief_row(r: dict) -> dict: - return { - "ref": r.get("키"), - "name": r.get("이름"), - "spec": r.get("규격") or "", - "unit": r.get("단위") or "", - "price": store._lowest(r), - "구분": r.get("구분"), - "상세구분": r.get("상세구분"), - } - - -def materials(q: str, sub: str, detail: str, page: int, size: int) -> dict: - """자재 찾기 — {total, page, size, items: [{ref, name, spec, unit, price, 구분, 상세구분}]}.""" - hits = _found(sub, detail, q) - page, size = max(page, 1), min(max(size, 1), 200) - part = hits[(page - 1) * size : page * size] - return {"total": len(hits), "page": page, "size": size, "items": [_brief_row(r) for r in part]} - - -FIELDS_RULE, OPS_RULE = ("규격", "이름", "키", "검색어"), ("포함", "같음") # Model CfMaterialRule -_HOLE = re.compile(r"\{[^{}]+\}") - - -def _filled(template: str, value: Any) -> str: - """검색어 틀의 {자리} — 알약 값이 이미 채운 글이면 그대로 · 아니면 자리마다 그 값.""" - text = str(value) - pattern = "".join( - ".+" if _HOLE.fullmatch(p) else re.escape(p) for p in re.split(r"(\{[^{}]+\})", template) - ) - return text if re.fullmatch(pattern, text) else _HOLE.sub(lambda _: text, template) - - -def _search(slot: dict, value: Any) -> dict: - """조건 찾기 field 검색어 — 틀(요소 ref 묶음)의 {자리} 를 알약 값으로 채워 옛 찾기 그대로.""" - if value in (None, ""): - return { - "ok": False, - "blank": True, - "reason": "찾을 값이 비어 있음 — 이어진 알약을 확인해 주세요", - } - cond = _pick(slot.get("ref")) # 요소 ref = 옛 검색어 묶음(규격 · 지역 칸도 그대로) - if cond is None: # 묶음이 없으면 범위(구분 · 상세구분) + 채운 검색어 - scope = slot.get("scope") or {} - cond = {k: scope[k] for k in ("구분", "상세구분") if scope.get(k)} | {"검색어": ""} - fill = {k: _filled(v, value) for k, v in cond.items() if isinstance(v, str) and _HOLE.search(v)} - cond = {**cond, **fill} if fill else {**cond, "검색어": str(value)} - return _material(cond, str(slot.get("unit") or ""), slot.get("inputs")) - - -def slot_price(slot: dict, value: Any = None, pick: str | None = None) -> dict: - """재료 자리 단가 — 고정 = 품목 · 선택 = 고른 품목(없으면 기본) · 조건 찾기 = 범위 + 규칙. - - slot = Model CfElementRef 꼴 {mode: fixed | choice | rule, ref?, default?, - scope?: {구분?, 상세구분?, 찾는말?}, field?: 규격 | 이름, op?: 포함 | 같음} - 조건 찾기(value = 이어진 알약 값): 하나면 그 단가 · 0 이면 맞는 재료 없음 · 여럿이면 후보 다섯. - """ - mode, inputs = slot.get("mode") or "fixed", slot.get("inputs") - if mode == "fixed": - return _price("재료", str(slot.get("ref") or ""), "", inputs) - if mode == "choice": - ref = pick or slot.get("default") - if not ref: - return {"ok": False, "reason": "고른 품목도 기본 품목도 없음 — 품목을 골라 주세요"} - return _price("재료", str(ref), "", inputs) - if mode != "rule": - return {"ok": False, "reason": f"모르는 재료 방식 「{mode}」"} - field, op, scope = ( - slot.get("field") or "규격", - slot.get("op") or "포함", - slot.get("scope") or {}, - ) - if field not in FIELDS_RULE or op not in OPS_RULE: - return {"ok": False, "reason": f"모르는 찾기 규칙 「{field} {op}」"} - if field == "검색어": - return _search(slot, value) - if value in (None, ""): - return { - "ok": False, - "blank": True, - "reason": "찾을 값이 비어 있음 — 이어진 알약을 확인해 주세요", - } - want = _squash(value) - sub, detail = str(scope.get("구분") or ""), str(scope.get("상세구분") or "") - rows = _found(sub, detail, scope.get("찾는말") or "") - numbers = _numbers() if field == "키" else {} # 키 = 자재 키 또는 품번(원문번호) - - def pool(r: dict) -> list[str]: - got = [r.get("키"), numbers.get(r.get("키"))] if field == "키" else [r.get(field)] - return [_squash(x) for x in got if x] - - hits = [r for r in rows if any(want == x if op == "같음" else want in x for x in pool(r))] - if not hits: - where = " · ".join(x for x in (sub, detail) if x) or "전체" - return {"ok": False, "reason": f"맞는 재료 없음 — {where} 에서 {field}에 「{value}」 {op}"} - if len(hits) > 1: - names = ", ".join(f"{r.get('이름')} {r.get('규격') or ''}".strip() for r in hits[:5]) - return { - "ok": False, - "reason": f"맞는 재료 {len(hits)}개 — 범위나 규칙을 좁혀 주세요({names} …)", - "candidates": [_brief_row(r) for r in hits[:5]], - } - got = _price("재료", str(hits[0].get("키")), "", inputs) - return {**got, "ref": hits[0].get("키"), "name": hits[0].get("이름")} - - GROUP_RULE = ( "인력", "기계", @@ -494,57 +50,13 @@ def _group_rows(group: str) -> list[dict]: ] -def group_find(group: str, slot: dict, value: Any) -> dict: - """인력 · 기계 · 유가전력 조건 찾기 — 알약 값이 이름 · 키(원문번호) 와 같음(포함)인 줄 하나. - - slot = {field?: 이름 | 키, op?: 같음 | 포함, scope?: {찾는말?}, ref?: 「키#칸」 = 칸 이어 씀} - · field 가 없으면 키(원문번호) 또는 이름이 같은 줄 · 하나면 그 값(`one_value`). - """ - if value in (None, ""): - return { - "ok": False, - "blank": True, - "reason": "찾을 값이 비어 있음 — 이어진 알약을 확인해 주세요", - } - field, op, want = slot.get("field"), slot.get("op") or "같음", _squash(value) - words = str((slot.get("scope") or {}).get("찾는말") or "").split() - - def hit(r: dict) -> bool: - hay = _squash(f"{r.get('이름')}{r.get('규격') or ''}") - if not all(_squash(w) in hay for w in words): - return False - keys = [_squash(r.get("키")), _squash(r.get("원문번호"))] - names = [_squash(r.get("이름"))] - pool = keys if field == "키" else names if field == "이름" else keys + names - return any(want == x if op == "같음" else want in x for x in pool if x) - - hits = [r for r in _group_rows(group) if hit(r)] - if len(hits) != 1: - if not hits: - return {"ok": False, "reason": f"맞는 {group} 없음 — 「{value}」"} - names = ", ".join(f"{r.get('이름')} {r.get('규격') or ''}".strip() for r in hits[:5]) - return {"ok": False, "reason": f"맞는 {group} {len(hits)}개 — 좁혀 주세요({names} …)"} - ref = str(hits[0].get("키")) - suffix = str(slot.get("ref") or "").partition(MACHINE_SEP)[2] - got = one_value({"group": group, "ref": f"{ref}{MACHINE_SEP}{suffix}" if suffix else ref, - "unit": slot.get("unit") or ""}) # fmt: skip - return {**got, "ref": ref, "name": hits[0].get("이름")} - - -# ── 단위 · 금액 표준 표 ──────────────────────────────────────────────── -STANDARDS = {"unit": "단위표준.json", "money": "금액단위표준.json"} +# ── 단위 표준 표 ──────────────────────────────────────────────── +STANDARDS = {"unit": "단위표준.json"} def standards(folder: Any, _old: Any = None) -> dict: # _old = 옛 고친 값 폴더(안 씀 · 옛 부름 꼴) - """{unit, money, saved} — 표준 표 파일(`_standard/` · 고치면 바로 그 파일) · saved 늘 False.""" + """{unit, saved} — 표준 표 파일(`_standard/` · 고치면 바로 그 파일) · saved 늘 False.""" out: dict[str, Any] = {"saved": False} for part, name in STANDARDS.items(): out[part] = json.loads((folder / name).read_text(encoding="utf-8")) return out - - -def standards_check(body: dict) -> None: - for part in STANDARDS: - table = body.get(part) - if not isinstance(table, dict) or not isinstance(table.get("줄"), list): - raise store.StoreError(400, f"「{part}」 표 모양이 아님 — 줄 목록이 있어야 함") diff --git a/M02_MasterTemplete/DataFlow/_standard/금액단위표준.json b/M02_MasterTemplete/DataFlow/_standard/금액단위표준.json deleted file mode 100644 index 2d19a5bd8..000000000 --- a/M02_MasterTemplete/DataFlow/_standard/금액단위표준.json +++ /dev/null @@ -1,42 +0,0 @@ -{ - "이름": "금액의 단위표준", - "출처": "산림품셈 1-2-2 2", - "원문": "resources/knowledge/original/원가계산/산림_표준품셈/본문/제01장_적용기준/1-02_설계_및_수량.md", - "줄": [ - { - "종목": "설계서의 총액", - "단위": "원", - "지위": 1000, - "비고": "미만버림", - "원문 줄": 145 - }, - { - "종목": "설계서의 소계", - "단위": "원", - "지위": 1, - "비고": "미만버림", - "원문 줄": 146 - }, - { - "종목": "설계서의 금액란", - "단위": "원", - "지위": 1, - "비고": "미만버림", - "원문 줄": 147 - }, - { - "종목": "일위대가표의 계금", - "단위": "원", - "지위": 1, - "비고": "미만버림", - "원문 줄": 148 - }, - { - "종목": "일위대가표의 금액란", - "단위": "원", - "지위": 0.1, - "비고": "미만버림", - "원문 줄": 149 - } - ] -} diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index ed8324189..c263059c6 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -3,7 +3,7 @@ 기계 줄 = 일위대가 · 단가산출 더한줄의 고정 줄(이음 기계 EQ · 수량 1) — 단가 = 이 값(노 · 재 · 경). 셈 = M01 「건설기계」 장 기계경비 로직 가운데 그 기종을 받는 짝 차례 첫째 (`로직(GC, 기계='원문번호')` · 옵션은 기본값). 짝 차례 · 셈은 -`DataFlow/M02_DF_Values._machine_hourly` 와 같은 규칙(그 폴더는 시험 길이라 따로 둠). +`DataFlow/M02_DF_Values._machine_hourly`(894 에서 걷음)와 같았던 규칙. 마스터 파일은 읽기만 · 로그인 사용자 모두. 기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) · 층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만. diff --git a/resources/tester/test_794_1b_flow_gone.py b/resources/tester/test_794_1b_flow_gone.py index e60b7dd86..8aa8515c8 100644 --- a/resources/tester/test_794_1b_flow_gone.py +++ b/resources/tester/test_794_1b_flow_gone.py @@ -41,7 +41,7 @@ def test_흐름_길은_없고_표준_표는_남음(client: TestClient) -> None: assert client.get("/api/m01/logic/flow", params={"key": "GF000219"}).status_code == 404 assert client.post("/api/m02/df/values", json={"items": []}).status_code == 404 got = client.get("/api/m02/df/standards").json() - assert got["unit"]["줄"] and got["money"]["줄"] + assert got["unit"]["줄"] and "money" not in got # 금액 표준 표는 894 에서 걷음(화면 0) def test_신규_로직은_시트_줄로_자체_GX(client: TestClient) -> None: diff --git a/resources/tester/test_m02_df_values_old.py b/resources/tester/test_m02_df_values_old.py deleted file mode 100644 index 526b21e22..000000000 --- a/resources/tester/test_m02_df_values_old.py +++ /dev/null @@ -1,75 +0,0 @@ -# ruff: noqa: E501 -"""값 찾기(`M02_DF_Values` · 남긴 바닥) = 옛 셈과 같은 뜻 — 마스터 읽기만. - -못박는 것 - - 표 블록 끝 칸 「·범위규칙」 = 줄마다 경계 말(범위규칙 첫 낱말 · 「이하 포함」 이면 맨 윗줄 이상·이하) - - 재료 값이 로직 입력(자재지역 · 계약종별)을 읽음 · 빈 단가 = 알림(blank) — 셈은 계속 - - 재료 조건 찾기 field 검색어 = 옛 검색어 찾기(틀의 {자리} 를 채운 글) -""" - -from __future__ import annotations - -import json - -from M01_MasterData import M01_MasterData_Store as store -from M02_MasterTemplete.DataFlow import M02_DF_Values as dv - - -def _old(key: str) -> dict: - row = store.logic(key)["logic"] - given = {k: str(v) for k, v in store.cm.시험입력(row).items()} - return {"given": given, "got": store.calc(key, given), "row": row} - - -def test_표_범위규칙_칸() -> None: - tables = [ - t - for d in store.loaded()[0].values() - if d.get("그룹") in store.cm.mf.TABLE_GROUPS - for t in d.get("표") or [] - ] - ranged = [t for t in tables if "범위" in (t.get("조건") or {}).values()] - for t in ranged[:40]: - got = dv._table(str(t["키"])) - head, rows = got["rows"][0], got["rows"][1:] - assert head[-1] == dv.RANGE_RULE - first = str(t.get("범위규칙") or "초과·이하").split(" · ")[0].split(" (")[0] - assert {r[-1] for r in rows} <= {first, "이상·이하"}, t["키"] - closed = [ - t - for t in ranged - if str(t.get("범위규칙") or "").startswith("이상·미만") - and "이하 포함" in str(t.get("범위규칙")) - ] - for t in closed[:5]: # 맨 윗줄(위 끝이 가장 큰 줄)만 이상·이하 - words = [r[-1] for r in dv._table(str(t["키"]))["rows"][1:]] - assert "이상·이하" in words and "이상·미만" in words, t["키"] - plain = next(t for t in tables if "범위" not in (t.get("조건") or {}).values()) - assert dv.RANGE_RULE not in dv._table(str(plain["키"]))["rows"][0] - - -def test_재료는_로직_입력을_읽고_빈_단가는_알림() -> None: - old = _old("GC000685") # 모래 — 「지역: 입력」 · 입력 자재지역 - line = next(x for x in old["got"]["lines"] if x["이름"] == "모래") - cond = next(x["요소"] for x in old["row"]["호표"] if x["이름"] == "모래") - assert dv._material(cond, "㎥", old["given"])["value"] == line["단가"] - alone = dv._material(cond, "㎥") - assert alone["ok"] is False and alone["blank"] is True # 입력이 없으면 그 값만 비움 - - -def test_검색어_조건_찾기는_옛_검색어_찾기() -> None: - old = _old("GF000185") # 레미콘 {굵은골재최대치수}-{강도}-{슬럼프} - item = next( - x - for x in old["row"]["호표"] - if isinstance(x["요소"], dict) and "{" in str(x["요소"].get("검색어")) - ) - want = next(x for x in old["got"]["lines"] if x["이름"] == item["이름"])["단가"] - text = store.cm.mf.fill(item["요소"]["검색어"], old["given"]) - slot = {"mode": "rule", "field": "검색어", "op": "같음", "unit": item["단위"], - "scope": {k: item["요소"][k] for k in ("구분", "상세구분") if item["요소"].get(k)}, - "ref": json.dumps(store._dec(item["요소"]), ensure_ascii=False, default=str), "inputs": old["given"]} # fmt: skip - assert dv.slot_price(slot, text)["value"] == want - assert dv.slot_price({**slot, "ref": None}, text)["value"] == want # 묶음 없이 범위 + 검색어 - assert dv._filled("레미콘 {a}-{b}-{c}", "레미콘 25-18-080") == "레미콘 25-18-080" - assert dv._filled("싱글코아바렐 {규격}", "BX") == "싱글코아바렐 BX"