feat(842-3): 기계 시간당 셈 한 길 — 식 문서 계산기 + 기계 줄 인력 · 잡품 목록 바탕 덮음
- 읽기 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 <noreply@anthropic.com>
This commit is contained in:
@@ -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}
|
||||
|
||||
@@ -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", {})
|
||||
|
||||
@@ -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", {})
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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 · 내 기계 줄 값 복사(품셈 비율 있으면 품셈 · 없으면 바로)."""
|
||||
|
||||
@@ -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 += [
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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<MachineCover> {
|
||||
/** 원본(단가산출 덮음 없음) 기본값 — 셈 답 값(`vals` = 그 기계로 셈한 원본 답 `값`) ·
|
||||
* `base` = 기계 줄 바탕 덮음(`rowEntry`) — 있는 부분은 그 목록(빈 직종 키 = 식이 고른 직종) */
|
||||
export function defaultsOf(
|
||||
doc: FormulaDoc,
|
||||
vals: Vals,
|
||||
base?: MachineCover | null,
|
||||
): Required<MachineCover> {
|
||||
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<MachineCover>
|
||||
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<string, unknown> | 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<string, unknown> | 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;
|
||||
}
|
||||
|
||||
@@ -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<string, unknown>;
|
||||
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(" · ");
|
||||
}
|
||||
@@ -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["값"]):
|
||||
|
||||
@@ -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
|
||||
)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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)) != "로직":
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"}]}},
|
||||
|
||||
Reference in New Issue
Block a user