eomsangdonandClaude Opus 5.5
91c743382b
- _sample/masonry.json — 돌쌓기 메쌓기(인력): 변수 · 품표(QF000421) · 증가율표(QF000422) · 인력 → 증가율 찾기 → 품(둘) → 노무비(둘) → 합 → 출력 노무비 - _sample/rate.json — 공구손료(비율): 노무비 × 율 → 출력 재료비 - _sample/value.json — 덤프트럭 시간당 작업량: q · f · E · Cm → 출력 값 - 시험 test_m02_cf_sample.py — 모양 · 알약 이름 규칙 · 견본 ① 노무비 148,470.504 = /calc GF000219 · ③ = GF000133 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01BU9gbNE3aWFUvE61pS2WGt
250 lines
11 KiB
Python
250 lines
11 KiB
Python
"""M02 단가산출 다이어그램 견본(35-7) 시험 — `M02_MasterTemplete/CostFlow/_sample/*.json` · `M02_CF_Sample.ts`.
|
||
|
||
· 견본 셋 모양 — 상자(입력 · 함수 · 출력) · 알약 이름 규칙 · 선(받는 자리마다 하나 · 출력에서 안 나감 · 순환 없음)
|
||
· 견본 ① 원가 = 지금 `/calc`(GF000219 · 같은 예시값 · 끝수 원 미만) — 함수 상자 시트를 우리 스프레드시트 엔진
|
||
(Node 번들)으로 차례대로 셈 · 입력 값(노임 · 품셈 표)은 마스터에서 읽기만
|
||
· ③ 값 = `/calc`(GF000133) · ② = 노무비 × 율 / 100
|
||
· `sampleList` · `sampleLoad`(사본 · key 없음) — Node 로 바로 돌림 · 파일 안 씀
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import shutil
|
||
import subprocess
|
||
from decimal import Decimal
|
||
from pathlib import Path
|
||
|
||
import pytest
|
||
|
||
ROOT = Path(__file__).resolve().parents[2]
|
||
FOLDER = ROOT / "M02_MasterTemplete" / "CostFlow"
|
||
SAMPLE_TS = FOLDER / "M02_CF_Sample.ts"
|
||
SAMPLES = {p.stem: json.loads(p.read_text(encoding="utf-8")) for p in sorted((FOLDER / "_sample").glob("*.json"))} # fmt: skip
|
||
|
||
HOOKS = r"""
|
||
import { readFileSync } from "node:fs";
|
||
import { fileURLToPath } from "node:url";
|
||
import { stripTypeScriptTypes } from "node:module";
|
||
export async function load(url, ctx, next) {
|
||
if (!url.endsWith(".ts")) return next(url, ctx);
|
||
let src = readFileSync(fileURLToPath(url), "utf8");
|
||
src = src.replace(/import\.meta\.glob(?:<[\s\S]*?>)?\([^)]*\)/g, "globalThis.__samples");
|
||
src = src.replace(/import\s*\{([^}]*)\}\s*from\s*"([^"]+)";/g, (m, names) => {
|
||
const list = names.split(",").map((x) => x.trim()).filter((x) => x && !x.startsWith("type "));
|
||
return list.length ? `const { ${list.join(", ")} } = globalThis.__stub;` : "";
|
||
});
|
||
return { format: "module", source: stripTypeScriptTypes(src, { mode: "transform" }), shortCircuit: true };
|
||
}
|
||
"""
|
||
|
||
|
||
def _node(body: str) -> object:
|
||
files = {f"./_sample/{k}.json": v for k, v in SAMPLES.items()}
|
||
script = (
|
||
"import { register } from 'node:module';\n"
|
||
f"register('data:text/javascript,' + encodeURIComponent({json.dumps(HOOKS)}));\n"
|
||
"globalThis.__stub = { currentLanguageIndex: 0 };\n"
|
||
f"globalThis.__samples = {json.dumps(files, ensure_ascii=False)};\n"
|
||
f"const S = await import({json.dumps(SAMPLE_TS.as_uri())});\n"
|
||
"const out = (x) => process.stdout.write(JSON.stringify(x));\n" + body
|
||
)
|
||
result = subprocess.run(
|
||
["node", "--no-warnings", "--input-type=module", "-e", script],
|
||
capture_output=True, text=True, encoding="utf-8", timeout=120, cwd=ROOT,
|
||
) # fmt: skip
|
||
assert result.returncode == 0, result.stderr[-2000:]
|
||
return json.loads(result.stdout)
|
||
|
||
|
||
# ── 모양 ─────────────────────────────────────────────────────────────────
|
||
def _ports_out(box: dict) -> list[str]:
|
||
if box["kind"] == "function":
|
||
return [box["func"]["output"]["name"]]
|
||
if box["kind"] == "output":
|
||
return []
|
||
inp = box["input"]
|
||
return (
|
||
[e["name"] for e in inp.get("elements", [])]
|
||
+ (["표"] if inp.get("table") else [])
|
||
+ [v["name"] for v in inp.get("variables", [])]
|
||
)
|
||
|
||
|
||
def _ports_in(box: dict) -> list[str]:
|
||
if box["kind"] == "function":
|
||
return [i["port"] for i in box["func"]["inputs"]]
|
||
return ["값"] if box["kind"] == "output" else []
|
||
|
||
|
||
def _order(lg: dict) -> list[dict]:
|
||
"""함수 상자 차례(앞 값을 받는 것이 뒤) — 순환이면 실패"""
|
||
boxes = {b["id"]: b for b in lg["boxes"]}
|
||
need = {b["id"]: {link["from"]["box"] for link in lg["links"] if link["to"]["box"] == b["id"]} for b in lg["boxes"]} # fmt: skip
|
||
done: list[str] = []
|
||
while len(done) < len(boxes):
|
||
ready = [i for i in boxes if i not in done and need[i] <= set(done)]
|
||
assert ready, "선이 돌고 돎"
|
||
done += ready
|
||
return [boxes[i] for i in done]
|
||
|
||
|
||
@pytest.mark.parametrize("name", ["masonry", "rate", "value"])
|
||
def test_견본_모양(name: str) -> None:
|
||
lg = SAMPLES[name]
|
||
assert lg["key"] and lg["name"] and lg["resultUnit"] and lg["userElements"] == []
|
||
boxes = {b["id"]: b for b in lg["boxes"]}
|
||
assert len(boxes) == len(lg["boxes"])
|
||
sheets = [b["func"]["sheet"]["id"] for b in lg["boxes"] if b["kind"] == "function"]
|
||
assert len(set(sheets)) == len(sheets)
|
||
for b in lg["boxes"]:
|
||
assert b["kind"] in ("input", "function", "output")
|
||
assert (
|
||
b["color"].startswith("#")
|
||
and b["unit"]
|
||
and isinstance(b["x"], int)
|
||
and isinstance(b["y"], int)
|
||
)
|
||
if b["kind"] == "function":
|
||
fn = b["func"]
|
||
cells = fn["sheet"]["칸"]
|
||
assert "식" in cells[fn["output"]["cell"]] # 출력 하나 = 수식 칸
|
||
assert len({i["cell"] for i in fn["inputs"]}) == len(fn["inputs"])
|
||
if b["kind"] == "output":
|
||
assert b["output"]["cost"] in ("노무비", "재료비", "경비", "값")
|
||
for link in lg["links"]:
|
||
a, z = boxes[link["from"]["box"]], boxes[link["to"]["box"]]
|
||
assert link["from"]["name"] in _ports_out(a), link
|
||
assert link["to"]["name"] in _ports_in(z), link
|
||
# 받는 자리마다 선 하나 · 출력에서 나가는 선 없음 · 왼 → 오
|
||
for b in lg["boxes"]:
|
||
for port in _ports_in(b):
|
||
got = [x for x in lg["links"] if x["to"]["box"] == b["id"] and x["to"]["name"] == port]
|
||
assert len(got) == 1, (b["id"], port)
|
||
for link in lg["links"]:
|
||
assert boxes[link["from"]["box"]]["kind"] != "output"
|
||
assert boxes[link["from"]["box"]]["x"] < boxes[link["to"]["box"]]["x"]
|
||
_order(lg)
|
||
|
||
|
||
def test_견본_목록_열기() -> None:
|
||
got = _node(
|
||
"out({ list: S.sampleList(), one: S.sampleLoad('masonry'), none: S.sampleLoad('없음') });"
|
||
)
|
||
assert [x["id"] for x in got["list"]] == ["masonry", "rate", "value"]
|
||
assert all(x["note"] for x in got["list"])
|
||
assert got["one"]["key"] is None and got["one"]["boxes"] == SAMPLES["masonry"]["boxes"]
|
||
assert got["none"] is None
|
||
|
||
|
||
# ── 값 ───────────────────────────────────────────────────────────────────
|
||
@pytest.fixture(scope="module")
|
||
def master():
|
||
from M01_MasterData import M01_MasterData_Store as store
|
||
|
||
cm = store.cm
|
||
files = cm.load(folder=store.FOLDER)
|
||
return cm, files
|
||
|
||
|
||
def _table_rows(table: dict) -> list[list]:
|
||
"""품셈 표 → 블록(머리 줄 + 줄) — 서버 「표」 와 같은 규칙(범위 = 「이름·아래」 「이름·위」 · 숫자 하나면 둘 다)"""
|
||
conds, lines = table.get("조건") or {}, table.get("줄") or []
|
||
names = [*conds, *(table.get("값칸") or {})]
|
||
split = {
|
||
n for n in names if conds.get(n) == "범위" or any(isinstance(r.get(n), list) for r in lines)
|
||
}
|
||
head = [h for n in names for h in ((f"{n}·아래", f"{n}·위") if n in split else (n,))]
|
||
rows = []
|
||
for r in lines:
|
||
line: list = []
|
||
for n in names:
|
||
v = r.get(n)
|
||
if n in split:
|
||
line += list(v) if isinstance(v, list) else [v, v]
|
||
else:
|
||
line.append(v)
|
||
rows.append(line)
|
||
return [head, *rows]
|
||
|
||
|
||
def _plain(v):
|
||
return float(v) if isinstance(v, Decimal) else v
|
||
|
||
|
||
def _run(lg: dict, master) -> dict:
|
||
"""상자 차례대로 — 입력 값(예시값 · 노임 · 표) → 함수 상자 시트에 넣고 엔진으로 셈 → 출력 상자 값"""
|
||
from common_util.common_util_spreadsheet import recalc_workbooks
|
||
|
||
cm, files = master
|
||
m = cm.mf.Master(files)
|
||
tables = {str(t["키"]): t for d in files.values() if d.get("그룹") in cm.mf.TABLE_GROUPS for t in d.get("표") or []} # fmt: skip
|
||
ports: dict[str, dict] = {}
|
||
for b in _order(lg):
|
||
into = {x["to"]["name"]: ports[x["from"]["box"]][x["from"]["name"]] for x in lg["links"] if x["to"]["box"] == b["id"]} # fmt: skip
|
||
if b["kind"] == "input":
|
||
inp = b["input"]
|
||
got = {v["name"]: v["example"] for v in inp.get("variables", [])}
|
||
got |= {
|
||
e["name"]: _plain(cm.mf.element(m, e["ref"], {})[0])
|
||
for e in inp.get("elements", [])
|
||
}
|
||
if inp.get("table"):
|
||
got["표"] = _table_rows(tables[inp["table"]["key"]])
|
||
ports[b["id"]] = got
|
||
elif b["kind"] == "function":
|
||
fn = b["func"]
|
||
sheet = json.loads(json.dumps(fn["sheet"]))
|
||
for i in fn["inputs"]:
|
||
value = into[i["port"]]
|
||
col, row = ord(i["cell"][0]) - 65, int(i["cell"][1:])
|
||
block = value if isinstance(value, list) else [[value]]
|
||
for r, line in enumerate(block):
|
||
for c, x in enumerate(line):
|
||
if x is not None:
|
||
sheet["칸"][f"{chr(65 + col + c)}{row + r}"] = {"값": _plain(x)}
|
||
book = {"종류": "통합문서", "판": 1, "열": "cf", "서식": [{}], "시트": [sheet]}
|
||
out = recalc_workbooks([book])[0][sheet["id"]][fn["output"]["cell"]]
|
||
assert "수" in out, out
|
||
ports[b["id"]] = {fn["output"]["name"]: float(out["수"])}
|
||
else:
|
||
ports[b["id"]] = {"값": into["값"]}
|
||
return {b["id"]: ports[b["id"]]["값"] for b in lg["boxes"] if b["kind"] == "output"}
|
||
|
||
|
||
def test_견본1_원가_calc_와_같음(master) -> None:
|
||
from M01_MasterData.LogicBuilder import M01_LB_Calc as lb
|
||
|
||
cm, files = master
|
||
row = next(
|
||
r
|
||
for d in files.values()
|
||
if d.get("그룹") == "로직"
|
||
for r in d["줄"]
|
||
if r["키"] == "GF000219"
|
||
)
|
||
given = {v["name"]: v["example"] for v in SAMPLES["masonry"]["boxes"][0]["input"]["variables"]}
|
||
want = lb.calc(json.loads(json.dumps(row, default=_plain)), {**given, "초과증가율": 80}, {})
|
||
assert want["ok"], want
|
||
got = _run(SAMPLES["masonry"], master)["out-pay"]
|
||
print(f"\n견본 ① 노무비 {got} · /calc {want['sums']['계']}")
|
||
assert abs(got - float(want["sums"]["계"])) < 1
|
||
|
||
|
||
def test_견본3_값_calc_와_같음_견본2_비율(master) -> None:
|
||
from M01_MasterData.LogicBuilder import M01_LB_Calc as lb
|
||
|
||
cm, files = master
|
||
row = next(
|
||
r
|
||
for d in files.values()
|
||
if d.get("그룹") == "로직"
|
||
for r in d["줄"]
|
||
if r["키"] == "GF000133"
|
||
)
|
||
given = {v["name"]: v["example"] for v in SAMPLES["value"]["boxes"][0]["input"]["variables"]}
|
||
given["qt"] = given.pop("q") # 견본은 정함대로 「q」 · 기존 로직 입력 이름은 「qt」
|
||
want = lb.calc(json.loads(json.dumps(row, default=_plain)), given, {})
|
||
assert _run(SAMPLES["value"], master)["out-q"] == float(want["result"])
|
||
assert _run(SAMPLES["rate"], master)["out-mat"] == 100000 * 3 / 100
|