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