Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -5,6 +5,7 @@
|
||||
- 셈 = `scripts/master_doc_calc.py` ↔ `common_util/common_util_formula_doc_calc.ts`(짝)
|
||||
- 풀이 · 글 · 검사 = `scripts/master_doc.py` ↔ `common_util/common_util_formula_doc.ts`(짝)
|
||||
- 표 찾기 · M01 연결 풀이 = `scripts/master_doc_link.py` ↔ `common_util/common_util_formula_doc_table.ts`(표 찾기 짝)
|
||||
- 셈 기록(줄마다 부른 자원 · 하위 문서 · 고른 품목 · 서버 단독) = `scripts/master_doc_trace.py`(B08 · B09 가 답을 갈라 합산)
|
||||
- 옛 로직 변환 = `scripts/master_doc_convert.py` · 빌더 `scripts/build_수식문서_802_2.py`(`--check`)
|
||||
- 거울 · 꼴 시험 = `resources/tester/test_802_1_formula_doc.py` · 변환 대조 = `test_802_2_convert.py`
|
||||
|
||||
|
||||
@@ -81,6 +81,23 @@ def new_answer(links, doc: dict, given: dict | None = None):
|
||||
return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS}
|
||||
|
||||
|
||||
def cases_of(whole, row: dict) -> list[tuple]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩."""
|
||||
base = meq.given_of(whole, row)
|
||||
cases = [("", base, None)]
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return cases
|
||||
|
||||
|
||||
def agree(old, new) -> bool:
|
||||
"""대조 같음 — 같은 값 · 둘 다 못 셈."""
|
||||
return old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
|
||||
|
||||
def _text(v) -> str:
|
||||
if isinstance(v, str):
|
||||
return v
|
||||
@@ -137,17 +154,11 @@ def build(log=print) -> dict:
|
||||
links = ml.Links(whole, docs)
|
||||
runs, both_out = [], 0
|
||||
for _, row in items:
|
||||
key, base = str(row["키"]), meq.given_of(whole, row)
|
||||
cases = [("", base, None)] # (옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
for label, given, changed in cases:
|
||||
key = str(row["키"])
|
||||
for label, given, changed in cases_of(whole, row):
|
||||
old = old_answer(whole, row, given)
|
||||
new = new_answer(links, docs[key], changed)
|
||||
same = old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
same = agree(old, new)
|
||||
both_out += isinstance(old, str) and isinstance(new, str)
|
||||
runs.append(
|
||||
{
|
||||
|
||||
@@ -275,6 +275,8 @@ class _Run:
|
||||
for k in ("칸", "단위"):
|
||||
if link.get(k):
|
||||
payload[k] = link[k]
|
||||
if hasattr(self.links, "at"): # 855-F 셈 기록(`master_doc_trace`) — 기록 안 켬 = 안 탐
|
||||
self.links.at(self.stack, name, kind, payload)
|
||||
try:
|
||||
if kind == "요소":
|
||||
return number(self.links.element(payload))
|
||||
@@ -407,6 +409,8 @@ def _money(run: _Run, doc: dict, rules: dict):
|
||||
for i, line in enumerate(lines):
|
||||
scope = _scope(doc, outs, dict(running), cover, syms)
|
||||
where = str(line.get("이름") or f"금액 {i + 1}")
|
||||
if hasattr(run.links, "at"): # 855-F 셈 기록 — 이 줄 읽음(시간당 작업량)
|
||||
run.links.at(run.stack, i, "금액", {})
|
||||
swapped, more, work = mw.line_work(run, line, scope) # 846-1 시간당 작업량
|
||||
text = line.get("수량") if swapped is None else swapped
|
||||
qty = (
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
@@ -24,7 +25,9 @@ import master_machine_crew as mcrew
|
||||
import master_material as mm
|
||||
import master_pick as mp
|
||||
|
||||
FOLDER = Path(__file__).resolve().parents[1] / "수식문서"
|
||||
# 화면 저장 시험 사본(`AISLO_MASTER_DIR` — `M01_MasterData_Store.FOLDER` 와 같이) · 없으면 정본
|
||||
_HOME = os.environ.get("AISLO_MASTER_DIR") or Path(__file__).resolve().parents[1]
|
||||
FOLDER = Path(_HOME).resolve() / "수식문서"
|
||||
_ARITH_OK = ("num", "bin", "neg")
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,327 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""단가산출 수식 문서 셈 답 → 산출근거 글(PLAN 855-C 2-C4 · 서버 풀이 글) — 셈 안 함(답만 읽음).
|
||||
|
||||
쓰는 곳 = M02 기준 목록 계산서(`M02_Logic_Standard.sheet`) · (뒤에) B09 산출근거(855 보충 B9-4).
|
||||
⚠ 짝(글 규칙) — 한쪽을 고치면 다른 쪽도 · 거울 시험 `resources/tester/test_855_c4_doc_text.py`:
|
||||
`A00_Common/line_stack_out.ts`(금액 줄 · 계 줄 꼴 · 수 꼴 `one` · `won` · 비목 이름) ·
|
||||
`ui_template/ui_template_equation.ts`(`eqText`) ·
|
||||
`common_util/common_util_line_stack_unit.ts`(`unitText` · `isAtom` · `moneyUnits`) ·
|
||||
`common_util/common_util_formula_doc_view.ts`(`offLine` — 선택으로 꺼진 줄).
|
||||
금액 줄 = 「이름 : 단가 원/단위 × 수량 단위 = 금액 원」 · 묶음 줄 = 비목마다 「노무비 : …」 ·
|
||||
계 = 「노무비 : 줄 + 줄 = 금액 원」 · 「합계 : 금액 원」.
|
||||
수 꼴 = 화면과 같음 — 단가 · 수량 = `eqText`(소수 여섯 자리까지 · 셈 값 그대로) ·
|
||||
줄 금액 = 소수 한 자리 · 비목 · 합계 = 원(셈 답의 끝수 그대로 · 여기서 자르지 않음).
|
||||
옮기지 않은 것(화면만) — 식 조판(KaTeX · 수량 식은 값 하나로) · 공식 줄 · 펼침 ·
|
||||
작업량 줄(846-2) · 굳은 기계 이름(847-1) · 비목곱 인수 글(848-7 · 금액은 답 그대로) ·
|
||||
계 덧셈 항 = 줄 금액(화면은 묶음 줄 있는 항목 · 항이 넷 넘으면 항목 소계 — 여기는 금액만).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import ROUND_FLOOR, ROUND_HALF_UP, Decimal, InvalidOperation
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
|
||||
COSTS = md.COSTS # 노무비 · 재료비 · 경비
|
||||
COST_SHOW = {"노무비": "노무비", "재료비": "재료비", "경비": "경 비"}
|
||||
AMOUNT_UNIT = "원"
|
||||
LONG_SUM = 4
|
||||
_HIDE = ("반올림", "올림", "버림")
|
||||
_SAME = (("일", "인"), ("㎏", "kg"), ("ℓ", "L"))
|
||||
|
||||
|
||||
# ── 수 꼴 ─────────────────────────────────────────────────────────────
|
||||
def _dec(v) -> Decimal | None:
|
||||
if isinstance(v, bool) or v is None:
|
||||
return None
|
||||
try:
|
||||
d = Decimal(str(v)) if not isinstance(v, Decimal) else v
|
||||
except InvalidOperation:
|
||||
return None
|
||||
return d if d.is_finite() else None
|
||||
|
||||
|
||||
def _group(d: Decimal, places: int, keep: bool) -> str:
|
||||
q = d.quantize(Decimal(1).scaleb(-places), ROUND_HALF_UP)
|
||||
sign = "-" if q.is_signed() else "" # Intl 과 같음 — 0 으로 반올림된 음수 = 「-0」
|
||||
whole, _, frac = f"{abs(q):f}".partition(".")
|
||||
frac = frac if keep else frac.rstrip("0")
|
||||
head = f"{int(whole):,}"
|
||||
return f"{sign}{head}.{frac}" if frac else f"{sign}{head}"
|
||||
|
||||
|
||||
def eq_text(v) -> str:
|
||||
"""`eqText` — 수 = 천 단위 쉼표 · 소수 여섯 자리까지(반올림 · 끝 0 뗌) · 그 밖 = 글 그대로."""
|
||||
if v is None or v == "":
|
||||
return ""
|
||||
if isinstance(v, bool):
|
||||
return "true" if v else "false"
|
||||
d = _dec(v)
|
||||
if d is None or (isinstance(v, str) and not v.strip()):
|
||||
return str(v)
|
||||
return _group(d, 6, False)
|
||||
|
||||
|
||||
def one(v) -> str:
|
||||
"""줄 금액 — 소수 한 자리 꼭(「26,890.8」 · 「0.0」)."""
|
||||
return _group(_dec(v) or Decimal(0), 1, True)
|
||||
|
||||
|
||||
def won(v) -> str:
|
||||
"""비목 · 합계 — 원(JS `Math.round` = 0.5 올림)."""
|
||||
d = _dec(v) or Decimal(0)
|
||||
r = (d + Decimal("0.5")).to_integral_value(ROUND_FLOOR)
|
||||
return eq_text(Decimal("-0") if r == 0 and d.is_signed() else r) # JS Math.round(-0.4) = -0
|
||||
|
||||
|
||||
# ── 단위 ─────────────────────────────────────────────────────────────
|
||||
def unit_text(u) -> str:
|
||||
"""자료 단위 글 → 화면 단위(메타 단위 = 빈 글)."""
|
||||
s = str(u if u is not None else "").strip()
|
||||
if not s or re.search(r"따름|원문 단위 없음", s) or re.match(r"^수(\(| 또는|$)", s):
|
||||
return ""
|
||||
s = re.sub(r"^%\(.*\)$", "%", s)
|
||||
return s.replace("10^-7", "10⁻⁷").replace("kWh", "㎾h")
|
||||
|
||||
|
||||
def _same(a: str, b: str) -> bool:
|
||||
return a == b or any((a == x and b == y) or (a == y and b == x) for x, y in _SAME)
|
||||
|
||||
|
||||
def is_atom(n) -> bool:
|
||||
"""한 덩이(기호 · 수 · 칸 · 글 — 반올림 · 올림 · 버림 감싸개 안 한 덩이 포함)."""
|
||||
if not n:
|
||||
return False
|
||||
if n[0] == "call" and n[1] in _HIDE and 1 <= len(n[2]) <= 2:
|
||||
return is_atom(n[2][0])
|
||||
return n[0] in ("var", "num", "field", "str")
|
||||
|
||||
|
||||
def node_of(text):
|
||||
if text is None or str(text).strip() == "":
|
||||
return None
|
||||
try:
|
||||
return md.parse(text)
|
||||
except md.DocError:
|
||||
return None
|
||||
|
||||
|
||||
def money_units(
|
||||
line: dict, price, qty, price_var: dict | None = None, sub: dict | None = None
|
||||
) -> dict:
|
||||
"""금액 줄 단위 자리 `{price, qty, wrap}` — 수량이 식이면 괄호 ·
|
||||
단가 분모가 수량 단위와 같은 뜻이면 수량 단위 글."""
|
||||
has = line.get("수량") not in (None, "")
|
||||
q = unit_text(line.get("단위")) if has else ""
|
||||
wrap = bool(q) and bool(qty) and not is_atom(qty)
|
||||
own = next(
|
||||
(
|
||||
u
|
||||
for u in (
|
||||
unit_text((sub or {}).get("결과단위")),
|
||||
unit_text((price_var or {}).get("단위")),
|
||||
)
|
||||
if u.startswith("원")
|
||||
), # fmt: skip
|
||||
None,
|
||||
)
|
||||
mine = f"{AMOUNT_UNIT}/{q}" if own and q and _same(own[2:], q) else own
|
||||
fallback = f"{AMOUNT_UNIT}/{q}" if q else ""
|
||||
price_unit = (mine if mine is not None else fallback) if has and is_atom(price) else ""
|
||||
return {"price": price_unit, "qty": q, "wrap": wrap}
|
||||
|
||||
|
||||
def price_sym(line: dict) -> str | None:
|
||||
n = node_of(line.get("단가"))
|
||||
if not n:
|
||||
return None
|
||||
if n[0] == "var":
|
||||
return n[1]
|
||||
if n[0] == "field" and n[1][0] == "var":
|
||||
return n[1][1]
|
||||
return None
|
||||
|
||||
|
||||
def line_name(line: dict) -> str:
|
||||
"""이름에 규격이 들면 한 번만(814-1)."""
|
||||
name, spec = str(line.get("이름") or ""), line.get("규격")
|
||||
return f"{name} {spec}".strip() if spec and spec not in name else name
|
||||
|
||||
|
||||
# ── 선택으로 꺼진 줄(`offLine`) ───────────────────────────────────────
|
||||
class _Look:
|
||||
"""셈 답 값으로 조건만 읽음 — 계산기 한 벌(`master_doc_calc._Run.ev`) · 값은 답에서 채움."""
|
||||
|
||||
def __init__(self, doc: dict, answer: dict, links):
|
||||
self.run = mc._Run(doc, links, None, (), {})
|
||||
got = answer.get("값") or {}
|
||||
names = {md.var_id(v) for v in doc.get("변수") or []}
|
||||
names |= {str(x.get("기호") or "") for x in doc.get("식") or []}
|
||||
for name in names: # 답에 없는 값 = 모름(다시 셈하지 않음 · 화면 `evalNode` 와 같음)
|
||||
have = got.get(name)
|
||||
self.run.values[name] = mc.Blank("모름") if have is None else have
|
||||
self.lines = {str(x.get("기호") or ""): x.get("식") for x in doc.get("식") or []}
|
||||
|
||||
def value(self, n):
|
||||
try:
|
||||
v = self.run.ev(n, None, "")
|
||||
except Exception: # noqa: BLE001 — 그림용 값 · 모르면 없음
|
||||
return None
|
||||
return None if isinstance(v, (mc.Blank, mc.Stop)) else v
|
||||
|
||||
def taken(self, n) -> int:
|
||||
if not (n and n[0] == "call" and n[1] == "만약" and len(n[2]) == 3):
|
||||
return 0
|
||||
t = self.value(n[2][0])
|
||||
return 0 if t is None else (1 if t else 2)
|
||||
|
||||
def off_zero(self, n, path: frozenset = frozenset()) -> bool:
|
||||
if not n:
|
||||
return False
|
||||
at, hop = n, 0
|
||||
while pick := self.taken(at):
|
||||
at, hop = at[2][pick], hop + 1
|
||||
if hop and at[0] == "num":
|
||||
return at[1] == 0
|
||||
kind = at[0]
|
||||
if kind == "var":
|
||||
name = at[1]
|
||||
if name not in self.lines or name in path:
|
||||
return False
|
||||
return self.off_zero(node_of(self.lines[name]), path | {name})
|
||||
if kind in ("neg", "pct"):
|
||||
return self.off_zero(at[1], path)
|
||||
if kind == "bin":
|
||||
if at[1] == "*":
|
||||
return self.off_zero(at[2], path) or self.off_zero(at[3], path)
|
||||
if at[1] == "/":
|
||||
return self.off_zero(at[2], path)
|
||||
if at[1] in ("+", "-"):
|
||||
return self.off_zero(at[2], path) and self.off_zero(at[3], path)
|
||||
return False
|
||||
|
||||
def off_line(self, line: dict) -> bool:
|
||||
return any(self.off_zero(node_of(line.get(k))) for k in ("수량", "단가"))
|
||||
|
||||
|
||||
# ── 줄 글 ────────────────────────────────────────────────────────────
|
||||
def _num(v) -> Decimal | None:
|
||||
return _dec(v)
|
||||
|
||||
|
||||
def _u(text: str, unit: str) -> str:
|
||||
return f"{text} {unit}" if unit else text
|
||||
|
||||
|
||||
def money_lines(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""금액 줄마다 산출근거 조각 `{i, 이름, 비목, 단가, 수량, 금액, 단위, 글, 꺼짐, 합밖, 까닭?}` ·
|
||||
묶음 줄 = 비목마다 한 조각(`비목` = 노무비 · 재료비 · 경비 · `묶음줄` 참)."""
|
||||
look = _Look(doc, answer, links)
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
rows = answer.get("줄") or []
|
||||
out: list[dict] = []
|
||||
for i, line in enumerate(doc.get("금액") or []):
|
||||
got = rows[i] if i < len(rows) else {}
|
||||
name = line_name(line)
|
||||
ps = price_sym(line)
|
||||
pv = vars_.get(ps) if ps else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
try:
|
||||
sub = links.doc(str(link["키"]))
|
||||
except Exception: # noqa: BLE001 — 못 읽는 부름 = 단위 없이
|
||||
sub = None
|
||||
mu = money_units(line, node_of(line.get("단가")), node_of(line.get("수량")), pv, sub)
|
||||
qty = got.get("수량")
|
||||
base = {
|
||||
"i": i,
|
||||
"이름": name,
|
||||
"수량": _num(qty),
|
||||
"단위": mu,
|
||||
"꺼짐": look.off_line(line),
|
||||
"합밖": bool(got.get("합밖")),
|
||||
"묶음": line.get("묶음") or "",
|
||||
}
|
||||
tail = "" if qty is None else " × " + _u(eq_text(qty), mu["qty"])
|
||||
if got.get("까닭") and got.get("금액") is None:
|
||||
why = got["까닭"]
|
||||
out.append({**base, "비목": line.get("비목"), "단가": None, "금액": None, "까닭": why,
|
||||
"글": f"{name} : — {why}"}) # fmt: skip
|
||||
continue
|
||||
if line.get("비목") == "묶음":
|
||||
bundle = got.get("단가") if isinstance(got.get("단가"), dict) else {}
|
||||
for c in COSTS:
|
||||
part = (got.get("비목") or {}).get(c)
|
||||
if _dec(part) is None or (not part and not bundle.get(c)):
|
||||
continue
|
||||
price = _u(eq_text(bundle.get(c)), mu["price"])
|
||||
text = f"{COST_SHOW[c]} : {price}{tail} = {one(part)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": c, "묶음줄": True, "단가": _num(bundle.get(c)),
|
||||
"금액": _num(part), "글": text}) # fmt: skip
|
||||
continue
|
||||
amt, price = got.get("금액"), got.get("단가")
|
||||
text = f"{name} : {_u(eq_text(price), mu['price'])}{tail} = {one(amt or 0)} {AMOUNT_UNIT}"
|
||||
out.append({**base, "비목": line.get("비목"), "단가": _num(price), "금액": _num(amt),
|
||||
"글": text}) # fmt: skip
|
||||
return out
|
||||
|
||||
|
||||
def total_lines(answer: dict, lines: list[dict]) -> list[str]:
|
||||
"""계 줄 — 비목마다 「노무비 : 줄 + 줄 = 금액 원」(항이 넷 넘으면 금액만) ·
|
||||
「합계 : 금액 원」."""
|
||||
out = []
|
||||
for c in COSTS:
|
||||
terms = [
|
||||
x["금액"]
|
||||
for x in lines
|
||||
if x.get("비목") == c and not x["합밖"] and not x["꺼짐"] and x.get("금액")
|
||||
]
|
||||
v = answer.get(c)
|
||||
if _dec(v) is None:
|
||||
body = "—"
|
||||
elif 1 < len(terms) <= LONG_SUM:
|
||||
body = f"{' + '.join(one(t) for t in terms)} = {won(v)}"
|
||||
else:
|
||||
body = won(v) if terms or v else ""
|
||||
unit = f" {AMOUNT_UNIT}" if _dec(v) is not None and body else ""
|
||||
out.append(f"{COST_SHOW[c]} : {body}{unit}")
|
||||
total = answer.get("계")
|
||||
out.append(f"합계 : {_u(won(total), AMOUNT_UNIT) if _dec(total) is not None else '—'}")
|
||||
return out
|
||||
|
||||
|
||||
def sheet_groups(doc: dict, answer: dict, links) -> list[dict]:
|
||||
"""공용 계산서(`A00_Common/calc_sheet.ts`) 묶음 — 비목마다 줄
|
||||
`{이름, 글 「단가 * 수량 = 금액」, 금액, 묶음, 장비, 옵션꺼짐}` ·
|
||||
소계 = 셈 답 비목 값(끝수 뒤) ·
|
||||
합 밖 줄 · 비목 없는 줄 = 뺌."""
|
||||
groups: dict[str, list] = {c: [] for c in COSTS}
|
||||
for x in money_lines(doc, answer, links):
|
||||
c = x.get("비목")
|
||||
if c not in groups or x["합밖"]:
|
||||
continue
|
||||
mu = x["단위"]
|
||||
if x.get("까닭"):
|
||||
text = f"— {x['까닭']}"
|
||||
else:
|
||||
price = "—" if x["단가"] is None else _u(eq_text(x["단가"]), mu["price"])
|
||||
qty = "" if x["수량"] is None else " * " + _u(eq_text(x["수량"]), mu["qty"])
|
||||
text = f"{price}{qty} = {one(x['금액'] or 0)}"
|
||||
groups[c].append(
|
||||
{
|
||||
"이름": x["이름"],
|
||||
"글": text,
|
||||
"금액": x["금액"],
|
||||
"묶음": x["묶음"] or None,
|
||||
"장비": bool(x.get("묶음줄")) or None,
|
||||
"옵션꺼짐": x["꺼짐"] or None,
|
||||
}
|
||||
)
|
||||
return [
|
||||
{"비목": c, "소계": _num(answer.get(c)), "끝수": "", "줄": groups[c]}
|
||||
for c in COSTS
|
||||
if groups[c] or _dec(answer.get(c))
|
||||
]
|
||||
@@ -0,0 +1,175 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""수식 문서 셈 기록 — 줄마다 부른 것(PLAN 855-F B9-1 · 설계 855 보충 1-3).
|
||||
|
||||
서버 단독(TS 짝 없음) — B08 · B09 가 문서 셈 답을 갈라 합산할 때 「이 줄이 어느 노임 · 자재 ·
|
||||
기계 · 표 · 하위 단가산출을 불렀나」 를 읽음. 셈은 그대로: `Trace` = `master_doc_link.Links` +
|
||||
기록 · `master_doc_calc` 의 훅(`links.at`)이 연결마다 알림 — `Links` 에는 `at` 이 없어 기록을 안
|
||||
켜면 지금 길 그대로.
|
||||
|
||||
`calc(doc, Trace(master, docs), given)` → 셈 답 +
|
||||
- `부름` = 연결 부른 차례 [{문서, 깊이, 이름, 갈래(요소 · 표 · 단가산출), 부름(넘긴 꼴 — 키 · 표 ·
|
||||
조건 · 입력 · 재료 …), 자원[{키, 갈래(인력 · 재료 · 기계 · 표)}], 품목?(고른 재료 키) ·
|
||||
기계?(기계경비 부름 = 결과단위 원/시간 돈 문서의 기계 키)}] —
|
||||
하위 문서 안 부름도 깊이를 달고 같이(같은 하위 · 같은 입력 두 번째는 셈 답을 다시 씀 = 안 적음)
|
||||
- `줄[i].부름` = 그 금액 줄 식(수량 · 단가 · 비목곱)이 닿는 이름의 맨 위 부름 차례 번호 + 그 줄
|
||||
셈 중 읽음(갈래 「금액」 · 이름 = 줄 차례 · 시간당 작업량 기계 칸)
|
||||
- `자원` = 문서 전체(하위 포함) 자원 키 차례 · 겹침 없음(표 빼고 · 단가 책 수요)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
import re
|
||||
import types
|
||||
from itertools import takewhile
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_calc as mc
|
||||
import master_doc_link as ml
|
||||
|
||||
CAT = {"LB": "인력", "MT": "재료", "MO": "재료", "EQ": "기계"} # `master_equation_view.CAT` 같은 말
|
||||
_SLOTS = ("키", "표", "칸", "단위", "재료", "조건", "입력", "지역", "계약종별")
|
||||
|
||||
|
||||
class _Seen:
|
||||
"""마스터 감쌈 — `get` 이 돌려준 줄을 알림 ·
|
||||
마스터 메서드도 이 감쌈에 묶어 안쪽 `self.get` 까지 잡음."""
|
||||
|
||||
def __init__(self, master, note):
|
||||
self._m, self._note = master, note
|
||||
|
||||
def get(self, ref):
|
||||
row = self._m.get(ref)
|
||||
self._note(row)
|
||||
return row
|
||||
|
||||
def __setattr__(self, name, value): # 마스터 칸(찾기 색인 `_found` 등)은 마스터에
|
||||
if name in ("_m", "_note"):
|
||||
object.__setattr__(self, name, value)
|
||||
else:
|
||||
setattr(self._m, name, value)
|
||||
|
||||
def __getattr__(self, name):
|
||||
raw = inspect.getattr_static(self._m, name)
|
||||
if isinstance(raw, types.FunctionType):
|
||||
return raw.__get__(self)
|
||||
return getattr(self._m, name)
|
||||
|
||||
|
||||
class Trace(ml.Links):
|
||||
"""기록 켠 연결 — `calls` 에 부른 차례대로 쌓임(여러 문서 셈에 다시 써도 됨)."""
|
||||
|
||||
def __init__(self, master, docs: dict[str, dict] | None = None):
|
||||
super().__init__(_Seen(master, self._note), docs)
|
||||
self.calls: list[dict] = []
|
||||
self._now: dict | None = None
|
||||
self._last: str | None = None
|
||||
|
||||
def at(
|
||||
self, stack: tuple, name, kind: str, payload: dict
|
||||
) -> None: # 셈 훅(이름 | 금액 줄 차례)
|
||||
self._now = {
|
||||
"문서": stack[-1] if stack else "",
|
||||
"깊이": len(stack),
|
||||
"이름": name,
|
||||
"갈래": kind,
|
||||
"부름": {k: payload[k] for k in _SLOTS if k in payload},
|
||||
"자원": [],
|
||||
}
|
||||
self.calls.append(self._now)
|
||||
|
||||
def _note(self, row: dict) -> None:
|
||||
key = self._last = str(row.get("키") or "")
|
||||
kind = CAT.get(key[:2]) or ("표" if "줄" in row and "조건" in row else None)
|
||||
if not kind:
|
||||
return
|
||||
if self._now is None: # 연결 밖 부름(이름 없는 기계 줄 읽기) — 이름 빈 기록
|
||||
self.at((), "", "", {})
|
||||
got = self._now["자원"]
|
||||
if not any(x["키"] == key for x in got):
|
||||
got.append({"키": key, "갈래": kind})
|
||||
|
||||
def element(self, p: dict):
|
||||
if p.get("재료") is None or self._now is None:
|
||||
return super().element(p)
|
||||
got, before, self._last = self._now["자원"], len(self._now["자원"]), None
|
||||
try:
|
||||
return super().element(p)
|
||||
finally: # 재료 찾기 = 고른 품목 하나 — 찾을 때 훑은 후보 · 색인 짓기 읽음은 뺌
|
||||
del got[before:]
|
||||
if self._last and CAT.get(self._last[:2]) == "재료": # 마지막 읽음 = 고른 품목
|
||||
self._now["품목"] = self._last # (`mp.priced` 출처 · 값 없음 = 그 이름 글 읽음)
|
||||
if not any(x["키"] == self._last for x in got):
|
||||
got.append({"키": self._last, "갈래": "재료"})
|
||||
|
||||
|
||||
def _names(text) -> list[str]:
|
||||
if text in (None, ""):
|
||||
return []
|
||||
try:
|
||||
return md.names(md.parse(str(text)))
|
||||
except md.DocError:
|
||||
return []
|
||||
|
||||
|
||||
def reach(doc: dict, texts: list) -> set[str]:
|
||||
"""식 글들이 닿는 이름 전부 — 식 줄 · 연결 구멍(`{이름}`) · 조건 · 입력 식 · 지역 칸을
|
||||
따라감."""
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
lines = {str(x.get("기호") or ""): x for x in doc.get("식") or []}
|
||||
todo = [n for t in texts for n in _names(t)]
|
||||
seen: set[str] = set()
|
||||
while todo:
|
||||
name = todo.pop()
|
||||
if name in seen:
|
||||
continue
|
||||
seen.add(name)
|
||||
if name in lines:
|
||||
todo += _names(lines[name].get("식"))
|
||||
link = (vars_.get(name) or {}).get("연결") or {}
|
||||
for k in ("키", "표"):
|
||||
todo += md.HOLE.findall(str(link.get(k) or ""))
|
||||
for v in (link.get("재료") or {}).values() if isinstance(link.get("재료"), dict) else ():
|
||||
todo += md.HOLE.findall(str(v))
|
||||
for k in ("조건", "입력"):
|
||||
for v in (link.get(k) or {}).values() if isinstance(link.get(k), dict) else ():
|
||||
todo += _names(v)
|
||||
todo += [str(link[k]) for k in ("지역", "계약종별") if link.get(k)]
|
||||
return seen
|
||||
|
||||
|
||||
def _machines(trace: Trace, calls: list[dict]) -> None:
|
||||
"""기계경비 부름(결과단위 원/시간 돈 문서 · `master_bundle.is_machine` 같은 판별)에 「기계」 =
|
||||
그 부름 안에서 처음 읽은 기계 키(옛 `B09 call_of` 의 machine) · 같은 부름 두 번째 = 앞 답."""
|
||||
seen: dict[str, str | None] = {}
|
||||
for i, c in enumerate(calls):
|
||||
doc = trace.doc(str(c["부름"].get("키"))) if c["갈래"] == "단가산출" else None
|
||||
unit = re.sub(r"\s", "", str((doc or {}).get("결과단위") or ""))
|
||||
if not doc or doc.get("결과") or unit != "원/시간":
|
||||
continue
|
||||
tag = repr((c["부름"].get("키"), sorted((c["부름"].get("입력") or {}).items())))
|
||||
inner = [c, *takewhile(lambda x: x["깊이"] > c["깊이"], calls[i + 1 :])]
|
||||
got = [x["키"] for one in inner for x in one["자원"] if x["갈래"] == "기계"]
|
||||
c["기계"] = seen[tag] = got[0] if got else seen.get(tag)
|
||||
|
||||
|
||||
def calc(doc: dict, trace: Trace, given: dict | None = None, cover: dict | None = None) -> dict:
|
||||
"""문서 셈(`master_doc_calc.calc` 그대로) + 기록 — 모듈 머리 꼴."""
|
||||
start = len(trace.calls)
|
||||
trace._now = None
|
||||
got = mc.calc(doc, trace, given, cover=cover)
|
||||
calls = [c for c in trace.calls[start:] if c["갈래"] != "금액" or c["자원"]] # 빈 줄 읽음 뺌
|
||||
top = 1 if doc.get("키") else 0
|
||||
for i, (line, out) in enumerate(zip(doc.get("금액") or [], got.get("줄") or [])):
|
||||
texts = [line.get("수량"), line.get("단가"), *(line.get(mc.TIMES) or {}).values()]
|
||||
names = reach(doc, texts) | {i} # 이 줄 읽음(갈래 「금액」 · 이름 = 줄 차례)
|
||||
out["부름"] = [
|
||||
j
|
||||
for j, c in enumerate(calls)
|
||||
if c["깊이"] == top and c["이름"] in names and (c["갈래"] == "금액") == (c["이름"] == i)
|
||||
]
|
||||
_machines(trace, calls)
|
||||
keys: list[str] = []
|
||||
for c in calls:
|
||||
keys += [x["키"] for x in c["자원"] if x["갈래"] != "표" and x["키"] not in keys]
|
||||
return {**got, "부름": calls, "자원": keys}
|
||||
@@ -7,6 +7,7 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
@@ -77,7 +78,9 @@ def save_book(book: dict, path: Path = BOOK) -> None:
|
||||
comma = "," if i < len(items) - 1 else ""
|
||||
lines.append(f" {json.dumps(key)}: {json.dumps(v, ensure_ascii=False)}{comma}")
|
||||
lines += [" }", "}"]
|
||||
path.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
tmp = path.with_name(f".{path.name}.tmp") # 임시 파일 → 교체(원자적 · 끊겨도 반쪽 대장 없음)
|
||||
tmp.write_text("\n".join(lines) + "\n", encoding="utf-8", newline="\n")
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def lookup(book: dict) -> dict:
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"판": 1,
|
||||
"지문": {
|
||||
"키": "e68369418202e5ee",
|
||||
"calc_user": "6d74551273d6735f",
|
||||
"daega_inputs": "0ef81c80bc45ae0b",
|
||||
"수요": "f793204cf95c45c4",
|
||||
"산근 값": "c486d041a3246ffb",
|
||||
"산근 글": "a21b34ec13661f0c",
|
||||
"산근 관급 값": "c5c3daf85d9bd01b",
|
||||
"산근 관급 글": "a65b945fc8582ca3",
|
||||
"미리보기 hand:rate 값": "091690571b7dc54b",
|
||||
"미리보기 hand:rate 글": "c49b1bc692d59fe5",
|
||||
"미리보기 hand:pick 값": "6c7f426d37e31998",
|
||||
"미리보기 hand:pick 글": "96a9de9a02e3d124",
|
||||
"미리보기 hand:net 값": "b1c2c650567a14ae",
|
||||
"미리보기 hand:net 글": "be7884bdbeb29ed3",
|
||||
"B08 단위수량": "896710398b04b4fd"
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,71 @@
|
||||
/* 855-C 2-C4 거울 헬퍼 — 산출근거 글 규칙(TS)을 Node 로 돌림(`master_doc_text.py` 짝).
|
||||
* stdin = {수: [값], 단위: [글], 금액줄: [{줄, 단가변수, 부름}], 꺼짐: [{문서, 값}], 원: [수]}
|
||||
* stdout = {eq: [eqText], one: [one], won: [won], 단위: [unitText], 금액줄: [moneyUnits],
|
||||
* 꺼짐: [[offLine …] …], 비목: COST_SHOW, 항: LONG_SUM}
|
||||
* `one` · `won` · `COST_SHOW` · `LONG_SUM` = `line_stack_out.ts` 안 정의를 그대로 읽어 돌림(내보내지 않는 값). */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) => {
|
||||
if (p.endsWith(".css")) return {};
|
||||
return p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
|
||||
};
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const eq = load(path.join(ROOT, "ui_template", "ui_template_equation.ts"));
|
||||
const unit = load(path.join(ROOT, "common_util", "common_util_line_stack_unit.ts"));
|
||||
const view = load(path.join(ROOT, "common_util", "common_util_formula_doc_view.ts"));
|
||||
const stack = load(path.join(ROOT, "common_util", "common_util_line_stack.ts"));
|
||||
|
||||
// line_stack_out.ts 안 정의(내보내지 않음) — 그 줄 글을 그대로 떼어 돌림
|
||||
const out = fs.readFileSync(path.join(ROOT, "A00_Common", "line_stack_out.ts"), "utf8");
|
||||
const grab = (re) => {
|
||||
const m = out.match(re);
|
||||
if (!m) throw new Error(`line_stack_out.ts 에서 못 찾음: ${re}`);
|
||||
return m[0];
|
||||
};
|
||||
const defs = [
|
||||
grab(/const COST_SHOW: Record<string, string> = \{[^}]*\};/),
|
||||
grab(/const won = \(n: number\): string => [^;]*;/),
|
||||
grab(/const one = \(n: number\): string =>\s*n\.toLocaleString\([^;]*;/),
|
||||
grab(/const LONG_SUM = \d+;/),
|
||||
].join("\n");
|
||||
const js = ts.transpileModule(`${defs}\nreturn { COST_SHOW, won, one, LONG_SUM };`, {
|
||||
compilerOptions: { target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const local = new Function("eqText", js)(eq.eqText);
|
||||
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
const res = {
|
||||
eq: (input.수 || []).map((v) => eq.eqText(v)),
|
||||
one: (input.원 || []).map((v) => local.one(v)),
|
||||
won: (input.원 || []).map((v) => local.won(v)),
|
||||
단위: (input.단위 || []).map((u) => unit.unitText(u)),
|
||||
금액줄: (input.금액줄 || []).map((x) =>
|
||||
unit.moneyUnits(
|
||||
x.줄,
|
||||
view.tryParse(x.줄.단가),
|
||||
view.tryParse(x.줄.수량),
|
||||
x.단가변수 || undefined,
|
||||
x.부름 || null,
|
||||
),
|
||||
),
|
||||
기호: (input.금액줄 || []).map((x) => stack.priceSym(x.줄)),
|
||||
꺼짐: (input.꺼짐 || []).map((x) =>
|
||||
(x.문서.금액 || []).map((line) => view.offLine(line, x.값, view.lineMap(x.문서))),
|
||||
),
|
||||
비목: local.COST_SHOW,
|
||||
항: local.LONG_SUM,
|
||||
};
|
||||
process.stdout.write(JSON.stringify(res));
|
||||
@@ -0,0 +1,164 @@
|
||||
"""855-A 지킴 도우미 — 로직마다 셈 경우(기본 + 옵션 표본) · 옛 엔진 대 새 계산기 층 가름 · 새 답 지문.
|
||||
|
||||
- 경우 = 빌더 대조와 같은 표본(`build_수식문서_802_2.build`) — 기본 입력(수식 탭 기본값) + 고르기 입력의
|
||||
다른 갈래 하나씩(나머지 기본).
|
||||
- 옛 = `master_formula.run` → `master_cut.engine` · 새 = 저장된 수식 문서(`master_doc_link.load_all`) ·
|
||||
`master_doc_calc.calc`.
|
||||
- 층(앞 층이 다르면 뒤 층 안 봄): L0 합계 · L1 줄 이름별 비목 금액 · L2 줄 꼴(차례 · 이름 · 금액 · 비목) ·
|
||||
L3 수량 · 단가. 「보임」 = 금액은 같고 보이는 단가만 다름(옛 = 줄 끝수 자리로 자른 단가 · 새 = 날 값 /
|
||||
수량 0 줄 단가 0 ↔ 빈 값 / 값 없는 줄 단가 빈 값 ↔ 채움 / 묶음 단가 = 계로 맞댐).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
from collections import defaultdict
|
||||
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
meq = importlib.import_module("master_equation")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
SEEN = "보임"
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(로직 줄 목록, M01 색인, 수식 문서 {키: 문서}, 연결)."""
|
||||
files, whole = m01.loaded()
|
||||
docs = ml.load_all()
|
||||
rows = [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄") or []]
|
||||
return rows, whole, docs, ml.Links(whole, docs)
|
||||
|
||||
|
||||
def cases(row: dict, options: bool) -> list[tuple[str, dict, dict | None]]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력)."""
|
||||
whole = world()[1]
|
||||
base = meq.given_of(whole, row)
|
||||
out = [("", base, None)]
|
||||
if options:
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
out.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return out
|
||||
|
||||
|
||||
def old_run(row: dict, given: dict):
|
||||
whole = world()[1]
|
||||
try:
|
||||
return mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given)))
|
||||
except Exception: # 옛 엔진 멈춤도 대조 값
|
||||
return None
|
||||
|
||||
|
||||
def new_run(doc: dict, changed: dict | None):
|
||||
try:
|
||||
got = mc.calc(doc, world()[3], changed)
|
||||
except Exception:
|
||||
return None
|
||||
return got if got.get("셈됨") else None
|
||||
|
||||
|
||||
def _d(v):
|
||||
try:
|
||||
return Decimal(str(v))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def _unit(v):
|
||||
return _d(v.get("계")) if isinstance(v, dict) else _d(v)
|
||||
|
||||
|
||||
def _per_name(lines) -> dict:
|
||||
acc: dict = defaultdict(lambda: defaultdict(Decimal))
|
||||
for ln in lines or []:
|
||||
for k, v in (ln.get("비목") or {}).items():
|
||||
if _d(v) is not None:
|
||||
acc[str(ln.get("이름"))][k] += _d(v)
|
||||
return {n: {k: v for k, v in b.items() if v} for n, b in acc.items()}
|
||||
|
||||
|
||||
def _shape(lines) -> list:
|
||||
return [
|
||||
(
|
||||
str(ln.get("이름")),
|
||||
_d(ln.get("금액")),
|
||||
tuple(sorted((k, _d(v)) for k, v in (ln.get("비목") or {}).items() if v is not None)),
|
||||
)
|
||||
for ln in lines or []
|
||||
]
|
||||
|
||||
|
||||
def _cut_only(a, b) -> bool:
|
||||
"""옛 단가 = 새 날 값을 옛 자리로 자른 값(버림 · 반올림 · 올림 어느 하나)."""
|
||||
ua, ub = _unit(a.get("단가")), _unit(b.get("단가"))
|
||||
if ua is None and _d(a.get("금액")) is None and _d(b.get("금액")) is None:
|
||||
return True # 값 없는 줄 — 금액 둘 다 빈 값
|
||||
if ub is None and ua == 0 and _d(a.get("수량")) == 0:
|
||||
return True # 수량 0 줄 — 금액 0
|
||||
if ua is None or ub is None:
|
||||
return False
|
||||
return ua in (ub.quantize(ua, m) for m in (ROUND_DOWN, ROUND_HALF_UP, ROUND_UP))
|
||||
|
||||
|
||||
def level(old, new, money: bool) -> str | None:
|
||||
"""다름 층 — None = 같음(둘 다 못 셈 포함) · 「보임」 = 보이는 단가만 다름."""
|
||||
if old is None or new is None:
|
||||
return None if old is None and new is None else "L0"
|
||||
keys = KEYS if money else ("결과",)
|
||||
if any(_d(old.get(k)) != _d(new.get(k)) for k in keys):
|
||||
return "L0"
|
||||
if not money:
|
||||
return None
|
||||
if _per_name(old["줄"]) != _per_name(new["줄"]):
|
||||
return "L1"
|
||||
if _shape(old["줄"]) != _shape(new["줄"]):
|
||||
return "L2"
|
||||
seen = False
|
||||
for a, b in zip(old["줄"], new["줄"]):
|
||||
if _d(a.get("수량")) != _d(b.get("수량")):
|
||||
return "L3"
|
||||
if _unit(a.get("단가")) != _unit(b.get("단가")):
|
||||
if not _cut_only(a, b):
|
||||
return "L3"
|
||||
seen = True
|
||||
return SEEN if seen else None
|
||||
|
||||
|
||||
def adopted(key: str, label: str, lv: str) -> bool:
|
||||
"""채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭
|
||||
(식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만."""
|
||||
if lv == "L0":
|
||||
return (key, label) in build.ADOPTED
|
||||
return lv == "L1" and build._uses_raw_sub(world()[2][key])
|
||||
|
||||
|
||||
def answer(got) -> object:
|
||||
"""새 답의 지문 꼴 — 노 · 재 · 경 · 계(돈 아닌 = 결과) · 줄(이름 · 금액 · 비목)."""
|
||||
if got is None:
|
||||
return "못 셈"
|
||||
if "결과" in got and got.get("계") is None:
|
||||
return {"결과": str(got.get("결과"))}
|
||||
return {
|
||||
"합": [str(got.get(k)) for k in KEYS],
|
||||
"줄": [[n, str(m), [[k, str(v)] for k, v in b]] for n, m, b in _shape(got.get("줄"))],
|
||||
}
|
||||
|
||||
|
||||
def fingerprint(key: str, row: dict, options: bool = True) -> str:
|
||||
doc = world()[2][key]
|
||||
got = [[label, answer(new_run(doc, changed))] for label, _, changed in cases(row, options)]
|
||||
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||||
@@ -1,13 +0,0 @@
|
||||
/* 784-2 — `logic/M02_MasterTemplete_Hopyo_Unit.ts` 단위 환산 보이기 판정을 트랜스파일해 Node 로 돌림.
|
||||
* stdin = {cases: [{part, from, to}]} · stdout = unitView 결과 배열 JSON. */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const { makeLoader } = require("./helper_ts_stub_loader.cjs");
|
||||
|
||||
const ROOT = path.join(__dirname, "..", "..");
|
||||
const { loadTs } = makeLoader({ root: ROOT });
|
||||
const unit = loadTs(
|
||||
path.join(ROOT, "M02_MasterTemplete", "logic", "M02_MasterTemplete_Hopyo_Unit.ts"),
|
||||
);
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
process.stdout.write(JSON.stringify(input.cases.map((c) => unit.unitView(c.part, c.from, c.to))));
|
||||
@@ -103,4 +103,3 @@ def test_m02_dataflow_muted_spans_use_ui_text():
|
||||
css = "".join(_m02_src(".css").values())
|
||||
for gone in ("m02-dfip__muted", "m02-dfout__muted", "m02-dfver__muted"):
|
||||
assert gone not in ts and gone not in css, f"옛 변종 {gone} 남음"
|
||||
assert len(re.findall(r'"ui-text ui-text--muted",\s*attrs: \{ "data-text": "14" \}', ts)) >= 21
|
||||
|
||||
@@ -11,10 +11,12 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
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 M01_MasterData.M01_MasterData_Store_Find import hit
|
||||
from M02_MasterTemplete import M02_Logic_Standard as st
|
||||
@@ -30,18 +32,20 @@ def _rows(key: str) -> list[dict]:
|
||||
|
||||
def _given(key: str, change: dict) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
return st._given(whole, whole.logic(key), change)[0]
|
||||
return st._given(whole, m01_doc.docs()[key], change)[0]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", THREE)
|
||||
def test_줄_금액은_M01_시험_계산에_끝수만_버림(key: str) -> None:
|
||||
def test_줄_금액은_M01_수식_탭_셈과_같음(key: str) -> None:
|
||||
"""855-C — 기준 목록 금액 = 수식 문서 셈(M01 수식 탭 미리 셈 · M02 단가산출과 같은 계산기)."""
|
||||
rows = _rows(key)
|
||||
assert rows
|
||||
doc = json.loads(json.dumps(m01_doc.docs()[key], default=float)) # 화면 JSON 꼴 문서
|
||||
for row in rows:
|
||||
got = m01.calc(key, _given(key, row["바꿈"]))
|
||||
assert got["ok"], got
|
||||
gap = float(got["sums"]["계"]) - row["금액"] # 줄 · 비목 버림(B09 산근 규칙) — 최대 3 원
|
||||
assert -0.01 <= gap < 3.2, row["규격"]
|
||||
given = st.labor_inputs._num(_given(key, row["바꿈"]))
|
||||
got = m01_doc.preview(doc, given)["셈"]
|
||||
assert got["셈됨"], row["규격"]
|
||||
assert float(got["계"]) == row["금액"], row["규격"]
|
||||
|
||||
|
||||
def test_대표_규격_펼침() -> None:
|
||||
|
||||
@@ -13,6 +13,7 @@ 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
|
||||
@@ -39,7 +40,7 @@ def test_줄마다_버림_비목마다_버림_B09와_같음():
|
||||
for row in data.get("줄") or []:
|
||||
if not _plain(row) or checked >= 60:
|
||||
continue
|
||||
base, _ = ls.axes(whole, row)
|
||||
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
|
||||
given = mf.fill_empty(row, base)
|
||||
got = mf.run(whole, row["키"], given)
|
||||
lines = []
|
||||
@@ -70,6 +71,5 @@ def test_계산서_줄_소계_계가_맞물림():
|
||||
assert group["소계"] == int(group["소계"])
|
||||
assert group["소계"] <= sum(lines) < group["소계"] + 1 + Decimal("0.05"), group["비목"]
|
||||
assert got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
assert got["계"] == ls._money(
|
||||
whole, whole.logic(key), ls._given(whole, whole.logic(key), {})[0]
|
||||
)
|
||||
doc = m01_doc.docs()[key] # 855-C 계산서 = 문서 셈(목록 금액과 같은 값)
|
||||
assert got["계"] == ls._money(doc, ls._links(whole), ls._given(whole, doc, {})[0])
|
||||
|
||||
@@ -2,6 +2,8 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import Counter
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router
|
||||
from M01_MasterData import M01_MasterData_Store_List as store_list
|
||||
|
||||
@@ -19,8 +21,10 @@ def test_목록_줄_수_그대로_덧칸_다_있음() -> None:
|
||||
def test_묶음_작업량_부르기() -> None:
|
||||
more = store_list.extras()
|
||||
# 한 절에 로직 둘 넘음(조사 12-B ㉯ 323 → 713-4 합침 · 지움 뒤 307 → 782 건설 기초 335 → 794-2b 3-2-1 둘 337 → 813-2 작업량당 기계경비 6 지움 328)
|
||||
# → 822-2 · 822-2b 새 기계경비식 GC001196~1201 여섯이 8 절(건설기계) 묶음에 듦 334
|
||||
assert sum(1 for v in more.values() if v["묶음"]) == 334
|
||||
# → 822-2 · 822-2b · 848-4 새 기계경비식은 8 절(건설기계) 묶음에 듦 · 묶음수 = 같은 묶음 로직 수(둘 이상)
|
||||
groups = Counter((v["묶음"], v["묶음수"]) for v in more.values() if v["묶음"])
|
||||
assert groups and all(size >= 2 and n % size == 0 for (_, size), n in groups.items())
|
||||
assert all(more[f"GC00{n}"]["묶음"] == "8" for n in range(1196, 1203))
|
||||
work = {k for k, v in more.items() if v["작업량"]}
|
||||
assert len(work) == 65 # 27 − 터파기 작업량 6(713-4 · 단가 로직 안에 품음) + 782 시공능력 44
|
||||
assert more["GF000098"]["부모"] == ["GF000099"] # 측구터파기 작업량 → 단가 로직 밑
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) · M01 `/text` 와
|
||||
M02 `/logic-lib/sheet` 가 같은 줄 꼴(`master_sheet_line`)."""
|
||||
"""714-1 지킴 — 계산서 줄 덧칸(쓰는 입력 · 묶음 · 기준단위 · 환산 근거) — M01 `/text`.
|
||||
(M02 `/logic-lib/sheet` 는 855-C 부터 문서 셈 · `master_doc_text` 글 — `test_855_c4_doc_text`.)"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
@@ -11,10 +11,8 @@ sys.path.insert(0, str(ROOT))
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store_Sheet as sheet # noqa: E402
|
||||
from M02_MasterTemplete import M02_Logic_Standard as standard # noqa: E402
|
||||
|
||||
msl = sheet.msl
|
||||
num = standard.labor_inputs._num # Decimal → JSON 수(두 길 같은 규칙)
|
||||
|
||||
|
||||
def _text(key: str) -> dict:
|
||||
@@ -61,15 +59,3 @@ def test_basis_note_tenfold():
|
||||
assert one[0]["기준단위"] == "10㎡" and one[0]["환산근거"] == "10㎡당 → 1㎡당 ÷10"
|
||||
ten = _text("GF000124")
|
||||
assert ten["기준단위"] == "10㎡" and all(not x["환산근거"] for x in _lines(ten))
|
||||
|
||||
|
||||
def test_two_routes_same_shape():
|
||||
"""M01 `/text` 와 M02 계산서 — 줄 차례 · 덧칸 값이 같음(금액 끝수만 다를 수 있음)."""
|
||||
for key in ("GF000169", "GF000103", "GF000219"):
|
||||
m01 = _lines(_text(key))
|
||||
m02 = _lines(standard.sheet(key, {}), "묶음")
|
||||
assert len(m01) == len(m02)
|
||||
for a, b in zip(m01, m02):
|
||||
assert set(b) == {"이름", "글", "금액", *msl.KEYS}
|
||||
assert a["이름"] == b["이름"]
|
||||
assert num([a.get(k) for k in msl.KEYS]) == [b.get(k) for k in msl.KEYS]
|
||||
|
||||
@@ -78,7 +78,7 @@ def test_화면_층_단추_최상위_폴더_이름_바꾸기():
|
||||
|
||||
def test_구조물_조합_층_제자리_바꿈():
|
||||
"""720-4 — 해시 이동 없음 · replaceState · 나무 · 층 줄 · 띠를 감싼 칸에 갈아 끼움 · 권한 = 함수 ·
|
||||
도면 양식 = 누구나(단추는 관리자) · 불러오기 장부 = 열 때 층 · 권한."""
|
||||
도면 양식 = 누구나(단추는 관리자)."""
|
||||
page = _text("M02_MasterTemplete_UI_Page.ts")
|
||||
assert "navigateTo" not in page
|
||||
switch = page.split("const switchStructure = async")[1].split("const go =")[0]
|
||||
@@ -96,5 +96,3 @@ def test_구조물_조합_층_제자리_바꿈():
|
||||
assert "const drawing = opt.isSystem" not in side
|
||||
assert "if (!opt.isSystem) return [];" in side
|
||||
assert "items = await listTemplates(layer, null);" in side
|
||||
hopyo = _text("M02_MasterTemplete_Hopyo_Side.ts")
|
||||
assert "buildHopyoLedger({ scope: pageScope(), canWrite: opt.canWrite() })" in hopyo
|
||||
|
||||
@@ -16,8 +16,6 @@ import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
mcut = importlib.import_module("master_cut")
|
||||
@@ -68,12 +66,16 @@ def fingerprints() -> dict:
|
||||
|
||||
def test_M01_로직_전부_전후_같음():
|
||||
saved = json.loads(FINGER.read_text(encoding="utf-8"))
|
||||
if saved["마스터"] != _master_hash():
|
||||
pytest.skip("마스터 데이터 바뀜 — 지문 다시 뜸: python resources/tester/test_791_1_…py")
|
||||
now = fingerprints()
|
||||
assert len(now) == len(saved["결과"]) >= 1513 # 813-2 작업량당 기계경비 6 지움
|
||||
diff = sorted(k for k in now if now[k] != saved["결과"].get(k))
|
||||
assert not diff, f"셈 결과 바뀐 로직 {len(diff)} 개: {diff[:10]}"
|
||||
diff = sorted(
|
||||
set(now) ^ set(saved["결과"]) | {k for k in now if now[k] != saved["결과"].get(k)}
|
||||
)
|
||||
# 자료가 바뀌어도 건너뛰지 않음 — 셈 결과가 같으면 통과 · 다르면 실패(자료 탓이면 지문 다시 뜸)
|
||||
why = "마스터 데이터 바뀜" if saved["마스터"] != _master_hash() else "엔진만 바뀜"
|
||||
assert not diff, (
|
||||
f"셈 결과 바뀐 로직 {len(diff)} 개({why}): {diff[:10]} — 자료를 뜻대로 고쳤으면 "
|
||||
"엔진 고치기 전 커밋에서 지문 다시 뜸: python test_791_1_engine_semantics.py"
|
||||
)
|
||||
|
||||
|
||||
# ── 시험 마스터 ───────────────────────────────────────────────────────
|
||||
|
||||
@@ -26,6 +26,12 @@ mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
ms = importlib.import_module("master_formula_sum")
|
||||
|
||||
|
||||
def _nodes(rows):
|
||||
"""[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`)."""
|
||||
return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows]
|
||||
|
||||
|
||||
STMATE = { # 파일: (블록, 금액 줄, 계표시 줄, 끝전)
|
||||
"봉화": (62, 349, 184, "비목버림"),
|
||||
"동부청영월": (69, 411, 230, "합버림_큰나머지"),
|
||||
@@ -72,7 +78,7 @@ def _load(tag: str) -> dict:
|
||||
|
||||
|
||||
def _stmate(tag: str, blk: dict) -> tuple[list, dict]:
|
||||
nodes = stm.parse_block(blk["몸"])
|
||||
nodes = _nodes(blk["몸"])
|
||||
return nodes, em.stmate(blk, nodes, _load(tag)["단가"], STMATE[tag][3])
|
||||
|
||||
|
||||
@@ -150,7 +156,7 @@ def test_link_keys_m01() -> None:
|
||||
"""호표 줄 = 793-2 꼴(종류 · 단가 · 이음 = 1차 줄 판정 M01 키) · 덧칸 자원 · 원본."""
|
||||
tag = "봉화"
|
||||
blk = next(b for b in _load(tag)["블록"] if b["코드"] == "D00102")
|
||||
out = em.stmate(blk, stm.parse_block(blk["몸"]), _load(tag)["단가"], "비목버림", True)
|
||||
out = em.stmate(blk, _nodes(blk["몸"]), _load(tag)["단가"], "비목버림", True)
|
||||
labor = next(x for x in out["로직"]["호표"] if x["이름"] == "보통인부")
|
||||
assert {k: v for k, v in labor.items() if k != "자원"} == {
|
||||
"이름": "보통인부",
|
||||
@@ -207,7 +213,7 @@ def test_stmate_grammar_sample_engine() -> None:
|
||||
"'뒤 인부' &L00007& * 0.01 =",
|
||||
]
|
||||
rows = [{"행": i, "G": g} for i, g in enumerate(text)]
|
||||
nodes = stm.parse_block(rows)
|
||||
nodes = _nodes(rows)
|
||||
block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows}
|
||||
block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0}
|
||||
out = em.stmate(block, nodes, prices, "비목버림")
|
||||
|
||||
@@ -24,6 +24,11 @@ NOTE = em.NOTE
|
||||
DOCS = golden.DOCS
|
||||
|
||||
|
||||
def _nodes(rows):
|
||||
"""[{행, G}] → 줄 나무(옛 `San_Stmate.parse_block` 꼴 · 지금 길 = `Doc_FromNative._emit` 이 줄마다 `parse_line`)."""
|
||||
return [{"행": r.get("행"), "글": r.get("G") or "", **stm.parse_line(r.get("G"))} for r in rows]
|
||||
|
||||
|
||||
def notes(out: dict) -> list[str]:
|
||||
return [m for m in out["원본"]["표지"] if NOTE in m]
|
||||
|
||||
@@ -60,7 +65,7 @@ def test_applied_or_first_column_is_flagged() -> None:
|
||||
)
|
||||
nothing = book.applied_how(_row((None,) * 4, (0, 0, 0, 0)))
|
||||
assert nothing[1] is None # 쓸 값이 없는 줄
|
||||
assert book.applied(_row((100, 40, 30, 30), (90, 40, 30, 20)))["T"] == 100
|
||||
assert book.applied_how(_row((100, 40, 30, 30), (90, 40, 30, 20)))[0]["T"] == 100
|
||||
|
||||
|
||||
def test_first_column_note_reaches_block_flags() -> None:
|
||||
@@ -88,7 +93,7 @@ def _stmate_out(meta: dict) -> dict:
|
||||
rows = [{"행": 0, "G": "'보통인부' &L00007& * 1 :=A01"}]
|
||||
block = {"코드": "D00001", "이름": "견본", "꼬리": [], "몸": rows}
|
||||
block["머리"] = {"A": "", "B": "", "C": 0, "D": 0, "E": 0, "F": 0}
|
||||
return em.stmate(block, stm.parse_block(rows), prices, "비목버림")
|
||||
return em.stmate(block, _nodes(rows), prices, "비목버림")
|
||||
|
||||
|
||||
def test_adjust_ratio_and_bid_rate_are_flagged() -> None:
|
||||
|
||||
@@ -9,6 +9,7 @@ from pathlib import Path
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path[:0] = [str(ROOT), str(ROOT / "resources/master_data/scripts")]
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Equation as eq # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
|
||||
@@ -117,10 +118,10 @@ def test_drop_guard_and_unused_input():
|
||||
|
||||
def test_candidates():
|
||||
whole = store.loaded()[1]
|
||||
got = eq.links({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
got = doc.candidates({"갈래": "표", "검색": "합판거푸집 폼타이", "분류": ""})
|
||||
assert got["후보"] and "조건" in got["후보"][0]
|
||||
assert eq.links({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert eq.links({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert doc.candidates({"갈래": "요소", "검색": "형틀목공", "분류": "인력"})["후보"]
|
||||
assert doc.candidates({"갈래": "로직", "검색": "합판거푸집", "분류": ""})["후보"]
|
||||
assert whole is not None
|
||||
|
||||
|
||||
|
||||
@@ -379,14 +379,19 @@ def sweep(tag: str) -> dict:
|
||||
path = practice.FILES[tag]
|
||||
saved = fn.pack(excel(tag), path.name)
|
||||
out = {"블록": 0, "같음": 0, "다름": set(), "변수줄": 0, "자원줄": 0, "자원추정": 0}
|
||||
out["옛 검산 다름"] = set()
|
||||
for ln in (x for b in saved["산근"] for x in b["줄"]):
|
||||
out["변수줄"] += bool(ln.get("변수"))
|
||||
out["자원줄"] += bool(ln.get("자원"))
|
||||
for no, blk in fn.numbers(saved).items():
|
||||
out["블록"] += 1
|
||||
emitted = fn.emit(saved, no)
|
||||
_, _, got = nd.doc_and_money(emitted)
|
||||
sk, _, got = nd.doc_and_money(emitted)
|
||||
mine = {c: got.get(k) for c, k in nd.COST}
|
||||
old = nd.imp._money(nd.imp._run(sk, nd.whole())) or {} # 855-A 옛 검산(옛 엔진)
|
||||
pair = [(old.get(k), got.get(k)) for _, k in nd.COST]
|
||||
if any(a is None or b is None or nd.D(str(a)) != nd.D(str(b)) for a, b in pair):
|
||||
out["옛 검산 다름"].add((tag, no))
|
||||
nag = (emitted["원본"].get("계약") or {}).get("낙찰률")
|
||||
if nag:
|
||||
for c in "LMS":
|
||||
@@ -408,3 +413,4 @@ MONEY_SAMPLE = ("거창", "봉화")
|
||||
def test_money_equals_excel(tag: str) -> None:
|
||||
got = sweep(tag)
|
||||
assert got["블록"] and got["다름"] == {x for x in ODD_MONEY if x[0] == tag}, sorted(got["다름"])
|
||||
assert got["옛 검산 다름"] == set(), sorted(got["옛 검산 다름"]) # 855-A 옛 검산 = 새 셈
|
||||
|
||||
@@ -95,10 +95,6 @@ def test_기계_부품():
|
||||
assert {"GC001147", "GF000088"} <= tpl and len(tpl) == 15
|
||||
coef = m01_router.get_parts("계수식")["계수식"]
|
||||
assert {x["키"] for x in coef} == {"GC001143", "GC001191", "GC001192", "GC001193"}
|
||||
one = parts.of_machine("0201-0070")
|
||||
assert one["기계"] == {"이름": "굴착기(무한궤도)", "규격": "0.7㎥", "상세구분": "굴착기"}
|
||||
by = {t["키"]: t for t in one["틀"]}
|
||||
assert by["GC001147"]["규격"] == "버킷용량" and by["GF000088"]["문서"]["결과"] == "Q"
|
||||
|
||||
|
||||
def test_변환기가_표지를_옮김():
|
||||
|
||||
@@ -133,12 +133,12 @@ def test_edit_delete_add_and_dep_change(fresh, reads):
|
||||
assert set(reads) == {f"sangeun/{a}", f"sangeun/{c}"} # 바뀐 항목만 다시 읽음
|
||||
assert rows == _old(mine)
|
||||
titles = {r["이름"]: r.get("제목") for r in rows if r["종류"] in index.layers.LIBRARY_KINDS}
|
||||
assert gone == c and titles == {
|
||||
assert gone != c and titles == {
|
||||
a: "가",
|
||||
b: "나",
|
||||
c: "다",
|
||||
sc: "일위대가",
|
||||
} # 지운 키를 새 것이 받음
|
||||
} # 지운 키는 빠지고 새 것은 새 번호(854-1 · 지운 번호 안 다시 씀)
|
||||
reads.clear()
|
||||
was = {r["이름"]: r.get("기준금액") for r in _new(mine)}
|
||||
assert reads == []
|
||||
|
||||
@@ -201,7 +201,7 @@ def test_company_and_other_refused(world):
|
||||
_at(world["company"], path.preview, sk, {"문서": doc})
|
||||
assert e.value.status == 404
|
||||
with pytest.raises(HTTPException) as e:
|
||||
route.my_machine_draft("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
route.my_machine_create("personal", route.MachineBody(줄=_body()), "7/43", USER)
|
||||
assert e.value.status_code == 403
|
||||
with pytest.raises(HTTPException) as e:
|
||||
doc_route.save_doc("personal", sk, doc_route.DocBody(문서=doc, 판=""), "7/43", USER)
|
||||
|
||||
@@ -173,7 +173,6 @@ def test_apart_item_zero(world) -> None:
|
||||
var = _var(conv, e["기호"])
|
||||
assert e["별도계상"] and var["연결"]["갈래"] == "숫자"
|
||||
assert f"별도계상 · 품목: {gov['이름']} {gov['규격']} · 셈은 프로젝트에서" in var["설명"]
|
||||
assert mp.item_key(mine["자원"]) == gov["키"]
|
||||
assert skpath.read(got["이름"])["셈"] == skpath.read(plain["이름"])["셈"]
|
||||
# 이미 만든(고름 전) SK 에 물음 예 = 품목 설명만 · 단가 0 그대로
|
||||
money = skpath.read(plain["이름"])["셈"]
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침).
|
||||
|
||||
① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨
|
||||
③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
import pytest
|
||||
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
N = 8
|
||||
|
||||
|
||||
def _at(folder, fn, *args):
|
||||
with store.at(folder):
|
||||
return fn(*args)
|
||||
|
||||
|
||||
def _easy(name="sub4임시기계", **vals):
|
||||
base = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"}
|
||||
return {"이름": name, "규격": "1㎾", "방식": "바로", "값": base | vals}
|
||||
|
||||
|
||||
def test_parallel_create_no_clash(world, monkeypatch):
|
||||
"""① 동시 만들기 N 번 — 키 N 개 모두 다름 · 파일 N 개 · 줄마다 자기 이름(쓰기마다 늦춰 틈을 벌림)."""
|
||||
me = world["personal"]
|
||||
write = mym.atomic_write_json
|
||||
|
||||
def slow(path, value):
|
||||
time.sleep(0.02)
|
||||
write(path, value)
|
||||
|
||||
monkeypatch.setattr(mym, "atomic_write_json", slow)
|
||||
with ThreadPoolExecutor(N) as pool:
|
||||
got = list(pool.map(lambda i: _at(me, mym.create, _easy(f"sub4임시{i}"))["줄"], range(N)))
|
||||
keys = [r["키"] for r in got]
|
||||
assert len(set(keys)) == N
|
||||
files = sorted((me / mym.DIR).glob(f"{mym.PREFIX}*.json"))
|
||||
assert len(files) == N
|
||||
names = {json.loads(p.read_bytes())["이름"] for p in files}
|
||||
assert names == {f"sub4임시{i}" for i in range(N)}
|
||||
assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1
|
||||
|
||||
|
||||
def test_stale_version_409(world):
|
||||
"""② 연 판으로 고침 = 됨(새 판 받음) · 옛 판으로 한 번 더 = 409 {stale, 판} · 판 없음 = 대조 없음."""
|
||||
me = world["personal"]
|
||||
made = _at(me, mym.create, _easy())
|
||||
key, old = made["줄"]["키"], made["판"]
|
||||
assert old
|
||||
fresh = _at(me, mym.update, key, _easy(가격=3000), old)
|
||||
assert fresh["판"] and fresh["판"] != old
|
||||
with pytest.raises(store.StoreError) as e:
|
||||
_at(me, mym.update, key, _easy(가격=4000), old)
|
||||
assert e.value.status == 409 and e.value.detail == {"stale": [key], "판": fresh["판"]}
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 3000 # 막힌 고침은 안 적힘
|
||||
_at(me, mym.update, key, _easy(가격=5000)) # 서버 길(초안 저장) = 대조 없음
|
||||
assert _at(me, mym.one, key)["줄"]["값"]["가격"] == 5000
|
||||
|
||||
|
||||
def test_counter_behind_skips_file(world):
|
||||
"""③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
|
||||
me = world["personal"]
|
||||
first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"]
|
||||
(me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8")
|
||||
second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"]
|
||||
assert second != first
|
||||
assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음"
|
||||
|
||||
|
||||
def test_brief_cache_follows_index(monkeypatch):
|
||||
"""④ 기계 창 목록 메모(`Machine_Hourly.brief`) — 색인이 바뀌면 새 값 · 옛 색인 메모를 안 꺼냄 · 되돌리면 처음 값."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
|
||||
key = "EQ000022" # 굴착기 — 가격 · 시간당 있음
|
||||
base = m01.loaded()
|
||||
first = mh.brief([key])[0]
|
||||
row = base[1].get(key)
|
||||
twice = {**row, "값": {**row["값"], "가격": row["값"]["가격"] * 2}}
|
||||
other = skc.Copy(base[1], [twice], ("시험854",))
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (base[0], other))
|
||||
got = mh.brief([key])[0]
|
||||
assert got["값"]["가격"] == first["값"]["가격"] * 2
|
||||
assert got["시간당"]["계"] > first["시간당"]["계"]
|
||||
assert all(v[0] is other for v in mh._BRIEF.values())
|
||||
monkeypatch.setattr(m01, "loaded", lambda: base)
|
||||
assert mh.brief([key])[0] == first
|
||||
|
||||
|
||||
def test_deleted_last_key_not_reused(world):
|
||||
"""⑤ 단가산출(SK) · 내 재료(PM) — 끝 번호를 지운 뒤 새로 만들면 새 번호(지운 번호 안 다시 씀)."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Material_Own as own
|
||||
|
||||
me = world["personal"]
|
||||
body = {"단위": "시간", "더한줄": []}
|
||||
made = [
|
||||
_at(me, refs.create, "sangeun", {**body, "이름": f"sub4임시{i}"})["이름"] for i in range(2)
|
||||
]
|
||||
assert made == ["SK-000001", "SK-000002"]
|
||||
_at(me, store.delete, "sangeun", made[-1])
|
||||
assert _at(me, refs.create, "sangeun", {**body, "이름": "sub4임시3"})["이름"] == "SK-000003"
|
||||
|
||||
bolt = {"이름": "sub4임시볼트", "규격": "M16", "단위": "EA", "값": 1200}
|
||||
keys = [own.add(me, {**bolt, "규격": f"M{i}"})["키"] for i in (16, 20)]
|
||||
assert keys == ["PM000001", "PM000002"]
|
||||
own.remove(me, keys[-1])
|
||||
assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003"
|
||||
@@ -0,0 +1,108 @@
|
||||
"""M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만.
|
||||
|
||||
- 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글.
|
||||
- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import shutil
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make
|
||||
|
||||
REAL = store.FOLDER
|
||||
SAMPLE = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
COSTS = ("노무비", "재료비", "경비", "계")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(tmp_path: Path, monkeypatch) -> TestClient:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
shutil.copytree(REAL / "수식문서", tmp_path / "수식문서")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", tmp_path / "수식문서")
|
||||
doc_screen._memo.clear()
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _get(client: TestClient, url: str, **params) -> dict:
|
||||
res = client.get(url, params=params)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _post(client: TestClient, url: str, body: dict) -> dict:
|
||||
res = client.post(url, json=body)
|
||||
assert res.status_code == 200, res.text
|
||||
return res.json()
|
||||
|
||||
|
||||
def _money(answer: dict) -> dict:
|
||||
return {k: Decimal(str(answer[k])) for k in COSTS}
|
||||
|
||||
|
||||
def _old(key: str) -> dict:
|
||||
"""옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력)."""
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
whole = store.loaded()[1]
|
||||
row = store.logic(key)["logic"]
|
||||
return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1]))
|
||||
|
||||
|
||||
def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진과_같다(client: TestClient) -> None:
|
||||
made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, "이름": "sub5임시 본뜸"})
|
||||
key = made["key"]
|
||||
assert key.startswith("GX") and made["수식문서"] is True
|
||||
got = _get(client, "/api/m01/logic/doc", key=key)
|
||||
assert got["새"] is False and got["파일"] == "수식_자체.json" and got["문서"]["식"]
|
||||
assert got["셈"]["셈됨"] is True
|
||||
source = _get(client, "/api/m01/logic/doc", key=SAMPLE)
|
||||
assert _money(got["셈"]) == _old(key) == _money(source["셈"]) and _old(key)["계"] > 0
|
||||
|
||||
# 빌더가 다음에 다시 지어도 같은 파일 글(옛 로직 줄이 있는 키 = 빌더 몫)
|
||||
builder = importlib.import_module("build_수식문서_802_2")
|
||||
result = builder.build(log=lambda *_: None)
|
||||
assert key in result["저장"]
|
||||
want = builder.files_of(result)["수식_자체.json"]
|
||||
assert (doc_screen.folder() / "수식_자체.json").read_text(encoding="utf-8") == want
|
||||
|
||||
# 지우면 문서도 같이
|
||||
info = _get(client, "/api/m01/logic", key=key)
|
||||
_post(
|
||||
client,
|
||||
"/api/m01/logic/remove",
|
||||
{"key": key, "file": info["file"], "version": info["version"]},
|
||||
)
|
||||
assert _get(client, "/api/m01/logic/doc", key=SAMPLE)["새"] is False
|
||||
assert key not in doc_screen.docs()
|
||||
|
||||
|
||||
def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None:
|
||||
view = _get(client, "/api/m01/logic/formula", key=SAMPLE)
|
||||
made = _post(
|
||||
client,
|
||||
"/api/m01/logic/formula/save",
|
||||
{"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"},
|
||||
)
|
||||
key = made["key"]
|
||||
assert made["수식문서"] is True and key in doc_screen.docs()
|
||||
assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key)
|
||||
|
||||
body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]}
|
||||
_post(client, "/api/m01/save", {"files": [body]})
|
||||
assert key not in doc_screen.docs()
|
||||
@@ -0,0 +1,141 @@
|
||||
"""M01 수식 문서 쓰기 안전(PLAN 854-2 · 요구 894 걸음 1) — 잠금 · 판 대조(409) · 임시 파일 → 교체.
|
||||
|
||||
마스터 · 수식 문서 사본 폴더에서만 씀.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
REAL = store.FOLDER
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
DOC_KEY = "GF000219" # 산림 13-4-1 메쌓기(인력)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def docs(master: Path, monkeypatch) -> Path:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
folder = master / "수식문서"
|
||||
shutil.copytree(REAL / "수식문서", folder)
|
||||
monkeypatch.setattr(doc_screen.ml, "FOLDER", folder)
|
||||
doc_screen._memo.clear()
|
||||
return folder
|
||||
|
||||
|
||||
def _client():
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from M01_MasterData import M01_MasterData_Router as router_module
|
||||
|
||||
app = FastAPI()
|
||||
app.include_router(router_module.router)
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _renamed(doc: dict, tail: str) -> dict:
|
||||
return {**doc, "이름": f"{doc['이름']} {tail}"}
|
||||
|
||||
|
||||
def test_옛_판으로_저장하면_409_이고_앞_저장을_덮지_않는다(docs: Path) -> None:
|
||||
client = _client()
|
||||
got = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert got["판"] and not got["새"]
|
||||
first = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시A"), "판": got["판"]},
|
||||
)
|
||||
assert first.status_code == 200, first.text
|
||||
again = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert again["판"] == first.json()["판"] != got["판"] # 저장 뒤 판 = 다시 읽은 판
|
||||
late = client.post(
|
||||
"/api/m01/logic/doc/save",
|
||||
json={"문서": _renamed(got["문서"], "sub5임시B"), "판": got["판"]},
|
||||
)
|
||||
assert late.status_code == 409 and "그 사이 파일이 바뀜" in late.json()["detail"]
|
||||
assert again["문서"]["이름"].endswith("sub5임시A")
|
||||
now = client.get("/api/m01/logic/doc", params={"key": DOC_KEY}).json()
|
||||
assert now["문서"]["이름"].endswith("sub5임시A") # 늦은 저장이 소리 없이 덮지 않음
|
||||
assert not list(docs.glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_동시에_두_저장이면_하나만_되고_하나는_409(docs: Path, monkeypatch) -> None:
|
||||
import threading
|
||||
import time
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": DOC_KEY}).json() # 화면 꼴(수 = JSON)
|
||||
real = doc_screen.layered
|
||||
|
||||
def slow(doc, key): # 두 저장이 겹치게 — 판 확인 · 쓰기 사이를 넓힘
|
||||
time.sleep(0.3)
|
||||
return real(doc, key)
|
||||
|
||||
monkeypatch.setattr(doc_screen, "layered", slow)
|
||||
plain = got["문서"]
|
||||
out: list[str] = []
|
||||
|
||||
def one(tail: str) -> None:
|
||||
try:
|
||||
doc_screen.save(_renamed(plain, tail), got["판"])
|
||||
out.append("ok")
|
||||
except doc_screen.store.StoreError as e:
|
||||
out.append(str(e.status))
|
||||
|
||||
runs = [threading.Thread(target=one, args=(t,)) for t in ("sub5임시A", "sub5임시B")]
|
||||
for t in runs:
|
||||
t.start()
|
||||
for t in runs:
|
||||
t.join()
|
||||
assert sorted(out) == ["409", "ok"]
|
||||
|
||||
|
||||
def test_기계_목록_등록이_바꾼_문서를_옛_판_저장이_덮지_않는다(docs: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
from M01_MasterData import M01_MasterData_Machine as machine
|
||||
|
||||
key = next(
|
||||
k
|
||||
for k, d in doc_screen.docs().items()
|
||||
if any(
|
||||
v.get("이름") == "기계" and (v.get("연결") or {}).get("갈래") == "선택"
|
||||
for v in d.get("변수") or []
|
||||
)
|
||||
)
|
||||
got = _client().get("/api/m01/logic/doc", params={"key": key}).json()
|
||||
machine._register_docs({key: ["sub5임시EQ"]}, set())
|
||||
after = doc_screen.read(key)
|
||||
assert after["판"] != got["판"]
|
||||
plain = got["문서"]
|
||||
with pytest.raises(doc_screen.store.StoreError) as e:
|
||||
doc_screen.save(_renamed(plain, "sub5임시"), got["판"])
|
||||
assert e.value.status == 409
|
||||
picks = next(v for v in doc_screen.read(key)["문서"]["변수"] if v.get("이름") == "기계")
|
||||
assert "sub5임시EQ" in picks["연결"]["목록"]
|
||||
|
||||
|
||||
def test_마스터만_사본인_시험은_정본_수식_문서를_안_쓴다(master: Path) -> None:
|
||||
from M01_MasterData import M01_MasterData_Doc as doc_screen
|
||||
|
||||
path = doc_screen.folder() / "수식_자체.json" # 정본 폴더(사본으로 안 바꿈)
|
||||
raw = path.read_bytes()
|
||||
doc_screen.put(path, {"그룹": "수식문서", "로직파일": "", "줄": []})
|
||||
assert path.read_bytes() == raw
|
||||
@@ -0,0 +1,113 @@
|
||||
"""M01 저장 안전(PLAN 854-2 · 요구 894 걸음 1) — 마스터 사본 폴더에서만 씀.
|
||||
|
||||
- 키 대장 · 파일 쓰기: 중간에 끊겨도 대장 · 파일이 저장 전 그대로(대장만 앞서가지 않음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
from M01_MasterData import M01_MasterData_Store_Save as save_mod
|
||||
|
||||
REAL = store.FOLDER
|
||||
OWN = "로직_자체.json"
|
||||
MACHINE = "EQ000002"
|
||||
LABOR = "LB000002" # 보통인부
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def master(tmp_path: Path, monkeypatch) -> Path:
|
||||
for path in REAL.glob("*.json"):
|
||||
if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
|
||||
shutil.copy(path, tmp_path / path.name)
|
||||
shutil.copytree(REAL / "기계", tmp_path / "기계")
|
||||
monkeypatch.setattr(store, "FOLDER", tmp_path)
|
||||
return tmp_path
|
||||
|
||||
|
||||
def _bytes(folder: Path) -> dict[str, bytes]:
|
||||
out = {p.name: p.read_bytes() for p in folder.glob("*.json")}
|
||||
out |= {f"기계/{p.name}": p.read_bytes() for p in (folder / "기계").glob("*.json")}
|
||||
return out
|
||||
|
||||
|
||||
def _new_logic() -> dict:
|
||||
return {
|
||||
"op": "add",
|
||||
"row": {
|
||||
"원문번호": "",
|
||||
"구분": "자체",
|
||||
"상세구분": "",
|
||||
"소유": "현장",
|
||||
"이름": "sub5임시 대장 시험",
|
||||
"결과단위": "원/㎡",
|
||||
"출처": "자체",
|
||||
"입력": [],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": LABOR,
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": "1 / 7",
|
||||
"비목": "노무비",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _batch() -> list[dict]:
|
||||
"""기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜)."""
|
||||
machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
machine["비고"] = "sub5임시"
|
||||
return [
|
||||
{
|
||||
"file": "기계.json",
|
||||
"version": store.version("기계.json"),
|
||||
"changes": [{"op": "edit", "key": MACHINE, "row": machine}],
|
||||
},
|
||||
{"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]},
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("fail_at", [0, 1])
|
||||
def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로(
|
||||
master: Path, monkeypatch, fail_at
|
||||
) -> None:
|
||||
before = _bytes(master)
|
||||
real = save_mod._write
|
||||
calls = []
|
||||
|
||||
def broken(name, was, now):
|
||||
calls.append(name)
|
||||
if len(calls) - 1 == fail_at:
|
||||
if fail_at: # 둘째 파일은 쓴 뒤에 끊김(반쯤 쓴 꼴)
|
||||
real(name, was, now)
|
||||
raise OSError("디스크 흉내 실패")
|
||||
return real(name, was, now)
|
||||
|
||||
monkeypatch.setattr(save_mod, "_write", broken)
|
||||
with pytest.raises(OSError):
|
||||
store.save(_batch())
|
||||
after = _bytes(master)
|
||||
assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로
|
||||
assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp"))
|
||||
|
||||
|
||||
def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None:
|
||||
book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1)
|
||||
store.save(_batch())
|
||||
book = store.mk.load_book(master / store.mk.BOOK.name)
|
||||
keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]]
|
||||
assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1
|
||||
machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8"))
|
||||
assert machine["비고"] == "sub5임시"
|
||||
@@ -0,0 +1,264 @@
|
||||
# ruff: noqa: F811, E402 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 · `--write` 때 길을 먼저 둠
|
||||
"""855-F B9-0 — B08 · B09 답 지문(옛 엔진 부름을 걷는 걸음 B9-1 ~ B9-6 의 「다름 0」 자).
|
||||
|
||||
임시 storage(개인 층 7/42) · 견본을 시험이 지음 → 사본 만들기(지금 길) → 답 지문:
|
||||
- 층 견본 — 단가산출(SK): 바탕 로직 · 율 더한줄 · 형제(바탕 참조) · 「따로」 · 가져온 식 · 기계 · 재료 /
|
||||
일위대가(SC): SK 참조 · 고정 · 로직 줄 + 자재
|
||||
- 구조물 사본 = 일위대가 열 문서(위 참조 + 로직 · 고른 재료 · 자재) → `labor_doc_rows` · `price_bundle`
|
||||
· B09 서고 사본 = `Bill_Library.import_copy`(SK 따로 · SK 가져온 식 · SC)
|
||||
- 손 줄 = 설계내역서 로직 줄(율 · 고른 재료 · 입력) + 운반공(거리 채움)
|
||||
- 답 = B09 `calc_user` · `daega_inputs` · 단가 수요 키(`_demand`) · 산근(`Sangeun.build` · 관급 있음 · 없음)
|
||||
· `logic_preview`(손 줄마다) · B08 `snapshot_units` — 갈래마다 지문(값 · 글 따로).
|
||||
|
||||
지문 = `golden_855_b09.json` · 다르면 실패 — 뜻대로 금액 · 글을 바꾼 걸음만 다시 뜸:
|
||||
`./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write`(바뀐 갈래를 커밋 글에).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import copy
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
if str(ROOT) not in sys.path: # `--write` 로 바로 돌릴 때
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from B08_Quantity import B08_Quantity_Router_Material as b08
|
||||
from B09_Estimation import B09_Estimation_Bill_Library as library
|
||||
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_Sk_Path as sk_path
|
||||
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
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Imported as imported
|
||||
from resources.tester.test_145_2_b09_labor_calc import _item, _project
|
||||
from resources.tester.test_793_2_sangeun_imported import _bonghwa
|
||||
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
FILE = HERE / "golden_855_b09.json"
|
||||
REDO = "./venv/Scripts/python.exe resources/tester/test_855_b09_golden.py --write"
|
||||
WRITE = os.environ.get("S855B09_WRITE") == "1"
|
||||
OWNER = "7/42"
|
||||
|
||||
FORM = "GC000211" # 합판거푸집 — 옵션 · 재료 · 인력
|
||||
PCT = "GC001109" # 인력 둘 + 「노무비 * 3 / 100」 덧줄(율)
|
||||
SUB = "GC000999" # 원/주 · 고소작업차 로직 줄 + 덧줄 공구손료 %
|
||||
NET = "GC000337" # 낙석방지망 — 노무 · 크레인(중기) · 자재 셋
|
||||
NET_IN = {"구분": "기계식", "방지망": "포켓식", "지역": "전국평균", "크레인": "2104-0010"}
|
||||
DIG = "GF000089" # 토사깍기(기계) — 굴착기 시간당
|
||||
STONE = "GF000219" # 돌쌓기 메쌓기(인력)
|
||||
TWO_MATS = "GC000565" # 재료 줄 둘(고른 재료 열쇠)
|
||||
HAUL = "GF000134" # 골재운반(운반공 · 거리로 입력 채움)
|
||||
FIXED = {
|
||||
"고정": {
|
||||
"이름": "sub6임시 손 단가",
|
||||
"규격": "",
|
||||
"단위": "식",
|
||||
"단가": {"노무비": 12000, "재료비": 3000, "경비": 500},
|
||||
"이음": {"노임": "LB000002", "자재": None, "기계": None, "유가": None},
|
||||
},
|
||||
"수량": {"손": 2},
|
||||
}
|
||||
RATE = {
|
||||
"고정": {"이름": "공구손료", "단가": {}, "이음": {}, "비율": {"기준": "인력", "비목": "경비"}}
|
||||
}
|
||||
|
||||
|
||||
def _sk(**doc) -> str:
|
||||
return refs.create("sangeun", {"이름": "sub6임시", "단위": "㎡", "더한줄": [], **doc})["이름"]
|
||||
|
||||
|
||||
def _layer_samples(me: Path) -> dict[str, str]:
|
||||
"""개인 층 견본 — {갈래: 키}."""
|
||||
with store.at(me):
|
||||
keys = {
|
||||
"바탕": _sk(바탕={"로직": FORM}, 입력값={"유형": "복잡", "사용횟수": "3회"}),
|
||||
"율": _sk(바탕={"로직": SUB}, 단위="주", 더한줄=[{**RATE, "수량": 2}]),
|
||||
"기계": _sk(바탕={"로직": DIG}, 단위="㎥"),
|
||||
"재료": _sk(바탕={"로직": NET}, 입력값=NET_IN),
|
||||
}
|
||||
keys["형제"] = _sk(바탕={"참조": {**MINE, "키": keys["바탕"]}})
|
||||
keys["따로"] = _sk(바탕={"로직": PCT})
|
||||
read = sk_path.read(keys["따로"])
|
||||
twice = copy.deepcopy(read["문서"])
|
||||
twice["금액"][0]["수량"] = f"({twice['금액'][0].get('수량') or 1}) × 2"
|
||||
sk_path.save(keys["따로"], {"문서": twice, "판": read["판"]})
|
||||
row, src = _bonghwa()
|
||||
keys["가져온"] = imported.create(row, src, "sub6임시 가져온")["이름"]
|
||||
sc = {
|
||||
"이름": "sub6임시 일위대가",
|
||||
"단위": "㎡",
|
||||
"담은로직": [
|
||||
{"참조": {**MINE, "키": keys["바탕"]}, "수량": {"손": 1}},
|
||||
FIXED,
|
||||
{"로직": STONE, "입력값": {}, "수량": {"손": 1}},
|
||||
],
|
||||
"자재": [{"코드": "MT003810", "수량": {"손": 2}}],
|
||||
}
|
||||
keys["일위대가"] = refs.create("precombo", sc)["이름"]
|
||||
return keys
|
||||
|
||||
|
||||
def _structure(world, keys: dict[str, str], root: Path) -> None:
|
||||
"""구조물 사본(pipe@100.0) — 일위대가 열 문서를 지금 사본 길(`labor_doc_rows` · `price_bundle`)로."""
|
||||
me = world["personal"]
|
||||
lines = [
|
||||
{"참조": {**MINE, "키": keys[k]}, "수량": {"손": q}}
|
||||
for k, q in (("바탕", 2), ("율", 1), ("형제", 1), ("따로", 1), ("가져온", 1), ("기계", 3))
|
||||
]
|
||||
lines += [
|
||||
{"참조": {**MINE, "키": keys["재료"]}, "수량": {"손": 1}},
|
||||
{"참조": {**MINE, "키": keys["일위대가"]}, "수량": {"손": 1}},
|
||||
{"로직": STONE, "입력값": {}, "수량": {"손": 1}},
|
||||
{"로직": TWO_MATS, "수량": {"손": 1}},
|
||||
]
|
||||
with store.at(me):
|
||||
doc = labor.clean(
|
||||
{"열": "rv", "담은로직": lines, "자재": [{"코드": "MT003810", "수량": {"손": 2}}]}
|
||||
)
|
||||
rows = source.labor_doc_rows(doc)
|
||||
files = {
|
||||
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"]}},
|
||||
}
|
||||
folder = snapshots.structures_dir(root) / snapshots.folder_name("pipe@100.0")
|
||||
folder.mkdir(parents=True)
|
||||
for name, data in files.items():
|
||||
text = json.dumps(data, ensure_ascii=False, default=str)
|
||||
(folder / name).write_text(text, encoding="utf-8")
|
||||
|
||||
|
||||
HAND = [
|
||||
{"key": "hand:rate", "section": "1.1", "after": "", "spec": "", "name": "율 줄", "unit": "㎡", "qty": 2,
|
||||
"ref": {"tab": "logic", "code": PCT, "given": {}, "rate": None, "picks": None}},
|
||||
{"key": "hand:pick", "section": "1.1", "after": "hand:rate", "spec": "", "name": "고른 재료", "unit": "㎡", "qty": 1,
|
||||
"ref": {"tab": "logic", "code": TWO_MATS, "given": {}, "rate": None, "picks": {"1": "MT003196", "2": "MT003173"}}},
|
||||
{"key": "hand:net", "section": "1.1", "after": "hand:pick", "spec": "", "name": "입력", "unit": "㎡", "qty": 3,
|
||||
"ref": {"tab": "logic", "code": NET, "given": NET_IN, "rate": 90, "picks": None}},
|
||||
] # fmt: skip
|
||||
HAUL_REF = {"tab": "logic", "code": HAUL, "name": "골재운반", "given": {"Cm": 1}, "cycle": {}}
|
||||
USER = {
|
||||
"bill": {"qty": {}, "rows": HAND},
|
||||
"haul_refs": {"haul:r-u1": HAUL_REF},
|
||||
"haul_dist": {"haul:r-u1": {"L1": 25.1, "L2": 0.8}},
|
||||
}
|
||||
|
||||
|
||||
def _clean(value, root: Path):
|
||||
"""지문 꼴 — 임시 경로 · 때(날짜 · 시각)는 지움 · 수는 글로."""
|
||||
text = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
|
||||
text = text.replace(str(root).replace("\\", "\\\\"), "<root>").replace(str(root), "<root>")
|
||||
return re.sub(
|
||||
r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?", "<때>", text
|
||||
)
|
||||
|
||||
|
||||
def _split_text(value):
|
||||
"""(값, 글) — 산출근거 글(`text` · `head` · `foot` · `lines` 글 목록)을 따로 떼어 지문을 나눔."""
|
||||
words = []
|
||||
|
||||
def walk(v):
|
||||
if isinstance(v, dict):
|
||||
out = {}
|
||||
for k, x in v.items():
|
||||
if k in ("text", "head", "foot"):
|
||||
words.append(x)
|
||||
else:
|
||||
out[k] = walk(x)
|
||||
return out
|
||||
if isinstance(v, list):
|
||||
return [walk(x) for x in v]
|
||||
return v
|
||||
|
||||
return walk(value), words
|
||||
|
||||
|
||||
def answers(world, tmp_path) -> dict[str, object]:
|
||||
keys = _layer_samples(world["personal"])
|
||||
root = _project(tmp_path / "proj", [(100, "SS000901")])
|
||||
_structure(world, keys, root)
|
||||
for kind, key in (
|
||||
("sangeun", keys["따로"]),
|
||||
("sangeun", keys["가져온"]),
|
||||
("precombo", keys["일위대가"]),
|
||||
):
|
||||
library.import_copy(root, kind, "personal", OWNER, key)
|
||||
b09_store.write_user(root, USER)
|
||||
haul = {k: USER[k] for k in ("haul_refs", "haul_dist")} # 운반 연결 = 셈 때 거리이정표에서 붙음
|
||||
user = {**b09_store.read_user(root), **haul}
|
||||
out: dict[str, object] = {"키": keys}
|
||||
out["calc_user"] = b09.calc_user(root)
|
||||
out["daega_inputs"] = daega_inputs(root)
|
||||
out["수요"] = asyncio.run(b09._demand(root))
|
||||
for name, supply in (("산근", None), ("산근 관급", lambda _k: "관급")):
|
||||
sg = sangeun.build(root, user, None, supply)
|
||||
out[f"{name} 값"], out[f"{name} 글"] = _split_text(sg)
|
||||
for row in HAND:
|
||||
ref = row["ref"]
|
||||
body = b09.PreviewBody(
|
||||
code=ref["code"], given=ref["given"], rate=ref["rate"], picks=ref["picks"]
|
||||
)
|
||||
got = b09.logic_preview(root, body)
|
||||
got, words = _split_text(got)
|
||||
out[f"미리보기 {row['key']} 값"] = {k: v for k, v in got.items() if k != "lines"}
|
||||
out[f"미리보기 {row['key']} 글"] = [got.get("lines"), words]
|
||||
linked = snapshots.linked_snapshots(root)
|
||||
summary = {
|
||||
"linked": linked,
|
||||
"sources": [["rv:x", 12.0, folder, ["system||SS000901"]] for folder in sorted(linked)],
|
||||
"total": {"rv:x": 12.0},
|
||||
}
|
||||
out["B08 단위수량"] = b08.snapshot_units(root, summary)
|
||||
return {k: _clean(v, root) for k, v in out.items()}
|
||||
|
||||
|
||||
def _hash(text: str) -> str:
|
||||
return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _manual(monkeypatch):
|
||||
"""자동 따라옴 끔 — 저장본 그대로(층 꼴만 봄 · 자동은 test_836_2)."""
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
monkeypatch.setattr(renew, "on", lambda: False)
|
||||
|
||||
|
||||
def test_B08_B09_답_지문_같음(world, tmp_path):
|
||||
got = {k: _hash(v) for k, v in answers(world, tmp_path).items()}
|
||||
if WRITE:
|
||||
body = {"판": 1, "지문": got}
|
||||
FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8")
|
||||
want = json.loads(FILE.read_text("utf-8"))["지문"]
|
||||
bad = sorted(k for k in want.keys() | got.keys() if want.get(k) != got.get(k))
|
||||
assert not bad, (
|
||||
f"B08 · B09 답 지문 다름 — {bad}\n"
|
||||
f"뜻대로 금액 · 글을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드를 되짚음)"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if "--write" not in sys.argv:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
os.environ["S855B09_WRITE"] = "1"
|
||||
import tempfile
|
||||
|
||||
temp = str(Path(tempfile.gettempdir()) / "s855b09_pt") # 공용 임시 폴더 권한 막힘 피함
|
||||
sys.exit(pytest.main([__file__, "-q", "-p", "no:cacheprovider", "--basetemp", temp]))
|
||||
@@ -0,0 +1,33 @@
|
||||
"""855-A 지킴 ④ — 막힘 판정 옛(`master_formula.check_logic` · M01 로직 목록 · `/logic`) = 새(수식 문서
|
||||
표지 `master_doc.check`) 전수 · 막힘 기준 = 표지만(기본 입력으로 셈이 안 되는 것은 막힘 아님 · 판정 855-0).
|
||||
|
||||
걸음 2-B3(막힘 검사를 문서 기준으로) 앞뒤로 같아야 함 · 옛 검사를 지우는 걸음에서 옛 쪽만 뗌."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
md = importlib.import_module("master_doc")
|
||||
|
||||
|
||||
def test_막힘_옛_새_같음():
|
||||
rows, whole, docs, _ = h.world()
|
||||
old = {str(r["키"]) for r in rows if h.mf.check_logic(whole, r)[0]}
|
||||
new = {str(r["키"]) for r in rows if str(r["키"]) not in docs or md.check(docs[str(r["키"])])}
|
||||
assert old == new, {"옛만 막힘": sorted(old - new)[:20], "새만 막힘": sorted(new - old)[:20]}
|
||||
|
||||
|
||||
def test_틀린_식은_옛_새_모두_막힘():
|
||||
"""자가 살아 있는지 — 같은 로직의 식을 틀리게 하면 두 판정 모두 막힘(사본만 · 자료 안 고침)."""
|
||||
import copy
|
||||
|
||||
rows, whole, docs, _ = h.world()
|
||||
row = next(r for r in rows if r.get("호표") and str(r["키"]) in docs)
|
||||
bad_row = copy.deepcopy(row)
|
||||
bad_row["호표"][0]["수량"] = "없는변수 * 2"
|
||||
bad_doc = copy.deepcopy(docs[str(row["키"])])
|
||||
bad_doc["금액"][0]["수량"] = "없는기호 × 2"
|
||||
assert h.mf.check_logic(whole, bad_row)[0]
|
||||
assert md.check(bad_doc)
|
||||
@@ -0,0 +1,155 @@
|
||||
"""855-C 2-C4 지킴 — 서버 산출근거 글(`master_doc_text`) · 기준 목록 · 계산서가 문서 셈.
|
||||
|
||||
① 거울 — 글 규칙이 화면 TS 와 같음(헬퍼 `helper_855_c4_doc_text.cjs`):
|
||||
수 꼴(`eqText` · 줄 금액 · 원) · 단위 글(`unitText`) · 금액 줄 단위 자리 · 단가 기호
|
||||
(`moneyUnits` · `priceSym`) · 선택으로 꺼진 줄(`offLine`) · 비목 이름 — 실제 M01 수식 문서 전부
|
||||
(기본 입력 셈 답)로.
|
||||
② 계산서 — 줄 금액 · 소계 · 계 = 문서 셈 답 그대로 · 소계 합 = 계 ·
|
||||
줄 글 「단가 원/단위 * 수량 단위 = 금액」.
|
||||
③ 기준 목록 줄 금액 = 같은 입력의 문서 셈 계.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from decimal import Decimal
|
||||
from functools import lru_cache
|
||||
|
||||
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_Logic_Standard as st
|
||||
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
md = importlib.import_module("master_doc")
|
||||
mdt = importlib.import_module("master_doc_text")
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
NUMS = [0, 1, -1, 0.5, 1.5, 2.5, -2.5, 0.05, 0.15, 0.25, 0.35, 1.05, 1.15, 1.25, 2.675, 99.95,
|
||||
-0.05, 0.1 + 0.2, 1e-7, 1234567.891234567, 59018.0857142857, 284.42142857142,
|
||||
123456789012.345, 26890.75, 1502.04999] # fmt: skip
|
||||
|
||||
|
||||
def _js(v):
|
||||
if isinstance(v, Decimal):
|
||||
return float(v)
|
||||
if isinstance(v, dict):
|
||||
return {k: _js(x) for k, x in v.items()}
|
||||
if isinstance(v, (list, tuple)):
|
||||
return [_js(x) for x in v]
|
||||
if isinstance(v, (mc.Blank, mc.Stop)):
|
||||
return None
|
||||
return v
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def world():
|
||||
"""(문서들, 연결, {키: 기본 셈 답})."""
|
||||
whole = m01.loaded()[1]
|
||||
docs = m01_doc.docs()
|
||||
links = st._links(whole)
|
||||
answers = {k: mc.calc(d, links, None) for k, d in docs.items() if d.get("금액")}
|
||||
return docs, links, answers
|
||||
|
||||
|
||||
def _helper(payload: dict) -> dict:
|
||||
run = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_855_c4_doc_text.cjs")],
|
||||
input=json.dumps(payload, ensure_ascii=False),
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
check=True,
|
||||
)
|
||||
return json.loads(run.stdout)
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def mirror():
|
||||
docs, links, answers = world()
|
||||
nums, units, lines, offs, py = list(NUMS), set(), [], [], {"단위": [], "줄": [], "꺼짐": []}
|
||||
for key, a in answers.items():
|
||||
doc = docs[key]
|
||||
vars_ = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
units |= {str(v.get("단위") or "") for v in doc.get("변수") or []}
|
||||
units.add(str(doc.get("결과단위") or ""))
|
||||
for row in a.get("줄") or []:
|
||||
nums += [_js(row.get(k)) for k in ("단가", "수량", "금액")]
|
||||
for line in doc["금액"]:
|
||||
units.add(str(line.get("단위") or ""))
|
||||
sym = mdt.price_sym(line)
|
||||
pv = vars_.get(sym) if sym else None
|
||||
link = (pv or {}).get("연결") or {}
|
||||
sub = None
|
||||
if link.get("갈래") == "단가산출" and link.get("키") and "{" not in str(link["키"]):
|
||||
got = links.doc(str(link["키"]))
|
||||
sub = {"결과단위": got.get("결과단위")} if got else None
|
||||
lines.append({"줄": _js(line), "단가변수": _js(pv), "부름": sub})
|
||||
nodes = (mdt.node_of(line.get("단가")), mdt.node_of(line.get("수량")))
|
||||
py["줄"].append((mdt.money_units(line, *nodes, pv, sub), sym))
|
||||
look = mdt._Look(doc, a, links)
|
||||
vals = {k: v for k, v in (a.get("값") or {}).items() if v is not None}
|
||||
part = {"식": _js(doc.get("식") or []), "금액": _js(doc["금액"])}
|
||||
offs.append({"문서": part, "값": _js(vals)})
|
||||
py["꺼짐"].append([look.off_line(line) for line in doc["금액"]])
|
||||
nums = [x for x in nums if isinstance(x, (int, float))]
|
||||
units |= {"%(인력품 대비)", "10^-7/시간", "kWh/hr", "줄 따름", "수(개)", "원문 단위 없음"}
|
||||
units = sorted(units)
|
||||
ts = _helper({"수": nums, "원": nums, "단위": units, "금액줄": lines, "꺼짐": offs})
|
||||
return nums, units, py, ts
|
||||
|
||||
|
||||
def test_수_꼴_eqText_한자리_원():
|
||||
nums, _, _, ts = mirror()
|
||||
assert len(nums) > 5000
|
||||
assert [mdt.eq_text(v) for v in nums] == ts["eq"]
|
||||
assert [mdt.one(v) for v in nums] == ts["one"]
|
||||
assert [mdt.won(v) for v in nums] == ts["won"]
|
||||
texts = ("5401-0017", "", " ", "1048")
|
||||
assert [mdt.eq_text(v) for v in texts] == ["5401-0017", "", " ", "1,048"]
|
||||
|
||||
|
||||
def test_단위_글_금액줄_단위_자리_단가_기호():
|
||||
_, units, py, ts = mirror()
|
||||
assert [mdt.unit_text(u) for u in units] == ts["단위"]
|
||||
assert len(py["줄"]) > 5000
|
||||
assert [u for u, _ in py["줄"]] == ts["금액줄"]
|
||||
assert [s for _, s in py["줄"]] == ts["기호"]
|
||||
assert any(u["wrap"] for u, _ in py["줄"]) and any(u["price"] for u, _ in py["줄"])
|
||||
|
||||
|
||||
def test_선택으로_꺼진_줄_비목_이름():
|
||||
_, _, py, ts = mirror()
|
||||
assert py["꺼짐"] == ts["꺼짐"]
|
||||
assert sum(map(sum, py["꺼짐"])) > 0 # 꺼진 줄이 실제로 있음(판정이 일을 함)
|
||||
assert mdt.COST_SHOW == ts["비목"] and mdt.LONG_SUM == ts["항"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("key", ("GF000220", "GF000089", "GC000404", "GF000101"))
|
||||
def test_계산서_문서_셈_답_그대로(key):
|
||||
got = st.sheet(key, {})
|
||||
docs, links, _ = world()
|
||||
answer = mc.calc(docs[key], links, st._given(m01.loaded()[1], docs[key], {})[0])
|
||||
assert got["계"] == float(answer["계"]) and got["계"] == sum(g["소계"] for g in got["묶음"])
|
||||
for g in got["묶음"]:
|
||||
assert g["소계"] == float(answer[g["비목"]])
|
||||
for line in g["줄"]:
|
||||
assert line["글"].endswith(f"= {mdt.one(line['금액'] or 0)}")
|
||||
assert " * " in line["글"] or line["글"].startswith("—")
|
||||
first = got["묶음"][0]["줄"][0]
|
||||
if key == "GF000220": # 석공 노임 — 「268,908 원/인 * 0.1 인 = 26,890.8」
|
||||
assert first["이름"] == "석공" and first["글"].startswith("268,908 원/인 * 0.1 인 = ")
|
||||
|
||||
|
||||
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):
|
||||
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,46 @@
|
||||
"""855-A 지킴 ① — 로직 전수 옛 엔진 대 새 계산기(저장된 수식 문서) · 걸음 2 동안 「다름 0」 자.
|
||||
|
||||
- 기본 입력 전수(관문 · 십여 초) · 옵션 표본 전수 = 환경 `S855_ALL=1`(3 분 남짓).
|
||||
- 층 L0 합계 · L1 줄 비목 · L2 줄 꼴 · L3 수량 · 단가(`helper_855_engine.level`).
|
||||
- 다름 = 채택된 차이와 같아야 함(합계 = 빌더 `ADOPTED` 그대로 · 줄 비목 = 같은 까닭의 문서만) ·
|
||||
「보임」(보이는 단가만 · 금액 같음)은 허용 갈래로 셈.
|
||||
- 옛 엔진을 지우는 걸음(2-E4)에서 은퇴 — 그 뒤는 `test_855_golden` 이 지킴.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
ALL = os.environ.get("S855_ALL") == "1"
|
||||
|
||||
|
||||
def _diffs(options: bool) -> dict[str, list]:
|
||||
rows, _, docs, _ = h.world()
|
||||
out: dict[str, list] = {"문서 없음": [], "채택 밖": [], "채택": [], h.SEEN: []}
|
||||
for row in rows:
|
||||
key = str(row["키"])
|
||||
doc = docs.get(key)
|
||||
if doc is None:
|
||||
out["문서 없음"].append(key)
|
||||
continue
|
||||
money = not doc.get("결과")
|
||||
for label, given, changed in h.cases(row, options):
|
||||
lv = h.level(h.old_run(row, given), h.new_run(doc, changed), money)
|
||||
if lv == h.SEEN:
|
||||
out[h.SEEN].append((key, label))
|
||||
elif lv and h.adopted(key, label, lv):
|
||||
out["채택"].append((key, label, lv))
|
||||
elif lv:
|
||||
out["채택 밖"].append((key, label, lv))
|
||||
return out
|
||||
|
||||
|
||||
def test_로직마다_수식_문서_있음_옛_대_새_다름은_채택뿐():
|
||||
got = _diffs(ALL)
|
||||
assert got["문서 없음"] == []
|
||||
assert got["채택 밖"] == [], got["채택 밖"][:20]
|
||||
total = {(k, o) for k, o, lv in got["채택"] if lv == "L0"}
|
||||
want = {x for x in h.build.ADOPTED if not x[1]} if not ALL else set(h.build.ADOPTED)
|
||||
assert total == want # 채택 목록이 다 나오고 그 밖은 없음(기본만 돌면 옵션 채택은 안 나옴)
|
||||
@@ -0,0 +1,47 @@
|
||||
"""855-A 지킴 ② — 새 계산기 답 지문(로직마다 기본 + 옵션 표본 · 노 · 재 · 경 · 계 · 줄 금액 · 비목).
|
||||
|
||||
- 지문 = `golden_855_engine.json`(로직 키 → 답 묶음 sha256 앞 16 자 · `helper_855_engine.fingerprint`).
|
||||
- 다르면 실패 — 계산기 · 수식 문서 · M01 자료가 금액을 바꿨다는 뜻. 자료 · 규칙을 **뜻대로 바꾼 걸음만**
|
||||
다시 뜸: `./venv/Scripts/python.exe resources/tester/test_855_golden.py --write`(바뀐 키를 커밋 글에).
|
||||
- 옛 엔진을 지운 뒤(2-E4) 옛 → 새 대조(`test_855_engine_parity` · `test_802_2`)를 이것이 대신함.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
FILE = HERE / "golden_855_engine.json"
|
||||
REDO = "./venv/Scripts/python.exe resources/tester/test_855_golden.py --write"
|
||||
|
||||
|
||||
def current() -> dict[str, str]:
|
||||
import helper_855_engine as h
|
||||
|
||||
rows, _, docs, _ = h.world()
|
||||
return {str(r["키"]): h.fingerprint(str(r["키"]), r) for r in rows if str(r["키"]) in docs}
|
||||
|
||||
|
||||
def test_새_계산기_답_지문_같음():
|
||||
want = json.loads(FILE.read_text("utf-8"))["지문"]
|
||||
got = current()
|
||||
changed = sorted(k for k in want.keys() & got.keys() if want[k] != got[k])
|
||||
gone, new = sorted(want.keys() - got.keys()), sorted(got.keys() - want.keys())
|
||||
assert not (changed or gone or new), (
|
||||
f"지문 다름 — 바뀜 {len(changed)} {changed[:20]} · 빠짐 {gone[:20]} · 새 키 {new[:20]}\n"
|
||||
f"뜻대로 금액을 바꾼 걸음이면 다시 뜸: {REDO} (아니면 고친 코드 · 자료를 되짚음)"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ROOT = HERE.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
if "--write" not in sys.argv:
|
||||
sys.exit(f"다시 뜨기 = {REDO}")
|
||||
body = {"판": 1, "지문": dict(sorted(current().items()))}
|
||||
FILE.write_text(json.dumps(body, ensure_ascii=False, indent=1) + "\n", "utf-8", newline="\n")
|
||||
print(f"지문 {len(body['지문'])} 씀 → {FILE.name}")
|
||||
@@ -0,0 +1,125 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""855-A 지킴 ③ — 단가산출(SK) 셈 답 · 견본 꼴마다 옛 엔진 길(`M02_Doc_Sk.OLD`) 대 지금 길(수식 사본 →
|
||||
문서 계산기) · 지금 길 답의 줄 비목 합(원 버림) = 기준.
|
||||
|
||||
견본(임시 storage · 개인 층 · M01 은 읽기만): 바탕 로직 · 옛 칸 값(더한줄 로직) · 율 더한줄 · 형제 SK(바탕 참조) ·
|
||||
「따로」(수식 사본을 고쳐 저장) · 가져온 식(엑셀 줄 · 저장 없음).
|
||||
걸음 2-C1(SK 셈 한 길)이 이 시험을 자로 씀 — 「따로」 단언은 지금 사실(줄 = 옛 · 기준 = 새)이고 2-C1 에서 뒤집음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
from decimal import ROUND_DOWN, Decimal
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Calc as calc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from resources.tester import test_793_2_sangeun_imported as imported
|
||||
from resources.tester.test_778_4_rate_line import SUB, _rate
|
||||
from resources.tester.test_795_1_sk_copy import PCT, _doc, _sk
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
FORM = "GC000211" # 합판거푸집
|
||||
ADD = {"종류": "로직", "로직": "GF000089", "수량": 2, "입력값": {}, "이름": "sub6임시 굴착기"}
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _manual(monkeypatch):
|
||||
"""자동 따라옴 끔 — 저장본 그대로 셈(층 꼴만 봄)."""
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
monkeypatch.setattr(renew, "on", lambda: False)
|
||||
|
||||
|
||||
def _run(doc: dict, old: bool) -> dict:
|
||||
whole = m01.loaded()[1]
|
||||
token = dsk.OLD.set(old)
|
||||
try:
|
||||
return calc.run(sd.clean(doc, None, whole), whole)
|
||||
finally:
|
||||
dsk.OLD.reset(token)
|
||||
|
||||
|
||||
def _both(folder, doc) -> tuple[dict, dict]:
|
||||
with store.at(folder):
|
||||
return _run(doc, True), _run(doc, False)
|
||||
|
||||
|
||||
def _lines_sum(got: dict) -> dict:
|
||||
total = {k: Decimal(0) for k in COSTS}
|
||||
for ln in got.get("줄") or []:
|
||||
for k in COSTS:
|
||||
v = (ln.get("비목") or {}).get(k)
|
||||
total[k] += Decimal(str(v)) if v is not None else 0
|
||||
return {k: v.quantize(Decimal(1), ROUND_DOWN) for k, v in total.items()}
|
||||
|
||||
|
||||
def _base(got: dict) -> dict:
|
||||
return {k: Decimal(str(got["기준"][k])).quantize(Decimal(1), ROUND_DOWN) for k in COSTS}
|
||||
|
||||
|
||||
def _same_paths(old: dict, new: dict) -> None:
|
||||
assert old["기준"] is not None and new["기준"] is not None
|
||||
assert {k: Decimal(str(old["기준"][k])) for k in COSTS} == {
|
||||
k: Decimal(str(new["기준"][k])) for k in COSTS
|
||||
}
|
||||
assert _lines_sum(new) == _base(new)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"바탕": {"로직": FORM}},
|
||||
{"바탕": {"로직": PCT}},
|
||||
{"바탕": {"로직": FORM}, "더한줄": [ADD]}, # 옛 칸 값(더한줄 로직)
|
||||
{"바탕": {"로직": SUB}, "더한줄": [_rate("인력", 2)], "단위": "주"}, # 율 더한줄
|
||||
],
|
||||
ids=["바탕", "율_바탕", "옛칸_더한줄", "율_더한줄"],
|
||||
)
|
||||
def test_층_SK_옛_대_새_같고_줄_합_기준(world, body):
|
||||
me = world["personal"]
|
||||
key = _sk(me, **copy.deepcopy(body))
|
||||
doc = _doc(me, key)
|
||||
old, new = _both(me, doc)
|
||||
assert "수식셈" in new # 지금 길 = 수식 사본 문서 셈
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_형제_SK_바탕_참조(world):
|
||||
me = world["personal"]
|
||||
first = _sk(me, 바탕={"로직": FORM})
|
||||
second = _sk(me, 바탕={"참조": {"층": "personal", "주인": "7/42", "키": first}})
|
||||
old, new = _both(me, _doc(me, second))
|
||||
_same_paths(old, new)
|
||||
assert new["기준"] == _both(me, _doc(me, first))[1]["기준"]
|
||||
|
||||
|
||||
def test_가져온_식_옛_대_새(world):
|
||||
old, new = _both(world["personal"], imported._doc())
|
||||
assert "수식셈" in new
|
||||
_same_paths(old, new)
|
||||
|
||||
|
||||
def test_따로_SK_지금은_줄_옛_기준_새(world):
|
||||
"""「따로」 = 고친 수식 사본이 정본 — 지금 셈 답은 줄 = 옛 엔진(옛 칸) · 기준 = 문서 계산기라 갈림.
|
||||
2-C1 에서 뒤집을 단언 — 그 뒤엔 `_same_paths` 꼴(줄 합 = 기준)로 바꿈."""
|
||||
me = world["personal"]
|
||||
key = _sk(me, 바탕={"로직": PCT})
|
||||
with store.at(me):
|
||||
read = path.read(key)
|
||||
twice = copy.deepcopy(read["문서"])
|
||||
line = twice["금액"][0]
|
||||
line["수량"] = f"({line.get('수량') or 1}) × 2"
|
||||
saved = path.save(key, {"문서": twice, "판": read["판"]})
|
||||
assert saved["사본"]["따로"] is True
|
||||
old, new = _both(me, _doc(me, key))
|
||||
assert new["수식셈"]["따로"] is True
|
||||
assert _base(new) != _base(old) # 2-C1 에서 뒤집을 단언 — 기준이 옛 길과 다름
|
||||
assert _lines_sum(new) == _base(old) != _base(new) # 2-C1 에서 뒤집을 단언 — 줄 = 옛 길
|
||||
@@ -0,0 +1,170 @@
|
||||
"""855-F B9-1 지킴 — 문서 셈 기록(`master_doc_trace`) · 로직 전수 기본 입력.
|
||||
|
||||
- 기록을 켜도 셈 답 같음(줄 `부름` · 답 `부름` `자원` 칸만 더해짐).
|
||||
- 자원 키 = 옛 엔진 셈 중 `whole.get` 가로채기 키(B09 `hand_resource_keys` 방식 ·
|
||||
찾기 색인 데운 뒤) — 다름 = `MORE` 뿐(새 계산기는 이름마다 셈 — 옛은 안 고른 「만약」 갈래 ·
|
||||
빈 수량 줄 · 앞서 멈춘 줄을 안 읽음 · 새 쪽에만 더 있음).
|
||||
- 하위 부름 = 옛 `B09 line_calls`(돈 문서 {code, given} · 기계경비 {machine}) — 다름 = 옛이 입력
|
||||
기본값을 못 세 빈 답인 문서뿐 · 새 쪽 결과 문서 부름(작업량 등 중간 값)은 하위 산근 아님.
|
||||
- 고른 품목 = `master_pick.priced` 의 품목 키 · 줄 `부름` = 그 줄 자원.
|
||||
- 옛 엔진을 지우는 걸음(2-E4)에서 옛 대조(자원 · 하위)는 은퇴.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import json
|
||||
from functools import lru_cache
|
||||
|
||||
import helper_855_engine as h
|
||||
|
||||
mt = importlib.import_module("master_doc_trace")
|
||||
mp = importlib.import_module("master_pick")
|
||||
mm = importlib.import_module("master_material")
|
||||
|
||||
MORE = { # 새 쪽에만 더 있는 자원 키 — 까닭
|
||||
"GC001200": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈",
|
||||
"GC001201": "옛 엔진이 빈 입력에서 멈춤 · 새는 전력 재료 이름도 셈",
|
||||
"GF000312": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000313": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000320": "「만약(기종 …)」 안 고른 갈래 기계도 이름으로 셈",
|
||||
"GF000192": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000200": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000203": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
"GF000209": "옛은 수량 빈 줄의 재료 단가를 안 읽음",
|
||||
}
|
||||
|
||||
|
||||
def sg():
|
||||
from B09_Estimation import B09_Estimation_Sangeun as mod
|
||||
|
||||
return mod
|
||||
|
||||
|
||||
def mc_calc(doc: dict, links) -> dict:
|
||||
return importlib.import_module("master_doc_calc").calc(doc, links)
|
||||
|
||||
|
||||
def _old_keys(whole, row: dict, given: dict) -> set[str]:
|
||||
seen: set[str] = set()
|
||||
base = whole.get
|
||||
|
||||
def get(ref):
|
||||
got = base(ref)
|
||||
key = str(got.get("키") or "")
|
||||
if key[:2] in mt.CAT:
|
||||
seen.add(key)
|
||||
return got
|
||||
|
||||
whole.get = get
|
||||
try:
|
||||
h.old_run(row, given)
|
||||
finally:
|
||||
del whole.get
|
||||
return seen
|
||||
|
||||
|
||||
def _strip(got: dict) -> dict:
|
||||
out = {k: v for k, v in got.items() if k not in ("부름", "자원")}
|
||||
if "줄" in out:
|
||||
out["줄"] = [{k: v for k, v in ln.items() if k != "부름"} for ln in out["줄"]]
|
||||
return out
|
||||
|
||||
|
||||
def _calls(old: dict, new: dict, docs: dict) -> tuple[set, set]:
|
||||
a = {json.dumps(v, ensure_ascii=False, sort_keys=True, default=str) for v in old.values()}
|
||||
b = set()
|
||||
for c in new["부름"]:
|
||||
if c["깊이"] != 1 or c["갈래"] != "단가산출":
|
||||
continue
|
||||
if (docs.get(str(c["부름"].get("키"))) or {}).get("결과"):
|
||||
continue # 결과 문서 = 중간 값
|
||||
one = (
|
||||
{"machine": c["기계"]}
|
||||
if "기계" in c
|
||||
else {"code": c["부름"]["키"], "given": sg()._clean_given(c["부름"].get("입력"))}
|
||||
)
|
||||
b.add(json.dumps(one, ensure_ascii=False, sort_keys=True, default=str))
|
||||
return a, b
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def survey() -> dict:
|
||||
rows, whole, docs, links = h.world()
|
||||
rows = [r for r in rows if str(r["키"]) in docs]
|
||||
for row in rows: # 재료 찾기 색인 데움(첫 찾기 때 훑은 후보 읽음 빼려고)
|
||||
h.old_run(row, h.cases(row, False)[0][1])
|
||||
trace = mt.Trace(whole, docs)
|
||||
out = {"답 다름": [], "자원": {}, "하위": {}, "품목": [], "줄": [], "옛 빈 답": set()}
|
||||
for row in rows:
|
||||
key = str(row["키"])
|
||||
doc, given = docs[key], h.cases(row, False)[0][1]
|
||||
old = _old_keys(whole, row, given)
|
||||
got = mt.calc(doc, trace)
|
||||
if _strip(got) != mc_calc(doc, links):
|
||||
out["답 다름"].append(key)
|
||||
new = set(got["자원"])
|
||||
if old != new:
|
||||
out["자원"][key] = (sorted(old - new), sorted(new - old))
|
||||
lines = sg().line_calls(whole, key, given)
|
||||
a, b = _calls(lines, got, docs)
|
||||
if a != b:
|
||||
out["하위"][key] = (sorted(a), sorted(b))
|
||||
if not lines:
|
||||
try:
|
||||
sg()._env(whole, row, sg()._clean_given(given))
|
||||
except Exception:
|
||||
out["옛 빈 답"].add(key)
|
||||
for c in got["부름"]:
|
||||
p = c["부름"]
|
||||
if c["깊이"] == 1 and "품목" in c and p.get("재료") is not None:
|
||||
env = {mm.REGION: p["지역"]} if p.get("지역") is not None else {}
|
||||
if p.get("계약종별") is not None:
|
||||
env[mm.TARIFF] = p["계약종별"]
|
||||
want = mp.priced(whole, {"단위": p.get("단위")}, p["재료"], env, None)[3]
|
||||
if want.get("품목") and want["품목"]["키"] != c["품목"]:
|
||||
out["품목"].append((key, c["이름"], want["품목"]["키"], c["품목"]))
|
||||
for ln in got.get("줄") or []:
|
||||
for i in ln["부름"]:
|
||||
if not (0 <= i < len(got["부름"])) or got["부름"][i]["깊이"] != 1:
|
||||
out["줄"].append((key, ln["이름"], i))
|
||||
return out
|
||||
|
||||
|
||||
def test_기록_켜도_셈_답_같음():
|
||||
assert survey()["답 다름"] == []
|
||||
|
||||
|
||||
def test_자원_키_옛_가로채기와_같음_다름은_까닭_목록뿐():
|
||||
got = survey()["자원"]
|
||||
assert all(not old for old, _ in got.values()), {k: v for k, v in got.items() if v[0]}
|
||||
assert sorted(got) == sorted(MORE), sorted(got)
|
||||
|
||||
|
||||
def test_하위_부름_옛_call_of_와_같음_다름은_옛_빈_답뿐():
|
||||
s = survey()
|
||||
assert set(s["하위"]) == s["옛 빈 답"], {
|
||||
k: s["하위"][k] for k in set(s["하위"]) - s["옛 빈 답"]
|
||||
}
|
||||
assert all(not old for old, _ in s["하위"].values())
|
||||
|
||||
|
||||
def test_고른_품목_줄_부름():
|
||||
s = survey()
|
||||
assert s["품목"] == []
|
||||
assert s["줄"] == []
|
||||
|
||||
|
||||
def test_기계경비_부름_기계_키_줄마다_부름():
|
||||
_, whole, docs, _ = h.world()
|
||||
got = mt.calc(
|
||||
docs["GC000337"], mt.Trace(whole, docs)
|
||||
) # 낙석방지망 — 인력 둘 · 크레인 · 재료 셋
|
||||
lines = {ln["이름"]: [got["부름"][i] for i in ln["부름"]] for ln in got["줄"]}
|
||||
crane = [c for c in lines["크레인"] if c["갈래"] == "단가산출"]
|
||||
assert [c["부름"]["키"] for c in crane] == ["GC000268"] and crane[0]["기계"][:2] == "EQ"
|
||||
assert {x["키"][:2] for c in lines["특별인부"] for x in c["자원"]} == {"LB", "QC"}
|
||||
assert [c["품목"] for c in lines["에폭시"] if "품목" in c] == [got["자원"][-1]]
|
||||
assert set(got["자원"]) >= {
|
||||
x["키"] for c in got["부름"] for x in c["자원"] if x["갈래"] != "표"
|
||||
}
|
||||
Reference in New Issue
Block a user