Files
Aislo/resources/master_data/scripts/master_doc_work.py
T

476 lines
20 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 846-1 · 요구 881 · 882 · 883) — 기계 줄 수량을 「1 ÷ 시간당 작업량」 으로 읽고
단가산출 덮음으로 그 기계의 작업량 식(시간당 방식)으로 바꿔 셈.
읽기(`sites`) — 기계 줄 수량 식의 시간당 작업량 자리(저장 식 글은 안 바꿈 · 만약 갈래 안도 찾음):
일당 = 곱 · 나눔 줄에 8 과 나눔 하나(시공량 D) → 시간당 작업량 = D ÷ (8 × 대수)
(대수 = 곱의 다른 변수 — 단위 % · `r_` 율은 곱에 남김)
식 = 나눔으로만 쓰는 변수 · 단위 「…/hr」(작업량 식 부품 · 표 값)
기계 값 칸 `작업량` = [{식: 작업량 틀 키, 단위, 변수: {기계 규격에서 정해지는 칸}}](빌더 `build_machine_work.py`).
덮음 = `기계덮음` 기계 칸 `작업량: {방식: '시간당', 식?, 변수?}` — 그 기계 줄의 작업량 자리를 `1 ÷ Q` 로 바꿈
(Q = 덮음 식 › 단위 맞는 첫 식을 식 문서 기본 › 기계 변수 › 덮음 변수로 셈) · 다른 곱(율 등) 그대로 ·
기계에 작업량 칸 없음 · 단위 맞는 식 없음 · Q 못 셈 = 그 줄 멈춤(까닭).
굳은 기계(847-1 · 요구 885) = 덮음 `기계`(시간당으로 바꿀 때 그 줄 기계 · 기계 창으로 바꾼 기계) — 그 줄 단가를
그 기계(`키` = 기계 식 문서가 다를 때)로 다시 부르고 작업량 식 · 변수도 그 기계 것 · `이름` = 화면 이름만 ·
부착 기계 줄 = 굳힘 없음 · 덮음 열쇠 = 그 줄 단가 기호 › 기계 열쇠(846-1 옛 꼴).
부착 줄(848-4 · 금액 줄 칸 `부착: true`) = 같은 묶음 앞쪽 주 기계 줄의 수량을 그대로 씀(품셈 일당 · 시간당 식
모두 · 그 줄 작업량 덮음은 안 읽음) · 답 칸 꼴 「따름」 + `따름` {기호, 이름, 꼴}.
셈 답 기계 줄 칸 `작업량` = {기계, 꼴(일당 · 식 · 시간당), 율, 값, 단위, 식들, 변수?, 까닭?}(산출근거 자료).
파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_work.ts` · 거울 시험
`resources/tester/test_846_1_machine_work.py`.
"""
from __future__ import annotations
import re
from decimal import Decimal
import master_doc as md
WORK = "작업량"
FIXED = ("기계", "키", "이름") # 847-1 굳은 기계 · 기계 식 문서 · 화면 이름
ATTACH, FOLLOW = "부착", "따름" # 848-4 금액 줄 칸 · 부착 줄 답 꼴
HOURLY, DAILY = "시간당", "일당"
Q_NEW = "Q_시간당작업량" # 셈 범위 이름(문서 기호 아님)
EIGHT = Decimal(8)
def norm_unit(u) -> str:
t = re.sub(r"[mM]3", "㎥", re.sub(r"[mM]2", "㎡", str(u or "").strip())) # 848-6 대문자 꼴
t = re.sub(r"(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])", lambda m: m.group(1).lower(), t)
return re.sub(r"/(시간|h|Hr|HR)$", "/hr", t)
def _var(doc: dict, name: str) -> dict:
return next((v for v in doc.get("변수") or [] if md.var_id(v) == name), {})
def _per_hour(doc: dict) -> str:
"""문서 결과 단위(원/X · 원/100㎡) → X/hr · 모름 = ""."""
t = str(doc.get("결과단위") or "")
low = re.sub(r"^[\d.,]+", "", t.split("/", 1)[1]).strip() if "/" in t else ""
return f"{norm_unit(low)}/hr" if low else ""
def unit_of(doc: dict, name: str, depth: int = 0) -> str:
"""변수 단위 — 빈 칸이면 정의 식에서 짐작(…/hr 변수를 씀 · 3600 이 든 식 = 문서 결과 단위/hr)."""
u = norm_unit(_var(doc, name).get("단위"))
line = next((x for x in doc.get("식") or [] if x.get("기호") == name), None)
if u or depth > 3 or line is None:
return u
node = _parse(line.get("식"))
if node is None:
return ""
for n in md.names(node):
if (got := unit_of(doc, n, depth + 1)).endswith("/hr"):
return got
return _per_hour(doc) if any(x[0] == "num" and x[1] == 3600 for x in md.walk(node)) else ""
def _held(doc: dict, name: str) -> bool:
"""곱에 남기는 변수(율) — 대수가 아님."""
return name.startswith("r_") or unit_of(doc, name) == "%"
# ── 식 나무 ───────────────────────────────────────────────────────────
def _chain(node) -> bool:
return node[0] == "bin" and node[1] in ("*", "/")
def _factors(node, sign: int = 1, out: list | None = None) -> list:
out = [] if out is None else out
if _chain(node):
_factors(node[2], sign, out)
_factors(node[3], sign if node[1] == "*" else -sign, out)
else:
out.append((sign, node))
return out
def _build(fs: list):
"""(부호, 노드) 목록 → 곱 · 나눔 나무(차례 그대로 · 곱 먼저)."""
tops = [n for s, n in fs if s > 0] or [("num", Decimal(1))]
node = tops[0]
for n in tops[1:]:
node = ("bin", "*", node, n)
for s, n in fs:
if s < 0:
node = ("bin", "/", node, n)
return node
def _kids(node) -> list:
if node[0] == "call":
return list(node[2])
return [x for x in node[1:] if isinstance(x, tuple)]
def _uses(node, sign: int, out: dict) -> None:
"""변수 쓰임 — {이름: [나눔으로만?]} (곱 · 나눔 줄 잎 = 부호 · 그 밖 = 0)."""
if _chain(node):
for s, n in _factors(node):
if n[0] == "var":
out.setdefault(n[1], []).append(s * sign)
else:
_uses(n, 0, out)
return
if node[0] == "var":
out.setdefault(node[1], []).append(0)
return
for k in _kids(node):
_uses(k, 0, out)
def _rates(doc: dict, node) -> set:
uses: dict = {}
_uses(node, 1, uses)
return {
n
for n, signs in uses.items()
if all(s < 0 for s in signs) and unit_of(doc, n).endswith("/hr")
}
def _daily(doc: dict, node, rates: set):
"""곱 · 나눔 줄 하나 → 일당 자리 | None."""
fs = _factors(node)
eight = [i for i, (s, n) in enumerate(fs) if s > 0 and n[0] == "num" and n[1] == EIGHT]
den = [
i for i, (s, n) in enumerate(fs) if s < 0 and n[0] != "num"
] # 수 나눔(÷ 100) = 곱에 남김
if not eight or len(den) != 1 or (fs[den[0]][1][0] == "var" and fs[den[0]][1][1] in rates):
return None
crew = [i for i, (s, n) in enumerate(fs) if s > 0 and n[0] == "var" and not _held(doc, n[1])]
d = fs[den[0]][1]
per = ("num", EIGHT)
for i in crew:
per = ("bin", "*", per, fs[i][1])
rate = ("bin", "/", d, per)
names = md.names(d)
u = re.sub(r"/일$", "", unit_of(doc, names[0])) if len(names) == 1 else "" # ㎥/일 → ㎥(847-2)
unit = f"{u}/hr" if u else _per_hour(doc) # 시공량 단위 없음 = 문서 결과 단위
return {"꼴": DAILY, "노드": rate, "단위": unit, "뺌": {eight[0], den[0], *crew}}
def _find(doc: dict, node, rates: set, test, out: list) -> None:
if node[0] == "call" and node[1] == "만약" and test is not None and len(node[2]) == 3:
t = test(node[2][0])
if t is not None:
_find(doc, node[2][1] if t else node[2][2], rates, test, out)
return
if _chain(node):
site = _daily(doc, node, rates)
if site:
out.append(site)
return
for s, n in _factors(node):
if s < 0 and n[0] == "var" and n[1] in rates:
out.append({"꼴": "식", "노드": n, "단위": unit_of(doc, n[1])})
elif n[0] != "var":
_find(doc, n, rates, test, out)
return
for k in _kids(node):
_find(doc, k, rates, test, out)
def _parse(text):
try:
return md.parse("1" if text in (None, "") else text)
except md.DocError:
return None
def sites(doc: dict, text, test=None) -> list[dict]:
"""수량 글 → 시간당 작업량 자리 [{꼴, 노드, 율(글), 단위}] · test(조건 노드) → 참 · 거짓 · None(두 갈래 다)."""
node = _parse(text)
if node is None:
return []
out: list = []
_find(doc, node, _rates(doc, node), test, out)
for s in out:
s["율"] = md.text_of(s["노드"])
return out
def _swap(doc: dict, node, rates: set):
if _chain(node):
site = _daily(doc, node, rates)
fs = _factors(node)
if site:
keep = [f for i, f in enumerate(fs) if i not in site["뺌"]]
return _build([*keep, (-1, ("var", Q_NEW))])
if any(s < 0 and n[0] == "var" and n[1] in rates for s, n in fs):
return _build(
[
(s, ("var", Q_NEW) if s < 0 and n[0] == "var" and n[1] in rates else n)
for s, n in fs
] # fmt: skip
)
kids = [(s, n if n[0] == "var" else _swap(doc, n, rates)) for s, n in fs]
return node if all(a[1] is b[1] for a, b in zip(fs, kids)) else _build(kids)
kids = [_swap(doc, k, rates) for k in _kids(node)]
if all(a is b for a, b in zip(_kids(node), kids)):
return node # 자리 없음 = 그대로(글 차례 안 바뀜)
if node[0] == "call":
return ("call", node[1], kids)
if node[0] == "field":
return ("field", kids[0], node[2])
return (node[0], *node[1:2], *kids) if node[0] == "bin" else (node[0], kids[0])
def swap(doc: dict, text) -> str:
"""수량 글의 작업량 자리(모든 갈래)를 `1 ÷ Q_NEW` 로 바꾼 글."""
node = _parse(text)
return md.text_of(_swap(doc, node, _rates(doc, node))) if node is not None else str(text)
# ── 기계 작업량 · 덮음 ──────────────────────────────────────────────────
def specs_of(got) -> list[dict]:
"""기계 값 칸 `작업량` → [{식, 단위, 변수}] (꼴 틀림 = 뺌)."""
return [
x
for x in (got if isinstance(got, list) else [])
if isinstance(x, dict) and isinstance(x.get("식"), str) and x["식"]
]
def fits(specs: list[dict], unit: str) -> list[str]:
"""시간당 작업량 단위에 맞는 식 키(단위 모름 = 전부)."""
return [s["식"] for s in specs if not unit or norm_unit(s.get("단위")) == unit]
def defaults(tpl: dict | None, spec: dict | None) -> dict:
"""식 문서 입력 · 선택 기본 › 기계 변수."""
out = {}
for v in (tpl or {}).get("변수") or []:
link = v.get("연결") or {}
if link.get("갈래") in ("입력", "선택", "숫자") and v.get("열쇠"):
out[str(v["열쇠"])] = link.get("값")
return {**out, **((spec or {}).get("변수") or {})}
def _same(a, b) -> bool:
try:
return abs(Decimal(str(a)) - Decimal(str(b))) <= Decimal("1e-9") * max(
Decimal(1), abs(Decimal(str(a)))
)
except Exception:
return str(a) == str(b)
def prune_work(want, base: dict | None = None) -> dict | None:
"""작업량 덮음 정리 — 방식 시간당만 · 기본(`defaults`)과 같은 변수 뺌 · 남는 것 없음 = None."""
if not isinstance(want, dict) or want.get("방식") != HOURLY:
return None
base = base or {}
got = {
k: v
for k, v in (want.get("변수") or {}).items()
if v not in (None, "") and not (k in base and _same(v, base[k]))
}
out: dict = {"방식": HOURLY}
if want.get("식"):
out["식"] = str(want["식"])
if got:
out["변수"] = got
out |= {k: str(want[k]) for k in FIXED if want.get(k)}
return out
def clean_work(want, where: str) -> dict:
"""몸 검사 — 틀리면 ValueError."""
if not isinstance(want, dict) or want.get("방식") not in (DAILY, HOURLY):
raise ValueError(f"{where} 작업량 — 방식 일당 · 시간당")
out: dict = {"방식": want["방식"]}
if want.get("식") not in (None, ""):
if not isinstance(want["식"], str):
raise ValueError(f"{where} 작업량 식 — 글")
out["식"] = want["식"]
elif want["방식"] == HOURLY: # 사본 부름 묶음(`cover_calls`)에 그 식을 담으려면 필요
raise ValueError(f"{where} 작업량 — 시간당은 식 키 필요")
vals = want.get("변수")
if vals is not None:
if not isinstance(vals, dict) or any(
isinstance(v, (dict, list, bool)) for v in vals.values()
):
raise ValueError(f"{where} 작업량 변수 — {{열쇠: 수 · 글}}")
out["변수"] = {str(k): v for k, v in vals.items() if v not in (None, "")}
for k in FIXED: # 847-1 굳은 기계
if want.get(k) not in (None, ""):
if not isinstance(want[k], str):
raise ValueError(f"{where} 작업량 {k} — 글")
out[k] = want[k]
return out
def cover_calls(doc: dict) -> list[str]:
"""문서 `기계덮음` 의 시간당 작업량 식 키 · 굳은 기계 식 문서 키(847-1) — 사본 부름 닫힌 묶음에 더함
(`M02_Doc_Copy.calls`)."""
got = doc.get("기계덮음") if isinstance(doc, dict) else None
return [
str(w[k])
for e in (got.values() if isinstance(got, dict) else [])
if isinstance(e, dict)
and isinstance(w := e.get(WORK), dict)
and w.get("방식") == HOURLY
and w.get("식")
for k in ("식", "키")
if w.get(k)
]
# ── 셈(계산기 `_money` 가 기계 줄마다 부름) ─────────────────────────────
NOT_MACHINE = ("지역", "보정작업", "조종원직종", "계약종별") # 기계 식 입력 가운데 기계 아닌 것
def _machine_of(run, line: dict):
"""금액 줄 단가가 부르는 기계 식 변수 → (작업 기계 입력 식, 변수 이름, 본 기계 칸인지) · 기계 줄 아님 = None ·
부착 기계(브레이커 · 집게 입력) 줄 = 그 부착 기계(일하는 기계 — 굴착기 줄과 따로)."""
node = _parse(line.get("단가"))
for name in md.names(node) if node is not None else []:
link = (run.vars.get(name) or {}).get("연결") or {}
given = link.get("입력") or {}
if link.get("갈래") == "단가산출" and "기계" in given:
tool = [v for k, v in given.items() if k != "기계" and k not in NOT_MACHINE]
return str(tool[-1] if tool else given["기계"]), name, not tool
return None
def work_key(cover, machine: str, sym: str | None) -> str:
"""그 줄 작업량 덮음 열쇠 — 단가 기호 › 기계 열쇠(옛 꼴) 가운데 덮음이 있는 것 · 없으면 단가 기호."""
has = lambda k: bool(k) and isinstance((cover or {}).get(k), dict) and bool(cover[k].get(WORK)) # noqa: E731
return sym if has(sym) else machine if has(machine) else (sym or machine)
def fixed_var(var: dict, want: dict) -> dict:
"""굳은 기계로 단가 기호 연결을 바꾼 변수(기계 입력 = 그 기계 · 기계 식 문서 = `키` 있으면 그것)."""
link = var.get("연결") or {}
return {
**var,
"연결": {**link, "입력": {**(link.get("입력") or {}), "기계": f"'{want['기계']}'"},
**({"키": want["키"]} if want.get("키") else {})},
} # fmt: skip
def host_of(run, line: dict) -> dict | None:
"""부착 줄 → 같은 묶음 앞쪽 주 기계 줄(부착 아님 · 기계 줄) · 아님 = None."""
if not line.get(ATTACH):
return None
lines = run.doc.get("금액") or []
at = next((i for i, x in enumerate(lines) if x is line), None)
for x in reversed(lines[:at] if at is not None else []):
if not x.get(ATTACH) and x.get("묶음") == line.get("묶음") and _machine_of(run, x):
return x
return None
def _follow(run, line: dict, host: dict, scope: dict, key: str, sym: str):
"""부착 줄 = 주 기계 줄 수량 그대로 · 답 칸 꼴 「따름」(주 기계 줄 작업량 답이 있을 때)."""
import master_doc_calc as mc
n, seen = len(run.marks), set(run.values)
try:
swapped, more, info = line_work(run, host, scope)
finally: # 주 기계 줄 셈의 흔적 = 그 줄이 냄
del run.marks[n:]
for k in set(run.values) - seen:
del run.values[k]
where = str(line.get("이름") or "")
if isinstance(swapped, mc.Stop):
swapped = mc.Stop(f"{where} 주 기계 줄을 따름 — {swapped.why}", "시간당 거절", where)
text = host.get("수량") if swapped is None else swapped
mine = None
if info:
mine = {"기계": key, "기호": sym, "꼴": FOLLOW, "율": info.get("율") or "", "값": info.get("값"),
"단위": info.get("단위") or "", "식들": [],
FOLLOW: {"기호": info.get("기호") or "", "이름": str(host.get("이름") or ""), "꼴": info.get("꼴") or ""}} # fmt: skip
same = text == line.get("수량")
return (None if same else text), {k: v for k, v in more.items() if k == Q_NEW}, mine
def line_work(run, line: dict, scope: dict):
"""기계 줄 하나 → (바꾼 수량 글 | 멈춤(표지는 계산기가 담) | None, 범위 더함 {}, 답 칸 | None) —
계산기 `_money` 가 부름."""
import master_doc_calc as mc
import master_doc_cover as mcv
got = _machine_of(run, line)
if not got:
return None, {}, None
where = str(line.get("이름") or "")
def quiet(fn):
"""흔적 없는 셈 — 표지 · 기억한 값을 되돌림(진짜 셈이 표지를 다시 냄)."""
n, seen = len(run.marks), set(run.values)
try:
return fn()
finally:
del run.marks[n:]
for k in set(run.values) - seen:
del run.values[k]
key_val = quiet(lambda: run.expr(got[0], where, scope))
if mc._bad(key_val):
return None, {}, None
key = mcv.machine_key({"기계": mc.plain_text(key_val)})
if (host := host_of(run, line)) is not None: # 848-4 부착 줄
return _follow(run, line, host, scope, key, got[1])
def test(cond):
v = quiet(lambda: run.ev(cond, scope, where))
return None if mc._bad(v) else bool(v)
found = sites(run.doc, line.get("수량"), test)
want = ((run.cover or {}).get(work_key(run.cover, key, got[1])) or {}).get(WORK)
hourly = isinstance(want, dict) and want.get("방식") == HOURLY
if not found and not hourly:
return None, {}, None
fixed = str(want["기계"]) if hourly and got[2] and want.get("기계") else "" # 847-1 굳은 기계
try:
specs = specs_of(run.links.element({"키": f"EQ:{fixed or key}", "칸": WORK}))
except (mc.Gap, mc.Broken):
specs = []
unit = found[0]["단위"] if found else ""
info = {"기계": key, "기호": got[1], "꼴": found[0]["꼴"] if found else "", "율": found[0]["율"] if found else "",
"값": None, "단위": unit, "식들": fits(specs, unit)} # fmt: skip
if not hourly:
v = quiet(lambda: run.ev(found[0]["노드"], scope, where))
info["값"] = v if isinstance(v, Decimal) else None
return None, {}, info
pick = str(want.get("식") or "") or next(iter(info["식들"]), "")
spec = next((s for s in specs if s["식"] == pick), None)
why = (
"시간당 작업량 식 없는 기계"
if not specs
else "시간당 작업량 자리 없는 줄"
if not found
else f"단위 {unit} 맞는 작업량 식 없음"
if not spec or pick not in info["식들"]
else ""
)
info |= {"꼴": HOURLY, "율": pick}
if fixed:
info["고정"] = fixed
if why:
info["까닭"] = why
return mc.Stop(f"{where} 시간당 거절 — {why}", "시간당 거절", where), {}, info
given = {**(spec.get("변수") or {}), **(want.get("변수") or {})}
tpl = None
try:
q = run.sub({"키": pick, "입력": given}, where)
tpl = run.links.doc(pick)
except (mc.Gap, mc.Broken) as e:
q = mc.Stop(str(e))
info["변수"] = {**defaults(tpl, spec), **(want.get("변수") or {})}
if not isinstance(q, Decimal) or q <= 0:
info["까닭"] = f"작업량 식 {pick} 못 셈" + (f" — {q.why}" if mc._bad(q) else "")
return mc.Stop(f"{where} {info['까닭']}", "시간당 거절", where), {}, info
info["값"] = q
more = {Q_NEW: q}
if fixed: # 단가 = 굳은 기계
price = run.link(fixed_var(run.vars[got[1]], want), got[1])
if isinstance(price, mc.Stop):
run.mark(price)
more[got[1]] = price
return swap(run.doc, line.get("수량")), more, info