From 5dfe3761a2e1de42245abe38ff18daa0add813da Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:18:04 +0900 Subject: [PATCH 1/3] auto: 2026-11-18 07:18 (ESD_LAPTOP) --- M02_MasterTemplete/M02_Labor_Inputs.py | 104 ++++++++++-------- M02_MasterTemplete/M02_Logic_Settle.py | 115 -------------------- M02_MasterTemplete/M02_Logic_Standard.py | 55 ++++------ resources/tester/test_222_1_m02_apart.py | 10 +- resources/tester/test_704_logic_standard.py | 2 +- resources/tester/test_704_settle.py | 48 +------- resources/tester/test_727_sk_base_add.py | 3 +- resources/tester/test_855_c4_doc_text.py | 2 +- 8 files changed, 94 insertions(+), 245 deletions(-) delete mode 100644 M02_MasterTemplete/M02_Logic_Settle.py 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["규격"]) From c60d2eef3b182bb9acb99821a2ee80bec120d383 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:29:48 +0900 Subject: [PATCH 2/3] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-2):=20?= =?UTF-8?q?=EC=84=9C=EA=B3=A0=20=ED=8E=BC=EC=B9=A8=20=C2=B7=20=EC=9D=BC?= =?UTF-8?q?=EC=9C=84=EB=8C=80=EA=B0=80=20SK=20=EC=A4=84=EC=9D=B4=20?= =?UTF-8?q?=EA=B8=B0=EC=B4=88=20=EC=9D=B4=EB=A6=84=20=C2=B7=20=EA=B2=B0?= =?UTF-8?q?=EA=B3=BC=EB=8B=A8=EC=9C=84=20=C2=B7=20=EC=9E=85=EB=A0=A5=20?= =?UTF-8?q?=EC=9D=B4=EB=A6=84=EC=9D=84=20=EC=88=98=EC=8B=9D=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C=EC=97=90=EC=84=9C=20=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Library_Flat: filled_adds · sk_adds · sc_adds · sk_line 의 기초 줄 읽기 = 수식 문서(`_doc` · 없는 키 = 옛 Master.logic 과 같은 FormulaError) · 입력 이름 = M02_Labor_Inputs.specs - M02_Labor_SkRow: logic_doc 이름 · 결과단위 = 수식 문서 · from_logic 없는 기초 거름 = M01_MasterData_Doc.head - 남김(옛 패치 칸 걷기 몫): compose · sk_line 줄 정체(sd.line_ids · sd.patched) · 호표 재료 차례 = 아직 로직 줄 - 전후 답 10,654 건 다름 0 · 관련 시험 8 파일 86 통과 Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Labor_SkRow.py | 14 +++++++++---- M02_MasterTemplete/M02_Library_Flat.py | 29 +++++++++++++++++++------- 2 files changed, 32 insertions(+), 11 deletions(-) diff --git a/M02_MasterTemplete/M02_Labor_SkRow.py b/M02_MasterTemplete/M02_Labor_SkRow.py index 22d494ac6..73672a86f 100644 --- a/M02_MasterTemplete/M02_Labor_SkRow.py +++ b/M02_MasterTemplete/M02_Labor_SkRow.py @@ -33,15 +33,19 @@ def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]: from M02_MasterTemplete import M02_Labor_Patch as patch from M02_MasterTemplete import M02_Sangeun_Calc as calc + from M01_MasterData import M01_MasterData_Doc as m01doc + code = str(one["로직"]) - row = whole.logic(code) + m01doc.head(code) # 없는 기초 = 옛 `Master.logic` 과 같은 까닭 + doc_ = m01doc.docs()[code] + row = whole.logic(code) # 호표 재료 차례 = 옛 자재표시 칸 몫(남김) shown = dict(one.get("자재표시") or {}) for n, item in enumerate(row.get("호표") or []): if item.get("종류") == "재료": mine = shown.get(str(n)) shown[str(n)] = {**labor.marks(mine), "별도계상": labor.mark_of(mine, "별도계상")} - unit = calc.base_unit(row) - name = str(one.get("별칭") or row.get("이름") or code) + unit = calc.base_unit(doc_) + name = str(one.get("별칭") or doc_.get("이름") or code) sk = patch.to_sangeun({**one, "자재표시": shown}, name, unit[1] if unit else "식", whole) return {**sk, **{k: doc[k] for k in CARRY if doc.get(k)}} @@ -50,9 +54,11 @@ def from_logic(code: Any, new: bool = False, use: str | None = None) -> dict[str """[+ 줄] M01 기초 고름 — 지금 층에 SK 사본(같은 내용 = 409 물음 · 733-2) → `{이름: SK 키, 참조}`.""" from M02_MasterTemplete import M02_Library_Ask as ask + from M01_MasterData import M01_MasterData_Doc as m01doc + whole = _whole() try: - whole.logic(str(code)) + m01doc.head(str(code)) except Exception as e: # noqa: BLE001 — 없는 로직 raise store.StoreError(400, f"없는 기초 「{code}」") from e sk = logic_doc({"로직": str(code), "입력값": {}}, {}, whole) diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index bc09a4c09..4a87c9ecd 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -23,6 +23,8 @@ 단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 · 기본정보 남김 → 값 = 연결된 M01 키 값. 한 번용 옮기기(`migrate`)는 끝나 걷음(894). +기초 이름 · 결과단위 · 입력 이름 = M01 수식 문서(855 L2 ⓑ · `_doc`) · 줄 정체(cid) · 호표 재료 차례는 +옛 패치 칸(덮개 · 뺀줄 · 고름 · 자재표시) 몫이라 아직 로직 줄(`compose` · `sk_line` · 옛 패치 칸 걷기 때 같이). """ from __future__ import annotations @@ -33,7 +35,9 @@ import time from decimal import Decimal from typing import Any +from M01_MasterData import M01_MasterData_Doc as m01doc from M02_MasterTemplete import M02_Labor_Fixed as fixed +from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Sangeun_Const as const from M02_MasterTemplete import M02_Sangeun_Doc as sd @@ -50,6 +54,16 @@ def _whole() -> Any: return m01.loaded()[1] +def _doc(code: Any) -> dict: + """기초 키 → 수식 문서 · 없거나 로직 아닌 키 = 옛 `Master.logic` 과 같은 `FormulaError`.""" + m01doc.head(str(code)) + return m01doc.docs()[str(code)] + + +def _names(doc: dict) -> set[str]: + return {s["이름"] for s in labor_inputs.specs(doc)} + + def _d(value: Any) -> Decimal: return Decimal(str(value)) @@ -124,7 +138,7 @@ def filled_adds(doc: dict, whole: Any) -> list[dict]: for one in doc.get("더한줄") or []: if one.get("종류") == "로직": try: - names = [str(s.get("이름")) for s in whole.logic(one["로직"]).get("입력") or []] + names = list(_names(_doc(one["로직"]))) except Exception: # noqa: BLE001 — 없는 로직 = 검사 · 셈이 까닭 names = [] mine = dict(one.get("입력값") or {}) @@ -150,8 +164,8 @@ def sk_adds(y: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]: raise sd.DocError("율 줄 있는 바탕 없는 단가산출은 펼쳐 넣지 못함 — 참조로 둠") if not code: return [_scaled(one, q, tag) for one in adds] - row = whole.logic(code) - names = {str(s.get("이름")) for s in row.get("입력") or []} + row = _doc(code) + names = _names(row) unit = calc.base_unit(row) entry: dict[str, Any] = { "종류": "로직", @@ -185,7 +199,7 @@ def sc_adds(z: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]: for at, one in enumerate(z.get("담은로직") or []): n = q * _hand(one, lines.get(str(at))) if one.get("로직"): - row = whole.logic(one["로직"]) + row = _doc(one["로직"]) body = patch.as_doc(one, whole) entry = { "종류": "로직", @@ -345,11 +359,12 @@ def sk_line(y: dict, one: dict, whole: Any, tag: dict) -> dict: code = (y.get("바탕") or {}).get("로직") if not code: raise sd.DocError("바탕 기초 없는 단가산출은 일위대가 줄로 못 담음 — 그 안 줄을 따로 넣음") - row = whole.logic(code) - if calc.ratio_of(y, row, whole) != calc.times_of(row): + doc = _doc(code) + if calc.ratio_of(y, doc, whole) != calc.times_of(doc): raise sd.DocError("단위 환산 단가산출은 일위대가 줄로 못 담음(값 단위가 바뀜)") + row = whole.logic(code) # 줄 정체 · 호표 재료 차례 = 옛 패치 칸 몫(남김) ids = sd.line_ids(row) - names = {str(s.get("이름")) for s in row.get("입력") or []} + names = _names(doc) at = {c: str(n) for n, c in enumerate(ids)} body = {k: y[k] for k in ("덮개", "뺀줄") if y.get(k) not in EMPTY} body |= {"더한줄": adds} if (adds := filled_adds(y, whole)) else {} From 8b7d4195f72d53488eb80e4a999aeb30fbc660e2 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 07:52:21 +0900 Subject: [PATCH 3/3] =?UTF-8?q?refactor(855-E=20L2=E2=93=91-2):=20?= =?UTF-8?q?=EA=B8=B0=EA=B3=84=20=EC=8B=9C=EA=B0=84=EB=8B=B9=20=EC=8B=9D=20?= =?UTF-8?q?=EA=B3=A0=EB=A6=84=20=C2=B7=20=EA=B9=8C=EB=8B=AD=20=C2=B7=20?= =?UTF-8?q?=EC=A1=B0=ED=95=A9=EC=9D=B4=20=EB=A1=9C=EC=A7=81=20=EC=A4=84=20?= =?UTF-8?q?=EB=8C=80=EC=8B=A0=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C?= =?UTF-8?q?=EB=A5=BC=20=EC=9D=BD=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - M02_Machine_Hourly: 「건설기계」 식 목록 = M01_MasterData_Doc.logic_files · 입력 · 기계 고르기 = M02_Labor_Inputs.specs · 조종원 줄 = 문서 금액 수량 줄 · 그 기계만의 식(_own) · 까닭 칸(why) = 문서 변수 요소 연결 · pick · logic_of 는 문서를 돌려줌(부르는 곳은 키 · 이름만 씀) - M02_Doc_Import.hourly_link: 입력 기본값 = 문서 입력 변수(브레인 답 ①) - 시험: test_822_2 · test_804_2 도우미가 문서 입력 · 금액 줄을 봄 · test_842_3 옛 엔진 거울은 로직 줄을 키로 따로 읽음(2-E4 까지) - 전후 답 8,034 건 다름 0 · 관련 33 파일 294 통과 · test_822_2 새 기계 등록 하나는 고치기 전 판에서도 실패(M01 Machine.register 쪽 · 이 커밋 밖) Co-Authored-By: Claude Opus 5.5 --- M02_MasterTemplete/M02_Doc_Import.py | 6 +- M02_MasterTemplete/M02_Machine_Hourly.py | 67 ++++++++++--------- resources/tester/test_804_2_line_stack.py | 7 +- .../tester/test_822_2_machine_hourly_all.py | 6 +- resources/tester/test_842_3_machine_crew.py | 1 + 5 files changed, 46 insertions(+), 41 deletions(-) diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index 98f67bad2..12537ef80 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -131,8 +131,10 @@ def hourly_link(eq: str, part: str) -> dict | None: if not logic: return None given = {"기계": _lit(code)} if machine.takes_machine(logic) else {} - for spec in logic.get("입력") or []: - if spec.get("이름") != "기계": + from M02_MasterTemplete import M02_Labor_Inputs as li + + for spec in li.specs(logic): # 문서 입력 변수(855 L2 ⓑ) + if spec["이름"] != "기계": given[spec["이름"]] = _lit((spec.get("고르기") or [""])[0]) return {"갈래": "단가산출", "키": str(logic["키"]), "입력": given, "칸": part} diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index fb43f70dc..5a8c70646 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -12,16 +12,19 @@ 식 고름 한 곳(822-2 · `pick`) = ㉠ 원문번호가 식 「기계」 목록에 있으면 그 식(짝 차례) ㉡ 그 기계만의 식 (`_own`) ㉢ 없으면 꼴(채운 칸 · `M02_MyMachine.logic_key`) — M01 [새 기계] · 불러오기 · 데이터 흐름 · 줄 쌓기 · 단가산출 기초가 다 이것을 씀 · 못 고름 · 값 모자람 = 까닭 글(`why`). +식 = M01 수식 문서(`M01_MasterData_Doc` · 입력 = 문서 입력 변수 · 기계 칸 = 문서 요소 연결 · 855 L2 ⓑ) — +`pick` · `logic_of` 는 문서를 돌려줌 · `why` · `takes_machine` 은 로직 줄을 받아도 키로 문서를 읽음. """ from __future__ import annotations -import re from typing import Any import master_machine_crew as mcrew +from M01_MasterData import M01_MasterData_Doc as m01doc from M01_MasterData import M01_MasterData_Store as store +from M02_MasterTemplete import M02_Labor_Inputs as li from M02_MasterTemplete import M02_MyMachine as mym cm = store.cm @@ -33,19 +36,24 @@ _PLAIN = { "전력 계약종별", } # 이 밖의 입력 = 부착 장비 전용 _TEXT = {"주연료종류", "조종원직종"} # 글 칸 — 나머지 기계 줄 값 칸은 수 -_FIELD = re.compile(r"EQ:\{기계\}\.([^\s*/+()\-,]+)") +_MACHINE = "EQ:{" # 문서 요소 연결 키 「EQ:{S_기계}」 = 고른 기계 줄 HOUR_UNIT = "10^-7/시간" +def _doc(logic: dict | None) -> dict: + """로직 키 → 수식 문서(문서 · 로직 줄 무엇을 받아도 키로) · 없음 = 빈 묶음.""" + return m01doc.docs().get(str((logic or {}).get("키"))) or {} + + def _rows() -> list[dict]: - """「건설기계」 장 파일 안 · 입력 「기계」 고르기가 있는 돈 로직(부착 조합 식 포함).""" + """「건설기계」 장 문서 파일 안 · 입력 「기계」 고르기가 있는 돈 문서(부착 조합 식 포함).""" return [ - row - for name, data in store.loaded()[0].items() - if data.get("그룹") == "로직" and "건설기계" in name - for row in data.get("줄") or [] - if str(row.get("결과단위") or "").startswith("원") - and any(i.get("이름") == "기계" and i.get("고르기") for i in row.get("입력") or []) + doc + for name, data in m01doc.logic_files().items() + if "건설기계" in name + for doc in data["줄"] + if str(doc.get("결과단위") or "").startswith("원") + and any(i["이름"] == "기계" and i.get("고르기") for i in li.specs(doc)) ] @@ -55,12 +63,12 @@ def _family() -> list[dict]: def _codes(row: dict) -> list: - return next(i["고르기"] for i in row["입력"] if i.get("이름") == "기계") + return next(i["고르기"] for i in li.specs(row) if i["이름"] == "기계") def _rank(row: dict) -> tuple: """부착 전용 · 손료만 · 보정 · 기종 수 · 키 — 작을수록 먼저.""" - names = [i.get("이름") for i in row.get("입력") or []] + names = [i["이름"] for i in li.specs(row)] attach = any(n not in _PLAIN for n in names) loss = "지역" not in names return (attach, loss, loss and "보정작업" in names, len(_codes(row)), str(row.get("키"))) @@ -100,11 +108,11 @@ def pick(row: dict) -> dict | None: if got := _own(code): return got key = None if _day_loss(row) else mym.logic_key(row) - return mym.whole().logic(key) if key else None + return m01doc.docs().get(key) if key else None op = float(_vals(row).get("조종원") or 0) > 0 or _operated(code) # 그 줄 인력도(842-3) def order(row: dict) -> tuple: - has = any(x.get("이름") == "조종원" for x in row.get("호표") or []) + has = any(x.get("이름") == "조종원" for x in row.get("금액") or [] if "수량" in x) rank = _rank(row) return (*rank[:3], op and not has, *rank[3:]) @@ -113,15 +121,16 @@ def pick(row: dict) -> dict | None: def _own(code: str) -> dict | None: """그 기계만의 시간당 경비 식(816-1 · 4륜구동 1톤 덤프트럭 = GF000145 · 816-3 체인톱 = GF000337) — - 「기계」 입력 없는 기계경비식이 그 원문번호 기계 줄 값(`EQ….가격` · `EQ….손료계수`)을 읽으면 그 식.""" + 「기계」 입력 없는 기계경비식 문서가 그 원문번호 기계 줄 값(요소 연결 `EQ…` 칸)을 읽으면 그 식.""" rows = mym.whole().index.get("EQ", {}).values() - keys = [f"{r.get('키')}." for r in rows if code and str(r.get("원문번호")) == code] - for data in store.loaded()[0].values(): - for row in data.get("줄") or [] if data.get("그룹") == "로직" else []: - if (row.get("부품") or {}).get("갈래") != "기계경비식" or takes_machine(row): + keys = {r.get("키") for r in rows if code and str(r.get("원문번호")) == code} + for data in m01doc.logic_files().values(): + for doc in data["줄"]: + if (doc.get("부품") or {}).get("갈래") != "기계경비식" or takes_machine(doc): continue - if any(k in str(row.get("중간")) + str(row.get("호표")) for k in keys): - return row + links = [v.get("연결") or {} for v in doc.get("변수") or []] + if any(x.get("갈래") == "요소" and x.get("키") in keys for x in links): + return doc return None @@ -150,10 +159,10 @@ def why(row: dict, logic: dict | None) -> str: if float(vals.get("조종원") or 0) > 0 and not vals.get("조종원직종"): return "조종원직종 없음" return "손료 계수 셋(상각 · 정비 · 관리) 없음" - text = " ".join(str(x.get(k)) for k in ("식", "수량") for p in ("중간", "호표", "덧줄") - for x in logic.get(p) or []) # fmt: skip + links = [v.get("연결") or {} for v in _doc(logic).get("변수") or []] + fields = [x["칸"] for x in links if x.get("갈래") == "요소" and str(x.get("키") or "").startswith(_MACHINE) and x.get("칸")] # fmt: skip lost, odd = [], [] - for name in dict.fromkeys(_FIELD.findall(text)): + for name in dict.fromkeys(fields): v = vals.get(name) if v in (None, ""): lost.append(name) @@ -166,7 +175,7 @@ def why(row: dict, logic: dict | None) -> str: def takes_machine(logic: dict) -> bool: """식이 「기계」 입력(원문번호 고르기)을 받는지 — 안 받는 식(GF000145)엔 기계='…' 를 안 넘김.""" - return any(i.get("이름") == "기계" for i in logic.get("입력") or []) + return any(i["이름"] == "기계" for i in li.specs(_doc(logic))) def hourly(key: str) -> dict[str, Any]: @@ -268,11 +277,7 @@ def combo(main: str, part: str) -> tuple[str, str] | None: return None rows = _rows() fits = any( - len( - attach := [ - i for i in r.get("입력") or [] if i.get("이름") not in _PLAIN and i.get("고르기") - ] - ) + len(attach := [i for i in li.specs(r) if i["이름"] not in _PLAIN and i.get("고르기")]) == 1 # fmt: skip and codes[0] in [str(c) for c in _codes(r)] and codes[1] in [str(c) for c in attach[0]["고르기"]] @@ -289,9 +294,7 @@ def combo(main: str, part: str) -> tuple[str, str] | None: if not fits or row is None: return None given = {"기계": codes[0]} | { - i["이름"]: (i.get("고르기") or [""])[0] - for i in row.get("입력") or [] - if i["이름"] != "기계" + i["이름"]: (i.get("고르기") or [""])[0] for i in li.specs(row) if i["이름"] != "기계" } args = "".join(f", {k}='{v}'" for k, v in given.items()) return str(row["키"]), f"로직({row['키']}{args})" diff --git a/resources/tester/test_804_2_line_stack.py b/resources/tester/test_804_2_line_stack.py index 5e8efa039..3bfb5f35f 100644 --- a/resources/tester/test_804_2_line_stack.py +++ b/resources/tester/test_804_2_line_stack.py @@ -31,6 +31,7 @@ from M01_MasterData import M01_MasterData_Doc as doc_screen from M01_MasterData import M01_MasterData_Router as router_module from M01_MasterData import M01_MasterData_Store as m01 from M02_MasterTemplete import M02_Doc_Copy as dc +from M02_MasterTemplete import M02_Labor_Inputs as li from M02_MasterTemplete import M02_Machine_Hourly as mh mr = importlib.import_module("master_doc_record") # M01 store 가 scripts 길을 둔 뒤 @@ -109,15 +110,13 @@ def _hourly_inputs(logic_key: str) -> dict: if not row: return {} return { - i["이름"]: str((i.get("고르기") or [""])[0]) - for i in row.get("입력") or [] - if i.get("이름") != "기계" + i["이름"]: str((i.get("고르기") or [""])[0]) for i in li.specs(row) if i["이름"] != "기계" } def _kind(row: dict) -> tuple: """갈래 = 부착 · 손료만 · 보정 · 조종원 줄 · 전력 줄(822-2 전력 기종 식 — 손료만 식과 갈림).""" - lines = {x.get("이름") for x in row.get("호표") or []} + lines = {x.get("이름") for x in row.get("금액") or [] if "수량" in x} # 문서 금액 줄(855 L2 ⓑ) return (*mh._rank(row)[:3], "조종원" in lines, "전력" in lines) diff --git a/resources/tester/test_822_2_machine_hourly_all.py b/resources/tester/test_822_2_machine_hourly_all.py index f125d5a2f..f6ad1d966 100644 --- a/resources/tester/test_822_2_machine_hourly_all.py +++ b/resources/tester/test_822_2_machine_hourly_all.py @@ -24,6 +24,7 @@ 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_Inputs as li 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 @@ -254,9 +255,8 @@ def test_moved_samples(): tower = mh.hourly("EQ000165") # 타워크레인 — 건설기계운전사 조종원 줄(요구 799) assert tower["로직"] == "GC000276" and tower["노무비"] == int(_wage("1048") * 5 / 24) spray = m01.loaded()[1].get("EQ000198") # 아스팔트 스프레어 — 직종 빈 칸 = 직종 입력 식 - assert mh.pick(spray)["키"] == "GC000275" and "조종원직종" in json.dumps( - mh.pick(spray)["입력"], ensure_ascii=False - ) + got = mh.pick(spray) # 수식 문서(855 L2 ⓑ) — 입력 = 문서 입력 변수 + assert got["키"] == "GC000275" and "조종원직종" in [i["이름"] for i in li.specs(got)] assert "가격" in mh.hourly("EQ000198")["reason"] assert "3450-0642" not in _codes("GC000273") # 손료만 식에서 뺌 for key, logic in ( diff --git a/resources/tester/test_842_3_machine_crew.py b/resources/tester/test_842_3_machine_crew.py index 7984c37ea..6cff5fb25 100644 --- a/resources/tester/test_842_3_machine_crew.py +++ b/resources/tester/test_842_3_machine_crew.py @@ -49,6 +49,7 @@ def world(): def _logic(index, row, logic): + logic = index.logic(logic["키"]) # 옛 엔진 거울 = 로직 줄(`pick` 은 문서 · 855 L2 ⓑ) given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []} if mh.takes_machine(logic): given["기계"] = str(row.get("원문번호"))