Files
Aislo/M02_MasterTemplete/M02_Machine_Hourly.py
T
eomsangdonandClaude Opus 5.5 8b7d4195f7 refactor(855-E L2ⓑ-2): 기계 시간당 식 고름 · 까닭 · 조합이 로직 줄 대신 수식 문서를 읽음
- 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 <noreply@anthropic.com>
2026-11-18 07:52:21 +09:00

301 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""M02 기계(M01 EQ) 한 시간 값 — [항목 추가] 창에서 기계를 고르면 고정 줄 단가(PLAN 736-3).
기계 줄 = 일위대가 · 단가산출 더한줄의 고정 줄(이음 기계 EQ · 수량 1) — 단가 = 이 값(노 · 재 · 경).
셈 = M01 「건설기계」 장 기계경비 로직 가운데 그 기종을 받는 짝 차례 첫째
(`로직(GC, 기계='원문번호')` · 옵션은 기본값). 짝 차례 · 셈은
`DataFlow/M02_DF_Values._machine_hourly`(894 에서 걷음)와 같았던 규칙.
마스터 파일은 읽기만 · 로그인 사용자 모두.
기계표 = M01 + 지금 층 내 기계(821-1 · `M02_MyMachine` — 식은 채운 칸으로 고른 같은 GC 식 · 직접 = 그 값) ·
층을 모르는 길(`/api/m02/logic-lib/machine-hourly`)은 M01 만.
셈 한 길(842-3) = 식 문서 계산기(`master_doc_calc` · 기계 줄 인력 · 잡품 목록을 바탕 덮음으로 얹음 —
`master_doc_cover.row_entry`) · 식 문서 없는 식 = 못 셈 + 까닭(855 2-B2 · 옛 엔진 폴백 걷음) · 조종원 유무 = 인력 줄(`master_machine_crew.view`).
식 고름 한 곳(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
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
_PLAIN = {
"기계",
"지역",
"보정작업",
"조종원직종",
"전력 계약종별",
} # 이 밖의 입력 = 부착 장비 전용
_TEXT = {"주연료종류", "조종원직종"} # 글 칸 — 나머지 기계 줄 값 칸은 수
_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 [
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))
]
def _family() -> list[dict]:
"""기계 시간당 경비 로직 — 부착 조합 식(848-4 · 부품 `조합` · 조합 묶음 주 기계 줄 전용)은 뺌."""
return [r for r in _rows() if not (r.get("부품") or {}).get("조합")]
def _codes(row: dict) -> list:
return next(i["고르기"] for i in li.specs(row) if i["이름"] == "기계")
def _rank(row: dict) -> tuple:
"""부착 전용 · 손료만 · 보정 · 기종 수 · 키 — 작을수록 먼저."""
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("키")))
def _operated(code: str) -> bool:
"""기계표(원문 8-4) 조종원 > 0 — 그 원문번호 기계 가운데 하나라도."""
rows = mym.whole().index.get("EQ", {}).values()
return any(
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` 과 같음(그 원문번호 기계 줄로)."""
index = mym.whole()
row = (index.numbers.get("EQ") or {}).get(code) or {"원문번호": code}
return pick(row)
def listed(code: str) -> bool:
"""원문번호가 어느 기계경비식 「기계」 목록에 있는지(M01 [새 기계] 식 등록 · 상세 「쓰는 계산식」)."""
return bool(code) and any(code in [str(c) for c in _codes(r)] for r in _family())
def pick(row: dict) -> dict | None:
"""기계 줄 → 시간당 경비 식 — ㉠ 목록 ㉡ 그 기계만의 식 ㉢ 꼴 · 못 고름 = None(까닭 = `why`)."""
code = str(row.get("원문번호") or "")
fit = [r for r in _family() if code and code in [str(c) for c in _codes(r)]]
if not fit:
if got := _own(code):
return got
key = None if _day_loss(row) else mym.logic_key(row)
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 [] if "수량" in x)
rank = _rank(row)
return (*rank[:3], op and not has, *rank[3:])
return min(fit, key=order)
def _own(code: str) -> dict | None:
"""그 기계만의 시간당 경비 식(816-1 · 4륜구동 1톤 덤프트럭 = GF000145 · 816-3 체인톱 = GF000337) —
「기계」 입력 없는 기계경비식 문서가 그 원문번호 기계 줄 값(요소 연결 `EQ…` 칸)을 읽으면 그 식."""
rows = mym.whole().index.get("EQ", {}).values()
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
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
def _day_loss(row: dict) -> str:
"""손료계수 단위가 시간당(10⁻⁷)이 아님(산림품셈 「1일 1대당」) — 그 단위 글 · 아니면 빈 글."""
unit = str((row.get("단위") or {}).get("손료계수") or HOUR_UNIT)
return "" if unit == HOUR_UNIT or "손료계수" not in (row.get("값") or {}) else unit
def _is_num(v: Any) -> bool:
try:
float(v)
except (TypeError, ValueError):
return False
return not isinstance(v, bool)
def why(row: dict, logic: dict | None) -> str:
"""시간당 경비를 못 내는 까닭 한 줄(값이 정말 모자람) · 셀 수 있으면 빈 글."""
vals = _vals(row)
if logic is None:
if unit := _day_loss(row):
return f"손료계수 단위 「{unit}」 — 시간당 식 없음(일 단위 손료)"
if not _is_num(vals.get("주연료")) and vals.get("주연료") not in (None, ""):
return f"주연료 「{vals['주연료']}」 — 수 아님"
if float(vals.get("조종원") or 0) > 0 and not vals.get("조종원직종"):
return "조종원직종 없음"
return "손료 계수 셋(상각 · 정비 · 관리) 없음"
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(fields):
v = vals.get(name)
if v in (None, ""):
lost.append(name)
elif name not in _TEXT and not _is_num(v):
odd.append(f"{name} 「{v}」 — {'범위' if '∼' in str(v) else '수 아님'}")
elif name == "주연료종류" and f"{v}:전국평균" not in (mym.whole().numbers.get("MO") or {}):
odd.append(f"주연료종류 「{v}」 — 유가 표에 없음")
return " · ".join([*([f"{' · '.join(lost)} 없음"] if lost else []), *odd])
def takes_machine(logic: dict) -> bool:
"""식이 「기계」 입력(원문번호 고르기)을 받는지 — 안 받는 식(GF000145)엔 기계='…' 를 안 넘김."""
return any(i["이름"] == "기계" for i in li.specs(_doc(logic)))
def hourly(key: str) -> dict[str, Any]:
"""`{ok, 이름, 규격, 로직, 원문번호, 노무비, 재료비, 경비, 계}` · 못 셈 = `{ok: False, reason}`."""
if not key.startswith("EQ"):
return {"ok": False, "reason": f"「{key}」 는 기계 아님"}
try:
row = (whole := mym.whole()).get(key)
except cm.mf.FormulaError as e:
return {"ok": False, "reason": str(e)}
if mym.mine(key):
return mym.hourly(row, whole)
code = str(row.get("원문번호") or "")
logic = pick(row)
if lack := why(row, logic):
return {"ok": False, "reason": lack, **({"로직": logic["키"]} if logic else {})}
got = hour(row, logic, whole) # 804-3 줄 쌓기 기계 줄 = 이 로직 + 기계='원문번호'
if not got["ok"]:
return got
return {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), "원문번호": code, **got}
def hour(row: dict, logic: dict, index: Any) -> dict[str, Any]:
"""시간당 한 몸(`hourly` · `brief` · `M02_MyMachine.hourly`) — {ok, 로직, 노무비 · 재료비 · 경비 · 계} |
{ok False, reason, 로직}."""
got = doc_sums(row, logic, index)
return {"ok": True, "로직": logic["키"], **got["합"]} if got["ok"] else got
def doc_sums(row: dict, logic: dict, index: Any) -> dict | None:
"""셈 한 길(842-3) — 식 문서 계산기 + 기계 줄 목록(바탕 덮음) · 입력 = 식 기본값 ·
{ok, 합 {노무비 · 재료비 · 경비 · 계}} | {ok False, reason, 로직} · 식 문서 없음 = 못 셈(855 2-B2)."""
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: # 854-2 이후 수식 문서 없는 로직 0 — 옛 엔진 폴백 없음
return {
"ok": False,
"reason": f"식 문서 없음 — 「{logic.get('키')}」",
"로직": logic.get("키"),
}
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, "계")}}
#: {키: (색인, 줄)} — 색인이 바뀌면 비움 · 꺼낼 때 `is` 확인(옛 색인 주소 재사용 · 옛 값 막음 · 854-1)
_BRIEF: dict[str, tuple[Any, dict]] = {}
_BRIEF_OF: list[Any] = [None]
def brief(keys: list[str]) -> list[dict[str, Any]]:
"""기계 창 목록 · 양식(827-1) — M01 기계 줄 값 + 시간당(`hourly` 와 같은 식 · 입력 기본값 ·
마스터를 다시 읽지 않고 색인 위에서 셈 · 색인마다 메모) · 키 · 원문번호로 찾음 · 없는 키 = 뺌."""
from M02_MasterTemplete.M02_Item_Prices import to_json
index, mf = store.loaded()[1], cm.mf
# ponytail: 통째 비움 · 기계 수(655)의 세 배
if _BRIEF_OF[0] is not index or len(_BRIEF) > 2000:
_BRIEF.clear()
_BRIEF_OF[0] = index
out = []
for key in keys[:60]:
hit = _BRIEF.get(key)
got = hit[1] if hit and hit[0] is index else None
if got is None:
try:
row = (index.numbers.get("EQ") or {}).get(key) or index.get(key)
except mf.FormulaError:
continue
if not str(row.get("키")).startswith("EQ"):
continue
logic = pick(row)
head = {k: row.get(k) for k in ("키", "원문번호", "이름", "규격")}
lack = why(row, logic)
hours = {"ok": False, "reason": lack} if lack else hour(row, logic, index)
got = {**head, "값": to_json(row.get("값")), "시간당": hours}
_BRIEF[key] = (index, got)
out.append(got)
return out
def combo(main: str, part: str) -> tuple[str, str] | None:
"""조합 기계(굴착기 + 대형 브레이커 · 부착용 집게 · 814-1 · 848-4) 첫 줄 → 부착 조합 굴착기 식
(키, 부름 글) `로직(GC001202, 기계='…', 지역='전국평균', …)`(잡재료 16 % · 8-4 주⑤) — 두 기계가 옛 조합 식
(GC000270 · 271) 고르기에 있을 때만 · 부착 기계 줄은 제 시간당(손료만)."""
try:
codes = [str(store.loaded()[1].get(k).get("원문번호") or "") for k in (main, part)]
except cm.mf.FormulaError:
return None
rows = _rows()
fits = any(
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]["고르기"]]
for r in rows
)
row = next(
(
r
for r in rows
if (r.get("부품") or {}).get("조합") and codes[0] in [str(c) for c in _codes(r)]
),
None,
)
if not fits or row is None:
return None
given = {"기계": codes[0]} | {
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})"