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
@@ -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(굴착기 시간당 작업량)", "확신": "원문"}
}
}
}