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:
2026-11-17 12:43:03 +09:00
co-authored by Claude Opus 5.5
parent 4060d0ea72
commit 38b172cbcb
32 changed files with 28 additions and 8156 deletions
@@ -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)]