Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
|
||||
|
||||
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
|
||||
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal
|
||||
|
||||
import master_keys as mk
|
||||
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
|
||||
|
||||
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
|
||||
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
|
||||
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
|
||||
TABLE_GROUPS = ("소요량", "계수")
|
||||
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
|
||||
COST_ITEMS = ("노무비", "재료비", "경비")
|
||||
BUNDLE = (*COST_ITEMS, "계")
|
||||
|
||||
|
||||
class FormulaError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class EmptyInput(FormulaError):
|
||||
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
|
||||
|
||||
|
||||
class NoRow(EmptyInput):
|
||||
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
|
||||
|
||||
|
||||
def _plain(v) -> str:
|
||||
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
|
||||
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
|
||||
|
||||
|
||||
# ── 마스터 모음 ────────────────────────────────────────────────────────
|
||||
class Master:
|
||||
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
|
||||
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
|
||||
|
||||
def __init__(self, files: dict[str, dict]):
|
||||
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
|
||||
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
|
||||
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
|
||||
for data in files.values():
|
||||
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
|
||||
for row in rows or []:
|
||||
key = str(row.get("키"))
|
||||
self.index.setdefault(key[:2], {}).setdefault(key, row)
|
||||
if row.get("원문번호"):
|
||||
number = str(row["원문번호"])
|
||||
slot = self.numbers.setdefault(key[:2], {})
|
||||
if number in slot:
|
||||
self.twice.add((key[:2], number))
|
||||
slot.setdefault(number, row)
|
||||
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
|
||||
|
||||
def get(self, ref: str) -> dict:
|
||||
tid, _, number = ref.partition(":")
|
||||
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
|
||||
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
|
||||
elif number:
|
||||
if (tid, number) in self.twice:
|
||||
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
|
||||
row = self.numbers.get(tid, {}).get(number)
|
||||
else:
|
||||
row = self.index.get(ref[:2], {}).get(ref)
|
||||
if row is None:
|
||||
raise FormulaError(f"없는 요소 「{ref}」")
|
||||
return row
|
||||
|
||||
def label(self, ref) -> str:
|
||||
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
|
||||
if isinstance(ref, dict):
|
||||
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
|
||||
try:
|
||||
row = self.get(ref)
|
||||
except FormulaError:
|
||||
return ref
|
||||
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
|
||||
|
||||
def value(self, ref: str):
|
||||
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
|
||||
row = self.get(ref)
|
||||
alias = row.get("준용")
|
||||
if alias not in (None, ""):
|
||||
target = self.get(str(alias))
|
||||
name = target.get("이름") or alias
|
||||
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
|
||||
return row.get("값"), f"추정(준용: {name})"
|
||||
return target.get("값"), f"준용: {name}"
|
||||
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
|
||||
|
||||
def logic(self, ref: str) -> dict:
|
||||
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
|
||||
raise FormulaError(f"로직 아님 「{ref}」")
|
||||
return self.get(ref)
|
||||
|
||||
|
||||
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
|
||||
def _match(table: dict, row: dict, cond: str, want) -> bool:
|
||||
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
|
||||
return True
|
||||
have = row[cond]
|
||||
if table.get("조건", {}).get(cond) == "범위":
|
||||
low, high = have
|
||||
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
|
||||
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
|
||||
if rule == "이상·이하":
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
if rule == "초과·이하":
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·미만":
|
||||
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
|
||||
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
|
||||
closed = any("이하 포함" in x for x in more) and high == top
|
||||
return (low is None or want >= low) and (
|
||||
high is None or want < high or (closed and want == high)
|
||||
)
|
||||
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
|
||||
return have == want
|
||||
|
||||
|
||||
def _name(row: dict) -> str:
|
||||
return f"{row.get('키')} {row.get('원문번호')}"
|
||||
|
||||
|
||||
def find(table: dict, conds: dict, want: str | None = None) -> dict:
|
||||
for cond in conds:
|
||||
if cond not in table.get("조건", {}):
|
||||
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
|
||||
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
|
||||
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
|
||||
for c in conds:
|
||||
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
|
||||
if ups and None not in ups:
|
||||
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
|
||||
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
|
||||
hits = [row for row in hits if want in row]
|
||||
if len(hits) != 1:
|
||||
where = f"표 {table.get('키')}({table.get('원문번호')})"
|
||||
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
|
||||
raise NoRow(
|
||||
f"{where}에 {what} 인 줄이 없음"
|
||||
if not hits
|
||||
else f"{where}에 {what} 인 줄이 {len(hits)}개"
|
||||
)
|
||||
return hits[0]
|
||||
|
||||
|
||||
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
|
||||
from master_material import ( # noqa: E402, F401
|
||||
LINKED,
|
||||
PICK_KEYS,
|
||||
REGION,
|
||||
SLOTS,
|
||||
TARIFF,
|
||||
candidates,
|
||||
check_pick,
|
||||
check_unit,
|
||||
static,
|
||||
cond_text,
|
||||
element,
|
||||
pick,
|
||||
)
|
||||
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
|
||||
@@ -11,7 +11,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import master_doc as md
|
||||
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
|
||||
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
|
||||
import master_keys as mk
|
||||
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
|
||||
|
||||
|
||||
@@ -20,7 +20,7 @@ from pathlib import Path
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
import master_formula as mf
|
||||
import master_base as mf # 바탕 기반(색인 · 오류)
|
||||
import master_machine_crew as mcrew
|
||||
import master_material as mm
|
||||
import master_pick as mp
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import master_doc_calc as mc
|
||||
import master_formula as mf
|
||||
import master_base as mf # 바탕 기반(색인 · 오류)
|
||||
|
||||
|
||||
class Rec:
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
|
||||
`check_master.py` 가 부름.
|
||||
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -12,15 +13,22 @@ import re
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
|
||||
|
||||
import master_keys as mk
|
||||
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
|
||||
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
|
||||
BUNDLE,
|
||||
COST_ITEMS,
|
||||
GROUPS,
|
||||
TABLE_GROUPS,
|
||||
TABLE_IDS,
|
||||
EmptyInput,
|
||||
FormulaError,
|
||||
Master,
|
||||
NoRow,
|
||||
_match,
|
||||
_name,
|
||||
_plain,
|
||||
find,
|
||||
)
|
||||
|
||||
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
|
||||
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
|
||||
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
|
||||
TABLE_GROUPS = ("소요량", "계수")
|
||||
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
|
||||
COST_ITEMS = ("노무비", "재료비", "경비")
|
||||
BUNDLE = (*COST_ITEMS, "계")
|
||||
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
|
||||
_NAME = re.compile(r"[\w가-힣]+")
|
||||
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
|
||||
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
|
||||
raise FormulaError(FLOW_GONE)
|
||||
|
||||
|
||||
class FormulaError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class EmptyInput(FormulaError):
|
||||
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
|
||||
|
||||
|
||||
class NoRow(EmptyInput):
|
||||
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
|
||||
|
||||
|
||||
class Blank:
|
||||
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
|
||||
|
||||
@@ -57,11 +53,6 @@ class Blank:
|
||||
self.why = why
|
||||
|
||||
|
||||
def _plain(v) -> str:
|
||||
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
|
||||
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
|
||||
|
||||
|
||||
# ── 읽기 ──────────────────────────────────────────────────────────────
|
||||
class _Parser:
|
||||
def __init__(self, text: str):
|
||||
@@ -257,70 +248,6 @@ def walk(node):
|
||||
yield from walk(item)
|
||||
|
||||
|
||||
# ── 마스터 모음 ────────────────────────────────────────────────────────
|
||||
class Master:
|
||||
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
|
||||
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
|
||||
|
||||
def __init__(self, files: dict[str, dict]):
|
||||
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
|
||||
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
|
||||
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
|
||||
for data in files.values():
|
||||
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
|
||||
for row in rows or []:
|
||||
key = str(row.get("키"))
|
||||
self.index.setdefault(key[:2], {}).setdefault(key, row)
|
||||
if row.get("원문번호"):
|
||||
number = str(row["원문번호"])
|
||||
slot = self.numbers.setdefault(key[:2], {})
|
||||
if number in slot:
|
||||
self.twice.add((key[:2], number))
|
||||
slot.setdefault(number, row)
|
||||
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
|
||||
|
||||
def get(self, ref: str) -> dict:
|
||||
tid, _, number = ref.partition(":")
|
||||
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
|
||||
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
|
||||
elif number:
|
||||
if (tid, number) in self.twice:
|
||||
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
|
||||
row = self.numbers.get(tid, {}).get(number)
|
||||
else:
|
||||
row = self.index.get(ref[:2], {}).get(ref)
|
||||
if row is None:
|
||||
raise FormulaError(f"없는 요소 「{ref}」")
|
||||
return row
|
||||
|
||||
def label(self, ref) -> str:
|
||||
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
|
||||
if isinstance(ref, dict):
|
||||
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
|
||||
try:
|
||||
row = self.get(ref)
|
||||
except FormulaError:
|
||||
return ref
|
||||
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
|
||||
|
||||
def value(self, ref: str):
|
||||
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
|
||||
row = self.get(ref)
|
||||
alias = row.get("준용")
|
||||
if alias not in (None, ""):
|
||||
target = self.get(str(alias))
|
||||
name = target.get("이름") or alias
|
||||
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
|
||||
return row.get("값"), f"추정(준용: {name})"
|
||||
return target.get("값"), f"준용: {name}"
|
||||
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
|
||||
|
||||
def logic(self, ref: str) -> dict:
|
||||
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
|
||||
raise FormulaError(f"로직 아님 「{ref}」")
|
||||
return self.get(ref)
|
||||
|
||||
|
||||
def fill(template: str, env: dict) -> str:
|
||||
def one(m):
|
||||
if m.group(1) not in env:
|
||||
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
|
||||
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
|
||||
|
||||
|
||||
def _match(table: dict, row: dict, cond: str, want) -> bool:
|
||||
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
|
||||
return True
|
||||
have = row[cond]
|
||||
if table.get("조건", {}).get(cond) == "범위":
|
||||
low, high = have
|
||||
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
|
||||
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
|
||||
if rule == "이상·이하":
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
if rule == "초과·이하":
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·미만":
|
||||
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
|
||||
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
|
||||
closed = any("이하 포함" in x for x in more) and high == top
|
||||
return (low is None or want >= low) and (
|
||||
high is None or want < high or (closed and want == high)
|
||||
)
|
||||
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want > low) and (high is None or want <= high)
|
||||
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
|
||||
return (low is None or want >= low) and (high is None or want <= high)
|
||||
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
|
||||
return have == want
|
||||
|
||||
|
||||
def _name(row: dict) -> str:
|
||||
return f"{row.get('키')} {row.get('원문번호')}"
|
||||
|
||||
|
||||
def find(table: dict, conds: dict, want: str | None = None) -> dict:
|
||||
for cond in conds:
|
||||
if cond not in table.get("조건", {}):
|
||||
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
|
||||
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
|
||||
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
|
||||
for c in conds:
|
||||
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
|
||||
if ups and None not in ups:
|
||||
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
|
||||
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
|
||||
hits = [row for row in hits if want in row]
|
||||
if len(hits) != 1:
|
||||
where = f"표 {table.get('키')}({table.get('원문번호')})"
|
||||
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
|
||||
raise NoRow(
|
||||
f"{where}에 {what} 인 줄이 없음"
|
||||
if not hits
|
||||
else f"{where}에 {what} 인 줄이 {len(hits)}개"
|
||||
)
|
||||
return hits[0]
|
||||
|
||||
|
||||
def evaluate(node, env: dict, master: Master, depth: int = 0):
|
||||
kind = node[0]
|
||||
if kind in ("num", "str"):
|
||||
|
||||
@@ -284,5 +284,5 @@ def element(
|
||||
return min(offers, key=lambda x: x[0]) if offers else (None, None)
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_pick as mp # noqa: E402 — 검색어 찾기
|
||||
|
||||
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
|
||||
return []
|
||||
|
||||
|
||||
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고).
|
||||
② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는
|
||||
남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길.
|
||||
③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
|
||||
③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
|
||||
"""
|
||||
|
||||
import os
|
||||
@@ -13,6 +13,7 @@ from decimal import Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
@@ -132,7 +133,7 @@ def test_사전조합_안_줄도_별도계상_뺌():
|
||||
|
||||
# ── ③ 원문 여럿 ──────────────────────────────────────────────────────
|
||||
def test_원문_출처는_같은_책_절_모두():
|
||||
src = inputs.sources(_whole().logic(MIX))
|
||||
src = inputs.sources(m01_doc.docs()[MIX])
|
||||
assert src == "산림품셈 12-1-2 · 12-1-3"
|
||||
assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src
|
||||
assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"]
|
||||
@@ -143,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로():
|
||||
assert inputs.sources({"출처": None}) is None
|
||||
one = {
|
||||
"출처": "산림품셈 3-1",
|
||||
"호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}],
|
||||
"금액": [
|
||||
{"수량": "1", "출처": "건설품셈 공통 1-2-4 3"},
|
||||
{"수량": "1", "출처": "산림품셈 3-1"},
|
||||
],
|
||||
}
|
||||
assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임
|
||||
|
||||
@@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) ·
|
||||
|
||||
def _rows(key: str) -> list[dict]:
|
||||
whole = m01.loaded()[1]
|
||||
return st._rows_of(whole, whole.logic(key), False)
|
||||
return st._rows_of(whole, m01_doc.docs()[key], False)
|
||||
|
||||
|
||||
def _given(key: str, change: dict) -> dict:
|
||||
|
||||
@@ -1,9 +1,8 @@
|
||||
"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0).
|
||||
"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈).
|
||||
|
||||
거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값.
|
||||
옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ).
|
||||
"""
|
||||
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
@@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2]
|
||||
if str(ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
|
||||
|
||||
mf = m01.cm.mf
|
||||
PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"}
|
||||
|
||||
|
||||
def _plain(row: dict) -> bool:
|
||||
"""로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음."""
|
||||
return (
|
||||
str(row.get("결과단위") or "").startswith("원")
|
||||
and not row.get("덧줄")
|
||||
and not row.get("끝수")
|
||||
and not any(i.get("종류") == "로직" for i in row.get("호표") or [])
|
||||
and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or [])
|
||||
)
|
||||
|
||||
|
||||
def test_줄마다_버림_비목마다_버림_B09와_같음():
|
||||
files, whole = m01.loaded()
|
||||
checked = 0
|
||||
for _, data in m01._logic_files(files):
|
||||
for row in data.get("줄") or []:
|
||||
if not _plain(row) or checked >= 60:
|
||||
continue
|
||||
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
|
||||
given = mf.fill_empty(row, base)
|
||||
got = mf.run(whole, row["키"], given)
|
||||
lines = []
|
||||
for line in got["줄"]:
|
||||
one = dict.fromkeys(PART_OF.values(), 0.0)
|
||||
for part, money in line["비목"].items():
|
||||
one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None
|
||||
lines.append(one)
|
||||
if any(v is None for one in lines for v in one.values()):
|
||||
continue
|
||||
want = sg.block_totals(lines)
|
||||
mine = st.settle(whole, row["키"], given)
|
||||
for name, part in PART_OF.items():
|
||||
assert float(mine[name]) == want[part], (row["키"], name)
|
||||
assert float(mine["계"]) == want["sum"], row["키"]
|
||||
checked += 1
|
||||
assert checked >= 30
|
||||
|
||||
|
||||
def test_계산서_줄_소계_계가_맞물림():
|
||||
files, whole = m01.loaded()
|
||||
|
||||
@@ -15,6 +15,7 @@ from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01_doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
@@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄():
|
||||
whole = m01.loaded()[1]
|
||||
rows = []
|
||||
for key in (GF, "GC000269", "GC001109"):
|
||||
rows += standard._rows_of(whole, whole.logic(key), False)
|
||||
rows += standard._rows_of(whole, m01_doc.docs()[key], False)
|
||||
assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕
|
||||
got = _heads(rows)
|
||||
assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"]
|
||||
|
||||
@@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()):
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
|
||||
files, live = m01.loaded()
|
||||
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
|
||||
fake = copy.copy(
|
||||
live
|
||||
) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ)
|
||||
fake.index = {t: dict(v) for t, v in live.index.items()}
|
||||
fake.numbers = {t: dict(v) for t, v in live.numbers.items()}
|
||||
for row in rows:
|
||||
row, key = copy.deepcopy(row), str(row["키"])
|
||||
fake.index.setdefault(key[:2], {})[key] = row
|
||||
if row.get("원문번호"):
|
||||
fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row
|
||||
for key in drop:
|
||||
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
|
||||
fake.index.get(key[:2], {}).pop(key, None)
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
|
||||
docs = {k: v for k, v in dc.folder().items() if k not in drop}
|
||||
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
|
||||
@@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
got = skc.held(_doc(me, key))
|
||||
assert PCT in {r["키"] for r in got["로직"]}
|
||||
assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ)
|
||||
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
|
||||
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
|
||||
first = _calc(me, _doc(me, key))
|
||||
@@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch):
|
||||
|
||||
|
||||
def test_deleted_keys_keep_last_value(world, monkeypatch):
|
||||
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
|
||||
"""⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409)."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
was = _sum(me, key)
|
||||
lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB"))
|
||||
_fake(monkeypatch, drop=[PCT, lb])
|
||||
with pytest.raises(Exception):
|
||||
m01.loaded()[1].logic(PCT)
|
||||
_fake(monkeypatch, drop=[lb])
|
||||
now = _calc(me, _doc(me, key))
|
||||
assert now["기준"]["계"] == was
|
||||
assert {PCT, lb} <= set(now["사본"]["지운키"])
|
||||
assert {lb} <= set(now["사본"]["지운키"])
|
||||
with store.at(me):
|
||||
got = path.preview(key, {"할일": skc.PRICE})
|
||||
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
|
||||
|
||||
@@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈():
|
||||
whole = m01.loaded()[1]
|
||||
docs, links, _ = world()
|
||||
for key in ("GF000220", "GC000404", "GX000004"):
|
||||
for row in st._rows_of(whole, whole.logic(key), False, links):
|
||||
for row in st._rows_of(whole, docs[key], False, links):
|
||||
given = st._given(whole, docs[key], row["바꿈"])[0]
|
||||
want = mc.calc(docs[key], links, given)
|
||||
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
|
||||
|
||||
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
|
||||
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
|
||||
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[1]
|
||||
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
|
||||
N = 24 # 견본 로직 수(키 차례 고르게)
|
||||
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
|
||||
"master_formula",
|
||||
"master_formula_check",
|
||||
"master_formula_sum",
|
||||
"master_cut",
|
||||
"master_text",
|
||||
"master_text_item",
|
||||
"master_auto",
|
||||
"master_combo",
|
||||
"master_sheet_line",
|
||||
"master_gate",
|
||||
"master_equation",
|
||||
"check_master",
|
||||
)
|
||||
|
||||
|
||||
def _enc(v):
|
||||
if isinstance(v, Decimal):
|
||||
return {"$d": str(v)}
|
||||
raise TypeError(type(v).__name__)
|
||||
|
||||
|
||||
def _dec(d: dict):
|
||||
return Decimal(d["$d"]) if set(d) == {"$d"} else d
|
||||
|
||||
|
||||
def _child() -> None:
|
||||
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
|
||||
sys.path.insert(0, str(SCRIPTS))
|
||||
import master_base as mb
|
||||
import master_doc_calc as mc
|
||||
import master_doc_link as ml
|
||||
import master_machine_files as mmf
|
||||
|
||||
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
|
||||
files = {}
|
||||
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
|
||||
if name == mmf.NAME and mmf.here(folder):
|
||||
files[name] = mmf.table(folder)[0]
|
||||
elif not name.startswith("_"):
|
||||
raw = (folder / name).read_bytes()
|
||||
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
|
||||
docs = ml.load_all()
|
||||
links = ml.Links(mb.Master(files), docs)
|
||||
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
|
||||
out = {}
|
||||
for key, cases in want.items():
|
||||
rows = []
|
||||
for label, changed in cases:
|
||||
try:
|
||||
got = mc.calc(docs[key], links, changed)
|
||||
except Exception:
|
||||
got = None
|
||||
rows.append([label, got if got and got.get("셈됨") else None])
|
||||
out[key] = rows
|
||||
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
|
||||
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
|
||||
|
||||
|
||||
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
|
||||
import helper_855_engine as h
|
||||
from helper_test_all import spread
|
||||
|
||||
rows, _, docs, _ = h.world()
|
||||
rows = spread([r for r in rows if str(r["키"]) in docs], N)
|
||||
want = {
|
||||
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
|
||||
}
|
||||
run = subprocess.run(
|
||||
[sys.executable, str(Path(__file__)), "--child"],
|
||||
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
|
||||
capture_output=True,
|
||||
cwd=str(ROOT),
|
||||
timeout=600,
|
||||
)
|
||||
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
|
||||
body = json.loads(run.stdout.decode("utf-8"))
|
||||
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
|
||||
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
|
||||
diff = []
|
||||
for key, cases in body["답"].items():
|
||||
got = [[label, h.answer(g)] for label, g in cases]
|
||||
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
|
||||
diff.append(key)
|
||||
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
|
||||
|
||||
|
||||
if __name__ == "__main__" and "--child" in sys.argv:
|
||||
_child()
|
||||
@@ -0,0 +1,50 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 ·
|
||||
일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌).
|
||||
|
||||
임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
from decimal import Decimal
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from resources.tester.test_795_1_sk_copy import _doc, _sk
|
||||
from resources.tester.test_795_2_sc_copy import PCT, _read, _sc
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
|
||||
def _logic_rows(doc: dict) -> list[str]:
|
||||
rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])]
|
||||
return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC]
|
||||
|
||||
|
||||
def _sum(folder, doc) -> Decimal:
|
||||
with store.at(folder):
|
||||
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
|
||||
|
||||
|
||||
def test_저장본에_로직줄_없음_금액_같음(world):
|
||||
me = world["personal"]
|
||||
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
|
||||
sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}]))
|
||||
assert _logic_rows(sk) == [] and PCT in _logic_rows(sc)
|
||||
assert _sum(me, sk) > 0
|
||||
|
||||
|
||||
def test_옛_저장본_로직줄은_안_읽음(world):
|
||||
me = world["personal"]
|
||||
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
|
||||
was = _sum(me, sk)
|
||||
old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것)
|
||||
row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str))
|
||||
row["호표"] = row["호표"][:1]
|
||||
old["수식"]["로직"] = [*old["수식"]["로직"], row]
|
||||
assert skc.held(old)["로직"] == skc.held(sk)["로직"]
|
||||
assert _sum(me, old) == was
|
||||
Reference in New Issue
Block a user