diff --git a/resources/master_data/_갱신절차.md b/resources/master_data/_갱신절차.md index 868fe5d75..5085c8494 100644 --- a/resources/master_data/_갱신절차.md +++ b/resources/master_data/_갱신절차.md @@ -63,7 +63,7 @@ ## 품셈재료 - 첫 층에 없음 — `old/재료_품셈재료.json` 은 시험 기준 자료(`test_자재품목_분류.py`)로만 둠. -- 로직 재료 줄 = 자재품목 고르기 조건 · 검색어(아래 로직 채우기). +- 기초 재료 = 수식 문서 변수 연결 「재료」(자재품목 고르기 조건 · 검색어). ## 기계 (폴더 `기계/` = 한 대 한 파일 · 읽기 · 쓰기 `master_machine_files` · 원문 건설품셈 · 산림품셈) @@ -94,7 +94,7 @@ | 산림 그 밖 장 | 산림품셈 본문 각 장 | 같음 | 같음 | 빌더 없음 | 같음 | | 건설 전 장 | 건설품셈 본문 각 부문 | 같음 | 연 1회 | 빌더 없음(소요량 빌더 안 계수 손 표는 소요량에 들어감) | 같음 | -- 소요량 · 계수 표를 다시 지은 뒤 = `scripts/build_용도.py`(표마다 「용도」 · 다시 돌려도 같음). +- 소요량 · 계수 표를 다시 지으면 표마다 「용도」 는 그대로 옮김(채우는 스크립트 없음 — 구멍). ## 환율 (`환율_한국은행환율.json`) @@ -116,37 +116,19 @@ | 빌더 | `scripts/build_요율.py --check`(대조만 · 정본 안 씀 · 다른 줄은 원문 셀 자리와 같이 나옴) · 요율 화면 책 = `scripts/build_제비율책.py`(→ `제비율엑셀/조달청_제비율_책.json` · 판마다) | | 검사 | `build_요율.py --check` · `build_제비율책.py --check` · `check_master.py 틀 요율_조달청제비율.json` | -## 로직 (`로직_<원문>_장_….json`) +## 수식 문서 = 단가산출 기초 (`수식문서/수식_<원문>_장_….json`) | 항목 | 값 | | --- | --- | -| 출처 | 품셈 본문 절 + 위 요소·표 파일(키로 끌어옴) · 자체 로직은 원문 「자체」 | -| 받는 법 | M01 화면에서 편집·저장 (정본 파일 직접 편집도 가능) | +| 출처 | 품셈 본문 절 + 위 요소·표 파일(변수 연결 = 키) · 자체 기초는 `수식_자체.json` | +| 받는 법 | M01 화면 [저장](줄 쌓기 · 이름표 · 별칭) · 문서 고침 스크립트 — 빌더 없음 | | 주기 | 요소 갱신 때 · 품셈 개정 때 | -| 빌더 | 빌더 없음 — 줄 칸 「개정」만 `scripts/build_로직_개정.py`(원문 절 머리 개정 연도 · 품셈 개정 때) | -| 검사 | `check_master.py 로직` (끊긴 키 · 돌고 도는 참조 · 찾기 조건) · `check_master.py 계산 <로직키> 이름=값 …` (견본 계산) · `pytest resources/tester/test_masterdata_check.py resources/tester/test_m01_api.py -q` | -| 복잡도 | `scripts/로직_복잡도_재기.py [상위 N]` (읽기 전용) | - -로직 줄을 더한 뒤 채우기(차례대로 · 모두 `--check` 로 남은 것만 봄 · 다시 돌려도 같음): - -1. `scripts/build_변수표_796_3.py`(변수 국문 이름 · 기호 · 단위 — 결정 자료 `scripts/변수표_796_3.json`) -2. `scripts/build_변수기호_800_1.py`(남은 변수 기호) -3. `scripts/build_단위표기_801_5.py`(단위 글 원문 꼴) -4. `scripts/build_재료_검색어.py [--쓰기]`(재료 줄 자재품목 키 → 검색어) - -## 수식 문서 (`수식문서/수식_<원문>_장_….json`) - -| 항목 | 값 | -| --- | --- | -| 출처 | 로직 JSON(위) — 변환 `master_doc_convert` · 셈 `master_doc_calc` | -| 받는 법 | 로직 · 요소를 고친 뒤 빌더로 다시 지음 · 화면 [저장]은 문서에 바로 씀 | -| 주기 | 로직 · 요소 갱신 때 | -| 빌더 | `scripts/build_수식문서_802_2.py`(변환 · 금액 전수 대조 · 저장) | -| 검사 | `build_수식문서_802_2.py --check`(저장본 · 목록과 같음) · `pytest resources/tester/test_802_2_convert.py -q` | +| 채우기 | 줄 머리 「개정」 = `scripts/build_로직_개정.py [--check]`(원문 절 머리 개정 연도 · 품셈 개정 때) | +| 검사 | `check_master.py 로직`(문서 막힘 · 돌고 도는 참조 · 키 겹침 · 대장) · `check_master.py 조합` · `pytest resources/tester/test_855_golden.py resources/tester/test_802_1_formula_doc.py -q` | ## 구멍 목록 -- 로직 — 빌더 없음(채우기 · 수식 문서만). +- 수식 문서 — 빌더 없음(화면 · 문서 고침 스크립트만) · 표 「용도.로직키」 를 다시 채우는 문서 대상 스크립트 없음. - 요율 — 대조(`--check`)만 됨 · 값을 정본에 반영하는 쓰기는 여전히 손으로. - 기계 산림품셈 · 소요량 건설 건축·유지관리 · 소요량 산림 전 장 · 계수 건설 전 장 · 계수 산림 1장 밖 — 빌더 없음. - 자재품목 — 나라장터 스냅샷 → 마스터 줄 빌더 없음 · 유료 물가지 받는 길 미정. diff --git a/resources/master_data/scripts/analyze_식_복사.py b/resources/master_data/scripts/analyze_식_복사.py deleted file mode 100644 index 168c470fd..000000000 --- a/resources/master_data/scripts/analyze_식_복사.py +++ /dev/null @@ -1,155 +0,0 @@ -"""로직 복사 설계용 — 호표·중간·덧줄 식 속 찾기()·로직() 전수 세기 (읽기 전용 · 아무것도 안 씀). - -resources/master_data/ref/_설계_식_복사.md 의 ② 수치 근거. - -사용: ./venv/Scripts/python.exe resources/master_data/scripts/analyze_식_복사.py -""" - -from __future__ import annotations - -import json -import re -import sys -from pathlib import Path - -ROOT = Path(__file__).resolve().parents[1] - -NAME_OF = re.compile(r"(찾기|로직)\(\s*([A-Za-z0-9]+)") - - -def find_calls(text: str) -> list[tuple[str, str, str]]: - """text 안 찾기(...)·로직(...) 전부 — (종류, 키, 괄호 안 전체 글) 목록. 중첩 괄호는 짝을 맞춰 끊음.""" - out = [] - for m in NAME_OF.finditer(text): - kind, key = m.group(1), m.group(2) - start = m.start() + len(kind) # '(' 위치 — 찾기·로직 바로 뒤 - depth = 0 - i = start - while i < len(text): - if text[i] == "(": - depth += 1 - elif text[i] == ")": - depth -= 1 - if depth == 0: - break - i += 1 - args = text[start + 1 : i] - out.append((kind, key, args.strip())) - return out - - -def row_lines(row: dict) -> list[tuple[str, str]]: - """(자리표, 식 글) 목록 — 호표 수량 · 호표 요소(문자열일 때) · 중간 식 · 덧줄 식.""" - out = [] - for i, h in enumerate(row.get("호표") or []): - if isinstance(h.get("수량"), str): - out.append((f"호표[{i}].수량", h["수량"])) - if isinstance(h.get("요소"), str): - out.append((f"호표[{i}].요소", h["요소"])) - for i, m in enumerate(row.get("중간") or []): - if isinstance(m.get("식"), str): - out.append((f"중간[{i}].식", m["식"])) - for i, m in enumerate(row.get("덧줄") or []): - if isinstance(m.get("식"), str): - out.append((f"덧줄[{i}].식", m["식"])) - return out - - -def load_table_names() -> dict[str, str]: - """표 키 → 표 이름 (소요량_*.json · 계수_*.json).""" - names = {} - for path in list(ROOT.glob("소요량_*.json")) + list(ROOT.glob("계수_*.json")): - data = json.loads(path.read_text(encoding="utf-8")) - for t in data.get("표", []): - names[t["키"]] = t.get("이름", "") - return names - - -def load_logic_names() -> dict[str, str]: - names = {} - for path in ROOT.glob("로직_*.json"): - data = json.loads(path.read_text(encoding="utf-8")) - for row in data.get("줄", []): - names[row["키"]] = row.get("이름", "") - return names - - -def main() -> None: - sys.stdout.reconfigure(encoding="utf-8") - table_names = load_table_names() - logic_names = load_logic_names() - - total_rows = 0 - total_찾기 = 0 - total_로직 = 0 - rows_with_call = 0 - multi_call_lines = 0 # 한 줄(자리표 하나)에 찾기·로직 합쳐 2번 이상 - rows_with_dup_call = 0 # 같은 행 안에서 (종류,키,인자) 짝이 완전히 같은 호출이 2번 이상 - dup_call_examples = [] - name_collisions = {} # 표이름 -> {키, 키, ...} (다른 키가 같은 이름을 씀 — 별칭 지을 때 번호 필요) - rows_with_collision = 0 - - for path in sorted(ROOT.glob("로직_*.json")): - data = json.loads(path.read_text(encoding="utf-8")) - for row in data.get("줄", []): - total_rows += 1 - row_calls = [] - has_call = False - for place, text in row_lines(row): - calls = find_calls(text) - if not calls: - continue - has_call = True - if len(calls) >= 2: - multi_call_lines += 1 - for kind, key, args in calls: - if kind == "찾기": - total_찾기 += 1 - else: - total_로직 += 1 - row_calls.append((kind, key, args, place)) - if has_call: - rows_with_call += 1 - - sig_count = {} - for kind, key, args, place in row_calls: - sig = (kind, key, args) - sig_count[sig] = sig_count.get(sig, 0) + 1 - dups = [s for s, c in sig_count.items() if c >= 2] - if dups: - rows_with_dup_call += 1 - if len(dup_call_examples) < 8: - dup_call_examples.append((row["키"], dups[0][0], dups[0][1], sig_count[dups[0]])) - - keys_in_row = {key for kind, key, args, place in row_calls if kind == "찾기"} - names_seen = {} - collided = False - for key in keys_in_row: - nm = table_names.get(key, key) - names_seen.setdefault(nm, set()).add(key) - for nm, keys in names_seen.items(): - if len(keys) >= 2: - collided = True - name_collisions.setdefault(nm, set()).update(keys) - if collided: - rows_with_collision += 1 - - print(f"로직 전체 줄 수: {total_rows}") - print(f"찾기() 호출 수: {total_찾기}") - print(f"로직() 호출 수: {total_로직}") - print(f"찾기·로직 호출이 1개 이상 있는 줄: {rows_with_call}") - print(f"한 자리(호표 수량 1칸·중간 식 1줄 등)에 호출이 2번 이상 겹친 자리 수: {multi_call_lines}") - print(f"같은 행 안에서 (표·인자)가 완전히 같은 호출이 2번 이상 반복되는 행 수: {rows_with_dup_call}") - print(" 보기:") - for key, kind_str, args, count in dup_call_examples: - print(f" {key} — {kind_str}({args[:40]}...) 를 {count}번") - print( - f"표 이름이 겹쳐(다른 키가 같은 표이름) 별칭에 번호가 필요한 행 수: {rows_with_collision}" - ) - print(" 겹치는 표이름 보기:") - for nm, keys in list(name_collisions.items())[:10]: - print(f" '{nm}' <- {sorted(keys)}") - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_단위표기_801_5.py b/resources/master_data/scripts/build_단위표기_801_5.py deleted file mode 100644 index cd2f58d86..000000000 --- a/resources/master_data/scripts/build_단위표기_801_5.py +++ /dev/null @@ -1,142 +0,0 @@ -# -*- coding: utf-8 -*- -"""M01 로직 단위 글을 건설품셈 원문 꼴로 (PLAN 801-5 · 요구 663-2) — 글만 바꿈 · 셈 지문 그대로. - -돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_단위표기_801_5.py [--check | --list 파일.xlsx] -- 대상 = M01 로직 줄의 입력 · 중간 변수 `단위` · `결과단위` — 규칙 · 근거 절 = `master_unit_text.RULES`. -- 계수 · 소요량 표 값칸 · 호표 줄 단위 · 사용자가 이미 원문 꼴로 쓴 칸은 안 건드림(이미 같으면 그대로 — 두 번 돌려도 같음). -- 쓰기 전 지문 대조 = 줄마다 엔진 셈 · 끝수 지문이 전후 같을 때만 씀(다르면 멈춤). -- `--check` = 쓰지 않고 쓸 것이 남았는지만(남았으면 종료 코드 1) · `--list` = 검토 목록 xlsx 만 씀(마스터 안 씀). -""" - -from __future__ import annotations - -import copy -import hashlib -import json -import sys -from pathlib import Path - -HERE = Path(__file__).resolve().parent -sys.path.insert(0, str(HERE.parents[2])) -import master_auto as ma # noqa: E402 -import master_cut as mcut # noqa: E402 -import master_formula as mf # noqa: E402 -import master_unit_text as ut # noqa: E402 - -from M01_MasterData import M01_MasterData_Store as st # noqa: E402 - - -def plan(files: dict[str, dict]) -> tuple[list[dict], list[dict], dict[str, dict]]: - """(저장 묶음, 목록 줄들, 새 files) — 읽기 전용.""" - batch, rows, new_files = [], [], {} - for name, data in files.items(): - if data.get("그룹") != "로직": - new_files[name] = data - continue - changes, new_data = [], copy.deepcopy(data) - for row in new_data.get("줄", []): - hit = False - for kind in ("입력", "중간"): - for spec in row.get(kind) or []: - now = ut.canon(spec.get("단위")) - if now != (spec.get("단위") or ""): - rows.append(_item(row, kind, spec["이름"], spec["단위"], now)) - spec["단위"], hit = now, True - if row.get("결과단위"): - now = ut.canon(row["결과단위"]) - if now != row["결과단위"]: - rows.append(_item(row, "결과단위", "", row["결과단위"], now)) - row["결과단위"], hit = now, True - if hit: - changes.append({"op": "edit", "key": row["키"], "row": row}) - new_files[name] = new_data - if changes: - batch.append({"file": name, "version": st.read(name)[1], "changes": changes}) - return batch, rows, new_files - - -def _item(row: dict, kind: str, var: str, before: str, after: str) -> dict: - return { - "로직": row["키"], - "이름": row.get("이름", ""), - "칸": kind, - "변수": var, - "지금": before, - "원문 꼴": after, - "규칙": ut.rule_of(before), - } - - -def fingerprint(whole: mf.Master, row: dict) -> str: - """줄 하나의 엔진 셈 · 끝수 지문 — 멈춤도 지문.""" - try: - key = str(row["키"]) - raw = mf.run( - whole, - key, - { - **ma.values(whole, row), - **{k: v for k, v in ma.defaults(whole, row).items() if v is not None}, - }, - ) - text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False) - text += json.dumps( - mcut.engine(whole, key, raw), default=str, sort_keys=True, ensure_ascii=False - ) - except Exception as e: # noqa: BLE001 - text = f"ERR {type(e).__name__} {e}" - return hashlib.sha256(text.encode()).hexdigest()[:16] - - -def differing(old: dict[str, dict], new: dict[str, dict]) -> list[str]: - """지문이 바뀐 로직 키들 — 고친 줄만 대조.""" - before, after = mf.Master(old), mf.Master(new) - out = [] - for name, data in new.items(): - if data.get("그룹") != "로직": - continue - was = {r["키"]: r for r in old[name]["줄"]} - for row in data["줄"]: - if row != was[row["키"]] and fingerprint(before, was[row["키"]]) != fingerprint( - after, row - ): - out.append(row["키"]) - return out - - -def write_list(rows: list[dict], path: Path) -> None: - import openpyxl - - book = openpyxl.Workbook() - sheet = book.active - sheet.title = "바뀜" - cols = ["로직", "이름", "칸", "변수", "지금", "원문 꼴", "규칙"] - sheet.append(cols) - for r in rows: - sheet.append([r[c] for c in cols]) - rule = book.create_sheet("대응표") - rule.append(["규칙", "바꿀 글", "근거 절(건설공사 표준품셈 본문 아래)", "바뀐 칸 수"]) - for name, _, to, _, files in ut.RULES: - rule.append([name, to, " · ".join(files), sum(name in r["규칙"] for r in rows)]) - path.parent.mkdir(parents=True, exist_ok=True) - book.save(path) - - -def main() -> None: - files, _ = st.loaded() - batch, rows, new_files = plan(files) - print(f"쓸 것 — 로직 {len({r['로직'] for r in rows})} · 칸 {len(rows)}") - if "--list" in sys.argv: - write_list(rows, Path(sys.argv[sys.argv.index("--list") + 1])) - return - if "--check" in sys.argv: - raise SystemExit(1 if batch else 0) - if batch: - bad = differing(files, new_files) - if bad: - raise SystemExit(f"셈 지문이 달라지는 로직 {len(bad)} — 멈춤: {bad[:10]}") - print(st.save(batch)) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_로직_직접칸_851_1.py b/resources/master_data/scripts/build_로직_직접칸_851_1.py deleted file mode 100644 index f50ce5fa1..000000000 --- a/resources/master_data/scripts/build_로직_직접칸_851_1.py +++ /dev/null @@ -1,515 +0,0 @@ -# -*- coding: utf-8 -*- -"""작업량 식 직접 칸 · 덤프 운반 구간 여럿(PLAN 851-1 · 요구 893) — 옛 로직 JSON 고침(한 번 돌림). - -돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_직접칸_851_1.py -그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길). -- 고르기(표 값)로만 정해지는 수 = 그 중간 줄(또는 식 속 그 찾기)을 「만약(X입력 > 0, X입력, 표)」 로 — - 비우거나 0 = 고르기 값 · 넣으면 그 값이 이김 · 입력 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 · - 보이는 이름 = 「○○ 직접」(변수표 이름) · 열쇠 = 「X입력」 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1](지금 E입력 과 같음). -- 지금 「0 = 표」 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 …) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」. -- 덤프트럭(8-2-8) t2 = 구간 셋(구간 1 = 지금 운반거리 · 도로상태 · 구간2거리 · 구간3거리 = 0 이면 안 탐) · - 구간마다 적재 · 공차 주행속도 직접(원문 3 [주] 「주행속도를 측정하여 사용할 수 있다」) · t2 · t3 · t4 · t5 직접. -- 직접 칸을 더한 식을 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음) = 새 입력 0 · 구간 도로상태 = 구간 1 값. -- 목록 276 변수 중 뺀 것(값 하나 · 이미 직접 칸이 덮음 · 글 값) = 851-1 보고 표. -- 이미 돌렸으면(덤프 V1 있음) 멈춤. -""" - -from __future__ import annotations - -import copy -import json -import re -import sys -from decimal import Decimal -from pathlib import Path - -HERE = Path(__file__).resolve().parent -MASTER = HERE.parent -ROOT = MASTER.parents[1] -for p in (str(ROOT), str(HERE)): - if p not in sys.path: - sys.path.insert(0, p) - -C08 = "로직_건설품셈_08장_건설기계.json" -F10 = "로직_산림품셈_10장_자재․장비_운반.json" -SELF = "로직_자체.json" -DUMP = "GC001155" -EFF = [ - 0, - 1, -] # 작업효율 직접 칸 범위(지금 E입력 과 같음 · 원문 표 값이 1 넘는 효율 표(준설선 · 임목파쇄기)는 범위 없음) - -# (식, 중간 줄 | 결과, 감쌀 글(None = 줄 통째), 열쇠, 보이는 이름, 자리(이 입력 아래), 단위, 범위) · 기호 = 이름 규칙 -OPS: list[tuple] = [ - ("GC001144", "q0", None, "q0입력", "삽날용량 직접", "급수", "㎥", None), - ("GC001144", "e", None, "e입력", "운반거리계수 직접", "거리구분", "", None), - ("GC001144", "V1", None, "V1입력", "전진속도 직접", "전진단", "m/분", None), - ("GC001144", "V2", None, "V2입력", "후진속도 직접", "후진단", "m/분", None), - ("GC001146", "An", None, "An입력", "리핑 단면적 직접", "발톱수", "㎡", None), - ("GC001149", "d", None, "d입력", "굴착심도계수 직접", "굴착심도", "", None), - ("GC001150", "m", None, "m입력", "주행계수 직접", "기종", "sec/m", None), - ( - "GC001150", - "cm", - "t1", - "t1입력", - "적재시간 직접", - "적재조건", - "sec", - None, - ), # 줄 t1 = 표 한 마디(열쇠 겹침 피함) - ("GC001150", "K", None, "K입력", "버킷계수 직접", "K조건", "", None), - ("GC001152", "K", None, "K입력", "적재계수 직접", "토질상태", "", None), - ("GC001152", "V1", None, "V1입력", "적재 주행속도 직접", "도로상태", "m/분", None), - ("GC001152", "V2", None, "V2입력", "공차 주행속도 직접", "V1입력", "m/분", None), - ("GC001152", "t", None, "t입력", "적토·사토·기어변속시간 직접", "푸쉬도우저", "분", None), - *[ - op - for key in ("GC001153", "GC001154") - for op in ( - (key, "V1", None, "V1입력", "작업속도 직접", "현장조건", "㎞/hr", None), - (key, "V2", None, "V2입력", "후진·회송속도 직접", "되돌림조건", "㎞/hr", None), - (key, "t", None, "t입력", "방향변환시간 직접", "t작업", "분", None), - ) - ], - ("GC001154", "l", None, "l입력", "블레이드 유효길이 직접", "l작업", "m", None), - *[ - op - for key in ("GC001157", "GC001158") - for op in ( - (key, "W", None, "W입력", "유효다짐폭 직접", "규격", "m", None), - (key, "V", None, "V입력", "다짐속도 직접", "다짐층", "㎞/hr", None), - ) - ], - ("GC001160", "결과", None, "Q입력", "생산능력 직접", "혼합재", "ton/hr", None), - ("GC001162", "결과", None, "Q입력", "생산능력 직접", "작업조건", "ton/hr", None), - ( - "GC001163", - "결과", - "찾기(CC000375, 출구간격=출구간격, 규격=규격).생산능력", - "q입력", - "생산능력 직접", - "출구간격", - "ton/hr", - None, - ), # fmt: skip - ("GC001163", "효율", None, "E효율입력", "효율 직접", "작업조건", "%", None), - ( - "GC001164", - "결과", - "찾기(CC000383, 규격=규격, 출구간격=출구간격).생산능력", - "q입력", - "생산능력 직접", - "출구간격", - "ton/hr", - None, - ), # fmt: skip - ("GC001164", "E", None, "E입력", "작업효율 직접", "작업조건", "", EFF), - ( - "GC001165", - "통과능력", - None, - "q통과입력", - "통과능력 직접", - "조합방법", - "ton/hr", - None, - ), # fmt: skip - ("GC001165", "A", None, "A입력", "택수 계수(A) 직접", "택의수", "", None), - ("GC001165", "B", None, "B입력", "작은 골재량 계수(B) 직접", "B골재량", "", None), - ("GC001165", "C", None, "C입력", "스크린 규격 계수(C) 직접", "C규격", "", None), - ("GC001165", "D", None, "D입력", "큰 골재량 계수(D) 직접", "D골재량", "", None), - ("GC001165", "E", None, "E입력", "재료 계수(E) 직접", "재료", "", None), - ("GC001168", "결과", None, "Q입력", "작업량 직접", "구분", "㎡/h", None), - ("GC001171", "q", None, "q입력", "실용량 직접", "슬럼프", "㎥", None), - ("GC001171", "cm", None, "cm입력", "싸이클시간 직접", "싸이클", "분", None), - ("GC001173", "W", None, "W입력", "적재용량 직접", "규격", "㎥", None), - ("GC001174", "n", None, "n입력", "대차수 직접", "기관차", "대", None), - ("GC001174", "t2", None, "t2입력", "적재적하시간 직접", "재료", "분", None), - ("GC001175", "t", None, "t입력", "적재적하시간 직접", "종류", "분", None), - ("GC001175", "V1", None, "V1입력", "적재시 속도 직접", "작업로", "m/분", None), - ("GC001175", "V2", None, "V2입력", "공차시 속도 직접", "V1입력", "m/분", None), - ("GC001176", "β", None, "β입력", "해머계수 직접", "해머", "", None), - ("GC001176", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None), - ("GC001176", "F", None, "F입력", "작업계수 직접", "현장", "", None), - ("GC001176", "tw", None, "tw입력", "용접시간 직접", "관두께", "분", None), - ("GC001177", "β", None, "β입력", "해머계수 직접", "해머", "", None), - ("GC001177", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None), - ( - "GC001177", - "Ts", - "만약(파일경 <= 300, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 250·300㎜').값, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 350∼500㎜').값)", - "Ts입력", - "세우기·위치조정 시간 직접", - "파일경", - "분/회", - None, - ), # fmt: skip - ("GC001177", "F", None, "F입력", "작업계수 직접", "현장", "", None), - ("GC001178", "β", None, "β입력", "판두께계수 직접", "판두께", "", None), - ("GC001178", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None), - ("GC001179", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None), - ("GC001180", "Ts", None, "Ts입력", "준비시간 직접", "작업", "분", None), - ( - "GC001180", - "F", - "찾기(CC000423, 작업=작업).F0", - "F0입력", - "작업계수 F0 직접", - "Ts입력", - "", - None, - ), # fmt: skip - ("GC001180", "k", None, "k입력", "해머계수 직접", "파일", "", None), - ("GC001180", "r1", None, "r1입력", "사질토 단위시간 직접", "사질N", "분/m", None), - ("GC001180", "r2", None, "r2입력", "점질토 단위시간 직접", "점질N", "분/m", None), - ("GC001181", "α", None, "α입력", "α 직접", "해머", "", None), - ("GC001181", "K", None, "K입력", "K 직접", "α입력", "", None), - ("GC001181", "γ", None, "γ입력", "γ 직접", "작업", "", None), - ( - "GC001181", - "F", - "찾기(CC000430, 작업='항타').F0", - "F0입력", - "작업계수 F0 직접", - "γ입력", - "", - None, - ), # fmt: skip - ("GC001181", "F인발", "찾기(CC000430, 작업='항발').F0", "F0입력", "", "", "", None), # 같은 칸 - ( - "GC001186", - "E", - "찾기(CC000466, 구분=E1).E", - "E1입력", - "흙의 두께 효율 직접", - "E1", - "", - None, - ), # fmt: skip - ( - "GC001186", - "E", - "찾기(CC000468, 구분=E2).E", - "E2입력", - "평면형상 효율 직접", - "E2", - "", - None, - ), # fmt: skip - ( - "GC001186", - "E", - "찾기(CC000470, 구분=E3).E", - "E3입력", - "단면형상 효율 직접", - "E3", - "", - None, - ), # fmt: skip - ( - "GC001186", - "E", - "찾기(CC000472, 구분=E4).E", - "E4입력", - "해상조건 효율 직접", - "E4", - "", - None, - ), # fmt: skip - ( - "GC001187", - "cm", - "찾기(CC000476, 버킷용량=버킷용량).싸이클시간", - "싸이클입력", - "기준 싸이클시간 직접", - "버킷용량", - "sec", - None, - ), # fmt: skip - ( - "GC001187", - "E", - "찾기(CC000477, 구분=E1).E", - "E1입력", - "흙의 두께 효율 직접", - "E1", - "", - EFF, - ), # fmt: skip - ( - "GC001187", - "E", - "찾기(CC000479, 구분=E2).E", - "E2입력", - "해상조건 효율 직접", - "E2", - "", - EFF, - ), # fmt: skip - ("GC001188", "S", None, "S입력", "쇄암면적 직접", "중추중량", "㎡", None), - ("GC001188", "n", None, "n입력", "낙추횟수 직접", "S입력", "회", None), - ( - "GC001189", - "결과", - "찾기(CC000486, 규격=규격).K", - "K입력", - "능력계수 직접", - "규격", - "", - None, - ), # fmt: skip - ( - "GC001189", - "결과", - "찾기(CC000487, 스크린=스크린).S", - "S입력", - "스크린계수 직접", - "스크린", - "", - None, - ), # fmt: skip - ( - "GC001189", - "결과", - "찾기(CC000488, 작업조건=작업조건).E", - "E입력", - "작업효율 직접", - "작업조건", - "", - None, - ), # fmt: skip - ("GC001190", "q", None, "q입력", "준설량 직접", "배송거리", "㎥/hr", None), - ("GC001190", "E", None, "E입력", "작업효율 직접", "유속", "", EFF), - ("GF000148", "f", None, "f입력", "체적환산계수 직접", "재료", "", None), - ("GF000148", "E", None, "E입력", "작업효율 직접", "f입력", "", EFF), -] - -# 지금 「0 = 표」 직접 칸 — 보이는 이름만(열쇠 · 기호 그대로) -RENAME = { - "E입력": "작업효율 직접", - "싸이클입력": "싸이클시간 직접", - "K입력": "버킷계수 직접", - "α입력": "토질계수 직접", - "f입력": "체적환산계수 직접", - "k입력": "버킷계수 직접", - "하역시간입력": "하역시간 직접", - "대기시간입력": "대기시간 직접", - "배출시간입력": "배출시간 직접", - "적재시간입력": "적재시간 직접", -} -RENAME_ROW = {("GC001186", "q입력"): "준설능력 직접"} -ROAD = "찾기(CC000054, 도로상태={road}).{col}" - - -def _load(name: str) -> tuple[str, dict]: - text = (MASTER / name).read_text(encoding="utf-8") - return text, json.loads(text, parse_float=Decimal, parse_int=Decimal) - - -def _save(name: str, text: str, before: dict, after: dict) -> None: - from M01_MasterData import M01_MasterData_Store_Shape as shape - - out = shape.keep_shape(text, before, after, "줄") or shape.dump(after) - assert json.loads(out, parse_float=Decimal, parse_int=Decimal) == after - (MASTER / name).write_text(out, encoding="utf-8", newline="\n") - - -def _guard(key: str, body: str) -> str: - return f"만약({key} > 0, {key}, {body})" - - -def _is_guard(row: dict, name: str) -> bool: - return any(re.search(rf"만약\({re.escape(name)} > 0, {re.escape(name)}, ", s["식"]) for s in row.get("중간") or []) # fmt: skip - - -def _add_input(row: dict, spec: dict, after: str) -> None: - ins = row["입력"] - at = next(i for i, x in enumerate(ins) if x["이름"] == after) - ins.insert(at + 1, spec) - if isinstance(row.get("시험입력"), dict): - row["시험입력"][spec["이름"]] = spec.pop("_시험", Decimal(0)) - spec.pop("_시험", None) - - -def _table(row: dict, key: str, name: str, pick: bool = False) -> None: - """변수표 — 기호 · 아래 = 이름 규칙(`master_symbol.rule` · 같은 열쇠 = 같은 기호) · 이름 = 보이는 이름.""" - import master_symbol as msym - - sign, sub = msym.rule(key, "변수", "고름" if pick else "")[:2] - row.setdefault("변수표", {})[key] = {"기호": sign, "아래": sub, "이름": name} - - -def apply_op(row: dict, op: tuple) -> None: - _, step, sub, key, name, after, unit, rng = op - target = row["결과"] if step == "결과" else next(s for s in row["중간"] if s["이름"] == step) - text = target["식"] - if sub is None: - target["식"] = _guard(key, text) - else: - assert sub in text, (row["키"], step, sub) - target["식"] = text.replace(sub, _guard(key, sub)) - if not name: # 같은 칸을 둘째 줄에도 - return - assert key not in {x["이름"] for x in row["입력"]} | {x["이름"] for x in row.get("중간") or []}, key # fmt: skip - spec = { - "이름": key, - "설명": f"{name.removesuffix(' 직접')} — 직접 넣을 때 · 0 이면 고르기(표) 값", - } - if unit: - spec["단위"] = unit - if rng: - spec["범위"] = [Decimal(str(x)) for x in rng] - spec["출처"] = row.get("출처") or "" - _add_input(row, spec, after) - _table(row, key, name) - - -def rename(row: dict, docs: dict) -> int: - """지금 직접 칸 보이는 이름 — 기호 · 아래는 지금 수식 문서 그대로 옮겨 적음.""" - n = 0 - doc = docs.get(str(row["키"])) or {} - for spec in row.get("입력") or []: - key = spec["이름"] - name = RENAME_ROW.get((row["키"], key)) or RENAME.get(key) - if not name or not (_is_guard(row, key) or key == "적재시간입력"): - continue - now = next((v for v in doc.get("변수") or [] if v.get("열쇠") == key), None) - assert now, (row["키"], key) - look = row.setdefault("변수표", {}).setdefault(key, {}) - look |= {"기호": now["기호"], "아래": now.get("아래") or "", "이름": name} - if now.get("위"): - look["위"] = now["위"] - n += 1 - return n - - -def dump(row: dict) -> None: - """덤프 t2 = 구간 셋 · 속도 직접 · t2 ~ t5 직접.""" - mids = row["중간"] - names = [m["이름"] for m in mids] - assert "V1" not in names - road = next(i for i in row["입력"] if i["이름"] == "도로상태") - base_road = row["시험입력"]["도로상태"] - speeds = [] - after = "도로상태" - for n in (1, 2, 3): - dist, rd = ("운반거리", "도로상태") if n == 1 else (f"구간{n}거리", f"구간{n}도로상태") - tag = "" if n == 1 else f" {n}" - if n > 1: - _add_input(row, {"이름": dist, "설명": f"운반 구간 {n} 거리(편도) — 0 이면 안 씀", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip - _table(row, dist, f"운반거리{tag}") - _add_input(row, {"이름": rd, "설명": f"운반 구간 {n} 도로 상태", "고르기": list(road["고르기"]), "출처": "건설품셈 공통 8-2-8 3", "_시험": base_road}, dist) # fmt: skip - _table(row, rd, f"도로상태{tag}", pick=True) - after = rd - for k, col, what in ((2 * n - 1, "적재", "적재속도"), (2 * n, "공차", "공차속도")): - key = f"V{k}입력" - _add_input(row, {"이름": key, "설명": f"구간 {n} {col}시 평균주행속도를 직접 넣을 때(측정값 · 3 [주]) — 0 이면 도로상태 표", "단위": "㎞/hr", "출처": "건설품셈 공통 8-2-8 3"}, after) # fmt: skip - _table(row, key, f"{what}{tag} 직접") - after = key - speeds.append({"이름": f"V{k}", "식": _guard(key, ROAD.format(road=rd, col=col)), "단위": "㎞/hr"}) # fmt: skip - row["변수표"][f"V{k}"] = {"기호": "V", "아래": str(k), "이름": f"{col}시 평균주행속도{tag}"} # fmt: skip - _add_input(row, {"이름": "t2입력", "설명": "왕복시간(t2)을 직접 넣을 때 — 0 이면 구간 거리 · 속도로 셈", "단위": "분", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip - _table(row, "t2입력", "왕복시간(t2) 직접") - legs = ["운반거리 / V1 * 60 + 운반거리 / V2 * 60"] + [ - f"만약(구간{n}거리 > 0, 구간{n}거리 / V{2 * n - 1} * 60 + 구간{n}거리 / V{2 * n} * 60, 0)" for n in (2, 3) - ] # fmt: skip - t2 = next(m for m in mids if m["이름"] == "t2") - t2["식"] = _guard("t2입력", " + ".join(legs)) - at = names.index("t2") - mids[at:at] = speeds - for step, key, name, after_ in ( - ("t3", "t3입력", "적하시간(t3) 직접", "적하조건"), - ("t4", "t4입력", "진입시간(t4) 직접", "적재장소"), - ("t5", "t5입력", "덮개시간(t5) 직접", "덮개"), - ): - apply_op(row, (DUMP, step, None, key, name, after_, "분", None)) - row["비고"] = ( - str(row["비고"]) - + " · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표" - ) - - -def _call_fill(text: str, key: str, extra: str) -> str: - pat = re.compile(rf"로직\({key},([^()]*(?:\([^()]*\)[^()]*)*)\)") - return pat.sub(lambda m: f"로직({key},{m[1]}{extra})", text) - - -def main() -> None: - import master_doc_link as ml - - docs = ml.load_all() - text, before = _load(C08) - after = copy.deepcopy(before) - rows = {str(r["키"]): r for r in after["줄"]} - if any(m["이름"] == "V1" for m in rows[DUMP]["중간"]): - print("이미 돌림 — 멈춤") - return - renamed = sum(rename(r, docs) for r in rows.values() if (r.get("부품") or {}).get("갈래") == "작업량 틀") # fmt: skip - added: dict[str, list[str]] = {} - for op in OPS: - if op[0] in rows: - apply_op(rows[op[0]], op) - if op[4]: - added.setdefault(op[0], []).append(op[3]) - dump(rows[DUMP]) - for k, keys in added.items(): - rows[k]["비고"] = ( - str(rows[k].get("비고") or "") + f" · 직접 칸 {' · '.join(keys)} 0 = 표(851-1)" - ) - _save(C08, text, before, after) - print("08장 — 이름만", renamed, "· 직접 칸", sum(map(len, added.values())), "식", len(added)) - - text, before = _load(F10) - after = copy.deepcopy(before) - rows = {str(r["키"]): r for r in after["줄"]} - for op in OPS: - if op[0] in rows: - apply_op(rows[op[0]], op) - _save(F10, text, before, after) - print("10장 — GF000148 직접 칸 f입력 · E입력") - - road = "'교차가 힘든 산간지도로 및 제방 등의 도로'" - dump_extra = ( - ", V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태=__R__, V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태=__R__," - " V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0" - ) - extra = {k: "".join(f", {x}=0" for x in keys) for k, keys in added.items()} - extra |= {"GF000148": ", f입력=0, E입력=0", DUMP: dump_extra} - for name in sorted(p.name for p in MASTER.glob("로직_*.json")): - text, before = _load(name) - raw = json.dumps(before, ensure_ascii=False, default=str) - hits = [k for k in extra if f"로직({k}," in raw or f"로직({k})" in raw] - if not hits: - continue - after = copy.deepcopy(before) - - def walk(x): - if isinstance(x, dict): - for k, v in x.items(): - if isinstance(v, str): - for key in hits: - first = extra[key].split("=")[0].lstrip(", ") - if f"로직({key}" in v and f"{first}=" not in v: - assert f"로직({key})" not in v, ( - name, - key, - ) # 입력 없는 부름 — 손으로 - m = re.search(r"도로상태=('[^']*'|[^,()]+)", v) - v = _call_fill( - v, key, extra[key].replace("__R__", m[1] if m else road) - ) - x[k] = v - else: - walk(v) - elif isinstance(x, list): - for v in x: - walk(v) - - walk(after) - _save(name, text, before, after) - print("부름 새 입력 0 —", name, " · ".join(hits)) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_변수기호_800_1.py b/resources/master_data/scripts/build_변수기호_800_1.py deleted file mode 100644 index 9c5085adc..000000000 --- a/resources/master_data/scripts/build_변수기호_800_1.py +++ /dev/null @@ -1,112 +0,0 @@ -# -*- coding: utf-8 -*- -"""M01 로직 변수 기호 기본값 전부 채우기 (PLAN 800-1 · 요구 660-1 · 659-2) — 796-3 이어서. - -돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_변수기호_800_1.py [--check] -- 입력 · 중간 변수 중 기호가 없는 것(이름이 한글 · 영문 낱말)에 `master_symbol` 규칙대로 `변수표` 기호 · 아래 · 위를 채움. - 원문 기호(796-3) · 사용자가 고친 칸은 덮지 않음 · 한 로직 안 겹치면 아래에 숫자 · 판마다 다시 돌려도 같은 결과. -- 찾기 · 요소 · 합 · 결과 변수는 정의 칸이 없어 수식 내보내기가 `master_symbol.apply` 로 씌움(저장 안 함). -- 엔진 열쇠 · 식 · 값은 그대로(보이기만). 저장 = M01 저장 길 · `AISLO_MASTER_DIR` 로 사본에 시험. -- `--check` = 쓰지 않고 쓸 것이 남았는지만(남았으면 종료 코드 1). -""" - -from __future__ import annotations - -import copy -import sys -from pathlib import Path - -HERE = Path(__file__).resolve().parent -sys.path.insert(0, str(HERE.parents[2])) -import master_equation as meq # noqa: E402 -import master_symbol as sym # noqa: E402 - -from M01_MasterData import M01_MasterData_Store as st # noqa: E402 - - -def logic_rows(files: dict[str, dict]) -> list[dict]: - return [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄", [])] - - -def needs(name: str) -> bool: - """기호를 정할 이름 — 이미 기호 꼴(영문 · 그리스 ≤ 6 자)이면 그대로.""" - return not sym.is_symbol(name) - - -def _hints(rows: list[dict]) -> dict[str, str]: - """변수 이름 → 힌트(고름 > 중간 > 빈).""" - rank = {"": 0, "중간": 1, "고름": 2} - out: dict[str, str] = {} - for r in rows: - for kind in ("입력", "중간"): - for spec in r.get(kind) or []: - now = ( - "고름" - if kind == "입력" and spec.get("고르기") - else "중간" - if kind == "중간" - else "" - ) - name = str(spec["이름"]) - if name not in out or rank[now] > rank[out[name]]: - out[name] = now - return out - - -# ── 정본에 채우기 ────────────────────────────────────────────────────── -def plan(files: dict[str, dict]) -> tuple[list[dict], dict]: - """(저장 묶음, 숫자) — 읽기 전용 · 고친 줄만 담음.""" - batch, stat = [], {"줄": 0, "변수": 0, "겹침비킴": 0} - hints = _hints(logic_rows(files)) - for name, data in files.items(): - if data.get("그룹") != "로직": - continue - changes = [] - for row in data.get("줄", []): - new, hit = copy.deepcopy(row), False - table = {k: dict(v) for k, v in (new.get(meq.FIELD) or {}).items()} - used = {sym_text for v in meq.table(new) for sym_text in (meq.token(v), v["이름"])} - for kind in ("입력", "중간"): - for spec in new.get(kind) or []: - key = str(spec["이름"]) - look = table.get(key, {}) - if look.get("기호") or not needs(key): - continue - sign, low, up = sym.lookup(key, "변수", hints.get(key, "")) - if look.get("아래") or look.get("위"): - continue # 사용자가 첨자만 정한 칸 — 건드리지 않음 - one = {**look, "기호": sign, "아래": low} - if up: - one["위"] = up - text = meq.token({"열쇠": key, **one}) - n, base = 1, low - while text in used: # 한 로직 안 겹침 — 아래에 숫자 - n += 1 - one["아래"] = base[: sym.SUBMAX - len(str(n))] + str(n) - text = meq.token({"열쇠": key, **one}) - stat["겹침비킴"] += 1 - used.add(text) - table[key] = one - stat["변수"] += 1 - hit = True - if not hit: - continue - new[meq.FIELD] = table - changes.append({"op": "edit", "key": row["키"], "row": new}) - stat["줄"] += 1 - if changes: - batch.append({"file": name, "version": st.read(name)[1], "changes": changes}) - return batch, stat - - -def main() -> None: - files, _ = st.loaded() - batch, stat = plan(files) - print(f"쓸 것 — 줄 {stat['줄']} · 변수 {stat['변수']} · 겹침 비킴 {stat['겹침비킴']}") - if "--check" in sys.argv: - raise SystemExit(1 if batch else 0) - if batch: - print(st.save(batch)) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_변수표_796_3.py b/resources/master_data/scripts/build_변수표_796_3.py deleted file mode 100644 index 285ba096d..000000000 --- a/resources/master_data/scripts/build_변수표_796_3.py +++ /dev/null @@ -1,102 +0,0 @@ -# -*- coding: utf-8 -*- -"""M01 로직 변수 국문 이름 · 기호 · 첨자 · 단위 기본값 채우기 (PLAN 796-3 · 요구 659-2 · 656-4). - -돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_변수표_796_3.py [--check] -- 결정 자료 = `변수표_796_3.json` {줄: {로직 키: {열쇠: {이름?, 기호?, 위?, 아래?, 단위?, 근거, 확신}}}} - (확신 = 원문 | 추정 · 값은 품셈 원문 「여기서 기호 : 풀이」 · 표 라벨 · 칸 설명 근거 · 지어 넣지 않음). -- 쓰는 곳 = 로직 줄 `변수표` {열쇠: {이름?, 기호?, 위?, 아래?}}(보이기만 · 셈에 안 씀) + - 단위가 비어 있는 입력 · 중간 칸의 `단위`. 엔진 열쇠 · 식 · 값은 그대로. -- 채우기만 함: 이미 `변수표` 에 있는 열쇠는 사용자 고침이라 덮지 않음 · 단위가 있으면 그대로. - 판마다 다시 돌려도 같은 결과(두 번째부터 쓸 것 없음). -- 저장 = M01 저장 길(`M01_MasterData_Store.save` — 검사 · 글 모양 유지). `AISLO_MASTER_DIR` 로 사본에 시험. -- `--check` = 쓰지 않고 쓸 것이 남았는지만 봄(남았으면 종료 코드 1). -""" - -from __future__ import annotations - -import copy -import json -import sys -from pathlib import Path - -HERE = Path(__file__).resolve().parent -sys.path.insert(0, str(HERE.parents[2])) -import master_equation as meq # noqa: E402 - -from M01_MasterData import M01_MasterData_Store as st # noqa: E402 - -DATA = HERE / "변수표_796_3.json" -LOOK = ("이름", "기호", "위", "아래") - - -def decisions() -> dict[str, dict[str, dict]]: - return json.loads(DATA.read_text(encoding="utf-8"))["줄"] - - -def plan(files: dict[str, dict], want: dict[str, dict[str, dict]]) -> tuple[list[dict], dict]: - """(저장 묶음, 숫자) — 읽기 전용 · 고친 줄만 담음.""" - left, batch, stat = set(want), [], {"변수표": 0, "단위": 0, "이미있음": 0, "줄": 0} - for name, data in files.items(): - if data.get("그룹") != "로직": - continue - changes = [] - for row in data.get("줄", []): - decided = want.get(row.get("키")) - if not decided: - continue - left.discard(row["키"]) - new, hit = copy.deepcopy(row), False - table = dict(new.get(meq.FIELD) or {}) - specs = {s["이름"]: s for k in ("입력", "중간") for s in new.get(k) or []} - for key, one in decided.items(): - spec = specs.get(key) - if spec is None: - raise SystemExit(f"{row['키']} · 없는 변수 「{key}」") - if key in table: - stat["이미있음"] += 1 - else: - look = {f: one[f] for f in LOOK if one.get(f)} - if look: - table[key] = look - stat["변수표"] += 1 - hit = True - if one.get("단위") and not spec.get("단위"): - spec["단위"] = one["단위"] - stat["단위"] += 1 - hit = True - if not hit: - continue - new[meq.FIELD] = table - seen: dict[ - str, str - ] = {} # 변수 글 겹침 — 키보드 식이 갈리지 않게(화면 저장과 같은 검사) - for v in meq.table(new): - for word in {meq.token(v), v["이름"]}: - if seen.get(word, v["열쇠"]) != v["열쇠"]: - raise SystemExit( - f"{row['키']} · 「{word}」 이 「{seen[word]}」 · 「{v['열쇠']}」 둘에 겹침" - ) - seen.setdefault(word, v["열쇠"]) - changes.append({"op": "edit", "key": row["키"], "row": new}) - stat["줄"] += 1 - if changes: - batch.append({"file": name, "version": st.read(name)[1], "changes": changes}) - if left: - raise SystemExit(f"없는 로직 {sorted(left)[:5]}") - return batch, stat - - -def main() -> None: - files, _ = st.loaded() - batch, stat = plan(files, decisions()) - print( - f"쓸 것 — 줄 {stat['줄']} · 변수표 칸 {stat['변수표']} · 단위 {stat['단위']} · 이미 있음 {stat['이미있음']}" - ) - if "--check" in sys.argv: - raise SystemExit(1 if batch else 0) - if batch: - print(st.save(batch)) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_수식문서_802_2.py b/resources/master_data/scripts/build_수식문서_802_2.py deleted file mode 100644 index bf58cd293..000000000 --- a/resources/master_data/scripts/build_수식문서_802_2.py +++ /dev/null @@ -1,435 +0,0 @@ -# -*- coding: utf-8 -*- -"""옛 M01 로직 → 수식 문서 빌더 + 금액 전수 대조 (PLAN 802-2 · 요구서_664 1 장 3). - - python resources/master_data/scripts/build_수식문서_802_2.py # 변환 · 대조 · 저장 - · 목록 - python resources/master_data/scripts/build_수식문서_802_2.py --check # 다시 돌려 저장본 - · 목록과 같은지 - -- 변환 = `master_doc_convert.convert`(로직마다 · 기본 옵션 = 수식 탭 기본값) -· 셈 = `master_doc_calc.calc`. -- 대조 = 새 계산기 대 옛 엔진(`master_formula.run` → `master_cut.engine`) 노 · 재 · 경 -· 계(돈 아닌 로직 = 결과) - 원 단위 — 기본 옵션 전부 + 옵션 표본(로직마다 고르기 입력의 다른 갈래 하나씩 · 나머지 기본). - 둘 다 못 셈 = 같음(따로 셈). 보정 없음 — 다르면 목록에 까닭. -- 채택된 차이(`ADOPTED`) = 사용자 요구 714-3 「1원 차이는 로직만 맞다면 문제 없음」 — 식 속 단가산출 - 부름 값 = 끝수 뒤(새 계산기 그대로) · 목록에 남기고 저장은 막지 않음. -- 저장 = 같은 것만(요구서_664 1 장 3) — 모든 대조가 같고(채택된 차이 빼고) 부르는 단가산출도 저장되는 문서 · - `resources/master_data/수식문서/수식_<옛 로직 파일 꼬리>.json`(로직 파일마다 - · 옛 로직 JSON 은 안 씀). -- 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약). -- 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`). -- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 · - `손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림. -- 이름표(855 L1) = 로직 줄 `원문번호 · 구분 · 상세구분 · 소유 · 비고 · 개정 · 별칭` → 문서 줄 머리 · - 로직 파일 머리 `원문 · 부문 · 차례` → 문서 파일 머리(`master_doc.tag` · 셈 · 지문 밖 · `--check` 기준). -- 빌더가 짓지 않는 저장본 문서(848-4 · 옛 로직 줄 없는 키 — 화면에서 만든 자체 로직 등) = 지우거나 덮지 않음 · - 제 파일 끝에 그대로(`foreign`) · 실행 · `--check` 때 목록 · `--check` 는 그대로면 같음. -""" - -from __future__ import annotations - -import argparse -import sys -from pathlib import Path - -ROOT = Path(__file__).resolve().parents[3] -for p in (str(ROOT), str(Path(__file__).resolve().parent)): - if p not in sys.path: - sys.path.insert(0, p) - -import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만) -import master_doc as md # noqa: E402 -import master_doc_calc as mc # noqa: E402 -import master_doc_convert as cv # noqa: E402 -import master_doc_cover as mcv # noqa: E402 -import master_doc_link as ml # noqa: E402 -import master_equation as meq # noqa: E402 -import master_formula as mf # noqa: E402 - -LIST = ROOT / "docs/raw/요구_1104/_목록_802-2_변환대조.xlsx" -KEYS = ("노무비", "재료비", "경비", "계") -HEAD = ("로직", "이름", "옵션", "옛", "새", "차이", "까닭") -RAW_SUB = ( - "식 속 단가산출 부름 = 끝수 뒤 값" - "(옛 엔진 = 끝수 전 날 값 · `master_formula.run` 결과를 식에 씀)" -) -# 채택된 차이 — (로직, 옵션) · 요구 714-3 -ADOPTED = {("GC000091", "지역=울산"), ("GC000093", "지역=경북"), ("GC000100", "지역=전북")} - - -def rows_of(files: dict) -> list[tuple[str, dict]]: - """(옛 로직 파일 이름, 로직 줄) — 파일 · 줄 차례.""" - return [ - (name, row) - for name, data in sorted(files.items()) - if data.get("그룹") == "로직" - for row in data.get("줄") or [] - ] - - -def old_answer(whole, row: dict, given: dict): - try: - got = mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given))) - except Exception as e: # 옛 엔진 멈춤도 대조 값 - return f"못 셈 — {e}" - return {"결과": got["결과"]} if "결과" in got else {k: got.get(k) for k in KEYS} - - -def new_answer(links, doc: dict, given: dict | None = None): - got = mc.calc(doc, links, given) - if not got["셈됨"]: - return "못 셈 — " + (" · ".join(m["글"] for m in got["표지"]) or got.get("까닭") or "") - return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS} - - -def cases_of(whole, row: dict) -> list[tuple]: - """(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩.""" - base = meq.given_of(whole, row) - cases = [("", base, None)] - for spec in row.get("입력") or []: - for opt in spec.get("고르기") or []: - if str(opt) != str(base.get(spec["이름"])): - one = {spec["이름"]: opt} - cases.append((f"{spec['이름']}={opt}", {**base, **one}, one)) - return cases - - -def agree(old, new) -> bool: - """대조 같음 — 같은 값 · 둘 다 못 셈.""" - return old == new or (isinstance(old, str) and isinstance(new, str)) - - -def _text(v) -> str: - if isinstance(v, str): - return v - return " · ".join(f"{k} {mc.plain_text(x) if x is not None else '—'}" for k, x in v.items()) - - -def _gap(a, b) -> str: - if isinstance(a, str) or isinstance(b, str): - return "한쪽 못 셈" - return " · ".join( - f"{k} {mc.plain_text((b.get(k) or 0) - (a.get(k) or 0))}" for k in a if a.get(k) != b.get(k) - ) - - -def _uses_raw_sub(doc: dict) -> bool: - """식 줄이 단가산출 부름 기호를 씀(금액 줄 단가가 아닌 자리).""" - subs = { - md.var_id(v) - for v in doc.get("변수") or [] - if (v.get("연결") or {}).get("갈래") == "단가산출" - } - for line in doc.get("식") or []: - try: - if subs & set(md.names(md.parse(line.get("식")))): - return True - except md.DocError: - pass - return False - - -def why(doc: dict, old, new) -> str: - """다름 까닭 — 문서 꼴에서 바로 보이는 것만 · 아니면 「까닭 모름」(시험이 막음).""" - if isinstance(old, str) and not isinstance(new, str): - return f"옛 엔진 멈춤 · 새 계산기 셈 — {old}" - if isinstance(new, str) and not isinstance(old, str): - return f"새 계산기 못 셈 — {new}" - if _uses_raw_sub(doc): - return RAW_SUB + " · 채택(요구 714-3)" - return "까닭 모름" - - -def build(log=print) -> dict: - """변환 · 대조 전부 — {문서, 알림, 파일, 대조, 저장, 요약}.""" - from M01_MasterData import M01_MasterData_Store as m01 - - files, whole = m01.loaded() - items = rows_of(files) - docs, notes, by_file = {}, {}, {} - for name, row in items: - key = str(row["키"]) - docs[key], notes[key] = cv.convert(whole, row) - by_file.setdefault(name, []).append(key) - log(f"변환 {len(docs)}") - links = ml.Links(whole, docs) - runs, both_out = [], 0 - for _, row in items: - key = str(row["키"]) - for label, given, changed in cases_of(whole, row): - old = old_answer(whole, row, given) - new = new_answer(links, docs[key], changed) - same = agree(old, new) - both_out += isinstance(old, str) and isinstance(new, str) - runs.append( - { - "로직": key, - "이름": row.get("이름") or "", - "옵션": label, - "옛": old, - "새": new, - "같음": same, - } - ) - for one in runs: - if not one["같음"]: - one["채택"] = (one["로직"], one["옵션"]) in ADOPTED - one["까닭"] = why(docs[one["로직"]], one["옛"], one["새"]) - keep = _keep(docs, runs) - for one in runs: # 같아도 못 넣는 것 — 부르는 단가산출이 빠짐 - if one["같음"] and one["로직"] not in keep and not one["옵션"]: - one["빠짐"] = "부르는 단가산출이 빠짐 — " + " · ".join( - sorted(_calls(docs[one["로직"]]) - keep) - ) - summary = { - "로직": len(docs), - "기본 같음": sum(1 for x in runs if not x["옵션"] and x["같음"]), - "기본 다름": sum(1 for x in runs if not x["옵션"] and not x["같음"]), - "옵션 표본": sum(1 for x in runs if x["옵션"]), - "옵션 같음": sum(1 for x in runs if x["옵션"] and x["같음"]), - "옵션 다름": sum(1 for x in runs if x["옵션"] and not x["같음"]), - "채택된 차이": sum(1 for x in runs if x.get("채택")), - "둘 다 못 셈": both_out, - "저장": len(keep), - "변환 알림": sum(1 for v in notes.values() if v), - } - log(" · ".join(f"{k} {v}" for k, v in summary.items())) - return { - "문서": docs, - "알림": notes, - "파일": by_file, - "대조": runs, - "저장": keep, - "요약": summary, - "저장본": carried(), - } - - -def carried() -> dict[str, dict]: - """이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}.""" - if not ml.FOLDER.exists(): - return {} - return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)} - - -def hand_kept(result: dict) -> list[str]: - """저장본 그대로 둔 `손고침` 문서 키(저장되는 것만).""" - have = result.get("저장본") or {} - return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"]) - - -def _labels() -> tuple[dict[str, dict], dict[str, dict]]: - """855 L1 이름표 — ({키: 로직 줄}, {로직 파일: 머리 이름표}) · 셈 · 지문 밖.""" - from M01_MasterData import M01_MasterData_Store as m01 - - rows, heads = {}, {} - for name, data in m01.loaded()[0].items(): - if data.get("그룹") == "로직": - heads[name] = {k: data[k] for k in md.FILE_TAGS if k in data} - rows.update({str(r["키"]): r for r in data.get("줄") or []}) - return rows, heads - - -def _out_doc(result: dict, key: str, rows: dict | None = None) -> dict: - """쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서 · - 이름표(855 L1) = 로직 줄 것(`rows` · 없으면 그대로).""" - have = (result.get("저장본") or {}).get(key) - if have and have.get(mcv.HAND): - out = have - elif have and have.get(mcv.COVER): - out = {**result["문서"][key], mcv.COVER: have[mcv.COVER]} - else: - out = result["문서"][key] - row = (rows or {}).get(key) - return md.tag(out, row) if row is not None else out - - -def _calls(doc: dict) -> set[str]: - out = set() - for v in doc.get("변수") or []: - link = v.get("연결") or {} - if link.get("갈래") == "단가산출" and "{" not in str(link.get("키")): - out.add(str(link["키"])) - return out - - -def _keep(docs: dict, runs: list[dict]) -> set[str]: - """저장할 문서 — 모든 대조 같음 + 부르는 단가산출도 저장(닫힘). - 키 구멍 부름은 그 로직 대조로 판정.""" - keep = set(docs) - {x["로직"] for x in runs if not x["같음"] and not x.get("채택")} - while True: - drop = {k for k in keep if not _calls(docs[k]) <= keep} - if not drop: - return keep - keep -= drop - - -def saved_keys() -> set[str]: - """지금 저장본 수식 문서 키.""" - return { - str(d.get("키")) - for p in ml.FOLDER.glob("수식_*.json") - for d in ml.load_file(p).get("줄") or [] - } - - -def foreign(result: dict) -> dict[str, dict]: - """빌더가 짓지 않는 저장본 문서(옛 로직 줄 없는 키) {파일 이름: {머리 · 줄}} — 그대로 둠(848-4).""" - out: dict[str, dict] = {} - for path in sorted(ml.FOLDER.glob("수식_*.json")) if ml.FOLDER.exists() else []: - data = ml.load_file(path) - rows = [d for d in data.get("줄") or [] if str(d.get("키")) not in result["문서"]] - if rows: - out[path.name] = {**{k: v for k, v in data.items() if k != "줄"}, "줄": rows} - return out - - -def foreign_keys(result: dict) -> list[str]: - return sorted(str(d.get("키")) for x in foreign(result).values() for d in x["줄"]) - - -def lost(result: dict) -> list[str]: - """저장본에 있는데 이번 빌드가 저장 밖으로 뺀 문서 — 「키 까닭」(빌더가 조용히 지우지 않게) · - 빌더가 짓지 않는 문서는 그대로 두므로 뺌.""" - why = {} - for one in result["대조"]: - if one["로직"] not in result["저장"]: - why.setdefault(one["로직"], one.get("까닭") or one.get("빠짐") or "") - gone = saved_keys() - result["저장"] - set(foreign_keys(result)) - return [f"{k} {why.get(k) or '저장 밖'}" for k in sorted(gone)] - - -def files_of(result: dict) -> dict[str, str]: - """저장 파일 이름 → 글 · 빌더가 짓지 않는 저장본 문서 = 제 파일 끝에 그대로.""" - bodies = {} - rows, heads = _labels() - for name, keys in result["파일"].items(): - kept = [_out_doc(result, k, rows) for k in keys if k in result["저장"]] - head = heads.get(name) or {} # 855 L1 파일 머리 이름표 - bodies[ml.file_of(name)] = {"그룹": "수식문서", "로직파일": name, **head, "줄": kept} - for file, data in foreign(result).items(): - if file in bodies: - bodies[file]["줄"] += data["줄"] - else: - bodies[file] = data - return {file: ml.dump(body) for file, body in bodies.items()} - - -def table_rows(result: dict) -> list[list[str]]: - rows = [] - for one in result["대조"]: - if one["같음"] and not one.get("빠짐"): - continue - rows.append( - [ - one["로직"], - one["이름"], - one["옵션"] or "기본", - _text(one["옛"]), - _text(one["새"]), - "" if one["같음"] else _gap(one["옛"], one["새"]), - one.get("까닭") or one.get("빠짐") or "", - ] - ) - return rows - - -def write_list(result: dict, path: Path = LIST) -> None: - from openpyxl import Workbook - - book = Workbook() - sheet = book.active - sheet.title = "다름" - sheet.append(list(HEAD)) - for row in table_rows(result): - sheet.append(row) - for col, width in zip("ABCDEFG", (11, 30, 26, 46, 46, 22, 70)): - sheet.column_dimensions[col].width = width - for title, rows in list(_sheets(result).items())[1:]: - sheet = book.create_sheet(title) - for row in rows: - sheet.append(row) - path.parent.mkdir(parents=True, exist_ok=True) - book.save(path) - - -def read_list(path: Path = LIST) -> dict[str, list[list[str]]]: - from openpyxl import load_workbook - - book = load_workbook(path, read_only=True) - out = { - s.title: [ - ["" if c is None else str(c) for c in row] for row in s.iter_rows(values_only=True) - ] - for s in book.worksheets - } - book.close() - return out - - -def _sheets(result: dict) -> dict[str, list[list[str]]]: - notes = [["로직", "알림"]] + [[k, t] for k, v in sorted(result["알림"].items()) for t in v] - both = [["로직", "이름", "옵션", "옛", "새"]] + [ - [x["로직"], x["이름"], x["옵션"] or "기본", x["옛"], x["새"]] - for x in result["대조"] - if isinstance(x["옛"], str) and isinstance(x["새"], str) - ] - return { - "다름": [list(HEAD), *table_rows(result)], - "요약": [[k, str(v)] for k, v in result["요약"].items()], - "둘 다 못 셈": both, - "변환 알림": notes, - } - - -def check(result: dict) -> list[str]: - """저장본 · 목록이 지금 빌드와 같은지 — 다른 것 목록.""" - out = [] - want = files_of(result) - have = {p.name for p in ml.FOLDER.glob("수식_*.json")} - for name in sorted(have - set(want)): - out.append(f"남은 파일 {name}") - for name, text in sorted(want.items()): - path = ml.FOLDER / name - if not path.exists() or path.read_text(encoding="utf-8") != text: - out.append(f"다른 파일 {name}") - if not LIST.exists() or read_list() != _sheets(result): - out.append(f"다른 목록 {LIST.name}") - return out - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) - parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만") - args = parser.parse_args() - result = build() - if hand := hand_kept(result): - print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}") - if own := foreign_keys(result): - print(f"빌더가 짓지 않는 문서 {len(own)} 장 — 저장본 그대로(안 지움): {' · '.join(own)}") - if args.check: - bad = check(result) - for line in bad: - print(line) - print("같음" if not bad else f"다름 {len(bad)}") - return 1 if bad else 0 - if gone := lost(result): - for line in gone: - print(f"저장본에서 빠질 문서 {line}") - print(f"멈춤 — 저장본 문서 {len(gone)} 개가 빠짐(안 씀) · 까닭을 고친 뒤 다시") - return 1 - ml.FOLDER.mkdir(parents=True, exist_ok=True) - want = files_of(result) - for path in ml.FOLDER.glob("수식_*.json"): - if path.name not in want: - path.unlink() - for name, text in want.items(): - (ml.FOLDER / name).write_text(text, encoding="utf-8", newline="\n") - write_list(result) - print(f"저장 {len(want)} 파일 · 목록 {LIST}") - return 0 - - -if __name__ == "__main__": - raise SystemExit(main()) diff --git a/resources/master_data/scripts/build_용도.py b/resources/master_data/scripts/build_용도.py deleted file mode 100644 index 589c33ea5..000000000 --- a/resources/master_data/scripts/build_용도.py +++ /dev/null @@ -1,225 +0,0 @@ -# -*- coding: utf-8 -*- -"""소요량 · 계수 표마다 「용도」(공종 · 대상 · 로직키) 채우기. - -담당: 소요량_*.json · 계수_*.json (읽기+쓰기) · 로직_*.json · 원문 md (읽기만). -다시 돌리면 같은 결과 — 순수 함수 + 정렬. -""" - -import glob -import json -import re -from pathlib import Path - -ROOT = Path(__file__).resolve().parents[3] -MASTER = ROOT / "resources" / "master_data" -ORIG_KS = ROOT / "resources" / "knowledge" / "original" / "원가계산" / "건설공사_표준품셈" / "본문" -ORIG_SR = ROOT / "resources" / "knowledge" / "original" / "원가계산" / "산림_표준품셈" / "본문" - -CODE_RE = re.compile(r"\b([A-Z]{2}\d{6})\b") -HEADING_RE = re.compile(r"^#{2,4}\s+([0-9]+(?:-[0-9]+)*)\.?\s+(.+?)\s*$") -TRAIL_PAREN_RE = re.compile(r"(\s*\([^()]*\))+\s*$") - -_heading_cache = {} - -# 원문번호 절 이름이 표 내용과 안 맞는 예외 — 검증(ref/_검증_기계_용도.md) 반영. -OVERRIDE_공종 = { - "CC000074": "불도저·굴착기", # 8-4-8 은 「[70]기타기계」 절이나 내용은 불도저·굴착기 잡재료 비율 -} - - -def _find_부문_dir(부문): - if not ORIG_KS.exists(): - return None - for d in sorted(ORIG_KS.iterdir()): - if d.is_dir() and d.name.endswith(부문 + "부문"): - return d - return None - - -def _find_장_dir(base, 장): - m = re.match(r"(\d+)", 장 or "") - if not m or not base or not base.exists(): - return None - num = m.group(1).zfill(2) - for d in sorted(base.iterdir()): - if d.is_dir() and d.name.startswith(f"제{num}장"): - return d - return None - - -def _heading_index(folder): - key = str(folder) - if key in _heading_cache: - return _heading_cache[key] - idx = {} - if folder and folder.exists(): - for md in sorted(folder.glob("*.md")): - for line in md.read_text(encoding="utf-8").splitlines(): - m = HEADING_RE.match(line) - if not m: - continue - num, text = m.group(1), m.group(2) - text = TRAIL_PAREN_RE.sub("", text).strip() - idx.setdefault(num, text) - _heading_cache[key] = idx - return idx - - -def resolve_공종(원문, 부문, 장, 원문번호): - if 원문 == "건설품셈": - base = _find_부문_dir(부문 or "") - folder = _find_장_dir(base, 장 or "") - elif 원문 == "산림품셈": - folder = _find_장_dir(ORIG_SR, 장 or "") - else: - folder = None - idx = _heading_index(folder) - num = 원문번호 or "" - parts = num.split("-") - while parts: - cand = "-".join(parts) - if cand in idx: - return idx[cand] - parts = parts[:-1] - return None - - -def _load_names(path, key="이름"): - d = json.load(open(path, encoding="utf-8")) - return set(r[key] for r in d["줄"] if r.get(key)) - - -def load_masters(): - 인력_이름 = _load_names(MASTER / "인력.json") - import master_machine_files as mmf # 기계 = 폴더(826-2) - - 기계_d = mmf.table(MASTER)[0] - 기계_이름 = set() - for r in 기계_d["줄"]: - 기계_이름.add(r["이름"]) - if r.get("상세구분"): - 기계_이름.add(r["상세구분"]) - 재료_이름 = _load_names(MASTER / "재료_품셈재료.json") - return 인력_이름, 기계_이름, 재료_이름 - - -def _strip_spec(key): - return key.split("(", 1)[0].strip() - - -def classify_대상(item, 인력_이름, 기계_이름, 재료_이름): - 대상 = set() - 이름 = item.get("이름", "") - if "할증" in 이름: - 대상.add("할증") - if "환산" in 이름: - 대상.add("환산") - 조건 = item.get("조건") or {} - if 조건: - 대상.add("작업량 조건") - - 값칸 = item.get("값칸") or {} - keys = list(값칸.keys()) - row_vals = set() - for row in item.get("줄") or []: - if isinstance(row, dict): - for v in row.values(): - if isinstance(v, str): - row_vals.add(v) - - candidates = set(keys) | row_vals - for c in candidates: - base = _strip_spec(c) - if c in 인력_이름 or base in 인력_이름: - 대상.add("인력") - elif c in 기계_이름 or base in 기계_이름: - 대상.add("기계") - elif c in 재료_이름 or base in 재료_이름: - 대상.add("재료") - - for k in keys: - if "시공량" in k: - 대상.add("작업량 조건") - - if not 대상: - 대상.add("작업량 조건") - return sorted(대상) - - -def build_로직_index(): - idx = {} - for fp in sorted(glob.glob(str(MASTER / "로직_*.json"))): - d = json.load(open(fp, encoding="utf-8")) - for row in d.get("줄", []): - own = row.get("키") - text = json.dumps(row, ensure_ascii=False) - for code in set(CODE_RE.findall(text)): - if code == own: - continue - idx.setdefault(code, set()).add(own) - return idx - - -def main(): - 인력_이름, 기계_이름, 재료_이름 = load_masters() - 로직_idx = build_로직_index() - - files = sorted(glob.glob(str(MASTER / "소요량_*.json"))) + sorted( - glob.glob(str(MASTER / "계수_*.json")) - ) - - 총_항목 = 0 - 공종_미확인 = [] - - for fp in files: - d = json.load(open(fp, encoding="utf-8")) - 원문 = d.get("원문") - 부문 = d.get("부문") - 용도_map = {} - for item in d.get("표", []): - 총_항목 += 1 - 키 = item["키"] - 장 = item.get("상세구분") - if 키 in OVERRIDE_공종: - 공종 = OVERRIDE_공종[키] - else: - 공종 = resolve_공종(원문, 부문, 장, item.get("원문번호")) - if 공종 is None: - 공종_미확인.append((키, fp, item.get("원문번호"))) - 공종 = item.get("이름", "").split("(", 1)[0].strip() - 대상 = classify_대상(item, 인력_이름, 기계_이름, 재료_이름) - 로직키 = sorted(로직_idx.get(키, [])) - 용도_map[키] = {"공종": 공종, "대상": 대상, "로직키": 로직키} - - text = open(fp, encoding="utf-8").read() - lines = text.split("\n") - out = [] - cur_키 = None - key_re = re.compile(r'"키":\s*"([A-Z]{2}\d{6})"') - src_re = re.compile(r'^(\s*)"출처":\s*".*",\s*$') - old_용도_re = re.compile(r'^\s*"용도":\s*\{.*\},\s*$') - for line in lines: - if old_용도_re.match(line): - continue - m = key_re.search(line) - if m: - cur_키 = m.group(1) - out.append(line) - sm = src_re.match(line) - if sm and cur_키 in 용도_map: - indent = sm.group(1) - payload = json.dumps(용도_map[cur_키], ensure_ascii=False) - out.append(f'{indent}"용도": {payload},') - - new_text = "\n".join(out) - with open(fp, "w", encoding="utf-8") as f: - f.write(new_text) - - print("총 항목:", 총_항목, "/ 공종 미확인:", len(공종_미확인)) - if 공종_미확인: - for 키, fp, 번호 in 공종_미확인[:30]: - print(" 미확인:", 키, 번호, fp) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/build_재료_검색어.py b/resources/master_data/scripts/build_재료_검색어.py deleted file mode 100644 index 134ddbcd5..000000000 --- a/resources/master_data/scripts/build_재료_검색어.py +++ /dev/null @@ -1,370 +0,0 @@ -# -*- coding: utf-8 -*- -"""로직 재료 줄의 자재품목 키를 「기본 검색어」 로 바꿈 (PLAN 8-3 · 계약 8-1). - - · 대표 키 박은 줄 · 대표가 재료 입력(`{철선}`)인 줄 · 조건만 있는 줄 — 요소를 - `{구분, 상세구분, 검색어}` 로. 검색어는 지금 잡히는 품목(자동값)이 8-1 찾기 규칙 · - 자동값 차례로 첫째가 되게 지음(이름 핵심 + 규격 핵심 + 지역 낱말 · 모자라면 낱말을 더함) - · 재료 입력 키 목록(고르기가 자재품목 키인 입력)은 걷음 — 그 입력을 넘기던 `이름=이름` 인자도 - · 지역·계약종별 조건 줄 · 유가전력 틀(`MO:경유:{지역}`)은 그대로 — 자재품목 키가 아님 - · 글 모양 그대로 — 바뀐 값 자리만 갈음 · 다시 돌려도 같은 결과 - -사용: python scripts/build_재료_검색어.py (마른 돌리기 — 파일 안 씀 · 못 맞춘 줄 목록) - python scripts/build_재료_검색어.py --쓰기 (로직 파일 갱신) -""" - -from __future__ import annotations - -import json -import re -import sys -from pathlib import Path - -HERE = Path(__file__).resolve().parent -sys.path.insert(0, str(HERE)) - -import check_master as cm # noqa: E402 -import master_auto as mau # noqa: E402 -import master_formula as mf # noqa: E402 -import master_material as mm # noqa: E402 -import master_pick as mp # noqa: E402 - -MASTER = HERE.parent -KEY = re.compile(r"MT\d{6}") - - -# ── 판정 — 서버 찾기(`master_pick.search`) 그대로 ───────────────────────── -def _has(word: str, row: dict) -> bool: - """`master_pick.search` 와 같은 맞대기 — 낱말이 이름 또는 규격에 듦.""" - w = mm.plain_spec(word) - return w in mm.plain(row.get("이름")).replace("×", "x") or w in mm.plain_spec(row.get("규격")) - - -def found(master: mf.Master, elem: dict, unit: str | None, env: dict) -> list[str]: - return mp.search(master, elem, env, unit) - - -def first(master, elem, unit, env) -> str | None: - got = found(master, elem, unit, env) - return got[0] if got else None - - -# ── 지금 잡히는 품목 ────────────────────────────────────────────────── -def material_inputs(row: dict) -> dict[str, list]: - """고르기가 자재품목 키 목록인 입력 — 걷을 것.""" - return { - s["이름"]: s["고르기"] - for s in row.get("입력", []) - if isinstance(s.get("고르기"), list) - and s["고르기"] - and all(isinstance(x, str) and KEY.fullmatch(x) for x in s["고르기"]) - } - - -def _holes(elem: dict) -> list[str]: - return sorted({h for v in elem.values() if isinstance(v, str) for h in mf._HOLE.findall(v)}) - - -def envs(master: mf.Master, row: dict, elem: dict) -> list[dict]: - """줄을 판정할 입력 벌 — 자동값 하나 · 조건에 끼운 입력은 고르기 값마다.""" - base = mau.values(master, row) - out = [base] - for hole in _holes(elem): - spec = next((s for s in row.get("입력", []) if s["이름"] == hole), {}) - if spec.get("고르기") and hole not in material_inputs(row): - out = [{**e, hole: v} for e in out for v in spec["고르기"]] - return out - - -def old_pick(master: mf.Master, elem: dict, env: dict, unit: str | None) -> str | None: - try: - cond = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in elem.items()} - return mm.pick(master, cond, env, unit) - except mf.FormulaError: - return None - - -# ── 검색어 짓기 ─────────────────────────────────────────────────────── -def _name(v) -> str: - """품명 — 띄어 쓴 한글 글자는 붙임(「골 함 석」) · 쉼표 둘레 빈칸 뗌 · 영문 낱말 사이는 둠.""" - s = re.sub(r"\s*,\s*", ",", str(v or "").strip()) - return re.sub(r"(?<=[가-힣])\s+(?=[가-힣])", "", s) - - -def _root(name: str) -> str: - """이름 핵심 — 빈칸 뗌 · 첫 괄호·쉼표 앞(「박 리 제(중유)」 → 박리제).""" - return re.split(r"[(\[,]", _name(name))[0] - - -def _pieces(spec) -> list[str]: - """규격 조각 — 빈칸·쉼표로 · 괄호 속 쉼표는 안 가름(「저유황(목재,합판용)」).""" - return [p for p in re.split(r"\s+|,(?![^()]*\))", str(spec or "")) if p] - - -def _core(row: dict) -> list[str]: - """이름 핵심(첫 쉼표 앞 · 괄호 그대로 「합판(내수)」) + 규격 핵심(첫 조각 · 「12t×1220×…」 → - 글자 든 첫 토막 12t).""" - name = _name(row.get("이름")).split(",")[0] - pieces = _pieces(row.get("규격")) - spec = "".join(pieces[:2]) if pieces and len(pieces[0]) < 2 else (pieces or [""])[0] - head = re.split(r"[×xX*]", spec)[0] - if head != spec and re.search(r"[^\d.]", head): - spec = head - return [w for w in (name, spec) if w] - - -def _tokens(row: dict) -> list[str]: - """더할 낱말 후보 — 이름 조각(쉼표로) · 이름 괄호 · 규격 조각(쉼표·빈칸·×로).""" - name = _name(row.get("이름")) - parts = [p for p in name.split(",") if p] - out = parts + re.findall(r"\([^()]*\)", name) - pieces = _pieces(row.get("규격")) - out += pieces + [q for p in pieces for q in re.split(r"[×xX*]", p) if q and q != p] - return list(dict.fromkeys(w for w in out if w)) - - -def _place(row: dict) -> str | None: - tail = _name(row.get("이름")).split(",")[-1] - return tail if tail in mp.REGIONS else None - - -def _ok(master, elem, unit, cases) -> bool: - """판정 — 입력 벌마다 서버 찾기 첫째가 지금 품목.""" - for env, want in cases: - filled = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in elem.items()} - if first(master, filled, unit, env) != want: - return False - return True - - -def words_for(master, base: dict, words: list[str], unit, cases) -> list[str] | None: - """모자라면 첫 품목의 낱말을 하나씩 더함 — 앞선 줄을 가장 많이 떨구는 낱말부터.""" - target_rows = {want for _, want in cases} - for _ in range(6): - elem = {**base, "검색어": " ".join(words)} - if _ok(master, elem, unit, cases): - return words - if len(target_rows) != 1 or None in target_rows: - return None # 입력 따라 품목이 갈리는 줄 — 끼운 낱말로만 - want = master.get(next(iter(target_rows))) - env = cases[0][0] - got = found(master, {k: mf.fill(v, env) for k, v in elem.items()}, unit, env) - ahead = got[: got.index(want["키"])] if want["키"] in got else got - pick = None - for w in _tokens(want): - if w in words or not _has(w, want): - continue - cut = sum(not _has(w, master.get(k)) for k in set(ahead)) - if cut and (pick is None or cut > pick[0]): - pick = (cut, w) - if not pick: - return None - words.append(pick[1]) - return None - - -def convert(master: mf.Master, row: dict, item: dict) -> tuple[dict | None, list]: - """재료 줄 하나 → 새 요소 · 판정 벌. 못 맞추면 (None, 벌).""" - elem, unit = item["요소"], item.get("단위") - cases = [] - for env in envs(master, row, elem): - cases.append((env, old_pick(master, elem, env, unit))) - base = {k: elem[k] for k in ("구분", "상세구분") if elem.get(k)} - # 이미 좁혀 둔 이름·규격 낱말은 그대로 검색어로(`{관경}` 같은 끼운 칸도) - words = [w for k in ("이름", "규격") for w in str(elem.get(k) or "").split()] - targets = {want for _, want in cases} - if targets == {None}: - # 지금 같은 단위 후보 0 인 빈 줄 — 후보 단위가 줄 단위와 같은 성격(g ↔ kg 등)일 때만 - # 검색어로(값이 생김 · 금액 바뀜 · 줄마다 보고) · 성격이 다르면 빈칸 그대로 - probe = {**base, "검색어": _root(item.get("이름"))} - got = mp.search(master, probe, mau.values(master, row), unit) - if not got or not mp.same_kind(master.get(got[0])["단위"], unit): - return None, cases - name = _core(master.get(got[0]))[0] - return {**base, "검색어": name}, cases - if len(targets) == 1: - want = master.get(next(iter(targets))) - name, *spec = _core(want) - if not any(mm.plain(w) in mm.plain(name) for w in words): - words.insert(0, name) # 조건 이름 낱말이 이미 품명을 가리키면 그대로 - if spec and not elem.get("규격") and spec[0] not in words: - words.append(spec[0]) - place = _place(want) - if place and place not in words: - words.append(place) - else: - roots = {_root(master.get(t)["이름"]) for t in targets if t} - if ( - len(roots) == 1 - and (root := roots.pop()) - and not any(mm.plain(root) in mm.plain(w) for w in words) - ): - words.insert(0, root) - got = words_for(master, base, list(words), unit, cases) - return ({**base, "검색어": " ".join(got)} if got else None), cases - - -# ── 돌리기 ──────────────────────────────────────────────────────────── -def _targets(item: dict) -> bool: - elem = item.get("요소") - return ( - item.get("종류") == "재료" - and isinstance(elem, dict) - and "검색어" not in elem - and elem.get("지역") != "입력" - and elem.get("계약종별") != "입력" - ) - - -def plan(master: mf.Master, files: dict[str, dict]) -> tuple[dict, list]: - """파일마다 {로직 키: {"요소": {호표 차례: 새 요소}, "걷음": [입력 이름]}} · 못 맞춘 줄.""" - out, misses = {}, [] - for name, data in files.items(): - if not name.startswith("로직_"): - continue - for row in data["줄"]: - elems = {} - for i, item in enumerate(row.get("호표", [])): - if not _targets(item): - continue - elem, cases = convert(master, row, item) - if elem is None: - misses.append((row["키"], i, item.get("이름"), item["요소"], cases)) - else: - elems[i] = elem - gone = list(material_inputs(row)) - if elems or gone: - out.setdefault(name, {})[row["키"]] = {"요소": elems, "걷음": gone} - return out, misses - - -_ARG = r"\s*,\s*{n}\s*=\s*{n}(?=\s*[,)])" -# 걷는 입력을 식에서 품목 키로 쓰던 자리(`MT:{합판}`) — 같은 값의 호표 줄 금액으로 -# (GC000211 소모자재: 줄 금액 = 찾기 수량 × 합판율 × 단가 이므로 합판율을 줄 금액이 품음) -SWAP = { - "(찾기(QC000427).합판 * MT:{합판} + 찾기(QC000427).각재 * MT:{각재}) * 합판율 * ": ( - "(줄.'합판(내수 12㎜)' + 줄.'각재') * " - ), -} - - -def _strip(text: str, names) -> str: - """부르는 식의 `, 철선=철선` 인자를 뗌 · 품목 키 자리는 줄 금액으로.""" - for n in names: - text = re.sub(_ARG.format(n=re.escape(n)), "", text) - for old, new in SWAP.items(): - text = text.replace(old, new) - return text - - -def apply(row: dict, change: dict) -> dict: - """바꿈을 줄 사본에 — 새 요소 · 재료 입력 걷음 · 그 입력을 넘기던 인자 뗌.""" - new = _copy(row) - for i, elem in change["요소"].items(): - new["호표"][i]["요소"] = elem - gone = change["걷음"] - if gone: - new["입력"] = [s for s in new["입력"] if s["이름"] not in gone] - for group in ("중간", "호표", "덧줄"): - for part in new.get(group, []): - for k in ("식", "요소", "수량"): - if isinstance(part.get(k), str): - part[k] = _strip(part[k], gone) - if "결과" in new: - new["결과"]["식"] = _strip(new["결과"]["식"], gone) - return new - - -def _copy(v): - if isinstance(v, dict): - return {k: _copy(x) for k, x in v.items()} - if isinstance(v, list): - return [_copy(x) for x in v] - return v - - -# ── 글 모양 그대로 쓰기 ────────────────────────────────────────────────── -_DEC = json.JSONDecoder() - - -def _skip(text: str, pos: int) -> int: - while text[pos] in " \t\r\n": - pos += 1 - return pos - - -def _items(text: str, pos: int) -> list[tuple[int, int]]: - """`[` 바로 뒤 `pos` 부터 목록 칸마다 (처음, 끝).""" - spans = [] - while text[pos := _skip(text, pos)] != "]": - _, end = _DEC.raw_decode(text, pos) - spans.append((pos, end)) - pos = _skip(text, end) - pos += text[pos] == "," - return spans - - -def _patch_row(text: str, row: dict, change: dict) -> str: - """줄 글 하나 — 바뀐 요소 값 자리 · 걷은 입력 칸 · 뗀 인자만 갈음.""" - spots = [m.end() for m in re.finditer(r'"요소"\s*:\s*', text)] - if len(spots) != len(row.get("호표", [])): - raise ValueError(f"{row['키']} 요소 자리 수가 호표와 다름") - for i in sorted(change["요소"], reverse=True): - at = spots[i] - _, end = _DEC.raw_decode(text, at) - text = text[:at] + json.dumps(change["요소"][i], ensure_ascii=False) + text[end:] - gone = change["걷음"] - if gone: - m = re.search(r'"입력"\s*:\s*\[', text) - spans = _items(text, m.end()) - keep = [text[s:e] for s, e in spans if json.loads(text[s:e]).get("이름") not in gone] - lead, close = text[m.end() : spans[0][0]], _skip(text, spans[-1][1]) - tail = text[spans[-1][1] : close] - body = lead + ("," + lead).join(keep) + tail if keep else "" - text = text[: m.end()] + body + text[close:] - text = re.sub(r'"(?:[^"\\]|\\.)*"', lambda s: _strip(s.group(0), gone), text) - return text - - -def patch(text: str, changes: dict) -> str: - """파일 글 — 바뀐 로직 줄만 손봄.""" - m = re.search(r'"줄"\s*:\s*\[', text) - spans = _items(text, m.end()) - parts, at = [], 0 - for s, e in spans: - row = json.loads(text[s:e]) - if row["키"] in changes: - parts += [text[at:s], _patch_row(text[s:e], row, changes[row["키"]])] - at = e - return "".join(parts) + text[at:] - - -def main(write: bool) -> int: - files = cm.load() - master = mf.Master(files) - changes, misses = plan(master, files) - lines = sum(len(c["요소"]) for rows in changes.values() for c in rows.values()) - inputs = sum(len(c["걷음"]) for rows in changes.values() for c in rows.values()) - for name, rows in changes.items(): - path = MASTER / name - text = path.read_text(encoding="utf-8") - new_text = patch(text, rows) - want = json.loads(text) - want["줄"] = [apply(r, rows[r["키"]]) if r["키"] in rows else r for r in want["줄"]] - if json.loads(new_text) != want: - raise SystemExit(f"{name} 글 갈음이 바꿈과 다름 — 안 씀") - if write: - path.write_text(new_text, encoding="utf-8", newline="\n") - print( - f"검색어로 바꾼 재료 줄 {lines} · 걷은 재료 입력 {inputs} · " - f"로직 {sum(map(len, changes.values()))} · 파일 {len(changes)}" - + ("" if write else " (마른 돌리기)") - ) - for key, i, name, elem, cases in misses: - wants = sorted({str(w) for _, w in cases}) - print(f" 못 맞춤 {key} 호표[{i}] {name} {json.dumps(elem, ensure_ascii=False)} → {wants}") - return 0 - - -if __name__ == "__main__": - sys.stdout.reconfigure(encoding="utf-8") - sys.exit(main("--쓰기" in sys.argv)) diff --git a/resources/master_data/scripts/check_값없는줄.py b/resources/master_data/scripts/check_값없는줄.py deleted file mode 100644 index ce09683c1..000000000 --- a/resources/master_data/scripts/check_값없는줄.py +++ /dev/null @@ -1,120 +0,0 @@ -# -*- coding: utf-8 -*- -"""재료_자재품목.json 다섯 값 칸이 모두 빈 줄 가운데 로직이 실제로 가리키는 줄 — 읽기 전용 분석. - - · 「빈 줄」 = 조달청·물가자료·유통물가·물가정보·거래가격·일반가격 여섯 칸이 모두 없음 - · 「로직이 가리킴」 = 로직 호표 요소가 그 키를 바로 적음 · 재료 고르기 조건(구분·상세구분·규격)의 - 후보 줄 · 대표 줄로 콕 집음 · 품셈재료 연결(문자열 키 · 지역 조건)을 따라간 줄 - · 지역 조건(모래·자갈 등)은 실제 프로젝트 자재지역을 모르므로 지역을 안 가리고 이름·단위만 맞춤 - (후보를 넓게 잡아 「안 쓰임」 판정이 헛짚지 않게) - · 값은 채우지 않음 · 마스터 파일을 고치지 않음 - -돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/check_값없는줄.py -""" - -from __future__ import annotations - -import json -import sys -from pathlib import Path - -HERE = Path(__file__).resolve().parent -MASTER = HERE.parent -sys.path.insert(0, str(HERE)) - -import check_master as cm # noqa: E402 -import master_material as mm # noqa: E402 - -PRICE = (*mm.SLOTS, mm.GOVT) - -# 두 ref 표의 키 목록 — 로직이 지금도 부르는지 다시 잣대질할 때 씀 (`_관리자값_미확보.md`·`_없는_재료.md`) -ADMIN_KEYS = ( - "MP000253 MP000290 MP000293 MP000048 MP000094 MP000216 MP000299 MP000359 " - "MP000023 MP000052 MP000055 MP000060 MP000065 MP000066 MP000070 MP000076 MP000082 " - "MP000095 MP000113 MP000129 MP000134 MP000144 MP000150 MP000169 MP000172 MP000176 " - "MP000177 MP000201 MP000202 MP000209 MP000211 MP000215 MP000218 MP000235 MP000239 " - "MP000241 MP000242 MP000250 MP000269 MP000294 MP000310 MP000314 MP000319 MP000357 " - "MP000363" -).split() -NO_ITEM_KEYS = ( - "MP000012 MP000038 MP000048 MP000052 MP000055 MP000056 MP000057 MP000060 " - "MP000065 MP000070 MP000076 MP000077 MP000078 MP000082 MP000095 MP000096 MP000101 " - "MP000113 MP000129 MP000134 MP000139 MP000144 MP000148 MP000150 MP000169 MP000172 " - "MP000176 MP000177 MP000201 MP000209 MP000210 MP000211 MP000212 MP000213 MP000214 " - "MP000216 MP000218 MP000220 MP000221 MP000223 MP000235 MP000239 MP000240 MP000241 " - "MP000242 MP000250 MP000253 MP000254 MP000255 MP000257 MP000258 MP000259 MP000260 " - "MP000261 MP000262 MP000265 MP000269 MP000271 MP000272 MP000273 MP000274 MP000275 " - "MP000276 MP000280 MP000281 MP000285 MP000286 MP000287 MP000288 MP000290 MP000293 " - "MP000294 MP000295 MP000296 MP000297 MP000298 MP000299 MP000301 MP000302 MP000303 " - "MP000304 MP000305 MP000306 MP000308 MP000309 MP000310 MP000314 MP000315 MP000319 " - "MP000325 MP000326 MP000327 MP000328 MP000330 MP000334 MP000335 MP000336 MP000337 " - "MP000338 MP000340 MP000341 MP000342 MP000343 MP000344 MP000345 MP000349 MP000351 " - "MP000352 MP000353 MP000359 MP000363" -).split() - - -def all_empty(master) -> set[str]: - """MT 다섯 값 칸이 모두 빈 키.""" - return { - key for key, row in master.index.get(mm.MARKET, {}).items() if not mm._offers(master, key) - } - - -def region_reach(master, name, unit) -> set[str]: - """MP 연결이 지역 조건(모래·자갈 등)일 때 이름 뿌리·단위만으로 넓게 잡은 후보.""" - want, need = mm.plain(name), (mm.plain_unit(unit) if unit else "") - return { - key - for root, _, _, u, key in mm._market_index(master) - if root.endswith(want) and (not need or u == need) - } - - -def reached(master) -> tuple[set[str], set[str]]: - """(로직이 가리키는 MT 키, 로직이 지금도 문자열로 부르는 MP 키).""" - mt_hit: set[str] = set() - mp_hit: set[str] = set() - for path in sorted(MASTER.glob("로직_*.json")): - rows = json.loads(path.read_text(encoding="utf-8")).get("줄", []) - for row in rows: - for h in row.get("호표") or []: - e, unit = h.get("요소"), h.get("단위") - if isinstance(e, str) and e[:2] == mm.MARKET: - mt_hit.add(e) - elif isinstance(e, dict) and "구분" in e: - mt_hit.update(mm.candidates(master, e, None, unit)) - if e.get("대표"): - mt_hit.add(str(e["대표"])) - elif isinstance(e, str) and e[:2] == mm.LINKED: - mp_hit.add(e) - link = master.index.get(mm.LINKED, {}).get(e, {}).get("연결") - if isinstance(link, str) and link[:2] == mm.MARKET: - mt_hit.add(link) - elif isinstance(link, dict) and "계약종별" not in link: - mrow = master.index[mm.LINKED][e] - mt_hit.update(region_reach(master, link.get("이름"), mrow.get("단위"))) - return mt_hit, mp_hit - - -def main() -> int: - master = cm.master() - empty = all_empty(master) - mt_hit, mp_hit = reached(master) - gap = sorted(empty & mt_hit) - print(f"MT 줄 {len(master.index.get(mm.MARKET, {}))}") - print(f"다섯 칸 모두 빈 줄 {len(empty)} · 그 가운데 로직이 가리키는 줄 {len(gap)}") - for key in gap: - row = master.get(key) - print(f" {key} {row.get('이름')} ({row.get('구분')}·{row.get('상세구분')})") - print(f"\n로직이 지금도 MP 키를 문자열로 부르는 곳 {len(mp_hit)}") - for title, keys in ( - ("_관리자값_미확보.md 45종", ADMIN_KEYS), - ("_없는_재료.md 111줄", NO_ITEM_KEYS), - ): - unused = [k for k in keys if k not in mp_hit] - print(f"{title} 가운데 로직이 이제 안 씀 {len(unused)} — {unused}") - return 0 - - -if __name__ == "__main__": - sys.stdout.reconfigure(encoding="utf-8") - sys.exit(main()) diff --git a/resources/master_data/scripts/master_doc_convert.py b/resources/master_data/scripts/master_doc_convert.py deleted file mode 100644 index d94fd8581..000000000 --- a/resources/master_data/scripts/master_doc_convert.py +++ /dev/null @@ -1,649 +0,0 @@ -# -*- coding: utf-8 -*- -"""옛 M01 로직 줄 → 수식 문서 변환 (PLAN 802-2 · 요구서_664 1 장 3 · 꼴 `_수식문서_틀.md`). - -빌더 `build_수식문서_802_2.py` 가 부름 · 다시 돌리면 같은 결과. -- 기호 = 800-1 · 800-5 기호(수식 탭이 보이는 것 -· `master_equation.export` + `master_equation_sign.settle`) · - 못 내보내는 로직은 같은 규칙(`master_symbol`)으로 · 한 문서 안 겹침 = 아래첨자 끝 숫자. -- 입력 = 선택(고르기) · 입력 · 값 = 기본 옵션(`master_equation.given_of`) · 중간 = 식 줄 -· 한 마디 중간 - (표 찾기 · 요소 · 로직 부름 하나) = 그 기호에 바로 연결 · 표 찾기 · 요소 - · 로직 부름 = 기호 + 연결. -- 호표 = 금액 줄(수량 × 단가 · 단가 = 요소 · 재료 고르기 · 단가산출 묶음) -· 덧줄 = 금액 줄(단가 = 식) · - `줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 결과 · 표시 = 식 안 반올림 - · 금액 끝수 = 문서 `끝수`. -- 변수 단위 = 끝에 `master_doc_unit.fill`(845-1 · 빈 단위를 원본 · 식 셈 · 금액 줄 역산으로) - · 앞뒤 `master_doc_unit_rule`(847-2 · 일당 /일 · 기계 기준 글 · 금액 줄 표기). -옛 엔진 셈은 안 함(기호 · 이름 보기만 export 를 씀). -""" - -from __future__ import annotations - -import re -from decimal import Decimal - -import master_doc as md -import master_doc_unit as mdu -import master_doc_unit_rule as mdr -import master_equation as meq -import master_equation_edit as mee -import master_equation_sign as mes -import master_formula as mf -import master_material as mm -import master_symbol as msym - -_ERR = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, IndexError) -SUBMAX = msym.SUBMAX - - -def _harvest(master, key: str) -> dict: - """수식 탭 내보내기 기호 — (꼴, 갈래, 식 | 열쇠) → 마디 · 못 내보내면 빈 것.""" - try: - ex = mes.settle(meq.export(master, key)) - except _ERR: - return {} - out: dict = {} - - def visit(t): - if isinstance(t, list): - for x in t: - visit(x) - elif isinstance(t, dict): - if t.get("꼴") in ("변수", "블록"): - out.setdefault((t["꼴"], t.get("갈래"), str(t.get("식") or t.get("열쇠"))), t) - for k, v in t.items(): - if k != "나무" and isinstance(v, (dict, list)): - visit(v) - - for line in ex.get("줄") or []: - visit(line.get("이름식")) - if isinstance(line.get("결과"), dict): - head = line["결과"] - out.setdefault(("머리", line.get("갈래"), str(head.get("열쇠"))), head) - return out - - -_CODE = re.compile(r"^(?:EQ|MT|LB)\d") - - -def res_low(master, link: dict, low: str) -> str: - """요소 키가 아래첨자로 샌 것(`k_EQ0006` · 804-7 · 요구 687-18) → 자원 이름 끝 낱말(`k_하베스터`) · - 괄호 · 쉼표 뒤 · 숫자로 시작하는 규격 낱말 뺌 · 겹침은 부른 쪽이 2 · 3.""" - if not _CODE.match(low or "") or (link or {}).get("갈래") != "요소": - return low - try: - row = master.get(str(link.get("키") or "")) - except _ERR: - return low - name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0] - words = [w for w in name.split() if not w[:1].isdigit()] - got = msym.short(words[-1]) if words else "" - return got if got and got != "·" else low - - -def _clean(text: str) -> str: - """기호 · 첨자 글 다듬기 — 낱말 아닌 글 뺌.""" - return re.sub(r"[^\w′'·]|_", "", str(text or "")) - - -class _Reg: - """기호 자리 — 열쇠마다 (기호, 아래, 위) 제안 → 겹침 없는 이름.""" - - def __init__(self): - self.props: dict[tuple, tuple[str, str, str]] = {} - self.ids: dict[tuple, str] = {} - self.used: set[str] = set() - self.notes: list[str] = [] - - def want(self, key: tuple, parts: tuple[str, str, str]) -> None: - self.props.setdefault(key, parts) - - def settle(self) -> None: - for key, (sign, low, up) in self.props.items(): - if key in self.ids: - continue - if not md.good_id(md.sym_id(sign, "", "")): - fixed = _clean(sign) - fixed = fixed if fixed and md.good_id(fixed) else "X" - self.notes.append(f"기호 「{sign}」 → 「{fixed}」") - sign = fixed - n, base = 1, low - while md.sym_id(sign, low, up) in self.used or not md.good_id(md.sym_id(sign, low, up)): - n += 1 - low = (base or "")[: SUBMAX - len(str(n))] + str(n) - if n > 99: - raise ValueError(f"기호 못 가름 {key}") - self.used.add(md.sym_id(sign, low, up)) - self.ids[key] = md.sym_id(sign, low, up) - - def id(self, key: tuple) -> str: - return self.ids.get(key, "?") - - -class _Conv: - def __init__(self, master, row: dict, given: dict): - self.master, self.row, self.given = master, row, given - self.key = str(row["키"]) - self.found = _harvest(master, self.key) - self.table = {v["열쇠"]: v for v in meq.table(row, master)} - self.reg = _Reg() - self.links: dict[tuple, dict] = {} # 열쇠 → 변수 칸(이름 · 단위 · 연결) - self.order: list[tuple] = [] - self.alias: dict[str, tuple] = {} # 한 마디 중간 식 → ('중간', 이름) - self.names = {s["이름"] for s in row.get("입력") or []} | { - s["이름"] for s in row.get("중간") or [] - } - self.kinds = {s["이름"]: "입력" for s in row.get("입력") or []} - self.kinds |= {s["이름"]: "중간" for s in row.get("중간") or []} - self.notes: list[str] = [] - self.used_lines: set[tuple] = set() # 식이 부른 금액 줄 — ('합' | '덧', 이름) - self.quiet = "" # 한 마디 중간 연결만 뜰 때(그 마디 식) — 기호 자리 안 잡음 - self.last: dict = {} - - # 기호 제안 - def _look(self, kind: str, raw: str) -> dict | None: - for k in (("변수", kind, raw), ("블록", None, raw), ("변수", "요소", raw)): - if k in self.found: - return self.found[k] - return None - - def _var(self, key: tuple, family: str, raw: str, name: str, link: dict, unit: str = "") -> str: - if self.quiet and self.quiet == raw: - self.quiet, self.last = "", link - return "?" - if key not in self.links: - node = self._look(family, raw) or {} - sign = str(node.get("기호") or "") - if sign and node.get("기호") != node.get("열쇠"): - parts = _merge(sign, str(node.get("아래") or ""), str(node.get("위") or "")) - else: - fam = {"블록": "결과"}.get(family, family) - parts = msym.lookup(name or raw, fam if fam in msym.FAMILY else "요소") - parts = (parts[0], res_low(self.master, link, parts[1]), parts[2]) - self.reg.want(key, parts) - self.order.append(key) - label = str(node.get("이름") or name or raw) - self.links[key] = { - "이름": label, - "단위": str(node.get("단위") or unit or ""), - "연결": link, - } - self.links[key]["연결"] = link # 두 번째 돌이 = 겹침 가른 이름으로 쓴 연결 - return self.reg.id(key) - - def own(self, name: str) -> str: - """입력 · 중간 이름 → 기호.""" - if name not in self.names: - self.notes.append(f"모르는 이름 「{name}」") - return name if md.good_id(name) else "X_" + _clean(name) - return self.reg.id((self.kinds[name], name)) - - def holes(self, text): - if not isinstance(text, str): - return text - return md.HOLE.sub(lambda m: "{" + self.own(m.group(1)) + "}", text) - - def _place(self) -> dict: - out = {} - if mm.REGION in self.kinds: - out["지역"] = self.own(mm.REGION) - if mm.TARIFF in self.kinds: - out["계약종별"] = self.own(mm.TARIFF) - return out - - # 식 - def emit(self, node, money: dict | None = None): - kind = node[0] - if kind in ("num", "str"): - return node - if kind == "name": - name = node[1] - if money is not None and name in md.COSTS: - return ("var", name) - if money is not None and name in money: - self.used_lines.add(money[name]) - return ("var", self.reg.id(money[name])) - return ("var", self.own(name)) - if kind == "ref": - return ("var", self.element(node[1])) - if kind == "neg": - return ("neg", self.emit(node[1], money)) - if kind == "bin": - return ("bin", node[1], self.emit(node[2], money), self.emit(node[3], money)) - if kind == "call": - return ("call", node[1], [self.emit(x, money) for x in node[2]]) - if kind == "find": - return ("var", self.find(node, None)) - if kind == "logic": - return ("var", self.block(node, None)) - base, col = node[1], node[2] - if base[0] == "find": - return ("var", self.find(base, col)) - if base[0] == "logic": - return ("var", self.block(base, col)) - if base[0] == "ref": - return ("var", self.element(base[1], col)) - if base[0] == "name" and base[1] == "줄" and money is not None: - self.used_lines.add(("합", col)) - return ("var", self.reg.id(("합", col))) - if base[0] == "field" and base[1][0] == "name" and base[1][1] in ("번지", "단계"): - return ("field", ("field", ("var", base[1][1]), base[2]), col) - return ("field", self.emit(base, money), col) - - def text(self, raw, money: dict | None = None) -> str: - return md.text_of(self.emit(mf.parse(raw), money)) - - # 연결 마디 - def find(self, node, col) -> str: - raw = mee.raw_text(node if col is None else ("field", node, col)) - if raw in self.alias: - return self.reg.id(self.alias[raw]) - link = {"갈래": "표", "표": self.holes(node[1])} - link["조건"] = {k: md.text_of(self.emit(v)) for k, v in node[2]} - if col is None: - self.notes.append(f"칸 없는 찾기 「{raw}」") - else: - link["칸"] = col - return self._var(("찾기", raw), "찾기", raw, col or raw, link) - - def block(self, node, col) -> str: - raw = mee.raw_text(node if col is None else ("field", node, col)) - if raw in self.alias: - return self.reg.id(self.alias[raw]) - link = {"갈래": "단가산출", "키": self.holes(node[1])} - link["입력"] = {k: md.text_of(self.emit(v)) for k, v in node[2]} - if col is not None: - link["칸"] = col - try: - sub = self.master.logic(mf.fill(node[1], {})) if "{" not in node[1] else {} - except _ERR: - sub = {} - unit = str(sub.get("결과단위") or "") - return self._var(("블록", raw), "블록", raw, str(sub.get("이름") or node[1]), link, unit) - - def element(self, ref: str, col: str | None = None, unit: str | None = None) -> str: - raw = ref if col is None else mee.raw_text(("field", ("ref", ref), col)) - if raw in self.alias and unit is None: - return self.reg.id(self.alias[raw]) - link = {"갈래": "요소", "키": self.holes(ref)} - if col is not None: - link["칸"] = col - if unit is not None: - link["단위"] = unit - link |= self._place() - try: - label = self.master.label(ref) if "{" not in ref else ref - except _ERR: - label = ref - return self._var(("요소", raw, unit), "요소", raw, label, link) - - def material(self, at: int, item: dict) -> str: - cond = {k: self.holes(v) for k, v in item["요소"].items()} - link = {"갈래": "요소", "재료": cond, "단위": item.get("단위") or ""} | self._place() - name = str(item.get("이름") or "") - return self._var(("재료", at), "요소", f"단가:{name}", f"{name}단가", link) - - def lone(self, raw: str): - """한 마디 식(표 찾기 · 요소 · 로직 부름 하나) — 마디 · 아니면 None.""" - try: - node = mf.parse(raw) - except mf.FormulaError: - return None - if node[0] in ("ref", "logic"): - return node - if node[0] == "field" and node[1][0] in ("find", "logic", "ref"): - return node - return None - - -def _merge(sign: str, low: str, up: str) -> tuple[str, str, str]: - """기호 칸에 첨자까지 든 것(「t_1」 · 「C_m」)을 가름.""" - if "_" in sign or "^" in sign: - head, low0, up0 = md.split_id(sign) - if head != sign: - return head, low0 + low, up or up0 - return sign, low, up - - -def _parts(var: dict) -> tuple[str, str, str]: - return _merge( - str(var.get("기호") or var["열쇠"]), str(var.get("아래") or ""), str(var.get("위") or "") - ) - - -def _line_parts(c: _Conv, name: str) -> tuple[str, str, str]: - head = c.found.get(("머리", "호표", name)) or c.found.get(("머리", "덧줄", name)) or {} - if head.get("기호") and head.get("기호") != name: - return str(head["기호"]), str(head.get("아래") or ""), str(head.get("위") or "") - return msym.lookup(name, "합") - - -def convert(master, row: dict, given: dict | None = None) -> tuple[dict, list[str]]: - """로직 줄 → (수식 문서, 알림). given = 기본 옵션(없으면 `given_of`).""" - given = meq.given_of(master, row) if given is None else given - c = _Conv(master, row, given) - for spec in row.get("입력") or []: - c.reg.want( - ("입력", spec["이름"]), _parts(c.table.get(spec["이름"], {"열쇠": spec["이름"]})) - ) - for step in row.get("중간") or []: - c.reg.want( - ("중간", step["이름"]), _parts(c.table.get(step["이름"], {"열쇠": step["이름"]})) - ) - for item in row.get("호표") or []: - c.reg.want(("합", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or ""))) - for item in row.get("덧줄") or []: - c.reg.want(("덧", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or ""))) - lone_steps = {} - for step in row.get("중간") or []: - node = c.lone(step["식"]) - if node is not None and step.get("표시") is None: - raw = mee.raw_text(node) - if raw not in c.alias: - c.alias[raw] = ("중간", step["이름"]) - lone_steps[step["이름"]] = node - doc = None - for _ in range(2): # 한 번 = 기호 모음 · 두 번 = 겹침 가른 이름으로 글 - c.reg.settle() - doc = _build(c, row, given, lone_steps) - c.notes += c.reg.notes - doc = slim_doc(doc) - if hasattr(master, "numbers"): # 빌더 · 실행 중 변환 한 벌 — 변수 단위 채움(845-1) - mdr.before(doc, master) # 847-2 일당 /일 · 기계 기준 글 - mdu.fill(doc, master) - mdr.after(doc) # 847-2 금액 줄 kg · L 표기 - return doc, sorted(set(c.notes)) - - -def _is(node, value) -> bool: - return node[0] == "num" and node[1] == value - - -def slim(node): - """옮김 군더더기 걷기(802-3) — `+ 0` · `- 0` · `× 1` · `÷ 1` 지움 · `A × k ÷ 100` → `A × k%`(값 같음).""" - kind = node[0] - if kind == "bin": - op, a, b = node[1], node[2], node[3] - if op == "/" and _is(b, 100) and a[0] == "bin" and a[1] == "*" and a[3][0] == "num": - return ("bin", "*", slim(a[2]), ("pct", a[3])) - a, b = slim(a), slim(b) - if (op in ("+", "-") and _is(b, 0)) or (op in ("*", "/") and _is(b, 1)): - return a - if (op == "+" and _is(a, 0)) or (op == "*" and _is(a, 1)): - return b - return ("bin", op, a, b) - if kind in ("neg", "pct"): - return (kind, slim(node[1])) - if kind == "field": - return ("field", slim(node[1]), node[2]) - if kind == "call": - return ("call", node[1], [slim(x) for x in node[2]]) - return node - - -def _slim_text(text): - if not isinstance(text, str) or not text.strip(): - return text - try: - return md.text_of(slim(md.parse(text))) - except md.DocError: - return text - - -def slim_doc(doc: dict) -> dict: - """식 줄 · 금액 줄(수량 · 단가) 글에 `slim`.""" - for line in doc.get("식") or []: - line["식"] = _slim_text(line.get("식")) - for line in doc.get("금액") or []: - for k in ("수량", "단가"): - if k in line: - line[k] = _slim_text(line[k]) - return doc - - -def _link_of(c: _Conv, node) -> dict: - """한 마디 중간의 연결 — 찾기 · 요소 · 로직 부름.""" - alias = dict(c.alias) - c.alias, c.quiet, c.last = {}, mee.raw_text(node), {} - try: - c.emit(node) - return dict(c.last) - finally: - c.alias, c.quiet = alias, "" - - -def _build(c: _Conv, row: dict, given: dict, lone_steps: dict) -> dict: - variables: list[dict] = [] - for spec in row.get("입력") or []: - name = spec["이름"] - look = c.table.get(name, {}) - value = given.get(name) - if isinstance(value, (int, float)) and not isinstance(value, bool): - value = Decimal(str(value)) - if "고르기" in spec: - link = {"갈래": "선택", "목록": list(spec["고르기"]), "값": value} - else: - link = {"갈래": "입력", "값": value} - if spec.get("범위"): - link["범위"] = list(spec["범위"]) - variables.append(_var_row(c.reg.id(("입력", name)), name, look, spec, link)) - lines: list[dict] = [] - for step in row.get("중간") or []: - name = step["이름"] - look = c.table.get(name, {}) - me = c.reg.id(("중간", name)) - if name in lone_steps: - variables.append(_var_row(me, name, look, step, _link_of(c, lone_steps[name]))) - continue - try: - text = c.text(step["식"]) - except mf.FormulaError as e: - c.notes.append(f"중간 「{name}」 식 못 읽음 — {e}") - text = str(step["식"]) - if step.get("표시") is not None: - text = f"반올림({text}, {int(step['표시'])})" - variables.append(_var_row(me, name, look, step, {"갈래": "식"})) - lines.append({"기호": me, "식": text}) - doc = { - "꼴": "수식문서", - "판": 1, - "키": c.key, - "이름": row.get("이름") or "", - "결과단위": row.get("결과단위") or "", - "출처": row.get("출처") or "", - **({"부품": row["부품"]} if row.get("부품") else {}), # 813-2 부품 표지 - } - money: list[dict] = [] - if "결과" in row: - head = c.found.get(("머리", "결과", "결과")) or {} - sign = head.get("기호") if msym.is_symbol(str(head.get("기호") or "")) else "" - parts = (sign, str(head.get("아래") or ""), str(head.get("위") or "")) if sign else None - parts = parts or msym.rule(str(row.get("결과단위") or ""), "결과")[:3] - c.reg.want(("결과", "결과"), parts) - text = c.text(row["결과"]["식"]) - rule = row.get("끝수") - if isinstance(rule, dict) and rule.get("대상") == "결과": - text = f"{rule['방법']}({text}, {int(rule.get('자리') or 0)})" - me = c.reg.id(("결과", "결과")) - variables.append( - { - "열쇠": "결과", - **_split(me), - "이름": "결과", - "단위": row.get("결과단위") or "", - "연결": {"갈래": "식"}, - } - ) - lines.append({"기호": me, "식": text}) - doc["결과"] = me - else: - money = _money(c, row) - for key in c.order: - if key[0] in ("입력", "중간") or key in [("결과", "결과")]: - continue - if any(alias == key for alias in c.alias.values()): - continue - one = c.links[key] - me = c.reg.id(key) - variables.append( - { - "열쇠": me, - **_split(me), - "이름": one["이름"], - "단위": one["단위"], - "연결": one["연결"], - } - ) - doc |= {"변수": variables, "식": lines, "금액": money} - cut = {k: (dict(v) if isinstance(v, dict) else v) for k, v in md.CUT.items()} - rule = row.get("끝수") - if isinstance(rule, dict) and rule.get("대상") == "계": - cut["계"] = {"방법": rule["방법"], "자리": int(rule.get("자리") or 0)} - if row.get("끝전"): - cut["끝전"] = row["끝전"] - doc["끝수"] = cut - for k in ("단계", "조정"): - if row.get(k): - doc[k] = row[k] - return doc - - -def _split(me: str) -> dict: - sign, low, up = md.split_id(me) - return {"기호": sign, "아래": low, "위": up} - - -def _var_row(me: str, name: str, look: dict, spec: dict, link: dict) -> dict: - out = { - "열쇠": name, - **_split(me), - "이름": look.get("이름") or name, - "단위": spec.get("단위") or "", - } - for k in ("설명", "출처"): - if spec.get(k): - out[k] = spec[k] - out["연결"] = link - return out - - -def _hand(c: _Conv, at: int, item: dict) -> str: - """손 값 줄 — 값묶음(노 · 재 · 경) 또는 손 단가 = 숫자 연결.""" - name = str(item.get("이름") or "") - given = item.get("값묶음") - if given: - if set(given) < set(md.COSTS): - c.notes.append(f"호표 「{name}」 값묶음 일부 — 빠진 비목 0") - value = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS} - else: - value = Decimal(str(item["단가"])) - link = {"갈래": "숫자", "값": value} - return c._var(("손", at), "요소", f"단가:{name}", f"{name}단가", link) - - -def _group_name(items: list[dict]) -> str: - kinds = [] - for x in items: - k = x.get("종류") or str(x.get("이름") or "") - if k not in kinds: - kinds.append(k) - return " · ".join(kinds) - - -def _money(c: _Conv, row: dict) -> list[dict]: - items, adds = row.get("호표") or [], row.get("덧줄") or [] - out: list[dict] = [] - for at, item in enumerate(items): - name = str(item.get("이름") or "") - line = {"이름": name} - if item.get("규격"): - line["규격"] = item["규격"] - line["단위"] = item.get("단위") or "" - try: - qty = c.text(item["수량"]) - except mf.FormulaError as e: - c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}") - qty = str(item["수량"]) - kind = item.get("종류") - if item.get("값묶음") or item.get("단가") is not None: # M02 손 값(값묶음 · 손 단가) - price, line["비목"] = _hand(c, at, item), item.get("비목") or "묶음" - if line["비목"] != "묶음" and item.get("값묶음"): - price = f"{price}.계" - elif kind == "로직": - node = mf.parse(str(item["요소"])) - price = md.text_of(c.emit(node)) - bundle = node[0] == "logic" - if "비목" in item: - line["비목"] = item["비목"] - if bundle: - price = f"{price}.계" - else: - line["비목"] = "묶음" - elif isinstance(item.get("요소"), dict): - line["비목"] = item["비목"] - price = c.material(at, item) - else: - line["비목"] = item["비목"] - ref = str( - item["요소"] - ) # 품셈재료(MP)만 줄 단위로 값이 갈림 — 그 밖은 식 속 요소와 한 기호 - price = c.element( - ref, None, str(item.get("단위") or "") if ref[:2] == mm.LINKED else None - ) - line |= {"수량": qty, "단가": price} - for k in ( - "번지", - "합밖", - "자리", - "출처", - "부착", - ): # 부착 = 같은 묶음 주 기계 줄을 따름(848-4) - if k in item: - line[k] = item[k] - out.append(line) - seen: dict[str, tuple] = {} - for add in adds: - name = str(add.get("이름") or "") - try: - price = c.text(add["식"], dict(seen)) - except mf.FormulaError as e: - c.notes.append(f"덧줄 「{name}」 식 못 읽음 — {e}") - price = str(add["식"]) - line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price} - for k in ("번지", "합밖", "자리", "출처"): - if k in add: - line[k] = add[k] - out.append(line) - seen[name] = ("덧", name) - last = { - str(x.get("이름") or ""): i for i, x in enumerate(items) - } # 같은 이름 = 뒤 줄(옛 `줄` 묶음) - for i, line in enumerate(out): - key = ("합", line["이름"]) if i < len(items) else ("덧", line["이름"]) - if key in c.used_lines and (i >= len(items) or last[line["이름"]] == i): - line["기호"] = c.reg.id(key) - _groups(out, [*items, *adds]) - return out - - -def _groups(out: list[dict], items: list[dict]) -> None: - """묶음 — 단가산출 부름 줄마다 한 묶음 · 그 사이 다른 줄은 이어진 것끼리 · 묶음 하나면 안 둠 · - 호표 `묶음`(848-4 · 기계 한 대 = 줄 하나) = 그 제목 · 이어진 같은 제목 부름 줄은 한 묶음.""" - runs: list[tuple[str, list[int]]] = [] - for i, item in enumerate(items): - title = str(item.get("묶음") or "") - if item.get("종류") == "로직" and title and runs and runs[-1][0] == title: - runs[-1][1].append(i) - elif item.get("종류") == "로직": - runs.append((title or str(item.get("이름") or ""), [i])) - elif runs and runs[-1][0] == "" and items[runs[-1][1][-1]].get("종류") != "로직": - runs[-1][1].append(i) - else: - runs.append(("", [i])) - if len(runs) < 2: - return - for name, members in runs: - label = name or _group_name([items[i] for i in members]) - for i in members: - out[i]["묶음"] = label diff --git a/resources/master_data/scripts/master_doc_unit_rule.py b/resources/master_data/scripts/master_doc_unit_rule.py index a31793ec2..2e02a4e5e 100644 --- a/resources/master_data/scripts/master_doc_unit_rule.py +++ b/resources/master_data/scripts/master_doc_unit_rule.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- """수식 문서 단위 채움 더함 (PLAN 847-2 · 요구 884). -변환(`master_doc_convert`)이 `master_doc_unit.fill` 앞뒤로 부름. +불러오기 문서 짓기(`M02_San_ToDoc`)가 `master_doc_unit.fill` 앞뒤로 부름. - `before` (채움 앞 — 식 셈이 새 단위로 셈): ㉠ 일당 시공량 — 표 기준이 하루(「일당」 · 「1일」 · 「1대 1일당」 …)인 표의 수량 칸 diff --git a/resources/master_data/scripts/로직_복잡도_재기.py b/resources/master_data/scripts/로직_복잡도_재기.py deleted file mode 100644 index 662f6e9f1..000000000 --- a/resources/master_data/scripts/로직_복잡도_재기.py +++ /dev/null @@ -1,53 +0,0 @@ -"""산림품셈 로직 복잡도 재기 — 입력 수 · 표 찾기 수 · 로직 부르기 · 덧줄 · 재료 가짓수. - -사용: python resources/master_data/scripts/로직_복잡도_재기.py [상위 N] -점수 = 입력 + 찾기 + 로직부르기*2 + 덧줄 + 재료 (읽기 전용 · 아무것도 안 씀) -""" - -import json -import re -import sys -from pathlib import Path - -ROOT = Path(__file__).resolve().parents[1] -FIND = re.compile(r"찾기\(") -CALL = re.compile(r"로직\(") - - -def measure(row: dict) -> dict: - ho = row.get("호표") or [] - text = " ".join(str(h.get("수량", "")) + str(h.get("요소", "")) for h in ho) - text += " ".join(str(m.get("식", "")) for m in row.get("중간") or []) - text += " ".join(str(m.get("식", "")) for m in row.get("덧줄") or []) - m = { - "입력": len(row.get("입력") or []), - "찾기": len(FIND.findall(text)), - "로직": len(CALL.findall(text)), - "덧줄": len(row.get("덧줄") or []), - "재료": sum(1 for h in ho if h.get("종류") == "재료"), - } - m["점수"] = m["입력"] + m["찾기"] + m["로직"] * 2 + m["덧줄"] + m["재료"] - return m - - -def main() -> None: - top = int(sys.argv[1]) if len(sys.argv) > 1 else 25 - out = [] - for f in sorted(ROOT.glob("로직_산림품셈_*.json")): - for row in json.loads(f.read_text(encoding="utf-8"))["줄"]: - out.append( - {"키": row["키"], "번호": row["원문번호"], "이름": row["이름"], **measure(row)} - ) - out.sort(key=lambda r: -r["점수"]) - for r in out[:top]: - print( - r["키"], - r["번호"], - r["이름"], - {k: r[k] for k in ("입력", "찾기", "로직", "덧줄", "재료", "점수")}, - ) - print("총", len(out)) - - -if __name__ == "__main__": - main() diff --git a/resources/master_data/scripts/변수표_796_3.json b/resources/master_data/scripts/변수표_796_3.json deleted file mode 100644 index 1e35fce60..000000000 --- a/resources/master_data/scripts/변수표_796_3.json +++ /dev/null @@ -1,844 +0,0 @@ -{ -"판": "796-3", -"줄": { -"GC000088": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000089": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000090": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000169": { - "t1": {"기호": "t", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "T": {"이름": "작업소요시간", "근거": "표 라벨/출처 「T(작업소요시간)」", "확신": "원문"} -}, -"GC000176": { - "t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "T": {"이름": "작업소요시간", "근거": "표 라벨/출처 「T(작업소요시간)」", "확신": "원문"} -}, -"GC000178": { - "T": {"이름": "천공시간", "근거": "표 라벨/출처 「T(천공시간)」", "확신": "원문"} -}, -"GC000183": { - "T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000185": { - "t1": {"이름": "준비 및 이동시간", "기호": "t", "아래": "1", "단위": "초", "근거": "건설품셈 공통 5-2-3 「t_1 : 준비 및 이동시간(sec)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "건설품셈 공통 5-2-3 「cm : 1회 싸이클 타임(sec)」", "확신": "원문"}, - "Q": {"이름": "시간당 작업량", "단위": "m/hr", "근거": "건설품셈 공통 5-2-3 「Q : 시간당 작업량 (m/hr)」", "확신": "원문"} -}, -"GC000187": { - "타설길이": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 5-2-4 「L_1 : 타설길이」", "확신": "원문"} -}, -"GC000189": { - "t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t3": {"기호": "t", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t4": {"기호": "t", "아래": "4", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t5": {"기호": "t", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000191": { - "T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000195": { - "T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000196": { - "말뚝길이": {"기호": "L", "근거": "건설품셈 공통 5-3-5 「L : 말뚝길이(m)」", "확신": "원문"}, - "T3": {"기호": "T", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000206": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000207": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000208": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000253": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000322": { - "W": {"이름": "빔 형식", "근거": "가드레일 판 「2W · 3W」 고르기", "확신": "추정"} -}, -"GC000323": { - "W": {"이름": "빔 형식", "근거": "가드레일 판 「2W · 3W」 고르기", "확신": "추정"} -}, -"GC000422": { - "a": {"이름": "표준고르기면적", "단위": "㎡/hr", "근거": "건설품셈 토목 7-2-5 「a : 표준고르기면적(㎡/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 토목 7-2-5 「E : 작업효율」", "확신": "원문"} -}, -"GC000510": { - "GSD": {"이름": "지상표본거리", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000522": { - "GSD": {"이름": "지상표본거리", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000561": { - "K1": {"기호": "K", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC000876": { - "SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000889": { - "SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000891": { - "SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000892": { - "SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000901": { - "보온두께": {"기호": "X", "단위": "㎜", "근거": "건설품셈 기계설비 13-3-1 「X : 보온두께(㎜)」", "확신": "원문"}, - "Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000902": { - "Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000903": { - "Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC000910": { - "StackFillet": {"이름": "용접장(6㎜ 필렛 환산)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000911": { - "CleanOutDoor": {"이름": "클린아웃 도어", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000912": { - "Scaffolder": {"이름": "비계(Scaffolder) 조립설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Chain": {"이름": "체인블록 설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Tube": {"이름": "튜브패널 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Buckstay": {"이름": "버크스테이 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Tube2": {"이름": "튜브피스 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Casing": {"이름": "케이싱 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Casing2": {"이름": "케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000914": { - "drum": {"이름": "드럼 굴림운반", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "hanger": {"이름": "행거 · 서포트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Chain": {"이름": "체인블록 설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "drum2": {"이름": "드럼 위치조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "drum3": {"이름": "드럼 내부품 조양 · 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000916": { - "DUCT": {"이름": "덕트 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "DUCT2": {"이름": "덕트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000917": { - "casing": {"이름": "케이싱 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Heating": {"이름": "히팅엘리먼트 삽입", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Sealing": {"이름": "시일플레이트 · 패킹링 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000918": { - "Rotary": {"이름": "로터리 수트블로워 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Retractable": {"이름": "리트랙터블 수트블로워 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000920": { - "Foundation": {"이름": "기초 치핑", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Foundation2": {"이름": "기초 마킹", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Sole": {"이름": "솔플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Grouting": {"이름": "그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Lower": {"이름": "하부 외부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Lower2": {"이름": "하부 내부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Rotor": {"이름": "로터 표면손질", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Nozzle": {"이름": "노즐플레이트 표면손질", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Nozzle2": {"이름": "노즐플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Rotor2": {"이름": "로터 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Rotor3": {"이름": "로터 간극 측정 · 교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Upper": {"이름": "상부 내부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Upper2": {"이름": "상부 외부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Upper3": {"이름": "상부 케이싱 간극 측정 · 교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Bearing": {"이름": "베어링 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Turining": {"이름": "터닝기어 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Front": {"이름": "프론트 페데스탈 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Steam": {"이름": "스팀체스트 · 거버닝밸브 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "coupling": {"이름": "커플링 조정 · 조립(개소)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "coupling2": {"이름": "커플링 조정 · 조립(대)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Bolt": {"이름": "볼트 비팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Foundation3": {"이름": "기초 침하 측정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000921": { - "Foundation": {"이름": "기초 치핑", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Sole": {"이름": "솔플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Grouting": {"이름": "그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Lifting": {"이름": "리프팅장치 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Lifting2": {"이름": "리프팅장치 설치(철거)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Stator": {"이름": "고정자 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Rotor": {"이름": "회전자 삽입설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Shaft": {"이름": "축 끝단 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Coupling": {"이름": "커플링 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Exciter": {"이름": "여자기 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Hydrogen": {"이름": "수소냉각기 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000922": { - "Foundation": {"이름": "기초 치핑 · 그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "body": {"이름": "본체 조립설치(ton)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "body2": {"이름": "본체 조립설치(대)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Tube": {"이름": "튜브 삽입설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000965": { - "SCAFFOLDER": {"이름": "비계 조립설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000969": { - "Shell": {"이름": "쉘 플레이트", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Hand": {"이름": "핸드 레일", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Conveyor": {"이름": "컨베이어", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Lapping": {"이름": "래핑 디바이스", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Leveling": {"이름": "레벨 재교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000974": { - "Tube": {"이름": "튜브패널 조립 · 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Buckstay": {"이름": "버크스테이 조립 · 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Sealing": {"이름": "시일 용접", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000975": { - "Inner": {"이름": "이너플레이트 · 행거 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000976": { - "Inner": {"이름": "이너플레이트 · 행거 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}, - "Sealing": {"이름": "시일 용접", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000983": { - "Portable": {"이름": "이동식 벨트컨베이어 가산율", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC000990": { - "Drift": {"이름": "드리프트 엘리미네이터 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"} -}, -"GC001029": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001030": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001063": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001064": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001065": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001066": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001068": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001069": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001074": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001091": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001096": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001099": { - "Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"} -}, -"GC001140": { - "운반거리": {"기호": "L", "근거": "건설품셈 공통 1-2-7 「L : 운반거리(m)」", "확신": "원문"}, - "실작업시간": {"기호": "T", "근거": "건설품셈 공통 1-2-7 「T : 1일 실작업시간(480분-30분)」", "확신": "원문"}, - "적재적하시간": {"기호": "t", "근거": "건설품셈 공통 1-2-7 「t : 적재적하 시간(분)」", "확신": "원문"}, - "평균왕복속도": {"기호": "V", "근거": "건설품셈 공통 1-2-7 「V : 평균왕복속도(m/hr)」", "확신": "원문"}, - "일운반회수": {"기호": "N", "근거": "건설품셈 공통 1-2-7 「N : 1일 운반횟수」", "확신": "원문"} -}, -"GC001141": { - "운반거리": {"기호": "L", "근거": "건설품셈 공통 1-2-7 「L : 운반거리(m)」", "확신": "원문"}, - "실작업시간": {"기호": "T", "근거": "건설품셈 공통 1-2-7 「T : 1일 실작업시간(480분-30분)」", "확신": "원문"}, - "왕복평균속도": {"기호": "V", "근거": "건설품셈 공통 1-2-7 「V : 왕복평균속도(km/hr)」", "확신": "원문"}, - "준비작업시간": {"기호": "t", "근거": "건설품셈 공통 1-2-7 「t : 준비작업시간(2분)」", "확신": "원문"} -}, -"GC001143": { - "작업량": {"기호": "q", "근거": "건설품셈 공통 8-1-4 「q : 1회 작업싸이클당 표준작업량(㎥ 또는 ton)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-1-4 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-1-4 「E : 작업효율」", "확신": "원문"}, - "n": {"이름": "시간당 작업싸이클 수", "근거": "건설품셈 공통 8-1-4 「n : 시간당 작업싸이클 수」", "확신": "원문"}, - "싸이클시간": {"기호": "cm", "근거": "설명 「1회 작업싸이클 시간(cm)」", "확신": "추정"} -}, -"GC001144": { - "운반거리": {"기호": "L", "근거": "건설품셈 공통 8-2-1 「L : 운반거리(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-1 「f : 체적환산계수」", "확신": "원문"}, - "q0": {"이름": "거리를 고려하지 않은 삽날의 용량", "기호": "q", "아래": "0", "근거": "건설품셈 공통 8-2-1 「q゚ : 거리를 고려하지 않은 삽날의 용량(㎥)」", "확신": "원문"}, - "e": {"이름": "운반거리계수", "근거": "건설품셈 공통 8-2-1 「e : 운반거리계수」", "확신": "원문"}, - "q": {"이름": "삽날의 용량", "근거": "건설품셈 공통 8-2-1 「q : 삽날의 용량(㎥)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-1 「E : 작업효율」", "확신": "원문"}, - "V1": {"이름": "전진속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-1 「V_1 : 전진속도(m/분)」", "확신": "원문"}, - "V2": {"이름": "후진속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-1 「V_2 : 후진속도(m/분)」", "확신": "원문"}, - "t": {"이름": "기어 변속시간", "근거": "건설품셈 공통 8-2-1 「t : 기어 변속시간(0.25분)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-1 「cm : 1회 싸이클 시간」", "확신": "원문"} -}, -"GC001146": { - "작업거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-2 「ℓ : 1회의 작업거리(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-2 「f : 체적환산계수」", "확신": "원문"}, - "An": {"이름": "1회 리핑 단면적", "근거": "건설품셈 공통 8-2-2 「An : 1회 리핑 단면적(㎡)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-2 「E : 작업효율」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-2 「cm : 1회 싸이클 시간(분)」", "확신": "원문"} -}, -"GC001147": { - "버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-3 「q : 버킷용량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-3 「f : 체적환산계수」", "확신": "원문"}, - "K": {"이름": "버킷계수", "근거": "건설품셈 공통 8-2-3 「K : 버킷계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-3 「E : 작업효율」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-3 「cm : 1회 싸이클 시간(초)」", "확신": "원문"} -}, -"GC001149": { - "작업거리": {"기호": "L", "근거": "건설품셈 공통 8-2-4 「L : 1열 실작업거리(편도m)」", "확신": "원문"}, - "전진거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-4 「L_1 : 1열 전진거리(m)」", "확신": "원문"}, - "후진거리": {"기호": "L", "아래": "2", "근거": "건설품셈 공통 8-2-4 「L_2 : 1열 후진거리(m)」", "확신": "원문"}, - "d": {"이름": "굴착심도계수", "근거": "건설품셈 공통 8-2-4 「d : 굴착심도계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-4 「E : 작업효율」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-4 「cm : 1회 싸이클시간(분)」", "확신": "원문"} -}, -"GC001150": { - "버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-5 「q : 버킷용량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-5 「f : 체적환산계수」", "확신": "원문"}, - "t1": {"이름": "버킷에 토량을 담는데 소요되는 시간", "기호": "t", "아래": "1", "근거": "건설품셈 공통 8-2-5 「t_1 : 버킷에 토량을 담는데 소요되는 시간(초)」", "확신": "원문"}, - "K": {"이름": "버킷계수", "근거": "건설품셈 공통 8-2-5 「K : 버킷계수」", "확신": "원문"}, - "m": {"이름": "계수", "근거": "건설품셈 공통 8-2-5 「m : 계수(초/m) 무한궤도식 : 2.0」", "확신": "원문"}, - "l": {"이름": "편도주행거리", "기호": "ℓ", "근거": "건설품셈 공통 8-2-5 「ℓ : 편도주행거리(표준을 8m로 한다)」", "확신": "원문"}, - "t2": {"이름": "기어변화 등 기본 시간과 다음 운반기계가 도착할 때까지의 시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-5 「t_2 : 기어변화 등 기본 시간과 다음 운반기계가 도착할 때까지의 시간(14초)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-5 「cm : 1회 싸이클 시간(초)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-5 「E : 작업효율」", "확신": "원문"} -}, -"GC001152": { - "적재주행거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-6 「L_1 : 적재시의 주행거리(m)」", "확신": "원문"}, - "공차주행거리": {"기호": "L", "아래": "2", "근거": "건설품셈 공통 8-2-6 「L_2 : 공차시의 주행거리(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-6 「f : 체적환산계수」", "확신": "원문"}, - "q": {"이름": "적재함용적×적재계수", "근거": "건설품셈 공통 8-2-6 「q : 적재함용적×적재계수(k)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-6 「E : 작업효율」", "확신": "원문"}, - "V1": {"이름": "적재시의 주행속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-6 「V_1 : 적재시의 주행속도(m/분)」", "확신": "원문"}, - "V2": {"이름": "공차시의 주행속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-6 「V_2 : 공차시의 주행속도(m/분)」", "확신": "원문"}, - "t": {"이름": "적토, 사토 및 기어변속시간", "근거": "건설품셈 공통 8-2-6 「t : 적토, 사토 및 기어변속시간(푸쉬도우저를 사용할 때 1.6분, 사용하지 않을 때 2.8분)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-6 「cm : 1회 싸이클 시간」", "확신": "원문"} -}, -"GC001153": { - "작업거리": {"기호": "D", "근거": "건설품셈 공통 8-2-7 「D : 1회의 작업거리(편도 m)」", "확신": "원문"}, - "작업폭": {"기호": "W", "근거": "건설품셈 공통 8-2-7 「W : 작업장 전체의 폭(m)」", "확신": "원문"}, - "V1": {"이름": "작업속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-7 「V_1 : 작업속도(㎞/hr)」", "확신": "원문"}, - "V2": {"이름": "후진 또는 회송속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-7 「V_2 : 후진 또는 회송속도(㎞/hr)」", "확신": "원문"}, - "t": {"이름": "방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간", "근거": "건설품셈 공통 8-2-7 「t : 방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간(분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-7 「E : 작업효율」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001154": { - "작업거리": {"기호": "D", "근거": "건설품셈 공통 8-2-7 「D : 1회의 작업거리(편도 m)」", "확신": "원문"}, - "두께": {"기호": "H", "근거": "건설품셈 공통 8-2-7 「H : 굴착 깊이 또는 흙고르기 두께(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-7 「f : 체적환산계수」", "확신": "원문"}, - "V1": {"이름": "작업속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-7 「V_1 : 작업속도(㎞/hr)」", "확신": "원문"}, - "V2": {"이름": "후진 또는 회송속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-7 「V_2 : 후진 또는 회송속도(㎞/hr)」", "확신": "원문"}, - "t": {"이름": "방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간", "근거": "건설품셈 공통 8-2-7 「t : 방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간(분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-7 「E : 작업효율」", "확신": "원문"}, - "l": {"이름": "블레이드의 유효길이", "기호": "ℓ", "근거": "건설품셈 공통 8-2-7 「ℓ : 블레이드의 유효길이(m)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001155": { - "적재용량": {"기호": "T", "근거": "건설품셈 공통 8-2-8 「T : 덤프트럭의 적재용량(ton)」", "확신": "원문"}, - "체적변화율": {"기호": "L", "근거": "건설품셈 공통 8-2-8 「L : 체적환산계수에서의 체적변화율」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-8 「f : 체적환산계수」", "확신": "원문"}, - "적재싸이클": {"기호": "cms", "근거": "건설품셈 공통 8-2-8 「cms : 적재기계의 1회 싸이클시간(초)」", "확신": "원문"}, - "버킷계수": {"기호": "k", "근거": "건설품셈 공통 8-2-8 「k : 리퍼 또는 버킷계수」", "확신": "원문"}, - "적재효율": {"기호": "Es", "근거": "건설품셈 공통 8-2-8 「Es : 적재기계의 작업효율」", "확신": "원문"}, - "q": {"이름": "흐트러진 상태의 덤프트럭 1회 적재량", "근거": "건설품셈 공통 8-2-8 「q : 흐트러진 상태의 덤프트럭 1회 적재량(㎥)」", "확신": "원문"}, - "n": {"이름": "덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수", "근거": "건설품셈 공통 8-2-8 「n : 덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-8 「cm : 1회 싸이클시간(분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-8 「E : 작업효율(0.9)」", "확신": "원문"}, - "t1": {"기호": "t", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t3": {"기호": "t", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t4": {"기호": "t", "아래": "4", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t5": {"기호": "t", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "t6": {"기호": "t", "아래": "6", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC001157": { - "다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"}, - "두께": {"기호": "D", "근거": "건설품셈 공통 8-2-9 「D : 펴는 흙의 두께(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-9 「f : 체적환산계수」", "확신": "원문"}, - "W": {"이름": "롤러의 유효폭", "근거": "건설품셈 공통 8-2-9 「W : 롤러의 유효폭(m)」", "확신": "원문"}, - "V": {"이름": "다짐속도", "근거": "건설품셈 공통 8-2-9 「V : 다짐속도(㎞/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-9 「E : 작업효율」", "확신": "원문"} -}, -"GC001158": { - "다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"}, - "W": {"이름": "롤러의 유효폭", "근거": "건설품셈 공통 8-2-9 「W : 롤러의 유효폭(m)」", "확신": "원문"}, - "V": {"이름": "다짐속도", "근거": "건설품셈 공통 8-2-9 「V : 다짐속도(㎞/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-9 「E : 작업효율」", "확신": "원문"} -}, -"GC001161": { - "W": {"이름": "유효혼합폭", "근거": "건설품셈 공통 8-2-11 「W : 유효혼합폭(m)」", "확신": "원문"}, - "V": {"이름": "작업속도", "근거": "건설품셈 공통 8-2-11 「V : 작업속도(1,000m/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-11 「E : 작업효율」", "확신": "원문"} -}, -"GC001164": { - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001167": { - "q": {"이름": "작업능력", "근거": "건설품셈 공통 8-2-14 「q : 작업능력(3.26㎥/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-14 「E : 작업효율(0.95)」", "확신": "원문"} -}, -"GC001169": { - "q": {"이름": "시간당 표준작업량", "근거": "건설품셈 공통 8-2-16 「q : 시간당 표준작업량(62.5㎥/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-16 「E : 작업효율(0.8)」", "확신": "원문"} -}, -"GC001170": { - "믹서용량": {"기호": "q", "근거": "건설품셈 공통 8-2-17 「q : 콘크리트 믹서용량(㎥)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-17 「E : 작업효율(0.8)」", "확신": "원문"} -}, -"GC001171": { - "q": {"이름": "믹서의 실용량", "근거": "건설품셈 공통 8-2-18 「q : 믹서의 실용량」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-18 「cm : 1회 싸이클시간(1.5분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-18 「E : 작업효율」", "확신": "원문"} -}, -"GC001172": { - "적재용량": {"기호": "W", "근거": "건설품셈 공통 8-2-19 「W : 적재용량」", "확신": "원문"}, - "t1": {"이름": "적입시간", "기호": "t", "아래": "1", "근거": "건설품셈 공통 8-2-19 「t_1 : 적입시간」", "확신": "원문"}, - "t2": {"이름": "주행시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-19 「t_2 : 주행시간」", "확신": "원문"}, - "t3": {"이름": "배출시간", "기호": "t", "아래": "3", "근거": "건설품셈 공통 8-2-19 「t_3 : 배출시간」", "확신": "원문"}, - "t4": {"이름": "대기시간", "기호": "t", "아래": "4", "근거": "건설품셈 공통 8-2-19 「t_4 : 대기시간」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-19 「E : 작업효율(0.95)」", "확신": "원문"}, - "플랜트실용량": {"기호": "q", "근거": "설명 「콘크리트플랜트 믹서 실용량(q)」", "확신": "추정"}, - "운반거리": {"기호": "L", "근거": "설명 「운반거리(편도)」", "확신": "추정"}, - "cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001173": { - "W": {"이름": "적재용량", "근거": "건설품셈 공통 8-2-19 「W : 적재용량」", "확신": "원문"}, - "cm1": {"이름": "1회 싸이클의 왕복 주행시간", "기호": "cm", "아래": "1", "근거": "건설품셈 공통 8-2-19 「cm_1 : 1회 싸이클의 왕복 주행시간(min)」", "확신": "원문"}, - "cm2": {"이름": "1회 싸이클의 작업하역시간 및 대기시간의 합계", "기호": "cm", "아래": "2", "근거": "건설품셈 공통 8-2-19 「cm_2 : 1회 싸이클의 작업하역시간 및 대기시간의 합계(min)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-19 「E : 작업효율(0.95)」", "확신": "원문"}, - "플랜트실용량": {"기호": "q", "근거": "설명 「콘크리트플랜트 믹서 실용량(q)」", "확신": "추정"}, - "운반거리": {"기호": "L", "근거": "설명 「편도운반거리(L · 15㎞까지)」", "확신": "추정"}, - "cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001174": { - "대차용량": {"기호": "q", "근거": "건설품셈 공통 8-2-20 「q : 대차의 용량(㎥)」", "확신": "원문"}, - "운반거리": {"기호": "L", "근거": "건설품셈 공통 8-2-20 「L : 평균 운반편도(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-20 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-20 「E : 작업효율」", "확신": "원문"}, - "n": {"이름": "1회운반시의 대차수", "근거": "건설품셈 공통 8-2-20 「n : 1회운반시의 대차수(5t일 때 12대, 7t일 때 15대)」", "확신": "원문"}, - "C": {"이름": "1회 운반토량", "근거": "건설품셈 공통 8-2-20 「C : 1회 운반토량(㎥)」", "확신": "원문"}, - "t2": {"이름": "적재 적하 소요시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-20 「t_2 : 적재 적하 소요시간(토사류는 17분, 석재류는 20분)」", "확신": "원문"}, - "N": {"이름": "1시간당 운반횟수", "근거": "건설품셈 공통 8-2-20 「N : 1시간당 운반횟수」", "확신": "원문"} -}, -"GC001175": { - "적재량": {"기호": "q", "근거": "건설품셈 공통 8-2-21 「q : 흐트러진 상태의 경운기 1회 적재량」", "확신": "원문"}, - "거리": {"기호": "L", "근거": "건설품셈 공통 8-2-21 「L : 거리(m)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-21 「f : 체적환산계수」", "확신": "원문"}, - "t": {"이름": "적재 적하시간", "근거": "건설품셈 공통 8-2-21 「t : 적재 적하시간(분)」", "확신": "원문"}, - "V1": {"이름": "적재시 속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-21 「V_1 : 적재시 속도(m/분)」", "확신": "원문"}, - "V2": {"이름": "공차시 속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-21 「V_2 : 공차시 속도(m/분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-21 「E : 작업효율(0.9)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GC001176": { - "관입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-22 「L : 파일 끝이 들어가는 전층의 길이(m)」", "확신": "원문"}, - "세우기횟수": {"기호": "Ns", "근거": "건설품셈 공통 8-2-22 「Ns : 파일세우기 횟수」", "확신": "원문"}, - "평균간격": {"기호": "a", "근거": "건설품셈 공통 8-2-22 「a : 파일의 평균간격(m)」", "확신": "원문"}, - "블록간거리": {"기호": "LS", "근거": "건설품셈 공통 8-2-22 「LS : 블록간의 거리(m)」", "확신": "원문"}, - "블록수": {"기호": "S", "근거": "건설품셈 공통 8-2-22 「S : 블록수」", "확신": "원문"}, - "시공본수": {"기호": "n", "근거": "건설품셈 공통 8-2-22 「n : 파일의 전 시공 본수」", "확신": "원문"}, - "이음수": {"기호": "Nw", "근거": "건설품셈 공통 8-2-22 「Nw : 파일 1본당 이음수」", "확신": "원문"}, - "α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-22 「α : 토질계수」", "확신": "원문"}, - "N": {"이름": "파일 끝이 들어가는 전층의 평균 N치", "근거": "건설품셈 공통 8-2-22 「N : 파일 끝이 들어가는 전층의 평균 N치」", "확신": "원문"}, - "F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-22 「F : 작업계수」", "확신": "원문"}, - "β": {"이름": "해머 계수", "근거": "건설품셈 공통 8-2-22 「β : 해머 계수」", "확신": "원문"}, - "Tb": {"이름": "파일 1본당 타격시간", "근거": "건설품셈 공통 8-2-22 「Tb : 파일 1본당 타격시간(min)」", "확신": "원문"}, - "tw": {"이름": "이음 1개소당 용접시간", "근거": "건설품셈 공통 8-2-22 「tw : 이음 1개소당 용접시간(분)」", "확신": "원문"}, - "Tw": {"이름": "파일 1본당 용접시간", "근거": "건설품셈 공통 8-2-22 「Tw : 파일 1본당 용접시간(min)」", "확신": "원문"}, - "Ts": {"이름": "파일 1본당 세우기 및 위치 조정시간", "근거": "건설품셈 공통 8-2-22 「Ts : 파일 1본당 세우기 및 위치 조정시간(min)」", "확신": "원문"}, - "Tt": {"이름": "파일 1본당 해머의 이동 및 준비시간", "근거": "건설품셈 공통 8-2-22 「Tt : 파일 1본당 해머의 이동 및 준비시간(min)」", "확신": "원문"}, - "Te": {"이름": "파일 1본당 해머의 점검 및 급유 등 기타시간", "근거": "건설품셈 공통 8-2-22 「Te : 파일 1본당 해머의 점검 및 급유 등 기타시간(min)」", "확신": "원문"} -}, -"GC001177": { - "관입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-22 「L : 파일 끝이 들어가는 전층의 길이(m)」", "확신": "원문"}, - "세우기횟수": {"기호": "Ns", "근거": "건설품셈 공통 8-2-22 「Ns : 파일세우기 횟수」", "확신": "원문"}, - "α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-22 「α : 토질계수」", "확신": "원문"}, - "N": {"이름": "파일 끝이 들어가는 전층의 평균 N치", "근거": "건설품셈 공통 8-2-22 「N : 파일 끝이 들어가는 전층의 평균 N치」", "확신": "원문"}, - "F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-22 「F : 작업계수」", "확신": "원문"}, - "β": {"이름": "해머 계수", "근거": "건설품셈 공통 8-2-22 「β : 해머 계수」", "확신": "원문"}, - "Tb": {"이름": "파일 1본당 타격시간", "근거": "건설품셈 공통 8-2-22 「Tb : 파일 1본당 타격시간(min)」", "확신": "원문"}, - "Ts": {"이름": "파일 1본당 세우기 및 위치 조정시간", "근거": "건설품셈 공통 8-2-22 「Ts : 파일 1본당 세우기 및 위치 조정시간(min)」", "확신": "원문"}, - "Tt": {"이름": "파일 1본당 해머의 이동 및 준비시간", "근거": "건설품셈 공통 8-2-22 「Tt : 파일 1본당 해머의 이동 및 준비시간(min)」", "확신": "원문"}, - "Te": {"이름": "파일 1본당 해머의 점검 및 급유 등 기타시간", "근거": "건설품셈 공통 8-2-22 「Te : 파일 1본당 해머의 점검 및 급유 등 기타시간(min)」", "확신": "원문"} -}, -"GC001178": { - "α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-23 「α : 토질계수」", "확신": "원문"}, - "β": {"이름": "판두께계수", "근거": "건설품셈 공통 8-2-23 「β : 판두께계수」", "확신": "원문"}, - "Ta": {"이름": "파일규격에 따른 시공시간", "근거": "건설품셈 공통 8-2-23 「Ta : 파일규격에 따른 시공시간(min/본)」", "확신": "원문"} -}, -"GC001179": { - "α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-23 「α : 토질계수」", "확신": "원문"}, - "Ta": {"이름": "파일규격에 따른 시공시간", "근거": "건설품셈 공통 8-2-23 「Ta : 파일규격에 따른 시공시간(min/본)」", "확신": "원문"} -}, -"GC001180": { - "사질층길이": {"기호": "ℓ", "아래": "1", "근거": "건설품셈 공통 8-2-24 「ℓ_1 : r_1에 대한 근입장(m)」", "확신": "원문"}, - "점질층길이": {"기호": "ℓ", "아래": "2", "근거": "건설품셈 공통 8-2-24 「ℓ_2 : r_2에 대한 근입장(m)」", "확신": "원문"}, - "Ts": {"이름": "파일 1본당 준비시간", "근거": "건설품셈 공통 8-2-24 「Ts : 파일 1본당 준비시간(분)」", "확신": "원문"}, - "r1": {"이름": "사질토, 역질토에 대한 항타 단위 작업시간", "기호": "r", "아래": "1", "근거": "건설품셈 공통 8-2-24 「r_1 : 사질토, 역질토에 대한 항타 단위 작업시간(min/m)」", "확신": "원문"}, - "r2": {"이름": "점질토에 대한 항타 단위 작업시간", "기호": "r", "아래": "2", "근거": "건설품셈 공통 8-2-24 「r_2 : 점질토에 대한 항타 단위 작업시간(min/m)」", "확신": "원문"}, - "r": {"이름": "토질별 항타 또는 항발시간", "근거": "건설품셈 공통 8-2-24 「r : 토질별 항타 또는 항발시간(분/m)」", "확신": "원문"}, - "k": {"이름": "해머계수", "근거": "건설품셈 공통 8-2-24 「k : 해머계수」", "확신": "원문"}, - "Tb": {"이름": "파일 1본당 항타 또는 항발시간", "근거": "건설품셈 공통 8-2-24 「Tb : 파일 1본당 항타 또는 항발시간(분)」", "확신": "원문"}, - "F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-24 「F : 작업계수」", "확신": "원문"}, - "사질N": {"기호": "N", "아래": "1", "근거": "설명 「사질토 · 역질토 N치(N1)」", "확신": "추정"}, - "점질N": {"기호": "N", "아래": "2", "근거": "설명 「점질토 N치(N2)」", "확신": "추정"}, - "f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"}, - "f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"}, - "f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"}, - "f4": {"이름": "작업조건 보정계수 4", "기호": "f", "아래": "4", "근거": "칸 설명", "확신": "원문"} -}, -"GC001181": { - "근입길이": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-24 「ℓ : 파일 근입장(m)」", "확신": "원문"}, - "Nmax": {"이름": "최대 N치", "근거": "건설품셈 공통 8-2-24 「Nmax : 최대 N치」", "확신": "원문"}, - "K": {"이름": "강널말뚝 종류 및 기계 규격에 따른 계수", "근거": "건설품셈 공통 8-2-24 「K : 강널말뚝 종류 및 기계 규격에 따른 계수」", "확신": "원문"}, - "F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-24 「F : 작업계수」", "확신": "원문"}, - "f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"}, - "f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"}, - "f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"} -}, -"GC001182": { - "근입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-25 「L : 근입길이(m)」", "확신": "원문"}, - "To": {"이름": "파일 1본(장)당 기본시공시간", "근거": "건설품셈 공통 8-2-25 「To : 파일 1본(장)당 기본시공시간(분)」", "확신": "원문"}, - "α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-25 「α : 토질계수」", "확신": "원문"}, - "F": {"이름": "현장의 조건에 따른 작업계수", "근거": "건설품셈 공통 8-2-25 「F : 현장의 조건에 따른 작업계수」", "확신": "원문"}, - "f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"}, - "f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"}, - "f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"}, - "f4": {"이름": "작업조건 보정계수 4", "기호": "f", "아래": "4", "근거": "칸 설명", "확신": "원문"} -}, -"GC001183": { - "파일길이": {"기호": "L", "근거": "건설품셈 공통 8-2-26 「L : 파일길이(m)」", "확신": "원문"}, - "압입길이": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-26 「ℓ : 강널말뚝 1본당 인발길이(m)」", "확신": "원문"}, - "Nmax": {"이름": "압입길이에 따른 최대 N치", "근거": "건설품셈 공통 8-2-26 「Nmax : 압입길이에 따른 최대 N치」", "확신": "원문"}, - "Ts": {"이름": "압입 강널말뚝 1본당 준비시간", "기호": "T", "아래": "s", "근거": "건설품셈 공통 8-2-26 「T_s : 압입 강널말뚝 1본당 준비시간(분/본)」", "확신": "원문"}, - "γ": {"이름": "압입단위 작업시간", "단위": "분/본", "근거": "건설품셈 공통 8-2-26 「γ : 압입단위 작업시간(분/본)」", "확신": "원문"}, - "Tb": {"이름": "압입 강널말뚝 1본당 압입시간", "기호": "T", "아래": "b", "근거": "건설품셈 공통 8-2-26 「T_b : 압입 강널말뚝 1본당 압입시간(분/본)」", "확신": "원문"}, - "F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-26 「F : 작업계수」", "확신": "원문"}, - "f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"}, - "f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"}, - "f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"} -}, -"GC001185": { - "작업거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-28 「ℓ : 1회의 작업거리(m)」", "확신": "원문"}, - "회전속도": {"기호": "R", "근거": "건설품셈 공통 8-2-28 「R : 굴착면의 분당 회전속도」", "확신": "원문"}, - "투과깊이": {"기호": "Pe", "근거": "건설품셈 공통 8-2-28 「Pe : 굴착면 1회전당 컷터의 투과깊이(cm / 회)」", "확신": "원문"}, - "A": {"이름": "굴착면적", "근거": "건설품셈 공통 8-2-28 「A : 굴착면적(㎡)」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-28 「cm : 1회의 싸이클 시간(분)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-28 「E : 작업효율」", "확신": "원문"}, - "굴착직경": {"기호": "D", "근거": "설명 「굴착직경(D)」", "확신": "추정"}, - "T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GC001186": { - "전동환산출력": {"기호": "bo", "근거": "건설품셈 공통 8-2-29 「bo : 펌프준설선의 전동환산 출력(㎾)」", "확신": "원문"}, - "E1": {"이름": "흙의 두께에 따른 효율", "기호": "E", "아래": "1", "근거": "건설품셈 공통 8-2-29 「E_1 : 흙의 두께에 따른 효율」", "확신": "원문"}, - "E2": {"이름": "평면형상에 따른 효율", "기호": "E", "아래": "2", "근거": "건설품셈 공통 8-2-29 「E_2 : 평면형상에 따른 효율」", "확신": "원문"}, - "E3": {"이름": "단면형상에 따른 효율", "기호": "E", "아래": "3", "근거": "건설품셈 공통 8-2-29 「E_3 : 단면형상에 따른 효율」", "확신": "원문"}, - "E4": {"이름": "해상조건에 따른 효율", "기호": "E", "아래": "4", "근거": "건설품셈 공통 8-2-29 「E_4 : 해상조건에 따른 효율」", "확신": "원문"}, - "q": {"이름": "펌프준설선의 전동환산 746㎾의 1시간당 준설량", "근거": "건설품셈 공통 8-2-29 「q : 펌프준설선의 전동환산(電動換算) 746㎾의 1시간당 준설량(㎥/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-29 「E : 작업효율」", "확신": "원문"} -}, -"GC001187": { - "버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-30 「q : 버킷 또는 디퍼의 용량(㎥)」", "확신": "원문"}, - "E1": {"이름": "흙의 두께에 따른 효율", "기호": "E", "아래": "1", "근거": "건설품셈 공통 8-2-30 「E_1 : 흙의 두께에 따른 효율」", "확신": "원문"}, - "E2": {"이름": "해상조건에 따른 효율", "기호": "E", "아래": "2", "근거": "건설품셈 공통 8-2-30 「E_2 : 해상조건에 따른 효율」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-30 「f : 현 지반의 토량을 기준하였을 때와의 준설토량의 변화율(체적 환산계수)」", "확신": "원문"}, - "k": {"이름": "버킷 및 디퍼의 계수", "근거": "건설품셈 공통 8-2-30 「k : 버킷 및 디퍼의 계수」", "확신": "원문"}, - "cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-30 「cm : 1회 싸이클시간(초)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-30 「E : 작업효율」", "확신": "원문"} -}, -"GC001188": { - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-31 「E : 작업효율」", "확신": "원문"}, - "S": {"이름": "1본당 쇄암면적", "근거": "건설품셈 공통 8-2-31 「S : 1본당 쇄암면적(㎡)」", "확신": "원문"}, - "n": {"이름": "1층의 쇄암깊이(d)를 쇄암하는데 필요한 낙추횟수", "근거": "건설품셈 공통 8-2-31 「n : 1층의 쇄암깊이(d)를 쇄암하는데 필요한 낙추횟수」", "확신": "원문"} -}, -"GC001190": { - "출력": {"기호": "b", "근거": "건설품셈 공통 8-2-33 「b : 하천골재채취선의 출력(㎾)」", "확신": "원문"}, - "q": {"이름": "하천골재채취선 746㎾의 시간당 준설량", "근거": "건설품셈 공통 8-2-33 「q : 하천골재채취선 746㎾의 시간당 준설량(㎥/hr)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-33 「E : 작업효율」", "확신": "원문"} -}, -"GF000003": { - "q": {"이름": "버킷용량", "근거": "표 라벨/출처 「q(버킷용량)」", "확신": "원문"}, - "K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클의 시간)」", "확신": "원문"} -}, -"GF000042": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클시간)」", "확신": "원문"} -}, -"GF000043": { - "작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 5-29 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"} -}, -"GF000062": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000063": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000064": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000065": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000066": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000067": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000068": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000071": { - "Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"} -}, -"GF000072": { - "Q": {"이름": "운재량", "근거": "표 열/행 이름 「운재량」", "확신": "원문"} -}, -"GF000073": { - "Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"} -}, -"GF000074": { - "Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"} -}, -"GF000075": { - "Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"} -}, -"GF000088": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000090": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000092": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000094": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000098": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000112": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000114": { - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000115": { - "T": {"이름": "표토두께", "근거": "산림품셈 9-15-1 「T : 표토두께(m)」", "확신": "원문"}, - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"}, - "f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000116": { - "T": {"이름": "표토두께", "근거": "산림품셈 9-15-1 「T : 표토두께(m)」", "확신": "원문"}, - "작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎡/hr", "근거": "산림품셈 9-15-1 「Q : 시간당 작업량(㎡/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"} -}, -"GF000117": { - "T": {"이름": "표토두께", "근거": "표 라벨/출처 「T(표토두께)」", "확신": "원문"}, - "L": {"이름": "운반거리", "근거": "표 라벨/출처 「L(운반거리)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "q0": {"이름": "거리를 고려하지 않은 삽날의 용량", "기호": "q", "아래": "0", "근거": "표 라벨/출처 「q0(거리를 고려하지 않은 삽날의 용량)」", "확신": "원문"}, - "e": {"이름": "운반거리계수", "근거": "표 라벨/출처 「e(운반거리계수)」", "확신": "원문"}, - "V1": {"이름": "전진속도", "기호": "V", "아래": "1", "근거": "표 라벨/출처 「V1(전진속도)」", "확신": "원문"}, - "V2": {"이름": "후진속도", "기호": "V", "아래": "2", "근거": "표 라벨/출처 「V2(후진속도)」", "확신": "원문"}, - "t": {"이름": "기어변속시간", "근거": "표 라벨/출처 「t(기어변속시간)」", "확신": "원문"}, - "f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000118": { - "q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000120": { - "V": {"이름": "다짐속도", "단위": "km/hr", "근거": "표 라벨/출처 「V(다짐속도)」", "확신": "원문"}, - "W": {"이름": "롤러 유효폭", "단위": "m", "근거": "표 라벨/출처 「W(롤러 유효폭)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "D": {"이름": "펴는 흙의 두께", "단위": "m", "근거": "표 라벨/출처 「D(펴는 흙의 두께)」", "확신": "원문"}, - "f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"}, - "N": {"이름": "소요다짐횟수", "근거": "표 라벨/출처 「N(소요다짐횟수)」", "확신": "원문"} -}, -"GF000121": { - "q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "V1": {"기호": "V", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "V2": {"기호": "V", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000122": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"} -}, -"GF000131": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"}, - "f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클시간)」", "확신": "원문"} -}, -"GF000132": { - "작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 9-22 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"} -}, -"GF000133": { - "qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림품셈 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "산림품셈 10-3 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "산림품셈 10-3 「E : 작업효율」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000134": { - "qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림품셈 10-3-1 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "산림품셈 10-3-1 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "산림품셈 10-3-1 「E : 작업효율」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"}, - "작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 10-3-1 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"} -}, -"GF000135": { - "qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "산림 10-3 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "산림 10-3 「E : 작업효율」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"} -}, -"GF000136": { - "qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "산림 10-3 「f : 체적환산계수」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "산림 10-3 「E : 작업효율」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"} -}, -"GF000137": { - "t2": {"이름": "한 번 싣고 내리는 데 드는 시간", "기호": "t", "아래": "2", "근거": "칸 설명", "확신": "원문"} -}, -"GF000148": { - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000153": { - "q": {"이름": "버킷용량", "근거": "표 라벨/출처 「q(버킷용량)」", "확신": "원문"}, - "k": {"이름": "버킷계수", "근거": "표 라벨/출처 「k(버킷계수)」", "확신": "원문"}, - "f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"}, - "E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000168": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000193": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000194": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000239": { - "q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}, - "Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"} -}, -"GF000256": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000257": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000258": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000259": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000260": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000261": { - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000277": { - "Q1": {"기호": "Q", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "Q5": {"기호": "Q", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GF000284": { - "K": {"이름": "버킷계수", "근거": "산림품셈 10-12-1 「K : 버켓계수」", "확신": "원문"}, - "Es": {"이름": "적재기계의 작업효율", "근거": "산림품셈 10-12-1 「Es : 적재기계의 작업효율」", "확신": "원문"}, - "q": {"이름": "적재기계의 버킷용량", "단위": "㎥", "근거": "산림품셈 10-12-1 「q : 적재기계의 버켓용량(㎥)」", "확신": "원문"}, - "n": {"이름": "덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수", "근거": "산림품셈 10-12-1 「n : 덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수」", "확신": "원문"}, - "q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "E0": {"기호": "E", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "Q1": {"기호": "Q", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"} -}, -"GF000308": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000309": { - "Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"} -}, -"GF000312": { - "Q0": {"기호": "Q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GF000313": { - "Q0": {"기호": "Q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"} -}, -"GF000314": { - "Q": {"이름": "작업량", "근거": "표 열/행 이름 「작업량」", "확신": "원문"} -}, -"GF000323": { - "Q": {"이름": "작업량", "근거": "표 열/행 이름 「작업량」", "확신": "원문"} -}, -"GX000004": { - "Q2": {"기호": "Q", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}, - "K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}, - "E": {"이름": "작업효율", "근거": "굴착기 작업효율 표(CC000043)", "확신": "추정"}, - "cm": {"이름": "1회 싸이클시간", "근거": "굴착기 싸이클시간 표(CC000045)", "확신": "추정"}, - "Q": {"이름": "시간당 작업량", "근거": "로직 GC001147(굴착기 시간당 작업량)", "확신": "원문"} -} -} -} diff --git a/resources/tester/helper_855_engine.py b/resources/tester/helper_855_engine.py index f27f74f21..48d038289 100644 --- a/resources/tester/helper_855_engine.py +++ b/resources/tester/helper_855_engine.py @@ -25,7 +25,6 @@ mcut = importlib.import_module("master_cut") mc = importlib.import_module("master_doc_calc") ml = importlib.import_module("master_doc_link") meq = importlib.import_module("master_equation") -build = importlib.import_module("build_수식문서_802_2") KEYS = ("노무비", "재료비", "경비", "계") SEEN = "보임" @@ -152,7 +151,8 @@ def level(old, new, money: bool) -> str | None: def adopted(key: str, label: str, lv: str) -> bool: """채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭 - (식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만.""" + (식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만 · 빌더는 855-E L4 에서 은퇴(옛 대조 몫 — 부를 때만 읽음).""" + build = importlib.import_module("build_수식문서_802_2") if lv == "L0": return (key, label) in build.ADOPTED return lv == "L1" and build._uses_raw_sub(world()[2][key]) diff --git a/resources/tester/test_796_3_var_names.py b/resources/tester/test_796_3_var_names.py deleted file mode 100644 index d78a10233..000000000 --- a/resources/tester/test_796_3_var_names.py +++ /dev/null @@ -1,200 +0,0 @@ -"""796-3 변수 국문 이름 · 기호 · 첨자 · 단위 기본값 지킴 (요구 659-2 · 656-4). - -① 빌더(`build_변수표_796_3.py`) — 정본에서 변수표를 걷은 상태에 돌리면 결정 자료 그대로 채움 · 채운 뒤 또 돌리면 쓸 것 없음. -② 변수표 열쇠 = 엔진 변수(입력 · 중간 이름) · 한 로직 안 기호(첨자 포함) · 이름 겹침 0. -③ 보이기만 — 변수표 · 채운 단위를 걷어도 엔진 셈 · 끝수 지문 같음(결정 줄 전부). -④ 표본 — GC001147(굴착기 8-2-3) · GC001140(인력운반 1-2-7) · GC001144(불도저 8-2-1) 기호 · 단위 = 품셈 원문 「여기서」. -""" - -from __future__ import annotations - -import copy -import hashlib -import importlib -import json -import re -from functools import lru_cache -from pathlib import Path - -import pytest - -from M01_MasterData import M01_MasterData_Store as store - -meq = importlib.import_module("master_equation") -mf = importlib.import_module("master_formula") -mcut = importlib.import_module("master_cut") -ma = importlib.import_module("master_auto") -build = importlib.import_module("build_변수표_796_3") - -ROOT = Path(__file__).resolve().parents[2] -BOOK = ROOT / "resources/knowledge/original/원가계산/건설공사_표준품셈/본문/01_공통부문" -SIGN = re.compile(r"^[^\W\d_]\w{0,9}$") # master_equation_edit.SIGN_FORM 과 같게 -SUB = re.compile(r"^[\w′'*]{1,6}$") - - -@lru_cache(maxsize=1) -def loaded(): - return store.loaded() - - -def logic_rows() -> list[dict]: - return [r for d in loaded()[0].values() if d.get("그룹") == "로직" for r in d.get("줄", [])] - - -def raw_state() -> dict[str, dict]: - """변수표를 걷고 결정 줄의 채운 단위를 걷은 사본(= 채우기 전) — 파일 이름 → 자료.""" - want = build.decisions() - out = {} - for name, data in loaded()[0].items(): - if data.get("그룹") != "로직": - out[name] = data - continue - data = copy.deepcopy(data) - for row in data["줄"]: - row.pop(meq.FIELD, None) - for key, one in (want.get(row["키"]) or {}).items(): - if not one.get("단위"): - continue - for kind in ("입력", "중간"): - for spec in row.get(kind) or []: - if spec["이름"] == key and spec.get("단위") == one["단위"]: - spec.pop("단위") - out[name] = data - return out - - -def test_결정_자료_꼴(): - want = build.decisions() - assert len(want) >= 150 - names = {r["키"]: {s["이름"] for k in ("입력", "중간") for s in r[k]} for r in logic_rows()} - n = 0 - for code, one in want.items(): - assert code in names, code - for key, e in one.items(): - n += 1 - assert key in names[code], (code, key) - assert e["확신"] in ("원문", "추정"), (code, key) - assert e.get("근거"), (code, key) - assert len(e.get("이름", "")) <= 40 - if e.get("기호"): - assert SIGN.match(e["기호"]), (code, key) - for f in ("위", "아래"): - assert not e.get(f) or SUB.match(e[f]), (code, key, f) - assert "원" not in e.get("단위", ""), ( - code, - key, - ) # 엔진이 「원」 단위를 금액 입력으로 봄 - assert any(e.get(f) for f in ("이름", "기호", "아래", "위", "단위")), (code, key) - assert n >= 500 - - -def test_빌더_채움_그리고_또_돌리면_쓸것_없음(): - want = build.decisions() - batch, stat = build.plan(raw_state(), want) # 채우기 전 → 결정 그대로 - assert stat["줄"] == len(want) == len(batch and [c for b in batch for c in b["changes"]]) - assert stat["변수표"] == sum( - 1 for one in want.values() for e in one.values() if any(e.get(f) for f in build.LOOK) - ) - assert stat["이미있음"] == 0 - batch2, stat2 = build.plan(loaded()[0], want) # 정본(이미 채움) → 쓸 것 없음 - assert batch2 == [] and stat2["변수표"] == 0 and stat2["단위"] == 0 - - -def test_변수표_열쇠는_엔진_변수_기호_이름_겹침_0(): - for r in logic_rows(): - names = {s["이름"] for k in ("입력", "중간") for s in r[k]} - assert set(r.get(meq.FIELD) or {}) <= names, r["키"] - seen: dict[str, str] = {} - for v in meq.table(r): - for word in {meq.token(v), v["이름"]}: - assert seen.get(word, v["열쇠"]) == v["열쇠"], (r["키"], word) - seen.setdefault(word, v["열쇠"]) - - -def _print(whole, row) -> str: - try: - raw = mf.run( - whole, - str(row["키"]), - { - **ma.values(whole, row), - **{k: v for k, v in ma.defaults(whole, row).items() if v is not None}, - }, - ) - text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False) - text += json.dumps( - mcut.engine(whole, str(row["키"]), raw), default=str, sort_keys=True, ensure_ascii=False - ) - except Exception as e: # 멈춤도 지문 - text = f"ERR {type(e).__name__} {e}" - return hashlib.sha256(text.encode()).hexdigest()[:16] - - -def test_셈_전후_같음_결정_줄_전부(): - want = build.decisions() - now = loaded()[1] - before_files = raw_state() - before = mf.Master(before_files) - for code in want: - row_now = now.logic(code) - row_before = before.logic(code) - assert meq.FIELD not in row_before - assert _print(now, row_now) == _print(before, row_before), code - - -def _table(code: str) -> dict[str, dict]: - return {v["열쇠"]: v for v in meq.table(loaded()[1].logic(code))} - - -def test_표본_기호_단위_원문_같음(): - excav = (BOOK / "제08장_건설기계/8-02-03_굴착기.md").read_text(encoding="utf-8") - for line in ( - "q : 버킷용량(㎥)", - "E : 작업효율", - "K : 버킷계수", - "f : 체적환산계수", - "cm : 1회 싸이클 시간(초)", - ): - assert line in excav, line - t = _table("GC001147") - assert (t["버킷용량"]["기호"], t["버킷용량"]["단위"]) == ("q", "㎥") - assert (t["K"]["이름"], t["E"]["이름"], t["f"]["이름"]) == ( - "버킷계수", - "작업효율", - "체적환산계수", - ) - assert (t["cm"]["이름"], t["cm"]["단위"]) == ("1회 싸이클시간", "sec") # 801-5 원문 표 머리 「싸이클시간(Sec)」 꼴 - - carry = (BOOK / "제01장_적용기준/1-02_설계_및_수량.md").read_text(encoding="utf-8") - for line in ( - "T : 1일 실작업시간", - "L : 운반거리(m)", - "t : 적재적하 시간(분)", - "V : 평균왕복속도(m/hr)", - "N : 1일 운반횟수", - ): - assert line in carry, line - t = _table("GC001140") - got = { - k: meq.token(t[k]) - for k in ("운반거리", "실작업시간", "적재적하시간", "평균왕복속도", "일운반회수") - } - assert got == { - "운반거리": "L", - "실작업시간": "T", - "적재적하시간": "t", - "평균왕복속도": "V", - "일운반회수": "N", - } - - dozer = (BOOK / "제08장_건설기계/8-02-01_불도저.md").read_text(encoding="utf-8") - for line in ("V_1 : 전진속도(m/분)", "V_2 : 후진속도(m/분)", "e : 운반거리계수"): - assert line in dozer, line - t = _table("GC001144") - assert (t["V1"]["기호"], t["V1"]["아래"], t["V1"]["이름"]) == ("V", "1", "전진속도") - assert (t["V2"]["기호"], t["V2"]["아래"], t["V2"]["이름"]) == ("V", "2", "후진속도") - assert meq.token(t["V1"]) == "V_1" and t["e"]["이름"] == "운반거리계수" - - -if __name__ == "__main__": - pytest.main([__file__, "-q"]) diff --git a/resources/tester/test_800_1_var_symbols.py b/resources/tester/test_800_1_var_symbols.py deleted file mode 100644 index 02c7239a1..000000000 --- a/resources/tester/test_800_1_var_symbols.py +++ /dev/null @@ -1,213 +0,0 @@ -"""800-1 변수 기호 기본값 지킴 (요구 660-1 · 659-2) — 수식 탭 왼쪽 식에 한글 변수가 안 보임. - -① 규칙(`master_symbol.rule`) 표본 — 끝말 → 머리글자 · 아래첨자 · 갈래별(찾기 위 「표」 · 요소 · 합 · 결과). -② 입력 · 중간 변수 — 기호에 한글 0 · 한 로직 안 겹침 0 · 같은 이름 같은 기호(원문 796-3 제외). - (한글 0 · 겹침 0 = 기본 로직 차례 고르게 600 · 전수 = `AISLO_TEST_ALL=1`) -③ 빌더 — 채운 정본에 쓸 것 없음 · 채운 것을 걷으면 같은 수만큼 다시 채움. -④ 수식 내보내기 — 표본 로직 전 변수 기호에 한글 0(찾기 · 요소 · 합 · 결과 포함) · 한 로직 안 겹침 없음. -⑤ 보이기만 — 변수표를 걷어도 엔진 셈 · 끝수 지문 같음(금액 전후 같음). -""" - -from __future__ import annotations - -import copy -import hashlib -import importlib -import json -import re -from functools import lru_cache - -import pytest -from helper_test_all import spread - -from M01_MasterData import M01_MasterData_Store as store - -meq = importlib.import_module("master_equation") -mf = importlib.import_module("master_formula") -mcut = importlib.import_module("master_cut") -ma = importlib.import_module("master_auto") -sym = importlib.import_module("master_symbol") -build = importlib.import_module("build_변수기호_800_1") -build796 = importlib.import_module("build_변수표_796_3") - -HAN = re.compile(r"[가-힣]") - - -@lru_cache(maxsize=1) -def loaded(): - return store.loaded() - - -def logic_rows() -> list[dict]: - return [r for d in loaded()[0].values() if d.get("그룹") == "로직" for r in d.get("줄", [])] - - -def test_규칙_표본(): - rule = sym.rule - assert rule("합판율")[:3] == ("r", "합판", "") - assert rule("사용횟수")[:3] == ("n", "사용", "") - assert rule("지형계수")[:3] == ("k", "지형", "") - assert rule("작업효율")[:3] == ("E", "작업", "") - assert rule("운반거리")[:3] == ("L", "운반", "") - assert rule("교량받침중량")[:3] == ("W", "교량받침", "") # 「량」 보다 「중량」 먼저 - assert rule("버킷용량")[:3] == ("q", "버킷", "") - assert rule("보통인부")[:3] == ("Q", "보통인부", "") - assert rule("지역")[:3] == ("S", "지역", "") # 고르는 말 - assert rule("E입력")[:3] == ("E", "입력", "") # 앞 영문 = 기호 - assert rule("폼타이", hint="고름")[0] == "S" and rule("구멍땜")[0] == "X" - assert rule("시공량", "찾기")[:3] == ("Q", "시공", "표") # 표 칸 = 위 「표」 - assert rule("보통인부노임", "요소")[:3] == ("w", "보통인부", "") - assert rule("합판단가", "요소")[:3] == ("P", "합판", "") - assert rule("형틀목공", "합")[:3] == ("C", "형틀목공", "") - assert rule("원/㎡", "결과")[:3] == ("P", "", "") and rule("㎥/hr", "결과")[:3] == ("Q", "", "") - assert sym.short("폼타이 12.7㎜") == "폼타이127" and len(sym.short("플랜트기계설치공")) <= 6 - assert sym.is_symbol("K") and sym.is_symbol("V_1") and not sym.is_symbol("합판율") - - -def test_기호에_한글_0_한_로직_겹침_0(): - for r in spread(logic_rows(), 600): - seen: dict[str, str] = {} - for v in meq.table(r): - assert not HAN.search(v["기호"]), (r["키"], v["열쇠"], v["기호"]) - for word in {meq.token(v), v["이름"]}: - assert seen.get(word, v["열쇠"]) == v["열쇠"], (r["키"], word) - seen.setdefault(word, v["열쇠"]) - - -def test_같은_이름_같은_기호(): - orig = build796.decisions() - got: dict[str, set[str]] = {} - for r in logic_rows(): - for key, look in (r.get(meq.FIELD) or {}).items(): - if (orig.get(r["키"]) or {}).get(key, {}).get("기호") or not look.get("기호"): - continue # 원문 · 추정(796-3) · 기호 없음 - if HAN.search(key) or not sym.is_symbol(key): - got.setdefault(key, set()).add(look["기호"]) - rules = {sym.rule(key, "변수", h)[:2] for h in ("", "고름", "중간")} - assert look["기호"] in {a for a, _ in rules}, (r["키"], key) - assert any(look.get("아래", "").startswith(b[:4]) for _, b in rules), (r["키"], key) - assert len(got) >= 1000 - assert all(len(v) == 1 for v in got.values()) - - -def test_빌더_쓸것_없음_그리고_걷으면_다시_채움(): - batch, stat = build.plan(loaded()[0]) - assert batch == [] and stat["변수"] == 0 - orig, files, cut = build796.decisions(), copy.deepcopy(loaded()[0]), 0 - for data in files.values(): - if data.get("그룹") != "로직": - continue - for r in data["줄"]: - for key in list((r.get(meq.FIELD) or {}).keys()): - if not (orig.get(r["키"]) or {}).get(key, {}).get("기호"): - look = r[meq.FIELD][key] - if look.get("기호") and not set(look) - {"기호", "아래", "위"}: - del r[meq.FIELD][key] - cut += 1 - _, again = build.plan(files) - assert cut >= 6000 and again["변수"] == cut - - -def _words(tree, out: list) -> None: - if isinstance(tree, dict): - if tree.get("꼴") == "변수": - out.append(tree) - for v in tree.values(): - _words(v, out) - elif isinstance(tree, list): - for v in tree: - _words(v, out) - - -SAMPLE = ("GC000211", "GF000089", "GC001147", "GC001140", "GC001144", "GC000087", "GC000303") - - -def test_수식_내보내기_표본_한글_기호_0(): - whole = loaded()[1] - rows = [r["키"] for r in logic_rows()] - for code in (*SAMPLE, *rows[::60]): - eq = meq.export(whole, str(code)) - found: list[dict] = [] - _words(eq["줄"], found) - _words(eq["풀이"], found) - assert found, code - for v in found: - assert not HAN.search(v.get("기호") or v.get("열쇠") or ""), ( - code, - v["갈래"], - v["열쇠"], - ) - - -def test_합판거푸집_표본_글(): - eq = meq.export(loaded()[1], "GC000211") - head = {x["열쇠"]: x for x in eq["줄"]} - tok = lambda n: sym._text(n["기호"], n.get("아래", ""), n.get("위", "")) # noqa: E731 - assert tok(head["합판율"]["결과"]) == "r_합판" - found: list[dict] = [] - _words(head["합판율"]["이름식"], found) - assert {tok(v) for v in found} >= {"n_사용", "Q_합판^표"} - tokens = [] - _words(eq["줄"], found := []) - tokens = {tok(v) for v in found} - assert {"Q_시공", "Q_시공^표", "w_형틀목공", "C_형틀목공", "P_합판", "S_폼타이"} <= tokens - - -def test_한_로직_안_다른_이름_같은_글이면_숫자(): - out = { - "결과단위": "원/㎡", - "변수표": [], - "줄": [ - { - "갈래": "호표", - "결과": { - "꼴": "변수", - "갈래": "합", - "열쇠": n, - "이름": n, - "기호": n, - "아래": "", - "위": "", - }, - } - for n in ("공기압축기 21㎥/min", "공기압축기 10.5㎥/min", "공기압축기 21㎥/min") - ], - } - sym.apply(out) - got = [meq.token(x["결과"]) for x in out["줄"]] - assert got == ["C_공기압축기", "C_공기압축기2", "C_공기압축기"] - - -def _print(whole, row) -> str: - try: - raw = mf.run( - whole, - str(row["키"]), - { - **ma.values(whole, row), - **{k: v for k, v in ma.defaults(whole, row).items() if v is not None}, - }, - ) - text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False) - text += json.dumps( - mcut.engine(whole, str(row["키"]), raw), default=str, sort_keys=True, ensure_ascii=False - ) - except Exception as e: # 멈춤도 지문 - text = f"ERR {type(e).__name__} {e}" - return hashlib.sha256(text.encode()).hexdigest()[:16] - - -def test_셈_전후_같음_변수표_걷어도(): - now = loaded()[1] - files = copy.deepcopy(loaded()[0]) - for data in files.values(): - if data.get("그룹") == "로직": - for row in data["줄"]: - row.pop(meq.FIELD, None) - before = mf.Master(files) - for code in [r["키"] for r in logic_rows()][::6]: - assert _print(now, now.logic(code)) == _print(before, before.logic(code)), code - - -if __name__ == "__main__": - pytest.main([__file__, "-q"]) diff --git a/resources/tester/test_801_5_units.py b/resources/tester/test_801_5_units.py deleted file mode 100644 index d62fac7d8..000000000 --- a/resources/tester/test_801_5_units.py +++ /dev/null @@ -1,118 +0,0 @@ -"""801-5 M01 로직 단위 글 = 건설품셈 원문 꼴(요구 663-2) 지킴 — 글만 바꿈 · 금액 그대로. - -① 대응표 근거 — 규칙마다 근거 절 파일이 있고 그 안에 원문 글이 실제로 있음(+ 지금 글은 같은 꼴로 안 쓰임) -② 섞임 0 — M01 로직 입력 · 중간 · 결과단위가 원문 꼴로 다 바뀌어 있음(규칙이 더 바꿀 것 없음 · 두 번 돌려도 같음) -③ 금액 같음 — 변수 단위 글을 지워도 엔진 셈 · 끝수 지문이 같음(단위 글은 셈에 안 듦) -④ M02 사본 도구 — 같은 규칙으로 사본 줄 단위만 바뀌고 `판` 다시 셈 -""" - -from __future__ import annotations - -import copy -import importlib -import re - -import pytest - -from M01_MasterData import M01_MasterData_Store as store - -ut = importlib.import_module("master_unit_text") -mf = importlib.import_module("master_formula") -build = importlib.import_module("build_단위표기_801_5") - - -def _rows(): - for data in store.loaded()[0].values(): - if data.get("그룹") == "로직": - yield from data["줄"] - - -def test_대응표_근거_절에_원문_글이_있음(): - assert len(ut.RULES) >= 7 - for name, _, to, token, files in ut.RULES: - assert files and to == token, name - for rel in files: - path = ut.EVIDENCE_ROOT / rel - assert path.is_file(), (name, rel) - assert token in path.read_text(encoding="utf-8"), (name, rel) - - -def test_규칙_예(): - got = { - u: ut.canon(u) - for u in ("㎥/시간", "㎡/시간", "㎢/시간", "원/시간", "초", "초/m", "mm", "TON/㎡") - } - assert got == { - "㎥/시간": "㎥/hr", - "㎡/시간": "㎡/hr", - "㎢/시간": "㎢/시간", # 원문 9-5-4 가 쓰는 꼴 — 안 건드림 - "원/시간": "원/시간", - "초": "sec", - "초/m": "sec/m", - "mm": "㎜", - "TON/㎡": "ton/㎡", - } - for u in got.values(): - assert ut.canon(u) == u # 두 번 돌려도 같음 - - -def test_섞임_0_원문_꼴로_다_바뀜(): - left = [] - for row in _rows(): - units = [row.get("결과단위")] + [ - s.get("단위") for k in ("입력", "중간") for s in row.get(k) or [] - ] - left += [(row["키"], u) for u in units if u and ut.canon(u) != u] - assert not left, left[:5] - - -def test_굴착기_Cm_sec_Q_hr(): - row = store.loaded()[1].logic("GF000088") # 토사깍기(굴착기 0.7㎥) 시간당 작업량 - assert {s["단위"] for s in row["중간"] if s["이름"] == "Cm"} == {"sec"} - assert row["결과단위"] == "㎥/hr" - - -_OLD = ( # 원문 꼴 → 옛 글(되돌려 본 꼴) — 두 꼴로 셈이 같음을 대조 - (re.compile(r"(? str: - for pat, old in _OLD: - text = pat.sub(old, text) - return text - - -def test_금액_같음_옛_글로_되돌려도_셈_지문_같음(): - files = store.loaded()[0] - old = copy.deepcopy(files) - for data in old.values(): - if data.get("그룹") == "로직": - for row in data["줄"]: - for k in ("입력", "중간"): - for s in row.get(k) or []: - s["단위"] = _legacy(s.get("단위") or "") - row["결과단위"] = _legacy(row.get("결과단위") or "") - now, was = mf.Master(files), mf.Master(old) - keys = [r["키"] for r in _rows()] - hit = { - r["키"] - for r in _rows() - if any( - _legacy(s.get("단위") or "") != (s.get("단위") or "") - for k in ("입력", "중간") - for s in r.get(k) or [] - ) - } - assert len(hit) >= 40 - for key in sorted(hit) + keys[::25]: - assert build.fingerprint(now, now.logic(key)) == build.fingerprint(was, was.logic(key)), key - - -if __name__ == "__main__": - pytest.main([__file__, "-q"]) diff --git a/resources/tester/test_802_2_convert.py b/resources/tester/test_802_2_convert.py deleted file mode 100644 index 8fca6a881..000000000 --- a/resources/tester/test_802_2_convert.py +++ /dev/null @@ -1,120 +0,0 @@ -"""802-2 옛 M01 로직 → 수식 문서 변환 · 금액 전수 대조 지킴 시험. - -빌더 `resources/master_data/scripts/build_수식문서_802_2.py`(한 번 돌림 · 2 분 안팎): -① --check — 다시 돌린 결과 = 저장본(`resources/master_data/수식문서/`) · 목록 xlsx. -② 로직 1,519 전수 기본 옵션 = 옛 엔진 노 · 재 · 경 · 계(결과) 원 단위 같음. -③ 옵션 표본 — 로직마다 고르기 입력의 모든 갈래 한 번 이상 · 같음 수 · 다름 = 목록 · 까닭 모름 0. -④ 저장 = 같은 것만(부르는 단가산출까지 · 채택된 차이 GC000100 지역=경북 재료비 1 원 빼고) · 저장본을 읽어 다시 셈해도 같음. -⑤ 791 실무 손 옮김 견본 넷(번지 · 단계 · 합밖 · 줄 자리 · 끝전 · 조정 · 값묶음)도 변환 셈 = 엑셀 금액. -""" - -import importlib -import sys -from pathlib import Path - -import pytest - -from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 - -HERE = Path(__file__).resolve().parent -build = importlib.import_module("build_수식문서_802_2") -mc = importlib.import_module("master_doc_calc") -ml = importlib.import_module("master_doc_link") -cv = importlib.import_module("master_doc_convert") -mf = importlib.import_module("master_formula") -mcut = importlib.import_module("master_cut") - - -@pytest.fixture(scope="module") -def result(): - return build.build(log=lambda *a: None) - - -def test_빌더_check_저장본_목록_같음(result): - assert build.lost(result) == [] # 저장본 문서를 조용히 빼지 않음(842-3 뒤 · 빌더가 멈추고 알림) - assert build.check(result) == [] - - -def test_로직_전수_기본_옵션_같음(result): - files, _ = m01.loaded() - count = sum(len(d.get("줄") or []) for d in files.values() if d.get("그룹") == "로직") - info = result["요약"] - assert info["로직"] == count >= 1513 # 813-2 지움 6 - assert info["기본 같음"] == count and info["기본 다름"] == 0 - assert info["변환 알림"] == 0 - - -def test_옵션_표본_모든_갈래_한_번_이상(result): - files, _ = m01.loaded() - seen = {(x["로직"], x["옵션"]) for x in result["대조"] if x["옵션"]} - want = 0 - for _, row in build.rows_of(files): - base = build.meq.given_of(_whole(), row) - for spec in row.get("입력") or []: - for opt in spec.get("고르기") or []: - if str(opt) != str(base.get(spec["이름"])): - want += 1 - assert (row["키"], f"{spec['이름']}={opt}") in seen - info = result["요약"] - assert info["옵션 표본"] == want == info["옵션 같음"] + info["옵션 다름"] - assert ( - info["옵션 같음"] >= 18400 and info["옵션 다름"] == info["채택된 차이"] == 3 - ) # 813-2: 지운 6 문서 표본 빠져 18,438 · 840-5 조종원 환산 뒤 채택 셋 - - -def _whole(): - return m01.loaded()[1] - - -def test_다름_목록_까닭(result): - rows = build.table_rows(result) - sheet = build.read_list()["다름"] - assert sheet[0] == list(build.HEAD) and sheet[1:] == rows - diff = [x for x in result["대조"] if not x["같음"]] - assert all(x["까닭"] != "까닭 모름" for x in diff) - # 채택된 차이(요구 714-3) — 식 속 단가산출 부름 값 = 끝수 뒤 · 재료비 1 원 · 저장은 함 - assert [(x["로직"], x["옵션"], x["채택"]) for x in diff] == [ - ("GC000091", "지역=울산", True), - ("GC000093", "지역=경북", True), - ("GC000100", "지역=전북", True), - ] # 840-5 조종원 1/8 × 16/12 × 25/20 뒤 — 같은 까닭 1 원 셋(옛 GC000100 경북 = 같아짐) - assert diff[0]["까닭"].startswith(build.RAW_SUB) - assert diff[0]["옛"]["재료비"] != diff[0]["새"]["재료비"] - assert abs(diff[0]["새"]["재료비"] - diff[0]["옛"]["재료비"]) == 1 - assert {k: diff[0]["옛"][k] for k in ("노무비", "경비")} == { - k: diff[0]["새"][k] for k in ("노무비", "경비") - } - - -def test_저장_같은_것만_다시_셈(result): - saved = ml.load_all() - assert set(saved) == result["저장"] - assert "GC000100" in saved and len(saved) == result["요약"]["저장"] >= 1513 - base = next(x for x in result["대조"] if x["로직"] == "GC000100" and not x["옵션"]) - assert ( - base["같음"] - and build.new_answer(ml.Links(_whole(), saved), saved["GC000100"]) == base["옛"] - ) - for key in ("GC000211", "GC001147", "GF000294", "GC000087"): - doc = saved[key] - got = build.new_answer(ml.Links(_whole(), saved), doc) - old = next(x for x in result["대조"] if x["로직"] == key and not x["옵션"])["옛"] - assert got == old - - -# ── ⑤ 791 실무 견본 ──────────────────────────────────────────────────── -def _semantics(): - sys.path.insert(0, str(HERE)) - return importlib.import_module("test_791_1_engine_semantics") - - -@pytest.mark.parametrize("name", ["봉화", "소광", "영월", "임도"]) -def test_791_실무_견본_변환_셈_같음(name): - t = _semantics() - master, row, want = getattr(t, name)() - old = mcut.engine(master, row["키"], mf.run(master, row["키"], {})) - doc, notes = cv.convert(master, row, {}) - got = mc.calc(doc, ml.Links(master, {row["키"]: doc})) - assert got["셈됨"], got["표지"] - assert {k: got[k] for k in want} == {k: old[k] for k in want} == want - assert not [x for x in notes if not x.startswith("기호")] diff --git a/resources/tester/test_802_3_doc_screen.py b/resources/tester/test_802_3_doc_screen.py index 3191a3289..5222ec98f 100644 --- a/resources/tester/test_802_3_doc_screen.py +++ b/resources/tester/test_802_3_doc_screen.py @@ -198,30 +198,3 @@ def test_표_하나(client): table = client.get("/api/m01/logic/doc/table", params={"key": "QF000249"}).json() assert "조건" in table and table["줄"] assert "끊김" in client.get("/api/m01/logic/doc/table", params={"key": "LB000002"}).json() - - -def test_옮김_군더더기_없음(): - """저장 문서 식 · 금액 글에 `+ 0` · `× 1` · `÷ 1` · `× k ÷ 100` 없음(옮김 `slim` · 값 같음).""" - import master_doc as md - import master_doc_convert as cv - import master_doc_link as ml - - def junk(n) -> bool: - if n[0] == "bin": - a, b = n[2], n[3] - if n[1] in ("+", "-", "*", "/") and cv.slim(n) != n: - return True - return junk(a) or junk(b) - if n[0] in ("neg", "pct", "field"): - return junk(n[1]) - return n[0] == "call" and any(junk(x) for x in n[2]) - - bad = [] - for key, doc in ml.load_all().items(): - texts = [x.get("식") for x in doc.get("식") or []] - texts += [x.get(k) for x in doc.get("금액") or [] for k in ("수량", "단가")] - for t in texts: - if t and junk(md.parse(t)): - bad.append((key, t)) - assert not bad, bad[:5] - assert md.text_of(cv.slim(md.parse("(r + 0) × 1 × 2 ÷ 100 ÷ 1"))) == "r × 2%" diff --git a/resources/tester/test_804_7_line_stack_fix.py b/resources/tester/test_804_7_line_stack_fix.py index 6c8d0bf0c..566ae6e3e 100644 --- a/resources/tester/test_804_7_line_stack_fix.py +++ b/resources/tester/test_804_7_line_stack_fix.py @@ -170,12 +170,6 @@ def test_요소키_기호_이름_0_전수() -> None: assert bad == [] ids = {doc_screen.md.var_id(v) for v in docs["GF000011"]["변수"]} assert {"k_하베스터", "P_하베스터", "k_굴착기", "P_굴착기"} <= ids - import master_doc_convert as cv - - whole = store.loaded()[1] - for key in ("GF000011", "GF000145", "GC001043"): - got, _ = cv.convert(whole, store.logic(key)["logic"]) - assert not [v for v in got["변수"] if CODE.match(str(v.get("아래") or ""))], key def test_단위_고르기_공용_친글() -> None: diff --git a/resources/tester/test_848_4_machine_split.py b/resources/tester/test_848_4_machine_split.py index 20c7777ab..5c2bf66fc 100644 --- a/resources/tester/test_848_4_machine_split.py +++ b/resources/tester/test_848_4_machine_split.py @@ -1,4 +1,4 @@ -"""848-4 기계 한 대 = 줄 하나 — 조합 줄 나눔 금액 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더가 모르는 문서 지킴. +"""848-4 기계 한 대 = 줄 하나 — 조합 줄 나눔 금액 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸. ① 216 짝(굴착기 × 집게 · 브레이커 × 보정작업) — 부착 조합 굴착기 식(GC001202) + 부착 손료(GC000273) = 옛 조합 식 (GC000270 · 271) 노 · 재 · 경 같음(8-4 주⑤ 잡재료 16 % 가 식 안). @@ -6,7 +6,6 @@ ③ 부착 줄 수량 = 주 기계 줄 수량 — 주 줄을 시간당으로 · 변수 고침 · 되돌림에 같이 · 부착 줄 고침은 안 걸림 · 저장 정리에서 지움 · 답 꼴 「따름」. ④ 굴착기 작업량 식 `K입력` — 넣으면 그 값 · 0 = 표(버킷조건). -⑤ 빌더 — 옛 로직 줄 없는 저장본 문서(자체 로직 · 화면에서 만든 문서)를 안 지우고 제 파일 그대로 · 빠짐 목록에 안 듦. ⑥ 불러오기 조합 첫 줄 = 부착 조합 굴착기 식 · 기계 식 고름은 GC001202 를 안 고름. ⑦ 거울 — 부착 줄 따름 · 묶음 끝수를 파이썬 · TS 가 같게. """ @@ -15,7 +14,6 @@ import importlib import itertools import json import os -import shutil import subprocess from decimal import Decimal as D @@ -31,7 +29,6 @@ mw = importlib.import_module("master_doc_work") mcut = importlib.import_module("master_cut") mf = importlib.import_module("master_formula") meq = importlib.import_module("master_equation") -build = importlib.import_module("build_수식문서_802_2") HERE = os.path.dirname(os.path.abspath(__file__)) COSTS = ("노무비", "재료비", "경비") @@ -153,49 +150,6 @@ def test_버킷계수_직접_칸(links): assert mc.calc(tpl, links, {"K입력": 0})["결과"] == base["결과"] -# ── ⑤ 빌더가 모르는 문서 ─────────────────────────────────────────────── -@pytest.fixture -def docs_tmp(tmp_path, monkeypatch): - dst = tmp_path / "수식문서" - dst.mkdir() - name = "로직_건설품셈_08장_건설기계.json" - shutil.copy(ml.FOLDER / ml.file_of(name), dst) - shutil.copy(ml.FOLDER / "수식_자체.json", dst) - monkeypatch.setattr(ml, "FOLDER", dst) - return dst, name - - -def test_빌더_모르는_문서_안_지움_그대로(docs_tmp): - dst, name = docs_tmp - files, whole = m01.loaded() - rows = files[name]["줄"] - own = dst / "수식_자체.json" - data = ml.load_file(own) - data["줄"].append(ml._norm({**data["줄"][0], "키": "GX999999", "이름": "sub2임시 화면 자체"})) - own.write_text(ml.dump(data), encoding="utf-8", newline="\n") - loose = dst / "수식_손.json" # 빌더 모르는 파일 - loose.write_text(ml.dump({"그룹": "수식문서", "로직파일": "", "줄": [{**data["줄"][0], "키": "GX999998"}]}), - encoding="utf-8", newline="\n") # fmt: skip - before = {p.name: p.read_text(encoding="utf-8") for p in dst.iterdir()} - keys = [str(r["키"]) for r in rows] - result = { - "문서": {str(r["키"]): build.cv.convert(whole, r)[0] for r in rows}, - "파일": {name: keys}, - "저장": set(keys), - "저장본": build.carried(), - "대조": [], - "알림": {}, - "요약": {}, - } - want = build.files_of(result) - assert want["수식_손.json"] == before["수식_손.json"] - assert want["수식_자체.json"] == before["수식_자체.json"] # GX 자체 문서 · 화면 문서 그대로 - assert want[ml.file_of(name)] == before[ml.file_of(name)] - assert build.lost(result) == [] - assert {"GX000004", "GX999999", "GX999998"} <= set(build.foreign_keys(result)) - assert [x for x in build.check(result) if not x.startswith("다른 목록")] == [] - - # ── ⑥ 불러오기 조합 · 기계 식 고름 ──────────────────────────────────── def test_불러오기_조합_첫_줄_부착_조합_식(monkeypatch): from M02_MasterTemplete import M02_Machine_Hourly as mh diff --git a/resources/tester/test_m01_search_words.py b/resources/tester/test_m01_search_words.py deleted file mode 100644 index 187b7cce6..000000000 --- a/resources/tester/test_m01_search_words.py +++ /dev/null @@ -1,74 +0,0 @@ -# -*- coding: utf-8 -*- -"""PLAN 8-3 — 로직 재료 줄 키 → 기본 검색어 바꿔 넣기(`build_재료_검색어.py`).""" - -from __future__ import annotations - -import json -import sys -from pathlib import Path - -import pytest - -ROOT = Path(__file__).resolve().parents[2] -sys.path.insert(0, str(ROOT / "resources/master_data/scripts")) - -import build_재료_검색어 as bw # noqa: E402 -import check_master as cm # noqa: E402 -import master_auto as mau # noqa: E402 -import master_formula as mf # noqa: E402 -import master_pick as mp # noqa: E402 - - -@pytest.fixture(scope="module") -def master() -> mf.Master: - return mf.Master(cm.load()) - - -def _material(master, key: str, name: str) -> dict: - return next(h for h in master.logic(key)["호표"] if h.get("이름") == name) - - -def test_결속선은_원문대로_고른_어닐링철선이_그대로_첫째(master) -> None: - item = _material(master, "GC000037", "결속선 # 10") - assert "대표" not in item["요소"] and item["요소"]["검색어"].startswith("어닐링철선") - row = master.logic("GC000037") - got = mp.search(master, item["요소"], mau.values(master, row), item["단위"]) - assert got[0] == "MT000204" # 어닐링철선 #10 서울 — 옛 입력 「결속선」 목록 첫째 - - -def test_재료_입력_키_목록은_걷히고_넘기던_인자도_없음(master) -> None: - for name, data in cm.load().items(): - if not name.startswith("로직_"): - continue - for row in data["줄"]: - assert not bw.material_inputs(row), row["키"] - call = next(h["요소"] for h in master.logic("GF000169")["호표"] if "GF000160" in h["요소"]) - assert "횟수=" in call and "철선=철선" not in call and "합판=합판" not in call - - -def test_남은_대표는_값_빈_자리표_품목만(master) -> None: - """검색어로 못 가르는 줄(규격 빈 자리표 MT030…)만 대표가 남음 — 목록으로 알린 줄.""" - reps = { - str(h["요소"]["대표"]) - for data in cm.load().values() - for row in data.get("줄", []) - if "호표" in row - for h in row["호표"] - if isinstance(h.get("요소"), dict) and h["요소"].get("대표") - } - assert reps and all(k.startswith("MT0306") for k in reps), reps - - -def test_글_갈음은_바뀐_값_자리만(master) -> None: - text = ( - '{ "키": "GX1", "입력": [\n { "이름": "철선", "고르기": ["MT000199"] },\n' - ' { "이름": "횟수", "고르기": ["1회"] }\n],\n "호표": [\n' - ' { "종류": "재료", "요소": {"구분": "철근·강재", "대표": "{철선}"}, "수량": "1" },\n' - ' { "종류": "로직", "요소": "로직(GF000160, 횟수=횟수, 철선=철선)", "수량": "1" }\n] }' - ) - row = json.loads(text) - change = {"요소": {0: {"구분": "철근·강재", "검색어": "어닐링철선 #8 서울"}}, "걷음": ["철선"]} - got = bw._patch_row(text, row, change) - assert json.loads(got) == bw.apply(row, change) - assert '"이름": "횟수"' in got and "철선=철선" not in got and "횟수=횟수" in got - assert got.count("\n") == text.count("\n") - 1 # 걷은 입력 한 줄만 빠짐