diff --git a/M02_MasterTemplete/M02_Labor_Inputs.py b/M02_MasterTemplete/M02_Labor_Inputs.py index 204102bfe..6e885c795 100644 --- a/M02_MasterTemplete/M02_Labor_Inputs.py +++ b/M02_MasterTemplete/M02_Labor_Inputs.py @@ -1,9 +1,9 @@ """M02 일위대가 입력 목록(39-3). 담은 단가산출 로직마다 입력 전부 · 로직마다 갈라 보이고 이름이 같아도 합치지 않음 · 입력 목록은 -그 로직 줄의 `입력` 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 입력으로만) · 자동값 = -`master_auto.values`(보기용 · 저장 안 함). 일위대가 입력 모달(`GET /api/m02/logic-lib/inputs`)이 -씀. M01 은 읽기만 · 권한은 부르는 쪽 몫. +그 수식 문서의 입력 변수(갈래 입력 · 선택) 그대로(하위 로직으로 넘겨지는 입력은 맨 위 로직 +입력으로만) · 자동값 = `M02_Doc_Copy.auto_of`(보기용 · 저장 안 함). 일위대가 입력 모달 +(`GET /api/m02/logic-lib/inputs`)이 씀. M01 은 읽기만(수식 문서 · 855 L2 ⓑ) · 권한은 부르는 쪽 몫. """ from __future__ import annotations @@ -12,10 +12,10 @@ import re from decimal import Decimal from typing import Any +from M01_MasterData import M01_MasterData_Doc as m01doc from M01_MasterData import M01_MasterData_Store as m01 -from M01_MasterData import M01_MasterData_Store_Combo as combo_store -_SPEC = ("이름", "설명", "단위", "고르기", "범위") +INPUTS = ("입력", "선택") # 문서 입력 변수 갈래 _LAYERED = "골쌓기 기준" # 85-2 — 표 주문에 이 글이 있으면 켜쌓기율 대상 로직 _NUMBER = re.compile(r"(? Any: return value -def _logics(codes: list[str]) -> tuple[list[dict], list[str]]: - """([로직 줄 …], 빠진 로직 키) — 키 차례 그대로.""" - whole = m01.loaded()[1] - found, missing = [], [] - for code in codes: - try: - found.append(whole.logic(code)) - except combo_store.cm.mf.FormulaError: - missing.append(code) - return found, missing +def _docs(codes: list[str]) -> tuple[list[dict], list[str]]: + """([수식 문서 …], 빠진 로직 키) — 키 차례 그대로.""" + docs = m01doc.docs() + found = [docs[code] for code in codes if code in docs] + return found, [code for code in codes if code not in docs] + + +def specs(doc: dict) -> list[dict[str, Any]]: + """문서 입력 변수 → 입력 칸 `{이름: 열쇠, 설명, 단위, 고르기?(선택 목록), 범위?}`(변수 차례).""" + out = [] + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") not in INPUTS or not v.get("열쇠"): + continue + one = {"이름": v["열쇠"], "설명": v.get("설명") or None, "단위": v.get("단위") or None} + if link.get("갈래") == "선택": + one["고르기"] = list(link.get("목록") or []) + if link.get("범위"): + one["범위"] = list(link["범위"]) + out.append(one) + return out def layered() -> set[str]: @@ -65,50 +76,51 @@ def _labels(whole: Any, spec: dict) -> dict[str, str]: return out -def sources(logic: dict) -> Any: - """원문 출처(222-1) — 로직 `출처` + 호표 · 입력 · 중간 · 덧줄 `출처` 가운데 같은 책(번호 앞 글이 - 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 절마다 찾음 · M01 - `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로.""" - main = str(logic.get("출처") or "") +def sources(doc: dict) -> Any: + """원문 출처(222-1) — 문서 `출처` + 금액 수량 줄 · 변수 · 금액 식 줄(수량 없음) `출처` + 가운데 같은 책(번호 앞 글이 같음)의 절 번호를 덧붙임(「산림품셈 12-1-2 · 12-1-3」 · 원문 패널이 + 절마다 찾음 · M01 `make.source`) · 다른 책 절은 안 붙임 · 번호 없는 출처는 그대로.""" + main = str(doc.get("출처") or "") head = _NUMBER.search(main) if not head: - return logic.get("출처") + return doc.get("출처") book, seen = main[: head.start()], set(_NUMBER.findall(main)) + money = [x for x in doc.get("금액") or [] if isinstance(x, dict)] + rows = [x for x in money if "수량" in x] + list(doc.get("변수") or []) extra = [] - for part in ("호표", "입력", "중간", "덧줄"): - for row in logic.get(part) or []: - src = str(row.get("출처") or "") if isinstance(row, dict) else "" - hit = _NUMBER.search(src) - if hit and src[: hit.start()] == book and hit.group() not in seen: - seen.add(hit.group()) - extra.append(hit.group()) + for row in rows + [x for x in money if "수량" not in x]: + src = str(row.get("출처") or "") if isinstance(row, dict) else "" + hit = _NUMBER.search(src) + if hit and src[: hit.start()] == book and hit.group() not in seen: + seen.add(hit.group()) + extra.append(hit.group()) return " · ".join([main, *extra]) -def _listed(logics: list[dict]) -> list[dict[str, Any]]: - """로직 줄마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`.""" +def _listed(docs: list[dict]) -> list[dict[str, Any]]: + """문서마다 `{로직, 이름, 결과단위, 출처, 켜쌓기, + 입력: [{이름, 설명, 단위, 고르기?, 고르기이름?, 범위?, 자동값}]}`.""" + from M02_MasterTemplete import M02_Doc_Copy as dc + whole = m01.loaded()[1] layers = layered() out = [] - for logic in logics: - auto = m01.mau.values(whole, logic) - specs = [] - for spec in logic.get("입력") or []: - one = {k: spec[k] for k in _SPEC if k in spec} - one.setdefault("설명", None) - one.setdefault("단위", None) - labels = _labels(whole, spec) + for doc in docs: + auto = dc.auto_of(doc, whole) + rows = [] + for one in specs(doc): + labels = _labels(whole, one) if labels: one["고르기이름"] = labels - specs.append({**one, "자동값": auto.get(spec["이름"])}) + rows.append({**one, "자동값": auto.get(one["이름"])}) out.append( { - "로직": logic.get("키"), - "이름": logic.get("이름"), - "결과단위": logic.get("결과단위"), - "출처": sources(logic), - "켜쌓기": logic.get("키") in layers, - "입력": specs, + "로직": doc.get("키"), + "이름": doc.get("이름"), + "결과단위": doc.get("결과단위"), + "출처": sources(doc), + "켜쌓기": doc.get("키") in layers, + "입력": rows, } ) return out @@ -116,5 +128,5 @@ def _listed(logics: list[dict]) -> list[dict[str, Any]]: def logic_inputs(codes: list[str]) -> dict[str, Any]: """일위대가 입력 모달 — 로직 키들의 입력 목록 `{로직: [...], 빠진로직}`(키 차례 · 겹침 한 번)""" - found, missing = _logics(list(dict.fromkeys(c for c in codes if c))) + found, missing = _docs(list(dict.fromkeys(c for c in codes if c))) return _num({"로직": _listed(found), "빠진로직": missing}) diff --git a/M02_MasterTemplete/M02_Logic_Settle.py b/M02_MasterTemplete/M02_Logic_Settle.py deleted file mode 100644 index 8900471e7..000000000 --- a/M02_MasterTemplete/M02_Logic_Settle.py +++ /dev/null @@ -1,115 +0,0 @@ -"""M02 기준 목록 · 계산서 끝수(PLAN 704-2 딸림) — B09 산근 끝수 규칙으로 셈(③ 서버 단독 · -`B09_Estimation_Sangeun` 과 규칙 짝 · 거울 시험 `test_704_settle`). - -줄 금액 = ROUNDDOWN(단가 × 수량, 1) 비목마다 · 비목 총계 = ROUNDDOWN(Σ 줄, 0) · 계 = 셋 합 · -작업량 Q(중간 이름 Q · Q1 …) = ROUND(식, 2) 뒤 쓰임 · % 덧줄 밑수 = 그때까지 줄 합(줄 끝수 뒤). -근거 = 지식DB `technical_info/01_임도/05_원가정보/단수처리_규칙.md`(행 금액 절사 · 관측 후보 규칙). -M01 엔진(`master_formula.run`)의 구조 그대로 — 끝수 자리만 다름(엔진은 줄 끝수 없이 계에서 한 번). -하위 로직(기계경비 포함)은 같은 규칙으로 다시 셈 · 흐름 · 결과 로직은 엔진 값 그대로. -""" - -from __future__ import annotations - -import re -from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal -from typing import Any - -from M01_MasterData import M01_MasterData_Store as m01 - -mf = m01.cm.mf -_Q = re.compile(r"Q\d*") - - -def _down(value: Any, places: int) -> Any: - return None if value is None else mf._round(Decimal(value), places, ROUND_DOWN) - - -def _bundle(whole: Any, item: dict, env: dict, depth: int) -> dict: - """로직 호표 줄이 부르는 하위 로직 — 같은 규칙으로 다시 셈(엔진 `logic` 마디 그대로).""" - node = mf.parse(item["요소"]) - if node[0] != "logic": - return mf.evaluate(node, env, whole, depth) - given = {k: mf.evaluate(v, env, whole, depth) for k, v in node[2]} - got = settle(whole, mf.fill(node[1], env), given, depth + 1) - return got["결과"] if "결과" in got else {k: got[k] for k in mf.BUNDLE} - - -def settle(whole: Any, ref: str, given: dict, depth: int = 0) -> dict: - """`master_formula.run` 과 같은 꼴 `{줄, 노무비, 재료비, 경비, 계, 중간}` — 끝수만 B09 규칙.""" - row = whole.logic(ref) - if isinstance(row.get("흐름"), dict) or "결과" in row: - return mf.run(whole, ref, given, depth) - env = mf._inputs(row, given) - for step in row.get("중간", []): - try: - value = mf.evaluate(mf.parse(step["식"]), env, whole, depth) - except mf.EmptyInput as e: - env[step["이름"]] = mf.Blank(str(e)) - continue - if _Q.fullmatch(step["이름"]) and isinstance(value, Decimal): - value = value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) - env[step["이름"]] = value - lines: list[dict] = [] - for n, item in enumerate(row.get("호표", [])): - try: - qty = mf.evaluate(mf.parse(item["수량"]), env, whole, depth) - if item["종류"] == "로직": - bundle = _bundle(whole, item, env, depth) - price = bundle["계"] - split = ( - {k: qty * bundle[k] for k in mf.COST_ITEMS} - if "비목" not in item - else {item["비목"]: qty * price} - ) - else: - ref_ = ( - { - k: mf.fill(v, env) if isinstance(v, str) else v - for k, v in item["요소"].items() - } - if isinstance(item["요소"], dict) - else mf.fill(item["요소"], env) - ) - if isinstance(ref_, str) and qty != 0: - whole.get(ref_) - price = mf.mp.priced(whole, item, ref_, env, n if depth == 0 else None)[0] - if price is None and qty == 0: - price = Decimal(0) - split = {item["비목"]: None if price is None else qty * price} - except mf.EmptyInput as e: - lines.append(mf._blank_line(item, str(e))) - continue - lines.append(_line(item["이름"], split)) - sums = {k: sum((x["비목"].get(k) or 0 for x in lines), Decimal(0)) for k in mf.COST_ITEMS} - env["줄"] = {x["이름"]: x["금액"] for x in lines if x["이름"] and x["금액"] is not None} - for extra in row.get("덧줄", []): - env.update(sums) - try: - value = mf.evaluate(mf.parse(extra["식"]), env, whole, depth) - env[extra["이름"]] = value - except mf.FormulaError: - value = None - sums[extra["비목"]] += _down(value, 1) or 0 - lines.append(_line(extra["이름"], {extra["비목"]: value})) - if value is not None: - env["줄"][extra["이름"]] = lines[-1]["금액"] - sums = {k: mf.cut(row, _down(v, 0), "계") for k, v in sums.items()} - return {"줄": lines, **sums, "계": sum(sums.values()), "중간": mf._shown(env)} - - -def _line(name: str, split: dict) -> dict: - cut = {k: _down(v, 1) for k, v in split.items()} - whole_sum = None if all(v is None for v in cut.values()) else sum(v or 0 for v in cut.values()) - return {"이름": name, "비목": cut, "금액": whole_sum} - - -def apply(groups: list[dict], engine: dict, done: dict) -> None: - """계산서 묶음의 줄 금액 · 소계를 `settle` 값으로 바꿈 — 줄 차례는 엔진과 같음.""" - seq: dict[str, list] = {k: [] for k in mf.COST_ITEMS} - for eng, mine in zip(engine["줄"], done["줄"]): - for part, _ in m01.mtx._shares(eng): - seq[part].append(mine["비목"].get(part)) - for group in groups: - for line, amount in zip(group["줄"], seq.get(group["비목"], [])): - line["금액"] = amount - group["소계"] = done[group["비목"]] diff --git a/M02_MasterTemplete/M02_Logic_Standard.py b/M02_MasterTemplete/M02_Logic_Standard.py index 953cd8ba7..456f29962 100644 --- a/M02_MasterTemplete/M02_Logic_Standard.py +++ b/M02_MasterTemplete/M02_Logic_Standard.py @@ -8,13 +8,12 @@ 바꾼 줄이 0 원이면 표에 없는 조합으로 보고 뺌). 금액 · 계산서 = 수식 문서 셈(`master_doc_calc` · M02 단가산출과 같은 계산기 · 끝수 = 문서 끝수) · 계산서 줄 글 = `master_doc_text`(줄 쌓기 산출근거와 같은 글 규칙) · 최신 판 노임(마스터 판). -(855-C 전 옛 길 = 옛 엔진 + B09 산근 끝수 `M02_Logic_Settle` — 그 파일은 B09 짝이라 남음.) 목록은 서버가 뒤에서 한 번 셈(프로세스 `WORKERS` 개) → 프로세스 메모리 + 파생 저장본 (storage `_derived/m02_logic_standard/`) · 열쇠 = 마스터 · 수식 문서 내용 지문 + `SHAPE` · 같으면 안 셈 · 셈 도중 목록 = 빈 줄 `준비: false`(화면은 로직 줄 그대로 · 금액 빈칸). 실무 낱말(`WORDS`) = 별칭 칸에 덧붙여 찾기(공용 `matchLogic`)가 「석축」 → 돌쌓기를 찾음. -이름표(이름 · 구분 · 출처 · 별칭)는 아직 로직 줄에서 읽음(855 보충 L2 몫). +이름표(이름 · 구분 · 출처 · 별칭) · 기초 차례(장 차례) = 수식 문서(`M01_MasterData_Doc` · 855 L2 ⓑ). M01 은 읽기만 · 권한은 부르는 쪽 몫(로그인). """ @@ -196,8 +195,8 @@ def _spec(given: dict, ax: list) -> str: return " · ".join(parts) -def _unit(logic: dict) -> str: - unit = str(logic.get("결과단위") or "") +def _unit(doc: dict) -> str: + unit = str(doc.get("결과단위") or "") return unit[2:] if unit.startswith("원/") else ("" if unit == "원" else unit) @@ -223,24 +222,21 @@ def _money(doc: dict, links: Any, given: dict) -> Decimal | None: return got.get("계") if got.get("계") is not None else got.get("결과") -def _rows_of(whole: Any, logic: dict, blocked: bool, links: Any = None) -> list[dict]: - doc = m01_doc.docs().get(str(logic.get("키"))) - if doc is None: - return [] +def _rows_of(whole: Any, doc: dict, blocked: bool, links: Any = None) -> list[dict]: links = links or _links(whole) base, ax = axes(whole, doc) changes: list[dict] = [{}] for name, reps in ax: changes += [{name: v} for v, _ in reps if v != base.get(name)] head = { - "키": logic.get("키"), - "이름": logic.get("이름") or "", - "단위": _unit(logic), - "출처": logic.get("출처") or "", - "공종": kind_of(logic), - "별칭": ", ".join(x for x in [logic.get("별칭") or "", *words_of(logic)] if x), - "구분": logic.get("구분") or "", - "상세구분": logic.get("상세구분") or "", + "키": doc.get("키"), + "이름": doc.get("이름") or "", + "단위": _unit(doc), + "출처": doc.get("출처") or "", + "공종": kind_of(doc), + "별칭": ", ".join(x for x in [doc.get("별칭") or "", *words_of(doc)] if x), + "구분": doc.get("구분") or "", + "상세구분": doc.get("상세구분") or "", "막힘": blocked, } out = [] @@ -283,12 +279,12 @@ def _stamp() -> str: def _chunk(keys: list[str], blocked: set[str]) -> list[dict]: - """일꾼 프로세스 몫 — 로직 키들의 줄(마스터는 그 프로세스가 읽음).""" - whole = m01.loaded()[1] + """일꾼 프로세스 몫 — 로직 키들의 줄(마스터 · 수식 문서는 그 프로세스가 읽음).""" + whole, docs = m01.loaded()[1], m01_doc.docs() links = _links(whole) out = [] for key in keys: - out += _rows_of(whole, whole.logic(key), key in blocked, links) + out += _rows_of(whole, docs[key], key in blocked, links) return out @@ -296,11 +292,8 @@ def build(files: dict, workers: int = 1) -> dict: """기준 목록 통째 — 장 차례 · `workers` > 1 이면 로직을 나눠 프로세스 여럿이 셈(차례 그대로).""" why_of = m01.blocks() blocked = {k for k, why in why_of.items() if why} - keys = [ - str(logic.get("키")) - for _, data in sorted(m01._logic_files(files), key=lambda f: m01.chapter_order(f[1])) - for logic in data.get("줄") or [] - ] + chapters = sorted(m01_doc.logic_files().values(), key=m01.chapter_order) + keys = [str(doc.get("키")) for data in chapters for doc in data.get("줄") or []] size = max(1, len(keys) // (workers * 8)) parts = [keys[i : i + size] for i in range(0, len(keys), size)] if workers > 1: @@ -379,13 +372,11 @@ def _given(whole: Any, doc: dict, change: dict) -> tuple[dict, list]: def sheet(key: str, change: dict) -> dict: """계산서 한 장 — 머리(품명 · 규격 · 단위 · 출처 · 판) + 비목 묶음 줄 · 소계 · 계(문서 셈).""" files, whole = m01.loaded() - doc = m01_doc.docs().get(key) try: - logic = whole.logic(key) + m01_doc.head(key) # 없는 · 로직 아닌 키 = 옛 `Master.logic` 과 같은 까닭 글 except m01.cm.mf.FormulaError as e: raise m01.StoreError(404, str(e)) from e - if doc is None: - raise m01.StoreError(404, f"수식 문서 없음 「{key}」") + doc = m01_doc.docs()[key] given, ax = _given(whole, doc, change) links = _links(whole) got = _calc(doc, links, given) or {} @@ -393,14 +384,14 @@ def sheet(key: str, change: dict) -> dict: return labor_inputs._num( { "키": key, - "이름": logic.get("이름") or "", + "이름": doc.get("이름") or "", "규격": _spec(given, ax), - "단위": _unit(logic), - "출처": labor_inputs.sources(logic) or "", + "단위": _unit(doc), + "출처": labor_inputs.sources(doc) or "", "판": edition(files), "입력": given, "묶음": mdt.sheet_groups(doc, got, links) if got and money else [], "계": got.get("계") if money else got.get("결과"), - "기준단위": _unit(logic) or None, + "기준단위": _unit(doc) or None, } ) diff --git a/resources/tester/test_222_1_m02_apart.py b/resources/tester/test_222_1_m02_apart.py index bf391275d..00a54a552 100644 --- a/resources/tester/test_222_1_m02_apart.py +++ b/resources/tester/test_222_1_m02_apart.py @@ -5,7 +5,7 @@ 자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고). ② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는 남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길. -③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」). +③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」). """ import os @@ -13,6 +13,7 @@ from decimal import Decimal import pytest +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M01_MasterData import M01_MasterData_Store_Make as make from M02_MasterTemplete import M02_Labor_Doc as labor @@ -132,7 +133,7 @@ def test_사전조합_안_줄도_별도계상_뺌(): # ── ③ 원문 여럿 ────────────────────────────────────────────────────── def test_원문_출처는_같은_책_절_모두(): - src = inputs.sources(_whole().logic(MIX)) + src = inputs.sources(m01_doc.docs()[MIX]) assert src == "산림품셈 12-1-2 · 12-1-3" assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"] @@ -143,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로(): assert inputs.sources({"출처": None}) is None one = { "출처": "산림품셈 3-1", - "호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}], + "금액": [ + {"수량": "1", "출처": "건설품셈 공통 1-2-4 3"}, + {"수량": "1", "출처": "산림품셈 3-1"}, + ], } assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임 diff --git a/resources/tester/test_704_logic_standard.py b/resources/tester/test_704_logic_standard.py index fcc306ce0..974face24 100644 --- a/resources/tester/test_704_logic_standard.py +++ b/resources/tester/test_704_logic_standard.py @@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) · def _rows(key: str) -> list[dict]: whole = m01.loaded()[1] - return st._rows_of(whole, whole.logic(key), False) + return st._rows_of(whole, m01_doc.docs()[key], False) def _given(key: str, change: dict) -> dict: diff --git a/resources/tester/test_704_settle.py b/resources/tester/test_704_settle.py index 2295c13a6..8bfcee708 100644 --- a/resources/tester/test_704_settle.py +++ b/resources/tester/test_704_settle.py @@ -1,9 +1,8 @@ -"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0). +"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈). -거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값. +옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ). """ -import re import sys from decimal import Decimal from pathlib import Path @@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2] if str(ROOT) not in sys.path: sys.path.insert(0, str(ROOT)) -from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402 from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402 from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402 -from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402 from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402 -mf = m01.cm.mf -PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"} - - -def _plain(row: dict) -> bool: - """로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음.""" - return ( - str(row.get("결과단위") or "").startswith("원") - and not row.get("덧줄") - and not row.get("끝수") - and not any(i.get("종류") == "로직" for i in row.get("호표") or []) - and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or []) - ) - - -def test_줄마다_버림_비목마다_버림_B09와_같음(): - files, whole = m01.loaded() - checked = 0 - for _, data in m01._logic_files(files): - for row in data.get("줄") or []: - if not _plain(row) or checked >= 60: - continue - base, _ = ls.axes(whole, m01_doc.docs()[row["키"]]) - given = mf.fill_empty(row, base) - got = mf.run(whole, row["키"], given) - lines = [] - for line in got["줄"]: - one = dict.fromkeys(PART_OF.values(), 0.0) - for part, money in line["비목"].items(): - one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None - lines.append(one) - if any(v is None for one in lines for v in one.values()): - continue - want = sg.block_totals(lines) - mine = st.settle(whole, row["키"], given) - for name, part in PART_OF.items(): - assert float(mine[name]) == want[part], (row["키"], name) - assert float(mine["계"]) == want["sum"], row["키"] - checked += 1 - assert checked >= 30 - def test_계산서_줄_소계_계가_맞물림(): files, whole = m01.loaded() diff --git a/resources/tester/test_727_sk_base_add.py b/resources/tester/test_727_sk_base_add.py index 3490829dd..a0368cd12 100644 --- a/resources/tester/test_727_sk_base_add.py +++ b/resources/tester/test_727_sk_base_add.py @@ -15,6 +15,7 @@ from pathlib import Path import pytest +from M01_MasterData import M01_MasterData_Doc as m01_doc from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Labor_Doc as labor from M02_MasterTemplete import M02_Labor_Ref as refs @@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄(): whole = m01.loaded()[1] rows = [] for key in (GF, "GC000269", "GC001109"): - rows += standard._rows_of(whole, whole.logic(key), False) + rows += standard._rows_of(whole, m01_doc.docs()[key], False) assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕 got = _heads(rows) assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"] diff --git a/resources/tester/test_855_c4_doc_text.py b/resources/tester/test_855_c4_doc_text.py index b94225ef2..795fd891a 100644 --- a/resources/tester/test_855_c4_doc_text.py +++ b/resources/tester/test_855_c4_doc_text.py @@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈(): whole = m01.loaded()[1] docs, links, _ = world() for key in ("GF000220", "GC000404", "GX000004"): - for row in st._rows_of(whole, whole.logic(key), False, links): + for row in st._rows_of(whole, docs[key], False, links): given = st._given(whole, docs[key], row["바꿈"])[0] want = mc.calc(docs[key], links, given) assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])