Merge branch 'sub_laptop_2' of C:/Aislo_wt/sub_laptop_2 into main_laptop_1
This commit is contained in:
@@ -4,7 +4,8 @@
|
||||
위 층 고침(`수식.위덮음`)으로 — {단가 기호: {작업량: {식: 우리 작업량 식 키, 변수: {우리 열쇠: 경쟁사 값}}}}.
|
||||
방식은 싣지 않음(방식 없음 = 위 층 방식 → 처음은 경쟁사 식 그대로 「문서 식」 · 사용자가 「시간당 식」 을
|
||||
고르는 순간 경쟁사 값에서 시작 · [원래 값] = 경쟁사 값).
|
||||
짝 = 경쟁사 Q 식 모양 → 우리 식 변수(굴착기 8-2-3 `3600·q·K·f·E/Cm` · 덤프 8-2-8 단일 구간) ·
|
||||
짝 = 경쟁사 Q 식 모양 → 우리 식 변수(굴착기 8-2-3 `3600·q·K·f·E/Cm` · 덤프 8-2-8 구간 셋까지 · 851-2 = 불도저 8-2-1 ·
|
||||
로더 8-2-5 · 롤러 8-2-9 · 콘크리트 믹서 8-2-17 · 표 밖 값 = 851-1 「직접」 칸) ·
|
||||
실은 값으로 우리 식을 셈한 Q 가 경쟁사 Q 와 같은(끝자리 안) 줄만 실음 — 다르면 안 실음(`why` = 줄마다 까닭).
|
||||
경쟁사 자료(단가 · 품목)를 우리 마스터로 옮기지 않음(그 공사의 조건 값을 그 단가산출에만).
|
||||
"""
|
||||
@@ -22,6 +23,12 @@ 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 작업량 식
|
||||
_SECT = (
|
||||
("운반거리", "도로상태", "V1입력", "V2입력"),
|
||||
("구간2거리", "구간2도로상태", "V3입력", "V4입력"),
|
||||
("구간3거리", "구간3도로상태", "V5입력", "V6입력"),
|
||||
) # 덤프 운반 구간 칸(851-1)
|
||||
_ALT = "_딴길" # 후보 속 둘째 길 — 첫 길로 Q 가 어긋날 때 덮어 볼 칸
|
||||
_EXC = {"q": "버킷용량", "qs": "버킷용량", "qo": "버킷용량", "k": "K입력", "f": "f", "e": "E입력",
|
||||
"es": "E입력", "cm": "싸이클입력", "cms": "싸이클입력"} # fmt: skip
|
||||
_RANGE = {
|
||||
@@ -91,15 +98,51 @@ def _excavator(d: _Doc, fs: list) -> dict:
|
||||
return out
|
||||
|
||||
|
||||
def _cut(d: _Doc, node) -> bool:
|
||||
"""변수 정의가 끝수(반올림 · 버림 · 올림 + 자리)로 싸였나."""
|
||||
text = d.defs.get(node[1]) if node[0] == "var" else None
|
||||
try:
|
||||
return text is not None and _inner(md.parse(text))[1] is not None
|
||||
except md.DocError:
|
||||
return False
|
||||
|
||||
|
||||
def _sum_terms(node) -> list:
|
||||
if node[0] == "bin" and node[1] == "+":
|
||||
return [*_sum_terms(node[2]), *_sum_terms(node[3])]
|
||||
return [node]
|
||||
|
||||
|
||||
def _legs(d: _Doc, tree) -> list[tuple]:
|
||||
"""t2 → 구간 [(거리 ㎞, 적재 속도, 공차 속도)] — (Σ l ÷ V) × 60 · × 2 = 같은 속도 왕복 · ÷ 1000 = m · 구간 셋까지."""
|
||||
k, rest = Decimal(1), []
|
||||
for s, n in mw._factors(tree) if tree is not None else []:
|
||||
if n[0] == "num":
|
||||
k = k * n[1] if s > 0 else k / n[1]
|
||||
else:
|
||||
rest.append((s, n))
|
||||
metre = k in (Decimal("0.06"), Decimal("0.12"))
|
||||
k = k * 1000 if metre else k
|
||||
if len(rest) != 1 or rest[0][0] < 0 or k not in (60, 120):
|
||||
raise _No("t2 = (Σ l ÷ V) × 60 꼴 아님")
|
||||
terms = [mw._factors(x) for x in _sum_terms(rest[0][1])]
|
||||
if any([s for s, _ in x] != [1, -1] for x in terms):
|
||||
raise _No("t2 항 l ÷ V 꼴 아님")
|
||||
if k == 120:
|
||||
legs = [(x[0][1], x[1][1], x[1][1]) for x in terms]
|
||||
elif len(terms) % 2 or any(a[0][1] != b[0][1] for a, b in zip(terms[::2], terms[1::2])):
|
||||
raise _No("t2 구간 거리 짝 안 맞음")
|
||||
else:
|
||||
legs = [(a[0][1], a[1][1], b[1][1]) for a, b in zip(terms[::2], terms[1::2])]
|
||||
if not 1 <= len(legs) <= len(_SECT):
|
||||
raise _No(f"t2 구간 {len(legs)} — 우리 칸 {len(_SECT)}")
|
||||
return [(d.value(x) / (1000 if metre else 1), d.value(a), d.value(b)) for x, a, b in legs]
|
||||
|
||||
|
||||
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) → 우리 입력 · 고르기."""
|
||||
t1 = cms·n ÷ (60·Es) · n = q ÷ (버킷 × k) · t2 = 구간 셋까지(`_legs` · 표 밖 속도 = 속도 직접) · 못 읽는 t2 =
|
||||
왕복시간 직접 · t3 · t4 · t5 표 밖 = 직접 칸(851-1) → 우리 입력 · 고르기."""
|
||||
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"]
|
||||
@@ -128,9 +171,12 @@ def _dump(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
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")
|
||||
try:
|
||||
out["덮개"] = _option(tpl, "덮개", lambda r: Decimal(str(r.get("시간"))) == t5, "t5")
|
||||
except _No:
|
||||
out["t5입력"] = t5
|
||||
if "6" in ts and (t6 := d.value(ts["6"])) != 0:
|
||||
if not _row(tpl, "T_시간4^표", {}, t6):
|
||||
if not _row(tpl, "CC000058", {}, t6): # 세륜기 통과시간(t6)
|
||||
raise _No(f"t6 {t6} 표에 없음")
|
||||
out["세륜"] = "함"
|
||||
t1 = d.tree(ts["1"][1])
|
||||
@@ -147,26 +193,39 @@ def _dump(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
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
|
||||
try: # t2 = 구간(거리 · 적재 · 공차 속도) — 표 속도 쌍이면 도로상태 · 아니면 속도 직접(851-1)
|
||||
for (dist, v1, v2), (kd, kr, k1, k2) in zip(_legs(d, d.tree(ts["2"][1])), _SECT):
|
||||
if dist == 0 and kd != _SECT[0][0]:
|
||||
continue # 거리 0 구간 = 안 씀(칸 안 채움)
|
||||
out[kd] = dist
|
||||
try:
|
||||
out[kr] = _option(tpl, "도로상태", lambda r: sorted(Decimal(str(r[k])) for k in ("적재", "공차")) == sorted((v1, v2))) # fmt: skip
|
||||
except _No:
|
||||
out[k1], out[k2] = v1, v2
|
||||
# t2 끝수(반올림 · 버림) = 딴길 t2 통째
|
||||
alt = {"t2입력": d.value(ts["2"])} if _cut(d, ts["2"]) else {}
|
||||
except _No:
|
||||
out["t2입력"] = d.value(ts["2"]) # t2 를 수로 적음 · 꼴 다름 = 왕복시간 직접
|
||||
alt = {}
|
||||
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")
|
||||
soil = next(((s, c) for s in _options(tpl, "적하토질") for c in _options(tpl, "적하조건") if _row(tpl, "CC000055", {"S_적하토질": s, "S_적하조건": c}, t3)), None) # fmt: skip
|
||||
if soil is not None:
|
||||
out["적하토질"], out["적하조건"] = soil
|
||||
else:
|
||||
out["t3입력"] = t3 # 표 밖 = 적하시간 직접
|
||||
try:
|
||||
out["적재장소"] = _option(
|
||||
tpl, "적재장소", lambda r: Decimal(str(r.get("시간"))) == t4, "t4"
|
||||
)
|
||||
except _No:
|
||||
out["t4입력"] = t4
|
||||
if _cut(d, ts["1"]): # t1 끝수 = 딴길 적재시간 직접(적재방법 「직접 입력」)
|
||||
alt |= {"적재방법": "직접 입력", "적재시간입력": d.value(ts["1"])}
|
||||
if alt: # 딴길 = 끝수 낸 t1 · t2 를 경쟁사 값 통째로(t2 통째면 구간 · 속도 칸 뺌)
|
||||
drop = "t2입력" in alt
|
||||
out[_ALT] = {
|
||||
k: v for k, v in out.items() if not (drop and any(k in x for x in _SECT))
|
||||
} | alt
|
||||
return out
|
||||
|
||||
|
||||
@@ -175,9 +234,9 @@ def _options(tpl: dict, key: str) -> list:
|
||||
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), {})
|
||||
def _table(tpl: dict, ref: str) -> tuple[dict, dict]:
|
||||
"""표 번호(CC…) → (표 연결, 그 표) — 그 표를 찾는 첫 변수(직접 칸 막이로 변수 열쇠가 바뀌어도)."""
|
||||
v = next((x for x in tpl.get("변수") or [] if (x.get("연결") or {}).get("표") == ref), {})
|
||||
link = v.get("연결") or {}
|
||||
return link, dc.skc.whole_().get(str(link.get("표")))
|
||||
|
||||
@@ -207,17 +266,139 @@ def _option(tpl: dict, key: str, test, label: str = "") -> str:
|
||||
raise _No(f"{label or key} 표에 없음")
|
||||
|
||||
|
||||
MAP = {EXC: lambda d, fs, tpl: _excavator(d, fs), DUMP: _dump}
|
||||
def _top(fs: list, head: int, ups: int) -> tuple[list, list]:
|
||||
"""Q 인수 → (위 변수, 아래 변수) — 수는 머리 수(60 · 1000 · 3600) 하나 · 아래 변수 하나."""
|
||||
if [(s, n) for s, n in fs if n[0] == "num"] != [(1, ("num", Decimal(head)))]:
|
||||
raise _No(f"{head} 꼴 아님")
|
||||
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) != ups or len(down) != 1 or down[0][0] != "var":
|
||||
raise _No("Q 꼴 아님")
|
||||
return up, down
|
||||
|
||||
|
||||
def _by_role(d: _Doc, nodes: list, roles: dict) -> dict:
|
||||
"""변수 마디 → {우리 열쇠: 값} — 이름 머리(밑줄 · 수 뗌 · 작은 글자)로 · 겹치거나 모르면 못 실음."""
|
||||
out: dict[str, Any] = {}
|
||||
for n in nodes:
|
||||
k = roles.get(_role(n[1]))
|
||||
if k is None or k in out:
|
||||
raise _No(f"변수 이름 낯섦({md.text_of(n)})")
|
||||
out[k] = d.value(n)
|
||||
return out
|
||||
|
||||
|
||||
def _const(ref: str, head: str) -> Decimal:
|
||||
"""산정식 상수 표(ref) 「항목」 이 head 로 시작하는 줄 값."""
|
||||
rows = (dc.skc.whole_().get(ref) or {}).get("줄") or []
|
||||
return next(Decimal(str(r["값"])) for r in rows if str(r.get("항목") or "").startswith(head))
|
||||
|
||||
|
||||
def _dozer(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
"""불도저 8-2-1 — 60·q·f·E/Cm · q = q° × e(수 하나 · 끝수 = q° 직접 · e 1) · Cm = L ÷ V1 + L ÷ V2 + t(표)."""
|
||||
up, down = _top(fs, 60, 3)
|
||||
load = next((n for n in up if _role(n[1]) not in ("f", "e", "es")), None)
|
||||
out = _by_role(d, [n for n in up if n is not load], {"f": "f", "e": "E입력", "es": "E입력"})
|
||||
if len(out) != 2 or load is None:
|
||||
raise _No("q · f · E 못 가림")
|
||||
text = d.defs.get(load[1])
|
||||
tree, places = _inner(md.parse(text)) if text else (None, None)
|
||||
qf = mw._factors(tree) if tree is not None else []
|
||||
if places is None and [s for s, _ in qf] == [1, 1]:
|
||||
out["q0입력"], out["e입력"] = d.value(qf[0][1]), d.value(qf[1][1])
|
||||
else:
|
||||
out["q0입력"], out["e입력"] = d.value(load), Decimal(1)
|
||||
cm = d.tree(down[0][1])
|
||||
legs, rest = [], []
|
||||
for x in _sum_terms(cm) if cm is not None else []:
|
||||
f2 = mw._factors(x)
|
||||
if [s for s, _ in f2] == [1, -1]:
|
||||
legs.append(f2)
|
||||
else:
|
||||
rest.append(x)
|
||||
if len(legs) != 2 or len(rest) != 1 or legs[0][0][1] != legs[1][0][1]:
|
||||
raise _No("Cm = L ÷ V1 + L ÷ V2 + t 꼴 아님")
|
||||
if (t := d.value(rest[0])) != _const("CC000039", "기어 변속시간"):
|
||||
raise _No(f"기어 변속시간 t {t} 표 밖")
|
||||
out |= {"운반거리": d.value(legs[0][0][1]), "V1입력": d.value(legs[0][1][1]), "V2입력": d.value(legs[1][1][1])} # fmt: skip
|
||||
return out
|
||||
|
||||
|
||||
def _loader(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
"""로더 8-2-5 — 3600·q·K·f·E/Cm · Cm = m × l + t1 + t2(표 14 초) → 버킷용량 · K · f · E · m · 주행거리 · t1 직접."""
|
||||
up, down = _top(fs, 3600, 4)
|
||||
roles = {"q": "버킷용량", "qs": "버킷용량", "qo": "버킷용량", "k": "K입력", "f": "f", "e": "E입력", "es": "E입력"} # fmt: skip
|
||||
out = _by_role(d, up, roles)
|
||||
cm = d.tree(down[0][1])
|
||||
terms = _sum_terms(cm) if cm is not None else []
|
||||
prod = [x for x in terms if [s for s, _ in mw._factors(x)] == [1, 1]]
|
||||
rest = [x for x in terms if not any(x is y for y in prod)]
|
||||
if len(out) != 4 or len(prod) != 1 or len(rest) != 2:
|
||||
raise _No("Cm = m × l + t1 + t2 꼴 아님")
|
||||
(_, m), (_, ln) = mw._factors(prod[0])
|
||||
t1, t2 = sorted(rest, key=lambda x: x[0] == "var" and x[1].lower().startswith("t2"))
|
||||
if (v := d.value(t2)) != _const("CC000052", "기본시간"):
|
||||
raise _No(f"기본시간 t2 {v} 표 밖")
|
||||
return out | {"m입력": d.value(m), "주행거리": d.value(ln), "t1입력": d.value(t1)}
|
||||
|
||||
|
||||
def _roller(volume: bool):
|
||||
"""롤러 8-2-9 — 1000·V·W(·D·f)·E/N → 다짐속도 · 유효폭 직접 · E · (두께 · f) · 다짐횟수."""
|
||||
|
||||
def parse(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
if not volume: # 면적 식에 f = 1 을 곱해 둔 꼴(값 같음) — f 뗌
|
||||
fs = [
|
||||
(s, n)
|
||||
for s, n in fs
|
||||
if not (n[0] == "var" and _role(n[1]) == "f" and d.value(n) == 1)
|
||||
]
|
||||
up, down = _top(fs, 1000, 5 if volume else 3)
|
||||
roles = {
|
||||
"v": "V입력",
|
||||
"w": "W입력",
|
||||
"e": "E입력",
|
||||
**({"d": "두께", "f": "f"} if volume else {}),
|
||||
}
|
||||
out = _by_role(d, up, roles)
|
||||
if _role(down[0][1]) != "n":
|
||||
raise _No("다짐횟수 N 아님")
|
||||
return out | {"다짐횟수": d.value(down[0])}
|
||||
|
||||
return parse
|
||||
|
||||
|
||||
def _mixer(d: _Doc, fs: list, tpl: dict) -> dict:
|
||||
"""콘크리트 믹서 8-2-17 — 60 ÷ t × q × E(t = 표 작업시간) → 믹서용량 · E."""
|
||||
if [(s, n) for s, n in fs if n[0] == "num" and s > 0] != [(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) != 2 or len(down) != 1:
|
||||
raise _No("Q 꼴 아님")
|
||||
if (t := d.value(down[0])) != _const("CC000388", "재료투입"):
|
||||
raise _No(f"작업시간 t {t} 표 밖")
|
||||
return _by_role(d, up, {"q": "믹서용량", "e": "E입력"})
|
||||
|
||||
|
||||
MAP = {
|
||||
EXC: lambda d, fs, tpl: _excavator(d, fs),
|
||||
DUMP: _dump,
|
||||
"GC001144": _dozer,
|
||||
"GC001150": _loader,
|
||||
"GC001157": _roller(True),
|
||||
"GC001158": _roller(False),
|
||||
"GC001170": _mixer,
|
||||
} # 경쟁사 Q 식 모양 → 우리 작업량 식 변수(851-2 = 불도저 · 로더 · 롤러 · 믹서 · 덤프 구간 여럿)
|
||||
|
||||
|
||||
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 · 끝자리) · 까닭."""
|
||||
def _candidates(doc: dict, ans: dict, links: Any) -> tuple[dict, dict, dict, dict]:
|
||||
"""줄마다 (단가 기호 → 덮음 후보) · (기호 → 경쟁사 Q · 끝자리) · 까닭 · 딴길 변수."""
|
||||
d = _Doc(doc, ans.get("값") or {})
|
||||
cand, comp, why = {}, {}, {}
|
||||
cand, comp, why, alts = {}, {}, {}, {}
|
||||
for z in ans.get("줄") or []:
|
||||
w = z.get(mw.WORK) or {}
|
||||
sym = str(w.get("기호") or "")
|
||||
@@ -250,12 +431,34 @@ def _candidates(doc: dict, ans: dict, links: Any) -> tuple[dict, dict, dict]:
|
||||
why[sym] = f"{key} {k} {got[k]} 범위 밖"
|
||||
break
|
||||
else:
|
||||
if _ALT in got:
|
||||
alts[sym] = {k: _plain(v) for k, v in got.pop(_ALT).items()}
|
||||
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
|
||||
return cand, comp, why, alts
|
||||
|
||||
|
||||
def _check(mine: dict, links: Any, cand: dict, comp: dict, why: dict) -> tuple[dict, list]:
|
||||
"""후보를 시간당 식으로 켜 셈 — (Q 가 경쟁사 Q 끝자리 안인 줄, 어긋난 줄) · 까닭 고침."""
|
||||
on = {k: {mw.WORK: {"방식": mw.HOURLY}} for k in cand}
|
||||
test = mc.calc(mine, links, cover=mcv.merge_layers(cand, on)) if cand else {}
|
||||
got, miss = {}, []
|
||||
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]
|
||||
why.pop(sym, None)
|
||||
else:
|
||||
miss.append(sym)
|
||||
why[sym] = f"우리 식 Q {q} ≠ 경쟁사 Q {want}" + (f" — {w.get('까닭')}" if w.get("까닭") else "") # fmt: skip
|
||||
return got, miss
|
||||
|
||||
|
||||
def carried(doc: dict, whole: Any = None) -> tuple[dict, dict]:
|
||||
@@ -270,24 +473,13 @@ def carried(doc: dict, whole: Any = None) -> tuple[dict, dict]:
|
||||
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 {}
|
||||
cand, comp, why, alts = _candidates(mine, ans, links)
|
||||
got, miss = _check(mine, links, cand, comp, why)
|
||||
retry = {k: {mw.WORK: {**cand[k][mw.WORK], "변수": alts[k]}} for k in miss if k in alts}
|
||||
if retry: # 딴길(덤프 t2 통째) — 경쟁사 t2 끝수로 첫 길 Q 가 어긋난 줄
|
||||
got |= _check(mine, links, retry, comp, why)[0]
|
||||
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)
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,515 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""작업량 식 직접 칸 · 덤프 운반 구간 여럿(PLAN 851-1 · 요구 893) — 옛 로직 JSON 고침(한 번 돌림).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_직접칸_851_1.py
|
||||
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
|
||||
- 고르기(표 값)로만 정해지는 수 = 그 중간 줄(또는 식 속 그 찾기)을 「만약(X입력 > 0, X입력, 표)」 로 —
|
||||
비우거나 0 = 고르기 값 · 넣으면 그 값이 이김 · 입력 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 ·
|
||||
보이는 이름 = 「○○ 직접」(변수표 이름) · 열쇠 = 「X입력」 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1](지금 E입력 과 같음).
|
||||
- 지금 「0 = 표」 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 …) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」.
|
||||
- 덤프트럭(8-2-8) t2 = 구간 셋(구간 1 = 지금 운반거리 · 도로상태 · 구간2거리 · 구간3거리 = 0 이면 안 탐) ·
|
||||
구간마다 적재 · 공차 주행속도 직접(원문 3 [주] 「주행속도를 측정하여 사용할 수 있다」) · t2 · t3 · t4 · t5 직접.
|
||||
- 직접 칸을 더한 식을 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음) = 새 입력 0 · 구간 도로상태 = 구간 1 값.
|
||||
- 목록 276 변수 중 뺀 것(값 하나 · 이미 직접 칸이 덮음 · 글 값) = 851-1 보고 표.
|
||||
- 이미 돌렸으면(덤프 V1 있음) 멈춤.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
ROOT = MASTER.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
|
||||
C08 = "로직_건설품셈_08장_건설기계.json"
|
||||
F10 = "로직_산림품셈_10장_자재․장비_운반.json"
|
||||
SELF = "로직_자체.json"
|
||||
DUMP = "GC001155"
|
||||
EFF = [
|
||||
0,
|
||||
1,
|
||||
] # 작업효율 직접 칸 범위(지금 E입력 과 같음 · 원문 표 값이 1 넘는 효율 표(준설선 · 임목파쇄기)는 범위 없음)
|
||||
|
||||
# (식, 중간 줄 | 결과, 감쌀 글(None = 줄 통째), 열쇠, 보이는 이름, 자리(이 입력 아래), 단위, 범위) · 기호 = 이름 규칙
|
||||
OPS: list[tuple] = [
|
||||
("GC001144", "q0", None, "q0입력", "삽날용량 직접", "급수", "㎥", None),
|
||||
("GC001144", "e", None, "e입력", "운반거리계수 직접", "거리구분", "", None),
|
||||
("GC001144", "V1", None, "V1입력", "전진속도 직접", "전진단", "m/분", None),
|
||||
("GC001144", "V2", None, "V2입력", "후진속도 직접", "후진단", "m/분", None),
|
||||
("GC001146", "An", None, "An입력", "리핑 단면적 직접", "발톱수", "㎡", None),
|
||||
("GC001149", "d", None, "d입력", "굴착심도계수 직접", "굴착심도", "", None),
|
||||
("GC001150", "m", None, "m입력", "주행계수 직접", "기종", "sec/m", None),
|
||||
(
|
||||
"GC001150",
|
||||
"cm",
|
||||
"t1",
|
||||
"t1입력",
|
||||
"적재시간 직접",
|
||||
"적재조건",
|
||||
"sec",
|
||||
None,
|
||||
), # 줄 t1 = 표 한 마디(열쇠 겹침 피함)
|
||||
("GC001150", "K", None, "K입력", "버킷계수 직접", "K조건", "", None),
|
||||
("GC001152", "K", None, "K입력", "적재계수 직접", "토질상태", "", None),
|
||||
("GC001152", "V1", None, "V1입력", "적재 주행속도 직접", "도로상태", "m/분", None),
|
||||
("GC001152", "V2", None, "V2입력", "공차 주행속도 직접", "V1입력", "m/분", None),
|
||||
("GC001152", "t", None, "t입력", "적토·사토·기어변속시간 직접", "푸쉬도우저", "분", None),
|
||||
*[
|
||||
op
|
||||
for key in ("GC001153", "GC001154")
|
||||
for op in (
|
||||
(key, "V1", None, "V1입력", "작업속도 직접", "현장조건", "㎞/hr", None),
|
||||
(key, "V2", None, "V2입력", "후진·회송속도 직접", "되돌림조건", "㎞/hr", None),
|
||||
(key, "t", None, "t입력", "방향변환시간 직접", "t작업", "분", None),
|
||||
)
|
||||
],
|
||||
("GC001154", "l", None, "l입력", "블레이드 유효길이 직접", "l작업", "m", None),
|
||||
*[
|
||||
op
|
||||
for key in ("GC001157", "GC001158")
|
||||
for op in (
|
||||
(key, "W", None, "W입력", "유효다짐폭 직접", "규격", "m", None),
|
||||
(key, "V", None, "V입력", "다짐속도 직접", "다짐층", "㎞/hr", None),
|
||||
)
|
||||
],
|
||||
("GC001160", "결과", None, "Q입력", "생산능력 직접", "혼합재", "ton/hr", None),
|
||||
("GC001162", "결과", None, "Q입력", "생산능력 직접", "작업조건", "ton/hr", None),
|
||||
(
|
||||
"GC001163",
|
||||
"결과",
|
||||
"찾기(CC000375, 출구간격=출구간격, 규격=규격).생산능력",
|
||||
"q입력",
|
||||
"생산능력 직접",
|
||||
"출구간격",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001163", "효율", None, "E효율입력", "효율 직접", "작업조건", "%", None),
|
||||
(
|
||||
"GC001164",
|
||||
"결과",
|
||||
"찾기(CC000383, 규격=규격, 출구간격=출구간격).생산능력",
|
||||
"q입력",
|
||||
"생산능력 직접",
|
||||
"출구간격",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001164", "E", None, "E입력", "작업효율 직접", "작업조건", "", EFF),
|
||||
(
|
||||
"GC001165",
|
||||
"통과능력",
|
||||
None,
|
||||
"q통과입력",
|
||||
"통과능력 직접",
|
||||
"조합방법",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001165", "A", None, "A입력", "택수 계수(A) 직접", "택의수", "", None),
|
||||
("GC001165", "B", None, "B입력", "작은 골재량 계수(B) 직접", "B골재량", "", None),
|
||||
("GC001165", "C", None, "C입력", "스크린 규격 계수(C) 직접", "C규격", "", None),
|
||||
("GC001165", "D", None, "D입력", "큰 골재량 계수(D) 직접", "D골재량", "", None),
|
||||
("GC001165", "E", None, "E입력", "재료 계수(E) 직접", "재료", "", None),
|
||||
("GC001168", "결과", None, "Q입력", "작업량 직접", "구분", "㎡/h", None),
|
||||
("GC001171", "q", None, "q입력", "실용량 직접", "슬럼프", "㎥", None),
|
||||
("GC001171", "cm", None, "cm입력", "싸이클시간 직접", "싸이클", "분", None),
|
||||
("GC001173", "W", None, "W입력", "적재용량 직접", "규격", "㎥", None),
|
||||
("GC001174", "n", None, "n입력", "대차수 직접", "기관차", "대", None),
|
||||
("GC001174", "t2", None, "t2입력", "적재적하시간 직접", "재료", "분", None),
|
||||
("GC001175", "t", None, "t입력", "적재적하시간 직접", "종류", "분", None),
|
||||
("GC001175", "V1", None, "V1입력", "적재시 속도 직접", "작업로", "m/분", None),
|
||||
("GC001175", "V2", None, "V2입력", "공차시 속도 직접", "V1입력", "m/분", None),
|
||||
("GC001176", "β", None, "β입력", "해머계수 직접", "해머", "", None),
|
||||
("GC001176", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
|
||||
("GC001176", "F", None, "F입력", "작업계수 직접", "현장", "", None),
|
||||
("GC001176", "tw", None, "tw입력", "용접시간 직접", "관두께", "분", None),
|
||||
("GC001177", "β", None, "β입력", "해머계수 직접", "해머", "", None),
|
||||
("GC001177", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
|
||||
(
|
||||
"GC001177",
|
||||
"Ts",
|
||||
"만약(파일경 <= 300, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 250·300㎜').값, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 350∼500㎜').값)",
|
||||
"Ts입력",
|
||||
"세우기·위치조정 시간 직접",
|
||||
"파일경",
|
||||
"분/회",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001177", "F", None, "F입력", "작업계수 직접", "현장", "", None),
|
||||
("GC001178", "β", None, "β입력", "판두께계수 직접", "판두께", "", None),
|
||||
("GC001178", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
|
||||
("GC001179", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
|
||||
("GC001180", "Ts", None, "Ts입력", "준비시간 직접", "작업", "분", None),
|
||||
(
|
||||
"GC001180",
|
||||
"F",
|
||||
"찾기(CC000423, 작업=작업).F0",
|
||||
"F0입력",
|
||||
"작업계수 F0 직접",
|
||||
"Ts입력",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001180", "k", None, "k입력", "해머계수 직접", "파일", "", None),
|
||||
("GC001180", "r1", None, "r1입력", "사질토 단위시간 직접", "사질N", "분/m", None),
|
||||
("GC001180", "r2", None, "r2입력", "점질토 단위시간 직접", "점질N", "분/m", None),
|
||||
("GC001181", "α", None, "α입력", "α 직접", "해머", "", None),
|
||||
("GC001181", "K", None, "K입력", "K 직접", "α입력", "", None),
|
||||
("GC001181", "γ", None, "γ입력", "γ 직접", "작업", "", None),
|
||||
(
|
||||
"GC001181",
|
||||
"F",
|
||||
"찾기(CC000430, 작업='항타').F0",
|
||||
"F0입력",
|
||||
"작업계수 F0 직접",
|
||||
"γ입력",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001181", "F인발", "찾기(CC000430, 작업='항발').F0", "F0입력", "", "", "", None), # 같은 칸
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000466, 구분=E1).E",
|
||||
"E1입력",
|
||||
"흙의 두께 효율 직접",
|
||||
"E1",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000468, 구분=E2).E",
|
||||
"E2입력",
|
||||
"평면형상 효율 직접",
|
||||
"E2",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000470, 구분=E3).E",
|
||||
"E3입력",
|
||||
"단면형상 효율 직접",
|
||||
"E3",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000472, 구분=E4).E",
|
||||
"E4입력",
|
||||
"해상조건 효율 직접",
|
||||
"E4",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"cm",
|
||||
"찾기(CC000476, 버킷용량=버킷용량).싸이클시간",
|
||||
"싸이클입력",
|
||||
"기준 싸이클시간 직접",
|
||||
"버킷용량",
|
||||
"sec",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"E",
|
||||
"찾기(CC000477, 구분=E1).E",
|
||||
"E1입력",
|
||||
"흙의 두께 효율 직접",
|
||||
"E1",
|
||||
"",
|
||||
EFF,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"E",
|
||||
"찾기(CC000479, 구분=E2).E",
|
||||
"E2입력",
|
||||
"해상조건 효율 직접",
|
||||
"E2",
|
||||
"",
|
||||
EFF,
|
||||
), # fmt: skip
|
||||
("GC001188", "S", None, "S입력", "쇄암면적 직접", "중추중량", "㎡", None),
|
||||
("GC001188", "n", None, "n입력", "낙추횟수 직접", "S입력", "회", None),
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000486, 규격=규격).K",
|
||||
"K입력",
|
||||
"능력계수 직접",
|
||||
"규격",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000487, 스크린=스크린).S",
|
||||
"S입력",
|
||||
"스크린계수 직접",
|
||||
"스크린",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000488, 작업조건=작업조건).E",
|
||||
"E입력",
|
||||
"작업효율 직접",
|
||||
"작업조건",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001190", "q", None, "q입력", "준설량 직접", "배송거리", "㎥/hr", None),
|
||||
("GC001190", "E", None, "E입력", "작업효율 직접", "유속", "", EFF),
|
||||
("GF000148", "f", None, "f입력", "체적환산계수 직접", "재료", "", None),
|
||||
("GF000148", "E", None, "E입력", "작업효율 직접", "f입력", "", EFF),
|
||||
]
|
||||
|
||||
# 지금 「0 = 표」 직접 칸 — 보이는 이름만(열쇠 · 기호 그대로)
|
||||
RENAME = {
|
||||
"E입력": "작업효율 직접",
|
||||
"싸이클입력": "싸이클시간 직접",
|
||||
"K입력": "버킷계수 직접",
|
||||
"α입력": "토질계수 직접",
|
||||
"f입력": "체적환산계수 직접",
|
||||
"k입력": "버킷계수 직접",
|
||||
"하역시간입력": "하역시간 직접",
|
||||
"대기시간입력": "대기시간 직접",
|
||||
"배출시간입력": "배출시간 직접",
|
||||
"적재시간입력": "적재시간 직접",
|
||||
}
|
||||
RENAME_ROW = {("GC001186", "q입력"): "준설능력 직접"}
|
||||
ROAD = "찾기(CC000054, 도로상태={road}).{col}"
|
||||
|
||||
|
||||
def _load(name: str) -> tuple[str, dict]:
|
||||
text = (MASTER / name).read_text(encoding="utf-8")
|
||||
return text, json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
|
||||
|
||||
def _save(name: str, text: str, before: dict, after: dict) -> None:
|
||||
from M01_MasterData import M01_MasterData_Store_Shape as shape
|
||||
|
||||
out = shape.keep_shape(text, before, after, "줄") or shape.dump(after)
|
||||
assert json.loads(out, parse_float=Decimal, parse_int=Decimal) == after
|
||||
(MASTER / name).write_text(out, encoding="utf-8", newline="\n")
|
||||
|
||||
|
||||
def _guard(key: str, body: str) -> str:
|
||||
return f"만약({key} > 0, {key}, {body})"
|
||||
|
||||
|
||||
def _is_guard(row: dict, name: str) -> bool:
|
||||
return any(re.search(rf"만약\({re.escape(name)} > 0, {re.escape(name)}, ", s["식"]) for s in row.get("중간") or []) # fmt: skip
|
||||
|
||||
|
||||
def _add_input(row: dict, spec: dict, after: str) -> None:
|
||||
ins = row["입력"]
|
||||
at = next(i for i, x in enumerate(ins) if x["이름"] == after)
|
||||
ins.insert(at + 1, spec)
|
||||
if isinstance(row.get("시험입력"), dict):
|
||||
row["시험입력"][spec["이름"]] = spec.pop("_시험", Decimal(0))
|
||||
spec.pop("_시험", None)
|
||||
|
||||
|
||||
def _table(row: dict, key: str, name: str, pick: bool = False) -> None:
|
||||
"""변수표 — 기호 · 아래 = 이름 규칙(`master_symbol.rule` · 같은 열쇠 = 같은 기호) · 이름 = 보이는 이름."""
|
||||
import master_symbol as msym
|
||||
|
||||
sign, sub = msym.rule(key, "변수", "고름" if pick else "")[:2]
|
||||
row.setdefault("변수표", {})[key] = {"기호": sign, "아래": sub, "이름": name}
|
||||
|
||||
|
||||
def apply_op(row: dict, op: tuple) -> None:
|
||||
_, step, sub, key, name, after, unit, rng = op
|
||||
target = row["결과"] if step == "결과" else next(s for s in row["중간"] if s["이름"] == step)
|
||||
text = target["식"]
|
||||
if sub is None:
|
||||
target["식"] = _guard(key, text)
|
||||
else:
|
||||
assert sub in text, (row["키"], step, sub)
|
||||
target["식"] = text.replace(sub, _guard(key, sub))
|
||||
if not name: # 같은 칸을 둘째 줄에도
|
||||
return
|
||||
assert key not in {x["이름"] for x in row["입력"]} | {x["이름"] for x in row.get("중간") or []}, key # fmt: skip
|
||||
spec = {
|
||||
"이름": key,
|
||||
"설명": f"{name.removesuffix(' 직접')} — 직접 넣을 때 · 0 이면 고르기(표) 값",
|
||||
}
|
||||
if unit:
|
||||
spec["단위"] = unit
|
||||
if rng:
|
||||
spec["범위"] = [Decimal(str(x)) for x in rng]
|
||||
spec["출처"] = row.get("출처") or ""
|
||||
_add_input(row, spec, after)
|
||||
_table(row, key, name)
|
||||
|
||||
|
||||
def rename(row: dict, docs: dict) -> int:
|
||||
"""지금 직접 칸 보이는 이름 — 기호 · 아래는 지금 수식 문서 그대로 옮겨 적음."""
|
||||
n = 0
|
||||
doc = docs.get(str(row["키"])) or {}
|
||||
for spec in row.get("입력") or []:
|
||||
key = spec["이름"]
|
||||
name = RENAME_ROW.get((row["키"], key)) or RENAME.get(key)
|
||||
if not name or not (_is_guard(row, key) or key == "적재시간입력"):
|
||||
continue
|
||||
now = next((v for v in doc.get("변수") or [] if v.get("열쇠") == key), None)
|
||||
assert now, (row["키"], key)
|
||||
look = row.setdefault("변수표", {}).setdefault(key, {})
|
||||
look |= {"기호": now["기호"], "아래": now.get("아래") or "", "이름": name}
|
||||
if now.get("위"):
|
||||
look["위"] = now["위"]
|
||||
n += 1
|
||||
return n
|
||||
|
||||
|
||||
def dump(row: dict) -> None:
|
||||
"""덤프 t2 = 구간 셋 · 속도 직접 · t2 ~ t5 직접."""
|
||||
mids = row["중간"]
|
||||
names = [m["이름"] for m in mids]
|
||||
assert "V1" not in names
|
||||
road = next(i for i in row["입력"] if i["이름"] == "도로상태")
|
||||
base_road = row["시험입력"]["도로상태"]
|
||||
speeds = []
|
||||
after = "도로상태"
|
||||
for n in (1, 2, 3):
|
||||
dist, rd = ("운반거리", "도로상태") if n == 1 else (f"구간{n}거리", f"구간{n}도로상태")
|
||||
tag = "" if n == 1 else f" {n}"
|
||||
if n > 1:
|
||||
_add_input(row, {"이름": dist, "설명": f"운반 구간 {n} 거리(편도) — 0 이면 안 씀", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
|
||||
_table(row, dist, f"운반거리{tag}")
|
||||
_add_input(row, {"이름": rd, "설명": f"운반 구간 {n} 도로 상태", "고르기": list(road["고르기"]), "출처": "건설품셈 공통 8-2-8 3", "_시험": base_road}, dist) # fmt: skip
|
||||
_table(row, rd, f"도로상태{tag}", pick=True)
|
||||
after = rd
|
||||
for k, col, what in ((2 * n - 1, "적재", "적재속도"), (2 * n, "공차", "공차속도")):
|
||||
key = f"V{k}입력"
|
||||
_add_input(row, {"이름": key, "설명": f"구간 {n} {col}시 평균주행속도를 직접 넣을 때(측정값 · 3 [주]) — 0 이면 도로상태 표", "단위": "㎞/hr", "출처": "건설품셈 공통 8-2-8 3"}, after) # fmt: skip
|
||||
_table(row, key, f"{what}{tag} 직접")
|
||||
after = key
|
||||
speeds.append({"이름": f"V{k}", "식": _guard(key, ROAD.format(road=rd, col=col)), "단위": "㎞/hr"}) # fmt: skip
|
||||
row["변수표"][f"V{k}"] = {"기호": "V", "아래": str(k), "이름": f"{col}시 평균주행속도{tag}"} # fmt: skip
|
||||
_add_input(row, {"이름": "t2입력", "설명": "왕복시간(t2)을 직접 넣을 때 — 0 이면 구간 거리 · 속도로 셈", "단위": "분", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
|
||||
_table(row, "t2입력", "왕복시간(t2) 직접")
|
||||
legs = ["운반거리 / V1 * 60 + 운반거리 / V2 * 60"] + [
|
||||
f"만약(구간{n}거리 > 0, 구간{n}거리 / V{2 * n - 1} * 60 + 구간{n}거리 / V{2 * n} * 60, 0)" for n in (2, 3)
|
||||
] # fmt: skip
|
||||
t2 = next(m for m in mids if m["이름"] == "t2")
|
||||
t2["식"] = _guard("t2입력", " + ".join(legs))
|
||||
at = names.index("t2")
|
||||
mids[at:at] = speeds
|
||||
for step, key, name, after_ in (
|
||||
("t3", "t3입력", "적하시간(t3) 직접", "적하조건"),
|
||||
("t4", "t4입력", "진입시간(t4) 직접", "적재장소"),
|
||||
("t5", "t5입력", "덮개시간(t5) 직접", "덮개"),
|
||||
):
|
||||
apply_op(row, (DUMP, step, None, key, name, after_, "분", None))
|
||||
row["비고"] = (
|
||||
str(row["비고"])
|
||||
+ " · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표"
|
||||
)
|
||||
|
||||
|
||||
def _call_fill(text: str, key: str, extra: str) -> str:
|
||||
pat = re.compile(rf"로직\({key},([^()]*(?:\([^()]*\)[^()]*)*)\)")
|
||||
return pat.sub(lambda m: f"로직({key},{m[1]}{extra})", text)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
import master_doc_link as ml
|
||||
|
||||
docs = ml.load_all()
|
||||
text, before = _load(C08)
|
||||
after = copy.deepcopy(before)
|
||||
rows = {str(r["키"]): r for r in after["줄"]}
|
||||
if any(m["이름"] == "V1" for m in rows[DUMP]["중간"]):
|
||||
print("이미 돌림 — 멈춤")
|
||||
return
|
||||
renamed = sum(rename(r, docs) for r in rows.values() if (r.get("부품") or {}).get("갈래") == "작업량 틀") # fmt: skip
|
||||
added: dict[str, list[str]] = {}
|
||||
for op in OPS:
|
||||
if op[0] in rows:
|
||||
apply_op(rows[op[0]], op)
|
||||
if op[4]:
|
||||
added.setdefault(op[0], []).append(op[3])
|
||||
dump(rows[DUMP])
|
||||
for k, keys in added.items():
|
||||
rows[k]["비고"] = (
|
||||
str(rows[k].get("비고") or "") + f" · 직접 칸 {' · '.join(keys)} 0 = 표(851-1)"
|
||||
)
|
||||
_save(C08, text, before, after)
|
||||
print("08장 — 이름만", renamed, "· 직접 칸", sum(map(len, added.values())), "식", len(added))
|
||||
|
||||
text, before = _load(F10)
|
||||
after = copy.deepcopy(before)
|
||||
rows = {str(r["키"]): r for r in after["줄"]}
|
||||
for op in OPS:
|
||||
if op[0] in rows:
|
||||
apply_op(rows[op[0]], op)
|
||||
_save(F10, text, before, after)
|
||||
print("10장 — GF000148 직접 칸 f입력 · E입력")
|
||||
|
||||
road = "'교차가 힘든 산간지도로 및 제방 등의 도로'"
|
||||
dump_extra = (
|
||||
", V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태=__R__, V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태=__R__,"
|
||||
" V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0"
|
||||
)
|
||||
extra = {k: "".join(f", {x}=0" for x in keys) for k, keys in added.items()}
|
||||
extra |= {"GF000148": ", f입력=0, E입력=0", DUMP: dump_extra}
|
||||
for name in sorted(p.name for p in MASTER.glob("로직_*.json")):
|
||||
text, before = _load(name)
|
||||
raw = json.dumps(before, ensure_ascii=False, default=str)
|
||||
hits = [k for k in extra if f"로직({k}," in raw or f"로직({k})" in raw]
|
||||
if not hits:
|
||||
continue
|
||||
after = copy.deepcopy(before)
|
||||
|
||||
def walk(x):
|
||||
if isinstance(x, dict):
|
||||
for k, v in x.items():
|
||||
if isinstance(v, str):
|
||||
for key in hits:
|
||||
first = extra[key].split("=")[0].lstrip(", ")
|
||||
if f"로직({key}" in v and f"{first}=" not in v:
|
||||
assert f"로직({key})" not in v, (
|
||||
name,
|
||||
key,
|
||||
) # 입력 없는 부름 — 손으로
|
||||
m = re.search(r"도로상태=('[^']*'|[^,()]+)", v)
|
||||
v = _call_fill(
|
||||
v, key, extra[key].replace("__R__", m[1] if m else road)
|
||||
)
|
||||
x[k] = v
|
||||
else:
|
||||
walk(v)
|
||||
elif isinstance(x, list):
|
||||
for v in x:
|
||||
walk(v)
|
||||
|
||||
walk(after)
|
||||
_save(name, text, before, after)
|
||||
print("부름 새 입력 0 —", name, " · ".join(hits))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -683,12 +683,16 @@
|
||||
"개정": [2026],
|
||||
"소유": "공용",
|
||||
"비고": "해석: 파쇄암·발파암의 E 는 「암석」 줄",
|
||||
"입력": [{ "이름": "재료", "고르기": ["토사", "파쇄암", "발파암"] }],
|
||||
"입력": [
|
||||
{ "이름": "재료", "고르기": ["토사", "파쇄암", "발파암"] },
|
||||
{ "이름": "f입력", "설명": "체적환산계수 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②" },
|
||||
{ "이름": "E입력", "설명": "작업효율 — 직접 넣을 때 · 0 이면 고르기(표) 값", "범위": [0, 1], "출처": "산림품셈 10-11 주②" }
|
||||
],
|
||||
"중간": [
|
||||
{ "이름": "q", "식": "찾기(QF000335, 구분='q0').값 * 찾기(QF000335, 구분='e').값", "출처": "산림품셈 10-11 주② 「q=3.2×e」" },
|
||||
{ "이름": "f", "식": "찾기(QF000335, 구분='f', 세부=재료).식" },
|
||||
{ "이름": "f", "식": "만약(f입력 > 0, f입력, 찾기(QF000335, 구분='f', 세부=재료).식)" },
|
||||
{ "이름": "E세부", "식": "만약(재료 == '토사', '토사', '암석')" },
|
||||
{ "이름": "E", "식": "찾기(QF000335, 구분='E', 세부=E세부).값" },
|
||||
{ "이름": "E", "식": "만약(E입력 > 0, E입력, 찾기(QF000335, 구분='E', 세부=E세부).값)" },
|
||||
{
|
||||
"이름": "Cm",
|
||||
"식": "찾기(QF000335, 구분='L').값 / 찾기(QF000335, 구분='V1').값 + 찾기(QF000335, 구분='L').값 / 찾기(QF000335, 구분='V2').값 + 찾기(QF000335, 구분='t').값",
|
||||
@@ -697,7 +701,15 @@
|
||||
],
|
||||
"결과": { "식": "반올림(60 * q * f * E / Cm, 3)", "출처": "건설품셈 공통 8-1-4 주①" },
|
||||
"끝수": "소수 3자리 사사오입(건설품셈 공통 8-1-4 주①)",
|
||||
"변수표": { "f": { "이름": "체적환산계수" }, "E": { "이름": "작업효율" }, "Cm": { "이름": "1회 싸이클시간" }, "재료": { "기호": "S", "아래": "재료" }, "E세부": { "기호": "E", "아래": "세부" } }
|
||||
"변수표": {
|
||||
"f": { "이름": "체적환산계수" },
|
||||
"E": { "이름": "작업효율" },
|
||||
"Cm": { "이름": "1회 싸이클시간" },
|
||||
"재료": { "기호": "S", "아래": "재료" },
|
||||
"E세부": { "기호": "E", "아래": "세부" },
|
||||
"f입력": { "기호": "f", "아래": "입력", "이름": "체적환산계수 직접" },
|
||||
"E입력": { "기호": "E", "아래": "입력", "이름": "작업효율 직접" }
|
||||
}
|
||||
},
|
||||
{
|
||||
"키": "GF000149",
|
||||
@@ -719,7 +731,7 @@
|
||||
"출처": "건설품셈 공통 8-1-7 5"
|
||||
}
|
||||
],
|
||||
"중간": [{ "이름": "작업량", "식": "로직(GF000148, 재료=재료)" }, { "이름": "보정작업", "식": "만약(재료 == '토사', '해당 없음', '암석작업(연암・보통암・경암)')", "출처": "건설품셈 공통 8-1-7 1" }],
|
||||
"중간": [{ "이름": "작업량", "식": "로직(GF000148, 재료=재료, f입력=0, E입력=0)" }, { "이름": "보정작업", "식": "만약(재료 == '토사', '해당 없음', '암석작업(연암・보통암・경암)')", "출처": "건설품셈 공통 8-1-7 1" }],
|
||||
"호표": [{ "종류": "로직", "요소": "로직(GC000269, 기계=기계, 지역=지역, 보정작업=보정작업)", "이름": "불도저(무한궤도)", "단위": "시간", "수량": "1 / 작업량" }],
|
||||
"덧줄": [],
|
||||
"끝수": null,
|
||||
|
||||
@@ -61,7 +61,7 @@
|
||||
{ "이름": "덤프T", "식": "만약(덤프 == '0602-0045', 4.5, 만약(덤프 == '0602-0060', 6, 만약(덤프 == '0602-0080', 8, 2.5)))", "단위": "ton" },
|
||||
{
|
||||
"이름": "Q2",
|
||||
"식": "로직(GC001155, 적재용량=덤프T, 단위중량=쌓기무게, 체적변화율=1, f=1, 운반거리=운반거리, 도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', 적하토질='모래, 역, 호박돌', 적하조건=적하조건, 적재장소='적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때', 덮개='해당 없음', 세륜='안 함', 적재방법='적재기계', 적재싸이클=cm, 적재버킷=q, 버킷계수=K, 적재효율=E, 인력종류='석재류', 적재시간입력=0, E입력=0)",
|
||||
"식": "로직(GC001155, 적재용량=덤프T, 단위중량=쌓기무게, 체적변화율=1, f=1, 운반거리=운반거리, 도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', 적하토질='모래, 역, 호박돌', 적하조건=적하조건, 적재장소='적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때', 덮개='해당 없음', 세륜='안 함', 적재방법='적재기계', 적재싸이클=cm, 적재버킷=q, 버킷계수=K, 적재효율=E, 인력종류='석재류', 적재시간입력=0, E입력=0, V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0)",
|
||||
"단위": "㎡/hr",
|
||||
"출처": "건설품셈 공통 8-2-8"
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -611,14 +611,18 @@
|
||||
"결과": "Q",
|
||||
"변수": [
|
||||
{"열쇠": "재료", "기호": "S", "아래": "재료", "위": "", "이름": "재료", "단위": "", "연결": {"갈래": "선택", "목록": ["토사", "파쇄암", "발파암"], "값": "토사"}},
|
||||
{"열쇠": "f입력", "기호": "f", "아래": "입력", "위": "", "이름": "체적환산계수 직접", "단위": "", "설명": "체적환산계수 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②", "연결": {"갈래": "입력", "값": 0}},
|
||||
{"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "작업효율 직접", "단위": "", "설명": "작업효율 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
|
||||
{"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "q", "단위": "㎥", "출처": "산림품셈 10-11 주② 「q=3.2×e」", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'f'", "세부": "S_재료"}, "칸": "식"}},
|
||||
{"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "E세부", "기호": "E", "아래": "세부", "위": "", "이름": "E세부", "단위": "", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "E", "기호": "E", "아래": "", "위": "", "이름": "작업효율", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'E'", "세부": "E_세부"}, "칸": "값"}},
|
||||
{"열쇠": "E", "기호": "E", "아래": "", "위": "", "이름": "작업효율", "단위": "", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "Cm", "기호": "Cm", "아래": "", "위": "", "이름": "1회 싸이클시간", "단위": "분", "출처": "산림품셈 10-11 주② 「㎝=L/V1+L/V2+0.25」", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "결과", "기호": "Q", "아래": "", "위": "", "이름": "결과", "단위": "㎥/hr", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "q0^표", "기호": "q0", "아래": "", "위": "표", "이름": "불도저 운반 q0", "단위": "㎥", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'q0'"}, "칸": "값"}},
|
||||
{"열쇠": "e^표", "기호": "e", "아래": "", "위": "표", "이름": "불도저 운반 e", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'e'"}, "칸": "값"}},
|
||||
{"열쇠": "Q_식^표", "기호": "Q", "아래": "식", "위": "표", "이름": "불도저 운반.식", "단위": "글", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'f'", "세부": "S_재료"}, "칸": "식"}},
|
||||
{"열쇠": "Q_토사^표", "기호": "Q", "아래": "토사", "위": "표", "이름": "불도저 운반 토사", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'E'", "세부": "E_세부"}, "칸": "값"}},
|
||||
{"열쇠": "L^표", "기호": "L", "아래": "", "위": "표", "이름": "불도저 운반 L", "단위": "m", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'L'"}, "칸": "값"}},
|
||||
{"열쇠": "V1^표", "기호": "V1", "아래": "", "위": "표", "이름": "불도저 운반 V1", "단위": "m/분", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'V1'"}, "칸": "값"}},
|
||||
{"열쇠": "V2^표", "기호": "V2", "아래": "", "위": "표", "이름": "불도저 운반 V2", "단위": "m/분", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'V2'"}, "칸": "값"}},
|
||||
@@ -626,7 +630,9 @@
|
||||
],
|
||||
"식": [
|
||||
{"기호": "q", "식": "q0^표 × e^표"},
|
||||
{"기호": "f", "식": "만약(f_입력 > 0, f_입력, Q_식^표)"},
|
||||
{"기호": "E_세부", "식": "만약(S_재료 == '토사', '토사', '암석')"},
|
||||
{"기호": "E", "식": "만약(E_입력 > 0, E_입력, Q_토사^표)"},
|
||||
{"기호": "Cm", "식": "L^표 ÷ V1^표 + L^표 ÷ V2^표 + t^표"},
|
||||
{"기호": "Q", "식": "반올림(60 × q × f × E ÷ Cm, 3)"}
|
||||
],
|
||||
@@ -648,7 +654,7 @@
|
||||
{"열쇠": "재료", "기호": "S", "아래": "재료", "위": "", "이름": "재료", "단위": "", "연결": {"갈래": "선택", "목록": ["토사", "파쇄암", "발파암"], "값": "토사"}},
|
||||
{"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032"], "값": "0101-0007"}},
|
||||
{"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
|
||||
{"열쇠": "작업량", "기호": "Q", "아래": "작업", "위": "", "이름": "작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GF000148", "입력": {"재료": "S_재료"}}},
|
||||
{"열쇠": "작업량", "기호": "Q", "아래": "작업", "위": "", "이름": "작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GF000148", "입력": {"재료": "S_재료", "f입력": "0", "E입력": "0"}}},
|
||||
{"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_기계", "지역": "S_지역", "보정작업": "S_보정작업"}}}
|
||||
],
|
||||
|
||||
@@ -29,7 +29,7 @@
|
||||
{"열쇠": "cm", "기호": "cm", "아래": "", "위": "", "이름": "1회 싸이클시간", "단위": "sec", "연결": {"갈래": "표", "표": "CC000045", "조건": {"규격": "S_규격구분", "각도": "θ_선회"}, "칸": "시간"}},
|
||||
{"열쇠": "Q", "기호": "Q", "아래": "", "위": "", "이름": "시간당 작업량", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-3", "연결": {"갈래": "단가산출", "키": "GC001147", "입력": {"버킷용량": "q", "규격구분": "S_규격구분", "선회각도": "θ_선회", "버킷조건": "'버킷에 넣기 어렵고 불규칙한 공극이 생기는 것으로서 발파 또는 리퍼작업 등에 의하여 얻어진 암과 파쇄암, 호박돌, 역 등인 경우'", "현장조건": "'흐트러진 상태'", "등급": "S_등급", "토질명": "'파쇄암'", "E보정": "'해당 없음'", "협소현장": "'해당 없음'", "f": "1", "E입력": "0", "싸이클입력": "0", "K입력": "0"}}},
|
||||
{"열쇠": "덤프T", "기호": "Q", "아래": "덤프T", "위": "", "이름": "덤프T", "단위": "ton", "연결": {"갈래": "식"}},
|
||||
{"열쇠": "Q2", "기호": "Q", "아래": "2", "위": "", "이름": "Q2", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "단가산출", "키": "GC001155", "입력": {"적재용량": "Q_덤프T", "단위중량": "W_쌓기", "체적변화율": "1", "f": "1", "운반거리": "L_운반", "도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "적하토질": "'모래, 역, 호박돌'", "적하조건": "S_적하조건", "적재장소": "'적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때'", "덮개": "'해당 없음'", "세륜": "'안 함'", "적재방법": "'적재기계'", "적재싸이클": "cm", "적재버킷": "q", "버킷계수": "K", "적재효율": "E", "인력종류": "'석재류'", "적재시간입력": "0", "E입력": "0"}}},
|
||||
{"열쇠": "Q2", "기호": "Q", "아래": "2", "위": "", "이름": "Q2", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "단가산출", "키": "GC001155", "입력": {"적재용량": "Q_덤프T", "단위중량": "W_쌓기", "체적변화율": "1", "f": "1", "운반거리": "L_운반", "도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "적하토질": "'모래, 역, 호박돌'", "적하조건": "S_적하조건", "적재장소": "'적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때'", "덮개": "'해당 없음'", "세륜": "'안 함'", "적재방법": "'적재기계'", "적재싸이클": "cm", "적재버킷": "q", "버킷계수": "K", "적재효율": "E", "인력종류": "'석재류'", "적재시간입력": "0", "E입력": "0", "V1입력": "0", "V2입력": "0", "구간2거리": "0", "구간2도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "V3입력": "0", "V4입력": "0", "구간3거리": "0", "구간3도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "V5입력": "0", "V6입력": "0", "t2입력": "0", "t3입력": "0", "t4입력": "0", "t5입력": "0"}}},
|
||||
{"열쇠": "P_굴착기무한궤", "기호": "P", "아래": "굴착기무한궤", "위": "", "이름": "굴착기(무한궤도) 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000267", "입력": {"기계": "S_굴착기", "지역": "S_지역", "보정작업": "S_보정작업"}}},
|
||||
{"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_덤프", "지역": "S_지역", "보정작업": "S_보정작업"}}}
|
||||
],
|
||||
|
||||
@@ -94,6 +94,13 @@ BASE_DUMP = {
|
||||
"인력종류": "토사류",
|
||||
"적재시간입력": 0,
|
||||
"E입력": 0,
|
||||
# 851-1 — 구간 2 · 3(거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표(옛 엔진은 입력을 다 받음)
|
||||
**{f"V{n}입력": 0 for n in range(1, 7)},
|
||||
**{f"t{n}입력": 0 for n in range(2, 6)},
|
||||
"구간2거리": 0,
|
||||
"구간2도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
|
||||
"구간3거리": 0,
|
||||
"구간3도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
|
||||
}
|
||||
|
||||
|
||||
@@ -178,10 +185,24 @@ def test_롤러_임목파쇄_브레이커(whole):
|
||||
"E기계": "불도저",
|
||||
"현장조건": "보통",
|
||||
"E입력": 0,
|
||||
"W입력": 0, # 851-1 직접 칸 0 = 표
|
||||
"V입력": 0,
|
||||
}
|
||||
assert mf.run(whole, ROLL_A, roll)["결과"] == D("2280.000") # 북부청임도 단산27
|
||||
assert (
|
||||
mf.run(whole, CHIP, {"규격": "93.25㎾", "스크린": "75㎜", "작업조건": "보통"})["결과"] == 6
|
||||
mf.run(
|
||||
whole,
|
||||
CHIP,
|
||||
{
|
||||
"규격": "93.25㎾",
|
||||
"스크린": "75㎜",
|
||||
"작업조건": "보통",
|
||||
"K입력": 0,
|
||||
"S입력": 0,
|
||||
"E입력": 0,
|
||||
},
|
||||
)["결과"]
|
||||
== 6
|
||||
) # 동부청영월 111
|
||||
# 북부청임도 단산75~78 — 엑셀 Q = 구조물 헐기 표 범위 평균치(적용방법 ②)
|
||||
rows = {r["구분"]: r for r in whole.get("CC000065")["줄"]}
|
||||
@@ -241,8 +262,15 @@ def test_가드_칸_자동값(whole):
|
||||
value = got.get("결과", got.get("계"))
|
||||
assert value >= 0, row["키"]
|
||||
spec = {i["이름"]: i for i in row["입력"]}
|
||||
direct = {
|
||||
k
|
||||
for k, v in (row.get("변수표") or {}).items()
|
||||
if str(v.get("이름") or "").endswith(" 직접")
|
||||
}
|
||||
for name in GUARD.findall(" ".join(ma._texts(row))):
|
||||
if "범위" in spec.get(name, {}):
|
||||
if (
|
||||
"범위" in spec.get(name, {}) or name in direct
|
||||
): # 851-1 「○○ 직접」 = 표 밖 값도 받는 칸 · 견본 = 표
|
||||
assert auto[name] == 0, (row["키"], name)
|
||||
elif name in spec:
|
||||
loose.add(name)
|
||||
|
||||
@@ -132,8 +132,12 @@ def test_왼쪽_제어_구역_방식_변수_칸(gc88):
|
||||
assert not any(t.strip().startswith("버킷용량") for t in day) # 일당 = 변수 칸 없음
|
||||
assert "버킷용량 q=[1]㎥" in [t.strip() for t in hour]
|
||||
assert "체적환산계수 f=[0.7]" in [t.strip() for t in hour]
|
||||
e = next(t.strip() for t in hour if t.strip().startswith("E입력"))
|
||||
assert e.startswith("E입력=[0.8]원래 값") # 고친 칸 = [원래 값] 단추(848-3 「고침」 글 → 테두리)
|
||||
e = next(
|
||||
t.strip() for t in hour if t.strip().startswith("작업효율 직접")
|
||||
) # 851-1 E입력 보이는 이름
|
||||
assert e.startswith(
|
||||
"작업효율 직접=[0.8]원래 값"
|
||||
) # 고친 칸 = [원래 값] 단추(848-3 「고침」 글 → 테두리)
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
|
||||
@@ -0,0 +1,256 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""PLAN 851-1(요구 893) — 작업량 식 「○○ 직접」 칸 · 덤프트럭 운반 구간 여럿.
|
||||
|
||||
① 직접 칸 전수 — 작업량 틀 문서의 「직접」 칸마다: 고르기(표) 값과 같은 수를 넣으면 결과 같음 ·
|
||||
다른 수를 넣으면 그 자리에 그 수를 박아 넣은 식과 같은 결과(그 수만큼) · 비우면(0) 지금 값
|
||||
② 덤프트럭 8-2-8 손셈(원문 식) — 구간 하나(봉화 109 견본 Q 26.209) · 둘 · 셋(속도 직접) · t2 · t3 ~ t5 직접
|
||||
③ 덤프 문서 화면 셈(TS) = 서버 셈 — 구간 셋 · 속도 직접
|
||||
④ 지금 직접 칸(E입력 · 싸이클입력 · K입력 …) — 열쇠 그대로 · 보이는 이름 「○○ 직접」
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
from decimal import ROUND_HALF_UP
|
||||
from decimal import Decimal as D
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from resources.tester import test_802_1_formula_doc as t1
|
||||
|
||||
md = t1.md
|
||||
mc = t1.mc
|
||||
ml = t1.ml
|
||||
DUMP = "GC001155"
|
||||
ROAD_HARD = "교차가 힘든 산간지도로 및 제방 등의 도로" # 원문 3 표 적재 10 · 공차 15
|
||||
ROAD_WORK = "2차로 이상의 공사용도로" # 30 · 35
|
||||
ROAD_EASY = "교차가 가능한 산간지도로 및 제방도로, 미포장도로" # 15 · 20
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def world():
|
||||
docs = ml.load_all()
|
||||
return docs, ml.Links(m01.loaded()[1], docs)
|
||||
|
||||
|
||||
def _q(links, doc, given=None):
|
||||
got = mc.calc(doc, links, given or {})
|
||||
assert got["셈됨"], [m["글"] for m in got["표지"]]
|
||||
return got
|
||||
|
||||
|
||||
def _guard(doc: dict, xid: str) -> tuple[int, str, str]:
|
||||
"""식 줄에서 「만약(X > 0, X, 안)」 → (줄 차례, 통째 글, 안 글)."""
|
||||
head = f"만약({xid} > 0, {xid}, "
|
||||
for i, line in enumerate(doc.get("식") or []):
|
||||
text = str(line["식"])
|
||||
at = text.find(head)
|
||||
if at < 0:
|
||||
continue
|
||||
depth, end = 0, None
|
||||
for j in range(at + len("만약"), len(text)):
|
||||
depth += {"(": 1, ")": -1}.get(text[j], 0)
|
||||
if depth == 0:
|
||||
end = j
|
||||
break
|
||||
return i, text[at : end + 1], text[at + len(head) : end]
|
||||
raise AssertionError(f"{doc['키']} {xid} 막이 없음")
|
||||
|
||||
|
||||
def _directs(docs: dict) -> list[tuple[str, dict]]:
|
||||
return [
|
||||
(k, v)
|
||||
for k, d in sorted(docs.items())
|
||||
if (d.get("부품") or {}).get("갈래") == "작업량 틀"
|
||||
for v in d.get("변수") or []
|
||||
if str(v.get("이름") or "").endswith(" 직접")
|
||||
and (v.get("연결") or {}).get("갈래") == "입력"
|
||||
]
|
||||
|
||||
|
||||
def _plain(v: D) -> str:
|
||||
return mc.plain_text(v)
|
||||
|
||||
|
||||
# ① 직접 칸 전수 ─────────────────────────────────────────────────────────
|
||||
def test_직접칸_전수(world):
|
||||
docs, links = world
|
||||
rows = _directs(docs)
|
||||
assert len({k for k, _ in rows}) >= 40 and len(rows) >= 120, len(rows)
|
||||
moved, still = 0, []
|
||||
for key, var in rows:
|
||||
doc = docs[key]
|
||||
xid = md.var_id(var)
|
||||
assert (var["연결"].get("값") or 0) == 0, (key, xid) # 비운 기본 = 고르기 값
|
||||
base = _q(links, doc)
|
||||
q0 = base["결과"]
|
||||
if var["열쇠"] == "적재시간입력": # 덤프 t1 — 적재방법 「직접 입력」 갈래(막이 아님)
|
||||
t1_ = base["값"]["t_1"]
|
||||
assert _q(links, doc, {"적재방법": "직접 입력", "적재시간입력": t1_})["결과"] == q0
|
||||
moved += 1
|
||||
continue
|
||||
at, whole, inner = _guard(doc, xid)
|
||||
line = doc["식"][at]
|
||||
probe = copy.deepcopy(doc) # 고르기 값 = 그 줄을 막이 안 글로만 셈한 값
|
||||
probe["식"][at]["식"] = inner
|
||||
v0 = mc.calc(probe, links)["값"].get(line["기호"])
|
||||
assert isinstance(v0, D), (key, xid, v0)
|
||||
if v0 > 0:
|
||||
assert _q(links, doc, {var["열쇠"]: v0})["결과"] == q0, (key, xid)
|
||||
high = D(str((var["연결"].get("범위") or [0, None])[1] or 0))
|
||||
v1 = v0 * D("1.25") if v0 > 0 else D(1)
|
||||
if high and v1 > high:
|
||||
v1 = v0 * D("0.8")
|
||||
pinned = copy.deepcopy(doc)
|
||||
pinned["식"][at]["식"] = str(line["식"]).replace(whole, f"({_plain(v1)})")
|
||||
want = _q(links, pinned)["결과"]
|
||||
got = _q(links, doc, {var["열쇠"]: v1})["결과"]
|
||||
assert got == want, (key, xid, v1, got, want)
|
||||
if got != q0:
|
||||
moved += 1
|
||||
else:
|
||||
still.append(f"{key} {var['열쇠']}")
|
||||
# 결과가 안 움직이는 것 = 기본 값에서 그 갈래를 안 탐(그레이더 왕복 작업 = 후진 속도 안 씀 · 덤프 구간 2 · 3 거리 0)
|
||||
gated = {"GC001153 V2입력", "GC001154 V2입력", *(f"{DUMP} V{n}입력" for n in (3, 4, 5, 6))}
|
||||
assert set(still) <= gated and moved == len(rows) - len(still), still
|
||||
|
||||
|
||||
def test_직접칸_범위_밖_멈춤(world):
|
||||
docs, links = world
|
||||
got = mc.calc(docs["GC001164"], links, {"E입력": D("1.5")})
|
||||
assert not got["셈됨"] and any("범위" in m["글"] for m in got["표지"])
|
||||
|
||||
|
||||
# ② 덤프트럭 손셈 ─────────────────────────────────────────────────────────
|
||||
def _r(v: D, n: int) -> D:
|
||||
return v.quantize(D(1).scaleb(-n), rounding=ROUND_HALF_UP)
|
||||
|
||||
|
||||
def _hand(legs, t3, t4, t5=D(0), t6=D(0), t2=None, *, T=D(15), rt=D("1.7"), L=D("1.175"), f=D("0.85"),
|
||||
cms=D(20), qs=D("0.7"), k=D("0.7"), es=D("0.5"), E=D("0.9")): # fmt: skip
|
||||
"""원문 8-2-8 — q = T/γt·L · n = q/(q·k) · t1 = cms·n/(60·Es) · t2 = Σ 거리/속도 × 60 · Q = 60·q·f·E/cm."""
|
||||
q = T / rt * L
|
||||
n = _r(q / (qs * k), 2)
|
||||
t1 = cms * n / (60 * es)
|
||||
if t2 is None:
|
||||
t2 = sum((d / v1 * 60 + d / v2 * 60 for d, v1, v2 in legs), D(0))
|
||||
cm = _r(t1 + t2 + t3 + t4 + t5 + t6, 3)
|
||||
return _r(60 * q * f * E / cm, 3)
|
||||
|
||||
|
||||
BONGHWA = { # STC 봉화 109 덤프 15톤(조사 889b B4 · 848-7 견본 Q 26.209)
|
||||
"적재용량": D(15),
|
||||
"단위중량": D("1.7"),
|
||||
"체적변화율": D("1.175"),
|
||||
"f": D("0.85"),
|
||||
"운반거리": D("0.185"),
|
||||
"도로상태": ROAD_HARD,
|
||||
"적하토질": "점질토, 점토",
|
||||
"적하조건": "불량",
|
||||
"적재장소": "적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때",
|
||||
"덮개": "해당 없음",
|
||||
"세륜": "안 함",
|
||||
"적재방법": "적재기계",
|
||||
"적재싸이클": D(20),
|
||||
"적재버킷": D("0.7"),
|
||||
"버킷계수": D("0.7"),
|
||||
"적재효율": D("0.5"),
|
||||
"E입력": D("0.9"),
|
||||
}
|
||||
CASES = [
|
||||
("구간 하나", {}, dict(legs=[(D("0.185"), D(10), D(15))], t3=D("1.5"), t4=D("0.7"))),
|
||||
(
|
||||
"구간 둘",
|
||||
{"구간2거리": D("0.5"), "구간2도로상태": ROAD_WORK},
|
||||
dict(legs=[(D("0.185"), D(10), D(15)), (D("0.5"), D(30), D(35))], t3=D("1.5"), t4=D("0.7")),
|
||||
),
|
||||
(
|
||||
"구간 셋 · 셋째 속도 직접",
|
||||
{
|
||||
"구간2거리": D("0.5"),
|
||||
"구간2도로상태": ROAD_WORK,
|
||||
"구간3거리": D("1.2"),
|
||||
"구간3도로상태": ROAD_EASY,
|
||||
"V5입력": D(22),
|
||||
"V6입력": D(28),
|
||||
},
|
||||
dict(
|
||||
legs=[(D("0.185"), D(10), D(15)), (D("0.5"), D(30), D(35)), (D("1.2"), D(22), D(28))],
|
||||
t3=D("1.5"),
|
||||
t4=D("0.7"),
|
||||
),
|
||||
), # fmt: skip
|
||||
(
|
||||
"구간 하나 속도 직접 · 둘째 도로상태",
|
||||
{
|
||||
"V1입력": D(12),
|
||||
"V2입력": D(18),
|
||||
"구간2거리": D("0.3"),
|
||||
"구간2도로상태": ROAD_EASY,
|
||||
"V4입력": D(25),
|
||||
},
|
||||
dict(legs=[(D("0.185"), D(12), D(18)), (D("0.3"), D(15), D(25))], t3=D("1.5"), t4=D("0.7")),
|
||||
), # fmt: skip
|
||||
("t2 직접", {"t2입력": D("3.35")}, dict(legs=[], t2=D("3.35"), t3=D("1.5"), t4=D("0.7"))),
|
||||
(
|
||||
"t3 · t4 · t5 직접(표 밖 0.9)",
|
||||
{"t3입력": D("0.95"), "t4입력": D("0.9"), "t5입력": D("0.5")},
|
||||
dict(legs=[(D("0.185"), D(10), D(15))], t3=D("0.95"), t4=D("0.9"), t5=D("0.5")),
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("label", "more", "hand"), CASES, ids=[c[0] for c in CASES])
|
||||
def test_덤프_손셈(world, label, more, hand):
|
||||
docs, links = world
|
||||
got = _q(links, docs[DUMP], {**BONGHWA, **more})["결과"]
|
||||
assert got == _hand(**hand), (label, got, _hand(**hand))
|
||||
if label == "구간 하나":
|
||||
assert got == D("26.209")
|
||||
|
||||
|
||||
def test_덤프_구간_거리0_안탐(world):
|
||||
"""구간 2 · 3 거리 0 = 그 구간 도로상태 · 속도 직접을 바꿔도 결과 같음(구간 하나 = 지금 값)."""
|
||||
docs, links = world
|
||||
one = _q(links, docs[DUMP], BONGHWA)["결과"]
|
||||
other = {"구간2도로상태": ROAD_WORK, "V3입력": D(5), "구간3도로상태": ROAD_EASY, "V6입력": D(3)}
|
||||
assert _q(links, docs[DUMP], {**BONGHWA, **other})["결과"] == one
|
||||
|
||||
|
||||
# ③ 화면 셈(TS) = 서버 셈 ─────────────────────────────────────────────────
|
||||
def test_덤프_TS_거울(world):
|
||||
docs, links = world
|
||||
rec = t1.Rec(links)
|
||||
py, payload = {}, {}
|
||||
for label, more, _ in CASES:
|
||||
doc = copy.deepcopy(docs[DUMP])
|
||||
given = {**BONGHWA, **more}
|
||||
for v in doc["변수"]:
|
||||
if v["열쇠"] in given:
|
||||
v["연결"]["값"] = given[v["열쇠"]]
|
||||
doc["키"] = f"{DUMP}:{label}"
|
||||
py[doc["키"]] = mc.calc(doc, rec)["결과"]
|
||||
payload[doc["키"]] = doc
|
||||
out = t1._ts({"문서들": payload, "대상": list(payload), "기록": rec.log})
|
||||
for k, want in py.items():
|
||||
assert float(out["답"][k]["결과"]) == pytest.approx(float(want), abs=1e-9), k
|
||||
|
||||
|
||||
# ④ 지금 직접 칸 — 열쇠 그대로 · 이름만 ─────────────────────────────────────
|
||||
@pytest.mark.parametrize(
|
||||
("key", "field", "name"),
|
||||
[
|
||||
("GC001147", "E입력", "작업효율 직접"),
|
||||
("GC001147", "싸이클입력", "싸이클시간 직접"),
|
||||
("GC001147", "K입력", "버킷계수 직접"),
|
||||
("GC001176", "α입력", "토질계수 직접"),
|
||||
("GC001187", "f입력", "체적환산계수 직접"),
|
||||
("GC001186", "q입력", "준설능력 직접"),
|
||||
("GC001155", "적재시간입력", "적재시간 직접"),
|
||||
],
|
||||
)
|
||||
def test_지금_직접칸_이름(world, key, field, name):
|
||||
docs, _ = world
|
||||
var = next(v for v in docs[key]["변수"] if v["열쇠"] == field)
|
||||
assert var["이름"] == name
|
||||
@@ -0,0 +1,119 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""PLAN 851-2(요구 893) — 가져온 값 층을 851-1 직접 칸으로 넓힘.
|
||||
|
||||
경쟁사 블록마다: 실은 값 = 경쟁사 식에 적힌 수 · 켜기 전(방식 없음) 금액 그대로 · 「시간당 식」 을 켜면
|
||||
우리 식 Q = 경쟁사 Q(경쟁사 끝자리 안).
|
||||
① 덤프 구간 둘 · 셋(봉화 118 · main 1442) · 같은 속도 왕복 × 2 꼴(임도용역 45 = 표 밖 속도 → 속도 직접) ·
|
||||
t2 를 수로 적음(임도용역 50 = 왕복시간 직접)
|
||||
② 불도저 · 로더 · 롤러(토량 · 면적) · 콘크리트 믹서
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
from decimal import Decimal as D
|
||||
|
||||
import pytest
|
||||
|
||||
from resources.tester import test_848_7_import_carry as t7
|
||||
|
||||
dim, car = t7.dim, t7.car
|
||||
mw = importlib.import_module("master_doc_work")
|
||||
|
||||
|
||||
def _carry(kind, tag, no):
|
||||
sk, doc, ours = t7._block(kind, tag, no)
|
||||
got, why = car.carried(doc)
|
||||
return sk, doc, ours, got, why
|
||||
|
||||
|
||||
def _on_q(doc, sk, got) -> dict:
|
||||
"""시간당 식을 켠 줄마다 (우리 Q, 경쟁사 Q)."""
|
||||
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}}
|
||||
out = {}
|
||||
for z in dim.run(on, sk, upper=got)["줄"]:
|
||||
w = z.get(mw.WORK) or {}
|
||||
if w.get("기호") in got and not w.get(mw.FOLLOW):
|
||||
assert w["꼴"] == "시간당", w
|
||||
out[w["기호"]] = (w["값"], comp[w["기호"]])
|
||||
return out
|
||||
|
||||
|
||||
CASES = [
|
||||
# (원천, 파일, 블록, 기호, 우리 식, 실린 값 일부)
|
||||
(
|
||||
"STC",
|
||||
"봉화",
|
||||
118,
|
||||
"P_덤프트럭",
|
||||
"GC001155",
|
||||
{
|
||||
"운반거리": 36.1,
|
||||
"구간2거리": 1.7,
|
||||
"구간2도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
|
||||
},
|
||||
), # fmt: skip
|
||||
(
|
||||
"EST",
|
||||
"main",
|
||||
1442,
|
||||
"P_덤프트럭",
|
||||
"GC001155",
|
||||
{
|
||||
"운반거리": 0.3,
|
||||
"구간2거리": 16.7,
|
||||
"구간3거리": 1.0,
|
||||
"구간3도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
|
||||
},
|
||||
), # fmt: skip
|
||||
(
|
||||
"EST",
|
||||
"임도용역",
|
||||
45,
|
||||
"P_덤프트럭",
|
||||
"GC001155",
|
||||
{"운반거리": 29.5, "V1입력": 30.0, "V2입력": 30.0},
|
||||
), # fmt: skip
|
||||
("EST", "임도용역", 50, "P_덤프트럭", "GC001155", {}),
|
||||
("EST", "main", 46, "P_로우더", "GC001150", {}),
|
||||
("EST", "main", 193, "P_진동로울러", "GC001157", {}),
|
||||
(
|
||||
"EST",
|
||||
"main",
|
||||
266,
|
||||
"P_진동로울러",
|
||||
"GC001158",
|
||||
{"V입력": 1.0, "W입력": 0.8, "E입력": 0.6, "다짐횟수": 4.0},
|
||||
), # fmt: skip
|
||||
("EST", "main", 463, "P_콘크리트믹서", "GC001170", {}),
|
||||
("STC", "동부청영월", 2032, "P_불도저", "GC001144", {}),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(("kind", "tag", "no", "sym", "form", "vals"), CASES, ids=[f"{c[1]}{c[2]}-{c[4]}" for c in CASES]) # fmt: skip
|
||||
def test_실음_켜기전_그대로_켜면_Q_같음(kind, tag, no, sym, form, vals):
|
||||
sk, doc, ours, got, why = _carry(kind, tag, no)
|
||||
assert sym in got, why.get(sym)
|
||||
w = got[sym][mw.WORK]
|
||||
assert "방식" not in w and w["식"] == form
|
||||
assert {k: w["변수"].get(k) for k in vals} == vals
|
||||
for s in (sk, ours): # 방식 없는 위 층 = 금액 그대로
|
||||
assert t7._money(dim.run(doc, s, upper=got)) == t7._money(dim.run(doc, s))
|
||||
for k, (q, want) in _on_q(doc, sk, got).items():
|
||||
assert abs(q - want) <= D("0.01"), (k, q, want)
|
||||
|
||||
|
||||
def test_구간0_칸_안_채움_t2수_왕복시간_직접():
|
||||
_, _, _, got, _ = _carry("EST", "임도용역", 45)
|
||||
v = got["P_덤프트럭"][mw.WORK]["변수"]
|
||||
assert not {"구간2거리", "구간3거리", "V3입력", "V5입력"} & set(v) # 거리 0 구간 = 칸 안 채움
|
||||
_, _, _, got, _ = _carry("EST", "임도용역", 50)
|
||||
v = got["P_덤프트럭"][mw.WORK]["변수"]
|
||||
assert v.get("t2입력", 0) > 0 and "운반거리" not in v # t2 를 수로 적음 = 왕복시간 직접
|
||||
|
||||
|
||||
def test_못_실음_끝수_까닭():
|
||||
"""경쟁사 Cm 을 2 자리로 끊은 불도저 = 우리 식(3 자리) Q 끝자리 넘음 — 안 실음 · 까닭 남김."""
|
||||
_, _, _, got, why = _carry("EST", "main", 62)
|
||||
assert "P_불도우저" not in got and why["P_불도우저"].startswith("우리 식 Q")
|
||||
@@ -196,7 +196,9 @@ def test_굴착기_부착용_집게(whole):
|
||||
|
||||
def test_불도저_운반_작업량(whole):
|
||||
"""10-11 — q=3.2×0.96 · ㎝=20/55+20/70+0.25 · Q=60×q×(1/1.30)×0.55/㎝."""
|
||||
got = mf.run(whole, "GF000148", {"재료": "토사"})
|
||||
got = mf.run(
|
||||
whole, "GF000148", {"재료": "토사", "f입력": 0, "E입력": 0}
|
||||
) # 851-1 직접 칸 0 = 표
|
||||
assert got["결과"] == Decimal("86.709")
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user