diff --git a/resources/master_data/scripts/_migrate_base.py b/resources/master_data/scripts/_migrate_base.py deleted file mode 100644 index 4f31165ea..000000000 --- a/resources/master_data/scripts/_migrate_base.py +++ /dev/null @@ -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) diff --git a/resources/master_data/scripts/_migrate_keys.py b/resources/master_data/scripts/_migrate_keys.py deleted file mode 100644 index 8837de3f7..000000000 --- a/resources/master_data/scripts/_migrate_keys.py +++ /dev/null @@ -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() diff --git a/resources/master_data/scripts/_건설기계_로직.py b/resources/master_data/scripts/_건설기계_로직.py deleted file mode 100644 index 869b6d25b..000000000 --- a/resources/master_data/scripts/_건설기계_로직.py +++ /dev/null @@ -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, -} diff --git a/resources/master_data/scripts/_건설기계_로직2.py b/resources/master_data/scripts/_건설기계_로직2.py deleted file mode 100644 index f2852c035..000000000 --- a/resources/master_data/scripts/_건설기계_로직2.py +++ /dev/null @@ -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, -} diff --git a/resources/master_data/scripts/_건설기계_로직3.py b/resources/master_data/scripts/_건설기계_로직3.py deleted file mode 100644 index e4f8fda13..000000000 --- a/resources/master_data/scripts/_건설기계_로직3.py +++ /dev/null @@ -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 diff --git a/resources/master_data/scripts/_건설기계_로직_경비.py b/resources/master_data/scripts/_건설기계_로직_경비.py deleted file mode 100644 index d021d30f5..000000000 --- a/resources/master_data/scripts/_건설기계_로직_경비.py +++ /dev/null @@ -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, - } diff --git a/resources/master_data/scripts/_건설기계_로직_준설.py b/resources/master_data/scripts/_건설기계_로직_준설.py deleted file mode 100644 index 9299c83a1..000000000 --- a/resources/master_data/scripts/_건설기계_로직_준설.py +++ /dev/null @@ -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 diff --git a/resources/master_data/scripts/_건설기계_로직_플랜트.py b/resources/master_data/scripts/_건설기계_로직_플랜트.py deleted file mode 100644 index fcf3c37b8..000000000 --- a/resources/master_data/scripts/_건설기계_로직_플랜트.py +++ /dev/null @@ -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", - ), - ] diff --git a/resources/master_data/scripts/_건설기계_읽기.py b/resources/master_data/scripts/_건설기계_읽기.py deleted file mode 100644 index 8ed5dc34f..000000000 --- a/resources/master_data/scripts/_건설기계_읽기.py +++ /dev/null @@ -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*
\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(("|", "#", "", "", 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("