Files
Aislo/M02_MasterTemplete/M02_Doc_Import_Carry.py
T
eomsangdonandClaude Opus 5.5 a071391aac feat(848-7): 불러오기 엑셀 판 기계 정체 · 가져온 값 층 · 비목곱(세 줄 → 기계 한 줄) — 서버 · 계산기 짝
- 엑셀 판 기계 정체: view ↔ importView 가 기계 줄 숫자 연결에 입력 · 잠금(값 · 조종원 · 잡품) 남김 ·
  작업량 엔진 기계 찾기(_machine_of ↔ machineOf)가 숫자 + 입력 기계도 봄 → 엑셀 판 작업량 줄 0 → 1,634 블록
- 가져온 값 층(새 M02_Doc_Import_Carry): 경쟁사 Q 식(굴착기 8-2-3 · 덤프 8-2-8 단일 구간) 변수 →
  수식.위덮음 {단가 기호: {작업량: {식, 변수}}}(방식 없음) · 우리 식 Q = 경쟁사 Q 인 줄만(759 줄 · 571 블록) ·
  M02_Doc_Import.run(upper) · M02_Doc_Sk copy_of · run 이 실음
- 비목곱: 금액 줄 선택 칸 {비목: 식} — 비목 수량 = 수량 × 곱(계산기 짝 master_doc_calc ↔ calc.ts) ·
  M02_Doc_Import_Shape 세 줄 합침이 「두 줄 같은 수량 + 더한 인수」 꼴도 한 줄로(301 줄)
- 단위 정규화 「톤/hr」 = 「ton/hr」(norm_unit ↔ normUnit)
- 굳히기: 수식 고침 저장한 가져온 식 SK 사본 = 가져온 식 셈 유지(M02_Item_Sangeun · 전엔 사본 0 원) → B09 = M02
- 시험 test_848_7_import_carry 14(거울 · 견본 · 임시 storage B09)
- 전수 3,241 블록 엑셀 · 우리 판 계 · 비목 · 검산 전후 다름 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 00:13:08 +09:00

310 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""M02 가져온 식 「가져온 값」 층(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, "T_시간4^표", {}, 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, "t3", {"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, key: str) -> tuple[dict, dict]:
"""표 변수 열쇠 → (표 연결, 그 표)."""
v = next((x for x in tpl.get("변수") or [] if x.get("열쇠") == key), {})
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