chore(853-1): 자료 스크립트 한 번용 25 걷음 — 묶음 ④
- 지움(부르는 곳 = 서로뿐 · 효과는 자료에 반영 · 다시 돌릴 일 없음): _migrate_base · _migrate_keys · _건설기계_* 10 · build_로직_건설품셈_08장_건설기계 · _적용기준_나머지_* 2 · build_로직_건설품셈_01장_적용기준 · build_기계_인력줄_842_3 · build_기계목록_빠진기계_814_1 · build_기계시간당_822_2 · build_기계폴더_826_2 · build_로직_M01보강_794_2a2 · build_로직_기계줄나눔_848_4 · build_로직_잔토처리 · build_로직_재료_고르기 · build_품셈재료_고르기(대상 자료 없음) · master_draft 는 묶음 ② 에서 지움 - 옮김: _migrate_base.dump_master → master_keys.dump_master(글자 그대로) · 갱신 빌더 넷(인력 노임 · 유가전력 · 자재품목 · 환율) import 를 바꿈 - 남김(다시 돌리는 채우기 = 갱신 절차): build_기계_작업량_846_1 · build_단위표기_801_5 · build_변수기호_800_1 · build_변수표_796_3(+ 변수표_796_3.json) · build_용도 · build_재료_검색어 - 시험: test_814_1 기계 목록 시험은 빌더 plan() 대신 수식 문서 기본값만 봄 · test_826_2 는 옮김 빌더 대신 master_machine_files.write 왕복만 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -1,472 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""1_기초 옛 파일 7 → 새 틀(`_틀.md` 2~4장) 요소 파일 6 옮김 · 대조.
|
||||
|
||||
돌리기: `./venv/Scripts/python.exe resources/master_data/scripts/_migrate_base.py`
|
||||
옛 파일은 `old/` 에서 읽기만 함. 새 파일은 `resources/master_data/` 첫 층에 씀. 값은 바꾸지 않음.
|
||||
`dump_master` 는 `_build_mat_price.py` 도 씀. 한 번 돌린 옮기기 — 지금 틀(키 · 인력.json)은 뒤에 `_migrate_keys.py` 로 옮김.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
MD = Path(__file__).resolve().parents[1]
|
||||
OLD = MD / "old"
|
||||
|
||||
UNIT = {
|
||||
"KRW/day": "원/일",
|
||||
"KRW/L": "원/L",
|
||||
"KRW/USD": "원/USD",
|
||||
"KRW/JPY100": "원/JPY100",
|
||||
"KRW/EUR": "원/EUR",
|
||||
"KRW/GBP": "원/GBP",
|
||||
"KRW/CNY": "원/CNY",
|
||||
}
|
||||
STATUS = {"published": "공표", "not_published": "미공표"}
|
||||
|
||||
|
||||
def dump_master(path: Path, head: dict, rows: list[dict]) -> None:
|
||||
"""머리는 들여쓰기 2칸 · 줄은 한 줄씩(길면 펼침) · UTF-8 · LF."""
|
||||
out = ["{"]
|
||||
for key, val in head.items():
|
||||
text = json.dumps(val, ensure_ascii=False, indent=2).replace("\n", "\n ")
|
||||
out.append(f" {json.dumps(key, ensure_ascii=False)}: {text},")
|
||||
out.append(' "줄": [')
|
||||
for i, row in enumerate(rows):
|
||||
line = json.dumps(row, ensure_ascii=False, separators=(", ", ": "))
|
||||
if len(line) <= 450:
|
||||
body = "{ " + line[1:-1] + " }"
|
||||
else:
|
||||
body = json.dumps(row, ensure_ascii=False, indent=2).replace("\n", "\n ")
|
||||
out.append(" " + body + ("," if i < len(rows) - 1 else ""))
|
||||
out += [" ]", "}"]
|
||||
path.write_bytes(("\n".join(out) + "\n").encode("utf-8"))
|
||||
|
||||
|
||||
def load(name: str) -> dict:
|
||||
return json.loads((OLD / name).read_text(encoding="utf-8"))
|
||||
|
||||
|
||||
def origin(sources: list[dict]) -> list[dict]:
|
||||
return [{"경로": s["path"], "해시": s["sha256"], "역할": s["role"]} for s in sources]
|
||||
|
||||
|
||||
def pick(rec: dict, allowed: set[str]) -> None:
|
||||
extra = set(rec) - allowed
|
||||
assert not extra, f"모르는 칸 {extra}"
|
||||
|
||||
|
||||
# ── 인력 ────────────────────────────────────────────────────────────────
|
||||
LABOR_EXTRA = { # 옛 칸 → 새 칸
|
||||
"hours_per_day": "일시간",
|
||||
"reliability": "신뢰도",
|
||||
"industry": "업종",
|
||||
"variation_coefficient": "변동계수",
|
||||
"source_flag": "원문기호",
|
||||
}
|
||||
LABOR_KEYS = {
|
||||
"occupation_code",
|
||||
"occupation_name",
|
||||
"unit",
|
||||
"daily_wage_krw",
|
||||
"status",
|
||||
*LABOR_EXTRA,
|
||||
}
|
||||
|
||||
|
||||
def labor_rows(recs: list[dict], origin_name: str) -> list[dict]:
|
||||
rows = []
|
||||
for r in recs:
|
||||
pick(r, LABOR_KEYS)
|
||||
row = {
|
||||
"열쇠": r["occupation_code"],
|
||||
"이름": r["occupation_name"],
|
||||
"규격": "",
|
||||
"단위": UNIT[r["unit"]],
|
||||
"값": r.get("daily_wage_krw"),
|
||||
"출처": f"{origin_name} {r['occupation_code']}",
|
||||
}
|
||||
for old, new in LABOR_EXTRA.items():
|
||||
if old in r:
|
||||
row[new] = r[old]
|
||||
row["상태"] = STATUS[r["status"]]
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
|
||||
def labor_back(rows: list[dict]) -> list[dict]:
|
||||
inv_unit = {v: k for k, v in UNIT.items()}
|
||||
inv_status = {v: k for k, v in STATUS.items()}
|
||||
out = []
|
||||
for w in rows:
|
||||
r = {
|
||||
"occupation_code": w["열쇠"],
|
||||
"occupation_name": w["이름"],
|
||||
"unit": inv_unit[w["단위"]],
|
||||
}
|
||||
for old, new in LABOR_EXTRA.items():
|
||||
if new in w:
|
||||
r[old] = w[new]
|
||||
if w["값"] is not None:
|
||||
r["daily_wage_krw"] = w["값"]
|
||||
r["status"] = inv_status[w["상태"]]
|
||||
out.append(r)
|
||||
return out
|
||||
|
||||
|
||||
# ── 재료 ────────────────────────────────────────────────────────────────
|
||||
MAT_EXTRA = {
|
||||
"classification_code": "분류코드",
|
||||
"notice_datetime": "공시일시",
|
||||
"notice_number": "공시번호",
|
||||
"business_division_code": "사업구분코드",
|
||||
"business_division_name": "사업구분",
|
||||
"vat_basis": "부가세",
|
||||
"price_type": "가격종류",
|
||||
"delivery_condition": "인도조건",
|
||||
"field": "분야",
|
||||
"price_adopted_reason": "비고",
|
||||
}
|
||||
MAT_KEYS = {"item_code", "classification_name", "specification", "unit", "price_krw", *MAT_EXTRA}
|
||||
|
||||
|
||||
def mat_rows(recs: list[dict]) -> list[dict]:
|
||||
rows = []
|
||||
for r in recs:
|
||||
pick(r, MAT_KEYS)
|
||||
row = {
|
||||
"열쇠": r["item_code"],
|
||||
"이름": r["classification_name"],
|
||||
"규격": r["specification"],
|
||||
"단위": r["unit"],
|
||||
"값": r["price_krw"],
|
||||
"출처": f"나라장터자재 {r['item_code']}",
|
||||
}
|
||||
for old, new in MAT_EXTRA.items():
|
||||
if old in r:
|
||||
row[new] = r[old]
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
|
||||
def mat_back(rows: list[dict]) -> list[dict]:
|
||||
inv = {v: k for k, v in MAT_EXTRA.items()}
|
||||
out = []
|
||||
for w in rows:
|
||||
r = {
|
||||
"item_code": w["열쇠"],
|
||||
"classification_name": w["이름"],
|
||||
"specification": w["규격"],
|
||||
"unit": w["단위"],
|
||||
"price_krw": w["값"],
|
||||
}
|
||||
for new, old in inv.items():
|
||||
if new in w:
|
||||
r[old] = w[new]
|
||||
out.append(r)
|
||||
return out
|
||||
|
||||
|
||||
# ── 유가 · 환율 ─────────────────────────────────────────────────────────
|
||||
FUEL = {"oil_gasoline": "휘발유", "oil_diesel": "경유"}
|
||||
FX_NAME = {
|
||||
"fx_usd": "USD",
|
||||
"fx_jpy100": "JPY100",
|
||||
"fx_eur": "EUR",
|
||||
"fx_gbp": "GBP",
|
||||
"fx_cny": "CNY",
|
||||
}
|
||||
|
||||
|
||||
def oil_rows(avg: dict, reg: dict) -> list[dict]:
|
||||
rows = []
|
||||
for var, v in avg["variables"].items():
|
||||
rows.append(
|
||||
{
|
||||
"열쇠": f"{FUEL[var]}:전국평균",
|
||||
"이름": v["source_product_name"],
|
||||
"규격": "",
|
||||
"단위": UNIT[v["unit"]],
|
||||
"값": v["value"],
|
||||
"출처": f"오피넷유가 {v['source_product_code']}",
|
||||
"구분": "전국평균",
|
||||
"지역": "전국평균",
|
||||
"기준일": v["date"],
|
||||
"상품코드": v["source_product_code"],
|
||||
}
|
||||
)
|
||||
for var, v in reg["variables"].items():
|
||||
for r in v["records"]:
|
||||
rows.append(
|
||||
{
|
||||
"열쇠": f"{FUEL[var]}:{r['sido_name']}",
|
||||
"이름": v["source_product_name"],
|
||||
"규격": "",
|
||||
"단위": UNIT[v["unit"]],
|
||||
"값": r["value"],
|
||||
"출처": f"오피넷유가 {v['source_product_code']}",
|
||||
"구분": "시도별",
|
||||
"지역": r["sido_name"],
|
||||
"지역코드": r["sido_code"],
|
||||
"기준일": v["date"],
|
||||
"상품코드": v["source_product_code"],
|
||||
}
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
def fx_rows(fx: dict) -> list[dict]:
|
||||
return [
|
||||
{
|
||||
"열쇠": v["source_item_code"],
|
||||
"이름": FX_NAME[var],
|
||||
"규격": "",
|
||||
"단위": UNIT[v["unit"]],
|
||||
"값": v["value"],
|
||||
"출처": f"한국은행환율 {v['source_item_code']}",
|
||||
"기준일": v["date"],
|
||||
}
|
||||
for var, v in fx["variables"].items()
|
||||
]
|
||||
|
||||
|
||||
# ── 요율 ────────────────────────────────────────────────────────────────
|
||||
RATE_NAME = {
|
||||
"rate_sanjae": "산재보험료",
|
||||
"rate_goyong": "고용보험료",
|
||||
"rate_health": "건강보험료",
|
||||
"rate_pension": "국민연금보험료",
|
||||
"rate_care": "노인장기요양보험료",
|
||||
"rate_safety_pct": "산업안전보건관리비",
|
||||
"rate_safety_base": "산업안전보건관리비 기초액",
|
||||
"rate_indirect_labor": "간접노무비",
|
||||
"rate_other_expense": "기타경비",
|
||||
"rate_environment": "환경보전비",
|
||||
"rate_retirement_mutual_aid": "퇴직공제부금비",
|
||||
"rate_wage_claim_contribution": "임금채권보장분담금",
|
||||
"rate_asbestos_contribution": "석면피해구제분담금",
|
||||
"rate_subcontract_payment_guarantee": "하도급대금 지급보증 수수료",
|
||||
"rate_equipment_payment_guarantee": "건설기계대여대금 지급보증 수수료",
|
||||
"rate_performance_guarantee_fee": "공사이행보증 수수료",
|
||||
"rate_overhead": "일반관리비",
|
||||
"rate_profit": "이윤",
|
||||
"rate_vat": "부가가치세",
|
||||
}
|
||||
|
||||
|
||||
def rate_rows(rates: dict) -> list[dict]:
|
||||
assert set(rates["variables"]) == set(RATE_NAME)
|
||||
return [
|
||||
{"열쇠": k, "이름": RATE_NAME[k], "값": v, "출처": "조달청제비율"}
|
||||
for k, v in rates["variables"].items()
|
||||
]
|
||||
|
||||
|
||||
# ── 옮기기 ──────────────────────────────────────────────────────────────
|
||||
F_LC = "1_기초_노임_건설업_대한건설협회_2026-01-01.json"
|
||||
F_LM = "1_기초_노임_제조업_중소기업중앙회_2026-07-01.json"
|
||||
F_OR = "1_기초_유가_시도별_오피넷_2026-09-09.json"
|
||||
F_OA = "1_기초_유가_전국평균_오피넷_2026-08-14.json"
|
||||
F_MT = "1_기초_자재_시설공통_나라장터_2026-08-14.json"
|
||||
F_RT = "1_기초_제비율_토목_조달청_2026-04-13.json"
|
||||
F_FX = "1_기초_환율_일별_한국은행_2026-08-14.json"
|
||||
|
||||
NEW = {
|
||||
"lc": "인력_건설노임.json",
|
||||
"lm": "인력_제조노임.json",
|
||||
"mt": "재료_나라장터자재.json",
|
||||
"oil": "재료_오피넷유가.json",
|
||||
"fx": "환율_한국은행환율.json",
|
||||
"rt": "요율_조달청제비율.json",
|
||||
}
|
||||
|
||||
|
||||
def migrate() -> None:
|
||||
lc, lm, mt = load(F_LC), load(F_LM), load(F_MT)
|
||||
orr, oa, rt, fx = load(F_OR), load(F_OA), load(F_RT), load(F_FX)
|
||||
|
||||
lcv = lc["variables"]["labor_rate"]
|
||||
dump_master(
|
||||
MD / NEW["lc"],
|
||||
{
|
||||
"그룹": "인력",
|
||||
"원문": "건설노임",
|
||||
"판": lc["effective_date"],
|
||||
"공표일": lc["publication_date"],
|
||||
"원천": origin(lc["sources"]),
|
||||
"비고": [lcv["reliability_note"]],
|
||||
},
|
||||
labor_rows(lcv["records"], "건설노임"),
|
||||
)
|
||||
lmv = lm["variables"]["labor_mfg"]
|
||||
dump_master(
|
||||
MD / NEW["lm"],
|
||||
{
|
||||
"그룹": "인력",
|
||||
"원문": "제조노임",
|
||||
"판": lm["effective_date"],
|
||||
"공표일": lm["publication_date"],
|
||||
"조사월": lm["survey_month"],
|
||||
"원천": origin(lm["sources"]),
|
||||
"비고": [lmv["industry_note"]],
|
||||
},
|
||||
labor_rows(lmv["records"], "제조노임"),
|
||||
)
|
||||
dump_master(
|
||||
MD / NEW["mt"],
|
||||
{
|
||||
"그룹": "재료",
|
||||
"원문": "나라장터자재",
|
||||
"판": mt["effective_date"],
|
||||
"원천": origin(mt["sources"]),
|
||||
"선정규칙": mt["selection_policy"],
|
||||
"원천행수": mt["source_row_count"],
|
||||
"제외묶음": mt["excluded_named_groups"],
|
||||
"0원미회수": {
|
||||
"비고": mt["zero_price_unrecovered"]["note"],
|
||||
"줄": mt["zero_price_unrecovered"]["items"],
|
||||
},
|
||||
},
|
||||
mat_rows(mt["variables"]["mat_price"]["records"]),
|
||||
)
|
||||
dump_master(
|
||||
MD / NEW["oil"],
|
||||
{
|
||||
"그룹": "재료",
|
||||
"원문": "오피넷유가",
|
||||
"판": orr["effective_date"],
|
||||
"원천": origin(oa["sources"]) + origin(orr["sources"]),
|
||||
"비고": [orr["note"]],
|
||||
},
|
||||
oil_rows(oa, orr),
|
||||
)
|
||||
dump_master(
|
||||
MD / NEW["fx"],
|
||||
{
|
||||
"그룹": "환율",
|
||||
"원문": "한국은행환율",
|
||||
"판": fx["effective_date"],
|
||||
"원천": origin(fx["sources"]),
|
||||
},
|
||||
fx_rows(fx),
|
||||
)
|
||||
dump_master(
|
||||
MD / NEW["rt"],
|
||||
{
|
||||
"그룹": "요율",
|
||||
"원문": "조달청제비율",
|
||||
"판": rt["effective_date"],
|
||||
"원천": origin(rt["sources"]),
|
||||
"처리규칙": rt["processing_rules"],
|
||||
},
|
||||
rate_rows(rt),
|
||||
)
|
||||
|
||||
|
||||
# ── 대조 ────────────────────────────────────────────────────────────────
|
||||
def new(key: str) -> dict:
|
||||
return json.loads((MD / NEW[key]).read_text(encoding="utf-8"))
|
||||
|
||||
|
||||
def num_sum(vals) -> float:
|
||||
return round(sum(v for v in vals if isinstance(v, (int, float))), 6)
|
||||
|
||||
|
||||
def leaves(o):
|
||||
if isinstance(o, dict):
|
||||
for v in o.values():
|
||||
yield from leaves(v)
|
||||
elif isinstance(o, list):
|
||||
for v in o:
|
||||
yield from leaves(v)
|
||||
elif isinstance(o, (int, float)) and not isinstance(o, bool):
|
||||
yield o
|
||||
|
||||
|
||||
def check() -> bool:
|
||||
res = [] # (이름, 옛 줄, 새 줄, 옛 합, 새 합, 같음)
|
||||
|
||||
def add(name, old_rows, new_rows, old_sum, new_sum, same):
|
||||
res.append((name, len(old_rows), len(new_rows), old_sum, new_sum, same))
|
||||
|
||||
for key, f, v, fn in (
|
||||
("lc", F_LC, "labor_rate", "건설노임"),
|
||||
("lm", F_LM, "labor_mfg", "제조노임"),
|
||||
):
|
||||
old = load(f)["variables"][v]["records"]
|
||||
nw = new(key)["줄"]
|
||||
add(
|
||||
fn,
|
||||
old,
|
||||
nw,
|
||||
num_sum(r.get("daily_wage_krw") for r in old),
|
||||
num_sum(r["값"] for r in nw),
|
||||
labor_back(nw) == old,
|
||||
)
|
||||
old = load(F_MT)["variables"]["mat_price"]["records"]
|
||||
nw = new("mt")["줄"]
|
||||
add(
|
||||
"나라장터자재",
|
||||
old,
|
||||
nw,
|
||||
num_sum(r["price_krw"] for r in old),
|
||||
num_sum(r["값"] for r in nw),
|
||||
mat_back(nw) == old,
|
||||
)
|
||||
oa, orr = load(F_OA), load(F_OR)
|
||||
nw = new("oil")["줄"]
|
||||
old_vals = [v["value"] for v in oa["variables"].values()] + [
|
||||
r["value"] for v in orr["variables"].values() for r in v["records"]
|
||||
]
|
||||
n_old = len(oa["variables"]) + sum(len(v["records"]) for v in orr["variables"].values())
|
||||
keys_ok = len({r["열쇠"] for r in nw}) == len(nw)
|
||||
same = keys_ok and [r["값"] for r in nw] == old_vals and nw == oil_rows(oa, orr)
|
||||
res.append(
|
||||
("오피넷유가", n_old, len(nw), num_sum(old_vals), num_sum(r["값"] for r in nw), same)
|
||||
)
|
||||
fx = load(F_FX)
|
||||
nw = new("fx")["줄"]
|
||||
old_vals = [v["value"] for v in fx["variables"].values()]
|
||||
same = [r["값"] for r in nw] == old_vals and nw == fx_rows(fx)
|
||||
res.append(
|
||||
(
|
||||
"한국은행환율",
|
||||
len(old_vals),
|
||||
len(nw),
|
||||
num_sum(old_vals),
|
||||
num_sum(r["값"] for r in nw),
|
||||
same,
|
||||
)
|
||||
)
|
||||
rt = load(F_RT)
|
||||
nw = new("rt")
|
||||
same = {r["열쇠"]: r["값"] for r in nw["줄"]} == rt["variables"] and nw["처리규칙"] == rt[
|
||||
"processing_rules"
|
||||
]
|
||||
old_sum = num_sum(leaves(rt["variables"]))
|
||||
res.append(
|
||||
(
|
||||
"조달청제비율",
|
||||
len(rt["variables"]),
|
||||
len(nw["줄"]),
|
||||
old_sum,
|
||||
num_sum(leaves([r["값"] for r in nw["줄"]])),
|
||||
same,
|
||||
)
|
||||
)
|
||||
|
||||
print(f"{'파일':<12}{'옛 줄':>7}{'새 줄':>7}{'옛 값합':>16}{'새 값합':>16} 일치")
|
||||
ok = True
|
||||
for name, a, b, sa, sb, same in res:
|
||||
good = a == b and sa == sb and same
|
||||
ok &= good
|
||||
print(f"{name:<12}{a:>7}{b:>7}{sa:>16}{sb:>16} {'예' if good else '아니오'}")
|
||||
return ok
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
migrate()
|
||||
sys.exit(0 if check() else 1)
|
||||
@@ -1,317 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""한 번 돌린 옮기기 — 열쇠 → 키(테이블ID + 6자리) · 인력·기계 한 테이블 · 장 파일 이름 (`_틀.md`).
|
||||
|
||||
옛 변수 `그룹:원문:열쇠` · `찾기(그룹:원문:열쇠, …)` · `로직(원문:열쇠, …)` → 키 · `{이름}` 낀 열쇠는 `ID:원문번호`.
|
||||
표·로직·재료 파일은 글 모양 그대로 두고 바뀐 자리만 갈음 · 인력·기계는 새로 씀.
|
||||
돌리기(옛 틀 파일 · 옛 master_formula(3f4fd66d) 일 때만 — 한 번 돌림): ./venv/Scripts/python.exe resources/master_data/scripts/_migrate_keys.py
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[2]
|
||||
sys.path.insert(0, str(HERE))
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
import master_formula as mf # noqa: E402 — 옛 틀 식 읽기
|
||||
import master_keys as mk # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store as st # noqa: E402
|
||||
|
||||
MD = mk.MASTER
|
||||
BODY = ROOT / "resources/knowledge/original/원가계산"
|
||||
DIVS = ("공통", "토목", "건축", "기계설비", "유지관리")
|
||||
DIV_DIR = {
|
||||
"공통": "01_공통부문",
|
||||
"토목": "02_토목부문",
|
||||
"건축": "03_건축부문",
|
||||
"기계설비": "04_기계설비부문",
|
||||
"유지관리": "05_유지관리부문",
|
||||
}
|
||||
LABOR = {
|
||||
"건설노임": "건설업",
|
||||
"제조노임": "제조업",
|
||||
"엔지니어링노임": "엔지니어링",
|
||||
"측량노임": "측량",
|
||||
"건설사업관리노임": "건설사업관리",
|
||||
"SW노임": "SW",
|
||||
"산림노임": "산림",
|
||||
"준용대상": "준용대상",
|
||||
}
|
||||
MACHINE = {"건설품셈": "건설품셈", "산림품셈": "산림품셈"}
|
||||
_CHAP = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈)_(\D*)(\d+)장\.json$")
|
||||
_OLDREF = re.compile(r"(인력|재료|기계|소요량|계수|로직|환율|요율):([^:\s·]+):(.+?)(?=\s·\s|$)")
|
||||
_STR = re.compile(r'"(?:[^"\\]|\\.)*"')
|
||||
|
||||
|
||||
def title(book: str, div: str, num: int) -> str:
|
||||
base = BODY / (
|
||||
"산림_표준품셈/본문" if book == "산림품셈" else f"건설공사_표준품셈/본문/{DIV_DIR[div]}"
|
||||
)
|
||||
(hit,) = base.glob(f"제{num:02d}장_*")
|
||||
return hit.name.split("_", 1)[1]
|
||||
|
||||
|
||||
def chapter_order(name: str) -> tuple:
|
||||
m = _CHAP.match(name)
|
||||
book, div, num = m.group(2), m.group(3), int(m.group(4))
|
||||
return (book != "산림품셈", DIVS.index(div) if div else -1, num)
|
||||
|
||||
|
||||
class _Spans(mf._Parser):
|
||||
"""옛 식 읽기 + 요소·표·로직 머리 글자 자리."""
|
||||
|
||||
def __init__(self, text: str):
|
||||
super().__init__(text)
|
||||
self.spans: list[tuple[int, int, str]] = []
|
||||
|
||||
def ref(self, head: bool = False) -> str:
|
||||
at = self.i
|
||||
text = super().ref(head)
|
||||
raw = self.s[at : self.i]
|
||||
start = at + len(raw) - len(raw.lstrip())
|
||||
if start > 0 and self.s[start - 1] == ":": # 앞 그룹 이름까지
|
||||
group = re.search(r"[\w가-힣]+:$", self.s[:start])
|
||||
self.spans.append((group.start(), start + len(text), group.group() + text))
|
||||
else: # 로직(원문:열쇠)
|
||||
self.spans.append((start, start + len(text), "로직:" + text))
|
||||
return text
|
||||
|
||||
|
||||
class Migrate:
|
||||
def __init__(self):
|
||||
self.files = {
|
||||
p.name: json.loads(
|
||||
p.read_text(encoding="utf-8"), parse_float=Decimal, parse_int=Decimal
|
||||
)
|
||||
for p in sorted(MD.glob("*.json"))
|
||||
if not p.name.startswith("_")
|
||||
}
|
||||
self.texts = {p.name: p.read_text(encoding="utf-8") for p in MD.glob("*.json")}
|
||||
self.book = {"다음": {}, "키": {}}
|
||||
self.keys: dict[tuple[str, str, str], str] = {} # (그룹, 원문, 열쇠) → 키
|
||||
self.names: dict[str, str] = {}
|
||||
self.new_name: dict[str, str] = {}
|
||||
self.order: dict[str, int] = {}
|
||||
self.missing: list[str] = []
|
||||
|
||||
# ── 키 주기 ──
|
||||
def plan(self) -> None:
|
||||
chapters = sorted((n for n in self.files if _CHAP.match(n)), key=chapter_order)
|
||||
for group in ("소요량", "계수", "로직"):
|
||||
mine = [n for n in chapters if n.startswith(group + "_")]
|
||||
for i, name in enumerate(mine, start=1):
|
||||
m = _CHAP.match(name)
|
||||
book, div, num = m.group(2), m.group(3), int(m.group(4))
|
||||
self.new_name[name] = f"{group}_{book}_{num:02d}장_{title(book, div, num)}.json"
|
||||
self.order[name] = i
|
||||
for name in self.files:
|
||||
self.new_name.setdefault(name, name)
|
||||
for b in LABOR:
|
||||
self.new_name[f"인력_{b}.json"] = "인력.json"
|
||||
for b in MACHINE:
|
||||
self.new_name[f"기계_{b}.json"] = "기계.json"
|
||||
first = [f"인력_{b}.json" for b in LABOR] + [f"기계_{b}.json" for b in MACHINE]
|
||||
rest = [n for n in self.files if n not in first and not _CHAP.match(n)]
|
||||
for name in first + rest + chapters:
|
||||
data = self.files[name]
|
||||
group, book = data["그룹"], data["원문"]
|
||||
tid = mk.table_id(group, book)
|
||||
for row in self.rows(data):
|
||||
number = str(row["열쇠"])
|
||||
key = mk.issue(self.book, tid, number, self.new_name[name])
|
||||
assert (group, book, number) not in self.keys, (name, number)
|
||||
self.keys[(group, book, number)] = key
|
||||
self.names[key] = str(row.get("이름") or number)
|
||||
|
||||
@staticmethod
|
||||
def rows(data: dict) -> list[dict]:
|
||||
return data.get("표") if data["그룹"] in mf.TABLE_GROUPS else data.get("줄")
|
||||
|
||||
# ── 변수 갈음 ──
|
||||
def ref(self, full: str) -> str:
|
||||
group, book, number = (full.split(":", 2) + ["", ""])[:3]
|
||||
tid = mk.table_id(group, book)
|
||||
if "{" in number:
|
||||
return f"{tid}:{number}"
|
||||
key = self.keys.get((group, book, number))
|
||||
if not key:
|
||||
self.missing.append(full)
|
||||
return full
|
||||
return key
|
||||
|
||||
def formula(self, text):
|
||||
if not isinstance(text, str):
|
||||
return text
|
||||
p = _Spans(text)
|
||||
p.parse()
|
||||
out = text
|
||||
for start, end, full in sorted(p.spans, reverse=True):
|
||||
out = out[:start] + self.ref(full) + out[end:]
|
||||
return out
|
||||
|
||||
def link(self, value, group: str, book: str):
|
||||
"""준용·통합 — `그룹:원문:열쇠` 또는 같은 원문 열쇠 → 키."""
|
||||
if value in (None, ""):
|
||||
return value
|
||||
value = str(value)
|
||||
return self.ref(value if ":" in value else f"{group}:{book}:{value}")
|
||||
|
||||
def hint(self, text):
|
||||
"""후보 글 속 `인력:원문:열쇠` → 「키 이름」."""
|
||||
if not isinstance(text, str):
|
||||
return text
|
||||
|
||||
def one(m):
|
||||
key = self.ref(m.group(0))
|
||||
return f"{key} {self.names.get(key, '')}".strip()
|
||||
|
||||
return _OLDREF.sub(one, text)
|
||||
|
||||
def row(self, data: dict, row: dict) -> dict:
|
||||
group, book = data["그룹"], data["원문"]
|
||||
out = {"키": self.keys[(group, book, str(row["열쇠"]))], "원문번호": str(row["열쇠"])}
|
||||
if group == "인력":
|
||||
out["조사"] = LABOR[book]
|
||||
if group == "기계":
|
||||
out["세부분류"] = MACHINE[book]
|
||||
for k, v in row.items():
|
||||
if k == "열쇠":
|
||||
continue
|
||||
if group == "로직" and k in ("중간", "덧줄"):
|
||||
v = [{**s, "식": self.formula(s["식"])} for s in v]
|
||||
elif group == "로직" and k == "결과":
|
||||
v = {**v, "식": self.formula(v["식"])}
|
||||
elif group == "로직" and k == "호표":
|
||||
v = [
|
||||
{**h, "수량": self.formula(h["수량"]), "요소": self.formula(h["요소"])}
|
||||
for h in v
|
||||
]
|
||||
elif k in ("준용", "통합"):
|
||||
v = self.link(v, group, book)
|
||||
elif k == "후보":
|
||||
v = self.hint(v)
|
||||
elif k == "연결" and isinstance(v, str):
|
||||
v = self.ref(f"재료:시중물가:{v}")
|
||||
elif k == "값" and book == "시중물가":
|
||||
source = str(v["조달"].get("출처") or "")
|
||||
if source.startswith("나라장터:"):
|
||||
new = "나라장터:" + self.ref("재료:나라장터자재:" + source.split(":", 1)[1])
|
||||
v = {**v, "조달": {**v["조달"], "출처": new}}
|
||||
out[k] = v
|
||||
return out
|
||||
|
||||
# ── 쓰기 ──
|
||||
def head(self, name: str, data: dict) -> dict:
|
||||
m = _CHAP.match(name)
|
||||
out = {"그룹": data["그룹"], "원문": data["원문"]}
|
||||
if m and m.group(3):
|
||||
out["부문"] = m.group(3)
|
||||
if m:
|
||||
out["차례"] = Decimal(self.order[name])
|
||||
return {**out, **{k: v for k, v in data.items() if k not in ("표", "줄")}}
|
||||
|
||||
def keep(self, name: str, data: dict, new: dict) -> str:
|
||||
"""글 모양 그대로 — 「열쇠」 칸 · 바뀐 글 · 머리 두 칸만 갈음. 읽어 맞대어 다르면 dump."""
|
||||
text = self.texts[name]
|
||||
rows = self.rows(new)
|
||||
spots = list(re.finditer(r'"열쇠": ("(?:[^"\\]|\\.)*"|[-\d.]+)', text))
|
||||
if len(spots) == len(rows):
|
||||
parts, at = [], 0
|
||||
for m, row in zip(spots, rows):
|
||||
parts += [
|
||||
text[at : m.start()],
|
||||
f'"키": "{row["키"]}", "원문번호": {json.dumps(row["원문번호"], ensure_ascii=False)}',
|
||||
]
|
||||
at = m.end()
|
||||
text = "".join(parts) + text[at:]
|
||||
swap = {}
|
||||
for old, row in zip(self.rows(data), rows):
|
||||
for k in row:
|
||||
if k in old and old[k] != row[k]:
|
||||
for a, b in zip(self.strings(old[k]), self.strings(row[k])):
|
||||
if a != b:
|
||||
swap[json.dumps(a, ensure_ascii=False)] = json.dumps(
|
||||
b, ensure_ascii=False
|
||||
)
|
||||
text = _STR.sub(lambda m: swap.get(m.group(0), m.group(0)), text)
|
||||
extra = {k: v for k, v in new.items() if k in ("부문", "차례")}
|
||||
if extra:
|
||||
add = "".join(
|
||||
f" {json.dumps(k, ensure_ascii=False)}: {st._atom(v)},\n"
|
||||
for k, v in extra.items()
|
||||
)
|
||||
text = re.sub(
|
||||
r'(\n "원문": "[^"]*",\n)', lambda m: m.group(1) + add, text, count=1
|
||||
)
|
||||
if json.loads(text, parse_float=Decimal, parse_int=Decimal) == new:
|
||||
return text
|
||||
print(" 모양 못 지켜 새로 씀:", name)
|
||||
return st.dump(new)
|
||||
|
||||
@classmethod
|
||||
def strings(cls, v):
|
||||
if isinstance(v, str):
|
||||
yield v
|
||||
elif isinstance(v, dict):
|
||||
for x in v.values():
|
||||
yield from cls.strings(x)
|
||||
elif isinstance(v, list):
|
||||
for x in v:
|
||||
yield from cls.strings(x)
|
||||
|
||||
@staticmethod
|
||||
def dump_rows(head: dict, rows: list[dict]) -> str:
|
||||
out = ["{"]
|
||||
for k, v in head.items():
|
||||
out.append(f" {st._atom(k)}: {st.dump(v, 2)},")
|
||||
out.append(' "줄": [')
|
||||
for i, row in enumerate(rows):
|
||||
line = st._flat(row)
|
||||
body = line if len(line) <= 450 else st.dump(row, 4, expand=True)
|
||||
out.append(" " + body + ("," if i < len(rows) - 1 else ""))
|
||||
out += [" ]", "}"]
|
||||
return "\n".join(out) + "\n"
|
||||
|
||||
def run(self) -> None:
|
||||
self.plan()
|
||||
written = {}
|
||||
merged = {"인력": ({}, []), "기계": ({}, [])}
|
||||
for name, data in self.files.items():
|
||||
new_rows = [self.row(data, r) for r in self.rows(data)]
|
||||
if data["그룹"] in merged:
|
||||
heads, rows = merged[data["그룹"]]
|
||||
label = LABOR[data["원문"]] if data["그룹"] == "인력" else MACHINE[data["원문"]]
|
||||
heads[label] = {k: v for k, v in data.items() if k not in ("그룹", "줄")}
|
||||
rows += new_rows
|
||||
continue
|
||||
new = {
|
||||
**self.head(name, data),
|
||||
("표" if data["그룹"] in mf.TABLE_GROUPS else "줄"): new_rows,
|
||||
}
|
||||
written[self.new_name[name]] = self.keep(name, data, new)
|
||||
written["인력.json"] = self.dump_rows(
|
||||
{"그룹": "인력", "조사": merged["인력"][0]}, merged["인력"][1]
|
||||
)
|
||||
written["기계.json"] = self.dump_rows(
|
||||
{"그룹": "기계", "세부분류": merged["기계"][0]}, merged["기계"][1]
|
||||
)
|
||||
if self.missing:
|
||||
print("못 찾은 변수", len(self.missing), sorted(set(self.missing))[:30])
|
||||
raise SystemExit(1)
|
||||
for name in self.files:
|
||||
(MD / name).unlink()
|
||||
for name, text in written.items():
|
||||
(MD / name).write_text(text, encoding="utf-8", newline="\n")
|
||||
mk.save_book(mk.finish(self.book))
|
||||
print("파일", len(written), "· 키", len(self.book["키"]), dict(self.book["다음"]))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
Migrate().run()
|
||||
@@ -1,482 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-1-4 · 8-2-1 ~ 8-2-21 시공능력 로직 — 결과 = 시간당 작업량(원문 단위 그대로).
|
||||
|
||||
`build_로직_건설품셈_08장_건설기계.py` 가 부름. 식의 `{T:<절> <짧은 이름>}` = 새 계수 표 키 ·
|
||||
`{L:<열쇠>}` = 새 로직 키 · `CC0000xx` = 이미 있는 8-2 계수 표. `C(표, 칸)` = 그 표 칸 값 목록(고르기).
|
||||
정함(브레인) — 원문 범위 값은 가운데를 기본(0 = 자동) · 조건은 고르기 · 원문에 없는 짐작 값 없음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_읽기 import HEAD
|
||||
|
||||
LEVEL = ["양호", "보통", "불량"]
|
||||
CUT = {"대상": "결과", "자리": 3, "방법": "반올림", "출처": "건설품셈 공통 8-1-4 주①"}
|
||||
|
||||
|
||||
def inp(name, desc, unit=None, pick=None, src=None, rng=None):
|
||||
d = {"이름": name, "설명": desc}
|
||||
if unit:
|
||||
d["단위"] = unit
|
||||
if pick is not None:
|
||||
d["고르기"] = pick
|
||||
if rng is not None:
|
||||
d["범위"] = [D(str(x)) for x in rng] # 「0 = 기본」 칸 — 견본 자동값 = 아래 끝 0(원문 기본)
|
||||
if src:
|
||||
d["출처"] = src
|
||||
return d
|
||||
|
||||
|
||||
def st(name, f, unit=None):
|
||||
return {"이름": name, "식": f, **({"단위": unit} if unit else {})}
|
||||
|
||||
|
||||
def look(t, field, **conds):
|
||||
"""찾기 글 — 조건 값은 식 글 그대로(이름 · 「'글'」 · 수)."""
|
||||
where = "".join(f", {k}={v}" for k, v in conds.items())
|
||||
ref = t if t.startswith("CC") else "{T:" + t + "}"
|
||||
return f"찾기({ref}{where}).{field}"
|
||||
|
||||
|
||||
def c(t, item):
|
||||
"""상수 표 값 — `c('8-2-4', '전진속도(V1)')`."""
|
||||
return look(f"{t} 상수", "값", 항목=f"'{item}'")
|
||||
|
||||
|
||||
def mid(t, item):
|
||||
"""상수 표 범위 가운데 — (아래 + 위) / 2."""
|
||||
return f"({look(f'{t} 상수', '아래', 항목=repr(item))} + {look(f'{t} 상수', '위', 항목=repr(item))}) / 2"
|
||||
|
||||
|
||||
def e_in(no, desc="작업효율을 직접 넣을 때 — 0 이면 원문 표 값"):
|
||||
return inp("E입력", desc, src=f"건설품셈 공통 {no}", rng=(0, 1)) # 원문 E 표 값 모두 1 이하
|
||||
|
||||
|
||||
def auto(name, expr):
|
||||
"""「0 = 자동」 수 입력 — 넣은 값이 이김."""
|
||||
return f"만약({name} > 0, {name}, {expr})"
|
||||
|
||||
|
||||
def logic(no, short, name, unit, inputs, steps, result, test, memo=None, cut=True, src=None):
|
||||
row = {
|
||||
"열쇠": f"공통 {no} {short}",
|
||||
"원문번호": no,
|
||||
**HEAD,
|
||||
"이름": f"{name} — 건설 공통 {no}",
|
||||
"결과단위": unit,
|
||||
"출처": src or f"건설품셈 공통 {no}",
|
||||
"소유": "공용",
|
||||
}
|
||||
if memo:
|
||||
row["비고"] = memo
|
||||
row["시험입력"] = test
|
||||
row["입력"] = inputs
|
||||
row["중간"] = steps
|
||||
row["결과"] = {"식": result, "출처": src or f"건설품셈 공통 {no}"}
|
||||
row["끝수"] = CUT if cut else None
|
||||
return row
|
||||
|
||||
|
||||
def soil_e(t, adj):
|
||||
"""흙 작업 E — 자연상태 · 흐트러진 상태 × 양호 · 보통 · 불량 × 토질 표 − 보정(터파기 등)."""
|
||||
base = look(t, "E", 현장조건="현장조건", 등급="등급", 토질명="토질명")
|
||||
return base, f"만약(E보정 == '해당 없음', 0, {look(adj, '보정값', 항목='E보정')})"
|
||||
|
||||
|
||||
def soil_inputs(no, C, t, adj, src):
|
||||
return [
|
||||
inp("현장조건", "흙 상태", pick=C(t, "현장조건"), src=f"건설품셈 공통 {no} {src}"),
|
||||
inp("등급", "작업 조건 등급", pick=LEVEL, src=f"건설품셈 공통 {no} {src}"),
|
||||
inp("토질명", "토질", pick=C(t, "토질명"), src=f"건설품셈 공통 {no} {src}"),
|
||||
inp(
|
||||
"E보정",
|
||||
"작업효율에서 뺄 경우",
|
||||
pick=["해당 없음", *C(adj, "항목")],
|
||||
src=f"건설품셈 공통 {no} {src} 주",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
F_IN = inp("f", "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", src="건설품셈 공통 8-1-4")
|
||||
|
||||
|
||||
def part1(C) -> list[dict]:
|
||||
out = []
|
||||
# 8-1-4 기본식
|
||||
out.append(
|
||||
logic(
|
||||
"8-1-4",
|
||||
"기본식",
|
||||
"시공능력 산정 기본식 Q = n·q·f·E",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("싸이클시간", "1회 작업싸이클 시간(cm)", src="건설품셈 공통 8-1-4 주⑤"),
|
||||
inp(
|
||||
"시간단위", "싸이클시간 단위", pick=["분", "초"], src="건설품셈 공통 8-1-4 주⑤"
|
||||
),
|
||||
inp("작업량", "1회 작업싸이클당 표준작업량(q)", "㎥", src="건설품셈 공통 8-1-4"),
|
||||
F_IN,
|
||||
inp("E", "작업효율", src="건설품셈 공통 8-1-4 주⑥"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"n",
|
||||
"반올림(만약(시간단위 == '분', 60, 3600) / 반올림(싸이클시간, 3), 2)",
|
||||
"회/hr",
|
||||
)
|
||||
],
|
||||
"n * 작업량 * f * E",
|
||||
{"싸이클시간": 21, "시간단위": "초", "작업량": D("0.9"), "f": D("0.7"), "E": D("0.75")},
|
||||
memo="n = 60/cm(분) 또는 3,600/cm(초) · 끝수 Q 3자리 · n 2자리 · cm 3자리(주①) · 단위는 원문대로 ㎥/hr 또는 ton/hr",
|
||||
)
|
||||
)
|
||||
# 8-2-1 불도저
|
||||
no = "8-2-1"
|
||||
base, adj = soil_e("CC000037", "CC000038")
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"불도저",
|
||||
"불도저 시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp(
|
||||
"종별",
|
||||
"불도저 종별",
|
||||
pick=C("CC000035", "종별"),
|
||||
src=f"건설품셈 공통 {no} 1 가",
|
||||
),
|
||||
inp(
|
||||
"급수",
|
||||
"불도저 급수(ton)",
|
||||
pick=C("CC000035", "급수"),
|
||||
src=f"건설품셈 공통 {no} 1 가",
|
||||
),
|
||||
inp("운반거리", "운반거리(L)", "m", src=f"건설품셈 공통 {no} 2"),
|
||||
inp(
|
||||
"거리구분",
|
||||
"운반거리계수(e) 표의 거리 칸",
|
||||
pick=C("CC000036", "운반거리"),
|
||||
src=f"건설품셈 공통 {no} 1 나",
|
||||
),
|
||||
*soil_inputs(no, C, "CC000037", "CC000038", "1 다"),
|
||||
inp("전진단", "전진 기어 단", pick=[1, 2, 3, 4], src=f"건설품셈 공통 {no} 2 주"),
|
||||
inp("후진단", "후진 기어 단", pick=[1, 2, 3], src=f"건설품셈 공통 {no} 2 주"),
|
||||
F_IN,
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("q0", look("CC000035", "'q°'", 급수="급수", 종별="종별"), "㎥"),
|
||||
st("e", look("CC000036", "e", 운반거리="거리구분")),
|
||||
st("q", "q0 * e", "㎥"),
|
||||
st("보정", adj),
|
||||
st("E", auto("E입력", f"{base} - 보정")),
|
||||
st("타이어규격", "만약(급수 == '15', 15, 만약(급수 == '28', 28, 33))", "ton"),
|
||||
st(
|
||||
"V1",
|
||||
f"만약(종별 == '무한궤도', {look('CC000040', '속도', 규격='급수', 방향="'전진'", 단='전진단')}, "
|
||||
f"{look('CC000041', '속도', 규격='타이어규격', 방향="'전진'", 단='전진단')})",
|
||||
"m/분",
|
||||
),
|
||||
st(
|
||||
"V2",
|
||||
f"만약(종별 == '무한궤도', {look('CC000040', '속도', 규격='급수', 방향="'후진'", 단='후진단')}, "
|
||||
f"{look('CC000041', '속도', 규격='타이어규격', 방향="'후진'", 단='후진단')})",
|
||||
"m/분",
|
||||
),
|
||||
st("t", look("CC000039", "값", 항목="'기어 변속시간(t)'"), "분"),
|
||||
st("cm", "반올림(운반거리 / V1 + 운반거리 / V2 + t, 3)", "분"),
|
||||
],
|
||||
"60 * q * f * E / cm",
|
||||
{
|
||||
"종별": "무한궤도",
|
||||
"급수": "19",
|
||||
"운반거리": 30,
|
||||
"거리구분": "30",
|
||||
"현장조건": "자연상태",
|
||||
"등급": "보통",
|
||||
"토질명": "모래, 사질토",
|
||||
"E보정": "해당 없음",
|
||||
"전진단": 1,
|
||||
"후진단": 1,
|
||||
"f": 1,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="q = q° × e · cm = L/V1 + L/V2 + t · 타이어형 속도 표는 규격이 수(15 · 28 · 33)",
|
||||
)
|
||||
)
|
||||
# 8-2-2 리퍼
|
||||
no = "8-2-2"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"리퍼",
|
||||
"리퍼(유압식) 시간당 파쇄량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp(
|
||||
"규격",
|
||||
"트랙터 규격(ton)",
|
||||
pick=C(f"{no} An", "규격"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp(
|
||||
"발톱수",
|
||||
"리퍼 발톱수",
|
||||
pick=C(f"{no} An", "발톱수"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp("작업거리", "1회의 작업거리(ℓ)", "m", src=f"건설품셈 공통 {no}"),
|
||||
inp("암질", "암질", pick=C(f"{no} E", "암질"), src=f"건설품셈 공통 {no} 2"),
|
||||
inp(
|
||||
"탄성파속도",
|
||||
"탄성파속도 — 작업효율 표의 칸 값",
|
||||
"m/sec",
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
F_IN,
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("An", look(f"{no} An", "An", 규격="규격", 발톱수="발톱수"), "㎡"),
|
||||
st(
|
||||
"E",
|
||||
auto(
|
||||
"E입력",
|
||||
look(f"{no} E", "E", 암질="암질", 규격="규격", 탄성파속도="탄성파속도"),
|
||||
),
|
||||
),
|
||||
st(
|
||||
"cm",
|
||||
f"반올림({c(no, 'cm 작업거리 계수')} * 작업거리 + {c(no, 'cm 기본시간')}, 3)",
|
||||
"분",
|
||||
),
|
||||
],
|
||||
"60 * An * 작업거리 * f * E / cm",
|
||||
{
|
||||
"규격": 20,
|
||||
"발톱수": "3본",
|
||||
"작업거리": 30,
|
||||
"암질": "연질",
|
||||
"탄성파속도": 500,
|
||||
"f": 1,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="cm = 0.05ℓ + 0.25(원문 산정식) · 탄성파속도는 작업효율 표에 있는 값(규격별)",
|
||||
)
|
||||
)
|
||||
# 8-2-3 굴착기
|
||||
no = "8-2-3"
|
||||
base, adj = soil_e("CC000043", "CC000046")
|
||||
narrow = look("CC000044", "E", 등급="등급", 토질명="토질명")
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"굴착기",
|
||||
"굴착기 시간당 작업량",
|
||||
"㎥/hr",
|
||||
excavator_inputs(no, C),
|
||||
[
|
||||
st("K", look("CC000042", "K", 현장조건="버킷조건")),
|
||||
st("보정", adj),
|
||||
st("E", auto("E입력", f"만약(협소현장 == '해당 없음', {base}, {narrow}) - 보정")),
|
||||
st(
|
||||
"cm",
|
||||
auto("싸이클입력", look("CC000045", "시간", 규격="규격구분", 각도="선회각도")),
|
||||
"초",
|
||||
),
|
||||
],
|
||||
"3600 * 버킷용량 * K * f * E / cm",
|
||||
EXCAVATOR_TEST,
|
||||
memo="Q = 3,600·q·K·f·E/cm · 협소현장 = 주⑦ 상하수도관로부설 등 별도 E 표 · 싸이클입력 0 = 표(규격 · 선회각도)",
|
||||
)
|
||||
)
|
||||
# 8-2-4 트랜처
|
||||
no = "8-2-4"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"트랜처",
|
||||
"트랜처 시간당 작업량",
|
||||
"m/hr",
|
||||
[
|
||||
inp("작업거리", "1열 실작업거리(L · 편도)", "m", src=f"건설품셈 공통 {no} 2"),
|
||||
inp(
|
||||
"전진거리",
|
||||
"1열 전진거리(L1) — 0 이면 실작업거리",
|
||||
"m",
|
||||
src=f"건설품셈 공통 {no} 2 다",
|
||||
),
|
||||
inp(
|
||||
"후진거리",
|
||||
"1열 후진거리(L2) — 0 이면 실작업거리",
|
||||
"m",
|
||||
src=f"건설품셈 공통 {no} 2 다",
|
||||
),
|
||||
inp(
|
||||
"굴착심도",
|
||||
"굴착심도",
|
||||
"m",
|
||||
C(f"{no} d", "굴착심도"),
|
||||
f"건설품셈 공통 {no} 2 가",
|
||||
),
|
||||
inp("토질", "토질", pick=C(f"{no} E", "토질"), src=f"건설품셈 공통 {no} 2 나"),
|
||||
inp("작업조건", "작업 조건", pick=LEVEL, src=f"건설품셈 공통 {no} 2 나"),
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("d", look(f"{no} d", "d", 굴착심도="굴착심도")),
|
||||
st("E", auto("E입력", look(f"{no} E", "E", 토질="토질", 작업조건="작업조건"))),
|
||||
st("전진", auto("전진거리", "작업거리"), "m"),
|
||||
st("후진", auto("후진거리", "작업거리"), "m"),
|
||||
st(
|
||||
"cm",
|
||||
f"반올림({c(no, '흡수관 삽입 및 수평조절시간(t1)')} + 전진 / {c(no, '전진속도(V1)')} + 후진 / "
|
||||
f"{c(no, '후진속도(V2)')} + {c(no, '회전 및 기어 변속 · 흡수관 끝봉합 시간(t3)')}, 3)",
|
||||
"분",
|
||||
),
|
||||
],
|
||||
"60 * 작업거리 * d * E / cm",
|
||||
{
|
||||
"작업거리": 100,
|
||||
"전진거리": 0,
|
||||
"후진거리": 0,
|
||||
"굴착심도": D("0.7"),
|
||||
"토질": "사질토",
|
||||
"작업조건": "보통",
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="cm = t1 + (L1/V1 + L2/V2) + t3 · 작업보조인부 4인 1조(주①)",
|
||||
)
|
||||
)
|
||||
# 8-2-5 로더
|
||||
no = "8-2-5"
|
||||
base, adj = soil_e("CC000050", "CC000053")
|
||||
k_all = C("CC000048", "현장조건") + C("CC000049", "현장조건")
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"로더",
|
||||
"로더 운전시간당 작업량",
|
||||
"㎥/hr",
|
||||
loader_inputs(no, C, k_all),
|
||||
[
|
||||
st(
|
||||
"t1",
|
||||
look("CC000047", "t1", 기종="기종", 작업방법="작업방법", 현장조건="적재조건"),
|
||||
"초",
|
||||
),
|
||||
st(
|
||||
"K",
|
||||
f"만약(K표 == '산적상태 적재', {look('CC000048', '계수', 현장조건='K조건')}, "
|
||||
f"{look('CC000049', '계수', 현장조건='K조건')})",
|
||||
),
|
||||
st("m", look("CC000051", "m", 기종="기종"), "초/m"),
|
||||
st("l", auto("주행거리", look("CC000052", "값", 항목="'편도주행거리(표준)'")), "m"),
|
||||
st("t2", look("CC000052", "값", 항목="'기본시간(t2, 기어변화 등)'"), "초"),
|
||||
st("cm", "m * l + t1 + t2", "초"),
|
||||
st("보정", adj),
|
||||
st("E", auto("E입력", f"{base} - 보정")),
|
||||
],
|
||||
"3600 * 버킷용량 * K * f * E / cm",
|
||||
LOADER_TEST,
|
||||
memo="cm = m·ℓ + t1 + t2 · K 표 둘(산적상태 적재 · 자연상태·기타 적재) · 주행거리 0 = 표준 8m",
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def excavator_inputs(no, C):
|
||||
return [
|
||||
inp("버킷용량", "버킷용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
inp(
|
||||
"규격구분",
|
||||
"싸이클시간 표의 규격 칸",
|
||||
"㎥",
|
||||
C("CC000045", "규격"),
|
||||
f"건설품셈 공통 {no} 3",
|
||||
),
|
||||
inp("선회각도", "선회 각도", "도", C("CC000045", "각도"), f"건설품셈 공통 {no} 3"),
|
||||
inp(
|
||||
"버킷조건",
|
||||
"버킷계수(K) 현장조건",
|
||||
pick=C("CC000042", "현장조건"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
*soil_inputs(no, C, "CC000043", "CC000046", "2"),
|
||||
inp(
|
||||
"협소현장",
|
||||
"주택가 상하수도관로부설 등 협소현장(주⑦)",
|
||||
pick=["해당 없음", "상하수도관로부설 등 협소현장"],
|
||||
src=f"건설품셈 공통 {no} 2 주⑦",
|
||||
),
|
||||
F_IN,
|
||||
e_in(no),
|
||||
inp(
|
||||
"싸이클입력",
|
||||
"1회 싸이클시간을 직접 넣을 때 — 0 이면 표",
|
||||
"초",
|
||||
src=f"건설품셈 공통 {no} 3",
|
||||
rng=(0, 30), # 원문 3 표 13∼30초
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
EXCAVATOR_TEST = {
|
||||
"버킷용량": 1,
|
||||
"규격구분": "1.0∼1.2",
|
||||
"선회각도": 135,
|
||||
"버킷조건": "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우",
|
||||
"현장조건": "흐트러진 상태",
|
||||
"등급": "보통",
|
||||
"토질명": "모래, 사질토",
|
||||
"E보정": "해당 없음",
|
||||
"협소현장": "해당 없음",
|
||||
"f": D("0.7"),
|
||||
"E입력": 0,
|
||||
"싸이클입력": 0,
|
||||
}
|
||||
|
||||
|
||||
def loader_inputs(no, C, k_all):
|
||||
return [
|
||||
inp("기종", "로더 기종", pick=C("CC000047", "기종"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp("버킷용량", "버킷용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
inp(
|
||||
"작업방법",
|
||||
"버킷에 담는 방법",
|
||||
pick=C("CC000047", "작업방법"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp("적재조건", "t1 현장조건", pick=C("CC000047", "현장조건"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp(
|
||||
"K표",
|
||||
"버킷계수 표 갈래",
|
||||
pick=["산적상태 적재", "자연상태·기타 적재"],
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
inp("K조건", "버킷계수 현장조건(고른 표의 줄)", pick=k_all, src=f"건설품셈 공통 {no} 2"),
|
||||
inp("주행거리", "편도주행거리(ℓ) — 0 이면 표준 8m", "m", src=f"건설품셈 공통 {no}"),
|
||||
*soil_inputs(no, C, "CC000050", "CC000053", "3"),
|
||||
F_IN,
|
||||
e_in(no),
|
||||
]
|
||||
|
||||
|
||||
LOADER_TEST = {
|
||||
"기종": "타이어식",
|
||||
"버킷용량": D("1.34"),
|
||||
"작업방법": "산적상태에서 담을 때",
|
||||
"적재조건": "보통인 경우",
|
||||
"K표": "산적상태 적재",
|
||||
"K조건": "굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등",
|
||||
"주행거리": 0,
|
||||
"현장조건": "흐트러진 상태",
|
||||
"등급": "양호",
|
||||
"토질명": "모래, 사질토",
|
||||
"E보정": "해당 없음",
|
||||
"f": 1,
|
||||
"E입력": 0,
|
||||
}
|
||||
@@ -1,378 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2-6 ~ 8-2-21 시공능력 로직 — `_건설기계_로직.py` 와 같은 꼴."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_로직 import F_IN, LEVEL, auto, c, e_in, inp, logic, look, st
|
||||
from _건설기계_로직_플랜트 import part2b
|
||||
|
||||
|
||||
def part2(C) -> list[dict]:
|
||||
out = []
|
||||
# 8-2-6 모터 스크레이퍼
|
||||
no = "8-2-6"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"스크레이퍼",
|
||||
"모터 스크레이퍼 시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("적재함용적", "적재함 용적", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
inp(
|
||||
"토질상태",
|
||||
"적재계수(K) 토질상태",
|
||||
pick=C(f"{no} K", "토질상태"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp(
|
||||
"작업현장",
|
||||
"작업효율(E) 현장조건",
|
||||
pick=C(f"{no} E", "현장조건"),
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
inp(
|
||||
"도로상태",
|
||||
"주행 도로상태",
|
||||
pick=C(f"{no} V", "도로상태"),
|
||||
src=f"건설품셈 공통 {no} 4",
|
||||
),
|
||||
inp("적재주행거리", "적재시의 주행거리(L1)", "m", src=f"건설품셈 공통 {no} 3"),
|
||||
inp("공차주행거리", "공차시의 주행거리(L2)", "m", src=f"건설품셈 공통 {no} 3"),
|
||||
inp(
|
||||
"푸쉬도우저",
|
||||
"푸쉬도우저 사용",
|
||||
pick=["사용", "사용 안 함"],
|
||||
src=f"건설품셈 공통 {no} 3",
|
||||
),
|
||||
F_IN,
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("K", look(f"{no} K", "K", 토질상태="토질상태")),
|
||||
st("q", "적재함용적 * K", "㎥"),
|
||||
st("E", auto("E입력", look(f"{no} E", "E", 현장조건="작업현장"))),
|
||||
st("V1", look(f"{no} V", "적재시", 도로상태="도로상태"), "m/분"),
|
||||
st("V2", look(f"{no} V", "공차시", 도로상태="도로상태"), "m/분"),
|
||||
st(
|
||||
"t",
|
||||
f"만약(푸쉬도우저 == '사용', {c(no, '적토·사토·기어변속시간(t) — 푸쉬도우저 사용')}, "
|
||||
f"{c(no, '적토·사토·기어변속시간(t) — 푸쉬도우저 사용 안 함')})",
|
||||
"분",
|
||||
),
|
||||
st("cm", "반올림(적재주행거리 / V1 + 공차주행거리 / V2 + t, 3)", "분"),
|
||||
],
|
||||
"60 * q * f * E / cm",
|
||||
{
|
||||
"적재함용적": 10,
|
||||
"적재주행거리": 300,
|
||||
"공차주행거리": 300,
|
||||
"푸쉬도우저": "사용",
|
||||
"f": 1,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="q = 적재함용적 × K · cm = L1/V1 + L2/V2 + t",
|
||||
)
|
||||
)
|
||||
# 8-2-7 모터 그레이더 — 면적(A) · 토량(Q)
|
||||
no = "8-2-7"
|
||||
common = [
|
||||
inp("작업거리", "1회의 작업거리(D · 편도)", "m", src=f"건설품셈 공통 {no}"),
|
||||
inp(
|
||||
"작업종류",
|
||||
"속도 표의 작업종류",
|
||||
pick=C(f"{no} V", "작업종류"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp("현장조건", "작업 현장조건", pick=LEVEL, src=f"건설품셈 공통 {no} 1 주①"),
|
||||
inp(
|
||||
"작업방식",
|
||||
"cm 산출 갈래",
|
||||
pick=["방향변환 또는 블레이드 선회 왕복작업", "전진 작업 후 후진·회송"],
|
||||
src=f"건설품셈 공통 {no} 1 가·나",
|
||||
),
|
||||
inp(
|
||||
"되돌림",
|
||||
"되돌아 오는 방법(작업방식 「전진 작업 후 후진·회송」 때)",
|
||||
pick=["후진", "회송"],
|
||||
src=f"건설품셈 공통 {no} 1 나",
|
||||
),
|
||||
inp("되돌림조건", "후진 · 회송 현장조건", pick=LEVEL, src=f"건설품셈 공통 {no} 1 주②"),
|
||||
inp("t작업", "t 표의 작업종류", pick=C(f"{no} t", "작업종류"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp(
|
||||
"E작업",
|
||||
"작업효율 표의 작업종류",
|
||||
pick=C(f"{no} E", "작업종류"),
|
||||
src=f"건설품셈 공통 {no} 3",
|
||||
),
|
||||
inp(
|
||||
"작업횟수",
|
||||
"작업장 전체의 폭을 그 속도로 행하는 작업횟수(P)",
|
||||
"회",
|
||||
src=f"건설품셈 공통 {no}",
|
||||
),
|
||||
e_in(no),
|
||||
]
|
||||
steps = [
|
||||
st(
|
||||
"V1",
|
||||
look(f"{no} V", "속도", 작업종류="작업종류", 구분="'작업'", 현장조건="현장조건"),
|
||||
"㎞/hr",
|
||||
),
|
||||
st(
|
||||
"V2",
|
||||
look(f"{no} V", "속도", 작업종류="작업종류", 구분="되돌림", 현장조건="되돌림조건"),
|
||||
"㎞/hr",
|
||||
),
|
||||
st("t", look(f"{no} t", "t", 작업종류="t작업"), "분"),
|
||||
st(
|
||||
"cm",
|
||||
"반올림(만약(작업방식 == '방향변환 또는 블레이드 선회 왕복작업', 0.06 * 작업거리 / V1 + t, "
|
||||
"0.06 * (작업거리 / V1 + 작업거리 / V2) + 2 * t), 3)",
|
||||
"분",
|
||||
),
|
||||
st("E", auto("E입력", look(f"{no} E", "E", 작업종류="E작업", 현장조건="현장조건"))),
|
||||
]
|
||||
test = {
|
||||
"작업거리": 100,
|
||||
"작업종류": "토사도보수",
|
||||
"현장조건": "보통",
|
||||
"작업방식": "방향변환 또는 블레이드 선회 왕복작업",
|
||||
"되돌림": "후진",
|
||||
"되돌림조건": "보통",
|
||||
"t작업": "도로보수",
|
||||
"E작업": "토사도의 보수 및 정지 등",
|
||||
"작업횟수": 2,
|
||||
"E입력": 0,
|
||||
}
|
||||
memo = "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"그레이더면적",
|
||||
"모터 그레이더 1시간당 작업면적",
|
||||
"㎡/hr",
|
||||
[*common, inp("작업폭", "작업장 전체의 폭(W)", "m", src=f"건설품셈 공통 {no}")],
|
||||
steps,
|
||||
"60 * 작업거리 * 작업폭 * E / (작업횟수 * cm)",
|
||||
{**test, "작업폭": 6},
|
||||
memo=memo,
|
||||
)
|
||||
)
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"그레이더토량",
|
||||
"모터 그레이더 1시간당 작업토량",
|
||||
"㎥/hr",
|
||||
[
|
||||
*common,
|
||||
inp(
|
||||
"l작업",
|
||||
"블레이드 유효길이 표의 작업종류",
|
||||
pick=C(f"{no} l", "작업종류"),
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
inp("두께", "굴착 깊이 또는 흙고르기 두께(H)", "m", src=f"건설품셈 공통 {no}"),
|
||||
F_IN,
|
||||
],
|
||||
[*steps, st("l", look(f"{no} l", "유효길이", 작업종류="l작업"), "m")],
|
||||
"60 * l * 작업거리 * 두께 * f * E / (작업횟수 * cm)",
|
||||
{**test, "l작업": "부드러운 토질에서의 깎기", "두께": D("0.1"), "f": 1},
|
||||
memo=memo,
|
||||
)
|
||||
)
|
||||
# 8-2-8 덤프트럭
|
||||
no = "8-2-8"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"덤프트럭",
|
||||
"덤프트럭 1시간당 작업량",
|
||||
"㎥/hr",
|
||||
dump_inputs(no, C),
|
||||
dump_steps(no),
|
||||
"60 * q * f * E / cm",
|
||||
DUMP_TEST,
|
||||
memo="q = T/γt × L · cm = t1 + … + t6 · 적재기계 t1 = cms·n/(60·Es) · n = q/(qs·k)(2자리) · 인력 t1 = 적재시간(분/㎥) × q · t2 = 거리/속도 × 60(분)",
|
||||
)
|
||||
)
|
||||
# 8-2-9 롤러 — 다짐토량(Q) · 다짐면적(A)
|
||||
no = "8-2-9"
|
||||
roll_in = [
|
||||
inp("다짐기계", "다짐기계", pick=C("CC000062", "다짐기계"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp("규격", "다짐기계 규격(ton)", pick=C("CC000062", "규격"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp(
|
||||
"다짐층",
|
||||
"표준다짐속도 칸",
|
||||
pick=["노체, 축제, 노상", "보조기층, 기층", "표층"],
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp("다짐횟수", "소요다짐횟수(N)", "회", src=f"건설품셈 공통 {no} 2"),
|
||||
inp("E공종", "작업효율 표의 공종", pick=C("CC000064", "공종"), src=f"건설품셈 공통 {no} 3"),
|
||||
inp(
|
||||
"E기계",
|
||||
"작업효율 표의 다짐기계",
|
||||
pick=C("CC000064", "다짐기계"),
|
||||
src=f"건설품셈 공통 {no} 3",
|
||||
),
|
||||
inp("현장조건", "작업 조건", pick=LEVEL, src=f"건설품셈 공통 {no} 3"),
|
||||
e_in(no),
|
||||
]
|
||||
w = lambda f: look("CC000062", f, 다짐기계="다짐기계", 규격="규격") # noqa: E731
|
||||
e = lambda f: look("CC000064", f, 공종="E공종", 다짐기계="E기계") # noqa: E731
|
||||
roll_steps = [
|
||||
st("W", w("유효다짐폭"), "m"),
|
||||
st(
|
||||
"V",
|
||||
f"만약(다짐층 == '노체, 축제, 노상', {w(chr(39) + '속도_노체축제노상' + chr(39))}, "
|
||||
f"만약(다짐층 == '보조기층, 기층', {w(chr(39) + '속도_보조기층기층' + chr(39))}, {w(chr(39) + '속도_표층' + chr(39))}))",
|
||||
"㎞/hr",
|
||||
),
|
||||
st(
|
||||
"E",
|
||||
auto(
|
||||
"E입력",
|
||||
f"만약(현장조건 == '양호', {e('양호')}, 만약(현장조건 == '보통', {e('보통')}, {e('불량')}))",
|
||||
),
|
||||
),
|
||||
]
|
||||
roll_test = {
|
||||
"다짐기계": "타이어롤러",
|
||||
"규격": "8∼15",
|
||||
"다짐층": "노체, 축제, 노상",
|
||||
"다짐횟수": 4,
|
||||
"E공종": "노체, 축제, 노상",
|
||||
"E기계": "불도저",
|
||||
"현장조건": "보통",
|
||||
"E입력": 0,
|
||||
}
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"롤러토량",
|
||||
"롤러 시간당 다짐토량",
|
||||
"㎥/hr",
|
||||
[
|
||||
*roll_in,
|
||||
inp(
|
||||
"두께", "펴는 흙의 두께(D · 다져진 상태)", "m", src=f"건설품셈 공통 {no} 2 주②"
|
||||
),
|
||||
F_IN,
|
||||
],
|
||||
roll_steps,
|
||||
"1000 * V * W * 두께 * E * f / 다짐횟수",
|
||||
{**roll_test, "두께": D("0.3"), "f": 1},
|
||||
memo="Q = 1,000·V·W·D·E·f/N · 소요다짐횟수 · 두께는 2 표(CC000063) 참고 입력",
|
||||
)
|
||||
)
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"롤러면적",
|
||||
"롤러 시간당 다짐면적",
|
||||
"㎡/hr",
|
||||
roll_in,
|
||||
roll_steps,
|
||||
"1000 * V * W * E / 다짐횟수",
|
||||
roll_test,
|
||||
memo="A = 1,000·V·W·E·1/N",
|
||||
)
|
||||
)
|
||||
out += part2b(C)
|
||||
return out
|
||||
|
||||
|
||||
def dump_inputs(no, C):
|
||||
s = f"건설품셈 공통 {no}"
|
||||
return [
|
||||
inp("적재용량", "덤프트럭의 적재용량(T)", "ton", src=s),
|
||||
inp("단위중량", "자연상태 토석의 단위중량(γt · 습윤밀도)", "t/㎥", src=s),
|
||||
inp("체적변화율", "체적환산계수에서의 체적변화율(L = 흐트러진/자연)", src=s),
|
||||
inp("f", "체적환산계수", src=s),
|
||||
inp("운반거리", "운반거리(편도)", "㎞", src=f"{s} 2"),
|
||||
inp("도로상태", "운반도로 상태", pick=C("CC000054", "도로상태"), src=f"{s} 3"),
|
||||
inp("적하토질", "적하시간 표의 토질", pick=C("CC000055", "토질"), src=f"{s} 4"),
|
||||
inp("적하조건", "적하 작업조건", pick=LEVEL, src=f"{s} 4"),
|
||||
inp("적재장소", "적재장소 진입 조건(t4)", pick=C("CC000056", "적재장소조건"), src=f"{s} 5"),
|
||||
inp(
|
||||
"덮개",
|
||||
"적재함 덮개 설치 · 해체(t5)",
|
||||
pick=["해당 없음", *C("CC000057", "구분")],
|
||||
src=f"{s} 6",
|
||||
),
|
||||
inp("세륜", "세륜기 통과(t6)", pick=["안 함", "함"], src=f"{s} 7"),
|
||||
inp(
|
||||
"적재방법",
|
||||
"적재시간(t1) 산출 갈래",
|
||||
pick=["적재기계", "인력", "직접 입력"],
|
||||
src=f"{s} 1 · 8 · 9",
|
||||
),
|
||||
inp("적재싸이클", "적재기계의 1회 싸이클시간(cms)", "초", src=f"{s} 8"),
|
||||
inp("적재버킷", "적재기계의 버킷용량(q)", "㎥", src=f"{s} 8"),
|
||||
inp("버킷계수", "적재기계의 버킷계수(k)", src=f"{s} 8"),
|
||||
inp("적재효율", "적재기계의 작업효율(Es)", src=f"{s} 8"),
|
||||
inp("인력종류", "인력 적재 종류", pick=C("CC000059", "종류"), src=f"{s} 9"),
|
||||
inp(
|
||||
"적재시간입력",
|
||||
"적재시간(t1)을 직접 넣을 때(적재방법 「직접 입력」)",
|
||||
"분",
|
||||
src=f"{s} 1",
|
||||
),
|
||||
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.9"),
|
||||
]
|
||||
|
||||
|
||||
def dump_steps(no):
|
||||
one = "반올림(q / (적재버킷 * 버킷계수), 2)"
|
||||
return [
|
||||
st("q", "적재용량 / 단위중량 * 체적변화율", "㎥"),
|
||||
st("n", f"만약(적재방법 == '적재기계', {one}, 0)", "회"),
|
||||
st(
|
||||
"t1",
|
||||
f"만약(적재방법 == '적재기계', 적재싸이클 * n / (60 * 적재효율), "
|
||||
f"만약(적재방법 == '인력', {look('CC000059', '적재시간', 종류='인력종류')} * q, 적재시간입력))",
|
||||
"분",
|
||||
),
|
||||
st(
|
||||
"t2",
|
||||
f"운반거리 / {look('CC000054', '적재', 도로상태='도로상태')} * 60 + "
|
||||
f"운반거리 / {look('CC000054', '공차', 도로상태='도로상태')} * 60",
|
||||
"분",
|
||||
),
|
||||
st("t3", look("CC000055", "시간", 토질="적하토질", 작업조건="적하조건"), "분"),
|
||||
st("t4", look("CC000056", "시간", 적재장소조건="적재장소"), "분"),
|
||||
st("t5", f"만약(덮개 == '해당 없음', 0, {look('CC000057', '시간', 구분='덮개')})", "분"),
|
||||
st(
|
||||
"t6",
|
||||
f"만약(세륜 == '함', {look('CC000058', '시간', 구분=chr(39) + '세륜시간' + chr(39))}, 0)",
|
||||
"분",
|
||||
),
|
||||
st("cm", "반올림(t1 + t2 + t3 + t4 + t5 + t6, 3)", "분"),
|
||||
st("E", auto("E입력", look("CC000060", "값", 항목="'작업효율(E)'"))),
|
||||
]
|
||||
|
||||
|
||||
DUMP_TEST = {
|
||||
"적재용량": 15,
|
||||
"단위중량": D("1.8"),
|
||||
"체적변화율": D("1.25"),
|
||||
"f": D("0.7"),
|
||||
"운반거리": D("0.08"),
|
||||
"도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
|
||||
"적하토질": "모래, 역, 호박돌",
|
||||
"적하조건": "불량",
|
||||
"적재장소": "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때",
|
||||
"덮개": "해당 없음",
|
||||
"세륜": "안 함",
|
||||
"적재방법": "적재기계",
|
||||
"적재싸이클": 21,
|
||||
"적재버킷": 1,
|
||||
"버킷계수": D("0.9"),
|
||||
"적재효율": D("0.75"),
|
||||
"인력종류": "토사류",
|
||||
"적재시간입력": 0,
|
||||
"E입력": 0,
|
||||
}
|
||||
@@ -1,425 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2-22 ~ 8-2-26 로직(파일 해머 · 압입 인발기) — `_건설기계_로직.py` 와 같은 꼴 · 27 ~ 33 은 `_건설기계_로직_준설.py`."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_로직 import auto, c, inp, logic, look, st
|
||||
from _건설기계_로직_준설 import marine
|
||||
|
||||
FIX = [D("-0.05"), D("0"), D("0.05")]
|
||||
|
||||
|
||||
def fixes(no, n, src):
|
||||
return [
|
||||
inp(
|
||||
f"f{i}",
|
||||
f"작업조건 보정계수 f_{i}(보정 표에서 고른 보정치)",
|
||||
pick=FIX,
|
||||
src=f"건설품셈 공통 {no} {src}",
|
||||
)
|
||||
for i in range(1, n + 1)
|
||||
]
|
||||
|
||||
|
||||
def fsum(n):
|
||||
return " + ".join(f"f{i}" for i in range(1, n + 1))
|
||||
|
||||
|
||||
def part3(C) -> list[dict]:
|
||||
out = []
|
||||
# 8-2-22 디젤 파일 해머 — 강관 · 콘크리트
|
||||
no, s = "8-2-22", "건설품셈 공통 8-2-22"
|
||||
soil = [
|
||||
inp("토질", "토질계수(α) 표의 토질", pick=C(f"{no} α", "토질"), src=f"{s} 1 가 (1)"),
|
||||
inp(
|
||||
"α입력",
|
||||
"토질계수를 직접 넣을 때(2종 이상 토층 가중평균) — 0 이면 표",
|
||||
src=f"{s} 1 가 (1) 주",
|
||||
rng=(0, "4.0"), # 원문 α 1.0 ∼ 4.0
|
||||
),
|
||||
]
|
||||
common = [
|
||||
inp("관입길이", "파일 끝이 들어가는 전층의 길이(L)", "m", src=f"{s} 1 가"),
|
||||
inp("평균N", "평균 N치(1이하는 1)", src=f"{s} 1 가 (3)"),
|
||||
inp("세우기횟수", "파일세우기 횟수(Ns)", "회", src=f"{s} 1 나"),
|
||||
inp("평탄성", "작업계수 평탄성", pick=C(f"{no} F", "평탄성"), src=f"{s} 1 마"),
|
||||
inp("현장", "작업 현장의 넓이와 상태", pick=C(f"{no} F", "현장"), src=f"{s} 1 마"),
|
||||
]
|
||||
base = [
|
||||
st("α", auto("α입력", look(f"{no} α", "α", 토질="토질"))),
|
||||
st("N", f"최대(평균N, {c(no, '평균 N치 아래끝(1이하는 1)')})"),
|
||||
st("F", look(f"{no} F", "F", 평탄성="평탄성", 현장="현장")),
|
||||
]
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"강관",
|
||||
"디젤 파일 해머 파일 1본당 시공시간 — 강관파일",
|
||||
"분/본",
|
||||
[
|
||||
*soil,
|
||||
inp("파일경", "파일경", "㎜", C(f"{no} β강관", "파일경"), f"{s} 1 가 (2)"),
|
||||
inp(
|
||||
"해머", "파일해머의 램중량", pick=C(f"{no} β강관", "해머"), src=f"{s} 1 가 (2)"
|
||||
),
|
||||
*common,
|
||||
inp("평균간격", "파일의 평균간격(a)", "m", src=f"{s} 1 다"),
|
||||
inp("블록간거리", "블록간의 거리(LS)", "m", src=f"{s} 1 다"),
|
||||
inp("블록수", "블록수(S)", src=f"{s} 1 다"),
|
||||
inp("시공본수", "파일의 전 시공 본수(n)", "본", src=f"{s} 1 다"),
|
||||
inp("용접방법", "이음 용접", pick=["해당 없음", "반자동", "수동"], src=f"{s} 1 바"),
|
||||
inp(
|
||||
"관두께",
|
||||
"관두께(박판 기준)",
|
||||
"㎜",
|
||||
C(f"{no} 용접반자동", "관두께"),
|
||||
f"{s} 1 바",
|
||||
),
|
||||
inp("이음수", "파일 1본당 이음수(Nw)", "개소", src=f"{s} 1 바"),
|
||||
],
|
||||
[
|
||||
*base,
|
||||
st("β", look(f"{no} β강관", "β", 파일경="파일경", 해머="해머")),
|
||||
st("Tb", f"{c(no, '타격시간 계수 — 강관파일')} * α * β * 관입길이 * (N + 2)", "분"),
|
||||
st(
|
||||
"tw",
|
||||
f"만약(용접방법 == '해당 없음', 0, 만약(용접방법 == '반자동', "
|
||||
f"{look(f'{no} 용접반자동', '시간', 파일경='파일경', 관두께='관두께')}, "
|
||||
f"{look(f'{no} 용접수동', '시간', 파일경='파일경', 관두께='관두께')}))",
|
||||
"분",
|
||||
),
|
||||
st("Tw", "tw * 이음수", "분"),
|
||||
st("Ts", f"{c(no, '세우기 및 위치조정 — 강관파일')} * 세우기횟수", "분"),
|
||||
st(
|
||||
"Tt",
|
||||
f"(평균간격 + 블록간거리 * (블록수 - 1) / 시공본수) / {c(no, '크롤러식 항타기 자주 표준주행속도(V)')}",
|
||||
"분",
|
||||
),
|
||||
st("Te", look(f"{no} Te강관", "Te", 해머="해머"), "분"),
|
||||
],
|
||||
"(Tb + Tw + Ts + Tt + Te) / F",
|
||||
{
|
||||
"토질": "실트・로움・모래",
|
||||
"α입력": 0,
|
||||
"파일경": 500,
|
||||
"해머": "2.2t 급",
|
||||
"관입길이": 12,
|
||||
"평균N": 10,
|
||||
"세우기횟수": 1,
|
||||
"평탄성": "양호",
|
||||
"현장": "현장이 넓으며 작업에 장애물이 없는 경우",
|
||||
"평균간격": 2,
|
||||
"블록간거리": 20,
|
||||
"블록수": 2,
|
||||
"시공본수": 50,
|
||||
"용접방법": "반자동",
|
||||
"관두께": 12,
|
||||
"이음수": 1,
|
||||
},
|
||||
cut=False,
|
||||
memo="Tc = (Tb+Tw+Ts+Tt+Te)/F · Tb = 0.05·α·β·L(N+2) — 원문 강관 식 글에 β 글자가 빠져 있으나 기호 풀이(β 해머 계수) · 표 · 콘크리트 식대로 β 곱함",
|
||||
)
|
||||
)
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"콘크리트",
|
||||
"디젤 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC)",
|
||||
"분/본",
|
||||
[
|
||||
*soil,
|
||||
inp("파일경", "파일경", "㎜", C(f"{no} β콘크리트", "파일경"), f"{s} 2 가"),
|
||||
inp("해머", "파일해머 규격", pick=C(f"{no} β콘크리트", "해머"), src=f"{s} 2 가"),
|
||||
*common,
|
||||
],
|
||||
[
|
||||
*base,
|
||||
st("β", look(f"{no} β콘크리트", "β", 해머="해머", 파일경="파일경")),
|
||||
st(
|
||||
"Tb",
|
||||
f"{c(no, '타격시간 계수 — 콘크리트 파일')} * α * β * 관입길이 * (N + 2)",
|
||||
"분",
|
||||
),
|
||||
st(
|
||||
"Ts",
|
||||
f"만약(파일경 <= 300, {c(no, '세우기 및 위치조정 — 콘크리트 파일 250·300㎜')}, "
|
||||
f"{c(no, '세우기 및 위치조정 — 콘크리트 파일 350∼500㎜')}) * 세우기횟수",
|
||||
"분",
|
||||
),
|
||||
st("Tt", c(no, "이동 및 준비시간 — 콘크리트 파일"), "분"),
|
||||
st(
|
||||
"Te",
|
||||
f"만약(해머 == '1.5ton 급', {look(f'{no} Te콘크리트', 'Te', 해머=chr(39) + '1.5톤 급' + chr(39))}, "
|
||||
f"{look(f'{no} Te콘크리트', 'Te', 해머=chr(39) + '2.2톤 급' + chr(39))})",
|
||||
"분",
|
||||
),
|
||||
],
|
||||
"(Tb + Ts + Tt + Te) / F",
|
||||
{
|
||||
"토질": "실트・로움・모래",
|
||||
"α입력": 0,
|
||||
"파일경": 400,
|
||||
"해머": "2.2ton 급",
|
||||
"관입길이": 12,
|
||||
"평균N": 10,
|
||||
"세우기횟수": 1,
|
||||
"평탄성": "양호",
|
||||
"현장": "현장이 넓으며 작업에 장애물이 없는 경우",
|
||||
},
|
||||
cut=False,
|
||||
memo="Tc = (Tb+Ts+Tt+Te)/F · Tb = 0.08α·β·L(N+2) · 용접 없음",
|
||||
)
|
||||
)
|
||||
# 8-2-23 유압 파일 해머 — 강관 · 콘크리트
|
||||
no, s = "8-2-23", "건설품셈 공통 8-2-23"
|
||||
n_in = inp("평균N", "타입층의 평균 N치", src=f"{s} 1 가 (1)")
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"강관",
|
||||
"유압 파일 해머 파일 1본당 시공시간 — 강관파일",
|
||||
"분/본",
|
||||
[
|
||||
n_in,
|
||||
inp("항타길이", "항타길이", "m", C(f"{no} β", "항타길이"), f"{s} 1 가 (2)"),
|
||||
inp("판두께", "판두께", "㎜", C(f"{no} β", "판두께"), f"{s} 1 가 (2)"),
|
||||
inp("파일경", "파일경", "㎜", C(f"{no} Ta강관", "파일경"), f"{s} 1 가 (3)"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"α",
|
||||
f"만약(평균N < 20, {look(f'{no} α강관', 'α', N치=chr(39) + '20 미만' + chr(39))}, "
|
||||
f"{look(f'{no} α강관', 'α', N치=chr(39) + '20 이상' + chr(39))})",
|
||||
),
|
||||
st("β", look(f"{no} β", "β", 항타길이="항타길이", 판두께="판두께")),
|
||||
# 원문 β 표 「16 이하」 · Ta 표 「16이하」 — 같은 칸 글자가 달라 맞춤
|
||||
st("Ta길이", "만약(항타길이 == '16 이하', '16이하', 항타길이)"),
|
||||
st("Ta", look(f"{no} Ta강관", "Ta", 항타길이="Ta길이", 파일경="파일경"), "분/본"),
|
||||
],
|
||||
"α * β * Ta",
|
||||
{"평균N": 15, "항타길이": "17∼32", "판두께": "12", "파일경": "500∼800"},
|
||||
cut=False,
|
||||
memo="Tc = α·β·Ta · 용접시간 포함(주④)",
|
||||
)
|
||||
)
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"콘크리트",
|
||||
"유압 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC · PHC)",
|
||||
"분/본",
|
||||
[
|
||||
n_in,
|
||||
inp(
|
||||
"항타길이", "항타길이", "m", C(f"{no} Ta콘크리트", "항타길이"), f"{s} 1 나 (2)"
|
||||
),
|
||||
inp("파일경", "파일경", "㎜", C(f"{no} Ta콘크리트", "파일경"), f"{s} 1 나 (2)"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"α",
|
||||
f"만약(평균N < 20, {look(f'{no} α콘크리트', 'α', N치=chr(39) + '20 미만' + chr(39))}, "
|
||||
f"{look(f'{no} α콘크리트', 'α', N치=chr(39) + '20 이상' + chr(39))})",
|
||||
),
|
||||
st(
|
||||
"Ta",
|
||||
look(f"{no} Ta콘크리트", "Ta", 항타길이="항타길이", 파일경="파일경"),
|
||||
"분/본",
|
||||
),
|
||||
],
|
||||
"α * Ta",
|
||||
{"평균N": 25, "항타길이": "16∼22", "파일경": "300∼600"},
|
||||
cut=False,
|
||||
memo="Tc = α·Ta",
|
||||
)
|
||||
)
|
||||
out += vibro(C)
|
||||
out += marine(C)
|
||||
return out
|
||||
|
||||
|
||||
def vibro(C) -> list[dict]:
|
||||
out = []
|
||||
no, s = "8-2-24", "건설품셈 공통 8-2-24"
|
||||
r = lambda soil, f: look(f"{no} r", f, 공종="'항타'", 토질=repr(soil)) # noqa: E731
|
||||
pull = lambda soil: look(f"{no} r", "r", 공종="'항발'", 토질=repr(soil)) # noqa: E731
|
||||
sand, clay = "사질토, 역질토(r_1)", "점질토(r_2)"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"H파일",
|
||||
"진동파일 해머 파일 1본당 시공시간 — H파일",
|
||||
"분/본",
|
||||
[
|
||||
inp("작업", "항타 · 항발", pick=["항타", "항발"], src=f"{s} 1"),
|
||||
inp("파일", "파일크기", pick=C(f"{no} k", "파일"), src=f"{s} 1 나 (2)"),
|
||||
inp("사질층길이", "사질토 · 역질토 층 길이(ℓ1)", "m", src=f"{s} 1 나 (1)"),
|
||||
inp("사질N", "사질토 · 역질토 N치(N1)", src=f"{s} 1 나 (1)"),
|
||||
inp("점질층길이", "점질토 층 길이(ℓ2)", "m", src=f"{s} 1 나 (1)"),
|
||||
inp("점질N", "점질토 N치(N2)", src=f"{s} 1 나 (1)"),
|
||||
*fixes(no, 4, "1 다 (2)"),
|
||||
],
|
||||
[
|
||||
st("Ts", look(f"{no} Ts", "Ts", 작업="작업"), "분"),
|
||||
st(
|
||||
"r1",
|
||||
f"만약(작업 == '항타', {r(sand, '기울기')} * 사질N + {r(sand, '절편')}, {pull(sand)})",
|
||||
"분/m",
|
||||
),
|
||||
st(
|
||||
"r2",
|
||||
f"만약(작업 == '항타', {r(clay, '기울기')} * 점질N + {r(clay, '절편')}, {pull(clay)})",
|
||||
"분/m",
|
||||
),
|
||||
st("길이", "사질층길이 + 점질층길이", "m"),
|
||||
st("r", "(r1 * 사질층길이 + r2 * 점질층길이) / 길이", "분/m"),
|
||||
st("k", look(f"{no} k", "k", 작업="작업", 파일="파일")),
|
||||
st("Tb", "r * 길이 * k", "분"),
|
||||
st("F", f"{look(f'{no} F0', 'F0', 작업='작업')} + {fsum(4)}"),
|
||||
],
|
||||
"(Ts + Tb) / F",
|
||||
{
|
||||
"작업": "항타",
|
||||
"파일": "H300",
|
||||
"사질층길이": 6,
|
||||
"사질N": 10,
|
||||
"점질층길이": 4,
|
||||
"점질N": 5,
|
||||
"f1": 0,
|
||||
"f2": 0,
|
||||
"f3": 0,
|
||||
"f4": 0,
|
||||
},
|
||||
cut=False,
|
||||
memo="Tc = (Ts+Tb)/F · Tb = r×ℓ×k · r = (r1ℓ1 + r2ℓ2)/(ℓ1+ℓ2) · F = F0 + (f1+f2+f3+f4)",
|
||||
)
|
||||
)
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"강널말뚝",
|
||||
"진동파일 해머 파일 1본당 시공시간 — 강널말뚝",
|
||||
"분/본",
|
||||
[
|
||||
inp("종류", "강널말뚝 종류", pick=C(f"{no} αK", "종류"), src=f"{s} 2 나 (1)"),
|
||||
inp("작업", "항타 · 인발", pick=["항타", "인발"], src=f"{s} 2 나"),
|
||||
inp(
|
||||
"해머",
|
||||
"진동파일해머 규격(162 = 유압식)",
|
||||
"㎾",
|
||||
C(f"{no} αK", "해머"),
|
||||
f"{s} 2 나 (1)",
|
||||
),
|
||||
inp("근입길이", "강널말뚝 길이(ℓ)", "m", src=f"{s} 2 나"),
|
||||
inp("Nmax", "최대 N치", src=f"{s} 2 나"),
|
||||
*fixes(no, 3, "2 나 (2)"),
|
||||
],
|
||||
[
|
||||
st("α", look(f"{no} αK", "α", 종류="종류", 작업="작업", 해머="해머")),
|
||||
st("K", look(f"{no} αK", "K", 종류="종류", 작업="'항타'", 해머="해머")),
|
||||
st("γ", look(f"{no} γ", "γ", 작업="작업")),
|
||||
st("F", f"{look(f'{no} F0널', 'F0', 작업=chr(39) + '항타' + chr(39))} + {fsum(3)}"),
|
||||
st(
|
||||
"F인발",
|
||||
f"{look(f'{no} F0널', 'F0', 작업=chr(39) + '항발' + chr(39))} + {fsum(3)}",
|
||||
),
|
||||
],
|
||||
f"(({c(no, '강널말뚝 시공시간 상수')} + γ * Nmax) * 근입길이 + α) * K / 만약(작업 == '항타', F, F인발)",
|
||||
{
|
||||
"종류": "III-Type (400×150×13)",
|
||||
"작업": "항타",
|
||||
"해머": 45,
|
||||
"근입길이": 10,
|
||||
"Nmax": 20,
|
||||
"f1": 0,
|
||||
"f2": 0,
|
||||
"f3": 0,
|
||||
},
|
||||
cut=False,
|
||||
memo="Tc = {(0.75+γ·Nmax)·ℓ+α}·K/F · K = 원문 항타 · 인발 두 줄에 걸친 한 칸(항타 줄 값) · 인발 F0 = 원문 「항발」 칸",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-25", "건설품셈 공통 8-2-25"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"워터제트",
|
||||
"진동파일해머(워터제트 병용 압입공) 파일 1본당 시공시간",
|
||||
"분/본",
|
||||
[
|
||||
inp("근입길이", "근입길이(L)", "m", src=f"{s} 2 가"),
|
||||
inp("평균N", "근입길이의 가중평균 N치", src=f"{s} 2 가"),
|
||||
inp("토질", "토질계수 표의 토질", pick=C(f"{no} α", "토질"), src=f"{s} 2 나"),
|
||||
inp(
|
||||
"α입력",
|
||||
"토질계수를 직접 넣을 때(여러 토질 가중평균) — 0 이면 표",
|
||||
src=f"{s} 2 나",
|
||||
rng=(0, "1.20"), # 원문 α 0.60 ∼ 1.20
|
||||
),
|
||||
*fixes(no, 4, "2 다 (2)"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"To",
|
||||
f"{c(no, '기본시공시간 계수')} * 근입길이 * (평균N + {c(no, '기본시공시간 N 가산')}) + "
|
||||
f"{c(no, '기본시공시간 상수')}",
|
||||
"분",
|
||||
),
|
||||
st("α", auto("α입력", look(f"{no} α", "α", 토질="토질"))),
|
||||
st(
|
||||
"F",
|
||||
f"{look(f'{no} F0', 'F0', 구분=chr(39) + '강널말뚝' + chr(39))} + {fsum(4)}",
|
||||
),
|
||||
],
|
||||
"To * α / F",
|
||||
{
|
||||
"근입길이": 12,
|
||||
"평균N": 40,
|
||||
"토질": "점성토",
|
||||
"α입력": 0,
|
||||
"f1": 0,
|
||||
"f2": 0,
|
||||
"f3": 0,
|
||||
"f4": 0,
|
||||
},
|
||||
cut=False,
|
||||
memo="Tc = To×α/F · To = 0.05L(N+42.5)+9.6 · F = F0 + (f1+f2+f3+f4)",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-26", "건설품셈 공통 8-2-26"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"압입인발",
|
||||
"유압식 압입 인발기 강널말뚝 1본당 시공시간",
|
||||
"분/본",
|
||||
[
|
||||
inp("작업", "압입 · 인발", pick=["압입", "인발"], src=f"{s} 2"),
|
||||
inp("파일길이", "파일길이(L)", "m", src=f"{s} 2 가"),
|
||||
inp("압입길이", "압입 · 인발 길이(ℓ)", "m", src=f"{s} 2 나"),
|
||||
inp("Nmax", "압입길이에 따른 최대 N치", src=f"{s} 2 나 (1)"),
|
||||
inp("규격", "압입 인발기 규격", pick=C(f"{no} k", "규격"), src=f"{s} 2 나 (2)"),
|
||||
*fixes(no, 3, "2 다"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"Ts",
|
||||
f"{c(no, '준비시간 계수(L당)')} * 파일길이 + {c(no, '준비시간 상수')}",
|
||||
"분",
|
||||
),
|
||||
st(
|
||||
"γ",
|
||||
f"{c(no, '압입 단위 작업시간 계수(Nmax당)')} * Nmax + {c(no, '압입 단위 작업시간 상수')}",
|
||||
),
|
||||
st("Tb", f"γ * 압입길이 * {look(f'{no} k', 'k', 규격='규격')}", "분"),
|
||||
st("F", f"{c(no, '작업계수 기본값')} + {fsum(3)}"),
|
||||
],
|
||||
f"만약(작업 == '압입', (Ts + Tb) / F, ({c(no, '인발 시간 계수(ℓ당)')} * 압입길이 + {c(no, '인발 시간 상수')}) / F)",
|
||||
{"작업": "압입", "파일길이": 12, "압입길이": 10, "Nmax": 20, "f1": 0, "f2": 0, "f3": 0},
|
||||
cut=False,
|
||||
memo="압입 Tc = (Ts+Tb)/F · 인발 Tc = (1.10ℓ+4.76)/F",
|
||||
)
|
||||
)
|
||||
return out
|
||||
@@ -1,121 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""작업량당 기계경비 로직(굴착기 · 불도저 · 로더 · 덤프트럭 · 롤러 · 대형브레이커) · 기계설비 13-2-7 아세틸렌량의 환산."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_로직 import inp, st
|
||||
|
||||
# ── 작업량당 기계경비 — 시간당 기계경비 로직 × 1/Q (원문 8-1-4 Q 를 품으로 · 산림 GF000089 꼴) ──
|
||||
COSTS = [ # (Q 로직 열쇠, 짧은 이름, 기계 이름, 시간당 경비 로직, 기계 상세구분)
|
||||
("공통 8-2-3 굴착기", "굴착기경비", "굴착기(무한궤도)", "GC000267", ("굴착기",)),
|
||||
("공통 8-2-1 불도저", "불도저경비", "불도저", "GC000269", ("불도저",)),
|
||||
("공통 8-2-5 로더", "로더경비", "로더", "GC000269", ("로더",)),
|
||||
("공통 8-2-8 덤프트럭", "덤프트럭경비", "덤프트럭", "GC000268", ("덤프트럭",)),
|
||||
(
|
||||
"공통 8-2-9 롤러토량",
|
||||
"롤러경비",
|
||||
"롤러",
|
||||
"GC000268",
|
||||
("머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"),
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
def costs(q_rows: dict, hourly: dict, machines: dict) -> list[dict]:
|
||||
"""`q_rows` = 열쇠 → Q 로직 · `hourly` = 키 → 시간당 경비 로직 · `machines` = 상세구분 → 분류번호 목록."""
|
||||
out = []
|
||||
for qkey, short, label, ref, kinds in COSTS:
|
||||
q = q_rows[qkey]
|
||||
base = {i["이름"]: i for i in hourly[ref]["입력"]}
|
||||
allowed = set(base["기계"]["고르기"])
|
||||
pick = [m for k in kinds for m in machines.get(k, []) if m in allowed]
|
||||
extra = [i for n, i in base.items() if n != "기계"]
|
||||
names = [i["이름"] for i in q["입력"]]
|
||||
call = ", ".join(f"{n}={n}" for n in names)
|
||||
sub = ", ".join(f"{i['이름']}={i['이름']}" for i in hourly[ref]["입력"])
|
||||
row = {
|
||||
"열쇠": f"{qkey.rsplit(' ', 1)[0]} {short}",
|
||||
"원문번호": q["원문번호"],
|
||||
"구분": q["구분"],
|
||||
"상세구분": q["상세구분"],
|
||||
"이름": f"{label} 작업량당 기계경비 — 건설 공통 {q['원문번호']}",
|
||||
"결과단위": "원/" + q["결과단위"].split("/")[0],
|
||||
"출처": f"{q['출처']} · 건설품셈 공통 8-1-4",
|
||||
"소유": "공용",
|
||||
"비고": f"시간당 기계경비({ref}) × 1/Q — Q = {qkey.split(' ', 1)[1]} 시간당 작업량 로직",
|
||||
"시험입력": {**q["시험입력"], "기계": pick[0]},
|
||||
"입력": [*q["입력"], {"이름": "기계", "설명": f"{label} 규격", "고르기": pick}, *extra],
|
||||
"중간": [st("작업량", f"로직({{L:{qkey}}}, {call})", q["결과단위"])],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "로직",
|
||||
"요소": f"로직({ref}, {sub})",
|
||||
"이름": label,
|
||||
"단위": "시간",
|
||||
"수량": "1 / 작업량",
|
||||
"출처": "건설품셈 공통 8-1-4",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
out.append(row)
|
||||
return out
|
||||
|
||||
|
||||
def breaker(hourly: dict) -> dict:
|
||||
"""대형브레이커 — 작업능력(표 범위 · 설계자 입력) → 굴착기+대형브레이커 시간당 경비 × 1/Q."""
|
||||
ins = hourly["GC000271"]["입력"]
|
||||
sub = ", ".join(f"{i['이름']}={i['이름']}" for i in ins)
|
||||
no, s = "8-2-13", "건설품셈 공통 8-2-13"
|
||||
return {
|
||||
"열쇠": f"공통 {no} 브레이커경비",
|
||||
"원문번호": no,
|
||||
"구분": "건설품셈 공통",
|
||||
"상세구분": "08장 건설기계",
|
||||
"이름": f"대형브레이커 작업량당 기계경비 — 건설 공통 {no}",
|
||||
"결과단위": "원/㎥",
|
||||
"출처": f"{s} 2",
|
||||
"소유": "공용",
|
||||
"비고": "작업능력 = 구조물 헐기(CC000065) · 굴착(CC000067) 표 범위 안에서 — 적용방법 다: 넓고 장해물 없음 상한치 · 약간 지장 평균치 · 협소 하한치 · 굴착기 0.4㎥ 조합 하한치(주⑤) · 보통인부 1인 · 치즐은 따로",
|
||||
"시험입력": {"작업능력": D("3.3"), "기계": "0201-0070", "브레이커": "0230-0007"},
|
||||
"입력": [
|
||||
inp("작업능력", "대형브레이커 작업능력(Q · 표 범위 안 값)", "㎥/hr", src=f"{s} 2"),
|
||||
*ins,
|
||||
],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "로직",
|
||||
"요소": f"로직(GC000271, {sub})",
|
||||
"이름": "굴착기+대형브레이커",
|
||||
"단위": "시간",
|
||||
"수량": "1 / 작업능력",
|
||||
"출처": f"{s} 2",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
|
||||
|
||||
def acetylene() -> dict:
|
||||
s = "건설품셈 기계설비 13-2-7"
|
||||
return {
|
||||
"열쇠": "기계설비 13-2-7 아세틸렌량의 환산",
|
||||
"원문번호": "13-2-7",
|
||||
"구분": "건설품셈 기계설비",
|
||||
"상세구분": "13장 플랜트설비공사",
|
||||
"이름": "아세틸렌량의 환산(ℓ → ㎏)",
|
||||
"결과단위": "㎏",
|
||||
"출처": s,
|
||||
"소유": "공용",
|
||||
"비고": "아세틸렌(㎏) = 아세틸렌(ℓ) × 26g/22.4ℓ ÷ 1,000 · 26g = 1mol당 분자량 · 22.4ℓ = 표준상태 1mol당량",
|
||||
"시험입력": {"아세틸렌부피": 1000},
|
||||
"입력": [inp("아세틸렌부피", "아세틸렌 부피", "ℓ", src=s)],
|
||||
"중간": [],
|
||||
"결과": {"식": "아세틸렌부피 * 26 / 22.4 / 1000", "출처": s},
|
||||
"끝수": None,
|
||||
}
|
||||
@@ -1,314 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2-27 ~ 8-2-33 로직(수중펌프 · TBM · 준설선 · 쇄암선 · 임목파쇄기 · 골재채취선) — `_건설기계_로직.py` 와 같은 꼴."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_로직 import LEVEL, auto, c, e_in, inp, logic, look, st
|
||||
|
||||
|
||||
def marine(C) -> list[dict]:
|
||||
out = []
|
||||
no, s = "8-2-27", "건설품셈 공통 8-2-27"
|
||||
crew = lambda n: look(f"{no} 설치", "수량", 명칭=repr(n)) # noqa: E731
|
||||
row = logic(
|
||||
no,
|
||||
"설치",
|
||||
"수중펌프 설치 및 해체(1개소당)",
|
||||
"원/개소",
|
||||
[],
|
||||
[],
|
||||
"",
|
||||
{},
|
||||
cut=False,
|
||||
src=f"{s} 5",
|
||||
)
|
||||
row.pop("결과")
|
||||
row.pop("시험입력")
|
||||
row["이름"] = "수중펌프 설치 및 해체" # 813-2 원문 제목 · 윗절
|
||||
row["호표"] = [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000001",
|
||||
"이름": "작업반장",
|
||||
"단위": "인",
|
||||
"수량": crew("작업반장"),
|
||||
"비목": "노무비",
|
||||
"출처": f"{s} 5",
|
||||
},
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000002",
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": crew("보통인부"),
|
||||
"비목": "노무비",
|
||||
"출처": f"{s} 5",
|
||||
},
|
||||
]
|
||||
row["덧줄"] = []
|
||||
out.append(row)
|
||||
no, s = "8-2-28", "건설품셈 공통 8-2-28"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"TBM",
|
||||
"터널전단면 굴착기(TBM) 1시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("굴착직경", "굴착직경(D)", "m", src=f"{s} 1"),
|
||||
inp("작업거리", "1회의 작업거리(ℓ · 장비 성능 · ø4.5m 때 1.2m)", "m", src=f"{s} 2"),
|
||||
inp("회전속도", "굴착면의 분당 회전속도(R)", "회/분", src=f"{s} 4"),
|
||||
inp("투과깊이", "굴착면 1회전당 컷터의 투과깊이(Pe)", "㎝/회", src=f"{s} 4"),
|
||||
inp("현장조건", "현장조건", pick=LEVEL, src=f"{s} 3"),
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("A", "3.14159265358979 * 굴착직경 * 굴착직경 / 4", "㎡"),
|
||||
st("T1", "작업거리 / (회전속도 * 투과깊이) * 100", "분"),
|
||||
st("cm", f"반올림(T1 + {c(no, '정치시간(T2)')}, 3)", "분"),
|
||||
st(
|
||||
"E", auto("E입력", look(f"{no} E", "E", 구분="'작업효율'", 현장조건="현장조건"))
|
||||
),
|
||||
],
|
||||
"60 * A * 작업거리 * E / cm",
|
||||
{
|
||||
"굴착직경": D("4.5"),
|
||||
"작업거리": D("1.2"),
|
||||
"회전속도": 8,
|
||||
"투과깊이": D("0.5"),
|
||||
"현장조건": "보통",
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="A = πD²/4 · cm = T1 + T2 · T1 = ℓ/(R×Pe)×100",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-29", "건설품셈 공통 8-2-29"
|
||||
es = [
|
||||
inp(f"E{i}", name, pick=C(f"{no} E{i}", "구분"), src=f"{s} 4")
|
||||
for i, name in ((1, "흙의 두께"), (2, "평면형상"), (3, "단면형상"), (4, "해상조건"))
|
||||
]
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"펌프준설",
|
||||
"펌프식 준설선 1시간당 준설능력",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("토질", "토질 분류", pick=C(f"{no} q", "토질"), src=f"{s} 2"),
|
||||
inp("N값", "기준 N값", pick=C(f"{no} q", "N값"), src=f"{s} 2"),
|
||||
inp("배송거리", "배송거리", "m", C(f"{no} q", "배송거리"), f"{s} 2"),
|
||||
inp(
|
||||
"q입력",
|
||||
"746㎾당 준설능력을 직접 넣을 때(단거리 능력 (q1+q2)/2 등) — 0 이면 표",
|
||||
"㎥/hr",
|
||||
src=f"{s} 3",
|
||||
rng=(0, 387), # 원문 q 표 32 ∼ 387
|
||||
),
|
||||
inp("전동환산출력", "펌프준설선의 전동환산 출력(bo)", "㎾", src=f"{s} 2"),
|
||||
*es,
|
||||
],
|
||||
[
|
||||
st(
|
||||
"q",
|
||||
auto(
|
||||
"q입력", look(f"{no} q", "q", 토질="토질", N값="N값", 배송거리="배송거리")
|
||||
),
|
||||
"㎥/hr",
|
||||
),
|
||||
st("E", " * ".join(look(f"{no} E{i}", "E", 구분=f"E{i}") for i in range(1, 5))),
|
||||
],
|
||||
f"q * 전동환산출력 * E / {c(no, '전동환산 기준 출력')}",
|
||||
{
|
||||
"토질": "사질토",
|
||||
"N값": 10,
|
||||
"배송거리": 3000,
|
||||
"q입력": 0,
|
||||
"전동환산출력": 3581,
|
||||
"E1": "적당",
|
||||
"E2": "적당",
|
||||
"E3": "적당",
|
||||
"E4": "보통",
|
||||
},
|
||||
memo="Q = q·bo·E/746 · E = E1×E2×E3×E4 · bo = 디젤 공칭 × 0.8 · 터빈 × 0.9",
|
||||
)
|
||||
)
|
||||
out += grab(C)
|
||||
return out
|
||||
|
||||
|
||||
def grab(C) -> list[dict]:
|
||||
out = []
|
||||
no, s = "8-2-30", "건설품셈 공통 8-2-30"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"그래브",
|
||||
"그래브 준설선 1시간당 준설량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("버킷용량", "버킷용량(q)", "㎥", C(f"{no} cm", "버킷용량"), f"{s} 3"),
|
||||
inp("f분류", "체적환산계수 표 토질 구분", pick=C(f"{no} f", "분류"), src=f"{s} 1"),
|
||||
inp("f상태", "체적환산계수 표 상태", pick=C(f"{no} f", "상태"), src=f"{s} 1"),
|
||||
inp(
|
||||
"fN값",
|
||||
"체적환산계수 표 N의 값(칸이 빈 줄 = 해당 없음)",
|
||||
pick=[*C(f"{no} f", "N값"), "해당 없음"],
|
||||
src=f"{s} 1",
|
||||
),
|
||||
inp(
|
||||
"f입력",
|
||||
"체적환산계수를 직접 넣을 때 — 0 이면 표",
|
||||
src=f"{s} 1",
|
||||
rng=(0, "1.00"),
|
||||
),
|
||||
inp("k분류", "버킷계수 표 토질 분류", pick=C(f"{no} k", "분류"), src=f"{s} 2"),
|
||||
inp("k상태", "버킷계수 표 상태", pick=C(f"{no} k", "상태"), src=f"{s} 2"),
|
||||
inp(
|
||||
"kN값",
|
||||
"버킷계수 표 N의 값(칸이 빈 줄 = 해당 없음)",
|
||||
pick=[*C(f"{no} k", "N값"), "해당 없음"],
|
||||
src=f"{s} 2",
|
||||
),
|
||||
inp("k입력", "버킷계수를 직접 넣을 때 — 0 이면 표", src=f"{s} 2", rng=(0, "1.00")),
|
||||
inp("평균수심", "평균수심", "m", src=f"{s} 3"),
|
||||
inp("E1", "흙의 두께", pick=C(f"{no} E1", "구분"), src=f"{s} 4 가"),
|
||||
inp("E2", "해상조건", pick=C(f"{no} E2", "구분"), src=f"{s} 4 나"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"f", auto("f입력", look(f"{no} f", "f", 분류="f분류", 상태="f상태", N값="fN값"))
|
||||
),
|
||||
st(
|
||||
"k",
|
||||
auto(
|
||||
"k입력",
|
||||
look(
|
||||
f"{no} k",
|
||||
"k",
|
||||
분류="k분류",
|
||||
상태="k상태",
|
||||
N값="kN값",
|
||||
버킷용량="버킷용량",
|
||||
),
|
||||
),
|
||||
),
|
||||
st(
|
||||
"cm",
|
||||
f"{look(f'{no} cm', '싸이클시간', 버킷용량='버킷용량')} + (평균수심 - {c(no, '기준 수심')}) * "
|
||||
f"{c(no, '수심 1m 증감당 싸이클시간 증감')}",
|
||||
"초",
|
||||
),
|
||||
st("E", f"{look(f'{no} E1', 'E', 구분='E1')} * {look(f'{no} E2', 'E', 구분='E2')}"),
|
||||
],
|
||||
"3600 * 버킷용량 * k * f * E / cm",
|
||||
{
|
||||
"버킷용량": D("3.0"),
|
||||
"f분류": "모래질토사",
|
||||
"f상태": "보통질",
|
||||
"fN값": "10∼20",
|
||||
"f입력": 0,
|
||||
"k분류": "모래질 토사",
|
||||
"k상태": "보통질",
|
||||
"kN값": "10∼20",
|
||||
"k입력": 0,
|
||||
"평균수심": 10,
|
||||
"E1": "적당",
|
||||
"E2": "보통",
|
||||
},
|
||||
memo="Q = 3,600·q·k·f·E/cm · E = E1×E2 · 수심 10m 기준 1m 증감마다 2초 증감 · 표의 괄호 값 = 쇄암 · 발파후 준설",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-31", "건설품셈 공통 8-2-31"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"쇄암선",
|
||||
"쇄암선(중추식) 시간당 작업능력",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("분류", "토질분류", pick=C(f"{no} S", "분류"), src=f"{s} 1"),
|
||||
inp("상태", "상태", pick=C(f"{no} S", "상태"), src=f"{s} 1"),
|
||||
inp("중추중량", "중추중량", "ton", C(f"{no} S", "중추중량"), f"{s} 1"),
|
||||
inp("E", "작업효율(원문 값 없음 — 설계자 입력)", src=f"{s} 3"),
|
||||
],
|
||||
[
|
||||
st("S", look(f"{no} S", "S", 분류="분류", 상태="상태", 중추중량="중추중량"), "㎡"),
|
||||
st("n", look(f"{no} n", "n", 분류="분류", 상태="상태", 중추중량="중추중량"), "회"),
|
||||
],
|
||||
f"60 * {c(no, '1층 쇄암 깊이(d)')} * S * E / ({c(no, '쇄암위치 이동 소요시간(t)')} + n / {c(no, '중추의 1분당 낙추횟수(P)')})",
|
||||
{"분류": "암반", "상태": "연질", "중추중량": 30, "E": D("0.7")},
|
||||
memo="Q = 60·d·S·E/(t + n/p)",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-32", "건설품셈 공통 8-2-32"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"임목파쇄기",
|
||||
"이동식 임목파쇄기 시간당 파쇄능력",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp(
|
||||
"규격",
|
||||
"임목파쇄기 규격",
|
||||
pick=["93.25㎾", *C(f"{no} K", "규격")],
|
||||
src=f"{s} 1 · 2",
|
||||
),
|
||||
inp(
|
||||
"스크린",
|
||||
"스크린 규격(354.35㎾ 이상)",
|
||||
pick=C(f"{no} S", "스크린"),
|
||||
src=f"{s} 2 라",
|
||||
),
|
||||
inp(
|
||||
"작업조건",
|
||||
"작업효율(354.35㎾ 이상)",
|
||||
pick=C(f"{no} E", "작업조건"),
|
||||
src=f"{s} 2 마",
|
||||
),
|
||||
],
|
||||
[],
|
||||
f"만약(규격 == '93.25㎾', {c(no, '93.25㎾ 작업량(Q)')}, {c(no, '354.35㎾ 시간당 표준파쇄량(q)')} * "
|
||||
f"{look(f'{no} K', 'K', 규격='규격')} * {look(f'{no} S', 'S', 스크린='스크린')} * {look(f'{no} E', 'E', 작업조건='작업조건')})",
|
||||
{"규격": "354.35㎾", "스크린": "75㎜", "작업조건": "보통"},
|
||||
memo="93.25㎾ Q = 6.0 · 354.35∼402.84㎾ Q = q·K·S·E",
|
||||
)
|
||||
)
|
||||
no, s = "8-2-33", "건설품셈 공통 8-2-33"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"골재채취선",
|
||||
"하천골재채취선 시간당 준설량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("분류", "구분", pick=C(f"{no} q", "분류"), src=f"{s} 2"),
|
||||
inp("상태", "상태", pick=C(f"{no} q", "상태"), src=f"{s} 2"),
|
||||
inp("배송거리", "배송거리", "m", C(f"{no} q", "배송거리"), f"{s} 2"),
|
||||
inp("출력", "하천골재채취선의 출력(b)", "㎾", src=f"{s} 1"),
|
||||
inp("조건", "천후, 평면형상, 위치 등", pick=C(f"{no} E", "조건"), src=f"{s} 3"),
|
||||
inp("유속", "유속", pick=C(f"{no} E", "유속"), src=f"{s} 3"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"q",
|
||||
look(f"{no} q", "q", 분류="분류", 상태="상태", 배송거리="배송거리"),
|
||||
"㎥/hr",
|
||||
),
|
||||
st("E", look(f"{no} E", "E", 조건="조건", 유속="유속")),
|
||||
],
|
||||
f"q * 출력 * E / {c(no, '기준 출력')}",
|
||||
{
|
||||
"분류": "모래질토사",
|
||||
"상태": "연질",
|
||||
"배송거리": 300,
|
||||
"출력": 746,
|
||||
"조건": "보통",
|
||||
"유속": "보통",
|
||||
},
|
||||
memo="Q = q·b·E/746",
|
||||
)
|
||||
)
|
||||
return out
|
||||
@@ -1,525 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2-10 ~ 8-2-21 로직(아스팔트 플랜트 · 크러셔 · 콘크리트 · 기관차 · 경운기) — `_건설기계_로직.py` 와 같은 꼴."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from decimal import Decimal as D
|
||||
|
||||
from _건설기계_로직 import F_IN, LEVEL, auto, c, e_in, inp, logic, look, mid, st
|
||||
|
||||
|
||||
def part2b(C) -> list[dict]:
|
||||
out = []
|
||||
# 8-2-10 아스팔트 플랜트
|
||||
no = "8-2-10"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"아스팔트플랜트",
|
||||
"아스팔트 플랜트 시간당 생산능력",
|
||||
"ton/hr",
|
||||
[
|
||||
inp(
|
||||
"플랜트규격",
|
||||
"플랜트 규격(ton)",
|
||||
pick=C(f"{no} 생산능력", "플랜트규격"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp(
|
||||
"혼합재",
|
||||
"혼합재의 종류(A 밀 조립식 안정처리 · B 아스팔트 · C 소일아스팔트 · D 샌드 아스팔트)",
|
||||
pick=C(f"{no} 생산능력", "혼합재"),
|
||||
src=f"건설품셈 공통 {no} 1 주②",
|
||||
),
|
||||
],
|
||||
[],
|
||||
look(f"{no} 생산능력", "생산능력", 플랜트규격="플랜트규격", 혼합재="혼합재"),
|
||||
{"플랜트규격": 60, "혼합재": "B"},
|
||||
memo="기계효율 80% 반영값 · 작업효율 적용 안 함 · 일생산 6시간(2)",
|
||||
)
|
||||
)
|
||||
# 8-2-11 스테이빌라이저
|
||||
no = "8-2-11"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"스테이빌라이저",
|
||||
"스테이빌라이저(노상안정기) 시간당 작업량",
|
||||
"㎡/hr",
|
||||
[
|
||||
inp("로터폭", "Rotor 폭", "m", src=f"건설품셈 공통 {no} 1"),
|
||||
inp(
|
||||
"작업조건",
|
||||
"작업 조건",
|
||||
pick=C(f"{no} E", "작업조건"),
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
inp("혼합횟수", "혼합횟수(P) — 0 이면 평균 3회", "회", src=f"건설품셈 공통 {no} 3"),
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("W", f"최대(로터폭 - {c(no, '유효혼합폭 — Rotor 폭에서 뺌')}, 0)", "m"),
|
||||
st("V", c(no, "작업속도(V)"), "m/hr"),
|
||||
st("P", auto("혼합횟수", c(no, "혼합횟수(평균)")), "회"),
|
||||
st("E", auto("E입력", look(f"{no} E", "E", 작업조건="작업조건"))),
|
||||
],
|
||||
"W * V * E / P",
|
||||
{"로터폭": D("2.4"), "작업조건": "보통의 경우", "혼합횟수": 0, "E입력": 0},
|
||||
memo="A = W·V·E/P · W = Rotor 폭 − 0.4m",
|
||||
)
|
||||
)
|
||||
out += crusher(C)
|
||||
# 8-2-14 압쇄기 · 8-2-16 골재세척설비 — Q = q × E
|
||||
for no, short, name, q in (
|
||||
("8-2-14", "압쇄기", "압쇄기(콘크리트 소할용) 시간당 작업량", "작업능력(q)"),
|
||||
("8-2-16", "골재세척", "골재세척설비 시간당 작업량", "시간당 표준작업량(q)"),
|
||||
):
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
short,
|
||||
name,
|
||||
"㎥/hr",
|
||||
[e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 값")],
|
||||
[
|
||||
st("q", c(no, q), "㎥/hr"),
|
||||
st("E", auto("E입력", c(no, "작업효율(E)"))),
|
||||
],
|
||||
"q * E",
|
||||
{"E입력": 0},
|
||||
memo="Q = q × E",
|
||||
)
|
||||
)
|
||||
# 8-2-15 법면다짐기
|
||||
no = "8-2-15"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"법면다짐기",
|
||||
"법면다짐기 시간당 작업량",
|
||||
"㎡/hr",
|
||||
[inp("구분", "장비", pick=C("CC000070", "구분"), src=f"건설품셈 공통 {no} 2")],
|
||||
[],
|
||||
look("CC000070", "작업량", 구분="구분"),
|
||||
{"구분": "유압식 진동콤팩터"},
|
||||
memo="유압식 진동콤팩터 + 굴착기 0.7㎥ · 법면다짐판 + 굴착기 1.0㎥(1)",
|
||||
)
|
||||
)
|
||||
# 8-2-17 콘크리트 믹서
|
||||
no = "8-2-17"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"믹서",
|
||||
"콘크리트 믹서 시간당 생산량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("믹서용량", "콘크리트 믹서용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.8"),
|
||||
],
|
||||
[st("E", auto("E입력", c(no, "작업효율(E)")))],
|
||||
f"60 / {c(no, '재료투입 혼합배출 등 작업시간')} * 믹서용량 * E",
|
||||
{"믹서용량": D("0.5"), "E입력": 0},
|
||||
memo="Q = 60/4 · q · E",
|
||||
)
|
||||
)
|
||||
# 8-2-18 콘크리트 배치플랜트
|
||||
no = "8-2-18"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"배치플랜트",
|
||||
"콘크리트 배치플랜트(강제 혼합식) 시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp(
|
||||
"규격",
|
||||
"배치플랜트 규격",
|
||||
pick=C(f"{no} q", "규격"),
|
||||
src=f"건설품셈 공통 {no} 1",
|
||||
),
|
||||
inp("슬럼프", "슬럼프", pick=C(f"{no} q", "슬럼프"), src=f"건설품셈 공통 {no} 1"),
|
||||
inp("공종", "공종", pick=C(f"{no} E", "공종"), src=f"건설품셈 공통 {no} 2"),
|
||||
inp(
|
||||
"현장조건",
|
||||
"현장조건",
|
||||
pick=C(f"{no} E", "현장조건"),
|
||||
src=f"건설품셈 공통 {no} 2",
|
||||
),
|
||||
inp(
|
||||
"싸이클",
|
||||
"1회 싸이클시간 갈래",
|
||||
pick=["표준", "터널 숏크리트 강섬유 혼합"],
|
||||
src=f"건설품셈 공통 {no} 주",
|
||||
),
|
||||
e_in(no),
|
||||
],
|
||||
[
|
||||
st("q", look(f"{no} q", "실용량", 규격="규격", 슬럼프="슬럼프"), "㎥"),
|
||||
st(
|
||||
"cm",
|
||||
f"만약(싸이클 == '표준', {c(no, '1회 싸이클시간(cm)')}, {c(no, '1회 싸이클시간 — 터널 숏크리트 강섬유 혼합')})",
|
||||
"분",
|
||||
),
|
||||
st("E", auto("E입력", look(f"{no} E", "E", 현장조건="현장조건", 공종="공종"))),
|
||||
],
|
||||
"60 * q * E / cm",
|
||||
{
|
||||
"규격": "60㎥/h (96㎾)",
|
||||
"슬럼프": "5㎝이상",
|
||||
"공종": "사방",
|
||||
"현장조건": "보통",
|
||||
"싸이클": "표준",
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="Q = 60·q·E/cm · 터널 숏크리트 매우 불량은 E입력 0.40(주②)",
|
||||
)
|
||||
)
|
||||
out += concrete_haul(C)
|
||||
# 8-2-20 기관차
|
||||
no = "8-2-20"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"기관차",
|
||||
"기관차 시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("기관차", "기관차 규격", pick=["5t", "7t"], src=f"건설품셈 공통 {no}"),
|
||||
inp("대차용량", "대차의 용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
inp("운반거리", "평균 운반편도(L)", "m", src=f"건설품셈 공통 {no}"),
|
||||
inp("재료", "적재 적하 재료", pick=["토사류", "석재류"], src=f"건설품셈 공통 {no}"),
|
||||
F_IN,
|
||||
inp("E", "작업효율(원문 값 없음 — 설계자 입력)", src=f"건설품셈 공통 {no}"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"n",
|
||||
f"만약(기관차 == '5t', {c(no, '1회 운반시 대차수(n) — 5t')}, {c(no, '1회 운반시 대차수(n) — 7t')})",
|
||||
"대",
|
||||
),
|
||||
st("C", "n * 대차용량", "㎥"),
|
||||
st(
|
||||
"t2",
|
||||
f"만약(재료 == '토사류', {c(no, '적재 적하 소요시간(t2) — 토사류')}, {c(no, '적재 적하 소요시간(t2) — 석재류')})",
|
||||
"분",
|
||||
),
|
||||
st(
|
||||
"N",
|
||||
f"반올림(60 / ({c(no, '입환소요시간(t1)')} + 운반거리 / {c(no, '적재시 주행속도(V1)')} + "
|
||||
f"운반거리 / {c(no, '공차시 주행속도(V2)')} + t2), 2)",
|
||||
"회/hr",
|
||||
),
|
||||
],
|
||||
"C * N * f * E",
|
||||
{
|
||||
"기관차": "5t",
|
||||
"대차용량": D("1.5"),
|
||||
"운반거리": 500,
|
||||
"재료": "토사류",
|
||||
"f": 1,
|
||||
"E": D("0.8"),
|
||||
},
|
||||
memo="Q = C·N·f·E · N = 60/(t1 + L/V1 + L/V2 + t2) · C = n × q",
|
||||
)
|
||||
)
|
||||
# 8-2-21 경운기
|
||||
no = "8-2-21"
|
||||
out.append(
|
||||
logic(
|
||||
no,
|
||||
"경운기",
|
||||
"경운기 시간당 작업량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("적재량", "흐트러진 상태의 1회 적재량(q)", "㎥", src=f"건설품셈 공통 {no}"),
|
||||
inp("거리", "운반거리(L)", "m", src=f"건설품셈 공통 {no} 1"),
|
||||
inp("종류", "재료 종류", pick=C("CC000071", "종류"), src=f"건설품셈 공통 {no} 2"),
|
||||
inp("작업로", "작업로 상태", pick=LEVEL, src=f"건설품셈 공통 {no} 2 주④"),
|
||||
F_IN,
|
||||
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.9"),
|
||||
],
|
||||
[
|
||||
st("t", look("CC000071", "시간", 종류="종류"), "분"),
|
||||
st(
|
||||
"V1",
|
||||
look("CC000072", "속도", 종류="종류", 구분="'적재'", 현장조건="작업로"),
|
||||
"m/분",
|
||||
),
|
||||
st(
|
||||
"V2",
|
||||
look("CC000072", "속도", 종류="종류", 구분="'적하'", 현장조건="작업로"),
|
||||
"m/분",
|
||||
),
|
||||
st("cm", "반올림(거리 / V1 + 거리 / V2 + t, 3)", "분"),
|
||||
st("E", auto("E입력", look("CC000073", "값", 항목="'작업효율(E)'"))),
|
||||
],
|
||||
"60 * 적재량 * f * E / cm",
|
||||
{
|
||||
"적재량": D("0.5"),
|
||||
"거리": 100,
|
||||
"종류": "토사류",
|
||||
"작업로": "보통",
|
||||
"f": 1,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="cm = L/V1 + L/V2 + t · 공차 속도 = 원문 「적하」 칸",
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def crusher(C) -> list[dict]:
|
||||
no, s = "8-2-12", "건설품셈 공통 8-2-12"
|
||||
jaw = lambda f: look(f"{no} 죠", f, 출구간격="출구간격", 규격="규격") # noqa: E731
|
||||
pick3 = inp("작업조건", "작업 조건", pick=LEVEL, src=f"{s} 1 다 주④")
|
||||
return [
|
||||
logic(
|
||||
no,
|
||||
"죠",
|
||||
"죠 크러셔 시간당 생산능력",
|
||||
"ton/hr",
|
||||
[
|
||||
inp("규격", "죠 크러셔 규격", pick=C(f"{no} 죠", "규격"), src=f"{s} 1 다"),
|
||||
inp("출구간격", "출구간격", "㎜", C(f"{no} 죠", "출구간격"), f"{s} 1 다"),
|
||||
pick3,
|
||||
],
|
||||
[],
|
||||
f"만약(작업조건 == '양호', {jaw('위')}, 만약(작업조건 == '보통', ({jaw('아래')} + {jaw('위')}) / 2, {jaw('아래')}))",
|
||||
{"규격": "025060", "출구간격": 40, "작업조건": "보통"},
|
||||
memo="양호 = 최대치 · 보통 = 평균치 · 불량 = 최소치(주④) · 단위용적중량 1.6ton/㎥ 기준",
|
||||
),
|
||||
logic(
|
||||
no,
|
||||
"롤",
|
||||
"롤 크러셔 시간당 생산능력",
|
||||
"ton/hr",
|
||||
[
|
||||
inp("규격", "롤 크러셔 규격", pick=C(f"{no} 롤", "규격"), src=f"{s} 1 라"),
|
||||
inp("출구간격", "출구간격", "㎜", C(f"{no} 롤", "출구간격"), f"{s} 1 라"),
|
||||
inp("작업조건", "작업 조건", pick=LEVEL, src=f"{s} 1 라 주③"),
|
||||
],
|
||||
[st("효율", look(f"{no} 롤효율", "효율", 작업조건="작업조건"), "%")],
|
||||
f"{look(f'{no} 롤', '생산능력', 출구간격='출구간격', 규격='규격')} * 효율 / 100",
|
||||
{"규격": "076063", "출구간격": 25, "작업조건": "보통"},
|
||||
memo="효율 양호 65% · 보통 50% · 불량 35%(주③)",
|
||||
),
|
||||
logic(
|
||||
no,
|
||||
"이동식",
|
||||
"이동식 크러셔 시간당 생산능력",
|
||||
"ton/hr",
|
||||
[
|
||||
inp(
|
||||
"규격", "이동식 크러셔 규격(ton)", pick=C(f"{no} 이동식", "규격"), src=f"{s} 2"
|
||||
),
|
||||
inp("출구간격", "출구간격", "㎜", C(f"{no} 이동식", "출구간격"), f"{s} 2"),
|
||||
inp("작업조건", "작업 조건(강자갈 = 양호)", pick=LEVEL, src=f"{s} 2 주③④"),
|
||||
],
|
||||
[st("E", look(f"{no} 이동식효율", "E", 작업조건="작업조건"))],
|
||||
f"{look(f'{no} 이동식', '생산능력', 규격='규격', 출구간격='출구간격')} * E",
|
||||
{"규격": 100, "출구간격": 25, "작업조건": "보통"},
|
||||
memo="괄호 값도 원문 칸 그대로 씀",
|
||||
),
|
||||
logic(
|
||||
no,
|
||||
"스크린",
|
||||
"스크린 전체 통과량",
|
||||
"ton/hr",
|
||||
[
|
||||
inp("체규격", "체의 규격", "㎜", C(f"{no} 스크린", "체규격"), f"{s} 1 마"),
|
||||
inp(
|
||||
"조합방법",
|
||||
"크러셔의 조합방법(롤 크러셔 = 1회통과식)",
|
||||
pick=C(f"{no} 스크린", "조합방법"),
|
||||
src=f"{s} 1 마",
|
||||
),
|
||||
inp(
|
||||
"택의수",
|
||||
"스크린택의 수",
|
||||
pick=C(f"{no} 계수A", "택의 수"),
|
||||
src=f"{s} 1 마 별표4",
|
||||
),
|
||||
inp(
|
||||
"B골재량",
|
||||
"스크린규격 1/2보다 작은 골재의 양",
|
||||
"%",
|
||||
C(f"{no} 계수B", "골재량"),
|
||||
f"{s} 1 마 별표4",
|
||||
),
|
||||
inp(
|
||||
"C규격",
|
||||
"돌을 직접 분사할 때 스크린의 규격",
|
||||
"㎜",
|
||||
C(f"{no} 계수C", "스크린규격"),
|
||||
f"{s} 1 마 별표4",
|
||||
),
|
||||
inp(
|
||||
"D골재량",
|
||||
"스크린 규격보다 큰 골재의 양",
|
||||
"%",
|
||||
C(f"{no} 계수D", "골재량"),
|
||||
f"{s} 1 마 별표4",
|
||||
),
|
||||
inp(
|
||||
"재료", "재료의 종류", pick=C(f"{no} 계수E", "재료분석"), src=f"{s} 1 마 별표4"
|
||||
),
|
||||
inp("체면적", "체적면적", "㎠", src=f"{s} 1 마 주⑤"),
|
||||
],
|
||||
[
|
||||
st(
|
||||
"통과능력",
|
||||
look(f"{no} 스크린", "통과능력", 체규격="체규격", 조합방법="조합방법"),
|
||||
"ton/hr",
|
||||
),
|
||||
st("A", look(f"{no} 계수A", "계수", **{"'택의 수'": "택의수"})),
|
||||
st("B", look(f"{no} 계수B", "계수", 골재량="B골재량")),
|
||||
st("C", look(f"{no} 계수C", "계수", 스크린규격="C규격")),
|
||||
st("D", look(f"{no} 계수D", "계수", 골재량="D골재량")),
|
||||
st("E", look(f"{no} 계수E", "계수", 재료분석="재료")),
|
||||
],
|
||||
"통과능력 * A * B * C * D * E * 체면적 / 930",
|
||||
{
|
||||
"체규격": 25,
|
||||
"조합방법": "1회통과식",
|
||||
"택의수": 1,
|
||||
"B골재량": 40,
|
||||
"C규격": D("28.0"),
|
||||
"D골재량": 30,
|
||||
"체면적": 930,
|
||||
},
|
||||
memo="통과량 = 930㎠당 통과능력 × A×B×C×D×E × 체적면적 × 1/930(주⑤ 예시)",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
def concrete_haul(C) -> list[dict]:
|
||||
no, s = "8-2-19", "건설품셈 공통 8-2-19"
|
||||
plant = [
|
||||
inp("플랜트실용량", "콘크리트플랜트 믹서 실용량(q)", "㎥", src="건설품셈 공통 8-2-18 1"),
|
||||
inp(
|
||||
"플랜트싸이클",
|
||||
"콘크리트플랜트 싸이클시간(cmc) — 0 이면 1.5분",
|
||||
"분",
|
||||
src="건설품셈 공통 8-2-18",
|
||||
),
|
||||
]
|
||||
cmc = auto("플랜트싸이클", c("8-2-18", "1회 싸이클시간(cm)"))
|
||||
e = e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.95")
|
||||
e_step = st("E", auto("E입력", look(f"{no} 상수", "아래", 항목="'작업효율(E)'")))
|
||||
return [
|
||||
logic(
|
||||
no,
|
||||
"믹서트럭",
|
||||
"콘크리트 믹서트럭 시간당 운반량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("적재용량", "믹서트럭 적재용량(W)", "㎥", src=f"{s} 1"),
|
||||
*plant,
|
||||
inp("운반거리", "운반거리(편도)", "㎞", src=f"{s} 1"),
|
||||
inp("적재속도", "적재시 평균주행속도", "㎞/hr", src=f"{s} 1"),
|
||||
inp("공차속도", "공차시 평균주행속도", "㎞/hr", src=f"{s} 1"),
|
||||
inp("슬럼프", "슬럼프", pick=["4㎝ 이하", "5㎝ 이상"], src=f"{s} 1"),
|
||||
inp("펌프조합", "콘크리트 펌프와 조합작업", pick=["아니오", "예"], src=f"{s} 1"),
|
||||
inp(
|
||||
"배출시간입력",
|
||||
"배출시간(t3) — 0 이면 원문 범위 가운데",
|
||||
"분",
|
||||
src=f"{s} 1",
|
||||
rng=(0, 4),
|
||||
),
|
||||
inp(
|
||||
"대기시간입력",
|
||||
"대기시간(t4) — 0 이면 원문 범위 가운데",
|
||||
"분",
|
||||
src=f"{s} 1",
|
||||
rng=(0, 10),
|
||||
),
|
||||
e,
|
||||
],
|
||||
[
|
||||
st("cmc", cmc, "분"),
|
||||
st("t1", "적재용량 / 플랜트실용량 * cmc", "분"),
|
||||
st("t2", "(운반거리 / 적재속도 + 운반거리 / 공차속도) * 60", "분"),
|
||||
st(
|
||||
"t3",
|
||||
f"{auto('배출시간입력', f'만약(슬럼프 == {chr(39)}4㎝ 이하{chr(39)}, {mid(no, "믹서트럭 배출시간 — 슬럼프 4㎝ 이하")}, {mid(no, "믹서트럭 배출시간 — 슬럼프 5㎝ 이상")})')}"
|
||||
f" + 만약(펌프조합 == '예', {look(f'{no} 상수', '아래', 항목=chr(39) + '믹서트럭 배출시간 — 콘크리트 펌프 조합 가산' + chr(39))}, 0)",
|
||||
"분",
|
||||
),
|
||||
st("t4", auto("대기시간입력", mid(no, "믹서트럭 대기시간(t4)")), "분"),
|
||||
st("cm", "반올림(t1 + t2 + t3 + t4, 3)", "분"),
|
||||
e_step,
|
||||
],
|
||||
"60 * 적재용량 * E / cm",
|
||||
{
|
||||
"적재용량": 6,
|
||||
"플랜트실용량": 1,
|
||||
"플랜트싸이클": 0,
|
||||
"운반거리": 5,
|
||||
"적재속도": 30,
|
||||
"공차속도": 35,
|
||||
"슬럼프": "5㎝ 이상",
|
||||
"펌프조합": "아니오",
|
||||
"배출시간입력": 0,
|
||||
"대기시간입력": 0,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="cm = t1 + t2 + t3 + t4 · t1 = w/q·cmc · t2 = 거리/속도 × 60(분) · 범위(배출 2∼3 · 3∼4 · 대기 5∼10)는 가운데 기본",
|
||||
),
|
||||
logic(
|
||||
no,
|
||||
"덤프",
|
||||
"콘크리트 덤프트럭 시간당 운반량",
|
||||
"㎥/hr",
|
||||
[
|
||||
inp("규격", "덤프트럭 규격(톤)", pick=C(f"{no} W", "규격"), src=f"{s} 2 가"),
|
||||
*plant,
|
||||
inp("운반거리", "편도운반거리(L · 15㎞까지)", "㎞", src=f"{s} 2 나"),
|
||||
inp(
|
||||
"하역시간입력",
|
||||
"하역시간(t1) — 0 이면 원문 범위 가운데",
|
||||
"분",
|
||||
src=f"{s} 2",
|
||||
rng=(0, 2),
|
||||
),
|
||||
inp(
|
||||
"대기시간입력",
|
||||
"대기시간(t2) — 0 이면 원문 범위 가운데",
|
||||
"분",
|
||||
src=f"{s} 2",
|
||||
rng=(0, 10),
|
||||
),
|
||||
e,
|
||||
],
|
||||
[
|
||||
st("W", look(f"{no} W", "W", 규격="규격"), "㎥"),
|
||||
st("cmc", cmc, "분"),
|
||||
st(
|
||||
"cm1",
|
||||
f"{look(f'{no} 주행', '기울기', 구분=chr(39) + '표준치' + chr(39))} * 운반거리 + "
|
||||
f"{look(f'{no} 주행', '절편', 구분=chr(39) + '표준치' + chr(39))}",
|
||||
"분",
|
||||
),
|
||||
st(
|
||||
"cm2",
|
||||
f"W / 플랜트실용량 * cmc + {auto('하역시간입력', mid(no, '덤프트럭 하역시간(t1)'))} + "
|
||||
f"{auto('대기시간입력', mid(no, '덤프트럭 대기시간(t2)'))}",
|
||||
"분",
|
||||
),
|
||||
st("cm", "반올림(cm1 + cm2, 3)", "분"),
|
||||
e_step,
|
||||
],
|
||||
"60 * W * E / cm",
|
||||
{
|
||||
"규격": D("10.5"),
|
||||
"플랜트실용량": 1,
|
||||
"플랜트싸이클": 0,
|
||||
"운반거리": 5,
|
||||
"하역시간입력": 0,
|
||||
"대기시간입력": 0,
|
||||
"E입력": 0,
|
||||
},
|
||||
memo="cm = cm1 + cm2 · cm1 = 3L + 5(±5) · cm2 = w/q·cmc + t1 + t2",
|
||||
),
|
||||
]
|
||||
@@ -1,233 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8장 건설기계 본문 md 읽기 · 표 모양 도우미 — `build_로직_건설품셈_08장_건설기계.py` 가 씀.
|
||||
|
||||
- 절 = 본문 `8-02-NN_*.md` 한 파일(머리 ~ 다음 같은 · 윗 단계 머리 앞 · 요구 630).
|
||||
- 칸 값 = 원문 글자 그대로의 수(`N`) · 「a∼b」 = [아래, 위] · 괄호 · 동그라미 번호 · 단위 붙은 수 = 수 + `<칸>원문`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
ROOT = HERE.parents[2]
|
||||
DIR = (
|
||||
ROOT
|
||||
/ "resources/knowledge/original/원가계산/건설공사_표준품셈/본문/01_공통부문/제08장_건설기계"
|
||||
)
|
||||
NUM = r"-?\d[\d,]*(?:\.\d+)?"
|
||||
HEAD = {"구분": "건설품셈 공통", "상세구분": "08장 건설기계"}
|
||||
|
||||
|
||||
class N(str):
|
||||
"""원문 그대로의 수 글자."""
|
||||
|
||||
|
||||
def section(no: str) -> list[str]:
|
||||
"""`8-2-12` → 그 절 md 줄(머리 뒤 · 글자층 밖 표시 뗌)."""
|
||||
a, b, c = no.split("-")
|
||||
path = next(DIR.glob(f"{a}-{int(b):02d}-{int(c):02d}_*.md"))
|
||||
text = re.sub(r"<!-- /?글자층 밖 -->", "", path.read_text(encoding="utf-8"))
|
||||
lines = text.split("\n")
|
||||
at = next(i for i, x in enumerate(lines) if x.startswith(f"### {no}"))
|
||||
return lines[at:]
|
||||
|
||||
|
||||
def _cell(c: str) -> str:
|
||||
c = re.sub(r"\s*<br>\s*", " ", c.strip())
|
||||
return re.sub(r"\s*∼\s*", "∼", c)
|
||||
|
||||
|
||||
def tables(lines: list[str]) -> list[tuple[list[list[str]], list[str]]]:
|
||||
"""md 표마다 (줄 칸 목록, 바로 뒤 [주] 줄) — 구분줄은 뺌."""
|
||||
out, i = [], 0
|
||||
while i < len(lines):
|
||||
if not lines[i].startswith("|"):
|
||||
i += 1
|
||||
continue
|
||||
rows = []
|
||||
while i < len(lines) and lines[i].startswith("|"):
|
||||
cells = [_cell(c) for c in lines[i].strip().strip("|").split("|")]
|
||||
if not all(re.fullmatch(r":?-+:?", c) for c in cells):
|
||||
rows.append(cells)
|
||||
i += 1
|
||||
note, j = [], i
|
||||
while j < len(lines) and not lines[j].strip():
|
||||
j += 1
|
||||
if j < len(lines) and lines[j].strip().startswith("[주]"):
|
||||
first = lines[j].strip().removeprefix("[주]").strip()
|
||||
note = [first] if first else []
|
||||
for x in lines[j + 1 :]:
|
||||
if not x.strip() or x.startswith(("|", "#", "<!--")):
|
||||
break
|
||||
note.append(x.strip())
|
||||
out.append((rows, note))
|
||||
return out
|
||||
|
||||
|
||||
def text_lines(lines: list[str], *starts: str) -> list[str]:
|
||||
"""글 줄 가운데 `starts` 로 시작하는 줄(표 밖 원문 글 그대로)."""
|
||||
return [x.strip() for x in lines if x.strip().startswith(starts)]
|
||||
|
||||
|
||||
def lab(x: str):
|
||||
"""조건 칸 글 — 수만 있으면 수."""
|
||||
x = x.strip()
|
||||
return N(x.replace(",", "")) if re.fullmatch(NUM, x) else x
|
||||
|
||||
|
||||
def val(c: str):
|
||||
"""값 칸 → (값, 원문) · 빈 칸 · 「-」 = (None, None)."""
|
||||
c = c.strip()
|
||||
if c in ("", "-", "―", "〃"):
|
||||
return None, None
|
||||
if re.fullmatch(NUM, c):
|
||||
return N(c.replace(",", "")), None
|
||||
m = re.fullmatch(rf"({NUM})∼({NUM})", c)
|
||||
if m:
|
||||
return [N(m[1].replace(",", "")), N(m[2].replace(",", ""))], None
|
||||
m = re.fullmatch(rf"[((]?[①-⑩]?\(?({NUM})\)?[㎥㎾분개/hrm]*", c)
|
||||
if m and m[1] != c:
|
||||
return N(m[1].replace(",", "")), c
|
||||
return c, None
|
||||
|
||||
|
||||
def put(row: dict, col: str, c: str) -> bool:
|
||||
v, o = val(c)
|
||||
if v is None:
|
||||
return False
|
||||
row[col] = v
|
||||
if o is not None:
|
||||
row[col + "원문"] = o
|
||||
return True
|
||||
|
||||
|
||||
def grid(
|
||||
rows, keys: list[str], heads: list[dict], name: str, fill: int | None = None
|
||||
) -> list[dict]:
|
||||
"""줄 머리(`keys` · 앞 `fill` 칸은 빈 칸이면 윗줄) × 열 머리(`heads` · 칸마다 조건 묶음) → 긴 줄."""
|
||||
out, last = [], [""] * len(keys)
|
||||
fill = len(keys) if fill is None else fill
|
||||
for r in rows:
|
||||
labels = [
|
||||
last[i] if x in ("", "〃") and i < fill else x for i, x in enumerate(r[: len(keys)])
|
||||
]
|
||||
last = labels
|
||||
for head, c in zip(heads, r[len(keys) :]):
|
||||
row = {k: lab(v) for k, v in zip(keys, labels) if v}
|
||||
row.update(head)
|
||||
if put(row, name, c):
|
||||
out.append(row)
|
||||
return out
|
||||
|
||||
|
||||
def plain(rows, cols: list[str], fill: int = 1, keys: int | None = None) -> list[dict]:
|
||||
"""줄마다 열 이름대로 · 앞 `keys` 칸은 조건 글(앞 `fill` 칸은 빈 칸이면 윗줄) · 값 없는 줄은 뺌."""
|
||||
out, last = [], [""] * len(cols)
|
||||
keys = fill if keys is None else keys
|
||||
for r in rows:
|
||||
row, got = {}, False
|
||||
for i, (col, c) in enumerate(zip(cols, r)):
|
||||
if i < keys:
|
||||
c = last[i] if c in ("", "〃") and i < fill else c
|
||||
last[i] = c
|
||||
if c:
|
||||
row[col] = lab(c)
|
||||
elif col:
|
||||
got = put(row, col, c) or got
|
||||
if got:
|
||||
out.append(row)
|
||||
return out
|
||||
|
||||
|
||||
def heads(*axes: tuple[str, list]) -> list[dict]:
|
||||
"""열 머리 조건 묶음 — 축(이름, 값 목록)들의 곱(앞 축이 바깥)."""
|
||||
out = [{}]
|
||||
for name, values in axes:
|
||||
out = [{**h, name: lab(str(v)) if isinstance(v, str) else v} for h in out for v in values]
|
||||
return out
|
||||
|
||||
|
||||
def table(label, name, src, cond, cols, rows, *, note=(), base="", memo=None, rule=None):
|
||||
t = {"열쇠": label, "이름": name, "기준": base, "출처": src}
|
||||
if memo:
|
||||
t["비고"] = memo
|
||||
t["용도"] = None # 빌더가 채움
|
||||
t["조건"] = cond
|
||||
if rule:
|
||||
t["범위규칙"] = rule
|
||||
t["값칸"] = cols
|
||||
t["줄"] = rows
|
||||
t["주"] = list(note)
|
||||
return t
|
||||
|
||||
|
||||
def conds(rows: list[dict], names: list[str]) -> dict:
|
||||
"""조건 종류 — 모두 수면 「수」 · 아니면 「고르기」(수도 글로 바꿈)."""
|
||||
out = {}
|
||||
for n in names:
|
||||
vals = [r[n] for r in rows if n in r]
|
||||
if vals and all(isinstance(v, N) for v in vals):
|
||||
out[n] = "수"
|
||||
else:
|
||||
out[n] = "고르기"
|
||||
for r in rows:
|
||||
if n in r and isinstance(r[n], N):
|
||||
r[n] = str(r[n])
|
||||
return out
|
||||
|
||||
|
||||
# ── 쓰기 — 8장 계수 파일 글 모양(머리 넷 한 줄 · 조건 · 값칸 · 줄은 펼침) ──
|
||||
def atom(v) -> str:
|
||||
import json
|
||||
|
||||
if isinstance(v, N):
|
||||
return str(v)
|
||||
if isinstance(v, bool) or v is None:
|
||||
return json.dumps(v)
|
||||
if isinstance(v, int):
|
||||
return str(v)
|
||||
if isinstance(v, list):
|
||||
return "[" + ", ".join(atom(x) for x in v) + "]"
|
||||
if isinstance(v, dict):
|
||||
return (
|
||||
"{"
|
||||
+ ", ".join(f"{json.dumps(k, ensure_ascii=False)}: {atom(x)}" for k, x in v.items())
|
||||
+ "}"
|
||||
)
|
||||
return json.dumps(v, ensure_ascii=False)
|
||||
|
||||
|
||||
def _block(d: dict, pad: str) -> str:
|
||||
import json
|
||||
|
||||
if not d:
|
||||
return "{}"
|
||||
body = ",\n".join(
|
||||
f"{pad} {json.dumps(k, ensure_ascii=False)}: {atom(v)}" for k, v in d.items()
|
||||
)
|
||||
return "{\n" + body + "\n" + pad + "}"
|
||||
|
||||
|
||||
def emit(t: dict) -> str:
|
||||
import json
|
||||
|
||||
head = ", ".join(f'"{k}": {atom(t[k])}' for k in ("키", "원문번호", "구분", "상세구분"))
|
||||
out = [" {", f" {head},"]
|
||||
for k in ("이름", "기준", "출처", "비고", "용도"):
|
||||
if k in t:
|
||||
out.append(f" {json.dumps(k, ensure_ascii=False)}: {atom(t[k])},")
|
||||
out.append(f' "조건": {_block(t["조건"], " ")},')
|
||||
if "범위규칙" in t:
|
||||
out.append(f' "범위규칙": {atom(t["범위규칙"])},')
|
||||
out.append(f' "값칸": {_block(t["값칸"], " ")},')
|
||||
rows = ",\n".join(" " + _block(r, " ") for r in t["줄"])
|
||||
out.append(' "줄": [\n' + rows + "\n ],")
|
||||
if t["주"]:
|
||||
notes = ",\n".join(" " + atom(x) for x in t["주"])
|
||||
out.append(' "주": [\n' + notes + "\n ]")
|
||||
else:
|
||||
out.append(' "주": []')
|
||||
out.append(" }")
|
||||
return "\n".join(out)
|
||||
@@ -1,653 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2 시공능력 — 계수 표(절마다 원문 md 표 전부 + 표 밖 글 속 상수) · 8-2-2 ~ 8-2-21.
|
||||
|
||||
`build_로직_건설품셈_08장_건설기계.py` 가 부름 · 8-2-22 ~ 8-2-33 은 `_건설기계_표2.py`.
|
||||
표 열쇠 = 「공통 <절> <짧은 이름>」 — 로직 식의 `{T:<절> <짧은 이름>}` 가 키로 바뀜.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
|
||||
from _건설기계_읽기 import N, conds, grid, heads, lab, plain, put, section, table, tables
|
||||
|
||||
LEVEL = ["양호", "보통", "불량"]
|
||||
|
||||
|
||||
def tb(no, short, name, src, keys, cols, rows, **kw):
|
||||
"""표 하나 — 조건 종류는 줄에서 셈 · 출처 = 「건설품셈 공통 <절> <항>」."""
|
||||
t = table(
|
||||
f"공통 {no} {short}",
|
||||
name,
|
||||
f"건설품셈 공통 {no} {src}".strip(),
|
||||
conds(rows, keys),
|
||||
cols,
|
||||
rows,
|
||||
**kw,
|
||||
)
|
||||
t["원문번호"] = no
|
||||
return t
|
||||
|
||||
|
||||
def const(no, lines, items, name="산정식 상수", src="", note=(), memo=None):
|
||||
"""표 밖 글 속 상수 — (항목, 값 글, 단위[, 위 값 글]) · 값은 원문 글에 있어야 함."""
|
||||
text = "\n".join(lines)
|
||||
rows = []
|
||||
for item in items:
|
||||
what, low, unit, *high = item
|
||||
for v in (low, *high):
|
||||
assert re.search(rf"(?<![\d.]){re.escape(v)}(?![\d])", text.replace(",", "")), (no, v)
|
||||
row = {"항목": what}
|
||||
if high:
|
||||
row["아래"], row["위"] = N(low), N(high[0])
|
||||
else:
|
||||
row["값"] = N(low)
|
||||
row["단위"] = unit
|
||||
rows.append(row)
|
||||
cols = {"아래": "수", "위": "수"} if any("아래" in r for r in rows) else {}
|
||||
if any("값" in r for r in rows):
|
||||
cols = {"값": "수", **cols}
|
||||
return tb(no, "상수", name, src, ["항목"], cols, rows, note=note, memo=memo)
|
||||
|
||||
|
||||
def pick(t, i, j):
|
||||
return t[i][0][j] if isinstance(j, int) else t[i][0]
|
||||
|
||||
|
||||
# ── 8-2-2 리퍼 ──────────────────────────────────────────────────────
|
||||
def s2():
|
||||
no, S = "8-2-2", section("8-2-2")
|
||||
T = tables(S)
|
||||
an, e, rock = T[0][0], T[1][0], T[2][0]
|
||||
rows_e, last = [], ["", ""]
|
||||
for r in e[2:]:
|
||||
last = [r[0] or last[0], r[1] or last[1]]
|
||||
for size, (v, x) in (("20", (r[2], r[3])), ("30", (r[4], r[5]))):
|
||||
rows_e.append(
|
||||
{
|
||||
"암질": last[0],
|
||||
"발톱수": last[1],
|
||||
"규격": N(size),
|
||||
"탄성파속도": lab(v),
|
||||
"E": N(x),
|
||||
}
|
||||
)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"An",
|
||||
"1회 리핑단면적(An)",
|
||||
"1",
|
||||
["규격", "발톱수"],
|
||||
{"An": "㎡"},
|
||||
grid(an[2:], ["규격"], heads(("발톱수", ["1본", "2본", "3본"])), "An"),
|
||||
note=T[0][1],
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"2",
|
||||
["암질", "발톱수", "규격", "탄성파속도"],
|
||||
{"E": ""},
|
||||
rows_e,
|
||||
memo="규격 = 트랙터 ton 급 · 탄성파속도 = m/sec",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"탄성파",
|
||||
"암질과 탄성파속도와의 관계",
|
||||
"2 주",
|
||||
["암의 종류", "암질"],
|
||||
{"탄성파속도": "m/sec"},
|
||||
grid(rock[2:], ["암의 종류"], heads(("암질", ["연질", "중질", "경질"])), "탄성파속도"),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[("cm 작업거리 계수", "0.05", "분/m"), ("cm 기본시간", "0.25", "분")],
|
||||
memo="cm = 0.05ℓ + 0.25 (원문 산정식)",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-4 트랜처 ────────────────────────────────────────────────────
|
||||
def s4():
|
||||
no, S = "8-2-4", section("8-2-4")
|
||||
T = tables(S)
|
||||
d = [
|
||||
{"굴착심도": N(h.removesuffix("m")), "d": N(v)}
|
||||
for h, v in zip(T[0][0][0][1:7], T[0][0][1][1:7])
|
||||
]
|
||||
notes = [x.strip() for x in S if re.match(r"^[①-⑤] ", x.strip())]
|
||||
return [
|
||||
tb(no, "d", "굴착심도 계수(d)", "2 가", ["굴착심도"], {"d": ""}, d, base="굴착심도 m"),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"2 나",
|
||||
["토질", "작업조건"],
|
||||
{"E": ""},
|
||||
grid(T[1][0][1:], ["토질"], heads(("작업조건", LEVEL)), "E"),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("흡수관 삽입 및 수평조절시간(t1)", "2.33", "분/열"),
|
||||
("전진속도(V1)", "5.3", "m/분"),
|
||||
("후진속도(V2)", "15.6", "m/분"),
|
||||
("회전 및 기어 변속 · 흡수관 끝봉합 시간(t3)", "2.5", "분/열"),
|
||||
],
|
||||
src="2 다",
|
||||
note=notes,
|
||||
memo="V1 = d 0.7m 일 때 기준",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-6 모터 스크레이퍼 ──────────────────────────────────────────
|
||||
def s6():
|
||||
no, S = "8-2-6", section("8-2-6")
|
||||
T = tables(S)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"K",
|
||||
"적재계수(K)",
|
||||
"1",
|
||||
["토질상태"],
|
||||
{"K": ""},
|
||||
plain(T[0][0][1:], ["토질상태", "K"]),
|
||||
note=T[0][1],
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"2",
|
||||
["현장조건"],
|
||||
{"E": ""},
|
||||
plain(T[1][0][1:], ["현장조건", "E"]),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"V",
|
||||
"적재시·공차시 주행속도(V1 · V2)",
|
||||
"4",
|
||||
["도로상태"],
|
||||
{"적재시": "m/분", "공차시": "m/분"},
|
||||
plain(T[2][0][2:], ["도로상태", "적재시", "공차시"]),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("적토·사토·기어변속시간(t) — 푸쉬도우저 사용", "1.6", "분"),
|
||||
("적토·사토·기어변속시간(t) — 푸쉬도우저 사용 안 함", "2.8", "분"),
|
||||
],
|
||||
src="3",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-7 모터 그레이더 ────────────────────────────────────────────
|
||||
def s7():
|
||||
no, S = "8-2-7", section("8-2-7")
|
||||
T = tables(S)
|
||||
v = grid(
|
||||
T[0][0][2:],
|
||||
["작업종류"],
|
||||
heads(("구분", ["작업", "후진", "회송"]), ("현장조건", LEVEL)),
|
||||
"속도",
|
||||
)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"V",
|
||||
"작업·후진·회송 속도(V1 · V2)",
|
||||
"1",
|
||||
["작업종류", "구분", "현장조건"],
|
||||
{"속도": "㎞/hr"},
|
||||
v,
|
||||
note=T[0][1],
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"t",
|
||||
"방향 변환·블레이드 선회 기어변속 시간(t)",
|
||||
"1",
|
||||
["작업종류"],
|
||||
{"t": "분"},
|
||||
plain(T[1][0][1:], ["작업종류", "t"]),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"l",
|
||||
"블레이드 유효길이(ℓ)",
|
||||
"2",
|
||||
["작업종류"],
|
||||
{"작업각도": "", "유효길이": "m(블레이드의 길이 3.6m)"},
|
||||
plain(T[2][0][1:], ["작업종류", "작업각도", "유효길이"]),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"3",
|
||||
["작업종류", "현장조건"],
|
||||
{"E": ""},
|
||||
grid(T[3][0][2:], ["작업종류"], heads(("현장조건", LEVEL)), "E"),
|
||||
note=T[3][1],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-10 아스팔트 플랜트 ─────────────────────────────────────────
|
||||
def s10():
|
||||
no, S = "8-2-10", section("8-2-10")
|
||||
T = tables(S)
|
||||
rows = grid(T[0][0][2:], ["플랜트규격"], heads(("혼합재", ["A", "B", "C", "D"])), "생산능력")
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"생산능력",
|
||||
"시간당 생산능력 표준",
|
||||
"1",
|
||||
["플랜트규격", "혼합재"],
|
||||
{"생산능력": "ton/hr"},
|
||||
rows,
|
||||
note=T[0][1],
|
||||
base="플랜트규격 ton",
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("기계효율", "80", "%"),
|
||||
("일생산시간", "6", "시간"),
|
||||
("준비예열 및 끝맺음시간", "1", "시간"),
|
||||
],
|
||||
name="기계효율 · 실작업시간",
|
||||
src="2",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-11 스테이빌라이저 ──────────────────────────────────────────
|
||||
def s11():
|
||||
no, S = "8-2-11", section("8-2-11")
|
||||
e = []
|
||||
for line in S:
|
||||
m = re.match(r"^(용이한 경우|보통의 경우|곤란한 경우) ([\d.]+)$", line.strip())
|
||||
if m:
|
||||
e.append({"작업조건": m[1], "E": N(m[2])})
|
||||
assert len(e) == 3
|
||||
notes = [x.strip() for x in S if re.match(r"^[①②] ", x.strip())]
|
||||
return [
|
||||
tb(no, "E", "작업효율(E)", "2", ["작업조건"], {"E": ""}, e),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("유효혼합폭 — Rotor 폭에서 뺌", "0.4", "m"),
|
||||
("작업속도(V)", "1000", "m/hr"),
|
||||
("혼합횟수(평균)", "3", "회"),
|
||||
],
|
||||
note=notes,
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-12 크러셔 ───────────────────────────────────────────────────
|
||||
def s12():
|
||||
no, S = "8-2-12", section("8-2-12")
|
||||
T = tables(S)
|
||||
belt = []
|
||||
for r in T[0][0][1:]:
|
||||
for w, c in ((r[0], r[1]), (r[2], r[3])):
|
||||
if w:
|
||||
belt.append({"폭": lab(w), "운반능력": N(c)})
|
||||
apron = grid(T[1][0][2:], ["속도"], [{"폭": lab(x)} for x in T[1][0][0][1:]], "운반능력")
|
||||
jaw = []
|
||||
for row in grid(T[2][0][2:], ["출구간격"], [{"규격": x} for x in T[2][0][0][1:]], "생산능력"):
|
||||
low, high = row.pop("생산능력")
|
||||
jaw.append({**row, "아래": low, "위": high})
|
||||
|
||||
def ratio(t):
|
||||
return grid(t[2:], ["골재크기"], [{"출구간격": lab(x)} for x in t[1][1:]], "비율")
|
||||
|
||||
roll_t = T[6][0]
|
||||
specs = roll_t[0][2:]
|
||||
roll_spec = [
|
||||
{"규격": s, "최대출구간격": N(a), "상용출구간격": N(b)}
|
||||
for s, a, b in zip(specs, roll_t[1][2:], roll_t[2][2:])
|
||||
]
|
||||
roll = []
|
||||
for r in roll_t[3:]:
|
||||
for s, c in zip(specs, r[2:]):
|
||||
row = {"출구간격": lab(r[0]), "규격": s}
|
||||
if put(row, "생산능력", c):
|
||||
roll.append(row)
|
||||
screen = grid(
|
||||
T[7][0][2:], ["체규격"], heads(("조합방법", ["1회통과식", "재투입식"])), "통과능력"
|
||||
)
|
||||
eff = T[8][0][3:]
|
||||
a = [{"택의 수": lab(r[0]), "계수": N(r[1])} for r in eff if r[0]]
|
||||
b = [{"골재량": lab(r[2]), "계수": N(r[3])} for r in eff if r[2]]
|
||||
c = [{"스크린규격": lab(r[4]), "계수": N(r[5])} for r in eff if r[4]]
|
||||
d = [{"골재량": lab(r[6]), "계수": N(r[7])} for r in eff if r[6]]
|
||||
kinds = [x.strip() for x in re.split(r"(?=\d\. )", eff[0][8]) if x.strip()]
|
||||
e = [{"재료분석": k, "계수": N(v)} for k, v in zip(kinds, eff[0][9].split())]
|
||||
assert len(e) == 4
|
||||
mob_t = T[9][0]
|
||||
outs = mob_t[1][2:10]
|
||||
mob, mob_spec = [], []
|
||||
for r in mob_t[2:]:
|
||||
mob_spec.append(
|
||||
{"규격": lab(r[0]), "입구간격": re.sub(r"×\s*", "×", r[1]), "출력": N(r[10])}
|
||||
)
|
||||
for o, cval in zip(outs, r[2:10]):
|
||||
row = {"규격": lab(r[0]), "출구간격": lab(o)}
|
||||
if put(row, "생산능력", cval):
|
||||
mob.append(row)
|
||||
mob_e = [{"작업조건": k, "E": N(v)} for k, v in zip(T[10][0][0], T[10][0][1])]
|
||||
roll_note = T[6][1]
|
||||
roll_e = []
|
||||
for k in LEVEL:
|
||||
m = next(re.search(rf"{k} : 효율 (\d+)%", x) for x in S if re.search(rf"{k} : 효율", x))
|
||||
roll_e.append({"작업조건": k, "효율": N(m[1])})
|
||||
s = "1 마 별표4"
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"벨트",
|
||||
"벨트컨베이어 운반능력",
|
||||
"1 가",
|
||||
["폭"],
|
||||
{"운반능력": "ton/hr"},
|
||||
belt,
|
||||
note=T[0][1],
|
||||
base="폭 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"피더",
|
||||
"에이프런 피더 운반능력",
|
||||
"1 나",
|
||||
["속도", "폭"],
|
||||
{"운반능력": "ton/hr"},
|
||||
apron,
|
||||
note=T[1][1],
|
||||
base="속도 m/min · 폭 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"죠",
|
||||
"죠 크러셔 생산능력",
|
||||
"1 다",
|
||||
["출구간격", "규격"],
|
||||
{"아래": "ton/hr", "위": "ton/hr"},
|
||||
jaw,
|
||||
note=T[2][1],
|
||||
base="출구간격 ㎜",
|
||||
memo="원문 범위 「a∼b」 를 아래 · 위 두 칸으로 폄(주④ 양호 = 최대치 · 보통 = 평균치 · 불량 = 최소치)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"별표1",
|
||||
"1회 통과시 크러셔의 골재크기에 따르는 생산량 비율",
|
||||
"1 다 별표1",
|
||||
["골재크기", "출구간격"],
|
||||
{"비율": "%"},
|
||||
ratio(T[3][0]),
|
||||
base="골재크기 · 출구간격 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"별표2",
|
||||
"재투입식 죠 크러셔의 골재크기에 따르는 생산량 비율",
|
||||
"1 다 별표2",
|
||||
["골재크기", "출구간격"],
|
||||
{"비율": "%"},
|
||||
ratio(T[4][0]),
|
||||
base="골재크기 · 출구간격 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"별표3",
|
||||
"롤 크러셔의 골재크기에 따르는 생산량 비율",
|
||||
"1 라 별표3",
|
||||
["골재크기", "출구간격"],
|
||||
{"비율": "%"},
|
||||
ratio(T[5][0]),
|
||||
base="골재크기 · 출구간격 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"롤규격",
|
||||
"롤 크러셔 규격별 출구간격",
|
||||
"1 라",
|
||||
["규격"],
|
||||
{"최대출구간격": "㎝", "상용출구간격": "㎝"},
|
||||
roll_spec,
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"롤",
|
||||
"롤 크러셔의 생산능력",
|
||||
"1 라",
|
||||
["출구간격", "규격"],
|
||||
{"생산능력": "ton/hr"},
|
||||
roll,
|
||||
note=roll_note,
|
||||
base="출구간격 ㎜",
|
||||
),
|
||||
tb(no, "롤효율", "롤 크러셔 작업효율", "1 라 주③", ["작업조건"], {"효율": "%"}, roll_e),
|
||||
tb(
|
||||
no,
|
||||
"스크린",
|
||||
"스크린 통과능력",
|
||||
"1 마",
|
||||
["체규격", "조합방법"],
|
||||
{"통과능력": "ton/hr"},
|
||||
screen,
|
||||
note=T[7][1],
|
||||
base="930㎠당 · 체의 규격 ㎜",
|
||||
),
|
||||
tb(no, "계수A", "스크린의 효율 — 계수 A(스크린택의 수)", s, ["택의 수"], {"계수": ""}, a),
|
||||
tb(
|
||||
no,
|
||||
"계수B",
|
||||
"스크린의 효율 — 계수 B(스크린규격 1/2보다 작은 골재의 양)",
|
||||
s,
|
||||
["골재량"],
|
||||
{"계수": ""},
|
||||
b,
|
||||
base="골재량 %",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"계수C",
|
||||
"스크린의 효율 — 계수 C(돌을 직접 분사할 때 스크린의 규격)",
|
||||
s,
|
||||
["스크린규격"],
|
||||
{"계수": ""},
|
||||
c,
|
||||
base="스크린규격 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"계수D",
|
||||
"스크린의 효율 — 계수 D(스크린 규격보다 큰 골재의 양)",
|
||||
s,
|
||||
["골재량"],
|
||||
{"계수": ""},
|
||||
d,
|
||||
base="골재량 %",
|
||||
),
|
||||
tb(no, "계수E", "스크린의 효율 — 계수 E(재료의 종류)", s, ["재료분석"], {"계수": ""}, e),
|
||||
tb(
|
||||
no,
|
||||
"이동식",
|
||||
"이동식 크러셔 생산능력",
|
||||
"2",
|
||||
["규격", "출구간격"],
|
||||
{"생산능력": "ton/hr"},
|
||||
mob,
|
||||
base="규격 ton · 출구간격 ㎜",
|
||||
memo="괄호 값은 원문 칸(「(57)」 등)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"이동식규격",
|
||||
"이동식 크러셔 입구간격 · 출력",
|
||||
"2",
|
||||
["규격"],
|
||||
{"입구간격": "㎜", "출력": "㎾"},
|
||||
mob_spec,
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"이동식효율",
|
||||
"이동식 크러셔 작업효율",
|
||||
"2 주③",
|
||||
["작업조건"],
|
||||
{"E": ""},
|
||||
mob_e,
|
||||
note=T[9][1],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-14 · 16 · 17 · 20 · 11 처럼 글 속 상수만 ────────────────────
|
||||
def s14():
|
||||
S = section("8-2-14")
|
||||
return [
|
||||
const("8-2-14", S, [("작업능력(q)", "3.26", "㎥/hr"), ("작업효율(E)", "0.95", "")], src="2")
|
||||
]
|
||||
|
||||
|
||||
def s16():
|
||||
S = section("8-2-16")
|
||||
return [
|
||||
const(
|
||||
"8-2-16",
|
||||
S,
|
||||
[("시간당 표준작업량(q)", "62.5", "㎥/hr"), ("작업효율(E)", "0.8", "")],
|
||||
src="2",
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def s17():
|
||||
S = section("8-2-17")
|
||||
return [
|
||||
const(
|
||||
"8-2-17", S, [("재료투입 혼합배출 등 작업시간", "4", "분"), ("작업효율(E)", "0.8", "")]
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def s20():
|
||||
S = section("8-2-20")
|
||||
return [
|
||||
const(
|
||||
"8-2-20",
|
||||
S,
|
||||
[
|
||||
("입환소요시간(t1)", "5", "분"),
|
||||
("적재 적하 소요시간(t2) — 토사류", "17", "분"),
|
||||
("적재 적하 소요시간(t2) — 석재류", "20", "분"),
|
||||
("적재시 주행속도(V1)", "140", "m/분"),
|
||||
("공차시 주행속도(V2)", "200", "m/분"),
|
||||
("1회 운반시 대차수(n) — 5t", "12", "대"),
|
||||
("1회 운반시 대차수(n) — 7t", "15", "대"),
|
||||
],
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-18 콘크리트 배치플랜트 · 8-2-19 콘크리트 운반 ───────────────
|
||||
def s18():
|
||||
no, S = "8-2-18", section("8-2-18")
|
||||
T = tables(S)
|
||||
q = []
|
||||
for r in T[0][0][1:]:
|
||||
for spec, c in zip(T[0][0][0][2:], r[2:]):
|
||||
row = {"규격": spec, "슬럼프": r[1]}
|
||||
if put(row, "실용량", c):
|
||||
q.append(row)
|
||||
return [
|
||||
tb(no, "q", "믹서의 실용량(q)", "1", ["규격", "슬럼프"], {"실용량": "㎥"}, q),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"2",
|
||||
["현장조건", "공종"],
|
||||
{"E": ""},
|
||||
grid(
|
||||
T[1][0][2:],
|
||||
["현장조건"],
|
||||
heads(("공종", ["도로포장", "교량", "터널", "사방"])),
|
||||
"E",
|
||||
),
|
||||
note=T[1][1],
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("1회 싸이클시간(cm)", "1.5", "분"),
|
||||
("1회 싸이클시간 — 터널 숏크리트 강섬유 혼합", "2.5", "분"),
|
||||
("작업효율 — 터널 숏크리트 현장조건 매우 불량", "0.40", ""),
|
||||
],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
def s19():
|
||||
no, S = "8-2-19", section("8-2-19")
|
||||
T = tables(S)
|
||||
w = [
|
||||
{"규격": N(h.removesuffix(" 톤")), "W": N(v)}
|
||||
for h, v in zip(T[0][0][0][1:], T[0][0][1][1:])
|
||||
]
|
||||
run = [
|
||||
{"구분": "표준치", "식": "cm1=3L+5", "기울기": N("3"), "절편": N("5")},
|
||||
{"구분": "범위", "식": "±5", "비고": T[1][0][1][2]},
|
||||
{"구분": "적용 거리", "비고": T[1][0][2][2], "최대거리": N("15")},
|
||||
]
|
||||
assert T[1][0][0][1] == "cm1=3L+5" and T[1][0][1][1] == "±5"
|
||||
return [
|
||||
tb(no, "W", "덤프트럭 적재량(W)", "2 가", ["규격"], {"W": "㎥"}, w, base="규격 톤"),
|
||||
tb(
|
||||
no,
|
||||
"주행",
|
||||
"덤프트럭 주행시간(cm1)",
|
||||
"2 나",
|
||||
["구분"],
|
||||
{"식": "", "기울기": "분/km", "절편": "분", "비고": "", "최대거리": "km"},
|
||||
run,
|
||||
memo="cm1 = 3L + 5 (L = 편도운반거리 km · 15km까지)",
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("믹서트럭 배출시간 — 슬럼프 4㎝ 이하", "3", "분", "4"),
|
||||
("믹서트럭 배출시간 — 슬럼프 5㎝ 이상", "2", "분", "3"),
|
||||
("믹서트럭 배출시간 — 콘크리트 펌프 조합 가산", "10", "분", "10"),
|
||||
("믹서트럭 대기시간(t4)", "5", "분", "10"),
|
||||
("덤프트럭 하역시간(t1)", "1", "분", "2"),
|
||||
("덤프트럭 대기시간(t2)", "5", "분", "10"),
|
||||
("작업효율(E)", "0.95", "", "0.95"),
|
||||
],
|
||||
memo="원문 범위 「a∼b」 = 아래 · 위 · 한 값은 두 칸이 같음",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
SECTIONS = [s2, s4, s6, s7, s10, s11, s12, s14, s16, s17, s18, s19, s20]
|
||||
@@ -1,626 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2 시공능력 — 계수 표 · 8-2-22 ~ 8-2-33(파일 해머 · 준설선 등).
|
||||
|
||||
`_건설기계_표.py` 와 같은 꼴 · `build_로직_건설품셈_08장_건설기계.py` 가 부름.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
|
||||
from _건설기계_읽기 import N, grid, heads, lab, plain, put, section, tables
|
||||
from _건설기계_표 import LEVEL, const, tb
|
||||
|
||||
CREW = {"인원": "인/일"}
|
||||
|
||||
|
||||
def crew(no, t, src):
|
||||
"""배치인원 (인/일) 한 줄 표 → 직종마다 줄."""
|
||||
rows = []
|
||||
for k, v in zip(t[0][0], t[0][1]):
|
||||
row = {"직종": k}
|
||||
put(row, "인원", v)
|
||||
rows.append(row)
|
||||
return tb(no, "배치인원", "배치인원", src, ["직종"], CREW, rows, note=t[1])
|
||||
|
||||
|
||||
def pair(no, short, name, src, t, key, col, unit="", **kw):
|
||||
"""머리 줄(이름들) · 값 줄 둘(또는 「계수」 줄 낀 셋)로 된 표 → 이름마다 줄."""
|
||||
names, values = t[0][0][1:], t[0][-1][1:]
|
||||
rows = []
|
||||
for k, v in zip(names, values):
|
||||
row = {key: lab(k)}
|
||||
if put(row, col, v):
|
||||
rows.append(row)
|
||||
kw.setdefault("base", t[0][-1][0]) # 값 줄 머리(「α」 · 「E_1」 · 「Te(분)」)
|
||||
return tb(no, short, name, src, [key], {col: unit}, rows, note=t[1], **kw)
|
||||
|
||||
|
||||
def wide(t):
|
||||
"""머리 칸 없는 두 줄 표(「| 항타 | 항발 |」 · 「| 10 | 6 |」) → `pair` 꼴."""
|
||||
return [[""] + t[0][0], [""] + t[0][1]], t[1]
|
||||
|
||||
|
||||
def fix(no, short, src, t, n):
|
||||
"""작업조건에 따른 보정계수 f_1 ~ f_n — 보정치(-0.05 · 0 · +0.05)마다 상태 · 적요."""
|
||||
rows = []
|
||||
for r in t[0][2 : 2 + n]:
|
||||
for level, c in zip(("-0.05", "0", "0.05"), r[2:5]):
|
||||
if c not in ("", "-"):
|
||||
rows.append({"보정": r[0], "조건": r[1], "보정치": N(level), "상태": c})
|
||||
if r[5]:
|
||||
rows.append({"보정": r[0], "조건": r[1], "적요": r[5]})
|
||||
return tb(
|
||||
no,
|
||||
short,
|
||||
"작업조건에 따른 보정계수(f)",
|
||||
src,
|
||||
["보정", "조건", "보정치"],
|
||||
{"상태": "", "적요": ""},
|
||||
rows,
|
||||
note=t[1],
|
||||
memo="보정치 = 작업계수 F 에 더함(+0.05 = 0.05)",
|
||||
)
|
||||
|
||||
|
||||
# ── 8-2-22 디젤 파일 해머 ──────────────────────────────────────────
|
||||
def s22():
|
||||
no, S = "8-2-22", section("8-2-22")
|
||||
T = tables(S)
|
||||
weld = lambda t: grid(t[0][2:], ["파일경"], [{"관두께": lab(x)} for x in t[0][1][1:]], "시간") # noqa: E731
|
||||
rows_weld_rod = grid(
|
||||
T[8][0][2:], ["파일경"], [{"관두께": lab(x)} for x in T[8][0][1][1:]], "소요량"
|
||||
)
|
||||
rows_power = grid(T[9][0][2:], ["파일경"], [{"관두께": lab(x)} for x in T[9][0][1][1:]], "전력")
|
||||
return [
|
||||
pair(no, "α", "토질계수(α)", "1 가 (1)", T[0], "토질", "α"),
|
||||
tb(
|
||||
no,
|
||||
"β강관",
|
||||
"해머 계수(β) — 강관파일",
|
||||
"1 가 (2)",
|
||||
["파일경", "해머"],
|
||||
{"β": ""},
|
||||
grid(T[1][0][2:], ["파일경"], [{"해머": x} for x in T[1][0][1][1:]], "β"),
|
||||
base="파일경 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"N치",
|
||||
"토질별 N치",
|
||||
"1 가 (3) 주",
|
||||
["구분", "상태"],
|
||||
{"N치": ""},
|
||||
plain(T[2][0][2:], ["구분", "상태", "N치"], keys=2),
|
||||
),
|
||||
pair(
|
||||
no, "Te강관", "급유 점검 등의 기타시간(Te) — 강관파일", "1 라", T[3], "해머", "Te", "분"
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"F",
|
||||
"작업계수(F)",
|
||||
"1 마",
|
||||
["평탄성", "현장"],
|
||||
{"F": ""},
|
||||
plain(T[4][0][2:], ["평탄성", "현장", "F"], keys=2),
|
||||
note=T[4][1],
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"용접반자동",
|
||||
"반자동 아크 용접기 용접이음 개소당 용접시간",
|
||||
"1 바 (1)",
|
||||
["파일경", "관두께"],
|
||||
{"시간": "분"},
|
||||
weld(T[5]),
|
||||
note=T[5][1],
|
||||
base="파일경 · 관두께 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"용접수동",
|
||||
"수동아크용접기 용접이음 1개소당 용접시간",
|
||||
"1 바 (2)",
|
||||
["파일경", "관두께"],
|
||||
{"시간": "분"},
|
||||
weld(T[6]),
|
||||
note=T[6][1],
|
||||
base="파일경 · 관두께 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"용접기",
|
||||
"파일해머와 용접기의 조합",
|
||||
"1 바 (3)",
|
||||
["기계명"],
|
||||
{"규격": "", "대수": "", "비고": ""},
|
||||
plain(T[7][0][1:], ["기계명", "규격", "대수", "비고"]),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"용접봉",
|
||||
"수동아크 용접기 용접이음 1개소당 용접봉 소요량",
|
||||
"1 바 (4)",
|
||||
["파일경", "관두께"],
|
||||
{"소요량": "㎏"},
|
||||
rows_weld_rod,
|
||||
base="파일경 · 관두께 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"용접전력",
|
||||
"용접이음 1개소당 전력 소비량",
|
||||
"1 바 (5)",
|
||||
["파일경", "관두께"],
|
||||
{"전력": "㎾/h"},
|
||||
rows_power,
|
||||
base="파일경 · 관두께 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"β콘크리트",
|
||||
"해머의 계수(β) — 콘크리트 파일",
|
||||
"2 가",
|
||||
["해머", "파일경"],
|
||||
{"β": ""},
|
||||
grid(T[10][0][2:], ["해머"], [{"파일경": lab(x)} for x in T[10][0][0][1:]], "β"),
|
||||
base="파일경 ㎜",
|
||||
),
|
||||
pair(
|
||||
no,
|
||||
"Te콘크리트",
|
||||
"점검 및 급유 등 기타 시간(Te) — 콘크리트 파일",
|
||||
"2 라",
|
||||
T[11],
|
||||
"해머",
|
||||
"Te",
|
||||
"분",
|
||||
),
|
||||
pair(no, "크레인", "파일해머와 크레인의 조합", "3", T[12], "해머", "크레인규격"),
|
||||
crew(no, T[13], "4"),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("타격시간 계수 — 강관파일", "0.05", ""),
|
||||
("타격시간 계수 — 콘크리트 파일", "0.08", ""),
|
||||
("세우기 및 위치조정 — 강관파일", "7", "분/회"),
|
||||
("세우기 및 위치조정 — 콘크리트 파일 250·300㎜", "3", "분/회"),
|
||||
("세우기 및 위치조정 — 콘크리트 파일 350∼500㎜", "5", "분/회"),
|
||||
("크롤러식 항타기 자주 표준주행속도(V)", "2.5", "m/min"),
|
||||
("이동 및 준비시간 — 콘크리트 파일", "3", "분"),
|
||||
("평균 N치 아래끝(1이하는 1)", "1", ""),
|
||||
],
|
||||
memo="Tb = 계수 × α × β × L × (N + 2) · Ts = 분/회 × Ns · Tt = (a + LS(S−1)/n) / V",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-23 유압 파일 해머 ──────────────────────────────────────────
|
||||
def s23():
|
||||
no, S = "8-2-23", section("8-2-23")
|
||||
T = tables(S)
|
||||
|
||||
def two(t, key, cols, name):
|
||||
return grid(t[0][2:], [key], [{cols: x} for x in t[0][1][1:]], name)
|
||||
|
||||
return [
|
||||
pair(no, "α강관", "토질계수(α) — 강관파일", "1 가 (1)", T[0], "N치", "α"),
|
||||
tb(
|
||||
no,
|
||||
"β",
|
||||
"판두께계수(β)",
|
||||
"1 가 (2)",
|
||||
["항타길이", "판두께"],
|
||||
{"β": ""},
|
||||
two(T[1], "항타길이", "판두께", "β"),
|
||||
base="항타길이 m · 판두께 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"Ta강관",
|
||||
"파일규격에 따른 시공시간(Ta) — 강관파일",
|
||||
"1 가 (3)",
|
||||
["항타길이", "파일경"],
|
||||
{"Ta": "분/본"},
|
||||
two(T[2], "항타길이", "파일경", "Ta"),
|
||||
note=T[2][1],
|
||||
base="항타길이 m · 파일경 ㎜",
|
||||
),
|
||||
pair(no, "α콘크리트", "토질계수(α) — 콘크리트 파일", "1 나 (1)", T[3], "N치", "α"),
|
||||
tb(
|
||||
no,
|
||||
"Ta콘크리트",
|
||||
"파일규격에 따른 시공시간(Ta) — 콘크리트 파일",
|
||||
"1 나 (2)",
|
||||
["항타길이", "파일경"],
|
||||
{"Ta": "분/본"},
|
||||
two(T[4], "항타길이", "파일경", "Ta"),
|
||||
note=T[4][1],
|
||||
base="항타길이 m · 파일경 ㎜",
|
||||
),
|
||||
pair(no, "크레인", "파일해머와 크레인의 조합", "3", T[5], "해머", "크레인규격"),
|
||||
crew(no, T[6], "4"),
|
||||
pair(
|
||||
no,
|
||||
"제잡비율",
|
||||
"잡재료 등 손료 — 직접노무비 대비 상한 비율",
|
||||
"5",
|
||||
T[7],
|
||||
"구분",
|
||||
"제잡비율",
|
||||
"%",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"장비",
|
||||
"장비조합",
|
||||
"6",
|
||||
["장비"],
|
||||
{"규격": "", "수량": "대", "작업시간": "", "비고": ""},
|
||||
plain(T[8][0][1:], ["장비", "규격", "수량", "작업시간", "비고"]),
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-24 진동파일 해머 ───────────────────────────────────────────
|
||||
def s24():
|
||||
no, S = "8-2-24", section("8-2-24")
|
||||
T = tables(S)
|
||||
r_t = T[1][0]
|
||||
r = []
|
||||
for soil, slope in zip(r_t[0][1:], r_t[2][1:]):
|
||||
m = re.fullmatch(r"([\d.]+)N_\d\+([\d.]+)", slope)
|
||||
r.append({"공종": "항타", "토질": soil, "식": slope, "기울기": N(m[1]), "절편": N(m[2])})
|
||||
for soil, v in zip(r_t[0][1:], r_t[3][1:]):
|
||||
r.append({"공종": "항발", "토질": soil, "r": N(v)})
|
||||
sheet = T[8][0]
|
||||
ak, gamma, kind = [], [], ""
|
||||
for row in sheet[3:]:
|
||||
kind = row[0] or kind
|
||||
if kind == "γ":
|
||||
gamma.append({"작업": row[1], "γ": N(row[3])})
|
||||
continue
|
||||
for i, kw in enumerate(("30", "45", "60", "162")):
|
||||
out = {"종류": kind, "작업": row[1], "해머": N(kw)}
|
||||
got = put(out, "α", row[2 + 2 * i])
|
||||
got = put(out, "K", row[3 + 2 * i]) or got
|
||||
if got:
|
||||
ak.append(out)
|
||||
combo = T[11][0]
|
||||
return [
|
||||
pair(no, "Ts", "파일 1본당 준비시간(Ts) — H파일", "1 가", wide(T[0]), "작업", "Ts", "분"),
|
||||
tb(
|
||||
no,
|
||||
"r",
|
||||
"토질별 항타 또는 항발시간(r)",
|
||||
"1 나 (1)",
|
||||
["공종", "토질"],
|
||||
{"식": "", "기울기": "분/m", "절편": "분/m", "r": "분/m"},
|
||||
r,
|
||||
memo="항타 r = 기울기 × N + 절편(원문 식 칸 그대로)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"k",
|
||||
"해머계수(k) — H파일",
|
||||
"1 나 (2)",
|
||||
["작업", "파일"],
|
||||
{"k": ""},
|
||||
grid(T[2][0][2:], ["작업"], heads(("파일", T[2][0][0][1:])), "k"),
|
||||
),
|
||||
pair(no, "F0", "작업계수 F_0 — H파일", "1 다 (1)", wide(T[3]), "작업", "F0"),
|
||||
fix(no, "f", "1 다 (2)", T[4], 4),
|
||||
tb(
|
||||
no,
|
||||
"조합",
|
||||
"진동해머 · 크레인(무한궤도) · 발전기의 조합 — H파일",
|
||||
"1 라",
|
||||
["해머"],
|
||||
{"크레인": "톤", "전력": "KVA", "발전기": "", "비고": ""},
|
||||
plain(T[5][0][2:], ["해머", "크레인", "전력", "발전기", "비고"]),
|
||||
note=T[5][1],
|
||||
base="진동파일해머 ㎾",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"선정",
|
||||
"진동파일해머 선정 — H파일",
|
||||
"1 마",
|
||||
["규격"],
|
||||
{"항타": "", "항발": ""},
|
||||
plain(T[6][0][1:], ["규격", "항타", "항발"]),
|
||||
),
|
||||
crew(no, T[7], "1 바"),
|
||||
tb(
|
||||
no,
|
||||
"αK",
|
||||
"강널말뚝 정수 α · 계수 K",
|
||||
"2 나 (1)",
|
||||
["종류", "작업", "해머"],
|
||||
{"α": "", "K": ""},
|
||||
ak,
|
||||
base="해머 = 진동파일해머 ㎾(162 = 유압식)",
|
||||
),
|
||||
tb(no, "γ", "강널말뚝 계수 γ", "2 나 (1)", ["작업"], {"γ": ""}, gamma),
|
||||
pair(no, "F0널", "작업계수 F_0 — 강널말뚝", "2 나 (2)", T[9], "작업", "F0"),
|
||||
fix(no, "f널", "2 나 (2)", T[10], 3),
|
||||
tb(
|
||||
no,
|
||||
"조합널",
|
||||
"진동해머 · 크레인 · 발전기의 조합 — 강널말뚝",
|
||||
"2 다",
|
||||
["기종", "해머"],
|
||||
{"규격": ""},
|
||||
grid(
|
||||
combo[2:],
|
||||
["기종"],
|
||||
[{"해머": lab(x.removesuffix("㎾"))} for x in combo[1][1:]],
|
||||
"규격",
|
||||
),
|
||||
base="해머 ㎾",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"선정전동",
|
||||
"진동 파일 해머 선정 — 항타 전동식",
|
||||
"2 라 (1) (가)",
|
||||
["토질", "규격"],
|
||||
{"항타": "", "비고": ""},
|
||||
plain(T[12][0][1:], ["토질", "규격", "항타", "비고"], keys=2),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"선정유압",
|
||||
"진동 파일 해머 선정 — 항타 유압식",
|
||||
"2 라 (1) (나)",
|
||||
["토질", "규격"],
|
||||
{"항타": "", "비고": ""},
|
||||
plain(T[13][0][1:], ["토질", "규격", "항타", "비고"], keys=2),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"선정인발",
|
||||
"진동 파일 해머 선정 — 항발시",
|
||||
"2 라 (2)",
|
||||
["종류"],
|
||||
{"전동 인발길이": "", "전동 규격": "㎾", "유압 인발길이": "", "유압 규격": "㎾"},
|
||||
plain(
|
||||
T[14][0][2:], ["종류", "전동 인발길이", "전동 규격", "유압 인발길이", "유압 규격"]
|
||||
),
|
||||
),
|
||||
crew(no, T[15], "2 마") | {"열쇠": f"공통 {no} 배치인원널", "이름": "배치인원 — 강널말뚝"},
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[("강널말뚝 시공시간 상수", "0.75", "")],
|
||||
memo="Tc = {(0.75 + γ × Nmax) × ℓ + α} × K / F",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-25 진동파일해머(워터제트 병용 압입공) ─────────────────────
|
||||
def s25():
|
||||
no, S = "8-2-25", section("8-2-25")
|
||||
T = tables(S)
|
||||
combo = []
|
||||
for r in T[5][0][2:]:
|
||||
hammer = lab(r[1].replace(" ", "").removesuffix("㎾"))
|
||||
for length, c in ((T[5][0][1][2], r[2]), (T[5][0][1][3], r[3])):
|
||||
combo.append({"해머": hammer, "길이": length, "크레인": N(c)})
|
||||
row = {"해머": hammer}
|
||||
put(row, "발전기", r[4])
|
||||
put(row, "전기용접기", r[5])
|
||||
combo.append(row)
|
||||
return [
|
||||
tb(no, "α", "토질계수(α)", "2 나", ["토질"], {"α": ""}, plain(T[0][0][1:], ["토질", "α"])),
|
||||
pair(no, "F0", "작업계수 F_0", "2 다 (1)", T[1], "구분", "F0"),
|
||||
fix(no, "f", "2 다 (2)", T[2], 4),
|
||||
tb(
|
||||
no,
|
||||
"선정",
|
||||
"진동파일해머 선정",
|
||||
"3 가",
|
||||
["토질", "규격"],
|
||||
{"파일연장": "m", "최대N치": "", "비고": ""},
|
||||
plain(T[3][0][1:], ["토질", "규격", "파일연장", "최대N치", "비고"], keys=2),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"펌프",
|
||||
"워터젯트 펌프선정",
|
||||
"3 나",
|
||||
["토질", "규격"],
|
||||
{"대상토질": "", "비고": ""},
|
||||
plain(T[4][0][1:], ["토질", "규격", "대상토질", "비고"], keys=2),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"조합",
|
||||
"진동해머 · 크레인(무한궤도) · 발전기의 조합",
|
||||
"3 다",
|
||||
["해머", "길이"],
|
||||
{"크레인": "톤", "발전기": "", "전기용접기": ""},
|
||||
combo,
|
||||
base="해머 ㎾ · 길이 = 파일 L(m)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"수조",
|
||||
"수중 펌프 및 수조선정",
|
||||
"3 라",
|
||||
["워터젯트", "대수"],
|
||||
{"수중펌프": "", "수조": "㎥", "비고": ""},
|
||||
plain(T[6][0][1:], ["워터젯트", "대수", "수중펌프", "수조", "비고"], keys=2),
|
||||
),
|
||||
crew(no, T[7], "4"),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("기본시공시간 계수", "0.05", ""),
|
||||
("기본시공시간 N 가산", "42.5", ""),
|
||||
("기본시공시간 상수", "9.6", "분"),
|
||||
("배관계 부재 손료 — 항타기 대비", "9", "%"),
|
||||
],
|
||||
memo="To = 0.05 × L × (N + 42.5) + 9.6",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-26 유압식 압입 인발기 ──────────────────────────────────────
|
||||
def s26():
|
||||
no, S = "8-2-26", section("8-2-26")
|
||||
T = tables(S)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"k",
|
||||
"기종 · 규격에 의한 계수(k)",
|
||||
"2 나 (2)",
|
||||
["규격"],
|
||||
{"k": ""},
|
||||
plain(T[0][0][1:], ["규격", "k"]),
|
||||
),
|
||||
fix(no, "f", "2 다", T[1], 3),
|
||||
tb(
|
||||
no,
|
||||
"조합",
|
||||
"압입 인발기 · 발전기의 조합",
|
||||
"3",
|
||||
["기종"],
|
||||
{"규격": ""},
|
||||
plain(T[2][0][1:], ["기종", "규격"]),
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"선정",
|
||||
"압입 인발기 선정",
|
||||
"4",
|
||||
["규격"],
|
||||
{"압입": "", "인발": ""},
|
||||
plain(T[3][0][1:], ["규격", "압입", "인발"]),
|
||||
),
|
||||
crew(no, T[4], "5"),
|
||||
tb(
|
||||
no,
|
||||
"설치",
|
||||
"유압식 말뚝 압입 인발기 설치 · 해체",
|
||||
"6 나",
|
||||
["작업", "항목", "조건"],
|
||||
{
|
||||
"설치해체시간": "시간",
|
||||
"압입항타기": "시간",
|
||||
"트럭크레인": "시간",
|
||||
"발동발전기": "시간",
|
||||
},
|
||||
plain(
|
||||
T[5][0][2:],
|
||||
["작업", "항목", "조건", "설치해체시간", "압입항타기", "트럭크레인", "발동발전기"],
|
||||
fill=2,
|
||||
keys=3,
|
||||
),
|
||||
base="대당 · 회당",
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("준비시간 계수(L당)", "0.52", "분/m"),
|
||||
("준비시간 상수", "5.12", "분"),
|
||||
("압입 단위 작업시간 계수(Nmax당)", "0.035", ""),
|
||||
("압입 단위 작업시간 상수", "1.02", ""),
|
||||
("인발 시간 계수(ℓ당)", "1.10", "분/m"),
|
||||
("인발 시간 상수", "4.76", "분"),
|
||||
("작업계수 기본값", "1.0", ""),
|
||||
],
|
||||
memo="압입 Tc = (Ts + Tb)/F · Ts = 0.52L + 5.12 · Tb = γ × ℓ × k · γ = 0.035Nmax + 1.02 · 인발 Tc = (1.10ℓ + 4.76)/F · F = 1.0 + (f1+f2+f3)",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-27 수중펌프 ─────────────────────────────────────────────────
|
||||
def s27():
|
||||
no, S = "8-2-27", section("8-2-27")
|
||||
T = tables(S)
|
||||
op = grid(
|
||||
T[1][0][2:],
|
||||
["펌프"],
|
||||
heads(("배수방법", ["작업시배수", "상시배수"]), ("전원", ["상용전원", "발전기"])),
|
||||
"운전공",
|
||||
)
|
||||
mat = [
|
||||
{**h, "비율": N(v)}
|
||||
for h, v in zip(
|
||||
heads(("배수방법", ["작업시배수", "상시배수"]), ("전원", ["상용전원", "발전기"])),
|
||||
T[2][0][2],
|
||||
)
|
||||
]
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"선정",
|
||||
"펌프의 선정",
|
||||
"1",
|
||||
["기종", "구경"],
|
||||
{"양정": "m", "전동기출력": ""},
|
||||
plain(T[0][0][2:], ["기종", "구경", "양정", "전동기출력"], keys=2),
|
||||
base="구경 ㎜",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"운전공",
|
||||
"펌프 운전공",
|
||||
"2",
|
||||
["펌프", "배수방법", "전원"],
|
||||
{"운전공": "인/1개소・일"},
|
||||
op,
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"잡재료",
|
||||
"잡재료 비율",
|
||||
"4",
|
||||
["배수방법", "전원"],
|
||||
{"비율": "%"},
|
||||
mat,
|
||||
memo="잡재료비 = 노무비, 기계손료 및 운전경비의 합 × 잡재료비율",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"설치",
|
||||
"펌프설치 및 해체(1개소당)",
|
||||
"5",
|
||||
["명칭"],
|
||||
{"수량": "인"},
|
||||
plain(T[3][0][1:], ["명칭", "단위", "수량"]),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[("전력소비 — 작업시 배수", "8", "시간"), ("전력소비 — 상시배수", "24", "시간")],
|
||||
src="3",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-28 TBM ──────────────────────────────────────────────────────
|
||||
def s28():
|
||||
no, S = "8-2-28", section("8-2-28")
|
||||
T = tables(S)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"3",
|
||||
["구분", "현장조건"],
|
||||
{"E": ""},
|
||||
grid(T[0][0][1:], ["구분"], heads(("현장조건", LEVEL)), "E"),
|
||||
),
|
||||
const(no, S, [("1회의 작업거리(ℓ) — ø4.5m", "1.2", "m"), ("정치시간(T2)", "10", "분")]),
|
||||
]
|
||||
|
||||
|
||||
SECTIONS = [s22, s23, s24, s25, s26, s27, s28]
|
||||
@@ -1,308 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-2 시공능력 — 계수 표 · 8-2-29 ~ 8-2-33(준설선 · 쇄암선 · 임목파쇄기 · 골재채취선).
|
||||
|
||||
`_건설기계_표.py` 와 같은 꼴 · `build_로직_건설품셈_08장_건설기계.py` 가 부름.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from _건설기계_읽기 import N, grid, heads, lab, plain, section, tables
|
||||
from _건설기계_표 import const, tb
|
||||
from _건설기계_표2 import pair
|
||||
|
||||
|
||||
# ── 8-2-29 펌프식 준설선 ───────────────────────────────────────────
|
||||
def s29():
|
||||
no, S = "8-2-29", section("8-2-29")
|
||||
T = tables(S)
|
||||
q = []
|
||||
for t, _ in T[:8]:
|
||||
q += grid(t[2:], ["토질", "N값"], [{"배송거리": lab(x)} for x in t[1][2:]], "q", fill=1)
|
||||
limit = grid(
|
||||
T[9][0][2:],
|
||||
["토질", "N값"],
|
||||
[{"출력": lab(x.removesuffix("㎾"))} for x in T[9][0][1][2:]],
|
||||
"거리",
|
||||
fill=1,
|
||||
)
|
||||
ex = T[10][0]
|
||||
sample = [{"산정조건": ex[1][0], "q_1": ex[1][1], "q_2": ex[1][2], "q": ex[1][3]}]
|
||||
out = [
|
||||
tb(
|
||||
no,
|
||||
"q",
|
||||
"전동환산 746㎾의 1시간당 준설능력(q)",
|
||||
"2",
|
||||
["토질", "N값", "배송거리"],
|
||||
{"q": "㎥/hr"},
|
||||
q,
|
||||
base="배송거리 m",
|
||||
memo="원문 동그라미 번호(계제선 ①∼⑥ 자리)는 q원문 칸",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"계제선",
|
||||
"계제선 적용표",
|
||||
"2",
|
||||
["공칭출력"],
|
||||
{"전동환산출력": "㎾", "계제선": "", "비고": ""},
|
||||
plain(T[8][0][2:], ["공칭출력", "전동환산출력", "계제선", "비고"]),
|
||||
base="주기출력 ㎾",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"한계",
|
||||
"규격별 보정한계거리",
|
||||
"3",
|
||||
["토질", "N값", "출력"],
|
||||
{"거리": "m"},
|
||||
limit,
|
||||
base="출력 = 전동환산 ㎾",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"산정예",
|
||||
"단거리 능력의 산정 예",
|
||||
"3",
|
||||
["산정조건"],
|
||||
{"q_1": "", "q_2": "", "q": ""},
|
||||
sample,
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("전동환산 기준 출력", "746", "㎾"),
|
||||
("전동환산 — 디젤 공칭주기 출력 곱", "0.8", ""),
|
||||
("전동환산 — 터빈 공칭주기 출력 곱", "0.9", ""),
|
||||
],
|
||||
memo="Q = q × bo × E / 746 · 단거리 q = (q1 + q2)/2",
|
||||
),
|
||||
]
|
||||
names = {
|
||||
11: ("E1", "흙의 두께에 따른 효율(E_1)", "4 가"),
|
||||
13: ("E2", "평면형상에 따른 효율(E_2)", "4 나"),
|
||||
15: ("E3", "단면형상에 따른 효율(E_3)", "4 다"),
|
||||
17: ("E4", "해상조건에 따른 효율(E_4)", "4 라"),
|
||||
}
|
||||
for i, (short, name, src) in names.items():
|
||||
out.append(pair(no, short, name, src, T[i], "구분", "E"))
|
||||
out.append(
|
||||
tb(
|
||||
no,
|
||||
short + "해설",
|
||||
name.split("(")[0] + " 해설",
|
||||
src,
|
||||
["구분"],
|
||||
{"적용 사항": ""},
|
||||
plain(T[i + 1][0][1:], ["구분", "적용 사항"]),
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
# ── 8-2-30 그래브 준설선 ───────────────────────────────────────────
|
||||
def s30():
|
||||
no, S = "8-2-30", section("8-2-30")
|
||||
T = tables(S)
|
||||
k = grid(
|
||||
T[1][0][2:],
|
||||
["분류", "상태", "N값"],
|
||||
[{"버킷용량": lab(x.removesuffix("㎥"))} for x in T[1][0][1][3:]],
|
||||
"k",
|
||||
fill=1,
|
||||
)
|
||||
cm = [{"버킷용량": lab(b), "싸이클시간": N(v)} for b, v in zip(T[2][0][1][1:], T[2][0][2][1:])]
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"f",
|
||||
"체적환산계수(f)",
|
||||
"1",
|
||||
["분류", "상태", "N값"],
|
||||
{"f": ""},
|
||||
plain(T[0][0][2:], ["분류", "상태", "N값", "f"], keys=3),
|
||||
note=T[0][1],
|
||||
memo="괄호 값 = 쇄암 또는 발파후의 준설(f원문 칸)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"k",
|
||||
"버킷계수(k)",
|
||||
"2",
|
||||
["분류", "상태", "N값", "버킷용량"],
|
||||
{"k": ""},
|
||||
k,
|
||||
base="버킷용량 ㎥",
|
||||
memo="원문 표 셋째 묶음 「점토질 토사」 연질 30이하 · 경질 30이상 은 원문 글 그대로(N값으로 갈림)",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"cm",
|
||||
"1회 싸이클시간(cm)",
|
||||
"3",
|
||||
["버킷용량"],
|
||||
{"싸이클시간": "초"},
|
||||
cm,
|
||||
note=T[2][1],
|
||||
),
|
||||
pair(no, "E1", "흙의 두께에 따른 효율(E_1)", "4 가", T[3], "구분", "E"),
|
||||
tb(
|
||||
no,
|
||||
"E1해설",
|
||||
"흙의 두께 해설",
|
||||
"4 가",
|
||||
["구분"],
|
||||
{"적용 사항": ""},
|
||||
plain(T[4][0][1:], ["구분", "적용 사항"]),
|
||||
),
|
||||
pair(no, "E2", "해상조건에 따른 효율(E_2)", "4 나", T[5], "구분", "E"),
|
||||
tb(
|
||||
no,
|
||||
"E2해설",
|
||||
"해상조건 해설",
|
||||
"4 나",
|
||||
["구분"],
|
||||
{"적용 사항": ""},
|
||||
plain(T[6][0][1:], ["구분", "적용 사항"]),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[("기준 수심", "10", "m"), ("수심 1m 증감당 싸이클시간 증감", "2", "초")],
|
||||
src="3",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-31 쇄암선 ───────────────────────────────────────────────────
|
||||
def s31():
|
||||
no, S = "8-2-31", section("8-2-31")
|
||||
T = tables(S)
|
||||
s_rows = grid(
|
||||
T[0][0][2:], ["분류", "상태"], [{"중추중량": lab(x)} for x in T[0][0][1][2:]], "S", fill=1
|
||||
)
|
||||
n_rows = grid(
|
||||
T[1][0][2:],
|
||||
["분류", "상태", "쇄암장"],
|
||||
[{"중추중량": lab(x)} for x in T[1][0][1][3:]],
|
||||
"n",
|
||||
fill=1,
|
||||
)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"S",
|
||||
"1본당 쇄암면적(S)",
|
||||
"1",
|
||||
["분류", "상태", "중추중량"],
|
||||
{"S": "㎡"},
|
||||
s_rows,
|
||||
base="중추중량 ton",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"n",
|
||||
"1층 쇄암하는데 필요한 낙추횟수(n)",
|
||||
"2",
|
||||
["분류", "상태", "쇄암장", "중추중량"],
|
||||
{"n": "회"},
|
||||
n_rows,
|
||||
base="쇄암장 m · 중추중량 ton",
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("1층 쇄암 깊이(d)", "1", "m"),
|
||||
("쇄암위치 이동 소요시간(t)", "1", "분"),
|
||||
("중추의 1분당 낙추횟수(P)", "2", "회/min"),
|
||||
],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-32 이동식 임목파쇄기 ────────────────────────────────────────
|
||||
def s32():
|
||||
no, S = "8-2-32", section("8-2-32")
|
||||
T = tables(S)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"소모93",
|
||||
"소모품 소모량 — 93.25㎾",
|
||||
"1 나",
|
||||
["소모품"],
|
||||
{"소모율": "개/hr", "비고": ""},
|
||||
plain(T[0][0][1:], ["소모품", "소모율", "비고"]),
|
||||
),
|
||||
pair(no, "K", "규격별 능력계수(K)", "2 다", T[1], "규격", "K"),
|
||||
pair(no, "S", "스크린계수(S)", "2 라", T[2], "스크린", "S"),
|
||||
pair(no, "E", "작업효율(E)", "2 마", T[3], "작업조건", "E"),
|
||||
tb(
|
||||
no,
|
||||
"소모354",
|
||||
"소모품 소모량 — 354.35 ∼ 402.84㎾",
|
||||
"2 바",
|
||||
["소모품"],
|
||||
{"규격": "", "소모율": "개/hr", "비고": ""},
|
||||
plain(T[4][0][1:], ["소모품", "규격", "소모율", "비고"]),
|
||||
),
|
||||
const(
|
||||
no,
|
||||
S,
|
||||
[
|
||||
("93.25㎾ 작업량(Q)", "6.0", "㎥/hr"),
|
||||
("354.35㎾ 시간당 표준파쇄량(q)", "26", "㎥/hr"),
|
||||
],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 8-2-33 하천골재채취선 ───────────────────────────────────────────
|
||||
def s33():
|
||||
no, S = "8-2-33", section("8-2-33")
|
||||
T = tables(S)
|
||||
q = grid(
|
||||
T[0][0][1:],
|
||||
["분류", "상태", "N치"],
|
||||
[{"배송거리": lab(x)} for x in T[0][0][0][3:]],
|
||||
"q",
|
||||
fill=1,
|
||||
)
|
||||
return [
|
||||
tb(
|
||||
no,
|
||||
"q",
|
||||
"하천골재채취선 746㎾의 시간당 준설량(q)",
|
||||
"2",
|
||||
["분류", "상태", "N치", "배송거리"],
|
||||
{"q": "㎥/hr"},
|
||||
q,
|
||||
base="배송거리 m",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"E",
|
||||
"작업효율(E)",
|
||||
"3",
|
||||
["조건", "유속"],
|
||||
{"E": ""},
|
||||
grid(T[1][0][2:], ["조건"], heads(("유속", ["느림", "보통", "빠름"])), "E"),
|
||||
memo="조건 = 천후, 평면형상, 위치 등",
|
||||
),
|
||||
tb(
|
||||
no,
|
||||
"배사관",
|
||||
"배사관 소모율(시간당)",
|
||||
"4",
|
||||
["분류", "자갈함유량"],
|
||||
{"단위": "", "소모율": ""},
|
||||
plain(T[2][0][1:], ["분류", "자갈함유량", "단위", "소모율"], keys=2),
|
||||
note=T[2][1],
|
||||
),
|
||||
const(no, S, [("기준 출력", "746", "㎾")], memo="Q = q × b × E / 746"),
|
||||
]
|
||||
|
||||
|
||||
SECTIONS = [s29, s30, s31, s32, s33]
|
||||
@@ -1,218 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 1장 나머지(782-2) — 1-5-4 · 1-5-6 로직 둘 + 계수 표 넣기 · 기존 할증 표 「성격」 칸.
|
||||
|
||||
`build_로직_건설품셈_01장_적용기준.py 나머지` 가 부름 · 한 번 돌림(이미 넣었으면 멈춤).
|
||||
- 계수 표 = `_적용기준_나머지_표.all_tables()` · 절 차례 자리에 끼움(처음으로 절 번호가 더 큰 기존 표 앞 · 없으면 끝).
|
||||
- 로직 = 로직_건설품셈_01장_적용기준.json 끝에 덧 · 키 = master_keys.issue(adopt 는 로직을 받지 않음).
|
||||
- 1-2-9 소규모 · 1-4 할증 로직 = 만들지 않음(PLAN 783-1).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from decimal import Decimal
|
||||
|
||||
import _적용기준_나머지_표 as T
|
||||
import build_로직_건설품셈_01장_적용기준 as base
|
||||
import build_로직_건설품셈_08장_건설기계 as b08
|
||||
import master_keys as mk
|
||||
|
||||
MASTER = base.MASTER
|
||||
COEF, LOGIC, HEAD = base.COEF, base.LOGIC, base.HEAD
|
||||
SRC4, SRC6 = "건설품셈 공통 1-5-4", "건설품셈 공통 1-5-6"
|
||||
|
||||
# 기존 1-3 · 1-4 표 → 성격(같은 성격 묶음 · 1-4-2 이중 적용 불가) — 기본 = 같은 표 · 딸린 표(정의 · 한도)는 본 표와 같음
|
||||
NATURE = {
|
||||
**{f"CC{n:06d}": "재료 할증" for n in range(1, 9)},
|
||||
"CC000009": "작업지연 — 현장조건",
|
||||
"CC000010": "작업지연 — 열차의 운행빈도",
|
||||
"CC000011": "작업지연 — 건물 층수",
|
||||
"CC000012": "작업지연 — 건물 층수",
|
||||
**{f"CC{n:06d}": "지세/지형 — 지세" for n in range(13, 20)},
|
||||
"CC000020": "지세/지형 — 도심지",
|
||||
"CC000021": "위험 — 고소작업",
|
||||
"CC000022": "위험 — 교량상 작업",
|
||||
**{f"CC{n:06d}": "위험 — 터널내 작업" for n in range(23, 26)},
|
||||
"CC000026": "위험 — 유해 작업",
|
||||
"CC000027": "위험 — 유해 작업",
|
||||
"CC000028": T.SMALL,
|
||||
"CC000029": "작업제한 — 폭염시 휴게시간",
|
||||
"CC000030": "작업환경 — 야간",
|
||||
"CC000031": "작업환경 — 특수작업",
|
||||
"CC000032": "작업환경 — 기타",
|
||||
"CC000033": "작업환경 — 기타",
|
||||
}
|
||||
|
||||
|
||||
def inp(name, desc, unit=None, pick=None, src=None):
|
||||
return base.inp(name, desc, unit, pick, src)
|
||||
|
||||
|
||||
def logics(K: dict) -> list[dict]:
|
||||
waste, water = K["건설폐기물 발생량"], K["공사용수"]
|
||||
w_rows = T.t_1_5_4()[0]["줄"]
|
||||
builds = list(dict.fromkeys(r["구조"] for r in w_rows))
|
||||
kinds = [r["구분"] for r in T.t_1_5_6()[0]["줄"] if r["구분"] != "잡용수"]
|
||||
env = {
|
||||
"열쇠": "공통 1-5-4 건설폐기물 발생량",
|
||||
**HEAD,
|
||||
"이름": "건설폐기물 발생량 — 건설 공통 1-5-4",
|
||||
"결과단위": "TON",
|
||||
"출처": f"{SRC4} 2",
|
||||
"소유": "공용",
|
||||
"비고": "발생량 = 면적 × 단위면적당 발생량(TON/㎡) × (1 + 증가율 ÷ 100) · 증가율 = 폐콘크리트류만(주③ 파일 시공 15% · 20% 이내 · 주④ 세륜 시설 개소당 3% 이내 — 설계자가 넣음 · 0 = 증가 없음) · 원문 칸 「-」 = 줄 없음(멈춤) · 건축물 해체는 설계도서 산출 우선(원문 2) · 주⑤ 현장 여건 조정",
|
||||
"시험입력": {
|
||||
"공사": "신축",
|
||||
"구조": "철근콘크리트조",
|
||||
"폐기물": "폐콘크리트류",
|
||||
"면적": 1000,
|
||||
"증가율": 0,
|
||||
},
|
||||
"입력": [
|
||||
inp("공사", "신축 · 해체", pick=["신축", "해체"], src=f"{SRC4} 2"),
|
||||
inp("구조", "건물 구조(주거용 = 단독주택 · 아파트)", pick=builds, src=f"{SRC4} 2"),
|
||||
inp("폐기물", "건설폐기물 종류", pick=list(T.WASTE), src=f"{SRC4} 2"),
|
||||
inp("면적", "단위면적 산출 면적", "㎡", src=f"{SRC4} 2"),
|
||||
inp(
|
||||
"증가율",
|
||||
"폐콘크리트 수량 증가(%) — 주③ 파일 15 · 20% 이내 · 주④ 세륜 개소당 3% 이내 · 0 = 없음",
|
||||
"%",
|
||||
src=f"{SRC4} 2 주③ ④",
|
||||
),
|
||||
],
|
||||
"중간": [
|
||||
{
|
||||
"이름": "원단위",
|
||||
"식": f"찾기({waste}, 공사=공사, 구조=구조, 폐기물=폐기물).발생량",
|
||||
"단위": "TON/㎡",
|
||||
},
|
||||
{
|
||||
"이름": "증가",
|
||||
"식": "만약(폐기물 == '폐콘크리트류', 증가율 / 100, 0)",
|
||||
},
|
||||
],
|
||||
"결과": {"식": "면적 * 원단위 * (1 + 증가)", "출처": f"{SRC4} 2"},
|
||||
"끝수": None,
|
||||
}
|
||||
use = {
|
||||
"열쇠": "공통 1-5-6 공사용수",
|
||||
**HEAD,
|
||||
"이름": "공사용수 — 건설 공통 1-5-6",
|
||||
"결과단위": "㎥",
|
||||
"출처": f"{SRC6} 3",
|
||||
"소유": "공용",
|
||||
"비고": "용수량 = 작업량 × 단위당 용수(㎥) × (1 + 잡용수율 ÷ 100) · 양생 물 포함([주]) · 해석: 잡용수 = 원문 「사용량비의 40∼50%」 — 잡용수율 0 = 더하지 않음(설계자가 40∼50 넣음)",
|
||||
"시험입력": {"구분": "콘크리트혼합 및 양생", "작업량": 100, "잡용수율": 0},
|
||||
"입력": [
|
||||
inp("구분", "용수 구분", pick=kinds, src=f"{SRC6} 3"),
|
||||
inp("작업량", "구분의 단위 분모 수량(㎡ · ㎥ · 1,000매 · 표면적 ㎡)", src=f"{SRC6} 3"),
|
||||
inp(
|
||||
"잡용수율",
|
||||
"잡용수(%) — 원문 사용량비의 40∼50% · 0 = 더하지 않음",
|
||||
"%",
|
||||
src=f"{SRC6} 3",
|
||||
),
|
||||
],
|
||||
"중간": [
|
||||
{"이름": "단위용수", "식": f"찾기({water}, 구분=구분).수량", "단위": "㎥"},
|
||||
],
|
||||
"결과": {"식": "작업량 * 단위용수 * (1 + 잡용수율 / 100)", "출처": f"{SRC6} 3"},
|
||||
"끝수": None,
|
||||
}
|
||||
return [env, use]
|
||||
|
||||
|
||||
def emit(t: dict) -> str:
|
||||
"""기존 표 글 모양 + 「성격」 칸(용도 다음 줄)."""
|
||||
text = base.emit(t)
|
||||
if "성격" in t:
|
||||
text = re.sub(
|
||||
r'(\n "용도": [^\n]*\n)',
|
||||
lambda m: m[1] + f' "성격": {json.dumps(t["성격"], ensure_ascii=False)},\n',
|
||||
text,
|
||||
count=1,
|
||||
)
|
||||
return text
|
||||
|
||||
|
||||
def _sec(no: str) -> tuple[int, ...]:
|
||||
return b08._sec(no)
|
||||
|
||||
|
||||
def insert_tables(text: str, made: list[dict]) -> str:
|
||||
"""새 표 → 처음으로 절 번호가 더 큰 기존 표 앞(없으면 끝)."""
|
||||
starts = [
|
||||
(m.start(), m[1])
|
||||
for m in re.finditer(r' \{\n "키": "CC\d+", "원문번호": "([^"]+)"', text)
|
||||
]
|
||||
pieces, last, left = [], 0, list(made)
|
||||
for at, no in starts:
|
||||
due = [t for t in left if _sec(t["원문번호"]) < _sec(no)]
|
||||
if due:
|
||||
pieces += [text[last:at], "".join(emit(t) + ",\n" for t in due)]
|
||||
left, last = [t for t in left if t not in due], at
|
||||
tail = text.rindex("\n ]\n}")
|
||||
pieces.append(text[last:tail])
|
||||
if left:
|
||||
pieces.append(",\n" + ",\n".join(emit(t) for t in left))
|
||||
pieces.append(text[tail:])
|
||||
return "".join(pieces)
|
||||
|
||||
|
||||
def add_nature(text: str) -> str:
|
||||
"""기존 1-3 · 1-4 표에 「성격」 한 줄 — 다른 글자는 그대로."""
|
||||
for key, nature in NATURE.items():
|
||||
pat = re.compile(
|
||||
rf'( "키": "{key}",[^\n]*\n(?: (?!"용도")[^\n]*\n)*? "용도": [^\n]*\n)'
|
||||
)
|
||||
text, n = pat.subn(
|
||||
lambda m: m[1] + f' "성격": {json.dumps(nature, ensure_ascii=False)},\n',
|
||||
text,
|
||||
count=1,
|
||||
)
|
||||
assert n == 1, key
|
||||
return text
|
||||
|
||||
|
||||
def run() -> None:
|
||||
coef_path = MASTER / COEF
|
||||
text = coef_path.read_text(encoding="utf-8")
|
||||
if '"원문번호": "1-5-4"' in text:
|
||||
raise SystemExit("이미 넣음 — 멈춤")
|
||||
old = json.loads(text, parse_float=Decimal, parse_int=Decimal)["표"]
|
||||
book = mk.load_book()
|
||||
made = T.all_tables()
|
||||
K = {}
|
||||
for t in made:
|
||||
t["키"] = mk.issue(book, "CC", t.pop("열쇠"), COEF)
|
||||
K[t["이름"]] = K[t["키"]] = t["키"]
|
||||
t.update(HEAD)
|
||||
K["건설폐기물 발생량"] = next(
|
||||
t["키"] for t in made if t["원문번호"] == "1-5-4" and "발생량" in t["이름"]
|
||||
)
|
||||
K["공사용수"] = next(
|
||||
t["키"] for t in made if t["원문번호"] == "1-5-6" and "공사용수" in t["이름"]
|
||||
)
|
||||
|
||||
rows = []
|
||||
for r in logics(K):
|
||||
r["키"] = mk.issue(book, "GC", r.pop("열쇠"), LOGIC)
|
||||
r["원문번호"] = r["출처"].split()[2]
|
||||
head = ["키", "원문번호"]
|
||||
rows.append({k: r[k] for k in head + [k for k in r if k not in head]})
|
||||
for t in made:
|
||||
t["용도"]["로직키"] = [
|
||||
r["키"] for r in rows if t["키"] in json.dumps(r, ensure_ascii=False)
|
||||
]
|
||||
|
||||
new = add_nature(insert_tables(text, made))
|
||||
data = json.loads(new, parse_float=Decimal, parse_int=Decimal)["표"]
|
||||
keep = {t["키"]: {k: v for k, v in t.items() if k != "성격"} for t in data}
|
||||
assert [keep[t["키"]] for t in old] == old # 기존 표 = 성격 칸만 더함
|
||||
assert len(data) == len(old) + len(made)
|
||||
assert sum("성격" in t for t in data) == len(NATURE) + 2
|
||||
coef_path.write_text(new, encoding="utf-8", newline="\n")
|
||||
b08.append_rows(LOGIC, rows)
|
||||
mk.save_book(mk.finish(book))
|
||||
print("계수", made[0]["키"], "~", made[-1]["키"], len(made), "· 로직", [r["키"] for r in rows])
|
||||
@@ -1,553 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 1장 나머지 — 규칙 · 계수만 절의 계수 표(782-2) · `build_로직_건설품셈_01장_적용기준.py 나머지` 가 부름.
|
||||
|
||||
- 절 범위 = `### N-N-N` 머리부터 다음 같은 · 윗 단계 머리 앞까지(요구 630).
|
||||
- 절마다 「규칙 글」 표 하나(원문 글 그대로 · 항 = 「N.」 · 번호 없는 머리 글 = 「머리」) + 수 · 표가 있는 절은 수 표.
|
||||
- 1-2-9 소규모 · 1-4-2 중복가산 = 계수로만(로직은 PLAN 783-1) · 성격 칸 = 같은 성격 묶음(1-4-2 이중 적용 불가 판정).
|
||||
- 값은 원문 글자 그대로(N) · 「-」 칸 = 값 없음(줄 · 칸을 두지 않음) · 범위 = [아래, 위].
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
import build_로직_건설품셈_01장_적용기준 as base
|
||||
|
||||
N, cell = base.N, base.cell
|
||||
CH1 = base.BODY.parent
|
||||
FILES = {
|
||||
"1-2": "1-02_설계_및_수량.md",
|
||||
"1-3": "1-03_재료_및_노임의_할증.md",
|
||||
"1-4": "1-04_품의_할증.md",
|
||||
"1-5": "1-05_기타.md",
|
||||
}
|
||||
SMALL = "작업시간 제한 · 소규모" # 1-2-9 ↔ 1-4-6 1 같은 성격(_제안_634 1-2)
|
||||
|
||||
|
||||
def section(no: str, md: Path | None = None) -> tuple[str, list[str]]:
|
||||
"""(절 이름, 절 줄) — 머리 줄부터 다음 같은 · 윗 단계 머리 앞까지."""
|
||||
md = md or CH1 / FILES[no.rsplit("-", 1)[0]]
|
||||
lines = md.read_text(encoding="utf-8").split("\n")
|
||||
head = re.compile(rf"^(#+) {re.escape(no)} (.+)$")
|
||||
a = next(i for i, x in enumerate(lines) if head.match(x))
|
||||
level = len(head.match(lines[a])[1])
|
||||
b = next(
|
||||
(j for j in range(a + 1, len(lines)) if re.match(rf"^#{{1,{level}}} ", lines[j])),
|
||||
len(lines),
|
||||
)
|
||||
name = re.sub(r"\s*\(['‘].*$", "", head.match(lines[a])[2]).strip()
|
||||
return name, lines[a:b]
|
||||
|
||||
|
||||
def _plain(x: str) -> str:
|
||||
x = re.sub(r"<!--.*?-->", "", x)
|
||||
x = re.sub(r"^(\d+)\\\.", r"\1.", x.strip())
|
||||
return x.strip()
|
||||
|
||||
|
||||
def rules(lines: list[str]) -> list[dict]:
|
||||
"""규칙 글 — 표 · 그림 · 주석 줄을 뺀 원문 글을 항(「N.」)마다 한 줄."""
|
||||
out, item = [], {"항": "머리", "글": []}
|
||||
for x in lines[1:]:
|
||||
if x.startswith(("|", "![")) or re.fullmatch(r"\s*<!--.*-->\s*", x):
|
||||
continue
|
||||
m = re.match(r"^(\d+)\\\. ", x)
|
||||
if m:
|
||||
out.append(item)
|
||||
item = {"항": m[1], "글": []}
|
||||
if _plain(x):
|
||||
item["글"].append(_plain(x))
|
||||
out.append(item)
|
||||
return [{"항": r["항"], "규칙": "\n".join(r["글"])} for r in out if r["글"]]
|
||||
|
||||
|
||||
def table(no, label, name, src, cols, rows, *, cond=None, note=(), base_="", extra=None, 대상=None):
|
||||
return {
|
||||
"열쇠": f"공통 {no} {label}",
|
||||
"원문번호": no,
|
||||
"이름": name,
|
||||
"기준": base_,
|
||||
"출처": f"건설품셈 공통 {no} {src}".strip(),
|
||||
**(extra or {}),
|
||||
"용도": {"공종": section(no)[0], "대상": 대상 or ["작업량 조건"], "로직키": []},
|
||||
"조건": cond or {},
|
||||
"값칸": cols,
|
||||
"줄": rows,
|
||||
"주": list(note),
|
||||
}
|
||||
|
||||
|
||||
def rule_table(no: str, extra: dict | None = None) -> dict:
|
||||
name, lines = section(no)
|
||||
return table(
|
||||
no,
|
||||
"규칙 글",
|
||||
f"{name} — 규칙 글",
|
||||
"",
|
||||
{"규칙": "글"},
|
||||
rules(lines),
|
||||
cond={"항": "고르기"},
|
||||
base_="원문 글 그대로",
|
||||
extra={
|
||||
"비고": "계산 칸 없는 규칙 · 기준 글 — 항 = 원문 「N.」 · 머리 = 번호 없는 글",
|
||||
**(extra or {}),
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def notes(lines: list[str], after: int = 0) -> list[str]:
|
||||
"""`after` 줄 뒤 첫 「[주]」 묶음(빈 줄까지)."""
|
||||
i = next(j for j in range(after, len(lines)) if lines[j].strip() == "[주]")
|
||||
out = []
|
||||
for x in lines[i + 1 :]:
|
||||
if not x.strip():
|
||||
break
|
||||
if not x.startswith("<!--"):
|
||||
out.append(_plain(x))
|
||||
return out
|
||||
|
||||
|
||||
def md_tables(lines: list[str]) -> list[list[list[str]]]:
|
||||
return base.md_tables(lines)
|
||||
|
||||
|
||||
def num(c: str):
|
||||
"""값 칸 — 수 · 범위 · 「-」(None)."""
|
||||
c = c.replace("\n", "").strip()
|
||||
return cell(c)[0] if c not in ("", "-") else None
|
||||
|
||||
|
||||
# ── 1-2-2 단위표준 ───────────────────────────────────────────────────
|
||||
def t_1_2_2() -> list[dict]:
|
||||
_, lines = section("1-2-2")
|
||||
unit, money = md_tables(lines)
|
||||
rows, kind = [], ""
|
||||
for r in unit[2:]:
|
||||
name, su, sd, qu, qd, note = r
|
||||
kind = name or kind
|
||||
row = {"종목": kind}
|
||||
for col, v in (("규격단위", su), ("수량단위", qu), ("비고", note)):
|
||||
if v not in ("", "-"):
|
||||
row[col] = v
|
||||
for col, v in (("규격소수자리", sd), ("수량소수자리", qd)):
|
||||
if v == "1 위": # 원문 그대로 「1 위」
|
||||
row[col], row[col + "원문"] = N("1"), v
|
||||
elif v not in ("", "-"):
|
||||
row[col] = N(v)
|
||||
rows.append(dict(sorted(row.items(), key=lambda kv: list(UNIT_ORDER).index(kv[0]))))
|
||||
i = lines.index("2\\. 금액의 단위표준")
|
||||
t1 = table(
|
||||
"1-2-2",
|
||||
"설계서의 단위 및 소수의 표준",
|
||||
"설계서의 단위 및 소수의 표준",
|
||||
"1",
|
||||
{
|
||||
"규격단위": "글",
|
||||
"규격소수자리": "자리",
|
||||
"수량단위": "글",
|
||||
"수량소수자리": "자리",
|
||||
"비고": "글",
|
||||
},
|
||||
rows,
|
||||
cond={"종목": "고르기"},
|
||||
note=notes(lines),
|
||||
extra={
|
||||
"비고": "원문 둘째 줄 이하 규격(말뚝 · 돌망태 · 관류)은 윗줄 종목 · 같은 종목 여러 줄 = 원문 그대로 · 「-」 = 칸 없음"
|
||||
},
|
||||
)
|
||||
t2 = table(
|
||||
"1-2-2",
|
||||
"금액의 단위표준",
|
||||
"금액의 단위표준",
|
||||
"2",
|
||||
{"단위": "글", "자리": "원", "비고": "글"},
|
||||
[{"종목": a, "단위": u, "자리": num(d), "비고": n} for a, u, d, n in money[1:]],
|
||||
cond={"종목": "고르기"},
|
||||
note=notes(lines, i),
|
||||
)
|
||||
return [t1, t2]
|
||||
|
||||
|
||||
UNIT_ORDER = (
|
||||
"종목",
|
||||
"규격단위",
|
||||
"규격소수자리",
|
||||
"규격소수자리원문",
|
||||
"수량단위",
|
||||
"수량소수자리",
|
||||
"수량소수자리원문",
|
||||
"비고",
|
||||
)
|
||||
|
||||
|
||||
# ── 1-2-3 토질 ───────────────────────────────────────────────────────
|
||||
def t_1_2_3() -> list[dict]:
|
||||
_, lines = section("1-2-3")
|
||||
md = md_tables(lines)
|
||||
rate = md[1]
|
||||
rows = []
|
||||
for kind, lv, cv in rate[1:]:
|
||||
row = {"종별": kind, "L": num(lv)}
|
||||
if re.search(r"\d", cv):
|
||||
row["C"] = num(cv)
|
||||
else:
|
||||
row["C원문"] = cv # 「별도 설계」
|
||||
rows.append(row)
|
||||
i = next(j for j, x in enumerate(lines) if x.startswith("다. 체적의 변화율"))
|
||||
f_rows = [
|
||||
{
|
||||
"기준이 되는 q": "자연상태의 체적",
|
||||
"자연상태의 체적": N("1"),
|
||||
"흐트러진상태의 체적": "L",
|
||||
"다져진후의 체적": "C",
|
||||
},
|
||||
{
|
||||
"기준이 되는 q": "흐트러진상태의 체적",
|
||||
"자연상태의 체적": "1/L",
|
||||
"흐트러진상태의 체적": N("1"),
|
||||
"다져진후의 체적": "C/L",
|
||||
},
|
||||
]
|
||||
assert md[2][2][0] == "자연상태의 체적" and md[2][3][3] == "C/L"
|
||||
stone = next(x for x in lines if x.startswith("다. 모암을 발파하여"))
|
||||
assert "10∼40%" in stone
|
||||
return [
|
||||
table(
|
||||
"1-2-3",
|
||||
"체적의 변화율",
|
||||
"체적의 변화율 L · C",
|
||||
"3 다",
|
||||
{"L": "", "C": ""},
|
||||
rows,
|
||||
cond={"종별": "고르기"},
|
||||
note=notes(lines, i),
|
||||
base_="L = 흐트러진 상태의 체적 ÷ 자연상태의 체적 · C = 다져진 상태의 체적 ÷ 자연상태의 체적",
|
||||
extra={"비고": "범위 = [아래, 위] · 폐콘크리트 C = 원문 「별도 설계」(값 없음)"},
|
||||
대상=["작업량 조건", "환산"],
|
||||
),
|
||||
table(
|
||||
"1-2-3",
|
||||
"체적환산계수",
|
||||
"체적환산계수(f) — 구하는 Q ÷ 기준이 되는 q",
|
||||
"3 라",
|
||||
{"자연상태의 체적": "식", "흐트러진상태의 체적": "식", "다져진후의 체적": "식"},
|
||||
f_rows,
|
||||
cond={"기준이 되는 q": "고르기"},
|
||||
extra={"비고": "값칸 = 구하는 Q · L · C = 체적의 변화율 표"},
|
||||
대상=["작업량 조건", "환산"],
|
||||
),
|
||||
table(
|
||||
"1-2-3",
|
||||
"파쇄된 돌 발생량",
|
||||
"토취장 및 골재원 — 규격품으로 못 쓰는 파쇄된 돌 발생량",
|
||||
"4 다",
|
||||
{"발생량": "%"},
|
||||
[{"발생량": [N("10"), N("40")], "발생량원문": "10∼40%를 표준"}],
|
||||
base_="모암을 발파하여 깬돌 등 규격품을 채취할 경우",
|
||||
extra={"비고": "유용하면 경비 별도 계상 · 발생량은 무대(無代)"},
|
||||
),
|
||||
rule_table("1-2-3"),
|
||||
]
|
||||
|
||||
|
||||
# ── 1-2-4 · 1-2-5 · 1-2-6 ────────────────────────────────────────────
|
||||
def t_1_2_4() -> list[dict]:
|
||||
_, lines = section("1-2-4")
|
||||
seven = next(x for x in lines if x.startswith("각 항목에 명시되어 있는 잡재료"))
|
||||
assert "2∼5%" in seven
|
||||
return [
|
||||
table(
|
||||
"1-2-4",
|
||||
"잡재료 및 소모재료",
|
||||
"잡재료 및 소모재료 — 명시 없는 잡재료 별도 계상 한도",
|
||||
"7",
|
||||
{"주재료비 대비": "%"},
|
||||
[
|
||||
{
|
||||
"주재료비 대비": [N("2"), N("5")],
|
||||
"주재료비 대비원문": "주재료비(재료비의 할증수량 제외)의 2∼5%까지",
|
||||
}
|
||||
],
|
||||
extra={"비고": "산정근거 명시 · 항목에 명시된 잡재료는 그대로 계상"},
|
||||
대상=["재료"],
|
||||
),
|
||||
rule_table("1-2-4"),
|
||||
]
|
||||
|
||||
|
||||
def t_1_2_5() -> list[dict]:
|
||||
_, lines = section("1-2-5")
|
||||
rows = []
|
||||
for cond, text in md_tables(lines)[0][1:]:
|
||||
m = re.fullmatch(r"보통인부 (\d+)인∼(\d+)인에 1인", text)
|
||||
rows.append(
|
||||
{
|
||||
"현장작업조건": cond,
|
||||
"보통인부": [N(m[1]), N(m[2])],
|
||||
"작업반장": N("1"),
|
||||
"보통인부원문": text,
|
||||
}
|
||||
)
|
||||
return [
|
||||
table(
|
||||
"1-2-5",
|
||||
"작업반장",
|
||||
"작업반장 — 현장작업조건별 작업반장 수(참고)",
|
||||
"2",
|
||||
{"보통인부": "인", "작업반장": "인"},
|
||||
rows,
|
||||
cond={"현장작업조건": "고르기"},
|
||||
base_="보통인부 인원 범위당 작업반장 1인",
|
||||
extra={"비고": "원문 [참고] 표 · 다수 보통인부 지휘통제가 필요할 때 계상할 수 있음"},
|
||||
대상=["인력"],
|
||||
),
|
||||
rule_table("1-2-5"),
|
||||
]
|
||||
|
||||
|
||||
def t_1_2_6() -> list[dict]:
|
||||
_, lines = section("1-2-6")
|
||||
one = next(x for x in lines if x.startswith("일반공구 및 시험용"))
|
||||
assert "인력품(노임할증과 작업시간 증가에 의하지 않은 품 할증 제외)의 3%까지" in one
|
||||
return [
|
||||
table(
|
||||
"1-2-6",
|
||||
"공구손료",
|
||||
"공구손료 — 명시 없는 공구손료 계상 한도",
|
||||
"1",
|
||||
{"인력품 대비": "%"},
|
||||
[
|
||||
{
|
||||
"인력품 대비": N("3"),
|
||||
"인력품 대비원문": "인력품(노임할증과 작업시간 증가에 의하지 않은 품 할증 제외)의 3%까지",
|
||||
}
|
||||
],
|
||||
extra={"비고": "특수공구 · 검사용 특수계측기류 손료는 별도 계상 · 상한(「까지」)"},
|
||||
대상=["기계"],
|
||||
),
|
||||
rule_table("1-2-6"),
|
||||
]
|
||||
|
||||
|
||||
# ── 1-2-8 · 1-2-9 ────────────────────────────────────────────────────
|
||||
def t_1_2_8() -> list[dict]:
|
||||
_, lines = section("1-2-8")
|
||||
digits, sample = md_tables(lines)
|
||||
heads = digits[0][1:]
|
||||
rows = [{"일당시공량": h, "소수자리": N(v)} for h, v in zip(heads, digits[1][1:])]
|
||||
sizes = [re.search(r"\(([\d,]+)㎡\)", h)[1] for h in sample[1][3:8]]
|
||||
ex, kind = [], ""
|
||||
for r in sample[2:6]:
|
||||
kind = r[0] or kind
|
||||
for h, size, v in zip(heads, sizes, r[3:8]):
|
||||
ex.append(
|
||||
{
|
||||
"구분": kind,
|
||||
"단위": r[1],
|
||||
"수량": N(r[2]),
|
||||
"일당시공량": h,
|
||||
"예시 시공량": N(size.replace(",", "")),
|
||||
"품": N(v),
|
||||
}
|
||||
)
|
||||
calc = [_plain(r[0]) for r in sample[6:8]]
|
||||
assert calc[0].startswith("※ 인력품") and "8(hr)" in calc[1]
|
||||
return [
|
||||
table(
|
||||
"1-2-8",
|
||||
"시공단위 품 소수자리",
|
||||
"시공단위 품 산정 — 일당시공량 단위별 소수자리",
|
||||
"3 가",
|
||||
{"소수자리": "자리"},
|
||||
rows,
|
||||
cond={"일당시공량": "고르기"},
|
||||
extra={
|
||||
"비고": "품의 규격 · 단위수량을 고려해 소수자리 정도를 조정할 수 있음(원문 「참고하여」)"
|
||||
},
|
||||
),
|
||||
table(
|
||||
"1-2-8",
|
||||
"시공단위 품 산정 식",
|
||||
"시공단위 품 산정 식 — 인력품 · 장비품",
|
||||
"3 가",
|
||||
{"식": "식", "단위": "글"},
|
||||
[
|
||||
{"구분": "인력", "식": "인력(인) ÷ 시공량(일당)", "단위": "인"},
|
||||
{"구분": "장비", "식": "장비(대) × 8(hr) ÷ 시공량(일당)", "단위": "hr"},
|
||||
],
|
||||
cond={"구분": "고르기"},
|
||||
note=calc,
|
||||
extra={"비고": "모든 로직의 품 환산 공통 규칙 — 일당시공량 기준 품을 시공단위 품으로"},
|
||||
),
|
||||
table(
|
||||
"1-2-8",
|
||||
"시공단위 품 표기 예시",
|
||||
"시공단위 품 — 소수자리 표기 예시(참고)",
|
||||
"3 가 [참고]",
|
||||
{"예시 시공량": "㎡", "품": "인 · hr"},
|
||||
ex,
|
||||
cond={"구분": "고르기", "수량": "수", "일당시공량": "고르기"},
|
||||
extra={"비고": "원문 [참고] 표를 줄로 폄 — 예시 시공량 = 원문 머리 괄호(㎡)"},
|
||||
),
|
||||
rule_table("1-2-8"),
|
||||
]
|
||||
|
||||
|
||||
def t_1_2_9() -> list[dict]:
|
||||
_, lines = section("1-2-9")
|
||||
small, sample = md_tables(lines)
|
||||
rows = [{"구분": N(a), "적용조건": b, "적용시공량": c} for a, b, c in small[1:]]
|
||||
note = notes(lines)
|
||||
ex, group, case = [], "", ""
|
||||
for r in sample[1:]:
|
||||
group = r[0].replace("\n", " ") or group
|
||||
case = r[1] or case
|
||||
row = {"적용": group, "예시": case, "규격": r[2], "현장수량": N(r[3])}
|
||||
for col, v in (("일당시공량", r[4]), ("적용시공량", r[5]), ("소요일수", r[6])):
|
||||
if v not in ("", "-"):
|
||||
row[col] = N(v)
|
||||
if r[7] not in ("", "-"):
|
||||
row["일수편차"], row["일수편차원문"] = num(r[7].split("\n")[0]), r[7].replace("\n", "")
|
||||
ex.append(row)
|
||||
return [
|
||||
table(
|
||||
"1-2-9",
|
||||
"소규모 적용시공량",
|
||||
"소규모(작업물량 제한) — 적용시공량",
|
||||
"",
|
||||
{"적용조건": "글", "적용시공량": "식"},
|
||||
rows,
|
||||
cond={"구분": "수"},
|
||||
note=note,
|
||||
base_="A 시공량(총 시공량) · B 1일시공량(표준품셈) · Q 적용시공량",
|
||||
extra={
|
||||
"비고": "「시공량/일」 명시 항목 · 재료량 제외 · A ≧ B = 미적용 · 로직(적용 배)은 PLAN 783-1 프로젝트 조정(B09)",
|
||||
"성격": SMALL,
|
||||
},
|
||||
대상=["작업량 조건", "할증"],
|
||||
),
|
||||
table(
|
||||
"1-2-9",
|
||||
"다수 규격 예시",
|
||||
"소규모(작업물량 제한) — 동일 항목 다수 규격 예시",
|
||||
"주③",
|
||||
{
|
||||
"현장수량": "m",
|
||||
"일당시공량": "m",
|
||||
"적용시공량": "m",
|
||||
"소요일수": "일",
|
||||
"일수편차": "",
|
||||
},
|
||||
ex,
|
||||
cond={"적용": "고르기", "예시": "고르기", "규격": "고르기"},
|
||||
extra={
|
||||
"비고": "원문 예시 표를 줄로 폄 · 일수편차 = 예시 첫 줄에만(원문 병합 칸) · 계 줄 = 원문 그대로",
|
||||
"성격": SMALL,
|
||||
},
|
||||
대상=["작업량 조건", "할증"],
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 1-3-2 · 1-4-1 · 1-4-2 ────────────────────────────────────────────
|
||||
def t_1_3_4() -> list[dict]:
|
||||
return [
|
||||
rule_table("1-3-2"),
|
||||
rule_table("1-4-1"),
|
||||
rule_table(
|
||||
"1-4-2",
|
||||
{
|
||||
"비고": "W = 기본품 × (1 + a1 + … + an) · 합산(곱 아님) · 동일 성격 이중 적용 불가 — 성격 = 계수 표 「성격」 칸 · 로직(할증 배)은 PLAN 783-1 프로젝트 조정(B09)",
|
||||
},
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
# ── 1-5 기타 ─────────────────────────────────────────────────────────
|
||||
WASTE = ("폐콘크리트류", "폐금속류", "폐보드류", "폐목재류", "폐합성수지류", "혼합폐기물")
|
||||
WATER_UNIT = "단위 칸"
|
||||
|
||||
|
||||
def t_1_5() -> list[dict]:
|
||||
out = []
|
||||
for n in range(1, 11):
|
||||
no = f"1-5-{n}"
|
||||
if n == 4:
|
||||
out += t_1_5_4()
|
||||
elif n == 6:
|
||||
out += t_1_5_6()
|
||||
out.append(rule_table(no))
|
||||
return out
|
||||
|
||||
|
||||
def t_1_5_4() -> list[dict]:
|
||||
_, lines = section("1-5-4")
|
||||
(md,) = md_tables(lines)
|
||||
assert [h.replace("\n", "") for h in md[0][3:]] == list(WASTE)
|
||||
rows, work, use = [], "", ""
|
||||
for r in md[1:]:
|
||||
work, use = r[0] or work, r[1].replace("\n", "") or use
|
||||
for kind, v in zip(WASTE, r[3:]):
|
||||
if num(v) is not None:
|
||||
rows.append(
|
||||
{"공사": work, "용도": use, "구조": r[2], "폐기물": kind, "발생량": num(v)}
|
||||
)
|
||||
return [
|
||||
table(
|
||||
"1-5-4",
|
||||
"건설폐기물 발생량",
|
||||
"환경관리비 — 건설폐기물 단위면적당 발생량",
|
||||
"2",
|
||||
{"발생량": "TON/㎡"},
|
||||
rows,
|
||||
cond={"공사": "고르기", "용도": "고르기", "구조": "고르기", "폐기물": "고르기"},
|
||||
note=notes(lines),
|
||||
base_="㎡당",
|
||||
extra={
|
||||
"비고": "원문 칸 「-」 = 줄 없음 · 건축물 해체는 설계도서 산출 우선(원문 2) · 주③ ④ = 폐콘크리트 수량 증가(이내)"
|
||||
},
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def t_1_5_6() -> list[dict]:
|
||||
_, lines = section("1-5-6")
|
||||
(md,) = md_tables(lines)
|
||||
rows = []
|
||||
for kind, unit, v in md[1:]:
|
||||
if re.fullmatch(r"[\d.]+", v):
|
||||
rows.append({"구분": kind, "단위": unit, "수량": N(v)})
|
||||
else:
|
||||
m = re.search(r"(\d+)∼(\d+)%", v)
|
||||
rows.append({"구분": kind, "단위": unit, "수량": [N(m[1]), N(m[2])], "수량원문": v})
|
||||
return [
|
||||
table(
|
||||
"1-5-6",
|
||||
"공사용수",
|
||||
"사용료 — 공사용수 소요량",
|
||||
"3",
|
||||
{"수량": WATER_UNIT},
|
||||
rows,
|
||||
cond={"구분": "고르기"},
|
||||
note=notes(lines),
|
||||
extra={
|
||||
"비고": "줄마다 단위 칸 · 잡용수 = 원문 「사용량비의 40∼50%」(범위 [아래, 위] %)"
|
||||
},
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def all_tables() -> list[dict]:
|
||||
"""원문 절 차례 — 같은 절은 만든 차례."""
|
||||
return [
|
||||
*t_1_2_2(),
|
||||
*t_1_2_3(),
|
||||
*t_1_2_4(),
|
||||
*t_1_2_5(),
|
||||
*t_1_2_6(),
|
||||
*t_1_2_8(),
|
||||
*t_1_2_9(),
|
||||
*t_1_3_4(),
|
||||
*t_1_5(),
|
||||
]
|
||||
@@ -1,76 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""842-3 자료 옮김 — M01 기계 줄 옛 칸(조종원 · 조종원직종 · 잡재료율) → 인력 · 잡품 목록(요구 849 · 867 · 868 · 870).
|
||||
|
||||
규칙 = `master_machine_crew.from_old_row`(값 · 단위 · 출처 — 사본 대조와 같은 규칙):
|
||||
인력 = 조종원 > 0 이면 [{키 'LB:<조종원직종>'(직종 없음 = 빈 키 = 식 입력 직종 고르기), 인 = 조종원}] · 0 = []
|
||||
잡품 = 잡재료율 > 0 이면 밑 재료 줄(주연료 · 전력 가운데 값 > 0)마다 {줄, 율 = 잡재료율} · 0 = []
|
||||
잡재료율 범위 글(「13∼18」) = 잡품 율 글 그대로(식이 못 셈 · 까닭 「범위」 — 옛 칸과 같음)
|
||||
칸 차례 = 옛 조종원 자리에 인력 · 옛 잡재료율 자리에 잡품 · 선원류 칸(선원 · 준설선선장 · 준설선기관사 · 고급선원) ·
|
||||
맨 위 칸(비활성 표지 등) = 그대로 · 다시 돌려도 같음(새 꼴 줄 = 그대로).
|
||||
실행 = `./venv/Scripts/python.exe resources/master_data/scripts/build_기계_인력줄_842_3.py [--dry]`
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
|
||||
import master_machine_crew as mcrew # noqa: E402
|
||||
import master_machine_files as mmf # noqa: E402
|
||||
|
||||
FOLDER = HERE.parent
|
||||
SPOT = {"조종원": mcrew.CREW, "잡재료율": mcrew.MISC} # 옛 칸 자리 → 새 칸
|
||||
|
||||
|
||||
def _order(old: dict, new: dict) -> dict:
|
||||
"""새 묶음을 옛 칸 차례로 — 옛 칸 자리에 새 칸 · 나머지 새 칸은 끝."""
|
||||
out: dict = {}
|
||||
for k in old:
|
||||
if k in new:
|
||||
out[k] = new[k]
|
||||
elif SPOT.get(k) in new:
|
||||
out[SPOT[k]] = new[SPOT[k]]
|
||||
return out | {k: v for k, v in new.items() if k not in out}
|
||||
|
||||
|
||||
def move(row: dict) -> dict:
|
||||
new = mcrew.from_old_row(row)
|
||||
if new is row:
|
||||
return row
|
||||
out = dict(row)
|
||||
for part in ("값", "단위", "출처"):
|
||||
if isinstance(row.get(part), dict):
|
||||
out[part] = _order(row[part], new[part])
|
||||
return out
|
||||
|
||||
|
||||
def main(dry: bool = False) -> Counter:
|
||||
data = mmf.read(FOLDER, mmf.NAME)
|
||||
old = {**data, "줄": list(data["줄"])}
|
||||
rows = [move(r) for r in data["줄"]]
|
||||
seen: Counter = Counter()
|
||||
for a, b in zip(data["줄"], rows):
|
||||
va, vb = a.get("값") or {}, b.get("값") or {}
|
||||
seen["대"] += 1
|
||||
seen["옮김"] += a is not b
|
||||
if vb.get(mcrew.CREW):
|
||||
seen["인력 줄 있음"] += 1
|
||||
seen[f"인력 {sum(r['인'] for r in vb[mcrew.CREW])}인"] += 1
|
||||
seen["직종 빈 줄(직종 고르기)"] += any(not r["키"] for r in vb[mcrew.CREW])
|
||||
seen["잡품 줄 있음"] += bool(vb.get(mcrew.MISC))
|
||||
seen["잡품 범위 글(율 글 그대로)"] += isinstance(va.get("잡재료율"), str)
|
||||
seen["선원류 칸 그대로"] += any(k in vb for k in ("선원", "준설선선장", "준설선기관사", "고급선원"))
|
||||
seen["비활성 표지 그대로"] += bool(b.get("비활성"))
|
||||
seen["옛 칸 남음"] += any(k in vb for k in mcrew.OLD)
|
||||
if not dry:
|
||||
mmf.write(FOLDER, {**data, "줄": rows}, old)
|
||||
return seen
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for k, v in sorted(main("--dry" in sys.argv).items()):
|
||||
print(f"{k}\t{v}")
|
||||
@@ -1,188 +0,0 @@
|
||||
"""시간당 경비 계산식(GC000267 ~ GC000276) 「기계」 고르기 · 선택 목록에 원문에 있는데 빠진 기계 더함(PLAN 814-1 · 요구 744 ~ 747).
|
||||
|
||||
기계표(EQ) 가운데 어느 계산식 목록에도 없는 기계를 자료(기계표 값)에 따라 식 하나에 배정 — 지어 넣는 값 없음:
|
||||
연료(주연료 · 종류) · 조종원(인 · 직종) · 잡재료율 · 상각 · 정비 · 관리 계수 있음 = GC000268(기계경비)
|
||||
연료 · 조종원(인) 있음 · 직종 없음 = GC000275(조종원직종 입력)
|
||||
연료 있음 · 조종원 없음 = GC000272(조종원 없는 기종)
|
||||
연료 없음 · 조종원(인 · 직종) 있음 = GC000276(연료 없는 기종)
|
||||
연료 · 조종원(직종) 없음 · 가격 · 손료계수 있음 = GC000273(손료만 — 부착 장비 등)
|
||||
그 식이 부르는 기계표 값이 비거나 수 하나가 아니면(「13∼18」) 안 넣고 「못 넣음」 목록에 적음.
|
||||
8-1-7 손료 보정 식(GC000269 · GC000274)은 보정 기종 식에 그 기계 번호가 이미 있을 때만 같이 더함.
|
||||
목록 끝에 덧붙임(기본값 그대로 = 기존 문서 금액 같음). 로직 파일(`로직_…_건설기계.json` 입력 고르기)과
|
||||
수식 문서(`수식문서/수식_…_건설기계.json` 「기계」 선택 목록)를 같이 고침. 두 번 돌려도 같음.
|
||||
|
||||
쓰기: venv python resources/master_data/scripts/build_기계목록_빠진기계_814_1.py [--check]
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
DATA = HERE.parent
|
||||
LOGIC = DATA / "로직_건설품셈_08장_건설기계.json"
|
||||
DOC = DATA / "수식문서" / "수식_건설품셈_08장_건설기계.json"
|
||||
FAMILY = [f"GC00027{i}" for i in range(6)] + ["GC000267", "GC000268", "GC000269"]
|
||||
FAMILY = sorted(set(FAMILY) | {"GC000276"})
|
||||
FIX = ("상각비계수", "정비비계수", "관리비계수")
|
||||
NEEDS = {
|
||||
"GC000268": ("가격", *FIX, "주연료종류", "주연료", "조종원직종", "조종원", "잡재료율"),
|
||||
"GC000275": ("가격", *FIX, "주연료종류", "주연료", "조종원", "잡재료율"),
|
||||
"GC000272": ("가격", *FIX, "주연료종류", "주연료", "잡재료율"),
|
||||
"GC000276": ("가격", *FIX, "조종원직종", "조종원"),
|
||||
"GC000273": ("가격", "손료계수"),
|
||||
}
|
||||
PAIR = {"GC000268": "GC000269", "GC000273": "GC000274"} # 8-1-7 보정 식
|
||||
|
||||
|
||||
TEXT = ("주연료종류", "조종원직종") # 글 칸 — 그 밖 = 수 하나(범위 「13∼18」 · 빈 값 = 없음)
|
||||
|
||||
|
||||
def _has(row: dict, field: str) -> bool:
|
||||
v = (row.get("값") or {}).get(field)
|
||||
if v in (None, ""):
|
||||
return False
|
||||
if field in TEXT:
|
||||
return bool(str(v).strip())
|
||||
try:
|
||||
return float(str(v).replace(",", "")) != 0
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
|
||||
NUMS = ("가격", *FIX, "손료계수", "주연료", "조종원", "잡재료율")
|
||||
|
||||
|
||||
def _bad(row: dict, field: str) -> bool:
|
||||
v = (row.get("값") or {}).get(field)
|
||||
if v in (None, ""):
|
||||
return False
|
||||
try:
|
||||
float(str(v).replace(",", ""))
|
||||
except ValueError:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def family_of(row: dict) -> tuple[str | None, list[str]]:
|
||||
"""기계표 한 줄 → (식 키 | None, 빈 값 이름들) — 연료 · 조종원 유무로 식 가족을 고름."""
|
||||
bad = [
|
||||
f for f in NUMS if _bad(row, f)
|
||||
] # 수 아닌 글(「73.7+」 · 「13∼18」) = 풀지 않음(822-2 DROP_ONLY)
|
||||
if bad:
|
||||
return None, bad
|
||||
fuel, crew, job = _has(row, "주연료"), _has(row, "조종원"), _has(row, "조종원직종")
|
||||
if fuel and crew:
|
||||
key = "GC000268" if job else "GC000275"
|
||||
elif fuel:
|
||||
key = "GC000272"
|
||||
elif crew and job:
|
||||
key = "GC000276"
|
||||
else:
|
||||
key = "GC000273"
|
||||
miss = [f for f in NEEDS[key] if not _has(row, f)]
|
||||
return (None if miss else key), miss
|
||||
|
||||
|
||||
def _rows() -> list[dict]:
|
||||
sys.path.insert(0, str(HERE))
|
||||
import master_machine_files as mmf # 기계 = 폴더(826-2)
|
||||
|
||||
data = mmf.table(DATA, exact=False)[0]
|
||||
return [
|
||||
r for r in data.get("줄") or data.get("표") or [] if str(r.get("키", "")).startswith("EQ")
|
||||
]
|
||||
|
||||
|
||||
def _is_family(row: dict) -> bool:
|
||||
"""옛 식 묶음 + 「기계경비식」 부품 표지 전부(822-2 새 식 여섯 포함 — 옮긴 기계를 손료만 식에 되넣지 않음)."""
|
||||
return row.get("키") in FAMILY or (row.get("부품") or {}).get("갈래") == "기계경비식"
|
||||
|
||||
|
||||
def _logic_lists(text: str) -> dict[str, list[str]]:
|
||||
data = json.loads(text)
|
||||
out = {}
|
||||
for row in data["줄"]:
|
||||
for i in row.get("입력") or []:
|
||||
if _is_family(row) and i.get("이름") == "기계":
|
||||
out[row["키"]] = [str(c) for c in i.get("고르기") or []]
|
||||
return out
|
||||
|
||||
|
||||
def _span(text: str, key: str, start_pat: str) -> tuple[int, int]:
|
||||
"""그 키 블록 안 첫 `start_pat` 뒤 배열 [ … ] 의 (여는 괄호, 닫는 괄호) 자리."""
|
||||
at = text.index(f'"키": "{key}"')
|
||||
m = re.compile(start_pat).search(text, at)
|
||||
if not m:
|
||||
raise SystemExit(f"{key} 기계 목록 자리를 못 찾음")
|
||||
open_ = m.end() - 1
|
||||
close = text.index("]", open_)
|
||||
return open_, close
|
||||
|
||||
|
||||
def _append(text: str, key: str, codes: list[str], start_pat: str) -> str:
|
||||
if not codes:
|
||||
return text
|
||||
open_, close = _span(text, key, start_pat)
|
||||
body = text[open_ + 1 : close]
|
||||
if "\n" in body: # 여러 줄 꼴 — 마지막 줄 들여쓰기 그대로
|
||||
last = body.rstrip().rsplit("\n", 1)[-1]
|
||||
pad = last[: len(last) - len(last.lstrip())]
|
||||
add = "".join(f',\n{pad}"{c}"' for c in codes)
|
||||
cut = open_ + 1 + len(body.rstrip())
|
||||
return text[:cut] + add + text[cut:]
|
||||
add = "".join(f', "{c}"' for c in codes)
|
||||
return text[:close] + add + text[close:]
|
||||
|
||||
|
||||
LOGIC_PAT = r'"이름":\s*"기계",\s*"고르기":\s*\['
|
||||
DOC_PAT = r'"열쇠":\s*"기계"[^\n]*?"목록":\s*\['
|
||||
|
||||
|
||||
def plan() -> tuple[dict[str, list[str]], list[tuple[str, str, str, list[str]]]]:
|
||||
logic = LOGIC.read_text("utf-8")
|
||||
have = _logic_lists(logic)
|
||||
taken = {c for v in have.values() for c in v}
|
||||
fixes = {}
|
||||
for r in json.loads(logic)["줄"]:
|
||||
if r.get("키") in PAIR.values():
|
||||
fixes[r["키"]] = " ".join(str(x.get("식") or "") for x in r.get("중간") or [])
|
||||
add: dict[str, list[str]] = {}
|
||||
skipped = []
|
||||
for row in _rows():
|
||||
code = str(row.get("원문번호") or "")
|
||||
if not code or code in taken:
|
||||
continue
|
||||
key, miss = family_of(row)
|
||||
if key is None:
|
||||
skipped.append((code, str(row.get("이름")), str(row.get("규격") or ""), miss))
|
||||
continue
|
||||
if code in add.get(key, []):
|
||||
continue
|
||||
add.setdefault(key, []).append(code)
|
||||
if PAIR.get(key) and f"'{code}'" in fixes.get(PAIR[key], ""):
|
||||
add.setdefault(PAIR[key], []).append(code)
|
||||
return add, skipped
|
||||
|
||||
|
||||
def main(check: bool = False) -> None:
|
||||
add, skipped = plan()
|
||||
print("더함:", {k: len(v) for k, v in sorted(add.items())}, "· 못 넣음:", len(skipped))
|
||||
for code, name, spec, miss in skipped:
|
||||
print(f" 못 넣음 {code} {name} {spec} — 빈 값 {', '.join(miss)}")
|
||||
if check or not add:
|
||||
return
|
||||
logic, doc = LOGIC.read_text("utf-8"), DOC.read_text("utf-8")
|
||||
for key, codes in sorted(add.items()):
|
||||
logic = _append(logic, key, codes, LOGIC_PAT)
|
||||
doc = _append(doc, key, codes, DOC_PAT)
|
||||
json.loads(logic), json.loads(doc) # 꼴 확인
|
||||
LOGIC.write_text(logic, "utf-8", newline="")
|
||||
DOC.write_text(doc, "utf-8", newline="")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main("--check" in sys.argv)
|
||||
@@ -1,310 +0,0 @@
|
||||
"""기계 시간당 경비 식 완성(PLAN 822-2 · 요구 797 · 798 · 799) — 기계표 · 08장 로직 고침(정본 저장 길).
|
||||
|
||||
한 번만 돎(두 번째는 바뀐 것 없음):
|
||||
기계.json
|
||||
· 주연료 칸에 ㎾ 글이 든 전동 기계 → 숫자 칸 `전력`(㎾ · 전동기 부하율 규정 없음 → 그대로) · 주연료 비움
|
||||
(원문 글은 `값원문` 그대로 · 비고에 한 줄) · 원문 잡재료 「-」 = 잡재료율 0
|
||||
· 조종원직종 13 대 = 사용자 확정(요구 799) · 아스팔트 믹싱플랜트 잡재료 「-」 = 0
|
||||
· EQ000534 이름 오자 「POWER TLOWEL」 → 「POWER TROWEL」(원문 8-4-8 표기 · `옛이름` 보존)
|
||||
로직_건설품셈_08장_건설기계.json
|
||||
· 새 식 넷 — 전력 기종 · 전력 + 조종원 · 손료계수 한 칸 연료 기종 · 시간당 값 직접
|
||||
· 손료만 식(GC000273) 목록에서 옮긴 기계 뺌 → 맞는 식 목록에 더함(보정 식 GC000274 는 그대로)
|
||||
저장 = `M01_MasterData_Store_Make.save`(검사 · 키 대장 · 줄 모양 그대로 · 개정확인).
|
||||
수식 문서는 뒤에 `build_수식문서_802_2.py` 로 다시.
|
||||
|
||||
venv python resources/master_data/scripts/build_기계시간당_822_2.py [--check]
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
sys.path.insert(0, str(ROOT))
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store # noqa: E402
|
||||
from M01_MasterData import M01_MasterData_Store_Make as make # noqa: E402
|
||||
|
||||
MACHINE = "기계.json"
|
||||
LOGIC = "로직_건설품셈_08장_건설기계.json"
|
||||
JOB_SRC = "건설품셈 공통 8-1-3 5 · 건설노임 {}"
|
||||
JOBS = { # 요구 799 — (직종, 까닭)
|
||||
**{f"EQ00016{i}": ("1048", "건설기계관리법상 건설기계") for i in range(5, 10)},
|
||||
**{
|
||||
k: ("1048", "원문 8-1-3 5 표의 「쇄석기」")
|
||||
for k in ("EQ000249", "EQ000250", "EQ000251", "EQ000252")
|
||||
},
|
||||
"EQ000347": ("1048", "원문 8-1-3 5 표의 「천공기」"),
|
||||
"EQ000348": ("1048", "원문 8-1-3 5 표의 「천공기」"),
|
||||
"EQ000309": ("1050", "두 법에 없는 기계"),
|
||||
"EQ000433": ("1050", "두 법에 없는 기계"),
|
||||
}
|
||||
POWER = { # 주연료 칸 ㎾ 글 → 전력(원문 값 그대로)
|
||||
"EQ000345": 330, "EQ000347": 135, "EQ000348": 239, "EQ000426": 15.1, "EQ000427": 15.1,
|
||||
"EQ000529": 3.73, "EQ000530": 7.46, "EQ000531": 37, "EQ000533": 1.49, "EQ000532": 1.87,
|
||||
} # fmt: skip
|
||||
MISC_DASH = ("EQ000426", "EQ000427", "EQ000529", "EQ000530", "EQ000531", "EQ000533",
|
||||
*(f"EQ0001{n}" for n in range(87, 92))) # fmt: skip
|
||||
TYPO = ("EQ000534", "POWER TLOWEL", "POWER TROWEL")
|
||||
|
||||
P1, P2, N3, DIRECT = "전력", "전력조종원", "손료한칸연료", "직접"
|
||||
MOVE = { # 식 → 더할 원문번호(손료만 식 GC000273 에서는 뺌)
|
||||
"GC000276": ["2208-5008", "2208-5010", "2208-5012", "2208-5016", "2208-5020", "5105-0050",
|
||||
"5105-0100", "5105-0150", "5105-0200", "5119-0625", "7205-0125"],
|
||||
"GC000268": ["3108-0060", "3108-0080", "3108-0100", "3108-0120", "9010-0120",
|
||||
"9010-0200"],
|
||||
P1: ["7991-0050", "7202-0008", "7202-0010", "7991-0100", "7991-0500",
|
||||
"7992-0001", "7993-0020"],
|
||||
P2: ["5805-0002", "5805-0003"],
|
||||
N3: ["7994-0050"],
|
||||
} # fmt: skip
|
||||
LOSS_ONLY = "GC000273"
|
||||
#: 손료만 식에서 빼기만 — 주연료 「73.7+ 휘발유54.5」 를 풀지 않음(꼴로 고름 → 까닭 글)
|
||||
DROP_ONLY = ["3450-0642"]
|
||||
#: 목록 밖(꼴로 고름 → 값 모자람 까닭 글) — 가격 없는 기계를 목록에 두면 식 기본 · 옵션 대조가 갈림(802-2):
|
||||
#: 아스팔트 스프레어 둘(가격 · 손료 없음 → 직종 입력 식 꼴) · TBM 4.5m(가격 없음 → 전력 식 꼴)
|
||||
#: 3108-0040 = 주연료 중유 — 유가 표에 중유 없음(검사가 막음) → 목록 밖 · 꼴로 고름 → 까닭 글
|
||||
LABEL = {P1: "전력", P2: "전력 조종원", N3: "손료계수 한 칸", DIRECT: "직접 값"}
|
||||
|
||||
_HEAD = {
|
||||
"원문번호": "8",
|
||||
"구분": "건설품셈 공통",
|
||||
"상세구분": "08장 건설기계",
|
||||
"결과단위": "원/시간",
|
||||
}
|
||||
_SRC = "건설품셈 공통 8-1-5 · 8-1-6"
|
||||
_LOSS_ONE = {
|
||||
"이름": "손료",
|
||||
"식": "버림(EQ:{기계}.가격 * 1000 * EQ:{기계}.손료계수 / 10000000, 0)",
|
||||
"출처": "건설품셈 공통 8-1-5 12 · 8-1-6 4",
|
||||
}
|
||||
_HOUR = {
|
||||
"이름": "시간환산",
|
||||
"식": "찾기(CC000336, 구분='시간환산').분자 / 찾기(CC000336, 구분='시간환산').분모",
|
||||
"출처": "건설품셈 공통 1-1-3 2(일일 작업시간 8시간)",
|
||||
}
|
||||
_JOB = {"이름": "직종", "식": "EQ:{기계}.조종원직종", "출처": "건설품셈 공통 8-1-3 5"}
|
||||
_CREW = {
|
||||
"종류": "인력",
|
||||
"요소": "LB:{직종}",
|
||||
"이름": "조종원",
|
||||
"단위": "인",
|
||||
"수량": "EQ:{기계}.조종원 * 시간환산",
|
||||
"비목": "노무비",
|
||||
"출처": "건설품셈 공통 8-1-3 6",
|
||||
"비고": "하루 노임 × 1/8(1일 8시간 · 건설품셈 공통 1-1-3 2)",
|
||||
}
|
||||
_ELEC_IN = {
|
||||
"이름": "전력 계약종별",
|
||||
"고르기": ["일반용(갑)Ⅰ 저압", "주택용 저압"],
|
||||
"출처": "유가전력 한전 전기요금표 2025-01-01",
|
||||
"비고": "품셈·계약예규에 계약종별 규정 없음(전력비는 실비 계상) — 기본 = 불러오기 기본값",
|
||||
}
|
||||
_ELEC = {
|
||||
"종류": "재료",
|
||||
"요소": {"이름": "전력량요금", "계약종별": "입력"},
|
||||
"이름": "전력",
|
||||
"단위": "㎾h",
|
||||
"수량": "EQ:{기계}.전력",
|
||||
"비목": "재료비",
|
||||
"출처": "건설품셈 공통 8-1-6 3 가",
|
||||
"비고": "기계 줄 전력(㎾) 그대로 — 전동기 부하율 규정 없음",
|
||||
}
|
||||
_FUEL = {"이름": "연료", "식": "EQ:{기계}.주연료종류", "출처": "건설품셈 공통 8-4 주①㉰"}
|
||||
_FUEL_LINE = {
|
||||
"종류": "재료",
|
||||
"요소": "MO:{연료}:{지역}",
|
||||
"이름": "주연료",
|
||||
"단위": "ℓ",
|
||||
"수량": "EQ:{기계}.주연료",
|
||||
"비목": "재료비",
|
||||
"출처": "건설품셈 공통 8-4-8",
|
||||
}
|
||||
_REGION = {"이름": "지역", "고르기": None, "출처": "건설품셈 공통 8-1-7 5"}
|
||||
_MISC = {
|
||||
"이름": "잡재료비",
|
||||
"식": "재료비 * EQ:{기계}.잡재료율 / 100",
|
||||
"비목": "재료비",
|
||||
"출처": "건설품셈 공통 8-4 주②",
|
||||
}
|
||||
_LOSS_ADD = {"이름": "기계손료", "식": "손료", "비목": "경비", "출처": "건설품셈 공통 8-1-6 2"}
|
||||
_CUT = "손료 원 미만 버림(건설품셈 공통 8-1-5 12) · 합계 원문 규정 없음"
|
||||
_S = {"기호": "S"}
|
||||
|
||||
|
||||
def _vars(*names: str) -> dict:
|
||||
sign = {"손료": "C", "시간환산": "Q"}
|
||||
return {
|
||||
n: {"기호": sign.get(n, "S"), "아래": n.replace("전력 계약종별", "전력계약종별")}
|
||||
for n in names
|
||||
}
|
||||
|
||||
|
||||
def _machine_in(codes: list[str]) -> dict:
|
||||
return {"이름": "기계", "고르기": codes}
|
||||
|
||||
|
||||
def new_rows(regions: list) -> dict[str, dict]:
|
||||
"""새 식 넷(키 없음 — 저장이 대장 다음 번호)."""
|
||||
region = {**_REGION, "고르기": regions}
|
||||
return {
|
||||
P1: {
|
||||
**_HEAD,
|
||||
"이름": "기계 시간당 기계경비(전력 기종)",
|
||||
"출처": f"{_SRC} · 8-1-6 3 가",
|
||||
"부품": {"갈래": "기계경비식"},
|
||||
"소유": "공용",
|
||||
"비고": "원문 운전경비 표 주연료 칸에 ㎾ 가 찍힌 전동 기종 — 전력비 = 전력(㎾) × 전력량요금 · 잡재료 = 전력비의 %(8-4 주②)",
|
||||
"입력": [_machine_in(MOVE[P1]), _ELEC_IN],
|
||||
"중간": [_LOSS_ONE],
|
||||
"호표": [_ELEC],
|
||||
"덧줄": [_MISC, _LOSS_ADD],
|
||||
"끝수": _CUT,
|
||||
"변수표": _vars("기계", "전력 계약종별", "손료"),
|
||||
},
|
||||
P2: {
|
||||
**_HEAD,
|
||||
"이름": "기계 시간당 기계경비(전력 · 조종원 기종)",
|
||||
"출처": f"{_SRC} · 8-1-6 3 가",
|
||||
"부품": {"갈래": "기계경비식"},
|
||||
"소유": "공용",
|
||||
"비고": "원문 운전경비 표 주연료 칸에 ㎾ 가 찍히고 조종원이 있는 전동 기종(점보드릴) — 전력비 + 잡재료(전력비의 %) + 조종원",
|
||||
"입력": [_machine_in(MOVE[P2]), _ELEC_IN],
|
||||
"중간": [_LOSS_ONE, _JOB, _HOUR],
|
||||
"호표": [_ELEC, _CREW],
|
||||
"덧줄": [_MISC, _LOSS_ADD],
|
||||
"끝수": _CUT,
|
||||
"변수표": _vars("기계", "전력 계약종별", "손료", "직종", "시간환산"),
|
||||
},
|
||||
N3: {
|
||||
**_HEAD,
|
||||
"이름": "기계 시간당 기계경비(조종원 없는 기종 · 손료계수 한 칸)",
|
||||
"출처": _SRC,
|
||||
"부품": {"갈래": "기계경비식"},
|
||||
"소유": "공용",
|
||||
"비고": "원문 손료 표가 시간당 손료계수 하나만 준 기종(8-3-8 기타기계 등) 가운데 주연료가 있고 조종원이 없는 것",
|
||||
"입력": [_machine_in(MOVE[N3]), region],
|
||||
"중간": [_LOSS_ONE, _FUEL],
|
||||
"호표": [_FUEL_LINE],
|
||||
"덧줄": [_MISC, _LOSS_ADD],
|
||||
"끝수": _CUT,
|
||||
"변수표": _vars("기계", "지역", "손료", "연료"),
|
||||
},
|
||||
DIRECT: {
|
||||
**_HEAD,
|
||||
"이름": "기계 시간당 기계경비(직접 값)",
|
||||
"출처": "자체",
|
||||
"부품": {"갈래": "기계경비식"},
|
||||
"소유": "공용",
|
||||
"비고": "자체 — 구성 없는 기계 · 구성(손료 · 연료 · 조종원) 없이 시간당 노무비 · 재료비 · 경비를 바로 둔 기계(내 기계 「시간당 값 직접」) — 기계 줄 값 그대로",
|
||||
"입력": [{"이름": "기계", "고르기": []}],
|
||||
"중간": [],
|
||||
"호표": [],
|
||||
"덧줄": [
|
||||
{
|
||||
"이름": "시간당 노무비",
|
||||
"식": "EQ:{기계}.노무비",
|
||||
"비목": "노무비",
|
||||
"출처": "자체",
|
||||
},
|
||||
{
|
||||
"이름": "시간당 재료비",
|
||||
"식": "EQ:{기계}.재료비",
|
||||
"비목": "재료비",
|
||||
"출처": "자체",
|
||||
},
|
||||
{"이름": "시간당 경비", "식": "EQ:{기계}.경비", "비목": "경비", "출처": "자체"},
|
||||
], # fmt: skip
|
||||
"끝수": None,
|
||||
"변수표": _vars("기계"),
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _note(row: dict, text: str) -> None:
|
||||
was = str(row.get("비고") or "")
|
||||
if text not in was:
|
||||
row["비고"] = f"{was} · {text}" if was else text
|
||||
|
||||
|
||||
def machine_changes() -> list[dict]:
|
||||
rows = {r["키"]: r for r in store.read(MACHINE)[0]["줄"]}
|
||||
out = []
|
||||
for key, row in rows.items():
|
||||
new = copy.deepcopy(row)
|
||||
vals, unit, src = new["값"], new.setdefault("단위", {}), new.setdefault("출처", {})
|
||||
if key in POWER and vals.get("전력") is None:
|
||||
text = str(vals.get("주연료"))
|
||||
text += "㎾" if unit.get("주연료") == "㎾" else "" # 모르타르 믹서 = 단위 칸에 ㎾
|
||||
got = re.search(r"([\d.]+)\s*㎾", text)
|
||||
assert got and float(got.group(1)) == POWER[key], (key, text)
|
||||
vals["주연료"], vals["전력"] = None, POWER[key]
|
||||
unit["주연료"], unit["전력"] = "ℓ/hr", "kWh/hr"
|
||||
src["전력"] = src.get("주연료")
|
||||
_note(new, f"전력 = 원문 주연료 칸 「{text}」(㎾ · 전동기 부하율 규정 없음 → 그대로)")
|
||||
if key == "EQ000532":
|
||||
_note(new, "원문 「휘발유1.3」 갈래는 주연료2 칸 · 시간당 식은 전력")
|
||||
if key in MISC_DASH and vals.get("잡재료율") is None:
|
||||
vals["잡재료율"] = 0
|
||||
_note(new, "잡재료율 0 = 원문 잡재료 「-」")
|
||||
if key in JOBS and not vals.get("조종원직종"):
|
||||
job, why = JOBS[key]
|
||||
vals["조종원직종"] = job
|
||||
src["조종원직종"] = JOB_SRC.format(job)
|
||||
_note(new, f"직종 = 사용자 확정(요구 799) — {why}")
|
||||
if key == TYPO[0] and new.get("이름") == TYPO[1]:
|
||||
items = list(new.items())
|
||||
at = [k for k, _ in items].index("이름") + 1
|
||||
items.insert(at, ("옛이름", TYPO[1]))
|
||||
new = dict(items)
|
||||
new["이름"] = TYPO[2]
|
||||
if new.get("상세구분") == TYPO[1]:
|
||||
new["상세구분"] = TYPO[2]
|
||||
if new != row:
|
||||
out.append({"op": "edit", "key": key, "row": new})
|
||||
return out
|
||||
|
||||
|
||||
def logic_changes() -> list[dict]:
|
||||
data = store.read(LOGIC)[0]
|
||||
rows = {r["키"]: r for r in data["줄"]}
|
||||
if any(r.get("이름") == "기계 시간당 기계경비(직접 값)" for r in rows.values()):
|
||||
return []
|
||||
moved = {c for codes in MOVE.values() for c in codes} | set(DROP_ONLY)
|
||||
out = []
|
||||
for key in (LOSS_ONLY, *[k for k in MOVE if k.startswith("GC")]):
|
||||
new = copy.deepcopy(rows[key])
|
||||
pick = next(i for i in new["입력"] if i.get("이름") == "기계")
|
||||
if key == LOSS_ONLY:
|
||||
pick["고르기"] = [c for c in pick["고르기"] if str(c) not in moved]
|
||||
else:
|
||||
pick["고르기"] += [c for c in MOVE[key] if c not in pick["고르기"]]
|
||||
out.append({"op": "edit", "key": key, "row": new})
|
||||
regions = next(i["고르기"] for i in rows["GC000268"]["입력"] if i["이름"] == "지역")
|
||||
out += [{"op": "add", "row": row} for row in new_rows(regions).values()]
|
||||
return out
|
||||
|
||||
|
||||
def main(check: bool) -> None:
|
||||
parts = []
|
||||
for file, changes in ((MACHINE, machine_changes()), (LOGIC, logic_changes())):
|
||||
print(file, len(changes), [c.get("key") or c["row"]["이름"] for c in changes])
|
||||
if changes:
|
||||
parts.append({"file": file, "version": store.read(file)[1], "changes": changes})
|
||||
if check or not parts:
|
||||
return
|
||||
# 대장 열쇠 = 원문번호 — 넷 다 「8」 이면 한 키로 겹침 → 옛 기계경비식처럼 이름 붙은 열쇠(줄은 「8」)
|
||||
labels = {r["이름"]: f"공통 8 기계 시간당 경비({LABEL[t]})" for t, r in new_rows([]).items()}
|
||||
plain = store.ledger_label
|
||||
store.ledger_label = lambda book, tid, no, row: (
|
||||
labels.get(row.get("이름")) or plain(book, tid, no, row)
|
||||
)
|
||||
got = make.save(parts, confirmed=True)
|
||||
print("저장", got["added"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main("--check" in sys.argv)
|
||||
@@ -1,44 +0,0 @@
|
||||
"""826-2 기계 한 파일(`기계.json`) → 폴더 `기계/`(한 대 한 파일 · `master_machine_files`).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_기계폴더_826_2.py [마스터 폴더]
|
||||
옮긴 뒤 폴더를 다시 읽어 옛 파일과 머리 · 줄마다 · 차례까지 같은지 대조하고 같을 때만 옛 파일을 지움.
|
||||
두 번 돌려도 같음(옛 파일이 없으면 할 일 없음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
|
||||
import master_machine_files as mmf # noqa: E402
|
||||
|
||||
|
||||
def move(folder: Path) -> int:
|
||||
old = folder / mmf.NAME
|
||||
if not old.is_file():
|
||||
return 0
|
||||
data = json.loads(old.read_bytes(), parse_float=Decimal, parse_int=Decimal)
|
||||
keys = [str(r["키"]) for r in data["줄"]]
|
||||
if keys != sorted(keys):
|
||||
raise SystemExit("줄 차례가 키 차례 아님 — 폴더 꼴(키 차례)로 못 옮김")
|
||||
mmf.write(folder, data)
|
||||
got = mmf.table(folder)[0]
|
||||
if list(got) != list(data) or any(got[k] != data[k] for k in data if k != "줄"):
|
||||
raise SystemExit("머리 다름 — 옛 파일 둠")
|
||||
if len(got["줄"]) != len(data["줄"]):
|
||||
raise SystemExit(f"줄 수 다름 {len(got['줄'])} ≠ {len(data['줄'])} — 옛 파일 둠")
|
||||
for a, b in zip(got["줄"], data["줄"]):
|
||||
if a != b or list(a) != list(b):
|
||||
raise SystemExit(f"줄 다름 「{b.get('키')}」 — 옛 파일 둠")
|
||||
old.unlink()
|
||||
return len(keys)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
target = Path(sys.argv[1]) if len(sys.argv) > 1 else HERE.parent
|
||||
print(f"옮긴 기계 {move(target)} 대")
|
||||
@@ -1,436 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""M01 보강(794-2a2 · 요구 653 · 분석 652-794-2a 2 장 번 1 · 3 · 9) — 로직 셋 더함 · GF000284 넓힘.
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_M01보강_794_2a2.py
|
||||
- 저장 = M01 화면 [저장] 길(`M01_MasterData_Store.save` — 대장 키 · 검사 · 글 모양 유지) · 한 번 돌림(있으면 멈춤).
|
||||
- 1 자재 운반 — 산림 10-1 시멘트운반 · 10-2 철근운반 GF 둘: 운임 = 자재 구역화물(톤급 · 거리 이내) ÷ 적재 톤 ·
|
||||
하차 = 보통인부 품 입력(원문 「인도조건에 따라」 · 품 수 없음 · 옛 판 값은 설명에 참고로만).
|
||||
- 9 기계 채집 — 자체 GX 한 줄: 굴착기 1 회 N 개(q = N ÷ ㎡당 개수) · 건설 공통 8-2-3 작업량(GC001147) ·
|
||||
상차 · 소운반 덤프 8-2-8(GC001155) · 근거 = 산림 13-2-4 주② · 13-2-3 주⑪.
|
||||
- 3 덤프 조합 — GF000284 입력 끝에 적재기계 · 덤프 고르기(첫째 = 원문 굴착기 0.7㎥ · 15ton = 기존 셈 그대로).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from decimal import Decimal as D
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
sys.path.insert(0, str(MASTER.parents[1]))
|
||||
from M01_MasterData import M01_MasterData_Store as st # noqa: E402
|
||||
|
||||
F10 = "로직_산림품셈_10장_자재․장비_운반.json"
|
||||
FX = "로직_자체.json"
|
||||
REGIONS = [
|
||||
"전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북",
|
||||
"경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주",
|
||||
] # fmt: skip
|
||||
ROCK = ["암석작업(연암・보통암・경암)", "해당 없음", "전석섞인토사"]
|
||||
NAMES = (
|
||||
"시멘트운반",
|
||||
"철근운반",
|
||||
"깬잡석 · 야면석 · 고임돌 · 파쇄석 채집(기계)",
|
||||
)
|
||||
|
||||
|
||||
# ── 1 자재 운반 ─────────────────────────────────────────────────────────
|
||||
def _freight() -> tuple[list[str], list[str]]:
|
||||
"""구역화물 줄 규격 「<톤급>, <거리>」 → (톤급 목록 · 거리 목록) — 2.0톤이하는 뺌 · 원문 10.5톤 첫째."""
|
||||
rows = json.loads((MASTER / "재료_자재품목.json").read_text(encoding="utf-8"))["줄"]
|
||||
tons, kms = [], []
|
||||
for r in rows:
|
||||
if r.get("이름") != "구역화물" or ", " not in str(r.get("규격")):
|
||||
continue
|
||||
ton, km = r["규격"].split(", ")
|
||||
tons += [ton] if ton not in tons and not ton.endswith("이하") else []
|
||||
kms += [km] if km not in kms else []
|
||||
tons.remove("10.5톤")
|
||||
return ["10.5톤", *tons], kms
|
||||
|
||||
|
||||
def _chain(name: str, pairs: list[tuple[str, D]], last: D) -> str:
|
||||
"""고른 글 → 수 — 만약(name == 'a', 1, 만약(…, last))."""
|
||||
text = str(last)
|
||||
for label, value in reversed(pairs):
|
||||
text = f"만약({name} == '{label}', {value}, {text})"
|
||||
return text
|
||||
|
||||
|
||||
def haul(no: str, what: str, unit: str, per: str, old: str) -> dict:
|
||||
tons, kms = _freight()
|
||||
t_pairs = [(t, D(t.removesuffix("톤"))) for t in tons[1:]]
|
||||
sack = no == "10-1"
|
||||
mid = [
|
||||
{"이름": "적재량", "식": _chain("톤급", t_pairs, D("10.5")), "단위": "ton"},
|
||||
]
|
||||
if sack:
|
||||
mid.append(
|
||||
{"이름": "포수", "식": "1000 / 40", "단위": "포/ton", "출처": "산림품셈 10-1 주"}
|
||||
)
|
||||
div = "1.1 * 적재량 * 포수" if sack else "1.1 * 적재량"
|
||||
return {
|
||||
"원문번호": no,
|
||||
"이름": what,
|
||||
"결과단위": unit,
|
||||
"출처": f"산림품셈 {no}",
|
||||
"소유": "공용",
|
||||
"비고": (
|
||||
f"운반비 = 구역화물 운임(자재 「구역화물」 톤급 · 거리 이내 줄 · 원/회) ÷ 적재 톤{per}"
|
||||
" · 해석: 적재 톤 = 톤급 · ÷ 1.1 = 운임의 부가세 뺌(실무 · 원문 없음)"
|
||||
" · 하차비 = 보통인부 하차 품(입력 · 원문 「1회 · 인도조건에 따라」 · 품 수 없음)"
|
||||
f" · 옛 판 참고(현행 원문 없음): {old}"
|
||||
),
|
||||
"시험입력": {"톤급": "10.5톤", "거리": "20km", "하차품": D("0.0489")},
|
||||
"입력": [
|
||||
{
|
||||
"이름": "톤급",
|
||||
"설명": "구역화물 차 톤급 — 원문 10.5ton",
|
||||
"고르기": tons,
|
||||
"출처": f"산림품셈 {no}",
|
||||
},
|
||||
{
|
||||
"이름": "거리",
|
||||
"설명": "운반 거리 구간(이내) — 구역화물 운임표 거리",
|
||||
"고르기": kms,
|
||||
"출처": f"산림품셈 {no}",
|
||||
},
|
||||
{
|
||||
"이름": "하차품",
|
||||
"설명": f"하차 보통인부 품(ton당) — 인도조건에 따라 · 옛 판 참고 {old}",
|
||||
"단위": "인/ton",
|
||||
"출처": f"산림품셈 {no}",
|
||||
"비고": "기본값 없음 — 설계자 입력",
|
||||
},
|
||||
],
|
||||
"중간": mid,
|
||||
"호표": [
|
||||
{
|
||||
"종류": "재료",
|
||||
"요소": {
|
||||
"구분": "운송·용역",
|
||||
"상세구분": "화물운임",
|
||||
"검색어": "구역화물 {톤급}, {거리}",
|
||||
},
|
||||
"이름": "구역화물 운임",
|
||||
"단위": "회",
|
||||
"수량": f"1 / ({div})",
|
||||
"비목": "경비",
|
||||
"출처": f"산림품셈 {no}",
|
||||
},
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000002",
|
||||
"이름": "보통인부(하차)",
|
||||
"단위": "인",
|
||||
"수량": "하차품 / 포수" if sack else "하차품",
|
||||
"비목": "노무비",
|
||||
"출처": f"산림품셈 {no}",
|
||||
},
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
|
||||
|
||||
# ── 9 기계 채집 ─────────────────────────────────────────────────────────
|
||||
K_ROCK = "버킷에 넣기 어렵고 불규칙한 공극이 생기는 것으로서 발파 또는 리퍼작업 등에 의하여 얻어진 암과 파쇄암, 호박돌, 역 등인 경우"
|
||||
DIGGERS = ["0201-0070", "0201-0020", "0201-0040", "0201-0060", "0201-0080", "0201-0100"]
|
||||
DUMPS = [("0602-0025", D("2.5")), ("0602-0045", D("4.5")), ("0602-0060", D(6)), ("0602-0080", D(8))]
|
||||
|
||||
|
||||
def gather() -> dict:
|
||||
q147 = (
|
||||
"로직(GC001147, 버킷용량=q, 규격구분=규격구분, 선회각도=선회각도, "
|
||||
f"버킷조건='{K_ROCK}', 현장조건='흐트러진 상태', 등급=등급, 토질명='파쇄암', "
|
||||
"E보정='해당 없음', 협소현장='해당 없음', f=1, E입력=0, 싸이클입력=0)"
|
||||
)
|
||||
q155 = (
|
||||
"로직(GC001155, 적재용량=덤프T, 단위중량=쌓기무게, 체적변화율=1, f=1, 운반거리=운반거리, "
|
||||
"도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', 적하토질='모래, 역, 호박돌', "
|
||||
"적하조건=적하조건, 적재장소='적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때', "
|
||||
"덮개='해당 없음', 세륜='안 함', 적재방법='적재기계', 적재싸이클=cm, 적재버킷=q, "
|
||||
"버킷계수=K, 적재효율=E, 인력종류='석재류', 적재시간입력=0, E입력=0)"
|
||||
)
|
||||
dig = "로직(GC000267, 기계=굴착기, 지역=지역, 보정작업=보정작업)"
|
||||
return {
|
||||
"원문번호": "13-2-4",
|
||||
"구분": "자체",
|
||||
"상세구분": "13장 구조물",
|
||||
"이름": NAMES[2],
|
||||
"결과단위": "원/㎡",
|
||||
"출처": "자체",
|
||||
"소유": "공용",
|
||||
"비고": (
|
||||
"깬잡석 · 야면석 · 고임돌 · 파쇄석 기계 채집 — 원문 품 없음: 산림 13-2-4 주② 「기계화 시공이 가능한"
|
||||
" 지역은 상기 품을 적용하지 않는다」 · 13-2-3 주⑪ 「건설 8-2-3 굴착기 참조」 · 실무 = 8-2-3 Q 식 +"
|
||||
" 1회 개수 · 해석: q = 1회 개수 ÷ ㎡당 개수(㎡ · f = 1) · K = 암·파쇄암 · E = 파쇄암 표(흐트러진)"
|
||||
" · 상차 = 채집과 같은 Q · 소운반 = 건설 공통 8-2-8(적재기계 = 같은 굴착기 · 산간지도로 · 좁은 적재장소)"
|
||||
),
|
||||
"시험입력": {
|
||||
"버킷개수": D(4),
|
||||
"쌓기개수": D(16),
|
||||
"굴착기": "0201-0070",
|
||||
"선회각도": D(90),
|
||||
"등급": "보통",
|
||||
"보정작업": ROCK[0],
|
||||
"상차": "포함",
|
||||
"덤프": "0602-0025",
|
||||
"운반거리": D("0.2"),
|
||||
"쌓기무게": D("0.575"),
|
||||
"적하조건": "불량",
|
||||
"지역": "전국평균",
|
||||
}, # fmt: skip
|
||||
"입력": [
|
||||
{"이름": "버킷개수", "설명": "굴착기가 한 번에 담는 돌 개수", "단위": "개"},
|
||||
{
|
||||
"이름": "쌓기개수",
|
||||
"설명": "쌓기 1㎡에 드는 돌 개수(돌 뒷길이에 따름)",
|
||||
"단위": "개/㎡",
|
||||
},
|
||||
{
|
||||
"이름": "굴착기",
|
||||
"설명": "채집 · 상차 굴착기(무한궤도)",
|
||||
"고르기": DIGGERS,
|
||||
"출처": "건설품셈 공통 8-2-3",
|
||||
},
|
||||
{
|
||||
"이름": "선회각도",
|
||||
"설명": "선회 각도",
|
||||
"단위": "도",
|
||||
"고르기": [D(90), D(135), D(45), D(180)],
|
||||
"출처": "건설품셈 공통 8-2-3 3",
|
||||
},
|
||||
{
|
||||
"이름": "등급",
|
||||
"설명": "작업 조건 등급(파쇄암 작업효율)",
|
||||
"고르기": ["보통", "불량"],
|
||||
"출처": "건설품셈 공통 8-2-3 2",
|
||||
},
|
||||
{
|
||||
"이름": "보정작업",
|
||||
"설명": "암석 작업이면 기계손료 가산",
|
||||
"고르기": ROCK,
|
||||
"출처": "건설품셈 공통 8-1-7 1",
|
||||
},
|
||||
{"이름": "상차", "설명": "채집한 돌을 덤프에 싣는지", "고르기": ["포함", "안 함"]},
|
||||
{
|
||||
"이름": "덤프",
|
||||
"설명": "소운반 덤프트럭",
|
||||
"고르기": [d for d, _ in DUMPS],
|
||||
"출처": "건설품셈 공통 8-2-8",
|
||||
},
|
||||
{
|
||||
"이름": "운반거리",
|
||||
"설명": "소운반 편도 거리 — 0 이면 소운반 없음",
|
||||
"단위": "㎞",
|
||||
"출처": "건설품셈 공통 8-2-8",
|
||||
},
|
||||
{"이름": "쌓기무게", "설명": "쌓기 1㎡ 돌 무게", "단위": "t/㎡"},
|
||||
{
|
||||
"이름": "적하조건",
|
||||
"설명": "덤프 적하 작업조건",
|
||||
"고르기": ["불량", "보통", "양호"],
|
||||
"출처": "건설품셈 공통 8-2-8 4",
|
||||
},
|
||||
{
|
||||
"이름": "지역",
|
||||
"설명": "기계 연료값을 고를 지역",
|
||||
"고르기": REGIONS,
|
||||
"출처": "건설품셈 공통 8-1-7 5",
|
||||
},
|
||||
],
|
||||
"중간": [
|
||||
{"이름": "q", "식": "반올림(버킷개수 / 쌓기개수, 2)", "단위": "㎡"},
|
||||
{
|
||||
"이름": "규격구분",
|
||||
"식": "만약(굴착기 == '0201-0020' 또는 굴착기 == '0201-0040', '0.12∼0.4', "
|
||||
"만약(굴착기 == '0201-0100', '1.0∼1.2', '0.6∼0.8'))",
|
||||
},
|
||||
{"이름": "K", "식": f"찾기(CC000042, 현장조건='{K_ROCK}').K"},
|
||||
{
|
||||
"이름": "E",
|
||||
"식": "찾기(CC000043, 현장조건='흐트러진 상태', 등급=등급, 토질명='파쇄암').E",
|
||||
},
|
||||
{"이름": "cm", "식": "찾기(CC000045, 규격=규격구분, 각도=선회각도).시간", "단위": "초"},
|
||||
{"이름": "Q", "식": q147, "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-3"},
|
||||
{"이름": "덤프T", "식": _chain("덤프", DUMPS[1:], DUMPS[0][1]), "단위": "ton"},
|
||||
{"이름": "Q2", "식": q155, "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-8"},
|
||||
],
|
||||
"호표": [
|
||||
{"종류": "로직", "요소": dig, "이름": "굴착기(채집)", "단위": "시간", "수량": "1 / Q"},
|
||||
{
|
||||
"종류": "로직",
|
||||
"요소": dig,
|
||||
"이름": "굴착기(상차)",
|
||||
"단위": "시간",
|
||||
"수량": "만약(상차 == '포함', 1 / Q, 0)",
|
||||
},
|
||||
{
|
||||
"종류": "로직",
|
||||
"요소": "로직(GC000269, 기계=덤프, 지역=지역, 보정작업=보정작업)",
|
||||
"이름": "덤프트럭(소운반)",
|
||||
"단위": "시간",
|
||||
"수량": "만약(운반거리 > 0, 1 / Q2, 0)",
|
||||
},
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
|
||||
|
||||
# ── 3 덤프 조합 ─────────────────────────────────────────────────────────
|
||||
LOADERS = ["0302-0134", "0302-0172"]
|
||||
BUCKET = [("0201-0020", "0.2"), ("0201-0040", "0.4"), ("0201-0060", "0.6"), ("0201-0080", "0.8"),
|
||||
("0201-0100", "1.0"), ("0302-0134", "1.34"), ("0302-0172", "1.72")] # fmt: skip
|
||||
LOOSE = "흐트러진 산적상태에서 적재하는 것으로 위 상태보다 약간 삽날이 들어가기 어려운 토질로서 버킷에 가득 채울 수 있는 것, 즉 점토, 역질토"
|
||||
LUMP = "버킷에 넣기 어렵고 허술하며 불규칙한 공극이 생긴 것, 예를 들면 발파 또는 리퍼로 깎은 암괴, 호박돌, 역 등"
|
||||
|
||||
|
||||
def dump(row: dict) -> dict:
|
||||
"""GF000284 — 입력 끝에 적재기계 · 덤프 · 0.7 · 20 · 0.85 · 15 수를 고른 값으로(기본 = 그 수)."""
|
||||
old = {m["이름"]: m for m in row["중간"]}
|
||||
assert "q0" not in old, "이미 넓힘"
|
||||
k_loader = f"만약(암 == 0, 찾기(CC000048, 현장조건='{LOOSE}').계수, 찾기(CC000049, 현장조건='{LUMP}').계수)"
|
||||
loader_cm = (
|
||||
"찾기(CC000051, 기종='타이어식').m * 찾기(CC000052, 항목='편도주행거리(표준)').값 + "
|
||||
"찾기(CC000047, 기종='타이어식', 작업방법='산적상태에서 담을 때', 현장조건='용이한 경우').t1 + "
|
||||
"찾기(CC000052, 항목='기본시간(t2, 기어변화 등)').값"
|
||||
)
|
||||
swap = {
|
||||
"Q1": ("3600 * 0.7 * K * (1 / L) * E0 / 찾기(QF000336, 구분='㎝(초)').값", "3600 * q0 * K * (1 / L) * E0 / Cm"),
|
||||
"q": ("15 / 감마 * L", "덤프T / 감마 * L"),
|
||||
"n": ("q / (0.7 * K)", "q / (q0 * K)"),
|
||||
"Cmt": ("20 * n / (60 * 0.85)", "Cms * n / (60 * Es)"),
|
||||
} # fmt: skip
|
||||
mid = []
|
||||
for m in row["중간"]:
|
||||
m = dict(m)
|
||||
if m["이름"] in swap:
|
||||
a, b = swap[m["이름"]]
|
||||
assert m["식"].count(a) == 1, m["이름"]
|
||||
m["식"] = m["식"].replace(a, b)
|
||||
if m["이름"] == "K":
|
||||
m["식"] = f"만약(로더 == 1, {k_loader}, {m['식']})"
|
||||
m["출처"] += " · 건설품셈 공통 8-2-5 2"
|
||||
if m["이름"] == "E0":
|
||||
m["식"] = (
|
||||
"만약(로더 == 1, 찾기(CC000050, 현장조건='흐트러진 상태', 등급='보통', "
|
||||
f"토질명=만약(암 == 0, '모래, 사질토', '파쇄암')).E, {m['식']})"
|
||||
)
|
||||
m["출처"] += " · 건설품셈 공통 8-2-5 3"
|
||||
if m["이름"] == "Q1":
|
||||
for x in [
|
||||
{"이름": "로더cm", "식": loader_cm, "단위": "초", "출처": "건설품셈 공통 8-2-5 1"},
|
||||
{
|
||||
"이름": "Cm",
|
||||
"식": "만약(로더 == 1, 로더cm, 만약(적재기계 == '0201-0070', "
|
||||
"찾기(QF000336, 구분='㎝(초)').값, 찾기(CC000045, 규격=규격구분, 각도=180).시간))",
|
||||
"단위": "초",
|
||||
"출처": "산림품셈 10-12-1 주⑤ · 건설품셈 공통 8-2-3 3",
|
||||
},
|
||||
{
|
||||
"이름": "Cms",
|
||||
"식": "만약(로더 == 1, 로더cm, 만약(적재기계 == '0201-0070', 20, "
|
||||
"찾기(CC000045, 규격=규격구분, 각도=135).시간))",
|
||||
"단위": "초",
|
||||
"출처": "산림품셈 10-12-1 2. 운반 · 건설품셈 공통 8-2-3 3",
|
||||
},
|
||||
{
|
||||
"이름": "Es",
|
||||
"식": "만약(로더 == 1, E0, 0.85)",
|
||||
"출처": "산림품셈 10-12-1 2. 운반",
|
||||
},
|
||||
{
|
||||
"이름": "덤프T",
|
||||
"식": "만약(덤프 == '0602-0080', 8, 만약(덤프 == '0602-0240', 24, 15))",
|
||||
"단위": "ton",
|
||||
"출처": "산림품셈 10-12-1 주① · 건설품셈 공통 8-2-8",
|
||||
},
|
||||
]:
|
||||
mid.append(x)
|
||||
mid.append(m)
|
||||
if m["이름"] == "암":
|
||||
mid += [
|
||||
{"이름": "로더", "식": "만약(적재기계 == '0302-0134' 또는 적재기계 == '0302-0172', 1, 0)"},
|
||||
{"이름": "q0", "식": _chain("적재기계", [(a, D(b)) for a, b in BUCKET], D("0.7")), "단위": "㎥"},
|
||||
{"이름": "규격구분", "식": "만약(q0 <= 0.4, '0.12∼0.4', 만약(q0 <= 0.8, '0.6∼0.8', '1.0∼1.2'))"},
|
||||
] # fmt: skip
|
||||
lines = [dict(x) for x in row["호표"]]
|
||||
a0 = "로직(GC000267, 기계='0201-0070', 지역=지역, 보정작업=보정작업)"
|
||||
a1 = "로직(GC000269, 기계='0602-0150', 지역=지역, 보정작업=보정작업)"
|
||||
assert lines[0]["요소"] == a0 and lines[1]["요소"] == a1
|
||||
lines[0]["요소"] = (
|
||||
"로직(GC000267, 기계=적재기계, 지역=지역, 보정작업=만약(로더 == 1, '해당 없음', 보정작업))"
|
||||
)
|
||||
lines[1]["요소"] = "로직(GC000269, 기계=덤프, 지역=지역, 보정작업=보정작업)"
|
||||
more = [
|
||||
{
|
||||
"이름": "적재기계",
|
||||
"설명": "덤프에 싣는 기계 — 원문 굴착기 0.7㎥",
|
||||
"고르기": ["0201-0070", *DIGGERS[1:], *LOADERS],
|
||||
"출처": "산림품셈 10-12-1 주① · 건설품셈 공통 8-2-3 · 8-2-5",
|
||||
},
|
||||
{
|
||||
"이름": "덤프",
|
||||
"설명": "덤프트럭 톤급 — 원문 15ton",
|
||||
"고르기": ["0602-0150", "0602-0080", "0602-0240"],
|
||||
"출처": "산림품셈 10-12-1 주① · 건설품셈 공통 8-2-8",
|
||||
},
|
||||
]
|
||||
memo = (
|
||||
" · 적재기계 · 덤프 고르기(794-2a2) — 첫째 = 원문(굴착기 0.7㎥ · 15ton · 셈 같음) · 다른 굴착기 ="
|
||||
" 8-2-3 싸이클 표(적재 180° · 운반 적재 135° — 0.7㎥ 이면 22 · 20초와 같음) · K · E0 · Es 는 산림 값 ·"
|
||||
" 해석: 로더(타이어) cm = m·ℓ + t1 + t2(8-2-5 · 산적 · 용이 · 표준 8m) · K = 산적 흐트러진 · 암은"
|
||||
" 자연·기타 넣기 어려움 · E = 흐트러진 보통 · Es = E · 손료 보정 없음(8-1-7 1 = 무한궤도만)"
|
||||
)
|
||||
return {
|
||||
**row,
|
||||
"비고": row["비고"] + memo,
|
||||
"입력": row["입력"] + more,
|
||||
"중간": mid,
|
||||
"호표": lines,
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
files, _ = st.loaded()
|
||||
have = {
|
||||
r.get("이름") for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄", [])
|
||||
}
|
||||
if any(n in have for n in NAMES):
|
||||
raise SystemExit("이미 넣음 — 멈춤")
|
||||
gf = next(r for r in files[F10]["줄"] if r["키"] == "GF000284")
|
||||
cement = haul(
|
||||
"10-1",
|
||||
"시멘트운반",
|
||||
"원/포",
|
||||
" ÷ 포수(40kg 포대 · 원문 주)",
|
||||
"적상 0.18 · 적하 0.13 인/ton",
|
||||
)
|
||||
rebar = haul("10-2", "철근운반", "원/ton", "", "철근 하차 11분/ton(2인 1조)")
|
||||
batch = [
|
||||
{
|
||||
"file": F10,
|
||||
"version": st.read(F10)[1],
|
||||
"changes": [
|
||||
{"op": "edit", "key": "GF000284", "row": dump(gf)},
|
||||
{"op": "add", "row": cement},
|
||||
{"op": "add", "row": rebar},
|
||||
],
|
||||
},
|
||||
{"file": FX, "version": st.read(FX)[1], "changes": [{"op": "add", "row": gather()}]},
|
||||
]
|
||||
print(st.save(batch))
|
||||
files, _ = st.loaded()
|
||||
for d in (files[F10], files[FX]):
|
||||
for r in d["줄"]:
|
||||
if r.get("이름") in NAMES:
|
||||
print(r["키"], r["이름"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
main()
|
||||
@@ -1,625 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 1-2-7 운반 — 계수 표 여덟(계수_건설품셈_01장_적용기준.json 에 덧) + 로직 셋(새 파일).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_건설품셈_01장_적용기준.py
|
||||
- `… 나머지` = 782-2 1장 나머지(`_적용기준_나머지_표.py` · `_적용기준_나머지_로직.py`).
|
||||
- 원문 = 건설품셈 공통 `1-02_설계_및_수량.md` 1-2-7 운반(머리 ~ 1-2-8 앞).
|
||||
- 계수 표는 1-2-4 표 뒤 · 1-3-1 표 앞에 글로 끼움(기존 표 글자 그대로) · 화물자동차 적재량은 본문 md 표에서 읽음.
|
||||
- 로직 파일 `로직_건설품셈_01장_적용기준.json` 은 통째로 씀 · 차례 13(같은 차례 공통 2장보다 이름이 앞).
|
||||
- 키는 `_키대장.json` 다음 번호(master_keys.issue) · 이미 넣었으면 멈춤(한 번 돌림).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
import master_keys as mk # noqa: E402
|
||||
|
||||
COEF = "계수_건설품셈_01장_적용기준.json"
|
||||
LOGIC = "로직_건설품셈_01장_적용기준.json"
|
||||
BODY = (
|
||||
MASTER.parents[1]
|
||||
/ "resources/knowledge/original/원가계산/건설공사_표준품셈/본문/01_공통부문/제01장_적용기준/1-02_설계_및_수량.md"
|
||||
)
|
||||
SRC = "건설품셈 공통 1-2-7"
|
||||
HEAD = {"구분": "건설품셈 공통", "상세구분": "01장 적용기준"}
|
||||
ANGLES = [6, 11, 17, 22, 27, 31, 35, 39, 42, 45]
|
||||
|
||||
|
||||
class N(str):
|
||||
"""원문 그대로의 수 글자."""
|
||||
|
||||
|
||||
def raw(v) -> str:
|
||||
if isinstance(v, N):
|
||||
return str(v)
|
||||
if v is None:
|
||||
return "null"
|
||||
if isinstance(v, list):
|
||||
return "[" + ", ".join(raw(x) for x in v) + "]"
|
||||
if isinstance(v, int) and not isinstance(v, bool):
|
||||
return str(v)
|
||||
if isinstance(v, dict):
|
||||
return (
|
||||
"{"
|
||||
+ ", ".join(f"{json.dumps(k, ensure_ascii=False)}: {raw(x)}" for k, x in v.items())
|
||||
+ "}"
|
||||
)
|
||||
return json.dumps(v, ensure_ascii=False)
|
||||
|
||||
|
||||
def emit(t: dict) -> str:
|
||||
"""기존 공통 1장 표 글 모양 — 머리 넷 한 줄 · 줄은 한 줄씩."""
|
||||
head = ", ".join(f'"{k}": {raw(t[k])}' for k in ("키", "원문번호", "구분", "상세구분"))
|
||||
out = [" {", f" {head},"]
|
||||
for k in ("이름", "기준", "출처", "비고", "용도", "조건", "범위규칙", "값칸"):
|
||||
if k in t:
|
||||
out.append(f" {json.dumps(k, ensure_ascii=False)}: {raw(t[k])},")
|
||||
out.append(' "줄": [')
|
||||
out.append(",\n".join(" " + raw(r) for r in t["줄"]))
|
||||
out.append(" ],")
|
||||
if t["주"]:
|
||||
out.append(' "주": [')
|
||||
out.append(",\n".join(" " + raw(x) for x in t["주"]))
|
||||
out.append(" ]")
|
||||
else:
|
||||
out.append(' "주": []')
|
||||
out.append(" }")
|
||||
return "\n".join(out)
|
||||
|
||||
|
||||
# ── 본문 md ──────────────────────────────────────────────────────────
|
||||
def section() -> list[str]:
|
||||
lines = BODY.read_text(encoding="utf-8").split("\n")
|
||||
a = next(i for i, x in enumerate(lines) if x.startswith("### 1-2-7 "))
|
||||
b = next(i for i, x in enumerate(lines) if x.startswith("### 1-2-8 "))
|
||||
return lines[a:b]
|
||||
|
||||
|
||||
def md_tables(lines: list[str]) -> list[list[list[str]]]:
|
||||
out, i = [], 0
|
||||
while i < len(lines):
|
||||
if not lines[i].startswith("|"):
|
||||
i += 1
|
||||
continue
|
||||
rows = []
|
||||
while i < len(lines) and lines[i].startswith("|"):
|
||||
cells = [c.strip() for c in lines[i].strip().strip("|").split("|")]
|
||||
if not all(re.fullmatch(r":?-+:?", c) for c in cells):
|
||||
rows.append([c.replace("<br>", "\n") for c in cells])
|
||||
i += 1
|
||||
out.append(rows)
|
||||
return out
|
||||
|
||||
|
||||
_NUM = r"\d[\d,]*(?:\.\d+)?"
|
||||
|
||||
|
||||
def cell(c: str):
|
||||
"""값 칸 → (값, 원문) · 「-」 · 빈 칸 = (None, None)."""
|
||||
c = c.strip()
|
||||
if c in ("", "-"):
|
||||
return None, None
|
||||
if re.fullmatch(_NUM, c):
|
||||
return N(c.replace(",", "")), None
|
||||
m = re.fullmatch(rf"({_NUM})\s*∼\s*({_NUM})", c)
|
||||
if m:
|
||||
return [N(m[1].replace(",", "")), N(m[2].replace(",", ""))], None
|
||||
m = re.fullmatch(rf"\(({_NUM})\)", c)
|
||||
if m:
|
||||
return N(m[1].replace(",", "")), c
|
||||
m = re.match(rf"({_NUM})\n", c)
|
||||
if m:
|
||||
return N(m[1].replace(",", "")), c.replace("\n", "")
|
||||
raise ValueError(f"값 칸 못 읽음 {c!r}")
|
||||
|
||||
|
||||
TRUCK = ("6톤 차량", "8톤 차량", "11톤 차량", "20톤 트레일러")
|
||||
|
||||
|
||||
def truck_rows(table: list[list[str]]) -> list[dict]:
|
||||
"""화물자동차 적재량 — 「〃」 · 빈 종별 · 빈 단위는 윗줄 · 비고 「모자이크 포함」은 원문 묶음(타일 셋)."""
|
||||
rows, kind, unit = [], "", ""
|
||||
for r in table[2:]:
|
||||
name, spec, u, *vals, note = r
|
||||
kind = kind if name in ("", "〃") else name
|
||||
unit = unit if u in ("", "〃") else u
|
||||
if kind == "페인트" and spec == "":
|
||||
spec = "(18ℓ)/통" # 원문 둘째 줄 = 18ℓ 통 괄호 값
|
||||
row = {"종별": kind, "규격": spec.replace("\n", ""), "단위": unit}
|
||||
for col, v in zip(TRUCK, vals):
|
||||
value, orig = cell(v)
|
||||
if value is not None:
|
||||
row[col] = value
|
||||
if orig is not None:
|
||||
row[col + "원문"] = orig
|
||||
if kind in ("타일", "크링커타일"):
|
||||
row["비고"] = "모자이크 포함"
|
||||
elif note:
|
||||
row["비고"] = note.replace("\n", "")
|
||||
rows.append(row)
|
||||
return rows
|
||||
|
||||
|
||||
def notes(lines: list[str], start: str) -> list[str]:
|
||||
"""`start` 로 시작하는 줄 뒤 「[주]」 묶음(빈 줄까지)."""
|
||||
i = next(i for i, x in enumerate(lines) if x.startswith(start))
|
||||
i = next(j for j in range(i, len(lines)) if lines[j].strip() == "[주]")
|
||||
out = []
|
||||
for x in lines[i + 1 :]:
|
||||
if not x.strip():
|
||||
break
|
||||
out.append(x.strip())
|
||||
return out
|
||||
|
||||
|
||||
# ── 계수 표 ──────────────────────────────────────────────────────────
|
||||
def tables(lines: list[str], logic: dict) -> list[dict]:
|
||||
md = md_tables(lines)
|
||||
jige, brick, slope, truck = md[0], md[1], md[2], md[3]
|
||||
assert jige[2][0] == "토사류" and brick[2][0] == "보통인부" and slope[0][0] == "경사도"
|
||||
t = []
|
||||
|
||||
def add(label, name, src, use, cond, cols, rows, note=(), base="", extra=None):
|
||||
t.append(
|
||||
{
|
||||
"열쇠": f"공통 1-2-7 {label}",
|
||||
"이름": name,
|
||||
"기준": base,
|
||||
"출처": f"{SRC} {src}".strip(),
|
||||
**(extra or {}),
|
||||
"용도": {"공종": "운반", "대상": use, "로직키": logic.get(label, [])},
|
||||
"조건": cond,
|
||||
"값칸": cols,
|
||||
"줄": rows,
|
||||
"주": list(note),
|
||||
}
|
||||
)
|
||||
|
||||
one = [x.strip() for x in lines if re.match(r"^[가-다]\. ", x)][:3]
|
||||
add(
|
||||
"소운반 거리",
|
||||
"소운반 — 품에 포함된 거리 · 경사면 환산",
|
||||
"1",
|
||||
["소운반", "환산"],
|
||||
{},
|
||||
{"소운반거리": "m", "직고": "m", "수평거리": "m"},
|
||||
[{"소운반거리": N("20"), "직고": N("1"), "수평거리": N("6")}],
|
||||
one,
|
||||
base="소운반 규정",
|
||||
)
|
||||
add(
|
||||
"인력운반 기본공식",
|
||||
"인력운반 기본공식 — 1일 실작업시간 · 1회 운반량",
|
||||
"2",
|
||||
["인력", "작업량 조건"],
|
||||
{},
|
||||
{"실작업시간": "분", "1회 운반량": "㎏"},
|
||||
[{"실작업시간": "480 - 30", "실작업시간원문": "480분-30분", "1회 운반량": N("25")}],
|
||||
notes(lines, "2\\. "),
|
||||
base="기본공식 상수",
|
||||
extra={
|
||||
"비고": "식 Q = N × q · N = T/(60 × L × 2/V + t) = VT/(120L + Vt) — Q 1일 운반량 · N 1일 운반횟수 · q 1회 운반량 · T 1일 실작업시간(분) · L 운반거리(m) · t 적재적하 시간(분) · V 평균왕복속도(m/hr) · 1회 운반량 25㎏ = [주] 「25㎏을 1인의 비율로」 · 3 주③"
|
||||
},
|
||||
)
|
||||
rows = []
|
||||
for kind, tt in (("토사류", jige[2][1]), ("석재류", jige[3][1])):
|
||||
for road, v in zip(("양호", "보통", "불량"), jige[2][2:5]):
|
||||
rows.append(
|
||||
{
|
||||
"종류": kind,
|
||||
"운반로": road,
|
||||
"적재적하시간": N(tt.removesuffix("분")),
|
||||
"평균왕복속도": cell(v)[0],
|
||||
}
|
||||
)
|
||||
add(
|
||||
"지게운반",
|
||||
"지게운반 — 적재적하 시간 · 평균왕복속도",
|
||||
"3",
|
||||
["인력", "작업량 조건"],
|
||||
{"종류": "고르기", "운반로": "고르기"},
|
||||
{"적재적하시간": "분", "평균왕복속도": "m/hr"},
|
||||
rows,
|
||||
notes(lines, "3\\. "),
|
||||
base="기본공식 상수",
|
||||
extra={
|
||||
"비고": "원문 평균왕복속도 칸은 토사류 · 석재류 두 줄에 걸친 한 칸 — 두 종류에 같은 값"
|
||||
},
|
||||
)
|
||||
rows = [
|
||||
{"운반": "인력", "층수": N(str(i + 1)), "보통인부": cell(v)[0]}
|
||||
for i, v in enumerate(brick[2][2:7])
|
||||
]
|
||||
assert "0.31" in brick[3][1]
|
||||
rows.append({"운반": "리프트", "보통인부": N("0.31")})
|
||||
add(
|
||||
"벽돌운반",
|
||||
"벽돌운반 — 층별 인력운반",
|
||||
"4",
|
||||
["인력"],
|
||||
{"운반": "고르기", "층수": "수"},
|
||||
{"보통인부": "인"},
|
||||
rows,
|
||||
notes(lines, "4\\. "),
|
||||
base="1,000매당",
|
||||
extra={
|
||||
"비고": "리프트 줄 = 원문 비고 「리프트를 사용할 경우 보통인부 0.31인을 적용한다」 — 층수 없음(어느 층이든)"
|
||||
},
|
||||
)
|
||||
add(
|
||||
"인력운반(기계설비) 왕복평균속도",
|
||||
"인력운반(기계설비) — 왕복평균속도",
|
||||
"5 가",
|
||||
["인력", "작업량 조건"],
|
||||
{"도로상태": "고르기"},
|
||||
{"왕복평균속도": "km/hr"},
|
||||
[
|
||||
{"도로상태": "양호", "왕복평균속도": N("2")},
|
||||
{"도로상태": "보통", "왕복평균속도": N("1.5")},
|
||||
{"도로상태": "불량", "왕복평균속도": N("1")},
|
||||
{"도로상태": "물논", "왕복평균속도": N("0.5")},
|
||||
],
|
||||
["※ 도로상태 구분은 토목부분 참조"],
|
||||
base="기본공식 상수",
|
||||
)
|
||||
add(
|
||||
"인력운반(기계설비) 준비작업시간",
|
||||
"인력운반(기계설비) — 준비작업시간 · 1회 운반량",
|
||||
"5 가",
|
||||
["인력", "작업량 조건"],
|
||||
{},
|
||||
{"준비작업시간": "분", "1회 운반량": "㎏"},
|
||||
[{"준비작업시간": N("2"), "1회 운반량": N("25")}],
|
||||
base="기본공식 상수",
|
||||
extra={
|
||||
"비고": "장대물 · 중량물 등 인력운반비 산출공식 — 운반비 = M/T × A(60 × 2 × L/V + t) · A 인력운반공 노임 · M 인력운반공 수(총운반량/1인당 1회 운반량) · L 운반거리(km) · V 왕복평균속도(km/hr) · T 1일 실작업시간 · t 준비작업시간"
|
||||
},
|
||||
)
|
||||
pct, ang, alpha = slope[0][2:], slope[1][2:], slope[2][2:]
|
||||
assert [int(a) for a in ang] == ANGLES
|
||||
add(
|
||||
"경사지 운반 환산계수",
|
||||
"경사지 운반 환산계수(α)",
|
||||
"5 나",
|
||||
["환산"],
|
||||
{"경사도": "수", "각도": "수"},
|
||||
{"환산계수": ""},
|
||||
[{"경사도": N(p), "각도": N(a), "환산계수": N(x)} for p, a, x in zip(pct, ang, alpha)],
|
||||
["경사지 환산거리 a×L"],
|
||||
base="환산계수",
|
||||
extra={
|
||||
"비고": "경사도 = % · 각도 = ° · 해석: 1 나 · 3 주⑤(직고 1m = 수평 6m)와 함께 지게운반(3)에도 씀"
|
||||
},
|
||||
)
|
||||
seven = [
|
||||
x.strip()
|
||||
for x in lines[lines.index("7\\. 화물자동차의 적재량") :]
|
||||
if re.match(r"^[가-라]\. ", x)
|
||||
]
|
||||
add(
|
||||
"화물자동차 적재량",
|
||||
"화물자동차의 적재량",
|
||||
"7 라",
|
||||
["작업량 조건", "운반"],
|
||||
{"종별": "고르기", "규격": "고르기"},
|
||||
{**{c: "단위 칸" for c in TRUCK}, "비고": ""},
|
||||
truck_rows(truck),
|
||||
seven,
|
||||
base="차 1대당",
|
||||
extra={
|
||||
"비고": "줄마다 단위 칸 · 「〃」 종별 · 단위와 빈 종별 줄은 윗줄 · 괄호 값은 원문 칸(타일 8㎜ · 페인트 18ℓ — 페인트 둘째 줄 규격 「(18ℓ)/통」은 원문 괄호를 따름) · 범위 값은 [아래, 위]"
|
||||
},
|
||||
)
|
||||
return t
|
||||
|
||||
|
||||
# ── 로직 ────────────────────────────────────────────────────────────
|
||||
def inp(name, desc, unit=None, pick=None, src=None):
|
||||
d = {"이름": name, "설명": desc}
|
||||
if unit:
|
||||
d["단위"] = unit
|
||||
if pick is not None:
|
||||
d["고르기"] = pick
|
||||
if src:
|
||||
d["출처"] = src
|
||||
return d
|
||||
|
||||
|
||||
def weights() -> tuple[list[str], list[str]]:
|
||||
data = json.loads((MASTER / COEF).read_text(encoding="utf-8"))
|
||||
table = next(x for x in data["표"] if x["키"] == "CC000337")
|
||||
kinds = list(dict.fromkeys(r["종별"] for r in table["줄"]))
|
||||
shapes = ["해당 없음", *dict.fromkeys(r["형상"] for r in table["줄"] if "형상" in r)]
|
||||
return kinds, shapes
|
||||
|
||||
|
||||
def logics(key: dict) -> list[dict]:
|
||||
kinds, shapes = weights()
|
||||
angle = inp(
|
||||
"경사각도", "운반로의 경사 각도 — 0 이면 평지(환산계수 1)", "°", [0, *ANGLES], f"{SRC} 5 나"
|
||||
)
|
||||
weight = [
|
||||
inp(
|
||||
"운반무게",
|
||||
"운반할 자재 한 단위의 무게 — 0 이면 아래 재료의 단위중량 표 값(㎏/㎥)",
|
||||
"㎏",
|
||||
src="건설품셈 공통 1-2-4 3",
|
||||
),
|
||||
inp(
|
||||
"재료종별",
|
||||
"단위중량 표에서 고를 재료(운반무게 0 일 때)",
|
||||
pick=kinds,
|
||||
src="건설품셈 공통 1-2-4 3",
|
||||
),
|
||||
inp(
|
||||
"재료형상",
|
||||
"단위중량 표의 형상(운반무게 0 일 때)",
|
||||
pick=shapes,
|
||||
src="건설품셈 공통 1-2-4 3",
|
||||
),
|
||||
]
|
||||
w_step = {
|
||||
"이름": "무게",
|
||||
"식": f"만약(운반무게 > 0, 운반무게, 찾기({key['CC000337']}, 종별=재료종별, 형상=재료형상).위)",
|
||||
"단위": "㎏",
|
||||
}
|
||||
jige = {
|
||||
"키": None,
|
||||
"열쇠": "공통 1-2-7 인력운반(지게)",
|
||||
**HEAD,
|
||||
"이름": "지게운반",
|
||||
"결과단위": "원/자재 단위",
|
||||
"출처": f"{SRC} 2 · 3",
|
||||
"소유": "공용",
|
||||
"비고": "품에 포함된 소운반 = 20m 이내(1-2-7 1 가) — 넘거나 2차 운반이면 이 로직으로 별도 계상(1 다) · 해석: 경사지 환산계수 α(5 나 표)를 지게운반에도 씀(1 나 · 3 주⑤ 직고 1m = 수평 6m) · 운반회수를 넣으면 식 대신 그 값(실무 엑셀이 1일 운반횟수를 값으로 넣은 경우) · 운반무게 0 = 재료의 단위중량 표(1-2-4 3) 위끝 · 1회 운반량 0 = 25㎏ · 실작업시간 0 = 450분",
|
||||
"시험입력": {
|
||||
"운반무게": 575,
|
||||
"운반거리": 6,
|
||||
"경사각도": 35,
|
||||
"재료갈래": "석재류",
|
||||
"운반로": "불량",
|
||||
"회당운반량": 0,
|
||||
"실작업시간": 0,
|
||||
"운반회수": 42,
|
||||
},
|
||||
"입력": [
|
||||
*weight,
|
||||
inp(
|
||||
"회당운반량",
|
||||
"한 사람이 한 번에 지는 무게 — 0 이면 25㎏",
|
||||
"㎏",
|
||||
src=f"{SRC} 2 주 · 3 주③",
|
||||
),
|
||||
inp("운반거리", "수평 운반 거리(편도)", "m", src=f"{SRC} 2"),
|
||||
angle,
|
||||
inp(
|
||||
"재료갈래",
|
||||
"적재적하 시간 갈래(석재류 = 자갈 · 부순돌 · 조약돌 등)",
|
||||
pick=["토사류", "석재류"],
|
||||
src=f"{SRC} 3",
|
||||
),
|
||||
inp("운반로", "운반로 상태", pick=["양호", "보통", "불량"], src=f"{SRC} 3 주②"),
|
||||
inp("실작업시간", "1일 실작업시간 — 0 이면 450분", "분", src=f"{SRC} 2"),
|
||||
inp("운반회수", "1일 운반횟수를 직접 넣을 때 — 0 이면 식으로 셈", "회", src=f"{SRC} 2"),
|
||||
],
|
||||
"중간": [
|
||||
w_step,
|
||||
{
|
||||
"이름": "운반량",
|
||||
"식": f"만약(회당운반량 > 0, 회당운반량, 찾기({key['인력운반 기본공식']}).'1회 운반량')",
|
||||
"단위": "㎏",
|
||||
},
|
||||
{
|
||||
"이름": "환산계수",
|
||||
"식": f"만약(경사각도 > 0, 찾기({key['경사지 운반 환산계수']}, 각도=경사각도).환산계수, 1)",
|
||||
},
|
||||
{"이름": "환산거리", "식": "환산계수 * 운반거리", "단위": "m"},
|
||||
{
|
||||
"이름": "작업시간",
|
||||
"식": f"만약(실작업시간 > 0, 실작업시간, 찾기({key['인력운반 기본공식']}).실작업시간)",
|
||||
"단위": "분",
|
||||
},
|
||||
{
|
||||
"이름": "적재적하시간",
|
||||
"식": f"찾기({key['지게운반']}, 종류=재료갈래, 운반로=운반로).적재적하시간",
|
||||
"단위": "분",
|
||||
},
|
||||
{
|
||||
"이름": "평균왕복속도",
|
||||
"식": f"찾기({key['지게운반']}, 종류=재료갈래, 운반로=운반로).평균왕복속도",
|
||||
"단위": "m/hr",
|
||||
},
|
||||
{
|
||||
"이름": "일운반회수",
|
||||
"식": "만약(운반회수 > 0, 운반회수, 평균왕복속도 * 작업시간 / (120 * 환산거리 + 평균왕복속도 * 적재적하시간))",
|
||||
"단위": "회",
|
||||
},
|
||||
],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000002",
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": "무게 / 운반량 / 일운반회수",
|
||||
"비목": "노무비",
|
||||
"출처": f"{SRC} 2",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
machine = {
|
||||
"키": None,
|
||||
"열쇠": "공통 1-2-7 인력운반(기계설비)",
|
||||
**HEAD,
|
||||
"이름": "인력운반(기계설비)",
|
||||
"결과단위": "원/자재 단위",
|
||||
"출처": f"{SRC} 5",
|
||||
"소유": "공용",
|
||||
"비고": "장대물 · 중량물 등 — 운반비 = M/T × A(60 × 2 × L/V + t) · M = 운반무게 ÷ 1회 운반량 · 해석: T = 1일 실작업시간 450분(1-2-7 2) · 경사지는 환산거리 α × L(5 나)",
|
||||
"시험입력": {
|
||||
"운반무게": 100,
|
||||
"운반거리": 0.1,
|
||||
"도로상태": "보통",
|
||||
"경사각도": 0,
|
||||
"회당운반량": 0,
|
||||
"실작업시간": 0,
|
||||
},
|
||||
"입력": [
|
||||
*weight,
|
||||
inp("회당운반량", "인력운반공 1회 운반량 — 0 이면 25㎏", "㎏", src=f"{SRC} 5 가"),
|
||||
inp("운반거리", "운반 거리(편도)", "km", src=f"{SRC} 5 가"),
|
||||
inp(
|
||||
"도로상태",
|
||||
"운반로 도로상태",
|
||||
pick=["양호", "보통", "불량", "물논"],
|
||||
src=f"{SRC} 5 가",
|
||||
),
|
||||
angle,
|
||||
inp("실작업시간", "1일 실작업시간 — 0 이면 450분", "분", src=f"{SRC} 2"),
|
||||
],
|
||||
"중간": [
|
||||
w_step,
|
||||
{
|
||||
"이름": "운반량",
|
||||
"식": f"만약(회당운반량 > 0, 회당운반량, 찾기({key['인력운반(기계설비) 준비작업시간']}).'1회 운반량')",
|
||||
"단위": "㎏",
|
||||
},
|
||||
{"이름": "인원", "식": "무게 / 운반량", "단위": "인"},
|
||||
{
|
||||
"이름": "환산계수",
|
||||
"식": f"만약(경사각도 > 0, 찾기({key['경사지 운반 환산계수']}, 각도=경사각도).환산계수, 1)",
|
||||
},
|
||||
{"이름": "환산거리", "식": "환산계수 * 운반거리", "단위": "km"},
|
||||
{
|
||||
"이름": "왕복평균속도",
|
||||
"식": f"찾기({key['인력운반(기계설비) 왕복평균속도']}, 도로상태=도로상태).왕복평균속도",
|
||||
"단위": "km/hr",
|
||||
},
|
||||
{
|
||||
"이름": "준비작업시간",
|
||||
"식": f"찾기({key['인력운반(기계설비) 준비작업시간']}).준비작업시간",
|
||||
"단위": "분",
|
||||
},
|
||||
{
|
||||
"이름": "작업시간",
|
||||
"식": f"만약(실작업시간 > 0, 실작업시간, 찾기({key['인력운반 기본공식']}).실작업시간)",
|
||||
"단위": "분",
|
||||
},
|
||||
],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000045",
|
||||
"이름": "인력운반공",
|
||||
"단위": "인",
|
||||
"수량": "인원 / 작업시간 * (60 * 2 * 환산거리 / 왕복평균속도 + 준비작업시간)",
|
||||
"비목": "노무비",
|
||||
"출처": f"{SRC} 5 가",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
brick = {
|
||||
"키": None,
|
||||
"열쇠": "공통 1-2-7 벽돌운반",
|
||||
**HEAD,
|
||||
"이름": "벽돌운반",
|
||||
"결과단위": "원/1,000매",
|
||||
"출처": f"{SRC} 4",
|
||||
"소유": "공용",
|
||||
"비고": "기본벽돌(19×9×5.7㎝)을 인력으로 층별(층고 3.6m) 운반 · 리프트를 쓰면 층수와 관계없이 보통인부 0.31인",
|
||||
"입력": [
|
||||
inp("운반", "운반 방법", pick=["인력", "리프트"], src=f"{SRC} 4"),
|
||||
inp("층수", "올릴 층(리프트면 무관)", "층", [1, 2, 3, 4, 5], f"{SRC} 4"),
|
||||
],
|
||||
"중간": [],
|
||||
"호표": [
|
||||
{
|
||||
"종류": "인력",
|
||||
"요소": "LB000002",
|
||||
"이름": "보통인부",
|
||||
"단위": "인",
|
||||
"수량": f"찾기({key['벽돌운반']}, 운반=운반, 층수=층수).보통인부",
|
||||
"비목": "노무비",
|
||||
"출처": f"{SRC} 4",
|
||||
}
|
||||
],
|
||||
"덧줄": [],
|
||||
"끝수": None,
|
||||
}
|
||||
return [jige, machine, brick]
|
||||
|
||||
|
||||
USES = { # 표 → 그 표를 부르는 로직(열쇠)
|
||||
"소운반 거리": [],
|
||||
"인력운반 기본공식": ["인력운반(지게)", "인력운반(기계설비)"],
|
||||
"지게운반": ["인력운반(지게)"],
|
||||
"벽돌운반": ["벽돌운반"],
|
||||
"인력운반(기계설비) 왕복평균속도": ["인력운반(기계설비)"],
|
||||
"인력운반(기계설비) 준비작업시간": ["인력운반(기계설비)"],
|
||||
"경사지 운반 환산계수": ["인력운반(지게)", "인력운반(기계설비)"],
|
||||
"화물자동차 적재량": [],
|
||||
}
|
||||
LOGIC_LABELS = ("인력운반(지게)", "인력운반(기계설비)", "벽돌운반")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
coef_path, logic_path = MASTER / COEF, MASTER / LOGIC
|
||||
text = coef_path.read_text(encoding="utf-8")
|
||||
if '"원문번호": "1-2-7"' in text or logic_path.exists():
|
||||
raise SystemExit("이미 넣음 — 멈춤")
|
||||
book = mk.load_book()
|
||||
lkey = {x: mk.issue(book, "GC", f"공통 1-2-7 {x}", LOGIC) for x in LOGIC_LABELS}
|
||||
uses = {label: [lkey[x] for x in v] for label, v in USES.items()}
|
||||
lines = section()
|
||||
made = tables(lines, uses)
|
||||
ckey = {"CC000337": "CC000337"}
|
||||
for t in made:
|
||||
label = t["열쇠"].removeprefix("공통 1-2-7 ")
|
||||
ckey[label] = mk.issue(book, "CC", t["열쇠"], COEF)
|
||||
t["키"], t["원문번호"] = ckey[label], "1-2-7"
|
||||
t.update(HEAD)
|
||||
at = text.index(' {\n "키": "CC000001"')
|
||||
new_text = text[:at] + "".join(emit(t) + ",\n" for t in made) + text[at:]
|
||||
data = json.loads(new_text, parse_float=Decimal, parse_int=Decimal)
|
||||
assert sum(1 for x in data["표"] if x["원문번호"] == "1-2-7") == len(made)
|
||||
coef_path.write_text(new_text, encoding="utf-8", newline="\n")
|
||||
|
||||
rows = []
|
||||
for row in logics(ckey):
|
||||
label = row.pop("열쇠").removeprefix("공통 1-2-7 ")
|
||||
row["키"], row["원문번호"] = lkey[label], "1-2-7"
|
||||
order = ["키", "원문번호", *[k for k in row if k not in ("키", "원문번호")]]
|
||||
rows.append({k: row[k] for k in order})
|
||||
head = {
|
||||
"그룹": "로직",
|
||||
"원문": "건설품셈",
|
||||
"부문": "공통",
|
||||
"차례": 13,
|
||||
"판": "2026",
|
||||
"줄": rows,
|
||||
}
|
||||
logic_path.write_text(mk._store().dump(head), encoding="utf-8", newline="\n")
|
||||
mk.save_book(mk.finish(book))
|
||||
print("계수", [t["키"] for t in made], "로직", list(lkey.values()))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
if sys.argv[1:] == ["나머지"]: # 782-2 1장 나머지 — 규칙 · 계수만 절 표 · 1-5-4 · 1-5-6 로직
|
||||
import _적용기준_나머지_로직
|
||||
|
||||
_적용기준_나머지_로직.run()
|
||||
else:
|
||||
main()
|
||||
@@ -1,206 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""건설품셈 공통 8-1-4 · 8-2 시공능력 + 기계설비 13-2-7 — 계수 표 덧 · 로직 덧(782-3).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_건설품셈_08장_건설기계.py
|
||||
- 원문 = 공통 `제08장_건설기계/8-02-NN_*.md` 절마다(머리 ~ 다음 같은 · 윗 머리 앞 · 요구 630) · 13-2-7 = 기계설비 13장.
|
||||
- 계수 표(`_건설기계_표.py` · `_건설기계_표2.py`) = 절의 원문 md 표 전부 + 표 밖 글 속 상수 → `계수_건설품셈_08장_건설기계.json`
|
||||
에 덧(기존 표 글자 그대로 · 절 차례 자리에 끼움).
|
||||
- 로직(`_건설기계_로직*.py`) = 시간당 작업량 Q(원문 단위) · 주요 기계 작업량당 기계경비(시간당 경비 × 1/Q)
|
||||
→ `로직_건설품셈_08장_건설기계.json` 끝에 덧 · 13-2-7 → `로직_건설품셈_13장_플랜트설비공사.json` 끝에 덧.
|
||||
- 키 = `_키대장.json` 다음 번호(`master_keys.issue` — `adopt` 는 로직을 받지 않음) · 이미 넣었으면 멈춤(한 번 돌림).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
import _건설기계_로직 as L1 # noqa: E402
|
||||
import _건설기계_로직2 as L2 # noqa: E402
|
||||
import _건설기계_로직3 as L3 # noqa: E402
|
||||
import _건설기계_로직_경비 as LC # noqa: E402
|
||||
import _건설기계_읽기 as rd # noqa: E402
|
||||
import _건설기계_표 as T1 # noqa: E402
|
||||
import _건설기계_표2 as T2 # noqa: E402
|
||||
import _건설기계_표3 as T3 # noqa: E402
|
||||
import master_keys as mk # noqa: E402
|
||||
|
||||
COEF = "계수_건설품셈_08장_건설기계.json"
|
||||
LOGIC = "로직_건설품셈_08장_건설기계.json"
|
||||
LOGIC13 = "로직_건설품셈_13장_플랜트설비공사.json"
|
||||
_REF = re.compile(r"\{([TL]):([^{}]+)\}")
|
||||
|
||||
|
||||
def _sec(no: str) -> tuple[int, ...]:
|
||||
return tuple(int(x) for x in no.split("-"))
|
||||
|
||||
|
||||
def _load(name: str) -> dict:
|
||||
return json.loads(
|
||||
(MASTER / name).read_text(encoding="utf-8"), parse_float=Decimal, parse_int=Decimal
|
||||
)
|
||||
|
||||
|
||||
def _title(no: str) -> str:
|
||||
head = rd.section(no)[0].removeprefix(f"### {no} ")
|
||||
return re.sub(r"\(['‘]\d\d.*\)$", "", head).strip()
|
||||
|
||||
|
||||
def chooser(made: list[dict], old: dict):
|
||||
"""C(표, 칸) — 새 표는 「<절> <짧은 이름>」 · 있던 표는 키 · 값 차례대로 한 번씩(수는 Decimal)."""
|
||||
|
||||
def C(ref: str, col: str) -> list:
|
||||
table = old.get(ref) or next(t for t in made if t["열쇠"] == f"공통 {ref}")
|
||||
seen = []
|
||||
for row in table["줄"]:
|
||||
v = row.get(col)
|
||||
if v is None:
|
||||
continue
|
||||
v = Decimal(v) if isinstance(v, rd.N) else v
|
||||
if v not in seen:
|
||||
seen.append(v)
|
||||
return seen
|
||||
|
||||
return C
|
||||
|
||||
|
||||
def fill(v, keys: dict):
|
||||
"""식 글의 `{T:…}` · `{L:…}` → 키."""
|
||||
if isinstance(v, str):
|
||||
return _REF.sub(lambda m: keys[(m[1], m[2])], v)
|
||||
if isinstance(v, list):
|
||||
return [fill(x, keys) for x in v]
|
||||
if isinstance(v, dict):
|
||||
return {k: fill(x, keys) for k, x in v.items()}
|
||||
return v
|
||||
|
||||
|
||||
def order(row: dict) -> dict:
|
||||
head = [
|
||||
"키",
|
||||
"원문번호",
|
||||
"구분",
|
||||
"상세구분",
|
||||
"이름",
|
||||
"결과단위",
|
||||
"출처",
|
||||
"소유",
|
||||
"비고",
|
||||
"시험입력",
|
||||
"입력",
|
||||
"중간",
|
||||
"호표",
|
||||
"덧줄",
|
||||
"결과",
|
||||
"끝수",
|
||||
]
|
||||
return {k: row[k] for k in head if k in row}
|
||||
|
||||
|
||||
def rows_text(rows: list[dict]) -> str:
|
||||
"""줄 목록만 로직 파일 글 모양으로 — 통째 dump 의 「줄」 칸 안쪽."""
|
||||
whole = mk._store().dump({"줄": rows})
|
||||
a = whole.index('"줄": [\n') + len('"줄": [\n')
|
||||
return whole[a : whole.rindex("\n ]\n}")]
|
||||
|
||||
|
||||
def append_rows(name: str, rows: list[dict]) -> None:
|
||||
path = MASTER / name
|
||||
text = path.read_text(encoding="utf-8")
|
||||
at = text.rindex("\n ]\n}")
|
||||
new = text[:at] + ",\n" + rows_text(rows) + text[at:]
|
||||
old, got = json.loads(text), json.loads(new)
|
||||
assert got["줄"][: len(old["줄"])] == old["줄"] and {
|
||||
k: v for k, v in got.items() if k != "줄"
|
||||
} == {k: v for k, v in old.items() if k != "줄"}
|
||||
path.write_text(new, encoding="utf-8", newline="\n")
|
||||
|
||||
|
||||
def insert_tables(text: str, made: list[dict]) -> str:
|
||||
"""새 표 글을 절 차례 자리에 — 처음으로 절 번호가 더 큰 기존 표 앞(없으면 끝)."""
|
||||
starts = [
|
||||
(m.start(), m[1])
|
||||
for m in re.finditer(r' \{\n "키": "CC\d+", "원문번호": "([^"]+)"', text)
|
||||
]
|
||||
pieces, last = [], 0
|
||||
for at, no in starts:
|
||||
due = [t for t in made if not t.get("_done") and _sec(t["원문번호"]) < _sec(no)]
|
||||
if due and _sec(no) > (8, 1, 7):
|
||||
pieces.append(text[last:at])
|
||||
pieces.append("".join(rd.emit(t) + ",\n" for t in due))
|
||||
for t in due:
|
||||
t["_done"] = True
|
||||
last = at
|
||||
rest = [t for t in made if not t.get("_done")]
|
||||
tail = text.rindex("\n ]\n}")
|
||||
pieces.append(text[last:tail])
|
||||
if rest:
|
||||
pieces.append(",\n" + ",\n".join(rd.emit(t) for t in rest))
|
||||
pieces.append(text[tail:])
|
||||
for t in made:
|
||||
t.pop("_done", None)
|
||||
return "".join(pieces)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
coef_text = (MASTER / COEF).read_text(encoding="utf-8")
|
||||
if '"원문번호": "8-2-2"' in coef_text:
|
||||
raise SystemExit("이미 넣음 — 멈춤")
|
||||
book = mk.load_book()
|
||||
made = [t for mod in (T1, T2, T3) for f in mod.SECTIONS for t in f()]
|
||||
made.sort(key=lambda t: _sec(t["원문번호"])) # 같은 절은 만든 차례 그대로(안정 정렬)
|
||||
keys = {}
|
||||
for t in made:
|
||||
t["키"] = mk.issue(book, "CC", t["열쇠"], COEF)
|
||||
keys[("T", t["열쇠"].removeprefix("공통 "))] = t["키"]
|
||||
t.update(rd.HEAD)
|
||||
old_coef = {t["키"]: t for t in _load(COEF)["표"]}
|
||||
C = chooser(made, old_coef)
|
||||
|
||||
rows = L1.part1(C) + L2.part2(C) + L3.part3(C)
|
||||
# 작업량당 기계경비(LC.costs · LC.breaker) = 813-2 지움 — 단가산출에 기계 하나 넣어 만듦
|
||||
rows.sort(key=lambda r: _sec(r["원문번호"]))
|
||||
for r in rows:
|
||||
r["키"] = mk.issue(book, "GC", r["열쇠"], LOGIC)
|
||||
keys[("L", r["열쇠"])] = r["키"]
|
||||
rows = [order(fill({k: v for k, v in r.items() if k != "열쇠"}, keys)) for r in rows]
|
||||
ace = LC.acetylene()
|
||||
ace["키"] = mk.issue(book, "GC", ace.pop("열쇠"), LOGIC13)
|
||||
|
||||
for t in made: # 용도 — 그 표를 부르는 새 로직
|
||||
uses = [r["키"] for r in rows if t["키"] in json.dumps(r, ensure_ascii=False, default=str)]
|
||||
t["용도"] = {"공종": _title(t["원문번호"]), "대상": ["작업량 조건"], "로직키": uses}
|
||||
t.pop("열쇠")
|
||||
new_coef = insert_tables(coef_text, made)
|
||||
data = json.loads(new_coef, parse_float=Decimal, parse_int=Decimal)
|
||||
assert len(data["표"]) == len(old_coef) + len(made)
|
||||
assert [t for t in data["표"] if t["키"] in old_coef] == list(_load(COEF)["표"])
|
||||
(MASTER / COEF).write_text(new_coef, encoding="utf-8", newline="\n")
|
||||
append_rows(LOGIC, rows)
|
||||
append_rows(LOGIC13, [order(ace)])
|
||||
mk.save_book(mk.finish(book))
|
||||
print(
|
||||
"계수",
|
||||
made[0]["키"],
|
||||
"~",
|
||||
made[-1]["키"],
|
||||
len(made),
|
||||
"· 로직",
|
||||
rows[0]["키"],
|
||||
"~",
|
||||
rows[-1]["키"],
|
||||
len(rows),
|
||||
"· 13-2-7",
|
||||
ace["키"],
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
main()
|
||||
@@ -1,249 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""기계 한 대 = 줄 하나(PLAN 848-4 · 요구 887 · 888 · 요구서_889 7 장) — 옛 로직 JSON 고침(한 번 돌림).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_기계줄나눔_848_4.py
|
||||
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
|
||||
- 새 식 = 「굴착기(무한궤도) 부착 조합 시간당 기계경비」(GC000271 에서 부착 몫만 뺌 · 잡재료 비율 16 % ·
|
||||
건설 공통 8-4 [70] 주⑤) · 08장 GC000271 뒤 · 키 = `_키대장.json` 다음 GC · 부품 `조합: 부착`(기계 식 고름에서 뺌).
|
||||
- 조합 식 부름 호표(GC000270 집게 · GC000271 브레이커) = 줄 둘 — 주 기계(새 식) + 부착 기계 손료(GC000273 ·
|
||||
`부착: true`) · 두 줄 `묶음` = 옛 줄 이름(묶음 제목 그대로) · 수량 같음.
|
||||
- 중간 식이 조합 값 전체를 밑으로 쓰는 6 문서(치즐 소모재료) = 두 식 값의 합.
|
||||
- 덧줄 단가가 두 기계 손료를 더하는 GF000011 · GF000012(하베스터 + 굴착기) · GF000320(멀티콥터 + 배터리) = 줄 둘.
|
||||
GF000312 · GF000313 = 기종 고르기로 한 대만 셈(더하지 않음) — 안 나눔.
|
||||
- GC000270 · GC000271 = 남김(옛 사본이 부름 · 틀 문서 9 절).
|
||||
- 이미 돌렸으면(새 식 있음) 멈춤.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
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)
|
||||
import master_keys as mk # noqa: E402
|
||||
|
||||
LOGIC = "로직_건설품셈_08장_건설기계.json"
|
||||
NAME = "굴착기(무한궤도) 부착 조합 시간당 기계경비"
|
||||
LOSS = "GC000273" # 기계 시간당 손료(연료 · 조종원 없는 기종)
|
||||
CALL = re.compile(
|
||||
r"로직\((GC00027[01]), 기계=([^,()]+), (?:집게|브레이커)=([^,()]+), 지역=([^,()]+), 보정작업=([^,()]+)\)"
|
||||
)
|
||||
SPLIT = { # 덧줄 단가가 두 기계를 더함 — (로직, 덧줄 이름) → [(새 이름, 식)]
|
||||
("GF000011", "기계손료"): [
|
||||
("기계손료(하베스터 헤드)", "EQ000634.손료계수 * EQ000634.장비가격 * 1000 / 공정량"),
|
||||
("기계손료(굴착기)", "EQ000635.손료계수 * EQ000635.장비가격 * 1000 / 공정량"),
|
||||
],
|
||||
("GF000012", "기계손료"): [
|
||||
("기계손료(하베스터 헤드)", "EQ000634.손료계수 * EQ000634.장비가격 * 1000 / 공정량"),
|
||||
("기계손료(굴착기)", "EQ000635.손료계수 * EQ000635.장비가격 * 1000 / 공정량"),
|
||||
],
|
||||
("GF000320", "드론 손료"): [
|
||||
(
|
||||
"드론 손료",
|
||||
"만약(기종 == '무인헬기', EQ000645.손료계수 * EQ000645.취득가액, "
|
||||
"EQ000646.손료계수 * EQ000646.취득가액) / 일방제면적",
|
||||
),
|
||||
(
|
||||
"배터리 손료",
|
||||
"만약(기종 == '무인헬기', 0, EQ000647.손료계수 * EQ000647.취득가액) / 일방제면적",
|
||||
),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
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 new_row(base: dict, keep: dict, key: str) -> dict:
|
||||
"""GC000271 → 부착 몫 뺀 굴착기 식(기계 고르기 = GC000267 목록)."""
|
||||
row = json.loads(json.dumps(base, default=str), parse_float=Decimal)
|
||||
row |= {"키": key, "이름": NAME, "부품": {"갈래": "기계경비식", "조합": "부착"}}
|
||||
row["출처"] = "건설품셈 공통 8-1-5 · 8-1-6 · 8-1-7 · 8-4 주⑤"
|
||||
row["비고"] = (
|
||||
"굴착기에 브레이커 · 부착용 집게를 조합할 때 굴착기 몫 — 잡재료 비율 16 %(8-4 [70] 주⑤) · "
|
||||
"부착 기계 손료는 같은 묶음 다음 줄(GC000273) · 수량은 이 줄을 따름"
|
||||
)
|
||||
row["입력"] = [i for i in row["입력"] if i["이름"] != "브레이커"]
|
||||
next(i for i in row["입력"] if i["이름"] == "기계")["고르기"] = list(
|
||||
next(i for i in keep["입력"] if i["이름"] == "기계")["고르기"]
|
||||
)
|
||||
row["중간"] = [x for x in row["중간"] if x["이름"] != "브레이커손료"]
|
||||
row["덧줄"] = [x for x in row["덧줄"] if x["이름"] != "브레이커손료"]
|
||||
row["변수표"] = {
|
||||
k: v for k, v in row["변수표"].items() if k not in ("브레이커", "브레이커손료")
|
||||
}
|
||||
return row
|
||||
|
||||
|
||||
def _name(eq: dict, code: str, fallback: str) -> str:
|
||||
"""기계 줄 이름 — 박힌 원문번호 = 「이름 규격」 · 변수 = 기종 이름."""
|
||||
t = code.strip()
|
||||
if t.startswith("'") and (r := eq.get(t.strip("'"))):
|
||||
return f"{r.get('이름')} {r.get('규격') or ''}".strip()
|
||||
return fallback
|
||||
|
||||
|
||||
def split_item(item: dict, eq: dict, key: str) -> list[dict]:
|
||||
m = CALL.fullmatch(str(item["요소"]))
|
||||
assert m, item
|
||||
_, main, part, region, rock = m.groups()
|
||||
title = str(item["이름"])
|
||||
common = {k: item[k] for k in ("단위", "수량") if k in item}
|
||||
first = {
|
||||
"종류": "로직",
|
||||
"요소": f"로직({key}, 기계={main}, 지역={region}, 보정작업={rock})",
|
||||
"이름": _name(eq, main, "굴착기(무한궤도)"),
|
||||
**common,
|
||||
"묶음": title,
|
||||
**{k: item[k] for k in item if k not in ("종류", "요소", "이름", "단위", "수량")},
|
||||
}
|
||||
attach = "부착용 집게" if m.group(1) == "GC000270" else "대형 브레이커"
|
||||
second = {
|
||||
"종류": "로직",
|
||||
"요소": f"로직({LOSS}, 기계={part})",
|
||||
"이름": _name(eq, part, attach),
|
||||
**common,
|
||||
"묶음": title,
|
||||
"부착": True,
|
||||
"출처": "건설품셈 공통 8-4 주⑤",
|
||||
}
|
||||
return [first, second]
|
||||
|
||||
|
||||
def _sum_call(text: str, key: str) -> str:
|
||||
"""중간 식 속 조합 식 값 `.계` = 두 식 값의 합."""
|
||||
|
||||
def one(m):
|
||||
_, main, part, region, rock = m.groups()
|
||||
return (
|
||||
f"(로직({key}, 기계={main}, 지역={region}, 보정작업={rock}).계 + "
|
||||
f"로직({LOSS}, 기계={part}).계)"
|
||||
)
|
||||
|
||||
out = re.sub(CALL.pattern + r"\.계", one, text)
|
||||
assert "GC000270" not in out and "GC000271" not in out, text
|
||||
return out
|
||||
|
||||
|
||||
BUCKET = { # 굴착기 작업량 식(8-2-3) 버킷계수 직접 칸 — E입력 · 싸이클입력 과 같은 꼴(0 = 표)
|
||||
"이름": "K입력",
|
||||
"설명": "버킷계수(K)를 직접 넣을 때 — 0 이면 표(버킷조건)",
|
||||
"범위": [0, 2],
|
||||
"출처": "건설품셈 공통 8-2-3 1",
|
||||
}
|
||||
|
||||
|
||||
def bucket() -> None:
|
||||
"""GC001147 에 `K입력` — 이미 있으면 그대로."""
|
||||
text, before = _load(LOGIC)
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
row = next(r for r in after["줄"] if r["키"] == "GC001147")
|
||||
if any(i["이름"] == BUCKET["이름"] for i in row["입력"]):
|
||||
return
|
||||
at = next(n for n, i in enumerate(row["입력"]) if i["이름"] == "싸이클입력") + 1
|
||||
row["입력"].insert(at, {**BUCKET, "범위": [Decimal(0), Decimal(2)]})
|
||||
step = next(x for x in row["중간"] if x["이름"] == "K")
|
||||
assert step["식"] == "찾기(CC000042, 현장조건=버킷조건).K", step
|
||||
step["식"] = "만약(K입력 > 0, K입력, 찾기(CC000042, 현장조건=버킷조건).K)"
|
||||
row["변수표"]["K입력"] = {"기호": "K", "아래": "입력"}
|
||||
row["시험입력"]["K입력"] = Decimal(0)
|
||||
row["비고"] = str(row["비고"]) + " · K입력 0 = 표(버킷조건)"
|
||||
_save(LOGIC, text, before, after)
|
||||
print("GC001147 K입력")
|
||||
|
||||
|
||||
_BUCKET_CALL = re.compile(r"로직\(GC001147,((?:[^()']|'[^']*')*)\)")
|
||||
|
||||
|
||||
def bucket_calls() -> None:
|
||||
"""GC001147 를 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음)에 `K입력=0` — 이미 있으면 그대로."""
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
text, before = _load(path.name)
|
||||
if "로직(GC001147," not in text:
|
||||
continue
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
hit = False
|
||||
for row in after["줄"]:
|
||||
for part in ("중간", "호표", "덧줄"):
|
||||
for x in row.get(part) or []:
|
||||
for k in ("식", "요소", "수량"):
|
||||
v = x.get(k)
|
||||
if isinstance(v, str) and "로직(GC001147," in v and "K입력=" not in v:
|
||||
x[k] = _BUCKET_CALL.sub(lambda m: f"로직(GC001147,{m[1]}, K입력=0)", v)
|
||||
hit = True
|
||||
if hit:
|
||||
_save(path.name, text, before, after)
|
||||
print("K입력=0 부름", path.name)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
bucket()
|
||||
bucket_calls()
|
||||
_, head = _load(LOGIC)
|
||||
if any(r.get("이름") == NAME for r in head["줄"]):
|
||||
raise SystemExit("나눔은 이미 넣음 — 멈춤")
|
||||
book = mk.load_book()
|
||||
key = mk.issue(book, "GC", "공통 8 굴착기 부착 조합 시간당 경비", LOGIC)
|
||||
eq = store.loaded()[1].numbers.get("EQ") or {}
|
||||
lines = splits = sums = 0
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
text, before = _load(path.name)
|
||||
after = json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
hit = False
|
||||
for row in after.get("줄") or []:
|
||||
if row["키"] in ("GC000270", "GC000271"):
|
||||
continue
|
||||
items = []
|
||||
for item in row.get("호표") or []:
|
||||
if item.get("종류") == "로직" and CALL.fullmatch(str(item.get("요소"))):
|
||||
items += split_item(item, eq, key)
|
||||
lines += 1
|
||||
else:
|
||||
items.append(item)
|
||||
if len(items) != len(row.get("호표") or []):
|
||||
row["호표"], hit = items, True
|
||||
for step in row.get("중간") or []:
|
||||
if "GC000270" in step["식"] or "GC000271" in step["식"]:
|
||||
step["식"], hit = _sum_call(step["식"], key), True
|
||||
sums += 1
|
||||
adds = []
|
||||
for add in row.get("덧줄") or []:
|
||||
got = SPLIT.get((row["키"], add.get("이름")))
|
||||
adds += [{**add, "이름": n, "식": f} for n, f in got] if got else [add]
|
||||
splits += bool(got)
|
||||
if len(adds) != len(row.get("덧줄") or []):
|
||||
row["덧줄"], hit = adds, True
|
||||
if path.name == LOGIC:
|
||||
rows = after["줄"]
|
||||
by = {r["키"]: r for r in rows}
|
||||
at = rows.index(by["GC000271"]) + 1
|
||||
rows.insert(at, new_row(by["GC000271"], by["GC000267"], key))
|
||||
hit = True
|
||||
if hit:
|
||||
_save(path.name, text, before, after)
|
||||
mk.save_book(mk.finish(book))
|
||||
print(f"새 식 {key} · 조합 줄 {lines} → 줄 둘 · 중간 합 {sums} · 덧줄 나눔 {splits}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,86 +0,0 @@
|
||||
"""잔토처리(인력) 단독 로직 한 줄(PLAN 794-2b · 분석 652-794-2a 2 장 6 번 · 요구 653).
|
||||
|
||||
근거 = 건설 공통 3-2-1 비고 「현장 내에서 소운반하여 깔고 고르는 잔토처리는 ㎥당 보통인부
|
||||
0.2인을 별도 계상」 · 호표 보통인부 = QC000172 「잔토처리 보통인부」(GC000083 옵션과 같은 표).
|
||||
이미 있으면 그대로 · 글 꼴 그대로 GC000083 줄 뒤에 끼움 · 키 = `_키대장` 다음 GC 번호.
|
||||
뒤에 `build_로직_개정.py` 를 돌림.
|
||||
|
||||
./venv/Scripts/python.exe resources/master_data/scripts/build_로직_잔토처리.py
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
MASTER = Path(__file__).resolve().parents[1]
|
||||
FILE = MASTER / "로직_건설품셈_03장_토공사.json"
|
||||
BOOK = MASTER / "_키대장.json"
|
||||
NAME = "잔토처리(인력)"
|
||||
LEDGER = f"공통 3-2-1 {NAME}"
|
||||
AFTER = "GC000083"
|
||||
SRC = "건설품셈 공통 3-2-1 비고"
|
||||
|
||||
|
||||
def _row(key: str, nl: str) -> str:
|
||||
q = "찾기(QC000172, 구분='잔토처리 보통인부').값"
|
||||
lines = [
|
||||
"{",
|
||||
f' "키": "{key}", "원문번호": "3-2-1", "구분": "건설품셈 공통", '
|
||||
'"상세구분": "03장 토공사",',
|
||||
f' "이름": "{NAME}",',
|
||||
' "결과단위": "원/㎥",',
|
||||
f' "출처": "{SRC}",',
|
||||
' "소유": "공용",',
|
||||
' "비고": "현장 내 소운반하여 깔고 고르는 잔토처리 — ㎥당 보통인부 0.2인 별도 계상",', # noqa: E501
|
||||
' "입력": [],',
|
||||
' "중간": [],',
|
||||
' "호표": [',
|
||||
" {",
|
||||
' "종류": "인력",',
|
||||
' "요소": "LB000002",',
|
||||
' "이름": "보통인부",',
|
||||
' "단위": "인",',
|
||||
f' "수량": "{q}",',
|
||||
' "비목": "노무비",',
|
||||
f' "출처": "{SRC}"',
|
||||
" }",
|
||||
" ],",
|
||||
' "덧줄": [],',
|
||||
' "끝수": null',
|
||||
"}",
|
||||
]
|
||||
return (nl + " ").join(lines)
|
||||
|
||||
|
||||
def build() -> str:
|
||||
text = FILE.read_bytes().decode("utf-8")
|
||||
book = BOOK.read_bytes().decode("utf-8")
|
||||
have = re.search(rf'"(GC\d{{6}})": \{{"원문번호": "{re.escape(LEDGER)}"', book)
|
||||
if have and f'"키": "{have.group(1)}"' in text:
|
||||
return have.group(1)
|
||||
nl = "\r\n" if "\r\n" in text else "\n"
|
||||
bnl = "\r\n" if "\r\n" in book else "\n"
|
||||
n = int(re.search(r'"GC": (\d+)', book).group(1))
|
||||
key = f"GC{n:06d}"
|
||||
entry = json.dumps({"원문번호": LEDGER, "파일": FILE.name}, ensure_ascii=False)
|
||||
prev = re.search(rf' "GC{n - 1:06d}": .*?,{bnl}', book)
|
||||
book = book.replace(f'"GC": {n}', f'"GC": {n + 1}', 1)
|
||||
at = book.index(prev.group(0)) + len(prev.group(0))
|
||||
book = book[:at] + f' "{key}": {entry},{bnl}' + book[at:]
|
||||
# 줄 끼움 — AFTER 줄 글 끝 뒤
|
||||
start = text.index(f'"키": "{AFTER}"')
|
||||
start = text.rindex("{", 0, start)
|
||||
_, end = json.JSONDecoder().raw_decode(text, start)
|
||||
out = text[:end] + "," + nl + " " + _row(key, nl) + text[end:]
|
||||
data = json.loads(out)
|
||||
assert [r["키"] for r in data["줄"]].count(key) == 1
|
||||
json.loads(book)
|
||||
FILE.write_bytes(out.encode("utf-8"))
|
||||
BOOK.write_bytes(book.encode("utf-8"))
|
||||
return key
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(build())
|
||||
@@ -1,86 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""로직 호표의 재료 줄을 「고르기 조건」 으로 바꿈 — 요소 「MP……」·「MT……」 를 조건 묶음으로.
|
||||
|
||||
· 바탕 넷 —
|
||||
① 재료_품셈재료.json 의 「고르기」 칸 (`scripts/build_품셈재료_고르기.py` 가 채움)
|
||||
② 자재품목 줄을 바로 가리키는 「MT……」 — 그 줄의 구분·상세구분·규격 + 대표 = 그 줄
|
||||
③ 연결이 자재품목 키 하나인 품셈재료 「MP……」 — 그 자재품목 줄로 ② 와 같게
|
||||
④ 연결이 지역·계약종별 조건 묶음(모래 · 자갈 · 전력)인 품셈재료 — 그 묶음을 호표에
|
||||
그대로 박음(PLAN 7-4b 뒤 절반 · `master_material._region`·`_tariff` 가 품셈재료
|
||||
간접 없이 바로 풂)
|
||||
②③ 은 대표 줄이 옛 요소와 같은 줄이라 금액이 그대로임(고르기 화면만 열림)
|
||||
· 줄 텍스트의 「"요소": "MP……"」 한 줄만 바꿈 — 나머지 글자·차례 그대로
|
||||
· 다시 돌려도 같은 결과(이미 바뀐 줄은 건드릴 것이 없음)
|
||||
|
||||
사용: python scripts/build_로직_재료_고르기.py (로직 파일 갱신)
|
||||
python scripts/build_로직_재료_고르기.py --보기 (바꿀 줄 수만 셈)
|
||||
"""
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
MASTER = Path(__file__).resolve().parents[1]
|
||||
SRC = MASTER / "재료_품셈재료.json"
|
||||
MARKET = MASTER / "재료_자재품목.json"
|
||||
LINE = re.compile(r'^(\s*"요소": )"((?:MP|MT)\d{6})"(,?)\s*$')
|
||||
|
||||
|
||||
def _cond_of(row: dict) -> dict | None:
|
||||
"""자재품목 줄 → 고르기 조건 · 대표는 그 줄(금액이 안 바뀌게)."""
|
||||
if not row.get("구분"):
|
||||
return None
|
||||
cond = {"구분": row["구분"]}
|
||||
for slot in ("상세구분", "규격"):
|
||||
if row.get(slot):
|
||||
cond[slot] = row[slot]
|
||||
cond["대표"] = str(row["키"])
|
||||
return cond
|
||||
|
||||
|
||||
def _picks() -> dict[str, dict]:
|
||||
"""요소 키 → 고르기 조건 — 품셈재료 고르기 칸 · 자재품목 줄 · 연결이 키 하나인 품셈재료 ·
|
||||
연결이 지역·계약종별 조건 묶음인 품셈재료(그 묶음을 그대로 호표에 박음 — PLAN 7-4b 뒤 절반)."""
|
||||
market = {str(r["키"]): r for r in json.loads(MARKET.read_text(encoding="utf-8"))["줄"]}
|
||||
picks = {key: cond for key, row in market.items() if (cond := _cond_of(row))}
|
||||
for row in json.loads(SRC.read_text(encoding="utf-8"))["줄"]:
|
||||
link = row.get("연결")
|
||||
if isinstance(link, str):
|
||||
cond = row.get("고르기") or picks.get(link)
|
||||
elif isinstance(link, dict) and (link.get("지역") == "입력" or link.get("계약종별") == "입력"):
|
||||
cond = link
|
||||
else:
|
||||
cond = row.get("고르기")
|
||||
if cond:
|
||||
picks[str(row["키"])] = cond
|
||||
return picks
|
||||
|
||||
|
||||
def main(show: bool) -> int:
|
||||
picks = _picks()
|
||||
done, kept, files = 0, 0, 0
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
text = path.read_text(encoding="utf-8")
|
||||
out, hit = [], 0
|
||||
for line in text.split("\n"):
|
||||
m = LINE.match(line)
|
||||
cond = picks.get(m.group(2)) if m else None
|
||||
if cond:
|
||||
out.append(m.group(1) + json.dumps(cond, ensure_ascii=False) + m.group(3))
|
||||
hit += 1
|
||||
else:
|
||||
kept += bool(m)
|
||||
out.append(line)
|
||||
done += hit
|
||||
if hit:
|
||||
files += 1
|
||||
if not show:
|
||||
path.write_text("\n".join(out), encoding="utf-8", newline="\n")
|
||||
print(f"고르기 조건으로 바꾼 재료 줄 {done} · 옛 방식 그대로 {kept} · 파일 {files}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
sys.exit(main("--보기" in sys.argv))
|
||||
@@ -24,7 +24,7 @@ from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
import master_keys as mk # noqa: E402
|
||||
from _migrate_base import dump_master # noqa: E402
|
||||
from master_keys import dump_master # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
MD = ROOT / "resources/master_data"
|
||||
|
||||
@@ -21,7 +21,7 @@ from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
import master_keys as mk # noqa: E402
|
||||
from _migrate_base import dump_master # noqa: E402
|
||||
from master_keys import dump_master # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
MASTER = Path(__file__).resolve().parents[1]
|
||||
|
||||
@@ -27,7 +27,7 @@ sys.path.insert(0, str(Path(__file__).parent))
|
||||
import master_keys as mk # noqa: E402
|
||||
import material_merge as mm # noqa: E402
|
||||
import master_region as mr # noqa: E402
|
||||
from _migrate_base import dump_master # noqa: E402
|
||||
from master_keys import dump_master # noqa: E402
|
||||
from compare_estx import ESTX, ROOT, SLOTS, Estx # noqa: E402
|
||||
|
||||
OUT = ROOT / "resources/master_data/재료_자재품목.json"
|
||||
|
||||
@@ -1,199 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""재료_품셈재료.json 의 「고르기」 칸 채움 — 품셈 원문 이름 → 자재품목 구분 · 상세구분[· 규격].
|
||||
|
||||
· 바탕 = `build_자재품목_분류.분류` (sub2 가 자재품목을 가른 바로 그 글자 규칙) · 묶음 목록 ref/_묶음_자재품목.md
|
||||
· 손으로 바로잡은 줄은 OVERRIDE — 값이 None 이면 비움(까닭을 비고에 적음)
|
||||
· 규격은 원문 규격 낱말이 모두 든 후보가 있을 때만 붙임(없으면 구분 · 상세구분까지만)
|
||||
· 후보 0 이거나 못 가린 줄은 「고르기」 null + 비고에 까닭
|
||||
· 값 · 이름 · 키 · 연결은 건드리지 않음 · 다시 돌리면 같은 결과
|
||||
|
||||
사용: python scripts/build_품셈재료_고르기.py (JSON 갱신)
|
||||
python scripts/build_품셈재료_고르기.py --보기 (고칠 내용만 나열)
|
||||
"""
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
import unicodedata
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
|
||||
import master_material as mm # noqa: E402
|
||||
from build_자재품목_분류 import 분류 # noqa: E402
|
||||
|
||||
SRC = MASTER / "재료_품셈재료.json"
|
||||
MT = MASTER / "재료_자재품목.json"
|
||||
|
||||
# 글자 규칙이 엉뚱한 묶음을 집은 줄 — 손으로 바로잡음(None = 비움)
|
||||
OVERRIDE = {
|
||||
"MP000012": None, # 사다리(ton) — 어느 묶음인지 원문만으로 못 가림
|
||||
"MP000015": ("단열·보온", "단열재"), # 문양 스티로폴 — 「문」 글자에 걸림
|
||||
"MP000024": ("관·이음관", "이음쇠·부속"), # 고무링(VR관)
|
||||
"MP000029": ("관·이음관", "이음쇠·부속"),
|
||||
"MP000034": ("관·이음관", "이음쇠·부속"),
|
||||
"MP000052": None, # 스페이셔(몰탈 블록)
|
||||
"MP000094": None, # 쉬즈관 — 강관 값으로 재면 어긋남
|
||||
"MP000101": None, # 내부PANEL(목재문) — 가설건축물 부재
|
||||
"MP000110": ("거푸집·가설재", "가설건축물"),
|
||||
"MP000111": ("거푸집·가설재", "가설건축물"),
|
||||
"MP000112": ("거푸집·가설재", "가설건축물"),
|
||||
"MP000134": None, # 모래주머니
|
||||
"MP000139": None, # HDPE 시트 — PE「관」 아님
|
||||
"MP000145": ("잡재료", "용접·가스"), # CO₂ 와이어
|
||||
"MP000147": ("잡재료", "용접·가스"), # 잠호용접와이어
|
||||
"MP000164": ("건축마감", "천장·바닥·마감재"), # 테라조 걸레받이
|
||||
"MP000165": ("건축마감", "천장·바닥·마감재"), # 합성수지 걸레받이
|
||||
"MP000195": ("잡재료", "용접·가스"), # 플럭스(브레이징용)
|
||||
"MP000200": ("철근·강재", "철근"), # 철물(D22 철근)
|
||||
"MP000209": None, # 버너(압접가열용)
|
||||
"MP000214": None, # 퓨즈(테르밋 용접용)
|
||||
"MP000250": None, # Lagging Sheet
|
||||
"MP000317": ("잡재료", "소모품"), # 톱날
|
||||
"MP000357": ("잡재료", "화약"), # 카트리지(화약)
|
||||
"MP000362": ("잡재료", "소모품"), # 폴리에틸렌필름
|
||||
# 이름이 같은 자재품목 줄이 하나뿐인 재료 — 그 줄을 대표로
|
||||
"MP000105": ("건축마감", "천장·바닥·마감재", "MT007262"), # ROOFSHEET
|
||||
"MP000168": ("건축마감", "천장·바닥·마감재", "MT008074"), # 초배지
|
||||
# 검증(ref/_검증_품셈재료_고르기.md) — 이름만 비슷한 다른 물건 · 규격 다른 대표 · 묶음 안 맞음: 비움
|
||||
**{
|
||||
k: None
|
||||
for k in (
|
||||
"MP000013 MP000268 MP000284 MP000291 MP000322 MP000354 MP000080 MP000244 MP000071 "
|
||||
"MP000122 MP000138 MP000059 MP000289 MP000292 MP000307 MP000312 MP000318 MP000339"
|
||||
).split()
|
||||
},
|
||||
}
|
||||
NO_GROUP = "자재품목 묶음에 짝이 없음 — 관리자가 화면에서 이음"
|
||||
NO_ROW = "자재품목에 그 묶음 줄이 없음"
|
||||
NO_UNIT = "자재품목 그 묶음에 같은 단위·이름 줄이 없음"
|
||||
UNIT = {
|
||||
"㎏": "kg",
|
||||
"톤": "ton",
|
||||
"Ton": "ton",
|
||||
"M": "m",
|
||||
"m²": "㎡",
|
||||
"L": "ℓ",
|
||||
"EA": "개",
|
||||
"set": "SET",
|
||||
"Set": "SET",
|
||||
}
|
||||
PRICE = ("물가자료", "유통물가", "물가정보", "거래가격", "일반가격")
|
||||
NOTE = re.compile(r"\s*·?\s*고르기 없음\([^)]*\)")
|
||||
FIELD = re.compile(r'("연결": (?:null|"[^"]*"|\{[^{}]*\}))(, "고르기": (?:null|\{[^{}]*\}))?')
|
||||
NOTE_FIELD = re.compile(r'(, "비고": )(null|"(?:[^"\\]|\\.)*")')
|
||||
|
||||
|
||||
def _spec(s) -> str:
|
||||
"""규격 표기 맞춤 — 지름 기호(∅ø⌀→Φ) 뒤 빈칸 없앰 · ㎜→mm."""
|
||||
return re.sub(r"[∅ø⌀]\s*", "Φ", unicodedata.normalize("NFKC", str(s or "")).replace("∅", "Φ"))
|
||||
|
||||
|
||||
def _has(word: str, spec) -> bool:
|
||||
"""낱말이 규격 글자에 숫자 경계로 듦 — 「50mm」 가 「150mm」 에 걸리지 않게."""
|
||||
w = re.escape(mm.plain_spec(_spec(word)))
|
||||
return re.search(rf"(?<![\d.]){w}(?!\d)", mm.plain_spec(_spec(spec))) is not None
|
||||
|
||||
|
||||
def 고르기(row: dict, market: list[dict]) -> tuple[dict | None, str]:
|
||||
"""한 줄의 고르기 조건 — (조건 또는 None, 까닭)."""
|
||||
key = str(row.get("키"))
|
||||
if row.get("연결") is not None:
|
||||
return None, "" # 관리자가 이미 이은 줄 — 옛 방식 그대로
|
||||
if key in OVERRIDE:
|
||||
got = OVERRIDE[key]
|
||||
if got is None:
|
||||
return None, NO_GROUP
|
||||
sub, detail, *rep = got
|
||||
else:
|
||||
sub, detail = 분류(row.get("이름"), "")
|
||||
rep = []
|
||||
if sub == "미분류":
|
||||
return None, NO_GROUP
|
||||
hits = [r for r in market if r.get("구분") == sub and r.get("상세구분") == detail]
|
||||
if not hits:
|
||||
return None, NO_ROW
|
||||
대표 = {"대표": rep[0]} if rep else {}
|
||||
spec = _spec(row.get("규격")).replace(",", " ").strip()
|
||||
want = spec.split()
|
||||
cond = {"구분": sub, "상세구분": detail, **대표}
|
||||
narrow = [r for r in hits if all(_has(w, r.get("규격")) for w in want)] if want else []
|
||||
if narrow:
|
||||
cond = {"구분": sub, "상세구분": detail, "규격": spec, **대표}
|
||||
got = _단위(row, cond, narrow, market)
|
||||
if got[0]:
|
||||
return got
|
||||
cond = {
|
||||
k: v for k, v in cond.items() if k != "규격"
|
||||
} # 규격까지 좁히면 단위 맞는 줄이 없음 — 규격 없이 다시
|
||||
return _단위(row, cond, hits, market)
|
||||
|
||||
|
||||
def _단위(row: dict, cond: dict, hits: list[dict], market: list[dict]) -> tuple[dict | None, str]:
|
||||
"""후보 첫 줄의 단위가 원문 단위와 다르면 — 단위·이름이 같은 줄을 대표로, 없으면 비움."""
|
||||
u = lambda x: UNIT.get(x, x) # noqa: E731
|
||||
want = u(str(row.get("단위") or ""))
|
||||
val = lambda r: [r[k] for k in PRICE if r.get(k) is not None] # noqa: E731
|
||||
if not want:
|
||||
return cond, ""
|
||||
if cond.get("대표"):
|
||||
rep = next(r for r in market if r["키"] == cond["대표"])
|
||||
return (cond, "") if u(rep["단위"]) == want else (None, NO_UNIT)
|
||||
first = next((r for r in hits if val(r)), hits[0])
|
||||
if u(first["단위"]) == want:
|
||||
return cond, ""
|
||||
root = re.sub(r"\s+", "", re.split(r"[(,\-]", str(row["이름"]))[0])
|
||||
same = [
|
||||
r for r in hits if u(r["단위"]) == want and val(r) and root in re.sub(r"\s+", "", r["이름"])
|
||||
]
|
||||
if not same:
|
||||
return None, NO_UNIT
|
||||
best = min(same, key=lambda r: (min(val(r)), r["키"]))
|
||||
return {**cond, "대표": best["키"]}, ""
|
||||
|
||||
|
||||
def main(show: bool) -> int:
|
||||
market = json.loads(MT.read_text(encoding="utf-8"))["줄"]
|
||||
rows = {str(r["키"]): r for r in json.loads(SRC.read_text(encoding="utf-8"))["줄"]}
|
||||
out, n_pick, n_spec, n_blank = [], 0, 0, 0
|
||||
for line in SRC.read_text(encoding="utf-8").split("\n"):
|
||||
m = FIELD.search(line)
|
||||
if not m or '"키": "MP' not in line:
|
||||
out.append(line)
|
||||
continue
|
||||
row = rows[json.loads(line.split('"키": ', 1)[1].split(",", 1)[0])]
|
||||
cond, why = 고르기(row, market)
|
||||
n_pick += cond is not None
|
||||
n_spec += bool(cond and "규격" in cond)
|
||||
n_blank += cond is None
|
||||
text = json.dumps(cond, ensure_ascii=False) if cond else "null"
|
||||
line = FIELD.sub(lambda mm_: mm_.group(1) + f', "고르기": {text}', line, count=1)
|
||||
line = _note(line, why)
|
||||
if show and (cond or why):
|
||||
print(f"{row['키']} {row['이름']} | {row.get('규격', '')} | {text} {why}")
|
||||
out.append(line)
|
||||
print(f"고르기 {n_pick} 줄 (규격 조건 {n_spec}) · 빈 채 {n_blank} 줄")
|
||||
if not show:
|
||||
SRC.write_text("\n".join(out), encoding="utf-8", newline="\n")
|
||||
return 0
|
||||
|
||||
|
||||
def _note(line: str, why: str) -> str:
|
||||
"""비고 — 옛 「고르기 없음(…)」 을 지우고 까닭이 있으면 새로 붙임(비고 칸이 없으면 만듦)."""
|
||||
m = NOTE_FIELD.search(line)
|
||||
old = NOTE.sub("", (json.loads(m.group(2)) if m else None) or "").strip(" ·")
|
||||
text = " · ".join(x for x in (old, f"고르기 없음({why})" if why else "") if x)
|
||||
new = json.dumps(text, ensure_ascii=False) if text else "null"
|
||||
if m:
|
||||
return line[: m.start(2)] + new + line[m.end(2) :]
|
||||
if not text:
|
||||
return line
|
||||
cut = line.rindex(" }")
|
||||
return line[:cut] + f', "비고": {new}' + line[cut:]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
sys.exit(main("--보기" in sys.argv))
|
||||
@@ -15,7 +15,7 @@ from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
import master_keys as mk # noqa: E402
|
||||
from _migrate_base import dump_master # noqa: E402
|
||||
from master_keys import dump_master # noqa: E402
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
OUT = Path(__file__).resolve().parents[1] / "환율_한국은행환율.json"
|
||||
|
||||
@@ -298,6 +298,24 @@ def dump_rows(head: dict, rows: list[dict]) -> str:
|
||||
return "\n".join(out + [" ]", "}"]) + "\n"
|
||||
|
||||
|
||||
def dump_master(path: Path, head: dict, rows: list[dict]) -> None:
|
||||
"""갱신 빌더 출력 — 머리는 들여쓰기 2칸 · 줄은 한 줄씩(길면 펼침) · UTF-8 · LF."""
|
||||
out = ["{"]
|
||||
for key, val in head.items():
|
||||
text = json.dumps(val, ensure_ascii=False, indent=2).replace("\n", "\n ")
|
||||
out.append(f" {json.dumps(key, ensure_ascii=False)}: {text},")
|
||||
out.append(' "줄": [')
|
||||
for i, row in enumerate(rows):
|
||||
line = json.dumps(row, ensure_ascii=False, separators=(", ", ": "))
|
||||
if len(line) <= 450:
|
||||
body = "{ " + line[1:-1] + " }"
|
||||
else:
|
||||
body = json.dumps(row, ensure_ascii=False, indent=2).replace("\n", "\n ")
|
||||
out.append(" " + body + ("," if i < len(rows) - 1 else ""))
|
||||
out += [" ]", "}"]
|
||||
path.write_bytes(("\n".join(out) + "\n").encode("utf-8"))
|
||||
|
||||
|
||||
def keep_text(text: str, old: dict, new: dict) -> str | None:
|
||||
"""글 모양 그대로 — 「열쇠」 칸(키·원문번호·갈래) · 바뀐 글 · 머리 부문·차례만 갈음 · 다르면 None."""
|
||||
rows_old, rows_new = old[_items(old)], new[_items(new)]
|
||||
|
||||
Reference in New Issue
Block a user