From e8d5534c116b87334c5cbf3dd775502fca5f3115 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Sun, 15 Nov 2026 18:23:04 +0900 Subject: [PATCH] =?UTF-8?q?feat(842-3):=20=EA=B8=B0=EA=B3=84=20=EC=8B=9C?= =?UTF-8?q?=EA=B0=84=EB=8B=B9=20=EC=85=88=20=ED=95=9C=20=EA=B8=B8=20?= =?UTF-8?q?=E2=80=94=20=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EA=B3=84=EC=82=B0?= =?UTF-8?q?=EA=B8=B0=20+=20=EA=B8=B0=EA=B3=84=20=EC=A4=84=20=EC=9D=B8?= =?UTF-8?q?=EB=A0=A5=20=C2=B7=20=EC=9E=A1=ED=92=88=20=EB=AA=A9=EB=A1=9D=20?= =?UTF-8?q?=EB=B0=94=ED=83=95=20=EB=8D=AE=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 읽기 view(Master.value) = 인력 · 잡품 목록 → 식이 읽는 조종원 수 · 직종 · 잡재료율(옛 꼴 = 그대로) - 목록이 식 한 줄로 안 풀리면 row_entry 바탕 덮음 · 단가산출 기계덮음은 merge 로 부분별 위에(짝 TS) - M02_Machine_Hourly.hourly · brief · M02_MyMachine.hourly = 문서 엔진(doc_sums) · 식 문서 없는 식만 옛 로직 엔진 - pick · _operated · why · logic_key · 호표 기계 고름 · 불러오기 기계 수 = 인력 줄로 - 내 기계 clean = 인력 · 잡품 목록 받음(옛 칸 = from_old) · M01 fix · check_master = 목록 꼴 검사 - 사본 자동 따라옴 = 옛 꼴 사본 줄 대 새 꼴 M01 줄은 새 꼴로 바꿔 대조(덮음 안 지움) - 시험 836_1 몸 검사: 조종원 빈 키 = 식 입력 직종으로 받음 → 틀림 꼴을 「키 없음」으로 고침 - 전후: 655 대 로직 엔진 = 문서 엔진 611 같음 · 다름 0 · 코드만 바꾼 뒤 655 대 hourly · brief · 문서 셈 전후 같음 Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Machine.py | 5 + M02_MasterTemplete/M02_Hopyo_SkUnit.py | 4 +- M02_MasterTemplete/M02_Hopyo_Units.py | 4 +- M02_MasterTemplete/M02_Machine_Hourly.py | 41 ++++++- M02_MasterTemplete/M02_MyMachine.py | 64 ++++++++-- M02_MasterTemplete/M02_San_Basis_Index.py | 8 +- M02_MasterTemplete/M02_Sk_AutoRenew.py | 9 +- common_util/common_util_formula_doc_calc.ts | 12 +- common_util/common_util_formula_doc_cover.ts | 111 ++++++++++++++++-- common_util/common_util_machine_crew.ts | 80 +++++++++++++ resources/master_data/scripts/check_master.py | 3 + .../master_data/scripts/master_doc_calc.py | 4 +- .../master_data/scripts/master_doc_cover.py | 105 +++++++++++++++-- .../master_data/scripts/master_doc_link.py | 3 + .../master_data/scripts/master_formula.py | 3 +- .../scripts/master_machine_crew.py | 57 +++++++++ resources/tester/test_836_1_machine_cover.py | 2 +- 17 files changed, 466 insertions(+), 49 deletions(-) create mode 100644 common_util/common_util_machine_crew.ts diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index e04fdd85b..17981f7d2 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -18,6 +18,7 @@ from decimal import Decimal from typing import Any import master_machine_coef as mc # noqa: E402 (`store` 가 scripts 를 길에 둠) +import master_machine_crew as mcrew # noqa: E402 from M01_MasterData import M01_MasterData_Store as store @@ -297,6 +298,9 @@ def fix(part: dict) -> None: or not isinstance(row.get("값"), dict) ): continue + row.update(mcrew.from_old_row(row)) # 옛 칸 → 인력 · 잡품 목록(842-3 · 두 벌 없음) + if bad := mcrew.check(row["값"]): + raise store.StoreError(400, f"{row.get('이름') or ''} — {' · '.join(bad)}") old = stored.get(str(ch.get("key") or "")) if ch.get("op") == "edit" else None values = row["값"] old_values = (old or {}).get("값") or {} @@ -311,5 +315,6 @@ def fix(part: dict) -> None: row.get("단위") or {}, row.get("출처") or {}, ) # 보낸 칸이 있으면 그 글(822-2 빌더) + units |= {k: units.get(k) or u for k, u in (("인력", "인/일"), ("잡품", "%"))} row["단위"] = {k: unit.get(k) or was_unit.get(k, units.get(k, "")) for k in values} row["출처"] = {k: src.get(k) or was_src.get(k, OWN_SOURCE) for k in values} diff --git a/M02_MasterTemplete/M02_Hopyo_SkUnit.py b/M02_MasterTemplete/M02_Hopyo_SkUnit.py index 3de969b6c..e9332dffd 100644 --- a/M02_MasterTemplete/M02_Hopyo_SkUnit.py +++ b/M02_MasterTemplete/M02_Hopyo_SkUnit.py @@ -49,7 +49,9 @@ def _mach_logics(whole: Any, kinds: set, eq: dict | None = None) -> list[str]: order = [first, *sorted(MACHINE_SET - {first})] if not eq: return order - has = eq.get("값") if isinstance(eq.get("값"), dict) else {} + import master_machine_crew as mcrew # 인력 줄 → 조종원 수(842-3) + + has = mcrew.view(eq.get("값")) if isinstance(eq.get("값"), dict) else {} if solo := SOLO.get((bool(has.get("주연료")), bool(has.get("조종원")))): return [solo] eqs = whole.numbers.get("EQ", {}) diff --git a/M02_MasterTemplete/M02_Hopyo_Units.py b/M02_MasterTemplete/M02_Hopyo_Units.py index 914276e91..9da3a6d31 100644 --- a/M02_MasterTemplete/M02_Hopyo_Units.py +++ b/M02_MasterTemplete/M02_Hopyo_Units.py @@ -61,7 +61,9 @@ def mach_logics(whole: Any, kinds: set, eq: dict | None = None) -> list[str]: order = [first, *sorted(MACHINE_SET - {first})] if not eq: return order - has = eq.get("값") if isinstance(eq.get("값"), dict) else {} + import master_machine_crew as mcrew # 인력 줄 → 조종원 수(842-3) + + has = mcrew.view(eq.get("값")) if isinstance(eq.get("값"), dict) else {} if solo := SOLO.get((bool(has.get("주연료")), bool(has.get("조종원")))): return [solo] eqs = whole.numbers.get("EQ", {}) diff --git a/M02_MasterTemplete/M02_Machine_Hourly.py b/M02_MasterTemplete/M02_Machine_Hourly.py index ebe68a7d9..cb53c4680 100644 --- a/M02_MasterTemplete/M02_Machine_Hourly.py +++ b/M02_MasterTemplete/M02_Machine_Hourly.py @@ -7,6 +7,8 @@ 마스터 파일은 읽기만 · 로그인 사용자 모두. 기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) · 층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만. +셈 한 길(842-3) = 식 문서 계산기(`master_doc_calc` · 기계 줄 인력 · 잡품 목록을 바탕 덮음으로 얹음 — +`master_doc_cover.row_entry`) · 식 문서 없는 식만 옛 로직 엔진 · 조종원 유무 = 인력 줄(`master_machine_crew.view`). 식 고름 한 곳(822-2 · `pick`) = ㉠ 원문번호가 식 「기계」 목록에 있으면 그 식(짝 차례) ㉡ 그 기계만의 식 (`_own`) ㉢ 없으면 꼴(채운 칸 · `M02_MyMachine.logic_key`) — M01 [새 기계] · 불러오기 · 데이터 흐름 · 줄 쌓기 · 단가산출 기초가 다 이것을 씀 · 못 고름 · 값 모자람 = 까닭 글(`why`). @@ -17,6 +19,8 @@ from __future__ import annotations import re from typing import Any +import master_machine_crew as mcrew + from M01_MasterData import M01_MasterData_Store as store from M02_MasterTemplete import M02_MyMachine as mym @@ -61,11 +65,15 @@ def _operated(code: str) -> bool: """기계표(원문 8-4) 조종원 > 0 — 그 원문번호 기계 가운데 하나라도.""" rows = mym.whole().index.get("EQ", {}).values() return any( - str(r.get("원문번호")) == code and float((r.get("값") or {}).get("조종원") or 0) > 0 - for r in rows + str(r.get("원문번호")) == code and float(_vals(r).get("조종원") or 0) > 0 for r in rows ) +def _vals(row: dict) -> dict: + """식이 읽는 값 칸(인력 · 잡품 줄 → 조종원 수 · 직종 · 잡재료율).""" + return mcrew.view(row.get("값") or {}) or {} + + def logic_of(code: str) -> dict | None: """기계 원문번호 → 그 기계 시간당 경비 로직 · 없으면 None(813-2 M01 화면 · 불러오기 `M02_Doc_Import.hourly_link` 도 씀) — `pick` 과 같음(그 원문번호 기계 줄로).""" @@ -128,7 +136,7 @@ def _is_num(v: Any) -> bool: def why(row: dict, logic: dict | None) -> str: """시간당 경비를 못 내는 까닭 한 줄(값이 정말 모자람) · 셀 수 있으면 빈 글.""" - vals = row.get("값") or {} + vals = _vals(row) if logic is None: if unit := _day_loss(row): return f"손료계수 단위 「{unit}」 — 시간당 식 없음(일 단위 손료)" @@ -175,6 +183,9 @@ def hourly(key: str) -> dict[str, Any]: for i in logic.get("입력") or [] if i.get("이름") != "기계" ) + if (got := doc_sums(row, logic, whole)) is not None: + return got if not got["ok"] else {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), + "로직": logic["키"], "원문번호": code, **got["합"]} # fmt: skip mine = f", 기계='{code}'" if takes_machine(logic) else "" call = f"로직({logic['키']}{mine}{args})" line = {"종류": "로직", "요소": call, "이름": "기계", "단위": "시간", "수량": "1"} @@ -197,6 +208,28 @@ def hourly(key: str) -> dict[str, Any]: } +def doc_sums(row: dict, logic: dict, index: Any) -> dict | None: + """셈 한 길(842-3) — 식 문서 계산기 + 기계 줄 목록(바탕 덮음) · 입력 = 식 기본값 · + {ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason} · 식 문서 없음 = None(옛 로직 엔진).""" + import master_doc_calc as mc + import master_doc_cover as mcv + import master_doc_link as ml + + from M01_MasterData import M01_MasterData_Doc as m01doc + + docs = m01doc.docs() + doc = docs.get(str(logic.get("키"))) + if doc is None: + return None + given = {"기계": str(row.get("원문번호"))} if takes_machine(logic) else {} + shaped = mcv.cover_doc(doc, given, None, mcv.row_entry(doc, row.get("값"))) + got = mc.calc(shaped, ml.Links(index, docs), given) + if not got["셈됨"]: + why = got.get("까닭") or " · ".join(m["글"] for m in got["표지"]) or "셈 못 함" + return {"ok": False, "reason": why, "로직": logic["키"]} + return {"ok": True, "합": {k: float(got[k]) for k in (*cm.mf.COST_ITEMS, "계")}} + + _BRIEF: dict[tuple, dict] = {} @@ -223,6 +256,8 @@ def brief(keys: list[str]) -> list[dict[str, Any]]: head = {k: row.get(k) for k in ("키", "원문번호", "이름", "규격")} if lack := why(row, logic): hour = {"ok": False, "reason": lack} + elif (by_doc := doc_sums(row, logic, index)) is not None: + hour = {"ok": True, "로직": logic["키"], **by_doc["합"]} if by_doc["ok"] else by_doc else: given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []} if takes_machine(logic): diff --git a/M02_MasterTemplete/M02_MyMachine.py b/M02_MasterTemplete/M02_MyMachine.py index 4d8f2f673..3fdbcc521 100644 --- a/M02_MasterTemplete/M02_MyMachine.py +++ b/M02_MasterTemplete/M02_MyMachine.py @@ -40,11 +40,11 @@ EASY, BOOK, DIRECT = "바로", "품셈", "직접" COSTS = ("노무비", "재료비", "경비") RATIOS = ("내용시간", "연간표준가동시간", "상각비율", "정비비율", "연간관리비율") COEFS = ("상각비계수", "정비비계수", "관리비계수") -NUMS = ("가격", *RATIOS, *COEFS, "손료계수", "주연료", "잡재료율", "조종원", "전력") +NUMS = ("가격", *RATIOS, *COEFS, "손료계수", "주연료", "전력") UNITS = { "가격": "천원", "내용시간": "시간", "연간표준가동시간": "시간", "상각비율": "", "정비비율": "", "연간관리비율": "", **{k: "10^-7/시간" for k in (*COEFS, "손료계수")}, "주연료": "ℓ/hr", - "주연료종류": "", "잡재료율": "주연료의 %", "조종원": "인/일", "조종원직종": "", "전력": "kWh/hr", + "주연료종류": "", "인력": "인/일", "잡품": "%", "전력": "kWh/hr", } # fmt: skip LOGIC = {(True, True): "GC000268", (True, False): "GC000272", (False, True): "GC000276", (False, False): "GC000273"} # fmt: skip @@ -124,14 +124,17 @@ def rows(folder: Path | None = None) -> list[dict]: # ── 셈 색인 ────────────────────────────────────────────────────────── def engine(row: dict) -> dict: - """셈 꼴 — 바로 = 상각비계수 ← 손료계수 · 정비 · 관리 0 · 빈 연료 · 조종원 칸 = 0 · 수 = Decimal.""" - vals = dict(row.get("값") or {}) + """셈 꼴 — 바로 = 상각비계수 ← 손료계수 · 정비 · 관리 0 · 빈 연료 = 0 · 인력 · 잡품 = 빈 목록 · + 옛 꼴(조종원 · 조종원직종 · 잡재료율 칸) = 목록으로(842-3 · `master_machine_crew.from_old`) · 수 = Decimal.""" + import master_machine_crew as mcrew + + vals = mcrew.from_old(dict(row.get("값") or {})) if row.get("방식") == DIRECT: # 직접 식(GC001199)이 읽는 칸 vals = {k: (row.get("시간당") or {}).get(k) or 0 for k in COSTS} if row.get("방식") == EASY: vals |= {"상각비계수": vals.get("손료계수") or 0, "정비비계수": 0, "관리비계수": 0} if row.get("방식") != DIRECT: - vals = {"주연료": 0, "잡재료율": 0, "조종원": 0, "주연료종류": "", "조종원직종": ""} | vals + vals = {"주연료": 0, "주연료종류": "", "인력": [], "잡품": []} | vals raw = json.dumps({**row, "값": vals}, ensure_ascii=False) return json.loads(raw, parse_float=Decimal, parse_int=Decimal) @@ -192,7 +195,9 @@ def logic_key(row: dict) -> str | None: 계수 셋(상각 · 정비 · 관리) 없음 = 손료계수 한 칸 식(연료만) · 그 밖은 그 식 + 모자란 칸 까닭.""" if row.get("방식") == DIRECT: return DIRECT_KEY - vals = row.get("값") or {} + import master_machine_crew as mcrew + + vals = mcrew.view(row.get("값") or {}) or {} # 인력 줄 → 조종원 수 · 직종(842-3) fuel, crew, power = (_pos(vals.get(k)) for k in ("주연료", "조종원", "전력")) job = bool(vals.get("조종원직종")) three = all(vals.get(k) is not None for k in COEFS) @@ -237,6 +242,11 @@ def hourly(row: dict, index: Any) -> dict[str, Any]: if key is None: return {"ok": False, **head, "reason": "식 없음 — 조종원직종 없음"} logic = index.logic(key) + from M02_MasterTemplete import M02_Machine_Hourly as mh # 셈 한 길(842-3) + + if (by_doc := mh.doc_sums(row, logic, index)) is not None: + got = by_doc.get("합") or {"reason": by_doc.get("reason")} + return {"ok": by_doc["ok"], **head, "로직": logic["키"], **got} given = {i["이름"]: (i.get("고르기") or [""])[0] for i in logic.get("입력") or []} given["기계"] = str(row.get("원문번호")) try: @@ -282,7 +292,10 @@ def clean(raw: Any) -> dict[str, Any]: how = raw.get("방식") or EASY if how not in (EASY, BOOK, DIRECT): raise _bad("방식은 바로 · 품셈 · 직접") + import master_machine_crew as mcrew + given = raw.get("값") if isinstance(raw.get("값"), dict) else {} + given = mcrew.from_old(given) # 옛 꼴(조종원 · 잡재료율 칸) = 목록으로(842-3) out: dict[str, Any] = {"이름": name, "규격": spec, "방식": how} if how == DIRECT: hour = raw.get("시간당") if isinstance(raw.get("시간당"), dict) else {} @@ -297,7 +310,7 @@ def clean(raw: Any) -> dict[str, Any]: vals = {k: v for k, v in vals.items() if k not in drop} if how == BOOK: vals |= _coef(vals) - vals |= _kinds(given, vals) + vals |= _kinds(given, vals) | _lists(given) out["값"] = vals out["단위"] = {k: UNITS[k] for k in vals if k in UNITS} out["출처"] = {k: "개인" for k in vals} @@ -307,20 +320,45 @@ def clean(raw: Any) -> dict[str, Any]: def _kinds(given: dict, vals: dict) -> dict: - """주연료종류 = M01 유가 이름 · 조종원직종 = M01 인력 원문번호(쓸 때만 · 고르기 목록 밖 = 400).""" + """주연료종류 = M01 유가 이름(쓸 때만 · 고르기 목록 밖 = 400).""" index, out = m01.loaded()[1], {} - fuel, job = str(given.get("주연료종류") or ""), str(given.get("조종원직종") or "") + fuel = str(given.get("주연료종류") or "") if vals.get("주연료"): if f"{fuel}:전국평균" not in (index.numbers.get("MO") or {}): raise _bad(f"주연료종류 「{fuel}」 — 유가 목록에서 고름") out["주연료종류"] = fuel - if vals.get("조종원"): - if job not in (index.numbers.get("LB") or {}): - raise _bad(f"조종원직종 「{job}」 — 인력 목록에서 고름") - out["조종원직종"] = job return out +def _lists(given: dict) -> dict: + """인력 · 잡품 줄(842-3 · `master_machine_crew` 꼴) — 꼴 = 덮음 검사(`master_doc_cover.clean`) · + 인력 키 = M01 노임(LB:원문번호 · LB 키) · 잡품 = 재료 줄(주연료 · 전력) 또는 M01 요소 키 · 빈 줄 = 뺌.""" + import master_doc_cover as mcv + import master_machine_crew as mcrew + + index = m01.loaded()[1] + body = {c: given[c] for c in mcrew.LISTS if given.get(c) is not None} + try: + got = mcv.clean({"기계": {"조종원": body.get("인력"), "잡품": body.get("잡품")}}) + except ValueError as e: + raise _bad(str(e).replace("기계덮음 「기계」 조종원", "인력")) from None + rows = got.get("기계") or {} + for r in rows.get("조종원") or []: + if mcrew.code(r["키"]) not in (index.numbers.get("LB") or {}) and r["키"] not in ( + index.index.get("LB") or {} + ): + raise _bad(f"인력 「{r['키']}」 — 인력 목록에서 고름") + for r in rows.get("잡품") or []: + if r.get("줄") and r["줄"] not in mcrew.BASE: + raise _bad(f"잡품 줄 「{r['줄']}」 — 주연료 · 전력") + if r.get("키"): + try: + index.get(str(r["키"])) + except m01.cm.mf.FormulaError: + raise _bad(f"잡품 재료 「{r['키']}」 — 재료 목록에서 고름") from None + return {c: rows[p] for c, p in (("인력", "조종원"), ("잡품", "잡품")) if c in body} + + # ── 만들기 · 고치기 · 지우기 · 읽기 ───────────────────────────────────── def _seed(key: str) -> dict: """「비슷한 기계에서 시작」 — M01 · 내 기계 줄 값 복사(품셈 비율 있으면 품셈 · 없으면 바로).""" diff --git a/M02_MasterTemplete/M02_San_Basis_Index.py b/M02_MasterTemplete/M02_San_Basis_Index.py index d4724a162..fd5ce7fcc 100644 --- a/M02_MasterTemplete/M02_San_Basis_Index.py +++ b/M02_MasterTemplete/M02_San_Basis_Index.py @@ -292,9 +292,11 @@ def _cells(tables: dict, eq: dict) -> list[dict]: "종류": "ratio", } ) - for ek, r in eq.items(): # 기계 요소 수(가격 · 글 뺌) - for col, x in (r.get("값") or {}).items(): - if col in ("가격", "주연료종류", "조종원직종") or col.endswith("가격"): + import master_machine_crew as mcrew # 인력 · 잡품 목록 → 조종원 수 · 잡재료율(842-3) + + for ek, r in eq.items(): # 기계 요소 수(가격 · 글 · 목록 뺌) + for col, x in (mcrew.view(r.get("값") or {}) or {}).items(): + if col in ("가격", "주연료종류", "조종원직종", *mcrew.LISTS) or col.endswith("가격"): continue unit = (r.get("단위") or {}).get(col, "") if isinstance(r.get("단위"), dict) else "" cells += [ diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index db33ebaac..7e588fa69 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -206,6 +206,13 @@ def _row_diff(a: dict, b: dict) -> list[str]: return [f"{k} {va.get(k, '—')} → {vb.get(k, '—')}" for k in keys if va.get(k) != vb.get(k)] +def _same_new(a: dict, b: dict) -> bool: + """옛 꼴 사본 줄 대 새 꼴 M01 줄(842-3 인력 · 잡품 목록 옮김) — 새 꼴로 바꿔 같으면 안 바뀜.""" + import master_machine_crew as mcrew + + return skc._fp(mcrew.from_old_row(a)) == skc._fp(mcrew.from_old_row(b)) + + def _covers(got: dict, out: dict, notes: list | None) -> dict: """문서(따로) · 맡긴 기계 덮음 가운데 그 기계 줄이 M01 에서 바뀐 것 = 지움 + 알림.""" doc = out.get("문서") if isinstance(out.get("문서"), dict) else None @@ -215,7 +222,7 @@ def _covers(got: dict, out: dict, notes: list | None) -> dict: was, now = _eq_rows(got), _eq_rows(out) for text in list(cover): a, b = was.get(text), now.get(text) - if a is None or b is None or skc._fp(a) == skc._fp(b): + if a is None or b is None or skc._fp(a) == skc._fp(b) or _same_new(a, b): continue entry = cover.pop(text) if notes is not None: diff --git a/common_util/common_util_formula_doc_calc.ts b/common_util/common_util_formula_doc_calc.ts index fe33fc79d..d140b1e14 100644 --- a/common_util/common_util_formula_doc_calc.ts +++ b/common_util/common_util_formula_doc_calc.ts @@ -25,7 +25,14 @@ import { type Node, type Rule, } from "./common_util_formula_doc"; -import { coverDoc, coverOf as machineCover, type Cover } from "./common_util_formula_doc_cover"; +import { + coverDoc, + coverOf as machineCover, + isMachine, + listsOf, + rowEntry, + type Cover, +} from "./common_util_formula_doc_cover"; const EPS = 1e-7; // B09_Estimation_Calc_Base EPS 와 같음 const DEEP = 20; @@ -367,7 +374,8 @@ class Run { .map((k) => `${k}=${plainText(given[k])}`) .join("|")}`; if (!this.memo.has(memoKey)) { - const shaped = coverDoc(doc, given, this.cover); + const lists = isMachine(doc) ? listsOf((q) => this.links.element(q), given) : null; + const shaped = coverDoc(doc, given, this.cover, rowEntry(doc, lists)); // 기계 줄 목록(842-3) this.memo.set( memoKey, calcDoc(shaped, this.links, given, [...this.stack, key], this.memo, this.cover), diff --git a/common_util/common_util_formula_doc_cover.ts b/common_util/common_util_formula_doc_cover.ts index 12d0f28ea..9f0ee7456 100644 --- a/common_util/common_util_formula_doc_cover.ts +++ b/common_util/common_util_formula_doc_cover.ts @@ -6,7 +6,10 @@ * 값 = 기계 식이 읽는 기계 칸(요소 `EQ:{S_기계}` 칸 — 조종원 · 조종원직종 · 잡재료율 빼고) · 조종원 = 인력 줄(노임 키 · 인/일) · * 잡품 = 재료 줄(율 % · 줄 = 그 금액 줄 단가 · 수량 따름(기본) · 키 = 고른 재료 요소) · 원본과 같은 칸 = 없음(`prune`) * 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음) - * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py + * 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) · + * 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째) + * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py · + * test_842_3_machine_crew.py * · 화면 · DOM · fetch 없음 * ========================================================================== */ @@ -19,6 +22,7 @@ import { type FormulaDoc, type MoneyLine, } from "./common_util_formula_doc"; +import { CREW, MISC, code as jobOf } from "./common_util_machine_crew"; export const COVER = "기계덮음"; /** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */ @@ -166,8 +170,13 @@ const fillKey = (text: string, vals: Vals): string => return typeof v === "number" ? plain(v) : String(v ?? ""); }); -/** 원본(덮음 없음) 기본값 — 셈 답 값(`vals` = 그 기계로 셈한 원본 답 `값`) */ -export function defaultsOf(doc: FormulaDoc, vals: Vals): Required { +/** 원본(단가산출 덮음 없음) 기본값 — 셈 답 값(`vals` = 그 기계로 셈한 원본 답 `값`) · + * `base` = 기계 줄 바탕 덮음(`rowEntry`) — 있는 부분은 그 목록(빈 직종 키 = 식이 고른 직종) */ +export function defaultsOf( + doc: FormulaDoc, + vals: Vals, + base?: MachineCover | null, +): Required { const parts = partsOf(doc); const lines = doc.금액 ?? []; const vars = new Map((doc.변수 ?? []).map((v) => [varId(v), v])); @@ -183,8 +192,16 @@ export function defaultsOf(doc: FormulaDoc, vals: Vals): Required return n && key ? [{ 키: fillKey(key, vals), 인: n }] : []; }); const r = parts.rate ? num(vals[parts.rate]) : null; - const 잡품 = r ? parts.base.map((i) => ({ 줄: String(lines[i].이름 ?? ""), 율: r })) : []; - return { 값, 조종원, 잡품 }; + let 잡품: MiscRow[] = r + ? parts.base.map((i) => ({ 줄: String(lines[i].이름 ?? ""), 율: r })) + : []; + let crew: CrewRow[] = 조종원; + if (base?.조종원) { + const own = 조종원[0]?.키 ?? ""; + crew = base.조종원.filter((x) => x.키 || own).map((x) => ({ ...x, 키: x.키 || own })); + } + if (base?.잡품) 잡품 = base.잡품; + return { 값, 조종원: crew, 잡품 }; } /** 원본 대조 꼴 — 이름 · 단위(화면 글) · 빈 칸 뺌 · 수 12 자리 */ @@ -252,7 +269,9 @@ function addVar(doc: FormulaDoc, sign: string, low: string, name: string, key: s return id; } -function crewLines(doc: FormulaDoc, rows: CrewRow[]): MoneyLine[] { +/** 조종원 줄 — 빈 키 줄 = 식의 조종원 단가 기호(`own` · 식 입력 직종) · 없으면 뺌 */ +function crewLines(doc: FormulaDoc, all: CrewRow[], own = ""): MoneyLine[] { + const rows = all.filter((r) => r.키 || own); const have = (doc.변수 ?? []).some((v) => varId(v) === HOUR) || (doc.식 ?? []).some((l) => l.기호 === HOUR); // prettier-ignore if (rows.length && !have) { const ids = new Set((doc.변수 ?? []).map(varId)); @@ -265,7 +284,7 @@ function crewLines(doc: FormulaDoc, rows: CrewRow[]): MoneyLine[] { 단위: "인", 비목: "노무비", 수량: `${plain(r.인)} × ${HOUR}`, - 단가: addVar(doc, "w", "조종원", "조종원 노임", r.키), + 단가: r.키 ? addVar(doc, "w", "조종원", "조종원 노임", r.키) : own, })); } @@ -288,14 +307,16 @@ function miscLines(doc: FormulaDoc, rows: MiscRow[], lines: MoneyLine[]): MoneyL }); } -/** 기계 식 문서에 그 기계 덮음을 얹음(새 문서) — 덮음 없음 = 그대로(같은 물건) */ +/** 기계 식 문서에 그 기계 덮음을 얹음(새 문서) — `base` = 기계 줄 바탕 덮음(`rowEntry`) · 덮음 없음 = 그대로(같은 물건) */ export function coverDoc( doc: FormulaDoc, given: Record | null | undefined, cover: Cover | null | undefined, + base?: MachineCover | null, ): FormulaDoc { - const entry = cover?.[machineKey(given)]; - if (!entry || !machineKey(given)) return doc; + const key = machineKey(given); + const entry = mergeCover(base, key ? cover?.[key] : undefined); + if (!entry) return doc; const out = clone(doc) as FormulaDoc & { 쌓기?: unknown }; delete out.쌓기; // 금액 차례가 바뀜 — 기본 차림 const parts = partsOf(out); @@ -304,7 +325,8 @@ export function coverDoc( for (const v of out.변수 ?? []) if (f.ids.includes(varId(v))) v.연결 = { 갈래: "숫자", 값: entry.값[f.칸] }; const lines = out.금액 ?? []; - const crew = entry.조종원 ? crewLines(out, entry.조종원) : null; + const own = parts.crew.length ? String(lines[parts.crew[0]].단가 ?? "") : ""; + const crew = entry.조종원 ? crewLines(out, entry.조종원, own) : null; const misc = entry.잡품 && (parts.misc !== null || entry.잡품.length) ? miscLines(out, entry.잡품, lines) : null; // prettier-ignore const gone = new Set([...(crew ? parts.crew : []), ...(misc && parts.misc !== null ? [parts.misc] : [])]); // prettier-ignore const tail = lines.findIndex((l) => l.비목 === "경비"); @@ -320,3 +342,70 @@ export function coverDoc( out.금액 = next; return out; } + +// ── 기계 줄 목록 → 바탕 덮음(842-3) ───────────────────────────────────── +/** 기계 시간당 식 — 결과 원/시간 · 요소 `EQ:{S_기계}` 칸을 읽음 */ +export const isMachine = (doc: FormulaDoc | null | undefined): boolean => + !!doc && + doc.결과단위 === "원/시간" && + (doc.변수 ?? []).some( + (v) => v.연결?.갈래 === "요소" && String(v.연결?.키 ?? "").includes("{S_기계}"), + ); + +/** 기계 줄 목록(`인력` · `잡품`) 가운데 식 한 줄로 안 풀리는 부분 = 바탕 덮음 · 다 풀림 = null */ +export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): MachineCover | null { + if (!vals || !isMachine(doc)) return null; + const parts = partsOf(doc); + const lines = doc.금액 ?? []; + const out: MachineCover = {}; + const crew = vals[CREW]; + if (Array.isArray(crew) && (crew.length || parts.crew.length)) { + const rows = crew as CrewRow[]; + const jobs = new Set(rows.map((r) => jobOf(r?.키))); + if (!(parts.crew.length && rows.length && jobs.size === 1)) out.조종원 = rows; + } + const misc = vals[MISC]; + if (Array.isArray(misc) && misc.length) { + const rows = misc as MiscRow[]; + const names = parts.base.map((i) => String(lines[i].이름 ?? "")).sort(); + const plainMisc = + parts.misc !== null && + rows.every((r) => r && r.줄 && !r.키) && + rows.every((r) => r.수량 === undefined || r.수량 === null) && + new Set(rows.map((r) => canon(r.율))).size === 1 && + JSON.stringify(rows.map((r) => String(r.줄)).sort()) === JSON.stringify(names); + if (!plainMisc) out.잡품 = rows; + } + return Object.keys(out).length ? out : null; +} + +/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */ +export function mergeCover( + base: MachineCover | null | undefined, + top: MachineCover | null | undefined, +): MachineCover | null { + if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null; + if (!top || !Object.keys(top).length) return base; + const out: MachineCover = { ...base, ...top }; + const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) }; + if (Object.keys(값).length) out.값 = 값; + else delete out.값; + return out; +} + +/** 셈 연결로 그 기계 줄 목록 읽기 — {인력?, 잡품?} · 못 읽음 = 빈 묶음(요소 `EQ:<기계>` 칸) */ +export function listsOf( + element: (p: { 키: string; 칸: string }) => unknown, + given: Record | null | undefined, +): Vals { + const key = machineKey(given); + const out: Vals = {}; + if (key) + for (const col of [CREW, MISC]) + try { + out[col] = element({ 키: `EQ:${key}`, 칸: col }); + } catch { + /* 못 읽음 = 그 목록 없음 */ + } + return out; +} diff --git a/common_util/common_util_machine_crew.ts b/common_util/common_util_machine_crew.ts new file mode 100644 index 000000000..145cdfba8 --- /dev/null +++ b/common_util/common_util_machine_crew.ts @@ -0,0 +1,80 @@ +/* ============================================================================= + * common_util_machine_crew.ts + * 기계 한 대 인력 줄 · 잡품 줄(PLAN 842-3 · 요구 849 · 853 · 867 · 868 · 870) — 기계 줄 값 칸 꼴 · 읽는 법 + * 꼴(기계 줄 `값`) — 인력 = [{키: 'LB:<인력 원문번호>'(빈 글 = 직종 고르기), 인, 이름?}] · + * 잡품 = [{줄: '주연료' | '전력' | 키: 재료 요소 키, 이름?, 수량?, 율 %}] · 옛 칸(조종원 · 조종원직종 · 잡재료율) 없음 + * 읽기(`crewView`) = 식이 읽는 조종원 수(인 합) · 직종(첫 직종) · 잡재료율(첫 줄 율)을 목록에서 셈(저장 안 함) · 옛 꼴 = 그대로 + * 옛 꼴 → 새 꼴(`fromOld`) + * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_machine_crew.py · 거울 시험 test_842_3_machine_crew.py + * · 화면 · DOM · fetch 없음 + * ========================================================================== */ + +import type { CrewRow, MiscRow } from "./common_util_formula_doc_cover"; + +export const CREW = "인력"; +export const MISC = "잡품"; +export const LISTS = [CREW, MISC]; +export const OLD = ["조종원", "조종원직종", "잡재료율"]; +/** 잡품 줄 기본 = 이 재료 줄(값 > 0) */ +export const BASE = ["주연료", "전력"]; + +type Vals = Record; +const isNum = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v); + +/** 노임 키 → 인력 원문번호(`LB:1048` → 1048 · 빈 글 = 직종 고르기) */ +export const code = (key: unknown): string => { + const t = String(key ?? ""); + return t.startsWith("LB:") ? t.slice(3) : t; +}; + +/** 새 꼴(옛 칸 없음) 기계 값 */ +export const isNew = (vals: unknown): boolean => + !!vals && + typeof vals === "object" && + !Array.isArray(vals) && + !OLD.some((k) => k in (vals as Vals)); + +export const crewOf = (vals: Vals | undefined): CrewRow[] | undefined => + Array.isArray(vals?.[CREW]) ? (vals[CREW] as CrewRow[]) : undefined; +export const miscOf = (vals: Vals | undefined): MiscRow[] | undefined => + Array.isArray(vals?.[MISC]) ? (vals[MISC] as MiscRow[]) : undefined; + +/** 식이 읽는 값 — 새 꼴이면 옛 칸 셋을 목록에서 셈해 더한 새 묶음 · 그 밖 = 그대로 */ +export function crewView(vals: Vals): Vals { + if (!isNew(vals)) return vals; + const crew = crewOf(vals); + const misc = miscOf(vals); + const jobs = (crew ?? []).map((r) => code(r?.키)).filter((c) => c); + const rate = (misc ?? []).find((r) => r && r.줄)?.율; + return { + ...vals, + 조종원: crew === undefined ? null : crew.reduce((a, r) => a + (Number(r?.인) || 0), 0), + 조종원직종: jobs.length ? jobs[0] : null, + 잡재료율: misc === undefined ? null : (rate ?? 0), + }; +} + +/** 옛 꼴 값 → 새 꼴(옛 칸 셋 → 인력 · 잡품) — 옛 칸 없음 = 그대로 */ +export function fromOld(vals: Vals, base?: string[]): Vals { + if (isNew(vals)) return vals; + const out: Vals = Object.fromEntries(Object.entries(vals).filter(([k]) => !OLD.includes(k))); + const n = vals.조종원; + const job = vals.조종원직종; + const rate = vals.잡재료율; + if (isNum(n)) out[CREW] = n > 0 ? [{ 키: job ? `LB:${String(job)}` : "", 인: n }] : []; + if (isNum(rate)) { + const b = base ?? BASE.filter((k) => Number(vals[k]) > 0); + out[MISC] = rate > 0 && b.length ? b.map((줄) => ({ 줄, 율: rate })) : []; + } + return out; +} + +/** 목록 요약 글(M01 기계 목록 열) — 「1048 1인 · 잡품 주연료 22%」 */ +export function crewSummary(vals: Vals | undefined, jobName?: (code: string) => string): string { + const crew = (crewOf(vals) ?? []).map((r) => { + const c = code(r.키); + return `${r.이름 || (c ? (jobName?.(c) ?? c) : "직종 고르기")} ${r.인}인`; + }); + const misc = (miscOf(vals) ?? []).map((r) => `${r.이름 || r.줄 || r.키} ${r.율}%`); + return [...crew, ...(misc.length ? [`잡품 ${misc.join(", ")}`] : [])].join(" · "); +} diff --git a/resources/master_data/scripts/check_master.py b/resources/master_data/scripts/check_master.py index fb6e21dfe..8bd3a0620 100644 --- a/resources/master_data/scripts/check_master.py +++ b/resources/master_data/scripts/check_master.py @@ -32,6 +32,7 @@ import master_basis as mbs # noqa: E402 import master_combo as mcb # noqa: E402 import master_formula as mf # noqa: E402 import master_keys as mk # noqa: E402 +import master_machine_crew as mcrew # noqa: E402 import master_machine_files as mmf # noqa: E402 import material_merge as mm # noqa: E402 @@ -311,6 +312,8 @@ def check_form(name: str, data: dict) -> list[str]: ) if kind == "품셈재료": out += _check_linked(where, row) + if kind == "요소" and str(row.get("키"))[:2] == "EQ": # 인력 · 잡품 목록(842-3) + out += [f"{where} · {x}" for x in mcrew.check(row.get("값"))] if kind == "요소" and isinstance(row.get("값"), dict): for bundle in ("단위", "출처"): if isinstance(row.get(bundle), dict) and set(row[bundle]) != set(row["값"]): diff --git a/resources/master_data/scripts/master_doc_calc.py b/resources/master_data/scripts/master_doc_calc.py index 8c13f2f2d..22bf2c0de 100644 --- a/resources/master_data/scripts/master_doc_calc.py +++ b/resources/master_data/scripts/master_doc_calc.py @@ -298,7 +298,9 @@ class _Run: given = payload.get("입력") or {} memo_key = (key, tuple(sorted((k, plain_text(v)) for k, v in given.items()))) if memo_key not in self.memo: - doc = mcv.cover_doc(doc, given, self.cover) + lists = mcv.lists_of(self.links, given) if mcv.is_machine(doc) else {} + base = mcv.row_entry(doc, lists) # 기계 줄 목록(842-3) + doc = mcv.cover_doc(doc, given, self.cover, base) self.memo[memo_key] = calc( doc, self.links, given, (*self.stack, key), self.memo, self.cover ) diff --git a/resources/master_data/scripts/master_doc_cover.py b/resources/master_data/scripts/master_doc_cover.py index 86701b53b..a8f866128 100644 --- a/resources/master_data/scripts/master_doc_cover.py +++ b/resources/master_data/scripts/master_doc_cover.py @@ -5,8 +5,10 @@ 기계 입력 글 = 부름 입력 `기계` 값(따옴표 뗌) — 같은 기계 줄 여럿 = 한 벌 · 원본과 같은 칸 = 없음(`prune`). 셈 규칙(`cover_doc`) = 계산기(`master_doc_calc.calc`)가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음). +기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) · + 단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째). 파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험 -`resources/tester/test_836_1_machine_cover.py`. +`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py`. """ from __future__ import annotations @@ -17,6 +19,7 @@ import re from decimal import Decimal import master_doc as md +import master_machine_crew as mcrew COVER = "기계덮음" NOT_VALUE = ( @@ -134,8 +137,9 @@ def _fill_key(text: str, vals: dict) -> str: return re.sub(r"\{([^{}]+)\}", one, text) -def defaults_of(doc: dict, vals: dict) -> dict: - """원본(덮음 없음) 기본값 — `vals` = 그 기계로 셈한 원본 답 `값`.""" +def defaults_of(doc: dict, vals: dict, base: dict | None = None) -> dict: + """원본(단가산출 덮음 없음) 기본값 — `vals` = 그 기계로 셈한 원본 답 `값` · + `base` = 기계 줄 바탕 덮음(`row_entry`) — 있는 부분은 그 목록(빈 직종 키 = 식이 고른 직종).""" parts = parts_of(doc) lines = doc.get("금액") or [] vars_ = {md.var_id(v): v for v in doc.get("변수") or []} @@ -153,6 +157,12 @@ def defaults_of(doc: dict, vals: dict) -> dict: crew.append({"키": _fill_key(key, vals), "인": n}) r = _num(vals.get(parts["rate"])) if parts["rate"] else None misc = [{"줄": str(lines[i].get("이름") or ""), "율": r} for i in parts["base"]] if r else [] + base = base or {} + if base.get("조종원") is not None: + own = crew[0]["키"] if crew else "" + crew = [{**x, "키": x.get("키") or own} for x in base["조종원"] if x.get("키") or own] + if base.get("잡품") is not None: + misc = base["잡품"] return {"값": values, "조종원": crew, "잡품": misc} @@ -214,7 +224,9 @@ def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str: return id_ -def _crew_lines(doc: dict, rows: list) -> list[dict]: +def _crew_lines(doc: dict, rows: list, own: str = "") -> list[dict]: + """조종원 줄 — 빈 키 줄 = 식의 조종원 단가 기호(`own` · 식 입력 직종) · 없으면 뺌.""" + rows = [r for r in rows if r.get("키") or own] have = any(md.var_id(v) == HOUR for v in doc.get("변수") or []) or any( x.get("기호") == HOUR for x in doc.get("식") or [] ) @@ -227,7 +239,7 @@ def _crew_lines(doc: dict, rows: list) -> list[dict]: return [ {"이름": "조종원", **({"규격": r["이름"]} if r.get("이름") else {}), "단위": "인", "비목": "노무비", "수량": f"{_plain(r['인'])} × {HOUR}", - "단가": _add_var(doc, "w", "조종원", "조종원 노임", r["키"])} + "단가": _add_var(doc, "w", "조종원", "조종원 노임", r["키"]) if r.get("키") else own} for r in rows ] # fmt: skip @@ -253,10 +265,11 @@ def _misc_lines(doc: dict, rows: list, lines: list) -> list[dict]: return out -def cover_doc(doc: dict, given, cover) -> dict: - """기계 식 문서에 그 기계 덮음을 얹음(새 문서) — 덮음 없음 = 그대로(같은 물건).""" +def cover_doc(doc: dict, given, cover, base: dict | None = None) -> dict: + """기계 식 문서에 그 기계 덮음을 얹음(새 문서) — `base` = 기계 줄 바탕 덮음(`row_entry`) · + 덮음 없음 = 그대로(같은 물건).""" key = machine_key(given) - entry = (cover or {}).get(key) if key else None + entry = merge(base, (cover or {}).get(key) if key else None) if not entry: return doc out = cp.deepcopy(doc) @@ -269,7 +282,8 @@ def cover_doc(doc: dict, given, cover) -> dict: if md.var_id(v) in f["ids"]: v["연결"] = {"갈래": "숫자", "값": values[f["칸"]]} lines = out.get("금액") or [] - crew = _crew_lines(out, entry["조종원"]) if entry.get("조종원") is not None else None + own = str(lines[parts["crew"][0]].get("단가") or "") if parts["crew"] else "" + crew = _crew_lines(out, entry["조종원"], own) if entry.get("조종원") is not None else None want = entry.get("잡품") misc = ( _misc_lines(out, want, lines) @@ -294,6 +308,72 @@ def cover_doc(doc: dict, given, cover) -> dict: return out +# ── 기계 줄 목록 → 바탕 덮음(842-3) ───────────────────────────────────── +def is_machine(doc) -> bool: + """기계 시간당 식 — 결과 원/시간 · 요소 `EQ:{S_기계}` 칸을 읽음.""" + return ( + isinstance(doc, dict) + and doc.get("결과단위") == "원/시간" + and any( + (v.get("연결") or {}).get("갈래") == "요소" + and "{S_기계}" in str((v.get("연결") or {}).get("키") or "") + for v in doc.get("변수") or [] + ) + ) + + +def row_entry(doc: dict, vals) -> dict | None: + """기계 줄 목록(`인력` · `잡품`) 가운데 식 한 줄로 안 풀리는 부분 = 바탕 덮음 · 다 풀림 = None. + 풀림 = 식이 그 줄을 갖고 · 인력 직종 하나 · 잡품 = 식 밑 재료 줄마다 같은 율(키 · 수량 없음) + (식이 `master_machine_crew.view` 로 읽는 조종원 수 · 직종 · 잡재료율 = 같은 금액).""" + if not isinstance(vals, dict) or not is_machine(doc): + return None + parts, lines = parts_of(doc), doc.get("금액") or [] + out: dict = {} + crew = vals.get(mcrew.CREW) + if isinstance(crew, list) and (crew or parts["crew"]): + jobs = {mcrew.code(r.get("키")) for r in crew if isinstance(r, dict)} + if not (parts["crew"] and crew and len(jobs) == 1): + out["조종원"] = crew + misc = vals.get(mcrew.MISC) + if isinstance(misc, list) and misc: + names = sorted(str(lines[i].get("이름") or "") for i in parts["base"]) + plain = ( + parts["misc"] is not None + and all(isinstance(r, dict) and r.get("줄") and not r.get("키") for r in misc) + and all(r.get("수량") is None for r in misc) + and len({_canon(r.get("율")) for r in misc}) == 1 + and sorted(str(r["줄"]) for r in misc) == names + ) + if not plain: + out["잡품"] = misc + return out or None + + +def merge(base: dict | None, top: dict | None) -> dict | None: + """바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만).""" + if not base: + return top or None + if not top: + return base + out = {**base, **{k: v for k, v in top.items() if k != "값"}} + vals = {**(base.get("값") or {}), **(top.get("값") or {})} + return {**out, "값": vals} if vals else out + + +def lists_of(links, given) -> dict: + """셈 연결로 그 기계 줄 목록 읽기 — {인력?, 잡품?} · 못 읽음 = 빈 묶음(요소 `EQ:<기계>` 칸).""" + import master_doc_calc as mc + + key, out = machine_key(given), {} + for col in (mcrew.CREW, mcrew.MISC) if key else (): + try: + out[col] = links.element({"키": f"EQ:{key}", "칸": col}) + except (mc.Gap, mc.Broken): + pass + return out + + # ── 서버 검사 · 정리 ────────────────────────────────────────────────── def _nonneg(v, where: str): if isinstance(v, bool) or not isinstance(v, (int, float, Decimal)) or v < 0: @@ -325,7 +405,7 @@ def clean(raw) -> dict: got[col] = v.strip() if isinstance(v, str) else _nonneg(v, f"「{key}」 {col}") if got: one["값"] = got - for part, need in (("조종원", ("키", "인")), ("잡품", ("율",))): + for part, need in (("조종원", ("인",)), ("잡품", ("율",))): rows = entry.get(part) if rows is None: continue @@ -337,6 +417,8 @@ def clean(raw) -> dict: for k in ("인", "율", "수량"): if r.get(k) is not None: _nonneg(r[k], f"「{key}」 {part} {k}") + if part == "조종원" and not isinstance(r.get("키"), str): # 빈 글 = 식 입력 직종 + raise ValueError(f"{COVER} 「{key}」 조종원 줄 — 키 필요") if part == "잡품" and not (r.get("줄") or r.get("키")): raise ValueError(f"{COVER} 「{key}」 잡품 줄 — 재료(키) 또는 줄 필요") one[part] = rows @@ -360,6 +442,7 @@ def prune_doc(doc: dict, links) -> dict: for (key, given), ans in memo.items(): m = machine_key(dict(given)) sub = links.doc(key) if m in cover and m not in kept else None - if sub and (one := prune(cover[m], defaults_of(sub, ans.get("값") or {}))): + base = row_entry(sub, lists_of(links, dict(given))) if sub else None + if sub and (one := prune(cover[m], defaults_of(sub, ans.get("값") or {}, base))): kept[m] = one return {**rest, COVER: kept} if kept else rest diff --git a/resources/master_data/scripts/master_doc_link.py b/resources/master_data/scripts/master_doc_link.py index 9d569e6a9..8ab4a4064 100644 --- a/resources/master_data/scripts/master_doc_link.py +++ b/resources/master_data/scripts/master_doc_link.py @@ -20,6 +20,7 @@ from pathlib import Path import master_doc as md import master_doc_calc as mc import master_formula as mf +import master_machine_crew as mcrew import master_material as mm import master_pick as mp @@ -53,6 +54,8 @@ def _arith(text: str): def _cell(value, col: str): if value is None: raise mc.Gap(f"칸 「{col}」 값 없음 — 관리자가 채울 값") + if isinstance(value, list) and col in mcrew.LISTS: # 기계 인력 · 잡품 줄(842-3) + return value if isinstance(value, list): raise mc.Broken(f"칸 「{col}」 값이 범위 — 입력으로 받아야 함") if isinstance(value, str): diff --git a/resources/master_data/scripts/master_formula.py b/resources/master_data/scripts/master_formula.py index ddb0cf557..4cd540ecd 100644 --- a/resources/master_data/scripts/master_formula.py +++ b/resources/master_data/scripts/master_formula.py @@ -12,6 +12,7 @@ import re from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal import master_keys as mk +import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3) # 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음 # (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) @@ -312,7 +313,7 @@ class Master: if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠 return row.get("값"), f"추정(준용: {name})" return target.get("값"), f"준용: {name}" - return row.get("값"), None + return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None def logic(self, ref: str) -> dict: if mk.GROUP_OF.get(mk.id_of(ref)) != "로직": diff --git a/resources/master_data/scripts/master_machine_crew.py b/resources/master_data/scripts/master_machine_crew.py index d1c6d1264..210b2c6b8 100644 --- a/resources/master_data/scripts/master_machine_crew.py +++ b/resources/master_data/scripts/master_machine_crew.py @@ -18,6 +18,7 @@ from __future__ import annotations from numbers import Number CREW, MISC = "인력", "잡품" +LISTS = (CREW, MISC) OLD = ("조종원", "조종원직종", "잡재료율") BASE = ("주연료", "전력") # 잡품 줄 기본 = 이 재료 줄(값 > 0) @@ -87,3 +88,59 @@ def summary(vals) -> str: for r in vals.get(MISC) or [] ] return " · ".join([*crew, *(["잡품 " + ", ".join(misc)] if misc else [])]) + + +def from_old_row(row: dict) -> dict: + """옛 꼴 기계 줄 → 새 꼴(값 · 단위 · 출처) — M01 자료 옮김(842-3) · 사본 대조가 같은 규칙. + 단위 = 인력 「인/일」 · 잡품 「%」 · 출처 = 인력 ← 조종원 · 조종원직종 · 잡품 ← 잡재료율.""" + vals = row.get("값") if isinstance(row, dict) else None + if not isinstance(vals, dict) or is_new(vals): + return row + new = from_old(vals) + out = {**row, "값": new} + for part in ("단위", "출처"): + box = row.get(part) + if not isinstance(box, dict): + continue + got = {k: v for k, v in box.items() if k not in OLD} + if CREW in new: + src = " · ".join( + dict.fromkeys(x for x in (box.get("조종원"), box.get("조종원직종")) if x) + ) + got[CREW] = "인/일" if part == "단위" else src + if MISC in new: + got[MISC] = "%" if part == "단위" else (box.get("잡재료율") or "") + out[part] = got + return out + + +def check(vals) -> list[str]: + """목록 칸 틀 — 인력 = [{키 'LB…' | 빈 글, 인 ≥ 0}] · 잡품 = [{줄 주연료 · 전력 | 키, 수량? ≥ 0, 율 ≥ 0}] · + 30 줄까지 · 옛 칸과 같이 = 두 벌(M01 틀 검사 `check_master` · 저장 손질 `M01_MasterData_Machine.fix`).""" + if not isinstance(vals, dict): + return [] + out: list[str] = [] + if any(k in vals for k in LISTS) and any(k in vals for k in OLD): + out.append("인력 · 잡품 목록과 옛 칸(조종원 · 조종원직종 · 잡재료율)이 같이 있음") + for col, need in ((CREW, "인"), (MISC, "율")): + rows = vals.get(col) + if rows is None: + continue + if not isinstance(rows, list) or len(rows) > 30: + out.append(f"{col} — 목록(30 줄까지)") + continue + for n, r in enumerate(rows, 1): + bad = not isinstance(r, dict) or not _isnum(r.get(need)) or r[need] < 0 + if not bad and r.get("수량") is not None: + bad = not _isnum(r["수량"]) or r["수량"] < 0 + if not bad and col == CREW: + bad = not isinstance(r.get("키", ""), str) or not ( + r.get("키", "") == "" or str(r["키"]).startswith("LB") + ) + if not bad and col == MISC: + bad = bool(r.get("줄")) == bool(r.get("키")) or ( + bool(r.get("줄")) and r["줄"] not in BASE + ) + if bad: + out.append(f"{col} {n} 줄 — 꼴 틀림") + return out diff --git a/resources/tester/test_836_1_machine_cover.py b/resources/tester/test_836_1_machine_cover.py index 363f6bf5c..c9e5f9fce 100644 --- a/resources/tester/test_836_1_machine_cover.py +++ b/resources/tester/test_836_1_machine_cover.py @@ -156,7 +156,7 @@ def test_원본과_같으면_지움_안_부르는_기계_지움(links): {NO: 1}, {NO: {"값": {"가격": -1}}}, {NO: {"값": {"조종원": 2}}}, - {NO: {"조종원": [{"키": "", "인": 1}]}}, + {NO: {"조종원": [{"인": 1}]}}, {NO: {"조종원": [{"키": "LB:1048", "인": -1}]}}, {NO: {"잡품": [{"율": 10}]}}, {NO: {"잡품": [{"줄": "주연료", "율": "x"}]}},