Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_1' into sub_laptop_4

This commit is contained in:
2026-11-18 05:05:59 +09:00
17 changed files with 178 additions and 208 deletions
-46
View File
@@ -21,7 +21,6 @@ from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_List as store_list
from M01_MasterData import M01_MasterData_RateSheet as rate_sheet
from M01_MasterData import M01_MasterData_Store_Make as make
from M01_MasterData import M01_MasterData_Store_Sheet as sheet
import master_basis as mbs # noqa: E402 (`store` 가 scripts 를 길에 둠)
@@ -31,16 +30,6 @@ if "pytest" not in sys.modules: # 시험은 사본 폴더를 써서 정본을
store.warm() # 서버가 뜰 때 뒤에서 마스터를 한 번 읽어 둠 — 첫 목록을 기다리지 않게
class CalcBody(BaseModel):
key: str
inputs: dict[str, Any] = {}
row: dict[str, Any] | None = None # 저장 전 고친 로직 줄(없으면 저장된 파일로)
file: str | None = None # 새 로직이면 더할 로직 파일
고름: dict[
str, str
] = {} # {호표 줄 차례(0부터): 자재 키} — 그 줄만 이 품목으로 셈 · 저장 안 함
class Change(BaseModel):
op: Literal["edit", "add", "delete"]
key: str | None = None
@@ -186,12 +175,6 @@ def get_logic_source(src: str) -> dict:
return _call(make.source, src)
@router.get("/logic/auto")
def get_logic_auto(key: str) -> dict:
"""견본 입력 — 마스터 보기용 자동값(프로젝트 기본값 아님)."""
return _call(store.auto, key)
@router.get("/elements")
def get_elements(group: str, q: str = "", limit: int = 50) -> dict:
return _call(store.elements, group, q, limit)
@@ -257,35 +240,6 @@ def post_machine_formula(row: dict[str, Any]) -> dict:
return _call(machine.formula, row)
@router.post("/calc")
def post_calc(body: CalcBody) -> dict:
with store.cm.mf.mp.choosing(body.고름):
got = _call(store.calc, body.key, body.inputs, body.row, body.file)
return _pct(got, body)
def _pct(got: dict, body: CalcBody) -> dict:
"""% 덧줄 표기(149-4) — 줄에 율 · 규격 덧칸(M02 일위대가 하위 행과 같은 도우미 · 금액 그대로)."""
if not got.get("lines"):
return got
from M02_MasterTemplete import M02_Labor_Doc as labor_doc # M02 가 M01 을 부름 — 늦게
whole = store.loaded()[1]
try:
logic = body.row or whole.logic(body.key)
except store.cm.mf.FormulaError:
return got
lines = labor_doc.pct_extras(whole, logic, got["lines"], got.get("middle") or {})
return {**got, "lines": _num(lines)} # 율 Decimal(4.0) 이 글자 「4.0」 으로 나가지 않게
@router.post("/text")
def post_text(body: CalcBody) -> dict:
"""읽는 식 줄 — 몸은 `/calc` 와 같음."""
with store.cm.mf.mp.choosing(body.고름):
return _call(sheet.text, body.key, body.inputs, body.row, body.file) # 줄 덧칸(714-1)
@router.post("/save")
def post_save(body: SaveBody) -> dict:
"""로직 정본 줄 고침 = 개정 확인 · 새 줄(키 없음)은 자체 GX — {files, added, warnings}."""
+3 -66
View File
@@ -19,11 +19,11 @@ SCRIPTS = Path(__file__).resolve().parents[1] / "resources/master_data/scripts"
sys.path.insert(0, str(SCRIPTS))
import check_master as cm # noqa: E402
import master_auto as mau # noqa: E402
import master_auto as mau # noqa: E402,F401 (M02 `Sangeun_Calc` · `Labor_Doc` · `Labor_Inputs` · B09 `Sangeun` 가 `store.mau` 로 씀)
import master_combo as mcb # noqa: E402,F401 (`_Store_Combo` 가 `store.mcb` 로 씀)
import master_copy as mcp # noqa: E402,F401 (`_Store_Make` 가 `store.mcp` 로 씀)
import master_keys as mk # noqa: E402
import master_text as mtx # noqa: E402
import master_text as mtx # noqa: E402,F401 (B09 `Sangeun_Text` · M02 `Logic_Settle` 가 `store.mtx` 로 씀)
from M01_MasterData import M01_MasterData_Store_Cache as cache # noqa: E402
from M01_MasterData.M01_MasterData_Store_Find import hit as _hit # noqa: E402
@@ -32,7 +32,6 @@ from M01_MasterData.M01_MasterData_Store_Shape import dump # noqa: E402,F401
_COPY = os.environ.get("AISLO_MASTER_DIR") # 화면 저장 시험 사본 폴더(정함 13) · 없으면 정본
FOLDER: Path = Path(_COPY).resolve() if _COPY else cm.MASTER # 시험은 사본 폴더로 바꿈
DRAFT = "_초안.json" # 저장 안 한 새 로직을 얹는 메모리 자리 — 파일로 쓰지 않음
_CHAPTER = re.compile(r"_(\d\d)장_(.+)\.json$") # 「_03장_토공사.json」
# ponytail: 저장은 한 번에 하나(프로세스 안 잠금) · 서버를 여럿 띄우면 파일 잠금으로
_LOCK = threading.Lock()
@@ -344,7 +343,7 @@ def table(file: str, key: str) -> dict:
def _logic_files(files: dict[str, dict]):
"""로직 파일 줄(옛 엔진 시험 셈 `_swap` 몫 · L3 에서 걷음)."""
"""로직 파일 줄 — M02 `Item_Source` · `Logic_Standard` 가 씀(로직 JSON 은 L3 에서 걷음)."""
for name, data in files.items():
if data.get("그룹") == "로직":
yield name, data
@@ -540,68 +539,6 @@ def materials(sub: str, detail: str, spec: str, region: str, unit: str, limit: i
}
# ── 시험 계산 ──────────────────────────────────────────────────────────
def _swap(files: dict, key: str, row: dict, file: str | None) -> str:
"""저장 전 시험 — 메모리 사본에서 그 로직을 고친 줄로 바꿈(없으면 `file` 에 더함) · 돌려받는 것 = 계산할 키."""
row = _dec(row)
for name, data in _logic_files(files):
items = data.get("줄") or []
for i, old in enumerate(items):
if str(old.get("키")) == key:
items[i] = {**row, "키": key}
return key
if file is None: # 저장 안 한 새 초안 — 메모리에만 얹고 셈(만들기 모달의 시험 계산)
file = DRAFT
files[file] = {"그룹": "로직", "원문": "자체", "줄": []}
if file not in files or files[file].get("그룹") != "로직":
raise StoreError(404, f"없는 로직 파일 「{file}」")
new = mk.table_id("로직", files[file].get("원문")) + "999999" # 아직 번호 안 받은 새 로직
files[file].setdefault("줄", []).append({**row, "키": new})
return new
def calc(key: str, inputs: dict, row: dict | None = None, file: str | None = None):
given = {k: _dec(v) for k, v in inputs.items()}
files = cm.load(folder=FOLDER)
if row is not None:
key = _swap(files, str(row.get("키") or key), row, file)
try:
given = cm.mf.fill_empty(cm.mf.Master(files).logic(key), given)
result = cm.calc(files, key, given)
except (cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
if "결과" in result:
return {"ok": True, "result": result["결과"], "middle": result["중간"]}
return {
"ok": True,
"lines": result["줄"],
"sums": {k: result[k] for k in cm.mf.BUNDLE},
"middle": result["중간"],
}
def auto(key: str) -> dict:
"""견본 입력 — 마스터 보기용 자동값(`master_auto`) · 프로젝트 기본값 아님 · 저장 안 함."""
whole = loaded()[1]
try:
return {"값": mau.values(whole, whole.logic(key))}
except cm.mf.FormulaError as e:
raise StoreError(404, str(e)) from e
def text(key: str, inputs: dict, row: dict | None = None, file: str | None = None):
"""사람이 읽는 식 줄 — 비목 묶음마다 「이름 : 단가 * 수량식 = 금액」 과 소계(`master_text`)."""
given = {k: _dec(v) for k, v in inputs.items()}
files = cm.load(folder=FOLDER)
if row is not None:
key = _swap(files, str(row.get("키") or key), row, file)
try:
given = cm.mf.fill_empty(cm.mf.Master(files).logic(key), given)
return mtx.lines(files, key, given)
except (cm.mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
# ── 저장 ──────────────────────────────────────────────────────────────
def _dec(v):
"""화면이 보낸 수 → Decimal(파일을 읽은 모양과 같게)."""
@@ -1,27 +0,0 @@
"""M01 `/text` 계산서 줄 덧칸(PLAN 714-1) — `store.text` 답에 줄마다 쓰는 입력 · 묶음 · 기준단위 ·
환산 근거(`master_sheet_line.annotate` — M02 `/logic-lib/sheet` 와 한 벌) · 서버 단독(③) · 저장 안 함.
`M01_MasterData_Store.py` 는 700 줄 근처라 여기서 감쌈."""
from __future__ import annotations
from M01_MasterData import M01_MasterData_Store as store
mf = store.cm.mf
import master_sheet_line as msl # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
def text(key: str, inputs: dict, row: dict | None = None, file: str | None = None) -> dict:
got = store.text(key, inputs, row, file)
if not isinstance(got, dict) or not got.get("ok"):
return got
given = {k: store._dec(v) for k, v in inputs.items()}
try:
if row is None:
files, whole = store.loaded()
else: # 저장 전 시험 — `store.text` 와 같은 메모리 사본
files = store.cm.load(folder=store.FOLDER)
key = store._swap(files, str(row.get("키") or key), row, file)
whole = mf.Master(files)
return msl.annotate(files, key, mf.fill_empty(whole.logic(key), given), got)
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError):
return got
+1 -17
View File
@@ -2,7 +2,7 @@
M01 상세 부품(`M01_MasterData_UI_Logic_Api.ts` · `Api_Fetch.ts` · `Logic_Note.ts`)이 길 앞머리만
`/m02/logic-lib` 로 바꿔 부름 — 길 · 몸 · 답 = M01 `/api/m01/…` 와 같음(M01 길 함수를 부름).
쓰기 없음 — `/calc` · `/text` 의 `row`(저장 안 한 고친 줄)는 메모리 사본에서만 셈(`Store._swap`).
쓰기 없음 · 옛 셈 길 `/calc` · `/text` 는 855 2-E1 에 걷음(화면 부름 0).
`/logics` · `/subs` · `/logic` · 원문은 `M02_MasterTemplete_Router_Combos.py` 에 있음.
"""
@@ -21,11 +21,6 @@ ROW_FILES = ("인력", "재료", "기계")
TABLE_FILES = ("소요량_", "계수_")
@router.get("/logic/auto")
def get_auto(key: str) -> dict:
return m01.get_logic_auto(key)
@router.get("/elements")
def get_elements(group: str, q: str = "", limit: int = 50) -> dict:
return m01.get_elements(group, q, min(limit, 200))
@@ -58,17 +53,6 @@ def get_table(file: str, key: str) -> dict:
return m01.get_table(file, key)
@router.post("/calc")
def post_calc(body: m01.CalcBody) -> dict:
"""M01 `/calc` 와 같음 — `row` = 저장 안 한 고친 줄(셈만 · 쓰기 없음)."""
return m01.post_calc(body)
@router.post("/text")
def post_text(body: m01.CalcBody) -> dict:
return m01.post_text(body)
@router.get("/machine-hourly")
def get_machine_hourly(key: str) -> dict:
"""기계(EQ) 한 시간 값 노 · 재 · 경(736-3 · [항목 추가] 기계 고정 줄 단가)."""
@@ -0,0 +1,129 @@
"""855 2-E1 — 서버에서 걷은 M01 옛 셈 길(`POST /api/m01/calc` · `/text` · `GET /logic/auto`)의 몸 — 시험 전용.
옛 엔진(`master_formula` · `master_text` · `master_sheet_line`)은 B09 · M02 가 아직 씀 →
그 엔진을 이 길 꼴로 보던 시험(test_m01_text · test_m01_api · test_m01_copy · test_794_1 · test_714_1)이
앱에 `router` 를 붙여 그대로 셈. 2-E4(엔진 지움)에서 같이 지움.
"""
from __future__ import annotations
from typing import Any
from fastapi import APIRouter
from pydantic import BaseModel
from M01_MasterData import M01_MasterData_Router as m01
from M01_MasterData import M01_MasterData_Store as store
import master_sheet_line as msl # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
cm, mf = store.cm, store.cm.mf
DRAFT = "_초안.json"
router = APIRouter(prefix="/api/m01")
class CalcBody(BaseModel):
key: str
inputs: dict[str, Any] = {}
row: dict[str, Any] | None = None
file: str | None = None
고름: dict[str, str] = {}
def _swap(files: dict, key: str, row: dict, file: str | None) -> str:
"""저장 전 시험 — 메모리 사본에서 그 로직을 고친 줄로 바꿈(없으면 `file` 에 더함)."""
row = store._dec(row)
for data in files.values():
if data.get("그룹") != "로직":
continue
items = data.get("줄") or []
for i, old in enumerate(items):
if str(old.get("키")) == key:
items[i] = {**row, "키": key}
return key
if file is None:
file = DRAFT
files[file] = {"그룹": "로직", "원문": "자체", "줄": []}
if file not in files or files[file].get("그룹") != "로직":
raise store.StoreError(404, f"없는 로직 파일 「{file}」")
new = store.mk.table_id("로직", files[file].get("원문")) + "999999"
files[file].setdefault("줄", []).append({**row, "키": new})
return new
def _files(key: str, row: dict | None, file: str | None) -> tuple[dict, str]:
files = cm.load(folder=store.FOLDER)
if row is not None:
key = _swap(files, str(row.get("키") or key), row, file)
return files, key
_FAIL = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError)
def calc(key: str, inputs: dict, row: dict | None = None, file: str | None = None) -> dict:
given = {k: store._dec(v) for k, v in inputs.items()}
files, key = _files(key, row, file)
try:
given = mf.fill_empty(mf.Master(files).logic(key), given)
result = cm.calc(files, key, given)
except _FAIL as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
if "결과" in result:
return {"ok": True, "result": result["결과"], "middle": result["중간"]}
sums = {k: result[k] for k in mf.BUNDLE}
return {"ok": True, "lines": result["줄"], "sums": sums, "middle": result["중간"]}
def text(key: str, inputs: dict, row: dict | None = None, file: str | None = None) -> dict:
"""읽는 식 줄(`master_text`) + 계산서 줄 덧칸(`master_sheet_line.annotate` · 714-1)."""
given = {k: store._dec(v) for k, v in inputs.items()}
files, key = _files(key, row, file)
try:
given = mf.fill_empty(mf.Master(files).logic(key), given)
got = store.mtx.lines(files, key, given)
except _FAIL as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
if not isinstance(got, dict) or not got.get("ok"):
return got
try:
return msl.annotate(files, key, given, got)
except _FAIL:
return got
def auto(key: str) -> dict:
"""견본 입력 — 옛 자동값(`master_auto`) · 없는 로직 = 404."""
whole = store.loaded()[1]
try:
return {"값": store.mau.values(whole, whole.logic(key))}
except mf.FormulaError as e:
raise store.StoreError(404, str(e)) from e
@router.get("/logic/auto")
def get_logic_auto(key: str) -> dict:
return m01._call(auto, key)
@router.post("/calc")
def post_calc(body: CalcBody) -> dict:
with mf.mp.choosing(body.고름):
got = m01._call(calc, body.key, body.inputs, body.row, body.file)
if not got.get("lines"):
return got
from M02_MasterTemplete import M02_Labor_Doc as labor_doc # % 덧줄 표기(149-4)
whole = store.loaded()[1]
try:
logic = body.row or whole.logic(body.key)
except mf.FormulaError:
return got
lines = labor_doc.pct_extras(whole, logic, got["lines"], got.get("middle") or {})
return {**got, "lines": m01._num(lines)}
@router.post("/text")
def post_text(body: CalcBody) -> dict:
with mf.mp.choosing(body.고름):
return m01._call(text, body.key, body.inputs, body.row, body.file)
+1 -9
View File
@@ -2,13 +2,12 @@
- M02 `run_line` → 큰돌쌓기 찰쌓기 제잡비 설치 9 · 안 함 3 · 「노무비의 %」
- 인력 줄 합 밑수 = 「인건비의 %」 · 호표 줄 밑수 = 「그 줄 이름의 %」 · 금액 식(기계손료) = 덧칸 없음
- M01 시험계산(`post_calc`) 도 같은 도우미 · 화면 두 곳은 `pctView` 한 벌
- M01 시험계산 길(`post_calc`)은 855 2-E1 에 걷음 · 화면은 `pctView` 한 벌
"""
from decimal import Decimal
from pathlib import Path
from M01_MasterData import M01_MasterData_Router as m01_router
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Doc as labor
@@ -42,10 +41,3 @@ def test_인건비_호표줄_밑수_금액식은_덧칸_없음():
assert "율" not in mach and "규격" not in mach
mat = _extra("GC000267", name="잡재료비")
assert mat["규격"] == "재료비의 %"
def test_M01_시험계산도_율_규격():
given = {"물빼기파이프": "설치", "직경": "60", "지역": "전국평균", "보정작업": "해당 없음"}
got = m01_router.post_calc(m01_router.CalcBody(key="GF000227", inputs=given))
extra = [x for x in got["lines"] if x["이름"] == "제잡비"][0]
assert extra["율"] == 9 and extra["규격"] == "노무비의 %"
+2 -3
View File
@@ -9,14 +9,13 @@ from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
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
import helper_855_old_engine_routes as sheet # noqa: E402 — 옛 `/text` 몸(855 2-E1 · 시험 전용)
msl = sheet.msl
def _text(key: str) -> dict:
auto = {k: v for k, v in store.auto(key)["값"].items() if v is not None}
auto = {k: v for k, v in sheet.auto(key)["값"].items() if v is not None}
return sheet.text(key, auto)
-21
View File
@@ -15,7 +15,6 @@ from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M01_MasterData import M01_MasterData_Router as m01_router
from M01_MasterData import M01_MasterData_Store as store
from M02_MasterTemplete import M02_Logic_Lib_Read as lib
@@ -55,7 +54,6 @@ def _prints() -> dict[str, str]:
def test_일반_계정_읽기(user: TestClient) -> None:
assert user.get(f"{BASE}/logic/auto", params={"key": KEY}).status_code == 200
assert user.get(f"{BASE}/elements", params={"group": "인력", "q": "LB000002"}).json()["items"]
assert user.get(f"{BASE}/pick", params={"kind": "price", "q": "시멘트"}).status_code == 200
assert user.get(f"{BASE}/rows", params={"file": "기계.json", "size": 3}).json()["rows"]
@@ -70,22 +68,3 @@ def test_요소_표_밖_파일은_막음(user: TestClient) -> None:
assert user.get(f"{BASE}/rows", params={"file": logic_file}).status_code == 403
assert user.get(f"{BASE}/table", params={"file": "기계.json", "key": "x"}).status_code == 403
assert user.get(f"{BASE}/rows", params={"file": "재료_../x.json"}).status_code == 404
def test_저장_안_한_줄_셈_쓰기_없음(user: TestClient) -> None:
before = _prints()
saved = user.post(f"{BASE}/calc", json={"key": KEY, "inputs": {}}).json()
row = m01_router._num(
store.logic(KEY)["logic"]
) # 화면이 받는 꼴(M01 /logic = _num · 794-2b 「개정」 수 칸)
same = user.post(f"{BASE}/calc", json={"key": KEY, "inputs": {}, "row": row}).json()
line = row["호표"][0]
row2 = {**row, "호표": [{**line, "수량": f"({line['수량']}) * 2"}, *row["호표"][1:]]}
double = user.post(f"{BASE}/calc", json={"key": KEY, "inputs": {}, "row": row2}).json()
text = user.post(f"{BASE}/text", json={"key": KEY, "inputs": {}, "row": row2}).json()
assert saved["ok"] and same["sums"] == saved["sums"]
# 751-3 — 줄 0.1 원 · 소계 1 원 버림이라 두 배는 1 원 안
assert double["sums"]["노무비"] == pytest.approx(saved["sums"]["노무비"] * 2, abs=2)
assert text["ok"] and text["계"] == pytest.approx(double["sums"]["계"], rel=1e-6)
assert store.logic(KEY)["logic"]["호표"][0]["수량"] == line["수량"] # 정본 그대로
assert _prints() == before
+4 -3
View File
@@ -8,6 +8,7 @@ from decimal import Decimal
from B09_Estimation import B09_Estimation_Sangeun as sg
from M01_MasterData import M01_MasterData_Store as m01
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 몸(855 2-E1 · 시험 전용)
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
@@ -72,9 +73,9 @@ def test_화면_넷_같은_값_SK_시험계산_읽는식():
{"키": "SK-000000", "이름": "끝수", "단위": "㎡", "바탕": {"로직": KEY}}, None, whole
)
sk = calc.run(doc, whole)["기준"]
auto = {k: v for k, v in (m01.auto(KEY)["값"] or {}).items() if v is not None}
m1 = m01.calc(KEY, auto)
text = m01.text(KEY, auto)
auto = {k: v for k, v in (old_engine.auto(KEY)["값"] or {}).items() if v is not None}
m1 = old_engine.calc(KEY, auto)
text = old_engine.text(KEY, auto)
assert float(sk["계"]) == m1["sums"]["계"] == float(text["계"])
assert {g["비목"]: float(g["소계"]) for g in text["groups"]} == {k: float(sk[k]) for k in COSTS}
line = next(x for g in text["groups"] for x in g["줄"] if x["이름"].startswith("형틀"))
+2
View File
@@ -19,6 +19,7 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import require_system_admin, verify_session
from M01_MasterData import M01_MasterData_Router as m01_router
from M01_MasterData import M01_MasterData_Store as store
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER
KEY = "GC000211" # 합판거푸집 설치 및 해체
@@ -48,6 +49,7 @@ def folder(tmp_path: Path, monkeypatch) -> Path:
def client(folder: Path) -> TestClient:
app = FastAPI()
app.include_router(m01_router.router)
app.include_router(old_engine.router)
return TestClient(app)
@@ -23,6 +23,7 @@ from fastapi.testclient import TestClient
from common_util import common_util_auth as auth
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as m01
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 몸(855 2-E1 · 시험 전용)
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Machine_Hourly as mh
from M02_MasterTemplete import M02_MasterTemplete_Store as store
@@ -215,7 +216,7 @@ def test_power_line_jumbo_drill():
h["경비"],
h["계"],
)
home = m01.calc(POWER_CREW, {"기계": "5805-0002", "전력 계약종별": "주택용 저압"})
home = old_engine.calc(POWER_CREW, {"기계": "5805-0002", "전력 계약종별": "주택용 저압"})
assert home["ok"] and float(home["sums"]["재료비"]) > h["재료비"] # 120 원/kWh > 114.4
+2
View File
@@ -17,6 +17,7 @@ from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as store
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER
LABOR = "인력.json"
@@ -51,6 +52,7 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서")
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
+2
View File
@@ -13,12 +13,14 @@ from fastapi import FastAPI
from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
@pytest.fixture(scope="module")
def client() -> TestClient:
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
+2
View File
@@ -24,6 +24,7 @@ from M01_MasterData import M01_MasterData_Store as store
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts"))
import master_copy as mcp # noqa: E402
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER
STACK = "GF000219" # 13-4-1 메쌓기(인력) — 같은 표를 같은 인자로 두 번(별칭 하나로 합침)
@@ -41,6 +42,7 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서")
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
+2
View File
@@ -16,6 +16,7 @@ from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Doc as doc_store
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as store
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
from M01_MasterData import M01_MasterData_Store_Make as make
REAL = store.FOLDER
@@ -37,6 +38,7 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
doc_store._memo.clear()
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
+8 -3
View File
@@ -13,6 +13,7 @@ from fastapi.testclient import TestClient
from M01_MasterData import M01_MasterData_Router as router_module
from M01_MasterData import M01_MasterData_Store as store
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
mf = store.cm.mf
mp = mf.mp
@@ -22,6 +23,7 @@ mp = mf.mp
def client() -> TestClient:
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
@@ -91,7 +93,10 @@ def test_검색어_후보가_없으면_그_줄만_비움(client) -> None:
def test_기계_입력은_목록_밖_원문번호도_받음(client) -> None:
key = "GC000267"
inputs = {**store.auto(key)["값"], "기계": "0101-0007"} # 고르기 목록 밖 · 기계 마스터엔 있음
inputs = {
**old_engine.auto(key)["값"],
"기계": "0101-0007",
} # 고르기 목록 밖 · 기계 마스터엔 있음
got = client.post("/api/m01/calc", json={"key": key, "inputs": inputs}).json()
assert got["ok"] is True, got
bad = client.post("/api/m01/calc", json={"key": key, "inputs": {**inputs, "기계": "9999-9999"}})
@@ -118,7 +123,7 @@ def test_기계_입력은_EQ_키도_원문번호로_풀어_받음(client) -> Non
key = "GC000267"
number = "0101-0007" # 고르기 목록 밖
eq = next(k for k, r in store.loaded()[1].index["EQ"].items() if r.get("원문번호") == number)
base = {**store.auto(key)["값"]}
base = {**old_engine.auto(key)["값"]}
by_number = client.post(
"/api/m01/calc", json={"key": key, "inputs": {**base, "기계": number}}
).json()
@@ -131,7 +136,7 @@ def test_기계_입력은_EQ_키도_원문번호로_풀어_받음(client) -> Non
def test_재료_줄마다_품목_칸(client) -> None:
key = "GF000160"
body = {"key": key, "inputs": {k: str(v) for k, v in store.auto(key)["값"].items()}}
body = {"key": key, "inputs": {k: str(v) for k, v in old_engine.auto(key)["값"].items()}}
lines = client.post("/api/m01/calc", json=body).json()["lines"]
idx = next(
i for i, x in enumerate(lines) if x.get("품목", {}).get("이름", "").startswith("합판(내수)")
+18 -12
View File
@@ -23,6 +23,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/script
import master_text as mt # noqa: E402
from helper_test_all import spread # noqa: E402
import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용)
REAL = store.FOLDER
STACK = "GF000219" # 13-4-1 메쌓기(인력) — 증가율이 걸린 줄
@@ -40,6 +41,7 @@ def client(tmp_path: Path, monkeypatch) -> TestClient:
monkeypatch.setattr(store, "FOLDER", tmp_path)
app = FastAPI()
app.include_router(router_module.router)
app.include_router(old_engine.router)
return TestClient(app)
@@ -416,7 +418,7 @@ def test_자동값으로_모든_로직을_돌려도_멈추지_않는다() -> Non
stops = []
keys = [k for rows in master.index.values() for k in rows]
for key in spread([k for k in keys if mt.mf.mk.GROUP_OF.get(k[:2]) == "로직"], 400):
given = {n: store._dec(v) for n, v in store.auto(key)["값"].items()}
given = {n: store._dec(v) for n, v in old_engine.auto(key)["값"].items()}
# 고르기가 빈 입력 = 내 기계 · 불러오기 전용 식(M01 정본 기계가 안 씀) — 자동값 고를 것이 없음
if any(i.get("고르기") == [] for i in master.logic(key).get("입력", [])):
continue
@@ -429,7 +431,7 @@ def test_자동값으로_모든_로직을_돌려도_멈추지_않는다() -> Non
def test_빈_줄은_빈_글이고_소계는_빈_줄_빼고_더한다(client: TestClient) -> None:
key = "GC000027"
given = {n: str(v) for n, v in store.auto(key)["값"].items()}
given = {n: str(v) for n, v in old_engine.auto(key)["값"].items()}
got = client.post("/api/m01/text", json={"key": key, "inputs": given}).json()
calc = client.post("/api/m01/calc", json={"key": key, "inputs": given}).json()
assert got["ok"] is True
@@ -442,7 +444,7 @@ def test_곱_뒤_덧셈_묶음은_괄호로_이름_식_값_식_모두() -> None:
"""GC000467 촌락지대가 — 노임 * (아홉 항 합) · 첫 항에만 곱하는 것처럼 읽히지 않게."""
files = store.cm.load(folder=REAL)
row = store.cm.master(REAL).logic("GC000467")
given = {n: store._dec(v) for n, v in store.auto("GC000467")["값"].items()}
given = {n: store._dec(v) for n, v in old_engine.auto("GC000467")["값"].items()}
got = mt.lines(files, "GC000467", given)
one = _all_lines(got)[0]
assert one["글"].startswith("295,138 * (1 + 1 + 0.5") and " = 3,984,363" in one["글"]
@@ -457,7 +459,7 @@ def test_곱_뒤_덧셈_묶음은_괄호로_이름_식_값_식_모두() -> None:
def test_이름글_번호_별칭은_별칭표로_되돌려진다() -> None:
"""이름글 속 별칭(가1~가9)은 별칭표 이름 그대로여야 식으로 되돌려짐(찾은 줄 이름 X)."""
files = store.cm.load(folder=REAL)
given = {n: store._dec(v) for n, v in store.auto("GC000467")["값"].items()}
given = {n: store._dec(v) for n, v in old_engine.auto("GC000467")["값"].items()}
got = mt.lines(files, "GC000467", given)
left = _all_lines(got)[0]["이름글"].split(" = ")[0].split(" * ", 1)[1].strip("()")
raw_of = {m["이름"]: m["원문"] for m in got["별칭"]}
@@ -498,8 +500,8 @@ def test_값_식_작은_수는_유효숫자로_보인_수끼리_곱해도_금액
def _text_of(key: str, **given) -> list[dict]:
auto = {k: v for k, v in (store.auto(key).get("값") or {}).items() if v is not None}
return _all_lines(store.text(key, {**auto, **given}))
auto = {k: v for k, v in (old_engine.auto(key).get("값") or {}).items() if v is not None}
return _all_lines(old_engine.text(key, {**auto, **given}))
def test_빈_줄을_부른_덧줄_값_조각은_None_대신_그_줄_이름() -> None:
@@ -523,12 +525,14 @@ def test_수량_식_안_로직_조각은_그_로직_이름() -> None:
def test_표에_없는_입력_조합은_그_줄만_비우고_글은_그대로() -> None:
"""/calc 와 같은 빈 줄 규칙 — 풀리지 않는 중간값은 /text 도 멈추지 않음."""
got = store.text("GC001000", {**store.auto("GC001000")["값"], "시공구분": "기계시공"})
got = old_engine.text("GC001000", {**old_engine.auto("GC001000")["값"], "시공구분": "기계시공"})
lines = _all_lines(got)
blank = [x for x in lines if x["금액"] is None]
assert blank and all(x["이름글"] and x["조각"] for x in blank)
assert len(blank) < len(lines) or got["계"] is not None
calc = store.calc("GC001000", {**store.auto("GC001000")["값"], "시공구분": "기계시공"})
calc = old_engine.calc(
"GC001000", {**old_engine.auto("GC001000")["값"], "시공구분": "기계시공"}
)
assert got["계"] == calc["sums"]["계"]
@@ -540,17 +544,19 @@ def test_재료_줄_요소조각은_잡힌_품목_이름과_MT_참조() -> None:
piece = _mat_piece(_text_of("GF000159"), "결속선 0.9㎜")
assert piece["글"].startswith("어닐링철선(결속선)")
assert piece["참조"] == {"테이블": "MT", "키": "MT000209"}
auto = {k: v for k, v in store.auto("GF000159")["값"].items() if v is not None}
assert store.text("GF000159", auto)["계"] == store.calc("GF000159", auto)["sums"]["계"]
auto = {k: v for k, v in old_engine.auto("GF000159")["값"].items() if v is not None}
assert (
old_engine.text("GF000159", auto)["계"] == old_engine.calc("GF000159", auto)["sums"]["계"]
)
def test_고름으로_바꾼_재료_줄_요소조각은_고른_품목() -> None:
import check_master as cm
import master_pick as mp
auto = {k: v for k, v in store.auto("GF000159")["값"].items() if v is not None}
auto = {k: v for k, v in old_engine.auto("GF000159")["값"].items() if v is not None}
items = cm.master().logic("GF000159")["호표"]
at = next(i for i, h in enumerate(items) if h.get("이름") == "결속선 0.9㎜")
with mp.choosing({at: "MT000174"}):
got = _all_lines(store.text("GF000159", auto))
got = _all_lines(old_engine.text("GF000159", auto))
assert _mat_piece(got, "결속선 0.9㎜")["참조"]["키"] == "MT000174"