diff --git a/M02_MasterTemplete/M02_Doc_Import.py b/M02_MasterTemplete/M02_Doc_Import.py index c0788829a..d74b21182 100644 --- a/M02_MasterTemplete/M02_Doc_Import.py +++ b/M02_MasterTemplete/M02_Doc_Import.py @@ -492,8 +492,12 @@ class _Row: # ── 셈 ──────────────────────────────────────────────────────────────── +LOCK = ("값", "조종원", "잡품") # 848-7 엑셀 판 기계 줄 — 잠긴 제어 구역 묶음(작업량은 열림) + + def view(doc: dict, basis: str) -> dict: - """단가기준 엑셀 = 엑셀 값 기억 연결(형제 SK 빼고)을 숫자로 · 우리 = 그대로 · + """단가기준 엑셀 = 엑셀 값 기억 연결(형제 SK 빼고)을 숫자로 · 우리 = 그대로 · 기계 줄(입력 「기계」)은 + `입력`(기계 정체 — 작업량 엔진) · `잠금` 을 남김(848-7) · TS 짝 = `common_util/common_util_formula_doc_import.ts` `importView`(거울 시험 test_802_4b1).""" if basis == "우리": return doc @@ -501,7 +505,9 @@ def view(doc: dict, basis: str) -> dict: for var in out.get("변수") or []: link = var.get("연결") or {} if XL in link and not str(link.get("키") or "").startswith("SK-"): - var["연결"] = {"갈래": "숫자", "값": link[XL]} + given = link.get("입력") if isinstance(link.get("입력"), dict) else {} + mine = {"입력": given, "잠금": list(LOCK)} if "기계" in given else {} + var["연결"] = {"갈래": "숫자", "값": link[XL], **mine} return out @@ -569,15 +575,17 @@ def record(doc: dict, sk: dict) -> dict[str, Any]: return rec.out() -def run(doc: dict, sk: dict, master: Any = None, index: Any = None) -> dict: +def run(doc: dict, sk: dict, master: Any = None, index: Any = None, upper: Any = None) -> dict: """가져온 식 문서 셈(SK 단가기준) — 계산기 = M01 과 같은 `master_doc_calc` · - `index` = 셈 색인 갈음(빈틈 적기 · 823-1).""" + `index` = 셈 색인 갈음(빈틈 적기 · 823-1) · `upper` = ① 가져온 값 층(848-7 · 사본 `위덮음`).""" basis = basis_of(sk) links = Links(index or _index(sk, master, doc), basis) mine = view(doc, basis) try: links.learn(mine) - return dc.mc.calc(mine, links) + return dc.mc.calc( + mine, links, cover=dc.mc.mcv.merge_layers(upper, dc.mc.mcv.cover_of(mine)) + ) except Exception as e: # noqa: BLE001 — 계산기 예외 없음이 원칙 · 남은 틈도 「—」 return { "셈됨": False, diff --git a/M02_MasterTemplete/M02_Doc_Import_Carry.py b/M02_MasterTemplete/M02_Doc_Import_Carry.py new file mode 100644 index 000000000..3c0fd55a3 --- /dev/null +++ b/M02_MasterTemplete/M02_Doc_Import_Carry.py @@ -0,0 +1,309 @@ +"""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 diff --git a/M02_MasterTemplete/M02_Doc_Import_Shape.py b/M02_MasterTemplete/M02_Doc_Import_Shape.py index f142240b0..ffed38c39 100644 --- a/M02_MasterTemplete/M02_Doc_Import_Shape.py +++ b/M02_MasterTemplete/M02_Doc_Import_Shape.py @@ -5,7 +5,9 @@ 「합 계」 절 아래 비목 = 「노무비 합계」 꼴) — 「줄_2 · 노무비_2 · 계_2」 같은 지은 이름 걷음 ② EST 기계 세 줄(같은 자원 · 같은 기계 이음 · 같은 수량 · 노무비 · 재료비 · 경비 하나씩) = 한 기계 줄 (이름 = 자원 이름 · 비목 묶음 · 단가 = 기계 이음 칸 없음 · 엑셀 = 값묶음) · 세 줄 기호를 부르던 식 = - 그 줄 비목 칸(`C_크레인.노무비`) — 셈 값 그대로(줄 끝수 = 비목마다 같은 규칙) + 그 줄 비목 칸(`C_크레인.노무비`) — 셈 값 그대로(줄 끝수 = 비목마다 같은 규칙) · + 848-7 두 줄 수량 A 가 같고 남은 줄 수량 = A 의 곱 · 나눔 인수 + 더한 인수(재료비 운전 시간율 · OH ÷ Q · × 0) = + 한 줄 수량 A + `비목곱` {비목: 더한 인수} 엑셀 원 글 · 엔진 줄은 안 고침(문서 겉꼴만) · 못 맞추면 그대로 둠. """ @@ -15,6 +17,8 @@ import re from decimal import Decimal from typing import Any +from M02_MasterTemplete.M02_Doc_Copy import md, mw + COSTS = ("노무비", "재료비", "경비") # 지은 이름 — 「줄_2 · 노무비_2」 · 읽기기 율 줄 「율」 _MADE = re.compile(r"^(?:(?:줄|노무비|재료비|경비|계|소계|합계)?_\d+|율(?:_\d+)?)$") @@ -88,9 +92,11 @@ def _bundle_of(doc: dict, at: int, who: dict[str, str] | None = None) -> list[in x.get("칸") for x in links ] != [x.get("비목") for x in three]: return None - for k in ("수량", "규격", "자리", "합밖", "번지"): + for k in ("규격", "자리", "합밖", "번지"): if len({str(x.get(k) or "") for x in three}) != 1: return None + if _times(three) is None: + return None names = {str(x.get("이름")) for x in three} for st in doc.get("단계") or []: # 단계가 셋 중 일부만 담으면 못 합침 if 0 < len(names & set(st.get("줄") or [])) < 3: @@ -98,6 +104,36 @@ def _bundle_of(doc: dict, at: int, who: dict[str, str] | None = None) -> list[in return [at, at + 1, at + 2] +def _factors(text: str) -> list | None: + try: + return [f for f in mw._factors(md.parse(text)) if f != (1, ("num", Decimal(1)))] + except md.DocError: + return None + + +def _times(three: list[dict]) -> tuple[str, dict[str, str]] | None: + """848-7 세 줄 수량 → (한 줄 수량 A, {비목: 곱 글}) — 모두 같음 = 곱 없음 · 두 줄이 A 이고 남은 줄 = + A 의 곱 · 나눔 인수를 모두 담고 인수를 더함 = 그 더한 인수 · 그 밖 = None(못 합침).""" + texts = [str(x.get("수량") or "") for x in three] + base = max(texts, key=texts.count) + low = _factors(base) + if texts.count(base) < 2 or low is None: + return None + out: dict[str, str] = {} + for x, text in zip(three, texts): + if text == base: + continue + rest = _factors(text) + for f in low: + if rest is None or f not in rest: + return None + rest.remove(f) + if not rest: + return None + out[str(x["비목"])] = md.text_of(mw._build(rest)) + return base, out + + def _place(doc: dict, name: str, used: set[str]) -> str: """기계 줄 번지 — 자원 이름 첫 낱말(괄호 · 규격 · 기호 뺌) · 겹치면 숫자.""" word = re.sub(r"[^\w]|_", "", re.split(r"[\s(]", name.strip())[0]) or "기계" @@ -184,6 +220,9 @@ def machines(doc: dict, title: dict[str, str], who: dict[str, str] | None = None name = f"{name} ({at + 1})" # 같은 이름 줄이 있으면 겹치지 않게 line = {k: v for k, v in lead.items() if k != "기호"} | {"이름": name, "비목": "묶음"} line["단가"] = lead["단가"] + qty, times = _times(three) + if times: # 848-7 비목곱 + line["수량"], line["비목곱"] = qty, times _rename_steps(doc, {str(x.get("이름")): name for x in three}) if any(x.get("기호") for x in three): # 부르던 식 = 번지 칸(엔진 `번지.X.노무비`) place = _place(doc, name, used) @@ -203,6 +242,8 @@ def machines(doc: dict, title: dict[str, str], who: dict[str, str] | None = None for line in out: for k in ("단가", "수량"): line[k] = _rewrite(line.get(k), swap) + if line.get("비목곱"): + line["비목곱"] = {k: _rewrite(v, swap) for k, v in line["비목곱"].items()} for one in doc.get("식") or []: one["식"] = _rewrite(one.get("식"), swap) diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 628874cac..36b7ac1d8 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -27,6 +27,7 @@ from typing import Any from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Doc_Gap as gap from M02_MasterTemplete import M02_Doc_Import as dim +from M02_MasterTemplete import M02_Doc_Import_Carry as carry from M02_MasterTemplete import M02_MyMachine_Draft as draft from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd @@ -152,14 +153,14 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None: return None got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1) if got.get("따로") or ctx is None: - return got + return carry.carry(sk, got) # 848-7 가져온 식 ① = 가져온 값 if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎) try: same = dim.basis_of(sk) == "엑셀" root = dim.derive(sk, ctx if same else None, dc.base(ctx[0])) except dc._ERR as e: root = {**dc.md.blank(str(sk.get("키"))), "_틀림": str(e)} - return {**got, "문서": root, "부름": {}} + return carry.carry(sk, {**got, "문서": root, "부름": {}}) try: root = renew.carry(got, derive(sk, ctx)) # 맡긴 기계 덮음(836-2) except dc._ERR as e: @@ -193,7 +194,9 @@ def on_run(sk: dict, ans: dict, ctx: tuple | None) -> dict: def run(sk: dict, copy: dict, master: Any = None) -> dict: """문서 셈 — 가져온 식 = 단가기준 · 형제 SK(`dim.run`) · 그 밖 = 값 사본(`dc.run`).""" if dim.is_imported(sk): - return dim.run(copy["문서"], sk, dc.base(master) if master is not None else None) + return dim.run( + copy["문서"], sk, dc.base(master) if master is not None else None, upper=copy.get(UPPER) + ) return dc.run(copy["문서"], copy) diff --git a/M02_MasterTemplete/M02_Item_Sangeun.py b/M02_MasterTemplete/M02_Item_Sangeun.py index 9d5b7e2d1..fd073420a 100644 --- a/M02_MasterTemplete/M02_Item_Sangeun.py +++ b/M02_MasterTemplete/M02_Item_Sangeun.py @@ -26,6 +26,7 @@ from M02_MasterTemplete import M02_Sangeun_Doc as sd #: 사본 `단가.json` 안 굳힌 SK 줄 파일(`master_formula.Master` 가 그룹 「로직」 으로 읽음) FILE = "로직_단가산출.json" ROW = "굳힌줄" +_IMPORTED = "가져온" # 가져온 식 머리(`M02_Sangeun_Imported.KEY`) _HEAD, _LOW, _SPAN = "GX", 900000, 99999 # GX900000 ~ GX999998(999999 = M01 저장 전 초안) @@ -87,6 +88,9 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]: frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"]) if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02 frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것 + # 848-7 가져온 식 수식 고침(저장 문서) = 사본도 가져온 식 셈(단가기준 · 가져온 값 층) + if doc.get(_IMPORTED) and doc["수식"].get("따로"): + frozen[_IMPORTED] = doc[_IMPORTED] out[rid] = frozen for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)): out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken) diff --git a/common_util/common_util_formula_doc_calc.ts b/common_util/common_util_formula_doc_calc.ts index d921933ce..8778ba7a7 100644 --- a/common_util/common_util_formula_doc_calc.ts +++ b/common_util/common_util_formula_doc_calc.ts @@ -450,6 +450,25 @@ function stepsOf(cover: [Step, Set][], outs: { 비목: Bundle }[]): Step }); } +/** 848-7 비목곱 {비목: 식} → {비목: 값} · 없음 = {} · 틀림 = Stop | Blank(수량과 같은 길) */ +function timesOf( + run: Run, + line: unknown, + where: string, + scope: Record, +): Bundle | Stop | Blank { + const out: Bundle = {}; + for (const [k, text] of Object.entries( + (line as { 비목곱?: Record }).비목곱 ?? {}, + )) { + const v = run.expr(text, where, scope); + if (v instanceof Stop || v instanceof Blank) return v; + if (!isNum(v)) return run.mark(new Stop(`${where} 비목곱 ${k} 수 아님`, "셈 틀림", where)); + out[k] = v; + } + return out; +} + function money(run: Run, doc: FormulaDoc, rules: Record) { const lines = doc.금액 ?? []; const cover = coverOf(doc); @@ -485,6 +504,7 @@ function money(run: Run, doc: FormulaDoc, rules: Record) { ? run.expr(text, where, { ...scope, ...(more as Record) }) : 1; const price = run.expr(line.단가, where, { ...scope, ...(more as Record) }); // 847-1 굳은 기계 단가 + const times = timesOf(run, line, where, { ...scope, ...(more as Record) }); // 848-7 비목곱 const kind = line.비목 as string; let parts: Bundle = {}; let bare: number | null = null; // 비목 없는 합 밖 줄(소계 보임 · 810-2) — 금액만 @@ -493,17 +513,19 @@ function money(run: Run, doc: FormulaDoc, rules: Record) { stopped = true; why = run.mark(new Stop(`${where} ${text}`, "셈 틀림", where)).why; }; - if (qty instanceof Stop || price instanceof Stop) { + const halt = [qty, price, times].find((x) => x instanceof Stop) as Stop | undefined; + if (halt) { stopped = true; - why = (qty instanceof Stop ? qty : (price as Stop)).why; + why = halt.why; } else if (qty instanceof Blank) why = qty.why; + else if (times instanceof Blank) why = times.why; else if (!isNum(qty)) stop("수량이 수 아님"); else if (qty === 0 && !kind && line.합밖) bare = 0; else if (qty === 0) for (const k of kind === "묶음" ? COSTS : [kind]) parts[k] = 0; else if (price instanceof Blank) why = price.why; else if (kind === "묶음") { if (isObj(price) && COSTS.every((k) => isNum((price as Bundle)[k]))) - for (const k of COSTS) parts[k] = qty * (price as Bundle)[k]; + for (const k of COSTS) parts[k] = qty * ((times as Bundle)[k] ?? 1) * (price as Bundle)[k]; else stop("묶음 줄 단가가 단가산출 묶음 아님"); } else if ((COSTS as readonly string[]).includes(kind) && isNum(price)) parts[kind] = qty * price; diff --git a/common_util/common_util_formula_doc_import.ts b/common_util/common_util_formula_doc_import.ts index 30fcfb3d3..c4166a3be 100644 --- a/common_util/common_util_formula_doc_import.ts +++ b/common_util/common_util_formula_doc_import.ts @@ -3,6 +3,7 @@ * 가져온 식(엑셀 불러오기) 수식 문서 단가기준 보기(PLAN 802-4b-1 · 요구 664) * [엑셀 단가 그대로](기본) = 연결 칸 `엑셀`(엑셀 값 기억)이 있는 변수를 숫자 연결로 보고 셈 · * [우리 단가로] = 문서 그대로(연결 값) · 형제 단가산출(SK-…) 연결은 늘 연결(부르는 쪽 단가기준) + * 848-7 엑셀 판 기계 줄(입력 「기계」) = 숫자 연결에 `입력`(기계 정체 — 작업량 엔진) · `잠금`(제어 구역 잠긴 묶음) * 파이썬 · TS 짝 — 짝 = M02_MasterTemplete/M02_Doc_Import.py `view` · 거울 시험 * test_802_4b1_import_doc.py(고칠 때 둘을 같이 고침) · 화면 · DOM · fetch 없음 * ========================================================================== */ @@ -10,6 +11,8 @@ import type { DocVar, FormulaDoc, Link } from "./common_util_formula_doc"; export const EXCEL = "엑셀"; +/** 848-7 엑셀 판 기계 줄 — 잠긴 제어 구역 묶음(작업량은 열림) */ +export const LOCK = ["값", "조종원", "잡품"]; export type Basis = "엑셀" | "우리"; /** 단가기준 보기 — 엑셀 = 엑셀 값 기억 연결(형제 SK 빼고)을 숫자로 · 우리 = 그대로(새 문서) */ @@ -18,7 +21,9 @@ export function importView(doc: FormulaDoc, basis: Basis): FormulaDoc { const vars = (doc.변수 ?? []).map((v: DocVar): DocVar => { const link = (v.연결 ?? {}) as Link & Record; if (!(EXCEL in link) || String(link.키 ?? "").startsWith("SK-")) return v; - return { ...v, 연결: { 갈래: "숫자", 값: link[EXCEL] } }; + const given = (link.입력 ?? {}) as Record; + const mine = "기계" in given ? { 입력: given, 잠금: [...LOCK] } : {}; + return { ...v, 연결: { 갈래: "숫자", 값: link[EXCEL], ...mine } as Link }; }); return { ...doc, 변수: vars }; } diff --git a/common_util/common_util_formula_doc_work.ts b/common_util/common_util_formula_doc_work.ts index 1e5b94593..cc87ba17b 100644 --- a/common_util/common_util_formula_doc_work.ts +++ b/common_util/common_util_formula_doc_work.ts @@ -93,6 +93,7 @@ export const normUnit = (u: unknown): string => .replace(/[mM]3/g, "㎥") // 848-6 대문자 꼴 .replace(/[mM]2/g, "㎡") .replace(/(? s.toLowerCase()) + .replace(/톤(?=\/)/g, "ton") // 848-7 「톤/hr」 = 우리 식 「ton/hr」 .replace(/\/(시간|h|Hr|HR)$/, "/hr"); const varOf = (doc: FormulaDoc, name: string): DocVar | undefined => @@ -370,7 +371,8 @@ export interface WorkKit { plainText: (v: unknown) => string; } -/** 기계 줄 단가 기호 → {작업 기계 입력 식, 단가 기호, 본 기계 칸인지(부착 기계 아님)} · 기계 줄 아님 = null */ +/** 기계 줄 단가 기호 → {작업 기계 입력 식, 단가 기호, 본 기계 칸인지(부착 기계 아님)} · 기계 줄 아님 = null · + * 숫자 연결 + 입력 「기계」 = 가져온 식 엑셀 판 기계 줄(848-7) */ export function machineOf( vars: Map, line: { 단가?: unknown }, @@ -379,7 +381,7 @@ export function machineOf( for (const name of node ? names(node) : []) { const link = (vars.get(name)?.연결 ?? {}) as { 갈래?: string; 입력?: Record }; // prettier-ignore const given = link.입력 ?? {}; - if (link.갈래 === "단가산출" && "기계" in given) { + if ((link.갈래 === "단가산출" || link.갈래 === "숫자") && "기계" in given) { const tool = Object.entries(given).filter(([k]) => k !== "기계" && !NOT_MACHINE.includes(k)); const expr = String(tool.length ? tool[tool.length - 1][1] : given.기계); return { expr, name, main: !tool.length }; diff --git a/resources/master_data/scripts/master_doc_calc.py b/resources/master_data/scripts/master_doc_calc.py index 38a7c7125..0f6f5be68 100644 --- a/resources/master_data/scripts/master_doc_calc.py +++ b/resources/master_data/scripts/master_doc_calc.py @@ -20,6 +20,7 @@ import master_doc_cover as mcv import master_doc_work as mw COSTS, BUNDLE = md.COSTS, md.BUNDLE +TIMES = "비목곱" # 848-7 금액 줄 선택 칸 {비목: 식} — 그 비목 수량 = 수량 × 곱 EPS = 1e-7 # B09_Estimation_Calc_Base.EPS 와 같음 DEEP = 20 # 단가산출 부름 깊이 _QUANT = {"버림": ROUND_DOWN, "반올림": ROUND_HALF_UP, "올림": ROUND_UP} @@ -416,12 +417,13 @@ def _money(run: _Run, doc: dict, rules: dict): else Decimal(1) ) price = run.expr(line.get("단가"), where, {**scope, **more}) # 847-1 굳은 기계 단가 + times = _times(run, line, where, {**scope, **more}) # 848-7 비목곱 kind = line.get("비목") parts, why, bare = {}, None, None - if isinstance(qty, Stop) or isinstance(price, Stop): - stopped, why = True, (qty if isinstance(qty, Stop) else price).why - elif isinstance(qty, Blank): - why = qty.why + if any(isinstance(x, Stop) for x in (qty, price, times)): + stopped, why = True, next(x for x in (qty, price, times) if isinstance(x, Stop)).why + elif isinstance(qty, Blank) or isinstance(times, Blank): + why = (qty if isinstance(qty, Blank) else times).why elif not isinstance(qty, Decimal): stopped, why = True, run.mark(Stop(f"{where} 수량이 수 아님", "셈 틀림", where)).why elif qty == 0 and not kind and line.get("합밖"): @@ -432,7 +434,7 @@ def _money(run: _Run, doc: dict, rules: dict): why = price.why elif kind == "묶음": if isinstance(price, dict) and all(isinstance(price.get(k), Decimal) for k in COSTS): - parts = {k: qty * price[k] for k in COSTS} + parts = {k: qty * times.get(k, 1) * price[k] for k in COSTS} else: stopped, why = ( True, @@ -485,6 +487,19 @@ def _money(run: _Run, doc: dict, rules: dict): return outs, running, stopped, cover +def _times(run: _Run, line: dict, where: str, scope: dict): + """848-7 비목곱 {비목: 식} → {비목: 값} · 없음 = {} · 틀림 = Stop | Blank(수량과 같은 길).""" + out = {} + for k, text in (line.get(TIMES) or {}).items(): + v = run.expr(text, where, scope) + if isinstance(v, (Stop, Blank)): + return v + if not isinstance(v, Decimal): + return run.mark(Stop(f"{where} 비목곱 {k} 수 아님", "셈 틀림", where)) + out[k] = v + return out + + def _settle(doc: dict, rules: dict, total: dict) -> dict: """비목 합 끝수 → 끝전(큰나머지) → 계 끝수 → 조정 → 비목 끝수.""" costs = {k: cut(v, rules["비목"]) for k, v in total.items()} diff --git a/resources/master_data/scripts/master_doc_work.py b/resources/master_data/scripts/master_doc_work.py index 1fa024325..9ec3be148 100644 --- a/resources/master_data/scripts/master_doc_work.py +++ b/resources/master_data/scripts/master_doc_work.py @@ -38,6 +38,7 @@ 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"(? (p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p)); + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const cu = (n) => load(path.join(process.argv[1], "common_util", n)); +const imp = cu("common_util_formula_doc_import.ts"), work = cu("common_util_formula_doc_work.ts"); +const x = JSON.parse(fs.readFileSync(0, "utf8")); +process.stdout.write(JSON.stringify({ 보기: x.보기.map((d) => imp.importView(d, "엑셀")), 단위: x.단위.map(work.normUnit) })); +""" + + +def test_거울_보기_단위(links): + docs = [_excel_doc(links), _three("1 ÷ q × ((c - a - b) ÷ c)")] + units = ["톤/hr", "TON/HR", "톤", "인/톤"] + want = {"보기": [dim.view(d, "엑셀") for d in docs], "단위": [mw.norm_unit(u) for u in units]} + assert want["단위"] == ["ton/hr", "ton/hr", "톤", "인/톤"] + proc = subprocess.run(["node", "-e", _JS, str(ROOT)], input=json.dumps(ml._norm({"보기": docs, "단위": units}), ensure_ascii=False), # fmt: skip + capture_output=True, text=True, encoding="utf-8", check=True) # fmt: skip + assert json.loads(proc.stdout) == json.loads(json.dumps(ml._norm(want), ensure_ascii=False)) + + +def test_거울_비목곱_엑셀_판_셈(links): + from test_846_1_machine_work import Rec, _lines, _same + + rec = Rec(links) + merged = _three("1 ÷ q × ((c - a - b) ÷ c)") + shape.machines(merged, {}, {}) + cases = [{"문서": dim.view(merged, "엑셀"), "덮음": None}, {"문서": dim.view(_excel_doc(links), "엑셀"), "덮음": None}] # fmt: skip + key = next(z[mw.WORK]["기호"] for z in mc.calc(cases[1]["문서"], links)["줄"] if z.get(mw.WORK)) # fmt: skip + cases.append({"문서": cases[1]["문서"], "덮음": {key: {mw.WORK: {"방식": "시간당", "식": "GC001147", "변수": {"K입력": 0.8}}}}}) # fmt: skip + want = [ + mc.calc({**c["문서"], **({"기계덮음": c["덮음"]} if c["덮음"] else {})}, rec) for c in cases + ] + proc = subprocess.run(["node", os.path.join(HERE, "helper_846_1_machine_work.cjs")], + input=json.dumps(ml._norm({"문서들": rec.docs, "대상": cases, "기록": rec.log}), ensure_ascii=False), # fmt: skip + capture_output=True, text=True, encoding="utf-8", check=True) # fmt: skip + got = json.loads(proc.stdout)["답"] + for i, (a, b) in enumerate(zip(want, got)): + _same(ml._norm({k: a.get(k) for k in (*COSTS, "계", "셈됨")}), {k: b.get(k) for k in (*COSTS, "계", "셈됨")}, f"답{i}") # fmt: skip + _same(ml._norm(_lines(a)), _lines(b), f"줄{i}") + assert want[0]["계"] == 3022 and want[2]["줄"][0][mw.WORK]["꼴"] == "시간당" + + +# ── ⑤ 실제 원파일 견본 ─────────────────────────────────────────────────── +def _block(kind, tag, no): + import test_810_2_native_doc as nd + + from M02_MasterTemplete import M02_Doc_FromNative as fn + from M02_MasterTemplete import M02_Sangeun_Imported as imp + + try: + saved = nd.native(kind, tag) + except Exception: # noqa: BLE001 — 원파일 없는 PC + pytest.skip("원파일 없음") + sk = nd.sk_of(fn.emit(saved, no)) + return ( + sk, + dim.derive(sk, None, nd.whole()), + {**sk, imp.KEY: {**sk[imp.KEY], "단가기준": "우리"}}, + ) + + +@pytest.mark.parametrize( + "kind, tag, no, want", + [ + ( + "EST", + "거창", + 1, + { + "P_굴삭기": ( + "GC001147", + {"버킷용량": 0.7, "K입력": 0.55, "f": 0.75, "E입력": 0.45, "싸이클입력": 20.0}, + ) + }, + ), # fmt: skip + ( + "STC", + "봉화", + 109, + { + "P_노무": ("GC001155", {"적재용량": 15.0, "운반거리": 0.185, "적하조건": "불량"}), + "P_노무2": ("GC001155", {"적재용량": 24.0}), + "P_굴삭기": ("GC001147", {"싸이클입력": 18.0}), + }, + ), # fmt: skip + ], +) +def test_가져온_값_층_켜기_전_그대로_켜면_Q_같음(kind, tag, no, want): + sk, doc, ours = _block(kind, tag, no) + got, why = car.carried(doc) + assert not why and set(got) == set(want) + for sym, (form, vals) in want.items(): + assert "방식" not in got[sym][mw.WORK] and got[sym][mw.WORK]["식"] == form + assert {k: got[sym][mw.WORK]["변수"][k] for k in vals} == vals + for s in (sk, ours): + assert _money(dim.run(doc, s, upper=got)) == _money(dim.run(doc, s)) + comp = {z[mw.WORK]["기호"]: z[mw.WORK]["값"] for z in dim.run(doc, sk)["줄"] if z.get(mw.WORK)} + on = {**doc, "기계덮음": {k: {mw.WORK: {"방식": "시간당"}} for k in got}} + for z in dim.run(on, sk, upper=got)["줄"]: + w = z.get(mw.WORK) or {} + if w.get("기호") in got: + assert w["꼴"] == "시간당" and abs(w["값"] - comp[w["기호"]]) <= D("0.01"), w + + +def test_봉화_세_줄_한_줄_금액_그대로(): + sk, doc, _ = _block("STC", "봉화", 109) + assert [x["이름"] for x in doc["금액"]] == [ + "덤프트럭 15톤", + "덤프트럭 24톤", + "굴삭기(무한궤도)", + ] + assert doc["금액"][0]["비목곱"] == {"재료비": "(cm_2 - t1 - t3) ÷ cm_2"} + assert _money(dim.run(doc, sk)) == [D(2570), D(293), D(933), D(3796)] + + +def test_읽기_답_위덮음_미리_셈_시간당(): + from M02_MasterTemplete import M02_Doc_Sk_Path as path + + sk, doc, _ = _block("EST", "거창", 1) + got = path.read_memory(sk) + assert got["위덮음"]["P_굴삭기"]["작업량"]["식"] == "GC001147" and got["셈"]["계"] == 5323 + mine = { + **got["문서"], + "기계덮음": {"P_굴삭기": {"작업량": {"방식": "시간당", "식": "GC001147"}}}, + } # 화면이 고른 꼴 + pre = path.preview("", {"본": sk, "문서": mine}) + line = pre["셈"]["줄"][0]["작업량"] + assert ( + line["꼴"] == "시간당" and line["값"] == pytest.approx(23.389) and pre["전"]["계"] == 5323 + ) + + +# ── ⑥ 프로젝트 사본(굳히기) — B09 = M02(임시 storage) ────────────────────── +@pytest.fixture +def world(tmp_path, monkeypatch): + from resources.tester.test_m02_labor_ref import world as make + + return make.__wrapped__(tmp_path, monkeypatch) + + +def _b09(me, key): + from B09_Estimation import B09_Estimation_Supply as supply + from B09_Estimation.B09_Estimation_Labor_Source import _Loose + from M02_MasterTemplete import M02_Item_Prices as item_prices + from M02_MasterTemplete import M02_Item_Source as source + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_MasterTemplete_Store as store + + with store.at(me): + here = refs.here() + ref = {"층": here[0], "주인": here[1], "키": key} + rows = source.labor_doc_rows({"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}) # fmt: skip + bundle = source.price_bundle(rows, me) + got = item_prices.calc(rows, bundle, {}, {}) + copies, whole = rows["참조사본"], item_prices.load_prices(bundle) + rid = refs.ref_id(ref) + b09 = supply.sk_money(copies[rid], whole, _Loose(whole, lambda r: copies.get(refs.ref_id(r))), rid) # fmt: skip + return float(got["반영합"]["계"]), sum(b09.values()) + + +@pytest.mark.parametrize("basis", ["엑셀", "우리"]) +def test_시간당_고침_저장_사본_B09_같음(world, basis): + from M02_MasterTemplete import M02_Doc_Sk_Path as path + from M02_MasterTemplete import M02_Labor_Ref as refs + from M02_MasterTemplete import M02_MasterTemplete_Store as store + + sk, _, _ = _block("EST", "거창", 1) + sk["가져온"]["단가기준"] = basis + me = world["personal"] + with store.at(me): + key = refs.create("sangeun", {**sk, "이름": f"848-7 sub1임시 {basis}"})["이름"] + got = path.read(key) + first = float(got["셈"]["계"]) + assert _b09(me, key) == (first, first) + with store.at(me): + doc = cp.deepcopy(got["문서"]) + doc["기계덮음"] = {"P_굴삭기": {"작업량": {"방식": "시간당", "식": "GC001147", "변수": {"싸이클입력": 15}}}} # fmt: skip + after = float(path.save(key, {"문서": doc, "판": got["판"]})["셈"]["계"]) + again = path.read(key) + assert after < first and float(again["셈"]["계"]) == after + assert again["셈"]["줄"][0]["작업량"]["변수"]["버킷용량"] == 0.7 # 가져온 값 위에 내 고침 + assert _b09(me, key) == (after, after) + + +def test_세_줄_OH_나누기_꼴도_한_줄_금액_같음(links): + doc = _three("0.5 ÷ q") # EST 「OH ÷ Q」 = 노무비 수량 인수 + 0.5 + before = mc.calc(dim.view(doc, "엑셀"), links) + shape.machines(doc, {}, {}) + assert len(doc["금액"]) == 1 and doc["금액"][0]["비목곱"] == {"재료비": "0.5"} + assert _money(mc.calc(dim.view(doc, "엑셀"), links)) == _money(before)