diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index f90545143..13e79738b 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -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}.""" diff --git a/M01_MasterData/M01_MasterData_Store.py b/M01_MasterData/M01_MasterData_Store.py index 0324711a8..3cb80e821 100644 --- a/M01_MasterData/M01_MasterData_Store.py +++ b/M01_MasterData/M01_MasterData_Store.py @@ -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(파일을 읽은 모양과 같게).""" diff --git a/M01_MasterData/M01_MasterData_Store_Sheet.py b/M01_MasterData/M01_MasterData_Store_Sheet.py deleted file mode 100644 index 57181e401..000000000 --- a/M01_MasterData/M01_MasterData_Store_Sheet.py +++ /dev/null @@ -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 diff --git a/M02_MasterTemplete/M02_Logic_Lib_Read.py b/M02_MasterTemplete/M02_Logic_Lib_Read.py index 9df0562b8..dcd0e4a56 100644 --- a/M02_MasterTemplete/M02_Logic_Lib_Read.py +++ b/M02_MasterTemplete/M02_Logic_Lib_Read.py @@ -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 · [항목 추가] 기계 고정 줄 단가).""" diff --git a/M02_MasterTemplete/M02_Sangeun_Const.py b/M02_MasterTemplete/M02_Sangeun_Const.py index 4229f4311..5c90e5ea3 100644 --- a/M02_MasterTemplete/M02_Sangeun_Const.py +++ b/M02_MasterTemplete/M02_Sangeun_Const.py @@ -267,21 +267,6 @@ def _top_add(key: str) -> bool: return bool(hit) and not hit[2] -def kinds(doc: dict, spot: str) -> list[str]: - """자리의 덮개 갈래 — 품 · 단가 · 상수 · 표값 · 뺌(차례 그대로).""" - cover, out = (doc.get("덮개") or {}).get(spot) or {}, [] - if "qty" in cover or "배율" in cover: - out.append("품") - if any(k in cover for k in sd.PARTS): - out.append("단가") - out += [ - n - for n, k in (("상수", "상수덮개"), ("표값", "표값덮개"), ("식", "식덮개")) - if spot in (doc.get(k) or {}) - ] - return out + (["뺌"] if spot in (doc.get("뺀줄") or []) else []) - - # ── 셈 답 ────────────────────────────────────────────────────────── def answer(got: dict, clean: dict) -> dict: """`M02_Sangeun_Calc.calc_doc` 답 — 셈 답(1 단위 몫) + 가져온 식 원본 보기(옛 `원래` · `시트` · 머리 걷음).""" diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index 98e9a11e6..c92cc9cd7 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -16,9 +16,7 @@ 재생성 = 지금 M01 로 새로 찍음 — 덮개 · 식덮개 · 변수줄 · 상수 · 표값 · 까닭은 cid 열쇠라 새 사본에 그대로 얹힘 · 못 얹은 칸 = 짝잃음. 저장 때 = 사본에 없는 새 줄(더한줄 로직 더함 · 기초 바꿈)만 지금 M01 에서 더함. -길(`M02_Sangeun_Router`): POST …/sangeun/copy/{price|regen} 몸 {문서, 입력값?} → - {문서(사본할일), 전, 후, 바뀐자원 [{키, 이름, 전, 후, 지워짐?}] · 못얹은 [{cid, 까닭}]} - (저장 없음). +미리 셈 = `M02_Doc_Sk_Path.preview`(몸 `할일` · 옛 `preview` 는 걷음 · 855 2-E2). 셈 답 덧칸 `사본` = {시점, 단가시점, M01새판, 지운키, 단가새값} · 같은 내용 지문 몫 = `same_part`. """ @@ -386,43 +384,3 @@ def same_part(doc: Any) -> str | None: seen = state(copy, whole_()) fresh = not (seen["M01새판"] or seen["지운키"] or seen["단가새값"]) return None if fresh else f"{copy.get('판')}:{copy.get('단가판')}" - - -# ── [단가 갱신] · [재생성] 미리 셈(저장 없음) ────────────────────────── -def _money(ans: dict) -> dict | None: - base = ans.get("기준") - return {k: base.get(k) for k in ("노무비", "재료비", "경비", "계")} if base else None - - -def _lost(ans: dict) -> dict[str, dict]: - rows = [*(ans.get("짝잃음") or []), *((ans.get("시트") or {}).get("짝잃음") or [])] - return {str(x.get("cid")): x for x in rows if isinstance(x, dict)} - - -def preview(doc: Any, job: str, given: dict | None = None) -> dict[str, Any]: - """{문서(할일 얹음), 전, 후, 바뀐자원 · 못얹은} — 재생성은 단가갱신을 품음.""" - from M02_MasterTemplete import M02_Sangeun_Calc as calc - - if not isinstance(doc, dict): - raise sd.DocError("단가산출 문서가 묶음 아님") - old = doc.get(JOB) - new = REGEN if REGEN in (old, job) else job - after_doc = {**doc, JOB: new} - before = calc.calc_doc(doc, given) - after = calc.calc_doc(after_doc, given) - out: dict[str, Any] = {"문서": after_doc, "전": _money(before), "후": _money(after)} - if cut := [ - str(x.get("이름") or x.get("로직")) for x in doc.get("더한줄") or [] if x.get("끊음") - ]: - out["끊은기초"] = cut # 줄은 그대로 · 자원 단가만(요구 656-1) - if job == PRICE: - copy = _stored(doc.get("키")) or taken(held(doc)) - out["바뀐자원"] = refresh(copy, whole_())[1] if copy else [] - else: - was = _lost(before) - out["못얹은"] = [ - {"cid": c, "까닭": x.get("까닭") or "새 사본에 그 줄 없음"} - for c, x in _lost(after).items() - if c not in was - ] - return out diff --git a/M02_MasterTemplete/M02_Sangeun_Formula.py b/M02_MasterTemplete/M02_Sangeun_Formula.py index 117e9981b..9d74ef16b 100644 --- a/M02_MasterTemplete/M02_Sangeun_Formula.py +++ b/M02_MasterTemplete/M02_Sangeun_Formula.py @@ -456,74 +456,3 @@ def _path(deps: dict, start: str, goal: str) -> list[str] | None: seen.add(nxt) todo.append([*path, nxt]) return None - - -# ── 셈 답 덧칸(790-2 `시트`) ───────────────────────────────────────── -def sheet_more(spots: dict, base: dict, clean: dict, mids: dict) -> list[dict]: - """790-2 시트 자리에 덧칸 — 식글(지금 식 이름 꼴) · 원식글 · 식덮개 · 식틀림 · 변수 줄 · - 더한줄 식글 · 돌려줌 = 틀린 식 · 짝 잃은 식 칸(시트 `짝잃음` 에 더함).""" - from M02_MasterTemplete import M02_Sangeun_Const as const - - row, bad, fixed = settle(base, clean) - eff, covers = const._swapped(row, clean), fixed.get("식덮개") or {} - now, why = _places(eff), clean.get("까닭") or {} - wrong: dict[str, list[str]] = {} - for b in bad: - wrong.setdefault(b["cid"], []).append(b["까닭"]) - for spot, one in spots.items(): - if spot in now and one.get("갈래") != "더한줄": - part, at = now[spot] - one["원식글"] = to_name(str(one.get("식")), base) - one["식글"] = to_name(str(eff[part][at].get(FIELD[part])), base) - one["식덮개"] = spot in covers - hit = _ADD.match(spot) - adds = fixed.get("더한줄") or [] - if hit and int(hit[1]) < len(adds) and adds[int(hit[1])].get("수량식"): - one["식"] = adds[int(hit[1])]["수량식"] - one["식글"] = to_name(one["식"], base) - if spot in wrong: - one["식틀림"] = wrong[spot] - good = {x["이름"]: x["식"] for x in fixed.get("변수줄") or []} - for line in clean.get("변수줄") or []: - spot, text = f"mid:{line['이름']}", good.get(line["이름"], line["식"]) - spots[spot] = { - "갈래": "변수", - "이름": line["이름"], - "식": text, - "식글": to_name(text, base), - "표시": line.get("표시"), - "자리": line["자리"], - "원래": None, - "지금": mids.get(line["이름"]) if line["이름"] in good else None, - "덮개": [], - "까닭": why.get(spot), - "M01바뀜": False, - **({"식틀림": wrong[spot]} if spot in wrong else {}), - } - return bad - - -def name_table(base: dict, clean: dict) -> list[dict]: - """식 칸에서 부를 이름 — 입력 · 중간 · 변수 · 덧줄 · 비목 · 별칭 · 자원 · 번지 · 단계.""" - mf = _eng() - out = [{"글": str(x.get("이름")), "갈래": "입력"} for x in base.get("입력") or []] - out += [{"글": str(x.get("이름")), "갈래": "중간"} for x in base.get("중간") or []] - out += [{"글": x["이름"], "갈래": "변수"} for x in clean.get("변수줄") or []] - out += [{"글": str(x.get("이름")), "갈래": "덧줄"} for x in base.get("덧줄") or []] - out += [{"글": k, "갈래": "비목"} for k in mf.COST_ITEMS] - out += [{"글": f"[{k}]", "갈래": "별칭"} for k in aliases(base)] - label_of, seen = _labels(_whole())[0], set() - for part in FIELD: - for x in base.get(part) or []: - texts = [ - str(x.get(FIELD[part])), - *([x["요소"]] if isinstance(x.get("요소"), str) else []), - ] - for key in (k for t in texts for k in mf.mk.KEY.findall(t)): - if key in label_of and key not in seen: - seen.add(key) - out.append({"글": f"[{label_of[key]}]", "갈래": "자원"}) - lines = [*(base.get("호표") or []), *(base.get("덧줄") or [])] - out += [{"글": f"번지.{x['번지']}", "갈래": "번지"} for x in lines if x.get("번지")] - out += [{"글": f"단계.'{x.get('이름')}'", "갈래": "단계"} for x in base.get("단계") or []] - return out diff --git a/resources/tester/helper_855_old_engine_routes.py b/resources/tester/helper_855_old_engine_routes.py new file mode 100644 index 000000000..6d06f3ca3 --- /dev/null +++ b/resources/tester/helper_855_old_engine_routes.py @@ -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) diff --git a/resources/tester/test_149_4_pct_extra.py b/resources/tester/test_149_4_pct_extra.py index b89d99fc2..775e38518 100644 --- a/resources/tester/test_149_4_pct_extra.py +++ b/resources/tester/test_149_4_pct_extra.py @@ -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["규격"] == "노무비의 %" diff --git a/resources/tester/test_714_1_sheet_line.py b/resources/tester/test_714_1_sheet_line.py index 61cbf574f..66b6195d3 100644 --- a/resources/tester/test_714_1_sheet_line.py +++ b/resources/tester/test_714_1_sheet_line.py @@ -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) diff --git a/resources/tester/test_717_1_logic_lib.py b/resources/tester/test_717_1_logic_lib.py index 906de3605..9fd7ca67b 100644 --- a/resources/tester/test_717_1_logic_lib.py +++ b/resources/tester/test_717_1_logic_lib.py @@ -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 diff --git a/resources/tester/test_751_3_money_cut.py b/resources/tester/test_751_3_money_cut.py index 1c6f49e6e..8d9ac1536 100644 --- a/resources/tester/test_751_3_money_cut.py +++ b/resources/tester/test_751_3_money_cut.py @@ -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("형틀")) diff --git a/resources/tester/test_792_1_sangeun_formula.py b/resources/tester/test_792_1_sangeun_formula.py index 4955671ac..183f63dc7 100644 --- a/resources/tester/test_792_1_sangeun_formula.py +++ b/resources/tester/test_792_1_sangeun_formula.py @@ -142,7 +142,7 @@ def test_펼침_막음_초기화_걷음(world): doc, n = flat.reset("sangeun", {**_plus(), "까닭": {MAN: "할증"}}) assert n == 1 and "식덮개" not in doc and "까닭" not in doc and doc["변수줄"] assert const.restore(_plus(), MAN).get("식덮개") is None - assert const.kinds(_plus(), MAN) == ["식"] and const.covers_n(_plus()) == 1 + assert const.covers_n(_plus()) == 1 # ── B09 사본 굳힘 ───────────────────────────────────────────────────── diff --git a/resources/tester/test_794_1_m01_sheet.py b/resources/tester/test_794_1_m01_sheet.py index 506239703..17fb32aed 100644 --- a/resources/tester/test_794_1_m01_sheet.py +++ b/resources/tester/test_794_1_m01_sheet.py @@ -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) diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 3f1d826ad..1a28585d6 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -14,6 +14,7 @@ import json import pytest from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Same as same @@ -118,12 +119,11 @@ def test_price_refresh_only_on_press(world, monkeypatch): assert _sum(me, key) == was # 누르기 전 = 단가 기준 시점 값 fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 지금 M01 로 새로 찍은 SK assert fresh != was - with store.at(me): - got = skc.preview(_doc(me, key), skc.PRICE) + with store.at(me): # 화면 [단가 갱신] 미리 셈 = 수식 길(옛 `skc.preview` 걷음 · 855 2-E2) + got = path.preview(key, {"할일": skc.PRICE}) assert got["전"]["계"] == was and got["후"]["계"] == fresh assert [x["키"] for x in got["바뀐자원"]] == [lb] - assert got["문서"][skc.JOB] == skc.PRICE - _save(me, key, got["문서"]) # [저장] = 서버가 할일 적용 + _save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [저장] = 서버가 할일 적용 saved = _doc(me, key) assert skc.JOB not in saved and _sum(me, key) == fresh assert skc.held(saved)["단가시점"] >= skc.held(saved)["시점"] @@ -142,7 +142,7 @@ def test_deleted_keys_keep_last_value(world, monkeypatch): assert now["기준"]["계"] == was assert {PCT, lb} <= set(now["사본"]["지운키"]) with store.at(me): - got = skc.preview(_doc(me, key), skc.PRICE) + got = path.preview(key, {"할일": skc.PRICE}) assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"] assert got["후"]["계"] == was @@ -195,7 +195,7 @@ def test_imported_same_rule(world, monkeypatch): row["값"] = row["값"] * 2 _fake(monkeypatch, [row]) assert _sum(me, key) == was - with store.at(me): - got = skc.preview(_doc(me, key), skc.PRICE) - assert [x["키"] for x in got["바뀐자원"]] == [MAN] - assert got["후"]["노무비"] == pytest.approx(got["전"]["노무비"] * 2, abs=1) + before = _calc(me, _doc(me, key))["기준"]["노무비"] + _save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [단가 갱신] 뒤 [저장] = 할일 적용 + after = _calc(me, _doc(me, key))["기준"]["노무비"] + assert after == pytest.approx(before * 2, abs=1) diff --git a/resources/tester/test_821_1_my_machine.py b/resources/tester/test_821_1_my_machine.py index 561810eb7..afa99fe9e 100644 --- a/resources/tester/test_821_1_my_machine.py +++ b/resources/tester/test_821_1_my_machine.py @@ -15,6 +15,7 @@ import pytest from fastapi import HTTPException from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Machine_Find as mfind from M02_MasterTemplete import M02_Machine_Hourly as mh @@ -147,11 +148,12 @@ def test_sk_copy_edit_refresh_delete(world): assert now["기준"]["계"] == was and now["사본"]["단가새값"] is True assert now["사본"]["지운키"] == [] new = _at(me, mh.hourly, key)["계"] - look = _at(me, skc.preview, _doc(me, sk), skc.PRICE) + look = _at(me, path.preview, sk, {"할일": skc.PRICE}) # 화면 [단가 갱신] 미리 셈(수식 길) assert float(look["전"]["계"]) == float(was) and float(look["후"]["계"]) == new assert [x["키"] for x in look["바뀐자원"]] == [key] with store.at(me): # [저장] = 할일 적용 - store.write("sangeun", sk, store.read("sangeun", sk)["판"], look["문서"]) + got = store.read("sangeun", sk) + store.write("sangeun", sk, got["판"], {**got["문서"], skc.JOB: skc.PRICE}) assert float(_sum(me, sk)) == new assert _calc(me, _doc(me, sk))["사본"]["단가새값"] is False # 층 사이 복사 — 사본이 따라감(받은 층에 그 내 기계 없음 · 마지막 값) @@ -162,7 +164,7 @@ def test_sk_copy_edit_refresh_delete(world): assert gone["쓰는곳"] == [{"키": sk, "이름": "sub3임시 내기계"}] after = _calc(me, _doc(me, sk)) assert float(after["기준"]["계"]) == new and after["사본"]["지운키"] == [key] - look = _at(me, skc.preview, _doc(me, sk), skc.PRICE) + look = _at(me, path.preview, sk, {"할일": skc.PRICE}) assert look["바뀐자원"] == [{"키": key, "이름": NAME, "지워짐": True}] assert float(look["후"]["계"]) == new diff --git a/resources/tester/test_822_1_copy_gap.py b/resources/tester/test_822_1_copy_gap.py index 2e09d9028..73a80f6e7 100644 --- a/resources/tester/test_822_1_copy_gap.py +++ b/resources/tester/test_822_1_copy_gap.py @@ -207,9 +207,9 @@ def test_imported_ours(world, monkeypatch): was = _sum(me, key) _move(monkeypatch, MAN) assert _sum(me, key) == was - doc = _at(me, lambda: store.read("sangeun", key)["문서"]) - got = _at(me, skc.preview, doc, skc.PRICE) - assert [x["키"] for x in got["바뀐자원"]] == [MAN] and got["후"]["계"] > was + doc = _at(me, lambda: store.read("sangeun", key)) # [단가 갱신] 뒤 [저장] = 할일 적용 + _at(me, lambda: store.write("sangeun", key, doc["판"], {**doc["문서"], skc.JOB: skc.PRICE})) + assert _sum(me, key) > was def test_layer_copy_keeps_copy(world, monkeypatch): diff --git a/resources/tester/test_822_2_machine_hourly_all.py b/resources/tester/test_822_2_machine_hourly_all.py index ba63f5df0..f125d5a2f 100644 --- a/resources/tester/test_822_2_machine_hourly_all.py +++ b/resources/tester/test_822_2_machine_hourly_all.py @@ -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 diff --git a/resources/tester/test_m01_api.py b/resources/tester/test_m01_api.py index b08113d5e..682ef3c23 100644 --- a/resources/tester/test_m01_api.py +++ b/resources/tester/test_m01_api.py @@ -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) diff --git a/resources/tester/test_m01_auto.py b/resources/tester/test_m01_auto.py index 7b4f1611b..aece281a2 100644 --- a/resources/tester/test_m01_auto.py +++ b/resources/tester/test_m01_auto.py @@ -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) diff --git a/resources/tester/test_m01_copy.py b/resources/tester/test_m01_copy.py index 4729f3a42..fd3f0e380 100644 --- a/resources/tester/test_m01_copy.py +++ b/resources/tester/test_m01_copy.py @@ -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) diff --git a/resources/tester/test_m01_make.py b/resources/tester/test_m01_make.py index 1544b66cb..65c3ee71b 100644 --- a/resources/tester/test_m01_make.py +++ b/resources/tester/test_m01_make.py @@ -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) diff --git a/resources/tester/test_m01_pick.py b/resources/tester/test_m01_pick.py index 5b7186b46..a62503736 100644 --- a/resources/tester/test_m01_pick.py +++ b/resources/tester/test_m01_pick.py @@ -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("합판(내수)") diff --git a/resources/tester/test_m01_text.py b/resources/tester/test_m01_text.py index ad5832f56..f16852931 100644 --- a/resources/tester/test_m01_text.py +++ b/resources/tester/test_m01_text.py @@ -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" diff --git a/ui_template/ui_template_locale_m2.ts b/ui_template/ui_template_locale_m2.ts index 76d522701..d33768375 100644 --- a/ui_template/ui_template_locale_m2.ts +++ b/ui_template/ui_template_locale_m2.ts @@ -170,10 +170,6 @@ export const ui_locales_m2 = { "바탕 단가산출 기초가 저장 뒤 바뀜 — 고친 칸의 바탕 값을 확인하고 [저장]하면 새 판으로 맞춤", "The base M01 logic changed since saving — check edited cells, then Save to adopt the new version", ], - M02_SangeunLost: [ - "바탕에서 짝을 잃은 고침 — 지우지 않고 남겨 둠", - "Edits that lost their base row — kept, not deleted", - ], M02_SangeunGap: [ "못 셈 줄 — 금액 빼고 나머지로 셈 · 줄을 빼거나 입력을 채움", "Lines not priced — total uses the rest · drop the line or fill its input",