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>
This commit is contained in:
@@ -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,
|
||||
|
||||
@@ -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
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -450,6 +450,25 @@ function stepsOf(cover: [Step, Set<number>][], outs: { 비목: Bundle }[]): Step
|
||||
});
|
||||
}
|
||||
|
||||
/** 848-7 비목곱 {비목: 식} → {비목: 값} · 없음 = {} · 틀림 = Stop | Blank(수량과 같은 길) */
|
||||
function timesOf(
|
||||
run: Run,
|
||||
line: unknown,
|
||||
where: string,
|
||||
scope: Record<string, Val>,
|
||||
): Bundle | Stop | Blank {
|
||||
const out: Bundle = {};
|
||||
for (const [k, text] of Object.entries(
|
||||
(line as { 비목곱?: Record<string, string> }).비목곱 ?? {},
|
||||
)) {
|
||||
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<string, Rule>) {
|
||||
const lines = doc.금액 ?? [];
|
||||
const cover = coverOf(doc);
|
||||
@@ -485,6 +504,7 @@ function money(run: Run, doc: FormulaDoc, rules: Record<string, Rule>) {
|
||||
? run.expr(text, where, { ...scope, ...(more as Record<string, Val>) })
|
||||
: 1;
|
||||
const price = run.expr(line.단가, where, { ...scope, ...(more as Record<string, Val>) }); // 847-1 굳은 기계 단가
|
||||
const times = timesOf(run, line, where, { ...scope, ...(more as Record<string, Val>) }); // 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<string, Rule>) {
|
||||
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;
|
||||
|
||||
@@ -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<string, unknown>;
|
||||
if (!(EXCEL in link) || String(link.키 ?? "").startsWith("SK-")) return v;
|
||||
return { ...v, 연결: { 갈래: "숫자", 값: link[EXCEL] } };
|
||||
const given = (link.입력 ?? {}) as Record<string, unknown>;
|
||||
const mine = "기계" in given ? { 입력: given, 잠금: [...LOCK] } : {};
|
||||
return { ...v, 연결: { 갈래: "숫자", 값: link[EXCEL], ...mine } as Link };
|
||||
});
|
||||
return { ...doc, 변수: vars };
|
||||
}
|
||||
|
||||
@@ -93,6 +93,7 @@ export const normUnit = (u: unknown): string =>
|
||||
.replace(/[mM]3/g, "㎥") // 848-6 대문자 꼴
|
||||
.replace(/[mM]2/g, "㎡")
|
||||
.replace(/(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])/g, (s) => 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<string, DocVar>,
|
||||
line: { 단가?: unknown },
|
||||
@@ -379,7 +381,7 @@ export function machineOf(
|
||||
for (const name of node ? names(node) : []) {
|
||||
const link = (vars.get(name)?.연결 ?? {}) as { 갈래?: string; 입력?: Record<string, unknown> }; // 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 };
|
||||
|
||||
@@ -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()}
|
||||
|
||||
@@ -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"(?<![A-Za-z])(M|HR|Hr|TON|Ton)(?![A-Za-z])", lambda m: m.group(1).lower(), t)
|
||||
t = re.sub(r"톤(?=/)", "ton", t) # 848-7 「톤/hr」 = 우리 식 「ton/hr」
|
||||
return re.sub(r"/(시간|h|Hr|HR)$", "/hr", t)
|
||||
|
||||
|
||||
@@ -325,12 +326,13 @@ NOT_MACHINE = ("지역", "보정작업", "조종원직종", "계약종별") #
|
||||
|
||||
def _machine_of(run, line: dict):
|
||||
"""금액 줄 단가가 부르는 기계 식 변수 → (작업 기계 입력 식, 변수 이름, 본 기계 칸인지) · 기계 줄 아님 = None ·
|
||||
부착 기계(브레이커 · 집게 입력) 줄 = 그 부착 기계(일하는 기계 — 굴착기 줄과 따로)."""
|
||||
부착 기계(브레이커 · 집게 입력) 줄 = 그 부착 기계(일하는 기계 — 굴착기 줄과 따로) ·
|
||||
숫자 연결 + 입력 「기계」 = 가져온 식 엑셀 판 기계 줄(848-7 — 값은 엑셀 · 기계 정체는 입력)."""
|
||||
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:
|
||||
if link.get("갈래") in ("단가산출", "숫자") 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
|
||||
|
||||
@@ -0,0 +1,362 @@
|
||||
"""848-7 불러오기 — 엑셀 판 기계 정체 · 가져온 값 층 · 비목곱(세 줄 → 기계 한 줄) 지킴 시험.
|
||||
|
||||
① 비목곱 — 한 줄(수량 × 곱 × 단가[비목]) 금액 = 세 줄 금액 · 틀린 곱 = 그 줄 멈춤 · 파이썬 = TS 거울
|
||||
② 엑셀 판 보기(`view` ↔ `importView`) — 기계 줄 = 숫자 + 입력 · 잠금 · 다른 줄 = 숫자만 · 거울 ·
|
||||
그 꼴에서도 작업량 엔진이 기계를 찾음(셈 답 `작업량` 우리 판과 같음 · 금액 = 엑셀 값)
|
||||
③ 「톤/hr」 = 「ton/hr」(파이썬 = TS)
|
||||
④ 세 줄 합침 — 재료비 수량 = 노무비 수량 × 곱이면 한 줄 + 비목곱(금액 그대로) · 꼴이 다르면 세 줄 그대로
|
||||
⑤ 실제 원파일 견본(없으면 skip) — 가져온 값 층(굴착기 · 덤프) · 켜기 전 금액 그대로 · 켜면 Q = 경쟁사 Q ·
|
||||
읽기 답 `위덮음` · 미리 셈에 시간당을 켜면 그 값으로 셈
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy as cp
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from decimal import Decimal as D
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
HERE = Path(__file__).resolve().parent
|
||||
for p in (ROOT, HERE):
|
||||
if str(p) not in sys.path:
|
||||
sys.path.insert(0, str(p))
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402 — scripts 길
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim # noqa: E402
|
||||
from M02_MasterTemplete import M02_Doc_Import_Carry as car # noqa: E402
|
||||
from M02_MasterTemplete import M02_Doc_Import_Shape as shape # noqa: E402
|
||||
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
mw = importlib.import_module("master_doc_work")
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
NO = "0201-0100" # 굴착기(무한궤도) 1.0㎥
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def links():
|
||||
return ml.Links(m01.loaded()[1])
|
||||
|
||||
|
||||
def _var(name, link, unit=""):
|
||||
return {"열쇠": name, "기호": name.split("_")[0], "아래": "_".join(name.split("_")[1:]), "위": "",
|
||||
"이름": name, "단위": unit, "연결": link} # fmt: skip
|
||||
|
||||
|
||||
def _num(name, v):
|
||||
return _var(name, {"갈래": "숫자", "값": D(str(v))})
|
||||
|
||||
|
||||
def _machine(name, col, excel):
|
||||
link = {"갈래": "단가산출", "키": "GC000267", "입력": {"기계": f"'{NO}'", "지역": "'전국평균'"}}
|
||||
return _var(name, {**link, **({"칸": col} if col else {}), "엑셀": excel})
|
||||
|
||||
|
||||
def _three(material_qty):
|
||||
"""노 · 재 · 경 세 줄(같은 기계 · 재료비 수량만 다름) 문서."""
|
||||
vars_ = [_num("q", "26.21"), _num("c", "18.16"), _num("a", "14.11"), _num("b", "1.5"),
|
||||
_machine("P_노무", "노무비", D(55700)), _machine("P_재료", "재료비", D(27932)),
|
||||
_machine("P_경비", "경비", D(19631))] # fmt: skip
|
||||
lines = [{"이름": "노 무 비", "단위": "시간", "비목": "노무비", "수량": "1 ÷ q", "단가": "P_노무"},
|
||||
{"이름": "재 료 비", "단위": "시간", "비목": "재료비", "수량": material_qty, "단가": "P_재료"},
|
||||
{"이름": "경 비", "단위": "시간", "비목": "경비", "수량": "1 ÷ q", "단가": "P_경비"}] # fmt: skip
|
||||
return {
|
||||
"키": "SK-999998",
|
||||
"이름": "덤프",
|
||||
"결과단위": "원/㎥",
|
||||
"변수": vars_,
|
||||
"식": [],
|
||||
"금액": lines,
|
||||
}
|
||||
|
||||
|
||||
def _money(ans):
|
||||
return [ans.get(k) for k in (*COSTS, "계")]
|
||||
|
||||
|
||||
# ── ① · ④ 비목곱 · 세 줄 합침 ─────────────────────────────────────────────
|
||||
def test_세_줄_합침_비목곱_금액_같음(links):
|
||||
doc = _three("1 ÷ q × ((c - a - b) ÷ c)")
|
||||
before = mc.calc(dim.view(doc, "엑셀"), links)
|
||||
merged = cp.deepcopy(doc)
|
||||
shape.machines(merged, {}, {})
|
||||
assert len(merged["금액"]) == 1
|
||||
line = merged["금액"][0]
|
||||
assert line["비목"] == "묶음" and line["수량"] == "1 ÷ q" and line["비목곱"] == {"재료비": "(c - a - b) ÷ c"} # fmt: skip
|
||||
after = mc.calc(dim.view(merged, "엑셀"), links)
|
||||
assert after["셈됨"] and _money(after) == _money(before) == [D(2125), D(149), D(748), D(3022)]
|
||||
assert after["줄"][0]["비목"] == {
|
||||
"노무비": D("2125.1"),
|
||||
"재료비": D("149.6"),
|
||||
"경비": D("748.9"),
|
||||
}
|
||||
|
||||
|
||||
def test_세_줄_꼴_다르면_그대로():
|
||||
doc = _three("1 ÷ c") # 노무비 수량의 인수를 다 담지 않음
|
||||
shape.machines(doc, {}, {})
|
||||
assert len(doc["금액"]) == 3 and not any("비목곱" in x for x in doc["금액"])
|
||||
|
||||
|
||||
def test_비목곱_틀리면_그_줄_멈춤(links):
|
||||
doc = _three("1 ÷ q")
|
||||
shape.machines(doc, {}, {})
|
||||
doc["금액"][0]["비목곱"] = {"재료비": "없는기호 × 2"}
|
||||
ans = mc.calc(dim.view(doc, "엑셀"), links)
|
||||
assert not ans["셈됨"] and "없는기호" in ans["줄"][0]["까닭"]
|
||||
|
||||
|
||||
# ── ② 엑셀 판 기계 정체 ───────────────────────────────────────────────
|
||||
def _excel_doc(links):
|
||||
"""터파기(GC000088) 기계 줄 단가를 엑셀 값 기억 연결로(가져온 식 꼴)."""
|
||||
doc = cp.deepcopy(links.doc("GC000088"))
|
||||
for v in doc["변수"]:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") == "단가산출" and "기계" in (link.get("입력") or {}):
|
||||
link["엑셀"] = {"노무비": D(59020), "재료비": D(43274), "경비": D(29621)}
|
||||
return doc
|
||||
|
||||
|
||||
def test_엑셀_판_기계_줄_숫자_입력_잠금(links):
|
||||
doc = _excel_doc(links)
|
||||
xv = dim.view(doc, "엑셀")
|
||||
got = [v["연결"] for v in xv["변수"] if "엑셀" in (next(x for x in doc["변수"] if x["열쇠"] == v["열쇠"])["연결"])] # fmt: skip
|
||||
assert got and all(x["갈래"] == "숫자" and "기계" in x["입력"] and x["잠금"] == ["값", "조종원", "잡품"] for x in got) # fmt: skip
|
||||
ours = mc.calc(dim.view(doc, "우리"), links)
|
||||
xl = mc.calc(xv, links)
|
||||
wx = [z.get(mw.WORK) for z in xl["줄"] if z.get(mw.WORK)]
|
||||
wu = [z.get(mw.WORK) for z in ours["줄"] if z.get(mw.WORK)]
|
||||
assert wx and [{k: w[k] for k in ("기계", "꼴", "율", "값", "단위")} for w in wx] == [
|
||||
{k: w[k] for k in ("기계", "꼴", "율", "값", "단위")} for w in wu
|
||||
]
|
||||
machine = next(z for z in xl["줄"] if z.get(mw.WORK))
|
||||
assert {k: machine["단가"][k] for k in COSTS} == {
|
||||
"노무비": D(59020),
|
||||
"재료비": D(43274),
|
||||
"경비": D(29621),
|
||||
}
|
||||
|
||||
|
||||
def test_엑셀_판_시간당_켜면_엑셀_값_나누기_우리_Q(links):
|
||||
doc = _excel_doc(links)
|
||||
key = next(z[mw.WORK]["기호"] for z in mc.calc(dim.view(doc, "엑셀"), links)["줄"] if z.get(mw.WORK)) # fmt: skip
|
||||
on = {
|
||||
**dim.view(doc, "엑셀"),
|
||||
"기계덮음": {key: {mw.WORK: {"방식": "시간당", "식": "GC001147"}}},
|
||||
}
|
||||
ans = mc.calc(on, links)
|
||||
line = next(z for z in ans["줄"] if z.get(mw.WORK))
|
||||
assert ans["셈됨"] and line[mw.WORK]["꼴"] == "시간당" and line["단가"]["노무비"] == D(59020)
|
||||
assert float(line["수량"]) == pytest.approx(1 / float(line[mw.WORK]["값"]), rel=1e-9)
|
||||
|
||||
|
||||
# ── ① ② ③ 거울 ─────────────────────────────────────────────────────────
|
||||
_JS = r"""
|
||||
const fs = require("fs"), path = require("path");
|
||||
const ts = require(path.join(process.argv[1], "config", "node_modules", "typescript"));
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) => (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)
|
||||
Reference in New Issue
Block a user