- 옛 로직 JSON(한 번 돌림 build_로직_직접칸_851_1.py) → 빌더 → 수식 문서 · 목록 276 변수 = 더함 106(직접 칸 81 개 · 식 31) · 뺌 170(값 하나 154 · 이미 직접 칸이 덮음 16) · 꼴 = 「만약(X입력 > 0, X입력, 표)」(비우거나 0 = 고르기 값 · 넣으면 그 값) · 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 · 보이는 이름 「○○ 직접」(변수표 이름) · 기호 = 이름 규칙 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1] · 지금 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 · f입력 · k입력 · q입력 · 하역 · 대기 · 배출 · 적재시간입력) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」(33 칸) - 덤프트럭 8-2-8 t2 = 구간 셋(구간 1 = 운반거리 · 도로상태 그대로 · 구간2거리 · 구간3거리 0 = 안 씀) · 구간마다 적재 · 공차 속도 직접(원문 3 [주] 측정값) · t2 · t3 · t4 · t5 직접 - 입력 다 넘겨 부르는 로직(로직_자체 GC001155 · 10장 GF000148) = 새 입력 0 - 가져온 값 층(848-7) 표 찾기 = 변수 열쇠 대신 표 번호(t3 줄이 막이로 바뀌어도 그대로) - 낡은 시험 고침 — test_782_3 · test_masterdata_check 옛 엔진 부름에 새 입력 0(옛 엔진은 입력을 다 받음) · 가드 칸 자동값 = 「○○ 직접」 칸은 견본 0(표 밖 값도 받는 칸이라 「1 이어도 10배 안」 대신) · test_846_2 E입력 보이는 이름 - 시험 test_851_1 새로(직접 칸 124 전수 — 고르기 값 같은 수 = 결과 같음 · 다른 수 = 그 자리에 그 수를 박은 식과 같음 · 덤프 구간 하나 26.209 · 둘 · 셋 · 속도 · t2 ~ t5 직접 손셈 · TS 거울) - 전후 = 수식 문서 21,900 대조 다름 0 · 빌더 1,521 같음(옵션 표본 18,900 → 18,926 = 구간 도로상태 갈래) · --check 같음 · 기계 655 대 · 작업량 칸 286 · 견본 SK 5 다름 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
310 lines
14 KiB
Python
310 lines
14 KiB
Python
"""M02 가져온 식 「가져온 값」 층(PLAN 848-7 · 요구서_889 8 절) — 서버 단독.
|
||
|
||
경쟁사 블록의 시간당 작업량 변수 값(q · K · f · E · Cm · 덤프 T · rt · L · t1 ~ t4 …)을 그 기계 줄의
|
||
위 층 고침(`수식.위덮음`)으로 — {단가 기호: {작업량: {식: 우리 작업량 식 키, 변수: {우리 열쇠: 경쟁사 값}}}}.
|
||
방식은 싣지 않음(방식 없음 = 위 층 방식 → 처음은 경쟁사 식 그대로 「문서 식」 · 사용자가 「시간당 식」 을
|
||
고르는 순간 경쟁사 값에서 시작 · [원래 값] = 경쟁사 값).
|
||
짝 = 경쟁사 Q 식 모양 → 우리 식 변수(굴착기 8-2-3 `3600·q·K·f·E/Cm` · 덤프 8-2-8 단일 구간) ·
|
||
실은 값으로 우리 식을 셈한 Q 가 경쟁사 Q 와 같은(끝자리 안) 줄만 실음 — 다르면 안 실음(`why` = 줄마다 까닭).
|
||
경쟁사 자료(단가 · 품목)를 우리 마스터로 옮기지 않음(그 공사의 조건 값을 그 단가산출에만).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import copy as cp
|
||
import hashlib
|
||
import json
|
||
import re
|
||
from decimal import Decimal
|
||
from typing import Any
|
||
|
||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||
|
||
md, mc, mw, mcv = dc.md, dc.mc, dc.mc.mw, dc.mc.mcv
|
||
EXC, DUMP = "GC001147", "GC001155" # 굴착기 8-2-3 · 덤프트럭 8-2-8 작업량 식
|
||
_EXC = {"q": "버킷용량", "qs": "버킷용량", "qo": "버킷용량", "k": "K입력", "f": "f", "e": "E입력",
|
||
"es": "E입력", "cm": "싸이클입력", "cms": "싸이클입력"} # fmt: skip
|
||
_RANGE = {
|
||
"E입력": (0, 1),
|
||
"싸이클입력": (0, 30),
|
||
"K입력": (0, 2),
|
||
} # 우리 입력 칸 범위(0 = 표 → 0 초과만)
|
||
_MEMO: dict[str, tuple] = {}
|
||
|
||
|
||
class _No(Exception):
|
||
"""못 실음 — 까닭 글."""
|
||
|
||
|
||
def _role(name: str) -> str:
|
||
return re.sub(r"[_\d]+$", "", str(name)).lower()
|
||
|
||
|
||
def _inner(node):
|
||
"""반올림 · 버림 · 올림(식, 자리) → (식, 자리) · 아님 = (그대로, None)."""
|
||
if node[0] == "call" and node[1] in ("반올림", "버림", "올림") and node[2]:
|
||
places = node[2][1] if len(node[2]) > 1 else None
|
||
return node[2][0], (places[1] if places and places[0] == "num" else None)
|
||
return node, None
|
||
|
||
|
||
class _Doc:
|
||
"""문서 식 줄 · 셈 값 — 기호 → 정의 나무 · 값."""
|
||
|
||
def __init__(self, doc: dict, values: dict) -> None:
|
||
self.defs = {str(x.get("기호")): x.get("식") for x in doc.get("식") or []}
|
||
self.values = values
|
||
|
||
def tree(self, name: str):
|
||
text = self.defs.get(name)
|
||
if text is None:
|
||
return None
|
||
try:
|
||
return _inner(md.parse(text))[0]
|
||
except md.DocError:
|
||
return None
|
||
|
||
def value(self, node) -> Decimal:
|
||
if node[0] == "num":
|
||
return node[1]
|
||
got = self.values.get(node[1]) if node[0] == "var" else None
|
||
if not isinstance(got, Decimal):
|
||
raise _No(f"값 못 읽음({md.text_of(node)})")
|
||
return got
|
||
|
||
|
||
def _excavator(d: _Doc, fs: list) -> dict:
|
||
"""3600·q·K·f·E/Cm → {버킷용량 · K입력 · f · E입력 · 싸이클입력}."""
|
||
nums = [(s, n) for s, n in fs if n[0] == "num"]
|
||
if nums != [(1, ("num", Decimal(3600)))]:
|
||
raise _No("3600 꼴 아님")
|
||
out: dict[str, Any] = {}
|
||
for s, n in fs:
|
||
if n[0] == "num":
|
||
continue
|
||
role = _EXC.get(_role(n[1])) if n[0] == "var" else None
|
||
if role is None or role in out or (role == "싸이클입력") != (s < 0):
|
||
raise _No(f"변수 이름 낯섦({md.text_of(n)})")
|
||
out[role] = d.value(n)
|
||
if len(out) != 5:
|
||
raise _No("변수 모자람")
|
||
return out
|
||
|
||
|
||
def _sum_terms(node) -> list:
|
||
if node[0] == "bin" and node[1] == "+":
|
||
return [*_sum_terms(node[2]), *_sum_terms(node[3])]
|
||
return [node]
|
||
|
||
|
||
def _dump(d: _Doc, fs: list, tpl: dict) -> dict:
|
||
"""60·q·f·E/Cm(덤프 8-2-8) — q = T ÷ rt × L(L 없음 = 1) · Cm = t1 + t2 + t3 + t4(+ t5 덮개 + t6 세륜) ·
|
||
t1 = cms·n ÷ (60·Es) · n = q ÷ (버킷 × k) · t2 = (l ÷ V1 + l ÷ V2) × 60(단일 구간 · ÷ 1000 = m) → 우리 입력 · 고르기."""
|
||
if [(s, n) for s, n in fs if n[0] == "num"] != [(1, ("num", Decimal(60)))]:
|
||
raise _No("60 꼴 아님")
|
||
up = [n for s, n in fs if s > 0 and n[0] == "var"]
|
||
down = [n for s, n in fs if s < 0]
|
||
if len(up) != 3 or len(down) != 1 or down[0][0] != "var":
|
||
raise _No("덤프 Q 꼴 아님")
|
||
roles = {_role(n[1]): n for n in up}
|
||
f, e = roles.get("f"), roles.get("e") or roles.get("es")
|
||
load = [n for n in up if n is not f and n is not e]
|
||
if f is None or e is None or len(load) != 1:
|
||
raise _No("덤프 q · f · E 못 가림")
|
||
out: dict[str, Any] = {"f": d.value(f), "E입력": d.value(e)}
|
||
q = d.tree(load[0][1])
|
||
qf = mw._factors(q) if q is not None else []
|
||
if [s for s, _ in qf] not in ([1, -1, 1], [1, -1]):
|
||
raise _No("적재량 q = T ÷ rt × L 꼴 아님")
|
||
out |= {"적재용량": d.value(qf[0][1]), "단위중량": d.value(qf[1][1]),
|
||
"체적변화율": d.value(qf[2][1]) if len(qf) == 3 else Decimal(1)} # fmt: skip
|
||
cm = d.tree(down[0][1])
|
||
ts: dict[str, Any] = {}
|
||
for t in _sum_terms(cm) if cm is not None else []:
|
||
m = re.match(r"^[tT](\d)(?:_\d+)?$", t[1]) if t[0] == "var" else None
|
||
if not m or m.group(1) in ts:
|
||
raise _No(f"Cm 항 낯섦({md.text_of(t)})")
|
||
ts[m.group(1)] = t
|
||
if set(ts) - {"5", "6"} != {"1", "2", "3", "4"}:
|
||
raise _No("Cm = t1 + t2 + t3 + t4 꼴 아님")
|
||
if "5" in ts and (t5 := d.value(ts["5"])) != 0:
|
||
out["덮개"] = _option(tpl, "덮개", lambda r: Decimal(str(r.get("시간"))) == t5, "t5")
|
||
if "6" in ts and (t6 := d.value(ts["6"])) != 0:
|
||
if not _row(tpl, "CC000058", {}, t6): # 세륜기 통과시간(t6)
|
||
raise _No(f"t6 {t6} 표에 없음")
|
||
out["세륜"] = "함"
|
||
t1 = d.tree(ts["1"][1])
|
||
f1 = mw._factors(t1) if t1 is not None else []
|
||
if (-1, ("num", Decimal(60))) not in f1 or len(f1) != 4:
|
||
raise _No("t1 = cms × n ÷ (60 × Es) 꼴 아님")
|
||
rest = [x for x in f1 if x != (-1, ("num", Decimal(60)))]
|
||
n_var = next((n for s, n in rest if s > 0 and n[0] == "var" and _role(n[1]) == "n"), None)
|
||
cms = next((n for s, n in rest if s > 0 and n is not n_var), None)
|
||
es = next((n for s, n in rest if s < 0), None)
|
||
nt = d.tree(n_var[1]) if n_var else None
|
||
nf = mw._factors(nt) if nt is not None else []
|
||
if None in (n_var, cms, es) or [s for s, _ in nf] != [1, -1, -1] or nf[0][1] != load[0]:
|
||
raise _No("n = q ÷ (버킷 × k) 꼴 아님")
|
||
bk = sorted(nf[1:], key=lambda x: x[1][0] == "var" and _role(x[1][1]) == "k") # 버킷 › k
|
||
out |= {"적재싸이클": d.value(cms), "적재효율": d.value(es), "적재버킷": d.value(bk[0][1]), "버킷계수": d.value(bk[1][1])} # fmt: skip
|
||
t2 = d.tree(ts["2"][1])
|
||
f2 = mw._factors(t2) if t2 is not None else []
|
||
metre = (-1, ("num", Decimal(1000))) in f2 # 거리 m(÷ 1000)
|
||
f2 = [x for x in f2 if x != (-1, ("num", Decimal(1000)))]
|
||
legs = [mw._factors(x) for x in _sum_terms(f2[0][1])] if len(f2) == 2 and f2[1] == (1, ("num", Decimal(60))) else [] # fmt: skip
|
||
if (
|
||
len(legs) != 2
|
||
or any([s for s, _ in x] != [1, -1] for x in legs)
|
||
or legs[0][0][1] != legs[1][0][1]
|
||
):
|
||
raise _No("t2 단일 구간 (l ÷ V1 + l ÷ V2) × 60 꼴 아님")
|
||
out["운반거리"] = d.value(legs[0][0][1]) / (1000 if metre else 1)
|
||
speeds = sorted(d.value(x[1][1]) for x in legs)
|
||
out["도로상태"] = _option(tpl, "도로상태", lambda r: sorted(Decimal(str(r[k])) for k in ("적재", "공차")) == speeds) # fmt: skip
|
||
t3, t4 = d.value(ts["3"]), d.value(ts["4"])
|
||
soil = next(((s, c) for s in _options(tpl, "적하토질") for c in _options(tpl, "적하조건") if _row(tpl, "CC000055", {"S_적하토질": s, "S_적하조건": c}, t3)), None) # fmt: skip
|
||
if soil is None:
|
||
raise _No(f"t3 {t3} 표에 없음")
|
||
out["적하토질"], out["적하조건"] = soil
|
||
out["적재장소"] = _option(tpl, "적재장소", lambda r: Decimal(str(r.get("시간"))) == t4, "t4")
|
||
return out
|
||
|
||
|
||
def _options(tpl: dict, key: str) -> list:
|
||
v = next((x for x in tpl.get("변수") or [] if x.get("열쇠") == key), {})
|
||
return list((v.get("연결") or {}).get("목록") or [])
|
||
|
||
|
||
def _table(tpl: dict, ref: str) -> tuple[dict, dict]:
|
||
"""표 번호(CC…) → (표 연결, 그 표) — 그 표를 찾는 첫 변수(직접 칸 막이로 변수 열쇠가 바뀌어도)."""
|
||
v = next((x for x in tpl.get("변수") or [] if (x.get("연결") or {}).get("표") == ref), {})
|
||
link = v.get("연결") or {}
|
||
return link, dc.skc.whole_().get(str(link.get("표")))
|
||
|
||
|
||
def _row(tpl: dict, key: str, picked: dict, want: Decimal) -> bool:
|
||
link, table = _table(tpl, key)
|
||
want_row = {c: str(ref)[1:-1] if str(ref).startswith("'") else picked.get(ref) for c, ref in (link.get("조건") or {}).items()} # fmt: skip
|
||
return any(
|
||
all(str(r.get(c)) == str(v) for c, v in want_row.items())
|
||
and Decimal(str(r.get(link.get("칸")))) == want
|
||
for r in table.get("줄") or []
|
||
)
|
||
|
||
|
||
def _option(tpl: dict, key: str, test, label: str = "") -> str:
|
||
"""고르기 칸 — 목록 가운데 표 줄이 맞는 첫 값(표 = 그 고르기를 조건으로 쓰는 표)."""
|
||
sym = f"S_{key}"
|
||
for v in tpl.get("변수") or []:
|
||
link = v.get("연결") or {}
|
||
if link.get("갈래") == "표" and sym in (link.get("조건") or {}).values():
|
||
table = dc.skc.whole_().get(str(link.get("표")))
|
||
col = next(c for c, ref in link["조건"].items() if ref == sym)
|
||
for opt in _options(tpl, key):
|
||
if any(str(r.get(col)) == str(opt) and test(r) for r in table.get("줄") or []):
|
||
return opt
|
||
break
|
||
raise _No(f"{label or key} 표에 없음")
|
||
|
||
|
||
MAP = {EXC: lambda d, fs, tpl: _excavator(d, fs), DUMP: _dump}
|
||
|
||
|
||
def _plain(v: Any) -> Any:
|
||
return float(v) if isinstance(v, Decimal) else v
|
||
|
||
|
||
def _candidates(doc: dict, ans: dict, links: Any) -> tuple[dict, dict, dict]:
|
||
"""줄마다 (단가 기호 → 덮음 후보) · (기호 → 경쟁사 Q · 끝자리) · 까닭."""
|
||
d = _Doc(doc, ans.get("값") or {})
|
||
cand, comp, why = {}, {}, {}
|
||
for z in ans.get("줄") or []:
|
||
w = z.get(mw.WORK) or {}
|
||
sym = str(w.get("기호") or "")
|
||
if not sym or w.get(mw.FOLLOW) or sym in cand:
|
||
continue
|
||
if w.get("꼴") != "식":
|
||
why[sym] = f"작업량 꼴 {w.get('꼴') or '없음'}"
|
||
continue
|
||
node = d.defs.get(str(w.get("율")))
|
||
try:
|
||
whole = md.parse(node) if node is not None else None
|
||
except md.DocError:
|
||
whole = None
|
||
if whole is None:
|
||
why[sym] = "Q 값 직접"
|
||
continue
|
||
inner, places = _inner(whole)
|
||
forms = [k for k in w.get("식들") or [] if k in MAP]
|
||
if not forms:
|
||
why[sym] = "짝 있는 우리 식 없음" if w.get("식들") else "우리 작업량 식 없음"
|
||
continue
|
||
for key in forms:
|
||
try:
|
||
got = MAP[key](d, mw._factors(inner), links.doc(key) or {})
|
||
except _No as e:
|
||
why[sym] = f"{key} {e}"
|
||
continue
|
||
for k, (low, high) in _RANGE.items():
|
||
if k in got and not (low < got[k] <= high):
|
||
why[sym] = f"{key} {k} {got[k]} 범위 밖"
|
||
break
|
||
else:
|
||
cand[sym] = {mw.WORK: {"식": key, "변수": {k: _plain(v) for k, v in got.items()}}}
|
||
tol = Decimal(1).scaleb(-int(places)) if places is not None else Decimal("0.001")
|
||
comp[sym] = (w.get("값"), tol)
|
||
why.pop(sym, None)
|
||
break
|
||
return cand, comp, why
|
||
|
||
|
||
def carried(doc: dict, whole: Any = None) -> tuple[dict, dict]:
|
||
"""문서(기계덮음 뗀) → (가져온 값 층, 못 실은 줄 까닭 {단가 기호: 글}) — 같은 문서 = 기억."""
|
||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||
|
||
bare = {k: v for k, v in doc.items() if k != mcv.COVER}
|
||
key = hashlib.sha1(json.dumps(bare, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest() # fmt: skip
|
||
if key in _MEMO:
|
||
return cp.deepcopy(_MEMO[key])
|
||
links = dim.Links(whole or dim.imp._whole(), "엑셀")
|
||
mine = dim.view(bare, "엑셀")
|
||
try:
|
||
ans = mc.calc(mine, links)
|
||
cand, comp, why = _candidates(mine, ans, links)
|
||
on = {k: {mw.WORK: {"방식": mw.HOURLY}} for k in cand}
|
||
test = mc.calc(mine, links, cover=mcv.merge_layers(cand, on)) if cand else {}
|
||
except Exception as e: # noqa: BLE001 — 못 셈 = 층 없음(가져온 식 셈은 그대로)
|
||
return {}, {"*": f"셈 틀림 — {e}"}
|
||
got = {}
|
||
for z in test.get("줄") or []:
|
||
w = z.get(mw.WORK) or {}
|
||
sym = str(w.get("기호") or "")
|
||
if sym not in cand or w.get(mw.FOLLOW):
|
||
continue
|
||
q, (want, tol) = w.get("값"), comp[sym]
|
||
if isinstance(q, Decimal) and isinstance(want, Decimal) and abs(q - want) <= tol:
|
||
got[sym] = cand[sym]
|
||
else:
|
||
why[sym] = f"우리 식 Q {q} ≠ 경쟁사 Q {want}" + (
|
||
f" — {w.get('까닭')}" if w.get("까닭") else ""
|
||
)
|
||
if len(_MEMO) > 512:
|
||
_MEMO.clear()
|
||
_MEMO[key] = (got, why)
|
||
return cp.deepcopy(got), dict(why)
|
||
|
||
|
||
def carry(sk: dict, copy: Any) -> Any:
|
||
"""가져온 식 SK 사본 → ① 위 층 덮음 = 그 문서의 가져온 값(셈마다 · 문서 변수를 고치면 따라감)."""
|
||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||
|
||
if (
|
||
not dim.is_imported(sk)
|
||
or not isinstance(copy, dict)
|
||
or not isinstance(copy.get("문서"), dict)
|
||
):
|
||
return copy
|
||
got = carried(copy["문서"])[0]
|
||
rest = {k: v for k, v in copy.items() if k != mcv.UPPER}
|
||
return {**rest, mcv.UPPER: got} if got else rest
|