refactor(855-E L4): 빌더 은퇴 — 수식 문서 빌더 · 변환기 · 로직 줄 채우기 · 한 번용 지움

- 지움: build_수식문서_802_2 · master_doc_convert · 「로직 줄을 더한 뒤 채우기」 넷(build_변수표_796_3 ·
  build_변수기호_800_1 · build_단위표기_801_5 · build_재료_검색어) · 변수표_796_3.json · 다 돈 한 번용
  (build_로직_직접칸_851_1 · build_용도 · analyze_식_복사 · 로직_복잡도_재기 · check_값없는줄)
- 그것만 붙들던 시험 지움: test_802_2_convert · test_796_3 · test_800_1 · test_801_5 · test_m01_search_words ·
  802_3 옮김 군더더기 · 804_7 변환 표본 · 848_4 빌더 모르는 문서
- helper_855_engine 빌더 부름 = 옛 대조 함수 안으로(855_golden 새 계산기 지문 지킴)
- _갱신절차.md 로직 절 · 수식 문서 절 → 수식 문서 절 하나(빌더 없음 · 고치는 길 = 화면 [저장] · 문서 고침 스크립트)
- 855_golden · 802_1 거울 · 855_b09_golden · 855_e4a 통과 · 서버 답 243 건 다름 0 · openapi 469 같음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 14:20:49 +09:00
co-authored by Claude Opus 5.5
parent cd608862fa
commit 7829d88b22
23 changed files with 12 additions and 4556 deletions
+8 -26
View File
@@ -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` |
## 로직 (`로직_<원문>_<NN>장_….json`)
## 수식 문서 = 단가산출 기초 (`수식문서/수식_<원문>_<NN>장_….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 [--쓰기]`(재료 줄 자재품목 키 → 검색어)
## 수식 문서 (`수식문서/수식_<원문>_<NN>장_….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장 밖 — 빌더 없음.
- 자재품목 — 나라장터 스냅샷 → 마스터 줄 빌더 없음 · 유료 물가지 받는 길 미정.
@@ -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()
@@ -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()
@@ -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()
@@ -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()
@@ -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()
@@ -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())
@@ -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()
@@ -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))
@@ -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())
@@ -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
@@ -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일당」 …)인 표의 수량 칸
@@ -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()
@@ -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(굴착기 시간당 작업량)", "확신": "원문"}
}
}
}
+2 -2
View File
@@ -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])
-200
View File
@@ -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"])
-213
View File
@@ -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"])
-118
View File
@@ -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"(?<![가-힣A-Za-z])sec(?![A-Za-z])"), "초"),
(re.compile(r"(?<=[㎥㎡])/hr"), "/시간"),
(re.compile("㎜"), "mm"),
(re.compile("㎝"), "cm"),
(re.compile("㎏"), "kg"),
(re.compile("㎞/hr"), "km/hr"),
)
def _legacy(text: str) -> 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"])
-120
View File
@@ -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("기호")]
-27
View File
@@ -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%"
@@ -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:
+1 -47
View File
@@ -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
-74
View File
@@ -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 # 걷은 입력 한 줄만 빠짐