Files
Aislo/resources/master_data/scripts/master_doc_cover.py
T
eomsangdonandClaude Opus 5.5 4ef320f2da fix(848-4): 부착 줄 답 꼴 = 주 줄 꼴 + 따름 칸(산출근거 화면이 모르는 꼴로 멈추지 않게) · 낡은 시험 고침
- 부착 줄 작업량 답 = 주 기계 줄 답 꼴 · 율 · 값 · 단위 그대로 + 따름 {기호, 이름, 꼴} · 식들 [] (파이썬 · TS 짝)
- 시험 고침 — test_846_1 부착 줄 = 주 줄 따름 · test_814_1 조합 첫 줄 GC001202 · 둘째 줄 GC000273 ·
  test_masterdata_check 치즐 = 두 줄 합 · test_782_3 GC001147 K입력 · 782-3 몫 키 범위 ·
  test_813_2 기계경비식 17 · 문서 1,521(GC001202) ·
  test_799_1 굴착기 블록 = 고정 금액 대신 엔진 줄 값(노임 갱신으로 낡음 · 848-4 와 무관한 문서 GF000089)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 22:28:07 +09:00

657 lines
30 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.
# -*- coding: utf-8 -*-
"""기계 덮음 (PLAN 836-1 · 요구 846 · 849 · 850 · 853) — 단가산출 안 기계 내부 값 고침.
자리 = 문서 칸 `기계덮음` {기계 입력 글: {값?: {칸: 값}, 조종원?: [{키, 인}], 잡품?: [{줄? | 키?, 이름?, 수량?, 율}]}}
기계 입력 글 = 부름 입력 `기계` 값(따옴표 뗌) — 같은 기계 줄 여럿 = 한 벌 · 원본과 같은 칸 = 없음(`prune`).
셈 규칙(`cover_doc`) = 계산기(`master_doc_calc.calc`)가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 —
덮음 없음 = 문서 그대로(금액 전후 같음).
기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) ·
단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째).
겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`merge` · `merge_layers` — 작업량 = 방식 · 식 · 변수 열쇠 ·
기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `prune_doc` 의 `upper`) · 위 층 값(`upper_of`) · 출처(`sources`).
파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험
`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py` · `test_848_1_cover_layers.py`.
"""
from __future__ import annotations
import copy as cp
import json
import re
from decimal import Decimal
import master_doc as md
import master_doc_work as mw
import master_machine_crew as mcrew
COVER = "기계덮음"
UPPER = "위덮음" # SK `수식` 칸 — ① 위 층 고침(848-1)
HAND = "손고침" # M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1)
MINE, ABOVE = "나", "위" # 출처(`sources`) — 없는 칸 = 정본
NOT_VALUE = (
"조종원",
"조종원직종",
"잡재료율",
) # 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸
HOUR = "Q_시간환산"
_HOUR_VARS = [
{"열쇠": "Q_분자^표", "기호": "Q", "아래": "분자", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분자",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'시간환산'"}, "칸": "분자"}},
{"열쇠": "Q_분모^표", "기호": "Q", "아래": "분모", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분모",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'시간환산'"}, "칸": "분모"}},
{"열쇠": "Q_분자2^표", "기호": "Q", "아래": "분자2", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분자",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'상여계수'"}, "칸": "분자"}},
{"열쇠": "Q_분모2^표", "기호": "Q", "아래": "분모2", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분모",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'상여계수'"}, "칸": "분모"}},
{"열쇠": "Q_분자3^표", "기호": "Q", "아래": "분자3", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분자",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'휴지계수'"}, "칸": "분자"}},
{"열쇠": "Q_분모3^표", "기호": "Q", "아래": "분모3", "위": "표", "이름": "건설기계 조종원 노임 시간 환산 계수.분모",
"단위": "", "연결": {"갈래": "표", "표": "CC000336", "조건": {"구분": "'휴지계수'"}, "칸": "분모"}},
{"열쇠": "시간환산", "기호": "Q", "아래": "시간환산", "위": "", "이름": "시간환산", "단위": "", "연결": {"갈래": "식"}},
] # fmt: skip
_HOUR_LINE = {
"기호": HOUR,
"식": "Q_분자^표 ÷ Q_분모^표 × Q_분자2^표 ÷ Q_분모2^표 × Q_분자3^표 ÷ Q_분모3^표",
}
MAX_ROWS = 30
def _plain(n) -> str:
d = Decimal(str(n)).normalize()
return format(d, "f")
def cover_of(doc) -> dict:
got = doc.get(COVER) if isinstance(doc, dict) else None
return got if isinstance(got, dict) else {}
def machine_key(given) -> str:
"""부름 입력 → 기계 열쇠(따옴표 뗌) · 기계 입력 없음 = ""."""
v = (given or {}).get("기계")
if v is None:
return ""
t = str(v).strip()
return t[1:-1] if len(t) >= 2 and t[0] == "'" and t[-1] == "'" else t
def _names(text) -> list[str]:
if text is None or str(text).strip() == "":
return []
try:
return md.names(md.parse(text))
except md.DocError:
return []
def parts_of(doc: dict) -> dict:
"""기계 식 짜임 — {fields [{칸, ids}], crew [줄 차례], crew_qty {차례: 기호}, misc, rate, base}."""
eq: dict[str, str] = {}
for v in doc.get("변수") or []:
link = v.get("연결") or {}
key = str(link.get("키") or "")
if (
link.get("갈래") == "요소"
and key.startswith("EQ:")
and "{S_기계}" in key
and link.get("칸")
):
eq[md.var_id(v)] = link["칸"]
fields: list[dict] = []
for id_, col in eq.items():
if col in NOT_VALUE:
continue
at = next((f for f in fields if f["칸"] == col), None)
if at:
at["ids"].append(id_)
else:
fields.append({"칸": col, "ids": [id_]})
lines = doc.get("금액") or []
crew, crew_qty, misc, rate = [], {}, None, None
for i, line in enumerate(lines):
q = next((n for n in _names(line.get("수량")) if eq.get(n) == "조종원"), None)
if line.get("비목") == "노무비" and q:
crew.append(i)
crew_qty[i] = q
p = _names(line.get("단가"))
other = [n for n in p if n != "재료비"]
if misc is None and line.get("비목") == "재료비" and "재료비" in p and len(other) == 1:
misc, rate = i, other[0]
base = (
[]
if misc is None
else [
i
for i, x in enumerate(lines)
if i < misc and x.get("비목") == "재료비" and not x.get("합밖")
]
)
return {"fields": fields, "crew": crew, "crew_qty": crew_qty, "misc": misc, "rate": rate, "base": base} # fmt: skip
def _num(v):
if isinstance(v, bool) or not isinstance(v, (int, float, Decimal)):
return None
return v
def _fill_key(text: str, vals: dict) -> str:
def one(m):
v = vals.get(m.group(1))
return _plain(v) if _num(v) is not None else str("" if v is None else v)
return re.sub(r"\{([^{}]+)\}", one, text)
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 []}
values = {}
for f in parts["fields"]:
v = vals.get(f["ids"][0])
if _num(v) is not None or isinstance(v, str):
values[f["칸"]] = v
crew = []
for i in parts["crew"]:
n = _num(vals.get(parts["crew_qty"][i]))
sym = (_names(lines[i].get("단가")) or [""])[0]
key = str(((vars_.get(sym) or {}).get("연결") or {}).get("키") or "")
if n and key:
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}
_LABEL = ("이름", "단위") # 화면 글 — 원본 대조 안 봄
def _canon(v) -> str:
def norm(x):
if isinstance(x, dict):
return {
k: norm(y) for k, y in sorted(x.items()) if y not in (None, "") and k not in _LABEL
}
if isinstance(x, list):
return [norm(y) for y in x]
if _num(x) is not None:
return float(f"{float(x):.12g}")
return x
return json.dumps(norm(v), ensure_ascii=False, sort_keys=True)
def _same(a, b) -> bool:
if _num(a) is not None and _num(b) is not None:
a, b = float(a), float(b)
return abs(a - b) <= 1e-9 * max(1.0, abs(a), abs(b))
return str(a) == str(b)
def prune(entry: dict, base: dict, upper: dict | None = None) -> dict | None:
"""위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None —
`base` = 정본 기본(`defaults_of` · `작업량` = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위)."""
up = upper_of(base, upper)
out: dict = {}
vals = {
k: v
for k, v in (entry.get("값") or {}).items()
if v not in (None, "") and not (k in up["값"] and _same(v, up["값"][k]))
}
if vals:
out["값"] = vals
for part in ("조종원", "잡품"):
if entry.get(part) is not None and _canon(entry[part]) != _canon(up[part]):
out[part] = entry[part]
work = prune_work_layer(entry.get(mw.WORK), base.get(mw.WORK), (upper or {}).get(mw.WORK))
if work: # 846-1 시간당 작업량
out[mw.WORK] = work
return out or None
# ── 층(848-1) ─────────────────────────────────────────────────────────
def _fixed(w: dict) -> dict:
return {k: str(w[k]) for k in mw.FIXED if w.get(k)}
def prune_work_layer(want, base: dict | None = None, upper: dict | None = None) -> dict | None:
"""작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 ·
`base` = 그 식 기본 변수(`mw.defaults`) · 일당 = 방식만 · 남는 것 없음 = None(위 층 없음 = `mw.prune_work` 와 같음)."""
if not isinstance(want, dict):
return None
up = upper if isinstance(upper, dict) else {}
up_way = up.get("방식") or mw.DAILY
way = want.get("방식") or up_way
out: dict = {"방식": way} if way != up_way else {}
if way != mw.HOURLY:
return out or None
up_form = str(up.get("식") or "") if up_way == mw.HOURLY else ""
form = str(want.get("식") or "") or up_form
if form != up_form:
out["식"] = form
held = {**(base or {}), **((up.get("변수") or {}) if form == up_form else {})}
got = {
k: v
for k, v in (want.get("변수") or {}).items()
if v not in (None, "") and not (k in held and mw._same(v, held[k]))
}
if got:
out["변수"] = got
fix, up_fix = _fixed(want), (_fixed(up) if up_way == mw.HOURLY else {})
if fix and (
not up_fix
or [fix.get(k) for k in ("기계", "키")] != [up_fix.get(k) for k in ("기계", "키")]
):
out |= fix
return out or None
def merge_work(top: dict | None, low: dict | None) -> dict | None:
"""작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
식을 바꾼 아래 층 = 위 층 변수 안 물려받음."""
if not isinstance(top, dict) or not top:
return low if isinstance(low, dict) and low else None
if not isinstance(low, dict) or not low:
return top
out = dict(top)
if low.get("방식"):
out["방식"] = low["방식"]
if low.get("식") and str(low["식"]) != str(top.get("식") or ""):
out["식"] = low["식"]
out.pop("변수", None)
if vals := {**(out.get("변수") or {}), **(low.get("변수") or {})}:
out["변수"] = vals
if low.get("기계"):
out = {k: v for k, v in out.items() if k not in mw.FIXED} | _fixed(low)
return out
def merge_layers(upper: dict | None, mine: dict | None) -> dict:
"""① 위 층 고침 위에 ② 내 고침(열쇠마다 `merge`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로."""
if not isinstance(upper, dict) or not upper:
return mine if isinstance(mine, dict) else {}
if not isinstance(mine, dict) or not mine:
return upper
out = {}
for k in [*upper, *(k for k in mine if k not in upper)]:
if got := merge(upper.get(k), mine.get(k)):
out[k] = got
return out
def upper_of(base: dict, upper: dict | None) -> dict:
"""위 층 값 — 정본 기본(`defaults_of`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `mw.defaults`)."""
out = {k: v for k, v in base.items() if k != mw.WORK}
if not upper:
return out
out["값"] = {**(base.get("값") or {}), **(upper.get("값") or {})}
for part in ("조종원", "잡품"):
if upper.get(part) is not None:
out[part] = upper[part]
if upper.get(mw.WORK):
out[mw.WORK] = upper[mw.WORK]
return out
def sources(upper: dict | None, mine: dict | None) -> dict[str, str]:
"""칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 ·
`작업량.방식` · `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계`."""
out: dict[str, str] = {}
up_form = str(((upper or {}).get(mw.WORK) or {}).get("식") or "")
for layer, tag in ((upper, ABOVE), (mine, MINE)):
e = layer if isinstance(layer, dict) else {}
for k in e.get("값") or {}:
out[f"값.{k}"] = tag
for part in ("조종원", "잡품"):
if e.get(part) is not None:
out[part] = tag
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
if (
tag == MINE and w.get("식") and str(w["식"]) != up_form
): # 식을 바꿈 = 위 층 변수 안 물려받음
out = {k: v for k, v in out.items() if not k.startswith("작업량.변수.")}
for k in ("방식", "식", "기계"):
if w.get(k):
out[f"작업량.{k}"] = tag
for k in w.get("변수") or {}:
out[f"작업량.변수.{k}"] = tag
return out
# ── 셈 규칙 ───────────────────────────────────────────────────────────
def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str:
have = {md.var_id(v) for v in doc.get("변수") or []} | {
str(x.get("기호") or "") for x in doc.get("식") or []
}
n = 1
while md.sym_id(sign, f"{low}{n}") in have:
n += 1
under = f"{low}{n}"
id_ = md.sym_id(sign, under)
doc.setdefault("변수", []).append(
{"열쇠": id_, "기호": sign, "아래": under, "위": "", "이름": name, "단위": "",
"연결": {"갈래": "요소", "키": key}}
) # fmt: skip
return id_
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 []
)
if rows and not have:
ids = {md.var_id(v) for v in doc.get("변수") or []}
doc.setdefault("변수", []).extend(
cp.deepcopy(v) for v in _HOUR_VARS if md.var_id(v) not in ids
)
doc.setdefault("식", []).append(dict(_HOUR_LINE))
return [
{"이름": "조종원", **({"규격": r["이름"]} if r.get("이름") else {}), "단위": "인",
"비목": "노무비", "수량": f"{_plain(r['인'])} × {HOUR}",
"단가": _add_var(doc, "w", "조종원", "조종원 노임", r["키"]) if r.get("키") else own}
for r in rows
] # fmt: skip
def _misc_lines(doc: dict, rows: list, lines: list) -> list[dict]:
out = []
for r in rows:
label = r.get("이름") or ""
if r.get("키"):
price = _add_var(doc, "P", "잡품", label or r["키"], r["키"])
qty = _plain(r["수량"] if r.get("수량") is not None else 1)
else:
b = next((x for x in lines if str(x.get("이름") or "") == r.get("줄")), None)
if not b or not b.get("단가"):
continue
price = str(b["단가"])
qty = _plain(r["수량"]) if r.get("수량") is not None else f"({b.get('수량') or 1})"
label = label or str(b.get("이름") or "")
out.append(
{"이름": "잡품", "규격": label, "단위": "", "비목": "재료비",
"수량": f"{qty} × {_plain(r['율'])} ÷ 100", "단가": price}
) # fmt: skip
return out
def cover_doc(doc: dict, given, cover, base: dict | None = None) -> dict:
"""기계 식 문서에 그 기계 덮음을 얹음(새 문서) — `base` = 기계 줄 바탕 덮음(`row_entry`) ·
덮음 없음 = 그대로(같은 물건)."""
key = machine_key(given)
top = {k: v for k, v in ((cover or {}).get(key) or {}).items() if k != mw.WORK} if key else None
entry = merge(base, top or None) # 작업량(846-1) = 부른 쪽 기계 줄 수량 몫 — 식 문서는 그대로
if not entry:
return doc
out = cp.deepcopy(doc)
out.pop("쌓기", None) # 금액 차례가 바뀜 — 기본 차림
parts = parts_of(out)
values = entry.get("값") or {}
for f in parts["fields"]:
if f["칸"] in values:
for v in out.get("변수") or []:
if md.var_id(v) in f["ids"]:
v["연결"] = {"갈래": "숫자", "값": values[f["칸"]]}
lines = out.get("금액") or []
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)
if want is not None and (parts["misc"] is not None or want)
else None
)
gone = set(parts["crew"] if crew is not None else []) | (
{parts["misc"]} if misc is not None and parts["misc"] is not None else set()
)
tail = next((i for i, x in enumerate(lines) if x.get("비목") == "경비"), len(lines))
crew_at = parts["crew"][0] if parts["crew"] else tail
misc_at = parts["misc"] if parts["misc"] is not None else tail
new = []
for i in range(len(lines) + 1):
if crew is not None and i == crew_at:
new += crew
if misc is not None and i == misc_at:
new += misc
if i < len(lines) and i not in gone:
new.append(lines[i])
out["금액"] = new
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 parts["crew"]:
jobs = {mcrew.code(r.get("키")) for r in crew if isinstance(r, dict)}
if not (crew and len(jobs) == 1):
out["조종원"] = crew
misc = vals.get(mcrew.MISC)
if isinstance(misc, list) and misc and parts["misc"] is not None:
names = sorted(str(lines[i].get("이름") or "") for i in parts["base"])
plain = (
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:
"""바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
작업량 = `merge_work`(848-1)."""
if not base:
return top or None
if not top:
return base
out = {**base, **{k: v for k, v in top.items() if k not in ("값", mw.WORK)}}
vals = {**(base.get("값") or {}), **(top.get("값") or {})}
out = {**out, "값": vals} if vals else out
work = merge_work(base.get(mw.WORK), top.get(mw.WORK))
return {**out, mw.WORK: work} if work 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:
raise ValueError(f"{where} — 0 이상 수")
return v
def clean(raw) -> dict:
"""몸 검사 — 틀리면 ValueError(까닭) · 빈 칸 · 빈 기계 = 뺌."""
if raw is None:
return {}
if not isinstance(raw, dict):
raise ValueError(f"{COVER} — 묶음 아님")
out: dict = {}
for key, entry in raw.items():
if not isinstance(entry, dict):
raise ValueError(f"{COVER} 「{key}」 — 묶음 아님")
one: dict = {}
values = entry.get("값")
if values is not None:
if not isinstance(values, dict):
raise ValueError(f"{COVER} 「{key}」 값 — 묶음 아님")
got = {}
for col, v in values.items():
if v in (None, ""):
continue
if col in NOT_VALUE:
raise ValueError(f"{COVER} 「{key}」 값 「{col}」 — 줄로 고침")
got[col] = v.strip() if isinstance(v, str) else _nonneg(v, f"「{key}」 {col}")
if got:
one["값"] = got
for part, need in (("조종원", ("인",)), ("잡품", ("율",))):
rows = entry.get(part)
if rows is None:
continue
if not isinstance(rows, list) or len(rows) > MAX_ROWS:
raise ValueError(f"{COVER} 「{key}」 {part} — 목록({MAX_ROWS} 줄까지)")
for r in rows:
if not isinstance(r, dict) or any(r.get(k) in (None, "") for k in need):
raise ValueError(f"{COVER} 「{key}」 {part} 줄 — {' · '.join(need)} 필요")
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
w = entry.get(mw.WORK)
if isinstance(w, dict) and not w.get("방식"): # 848-1 바꾼 칸만 담은 층(방식 = 위 층)
got = mw.clean_work({**w, "방식": mw.DAILY}, f"{COVER} 「{key}」")
got.pop("방식")
if got:
one[mw.WORK] = got
elif w is not None:
one[mw.WORK] = mw.clean_work(w, f"{COVER} 「{key}」")
if one:
out[str(key)] = one
return out
def _quoted(text) -> set[str]:
return set(re.findall(r"'([^']*)'", str(text or "")))
def listed(doc: dict) -> set[str]:
"""문서 안 덮음 열쇠 후보(848-1) — 선택 목록 · 입력 값 · 따옴표 글(식 · 부름 입력 · 금액) · 변수 기호."""
out: set[str] = set()
for v in doc.get("변수") or []:
out.add(md.var_id(v))
link = v.get("연결") or {}
out |= {str(x) for x in link.get("목록") or []}
if isinstance(link.get("값"), str):
out.add(link["값"])
for x in (link.get("입력") or {}).values():
out |= _quoted(x)
for x in doc.get("식") or []:
out |= _quoted(x.get("식"))
for x in doc.get("금액") or []:
out |= _quoted(x.get("수량")) | _quoted(x.get("단가"))
return out
def prune_doc(doc: dict, links, upper: dict | None = None) -> dict:
"""서버 정리 — 덮음을 검사하고 위 층과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로).
정본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답 · 작업량 · 굳은 기계는 얹고 셈) ·
`upper` = ① 위 층 고침(SK `수식.위덮음` · 848-1) · 이번 셈이 안 부른 열쇠 = 문서 안에 들면(`listed`) 그대로 남김."""
import master_doc_calc as mc
cover = clean(doc.get(COVER))
rest = {k: v for k, v in doc.items() if k != COVER}
if not cover:
return rest
upper = upper if isinstance(upper, dict) else {}
both = merge_layers(upper, cover)
steer = {k: {mw.WORK: e[mw.WORK]} for k, e in both.items() if (e or {}).get(mw.WORK)}
memo: dict = {}
top = mc.calc(rest, links, None, (), memo, steer)
kept: dict = {}
seen: set[str] = set() # 값 · 조종원 · 잡품을 견준 열쇠
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 not sub or not is_machine(sub):
continue
seen.add(m)
base = defaults_of(sub, ans.get("값") or {}, row_entry(sub, lists_of(links, dict(given))))
if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base, upper.get(m)):
kept[m] = one
works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도
for a in (top, *memo.values()):
for x in a.get("줄") or []:
if (w := x.get(mw.WORK)) and not w.get(mw.FOLLOW): # 848-4 부착 줄 = 주 줄 따름
works.setdefault(w["기계"], w["기계"])
if w.get("기호"):
works.setdefault(w["기호"], w["기계"])
for m in sorted(set(works) & set(cover)):
if not (want := cover[m].get(mw.WORK)):
continue
seen.add(f"{m}\n{mw.WORK}")
up = (upper.get(m) or {}).get(mw.WORK) or {}
eff = merge_work(up, want) or {}
if eff.get("방식") == mw.HOURLY and not eff.get("식"):
raise ValueError(f"{COVER} 「{m}」 작업량 — 시간당은 식 키 필요")
base = _work_base(links, eff.get("기계") or works[m], eff)
if one := prune_work_layer(want, base, up):
kept[m] = {**kept.get(m, {}), mw.WORK: one}
names = listed(rest) | {
str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계")
}
follow = { # 848-4 부착 줄 단가 기호 — 작업량 고침이 안 걸림(지움)
n for x in rest.get("금액") or [] if x.get(mw.ATTACH) for n in _names(x.get("단가"))
}
for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로
if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}):
kept[m] = {**vals, **kept.get(m, {})}
if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK) and m not in follow:
kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]}
return {**rest, COVER: kept} if kept else rest
def _work_base(links, machine: str, want: dict) -> dict:
"""시간당 작업량 덮음 기본 변수(식 문서 기본 › 기계 변수) · 기계에 그 식 없음 = ValueError(거절)."""
import master_doc_calc as mc
if want.get("방식") != mw.HOURLY:
return {}
try:
specs = mw.specs_of(links.element({"키": f"EQ:{machine}", "칸": mw.WORK}))
except (mc.Gap, mc.Broken):
specs = []
spec = next((s for s in specs if s["식"] == want.get("식")), None)
if spec is None:
what = f"작업량 식 「{want.get('식')}」 없음" if specs else "작업량 식 없는 기계"
raise ValueError(f"{COVER} 「{machine}」 시간당 — {what}")
return mw.defaults(links.doc(spec["식"]), spec)