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:
@@ -63,7 +63,7 @@
|
||||
## 품셈재료
|
||||
|
||||
- 첫 층에 없음 — `old/재료_품셈재료.json` 은 시험 기준 자료(`test_자재품목_분류.py`)로만 둠.
|
||||
- 로직 재료 줄 = 자재품목 고르기 조건 · 검색어(아래 로직 채우기).
|
||||
- 기초 재료 = 수식 문서 변수 연결 「재료」(자재품목 고르기 조건 · 검색어).
|
||||
|
||||
## 기계 (폴더 `기계/` = 한 대 한 파일 · 읽기 · 쓰기 `master_machine_files` · 원문 건설품셈 · 산림품셈)
|
||||
|
||||
@@ -94,7 +94,7 @@
|
||||
| 산림 그 밖 장 | 산림품셈 본문 각 장 | 같음 | 같음 | 빌더 없음 | 같음 |
|
||||
| 건설 전 장 | 건설품셈 본문 각 부문 | 같음 | 연 1회 | 빌더 없음(소요량 빌더 안 계수 손 표는 소요량에 들어감) | 같음 |
|
||||
|
||||
- 소요량 · 계수 표를 다시 지은 뒤 = `scripts/build_용도.py`(표마다 「용도」 · 다시 돌려도 같음).
|
||||
- 소요량 · 계수 표를 다시 지으면 표마다 「용도」 는 그대로 옮김(채우는 스크립트 없음 — 구멍).
|
||||
|
||||
## 환율 (`환율_한국은행환율.json`)
|
||||
|
||||
@@ -116,37 +116,19 @@
|
||||
| 빌더 | `scripts/build_요율.py --check`(대조만 · 정본 안 씀 · 다른 줄은 원문 셀 자리와 같이 나옴) · 요율 화면 책 = `scripts/build_제비율책.py`(→ `제비율엑셀/조달청_제비율_책.json` · 판마다) |
|
||||
| 검사 | `build_요율.py --check` · `build_제비율책.py --check` · `check_master.py 틀 요율_조달청제비율.json` |
|
||||
|
||||
## 로직 (`로직_<원문>_<NN>장_….json`)
|
||||
## 수식 문서 = 단가산출 기초 (`수식문서/수식_<원문>_<NN>장_….json`)
|
||||
|
||||
| 항목 | 값 |
|
||||
| --- | --- |
|
||||
| 출처 | 품셈 본문 절 + 위 요소·표 파일(키로 끌어옴) · 자체 로직은 원문 「자체」 |
|
||||
| 받는 법 | M01 화면에서 편집·저장 (정본 파일 직접 편집도 가능) |
|
||||
| 출처 | 품셈 본문 절 + 위 요소·표 파일(변수 연결 = 키) · 자체 기초는 `수식_자체.json` |
|
||||
| 받는 법 | M01 화면 [저장](줄 쌓기 · 이름표 · 별칭) · 문서 고침 스크립트 — 빌더 없음 |
|
||||
| 주기 | 요소 갱신 때 · 품셈 개정 때 |
|
||||
| 빌더 | 빌더 없음 — 줄 칸 「개정」만 `scripts/build_로직_개정.py`(원문 절 머리 개정 연도 · 품셈 개정 때) |
|
||||
| 검사 | `check_master.py 로직` (끊긴 키 · 돌고 도는 참조 · 찾기 조건) · `check_master.py 계산 <로직키> 이름=값 …` (견본 계산) · `pytest resources/tester/test_masterdata_check.py resources/tester/test_m01_api.py -q` |
|
||||
| 복잡도 | `scripts/로직_복잡도_재기.py [상위 N]` (읽기 전용) |
|
||||
|
||||
로직 줄을 더한 뒤 채우기(차례대로 · 모두 `--check` 로 남은 것만 봄 · 다시 돌려도 같음):
|
||||
|
||||
1. `scripts/build_변수표_796_3.py`(변수 국문 이름 · 기호 · 단위 — 결정 자료 `scripts/변수표_796_3.json`)
|
||||
2. `scripts/build_변수기호_800_1.py`(남은 변수 기호)
|
||||
3. `scripts/build_단위표기_801_5.py`(단위 글 원문 꼴)
|
||||
4. `scripts/build_재료_검색어.py [--쓰기]`(재료 줄 자재품목 키 → 검색어)
|
||||
|
||||
## 수식 문서 (`수식문서/수식_<원문>_<NN>장_….json`)
|
||||
|
||||
| 항목 | 값 |
|
||||
| --- | --- |
|
||||
| 출처 | 로직 JSON(위) — 변환 `master_doc_convert` · 셈 `master_doc_calc` |
|
||||
| 받는 법 | 로직 · 요소를 고친 뒤 빌더로 다시 지음 · 화면 [저장]은 문서에 바로 씀 |
|
||||
| 주기 | 로직 · 요소 갱신 때 |
|
||||
| 빌더 | `scripts/build_수식문서_802_2.py`(변환 · 금액 전수 대조 · 저장) |
|
||||
| 검사 | `build_수식문서_802_2.py --check`(저장본 · 목록과 같음) · `pytest resources/tester/test_802_2_convert.py -q` |
|
||||
| 채우기 | 줄 머리 「개정」 = `scripts/build_로직_개정.py [--check]`(원문 절 머리 개정 연도 · 품셈 개정 때) |
|
||||
| 검사 | `check_master.py 로직`(문서 막힘 · 돌고 도는 참조 · 키 겹침 · 대장) · `check_master.py 조합` · `pytest resources/tester/test_855_golden.py resources/tester/test_802_1_formula_doc.py -q` |
|
||||
|
||||
## 구멍 목록
|
||||
|
||||
- 로직 — 빌더 없음(채우기 · 수식 문서만).
|
||||
- 수식 문서 — 빌더 없음(화면 · 문서 고침 스크립트만) · 표 「용도.로직키」 를 다시 채우는 문서 대상 스크립트 없음.
|
||||
- 요율 — 대조(`--check`)만 됨 · 값을 정본에 반영하는 쓰기는 여전히 손으로.
|
||||
- 기계 산림품셈 · 소요량 건설 건축·유지관리 · 소요량 산림 전 장 · 계수 건설 전 장 · 계수 산림 1장 밖 — 빌더 없음.
|
||||
- 자재품목 — 나라장터 스냅샷 → 마스터 줄 빌더 없음 · 유료 물가지 받는 길 미정.
|
||||
|
||||
@@ -1,155 +0,0 @@
|
||||
"""로직 복사 설계용 — 호표·중간·덧줄 식 속 찾기()·로직() 전수 세기 (읽기 전용 · 아무것도 안 씀).
|
||||
|
||||
resources/master_data/ref/_설계_식_복사.md 의 ② 수치 근거.
|
||||
|
||||
사용: ./venv/Scripts/python.exe resources/master_data/scripts/analyze_식_복사.py
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
NAME_OF = re.compile(r"(찾기|로직)\(\s*([A-Za-z0-9]+)")
|
||||
|
||||
|
||||
def find_calls(text: str) -> list[tuple[str, str, str]]:
|
||||
"""text 안 찾기(...)·로직(...) 전부 — (종류, 키, 괄호 안 전체 글) 목록. 중첩 괄호는 짝을 맞춰 끊음."""
|
||||
out = []
|
||||
for m in NAME_OF.finditer(text):
|
||||
kind, key = m.group(1), m.group(2)
|
||||
start = m.start() + len(kind) # '(' 위치 — 찾기·로직 바로 뒤
|
||||
depth = 0
|
||||
i = start
|
||||
while i < len(text):
|
||||
if text[i] == "(":
|
||||
depth += 1
|
||||
elif text[i] == ")":
|
||||
depth -= 1
|
||||
if depth == 0:
|
||||
break
|
||||
i += 1
|
||||
args = text[start + 1 : i]
|
||||
out.append((kind, key, args.strip()))
|
||||
return out
|
||||
|
||||
|
||||
def row_lines(row: dict) -> list[tuple[str, str]]:
|
||||
"""(자리표, 식 글) 목록 — 호표 수량 · 호표 요소(문자열일 때) · 중간 식 · 덧줄 식."""
|
||||
out = []
|
||||
for i, h in enumerate(row.get("호표") or []):
|
||||
if isinstance(h.get("수량"), str):
|
||||
out.append((f"호표[{i}].수량", h["수량"]))
|
||||
if isinstance(h.get("요소"), str):
|
||||
out.append((f"호표[{i}].요소", h["요소"]))
|
||||
for i, m in enumerate(row.get("중간") or []):
|
||||
if isinstance(m.get("식"), str):
|
||||
out.append((f"중간[{i}].식", m["식"]))
|
||||
for i, m in enumerate(row.get("덧줄") or []):
|
||||
if isinstance(m.get("식"), str):
|
||||
out.append((f"덧줄[{i}].식", m["식"]))
|
||||
return out
|
||||
|
||||
|
||||
def load_table_names() -> dict[str, str]:
|
||||
"""표 키 → 표 이름 (소요량_*.json · 계수_*.json)."""
|
||||
names = {}
|
||||
for path in list(ROOT.glob("소요량_*.json")) + list(ROOT.glob("계수_*.json")):
|
||||
data = json.loads(path.read_text(encoding="utf-8"))
|
||||
for t in data.get("표", []):
|
||||
names[t["키"]] = t.get("이름", "")
|
||||
return names
|
||||
|
||||
|
||||
def load_logic_names() -> dict[str, str]:
|
||||
names = {}
|
||||
for path in ROOT.glob("로직_*.json"):
|
||||
data = json.loads(path.read_text(encoding="utf-8"))
|
||||
for row in data.get("줄", []):
|
||||
names[row["키"]] = row.get("이름", "")
|
||||
return names
|
||||
|
||||
|
||||
def main() -> None:
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
table_names = load_table_names()
|
||||
logic_names = load_logic_names()
|
||||
|
||||
total_rows = 0
|
||||
total_찾기 = 0
|
||||
total_로직 = 0
|
||||
rows_with_call = 0
|
||||
multi_call_lines = 0 # 한 줄(자리표 하나)에 찾기·로직 합쳐 2번 이상
|
||||
rows_with_dup_call = 0 # 같은 행 안에서 (종류,키,인자) 짝이 완전히 같은 호출이 2번 이상
|
||||
dup_call_examples = []
|
||||
name_collisions = {} # 표이름 -> {키, 키, ...} (다른 키가 같은 이름을 씀 — 별칭 지을 때 번호 필요)
|
||||
rows_with_collision = 0
|
||||
|
||||
for path in sorted(ROOT.glob("로직_*.json")):
|
||||
data = json.loads(path.read_text(encoding="utf-8"))
|
||||
for row in data.get("줄", []):
|
||||
total_rows += 1
|
||||
row_calls = []
|
||||
has_call = False
|
||||
for place, text in row_lines(row):
|
||||
calls = find_calls(text)
|
||||
if not calls:
|
||||
continue
|
||||
has_call = True
|
||||
if len(calls) >= 2:
|
||||
multi_call_lines += 1
|
||||
for kind, key, args in calls:
|
||||
if kind == "찾기":
|
||||
total_찾기 += 1
|
||||
else:
|
||||
total_로직 += 1
|
||||
row_calls.append((kind, key, args, place))
|
||||
if has_call:
|
||||
rows_with_call += 1
|
||||
|
||||
sig_count = {}
|
||||
for kind, key, args, place in row_calls:
|
||||
sig = (kind, key, args)
|
||||
sig_count[sig] = sig_count.get(sig, 0) + 1
|
||||
dups = [s for s, c in sig_count.items() if c >= 2]
|
||||
if dups:
|
||||
rows_with_dup_call += 1
|
||||
if len(dup_call_examples) < 8:
|
||||
dup_call_examples.append((row["키"], dups[0][0], dups[0][1], sig_count[dups[0]]))
|
||||
|
||||
keys_in_row = {key for kind, key, args, place in row_calls if kind == "찾기"}
|
||||
names_seen = {}
|
||||
collided = False
|
||||
for key in keys_in_row:
|
||||
nm = table_names.get(key, key)
|
||||
names_seen.setdefault(nm, set()).add(key)
|
||||
for nm, keys in names_seen.items():
|
||||
if len(keys) >= 2:
|
||||
collided = True
|
||||
name_collisions.setdefault(nm, set()).update(keys)
|
||||
if collided:
|
||||
rows_with_collision += 1
|
||||
|
||||
print(f"로직 전체 줄 수: {total_rows}")
|
||||
print(f"찾기() 호출 수: {total_찾기}")
|
||||
print(f"로직() 호출 수: {total_로직}")
|
||||
print(f"찾기·로직 호출이 1개 이상 있는 줄: {rows_with_call}")
|
||||
print(f"한 자리(호표 수량 1칸·중간 식 1줄 등)에 호출이 2번 이상 겹친 자리 수: {multi_call_lines}")
|
||||
print(f"같은 행 안에서 (표·인자)가 완전히 같은 호출이 2번 이상 반복되는 행 수: {rows_with_dup_call}")
|
||||
print(" 보기:")
|
||||
for key, kind_str, args, count in dup_call_examples:
|
||||
print(f" {key} — {kind_str}({args[:40]}...) 를 {count}번")
|
||||
print(
|
||||
f"표 이름이 겹쳐(다른 키가 같은 표이름) 별칭에 번호가 필요한 행 수: {rows_with_collision}"
|
||||
)
|
||||
print(" 겹치는 표이름 보기:")
|
||||
for nm, keys in list(name_collisions.items())[:10]:
|
||||
print(f" '{nm}' <- {sorted(keys)}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,142 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""M01 로직 단위 글을 건설품셈 원문 꼴로 (PLAN 801-5 · 요구 663-2) — 글만 바꿈 · 셈 지문 그대로.
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_단위표기_801_5.py [--check | --list 파일.xlsx]
|
||||
- 대상 = M01 로직 줄의 입력 · 중간 변수 `단위` · `결과단위` — 규칙 · 근거 절 = `master_unit_text.RULES`.
|
||||
- 계수 · 소요량 표 값칸 · 호표 줄 단위 · 사용자가 이미 원문 꼴로 쓴 칸은 안 건드림(이미 같으면 그대로 — 두 번 돌려도 같음).
|
||||
- 쓰기 전 지문 대조 = 줄마다 엔진 셈 · 끝수 지문이 전후 같을 때만 씀(다르면 멈춤).
|
||||
- `--check` = 쓰지 않고 쓸 것이 남았는지만(남았으면 종료 코드 1) · `--list` = 검토 목록 xlsx 만 씀(마스터 안 씀).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE.parents[2]))
|
||||
import master_auto as ma # noqa: E402
|
||||
import master_cut as mcut # noqa: E402
|
||||
import master_formula as mf # noqa: E402
|
||||
import master_unit_text as ut # noqa: E402
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as st # noqa: E402
|
||||
|
||||
|
||||
def plan(files: dict[str, dict]) -> tuple[list[dict], list[dict], dict[str, dict]]:
|
||||
"""(저장 묶음, 목록 줄들, 새 files) — 읽기 전용."""
|
||||
batch, rows, new_files = [], [], {}
|
||||
for name, data in files.items():
|
||||
if data.get("그룹") != "로직":
|
||||
new_files[name] = data
|
||||
continue
|
||||
changes, new_data = [], copy.deepcopy(data)
|
||||
for row in new_data.get("줄", []):
|
||||
hit = False
|
||||
for kind in ("입력", "중간"):
|
||||
for spec in row.get(kind) or []:
|
||||
now = ut.canon(spec.get("단위"))
|
||||
if now != (spec.get("단위") or ""):
|
||||
rows.append(_item(row, kind, spec["이름"], spec["단위"], now))
|
||||
spec["단위"], hit = now, True
|
||||
if row.get("결과단위"):
|
||||
now = ut.canon(row["결과단위"])
|
||||
if now != row["결과단위"]:
|
||||
rows.append(_item(row, "결과단위", "", row["결과단위"], now))
|
||||
row["결과단위"], hit = now, True
|
||||
if hit:
|
||||
changes.append({"op": "edit", "key": row["키"], "row": row})
|
||||
new_files[name] = new_data
|
||||
if changes:
|
||||
batch.append({"file": name, "version": st.read(name)[1], "changes": changes})
|
||||
return batch, rows, new_files
|
||||
|
||||
|
||||
def _item(row: dict, kind: str, var: str, before: str, after: str) -> dict:
|
||||
return {
|
||||
"로직": row["키"],
|
||||
"이름": row.get("이름", ""),
|
||||
"칸": kind,
|
||||
"변수": var,
|
||||
"지금": before,
|
||||
"원문 꼴": after,
|
||||
"규칙": ut.rule_of(before),
|
||||
}
|
||||
|
||||
|
||||
def fingerprint(whole: mf.Master, row: dict) -> str:
|
||||
"""줄 하나의 엔진 셈 · 끝수 지문 — 멈춤도 지문."""
|
||||
try:
|
||||
key = str(row["키"])
|
||||
raw = mf.run(
|
||||
whole,
|
||||
key,
|
||||
{
|
||||
**ma.values(whole, row),
|
||||
**{k: v for k, v in ma.defaults(whole, row).items() if v is not None},
|
||||
},
|
||||
)
|
||||
text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False)
|
||||
text += json.dumps(
|
||||
mcut.engine(whole, key, raw), default=str, sort_keys=True, ensure_ascii=False
|
||||
)
|
||||
except Exception as e: # noqa: BLE001
|
||||
text = f"ERR {type(e).__name__} {e}"
|
||||
return hashlib.sha256(text.encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
def differing(old: dict[str, dict], new: dict[str, dict]) -> list[str]:
|
||||
"""지문이 바뀐 로직 키들 — 고친 줄만 대조."""
|
||||
before, after = mf.Master(old), mf.Master(new)
|
||||
out = []
|
||||
for name, data in new.items():
|
||||
if data.get("그룹") != "로직":
|
||||
continue
|
||||
was = {r["키"]: r for r in old[name]["줄"]}
|
||||
for row in data["줄"]:
|
||||
if row != was[row["키"]] and fingerprint(before, was[row["키"]]) != fingerprint(
|
||||
after, row
|
||||
):
|
||||
out.append(row["키"])
|
||||
return out
|
||||
|
||||
|
||||
def write_list(rows: list[dict], path: Path) -> None:
|
||||
import openpyxl
|
||||
|
||||
book = openpyxl.Workbook()
|
||||
sheet = book.active
|
||||
sheet.title = "바뀜"
|
||||
cols = ["로직", "이름", "칸", "변수", "지금", "원문 꼴", "규칙"]
|
||||
sheet.append(cols)
|
||||
for r in rows:
|
||||
sheet.append([r[c] for c in cols])
|
||||
rule = book.create_sheet("대응표")
|
||||
rule.append(["규칙", "바꿀 글", "근거 절(건설공사 표준품셈 본문 아래)", "바뀐 칸 수"])
|
||||
for name, _, to, _, files in ut.RULES:
|
||||
rule.append([name, to, " · ".join(files), sum(name in r["규칙"] for r in rows)])
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
book.save(path)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
files, _ = st.loaded()
|
||||
batch, rows, new_files = plan(files)
|
||||
print(f"쓸 것 — 로직 {len({r['로직'] for r in rows})} · 칸 {len(rows)}")
|
||||
if "--list" in sys.argv:
|
||||
write_list(rows, Path(sys.argv[sys.argv.index("--list") + 1]))
|
||||
return
|
||||
if "--check" in sys.argv:
|
||||
raise SystemExit(1 if batch else 0)
|
||||
if batch:
|
||||
bad = differing(files, new_files)
|
||||
if bad:
|
||||
raise SystemExit(f"셈 지문이 달라지는 로직 {len(bad)} — 멈춤: {bad[:10]}")
|
||||
print(st.save(batch))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,515 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""작업량 식 직접 칸 · 덤프 운반 구간 여럿(PLAN 851-1 · 요구 893) — 옛 로직 JSON 고침(한 번 돌림).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_직접칸_851_1.py
|
||||
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
|
||||
- 고르기(표 값)로만 정해지는 수 = 그 중간 줄(또는 식 속 그 찾기)을 「만약(X입력 > 0, X입력, 표)」 로 —
|
||||
비우거나 0 = 고르기 값 · 넣으면 그 값이 이김 · 입력 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 ·
|
||||
보이는 이름 = 「○○ 직접」(변수표 이름) · 열쇠 = 「X입력」 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1](지금 E입력 과 같음).
|
||||
- 지금 「0 = 표」 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 …) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」.
|
||||
- 덤프트럭(8-2-8) t2 = 구간 셋(구간 1 = 지금 운반거리 · 도로상태 · 구간2거리 · 구간3거리 = 0 이면 안 탐) ·
|
||||
구간마다 적재 · 공차 주행속도 직접(원문 3 [주] 「주행속도를 측정하여 사용할 수 있다」) · t2 · t3 · t4 · t5 직접.
|
||||
- 직접 칸을 더한 식을 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음) = 새 입력 0 · 구간 도로상태 = 구간 1 값.
|
||||
- 목록 276 변수 중 뺀 것(값 하나 · 이미 직접 칸이 덮음 · 글 값) = 851-1 보고 표.
|
||||
- 이미 돌렸으면(덤프 V1 있음) 멈춤.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
ROOT = MASTER.parents[1]
|
||||
for p in (str(ROOT), str(HERE)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
|
||||
C08 = "로직_건설품셈_08장_건설기계.json"
|
||||
F10 = "로직_산림품셈_10장_자재․장비_운반.json"
|
||||
SELF = "로직_자체.json"
|
||||
DUMP = "GC001155"
|
||||
EFF = [
|
||||
0,
|
||||
1,
|
||||
] # 작업효율 직접 칸 범위(지금 E입력 과 같음 · 원문 표 값이 1 넘는 효율 표(준설선 · 임목파쇄기)는 범위 없음)
|
||||
|
||||
# (식, 중간 줄 | 결과, 감쌀 글(None = 줄 통째), 열쇠, 보이는 이름, 자리(이 입력 아래), 단위, 범위) · 기호 = 이름 규칙
|
||||
OPS: list[tuple] = [
|
||||
("GC001144", "q0", None, "q0입력", "삽날용량 직접", "급수", "㎥", None),
|
||||
("GC001144", "e", None, "e입력", "운반거리계수 직접", "거리구분", "", None),
|
||||
("GC001144", "V1", None, "V1입력", "전진속도 직접", "전진단", "m/분", None),
|
||||
("GC001144", "V2", None, "V2입력", "후진속도 직접", "후진단", "m/분", None),
|
||||
("GC001146", "An", None, "An입력", "리핑 단면적 직접", "발톱수", "㎡", None),
|
||||
("GC001149", "d", None, "d입력", "굴착심도계수 직접", "굴착심도", "", None),
|
||||
("GC001150", "m", None, "m입력", "주행계수 직접", "기종", "sec/m", None),
|
||||
(
|
||||
"GC001150",
|
||||
"cm",
|
||||
"t1",
|
||||
"t1입력",
|
||||
"적재시간 직접",
|
||||
"적재조건",
|
||||
"sec",
|
||||
None,
|
||||
), # 줄 t1 = 표 한 마디(열쇠 겹침 피함)
|
||||
("GC001150", "K", None, "K입력", "버킷계수 직접", "K조건", "", None),
|
||||
("GC001152", "K", None, "K입력", "적재계수 직접", "토질상태", "", None),
|
||||
("GC001152", "V1", None, "V1입력", "적재 주행속도 직접", "도로상태", "m/분", None),
|
||||
("GC001152", "V2", None, "V2입력", "공차 주행속도 직접", "V1입력", "m/분", None),
|
||||
("GC001152", "t", None, "t입력", "적토·사토·기어변속시간 직접", "푸쉬도우저", "분", None),
|
||||
*[
|
||||
op
|
||||
for key in ("GC001153", "GC001154")
|
||||
for op in (
|
||||
(key, "V1", None, "V1입력", "작업속도 직접", "현장조건", "㎞/hr", None),
|
||||
(key, "V2", None, "V2입력", "후진·회송속도 직접", "되돌림조건", "㎞/hr", None),
|
||||
(key, "t", None, "t입력", "방향변환시간 직접", "t작업", "분", None),
|
||||
)
|
||||
],
|
||||
("GC001154", "l", None, "l입력", "블레이드 유효길이 직접", "l작업", "m", None),
|
||||
*[
|
||||
op
|
||||
for key in ("GC001157", "GC001158")
|
||||
for op in (
|
||||
(key, "W", None, "W입력", "유효다짐폭 직접", "규격", "m", None),
|
||||
(key, "V", None, "V입력", "다짐속도 직접", "다짐층", "㎞/hr", None),
|
||||
)
|
||||
],
|
||||
("GC001160", "결과", None, "Q입력", "생산능력 직접", "혼합재", "ton/hr", None),
|
||||
("GC001162", "결과", None, "Q입력", "생산능력 직접", "작업조건", "ton/hr", None),
|
||||
(
|
||||
"GC001163",
|
||||
"결과",
|
||||
"찾기(CC000375, 출구간격=출구간격, 규격=규격).생산능력",
|
||||
"q입력",
|
||||
"생산능력 직접",
|
||||
"출구간격",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001163", "효율", None, "E효율입력", "효율 직접", "작업조건", "%", None),
|
||||
(
|
||||
"GC001164",
|
||||
"결과",
|
||||
"찾기(CC000383, 규격=규격, 출구간격=출구간격).생산능력",
|
||||
"q입력",
|
||||
"생산능력 직접",
|
||||
"출구간격",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001164", "E", None, "E입력", "작업효율 직접", "작업조건", "", EFF),
|
||||
(
|
||||
"GC001165",
|
||||
"통과능력",
|
||||
None,
|
||||
"q통과입력",
|
||||
"통과능력 직접",
|
||||
"조합방법",
|
||||
"ton/hr",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001165", "A", None, "A입력", "택수 계수(A) 직접", "택의수", "", None),
|
||||
("GC001165", "B", None, "B입력", "작은 골재량 계수(B) 직접", "B골재량", "", None),
|
||||
("GC001165", "C", None, "C입력", "스크린 규격 계수(C) 직접", "C규격", "", None),
|
||||
("GC001165", "D", None, "D입력", "큰 골재량 계수(D) 직접", "D골재량", "", None),
|
||||
("GC001165", "E", None, "E입력", "재료 계수(E) 직접", "재료", "", None),
|
||||
("GC001168", "결과", None, "Q입력", "작업량 직접", "구분", "㎡/h", None),
|
||||
("GC001171", "q", None, "q입력", "실용량 직접", "슬럼프", "㎥", None),
|
||||
("GC001171", "cm", None, "cm입력", "싸이클시간 직접", "싸이클", "분", None),
|
||||
("GC001173", "W", None, "W입력", "적재용량 직접", "규격", "㎥", None),
|
||||
("GC001174", "n", None, "n입력", "대차수 직접", "기관차", "대", None),
|
||||
("GC001174", "t2", None, "t2입력", "적재적하시간 직접", "재료", "분", None),
|
||||
("GC001175", "t", None, "t입력", "적재적하시간 직접", "종류", "분", None),
|
||||
("GC001175", "V1", None, "V1입력", "적재시 속도 직접", "작업로", "m/분", None),
|
||||
("GC001175", "V2", None, "V2입력", "공차시 속도 직접", "V1입력", "m/분", None),
|
||||
("GC001176", "β", None, "β입력", "해머계수 직접", "해머", "", None),
|
||||
("GC001176", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
|
||||
("GC001176", "F", None, "F입력", "작업계수 직접", "현장", "", None),
|
||||
("GC001176", "tw", None, "tw입력", "용접시간 직접", "관두께", "분", None),
|
||||
("GC001177", "β", None, "β입력", "해머계수 직접", "해머", "", None),
|
||||
("GC001177", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
|
||||
(
|
||||
"GC001177",
|
||||
"Ts",
|
||||
"만약(파일경 <= 300, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 250·300㎜').값, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 350∼500㎜').값)",
|
||||
"Ts입력",
|
||||
"세우기·위치조정 시간 직접",
|
||||
"파일경",
|
||||
"분/회",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001177", "F", None, "F입력", "작업계수 직접", "현장", "", None),
|
||||
("GC001178", "β", None, "β입력", "판두께계수 직접", "판두께", "", None),
|
||||
("GC001178", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
|
||||
("GC001179", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
|
||||
("GC001180", "Ts", None, "Ts입력", "준비시간 직접", "작업", "분", None),
|
||||
(
|
||||
"GC001180",
|
||||
"F",
|
||||
"찾기(CC000423, 작업=작업).F0",
|
||||
"F0입력",
|
||||
"작업계수 F0 직접",
|
||||
"Ts입력",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001180", "k", None, "k입력", "해머계수 직접", "파일", "", None),
|
||||
("GC001180", "r1", None, "r1입력", "사질토 단위시간 직접", "사질N", "분/m", None),
|
||||
("GC001180", "r2", None, "r2입력", "점질토 단위시간 직접", "점질N", "분/m", None),
|
||||
("GC001181", "α", None, "α입력", "α 직접", "해머", "", None),
|
||||
("GC001181", "K", None, "K입력", "K 직접", "α입력", "", None),
|
||||
("GC001181", "γ", None, "γ입력", "γ 직접", "작업", "", None),
|
||||
(
|
||||
"GC001181",
|
||||
"F",
|
||||
"찾기(CC000430, 작업='항타').F0",
|
||||
"F0입력",
|
||||
"작업계수 F0 직접",
|
||||
"γ입력",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001181", "F인발", "찾기(CC000430, 작업='항발').F0", "F0입력", "", "", "", None), # 같은 칸
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000466, 구분=E1).E",
|
||||
"E1입력",
|
||||
"흙의 두께 효율 직접",
|
||||
"E1",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000468, 구분=E2).E",
|
||||
"E2입력",
|
||||
"평면형상 효율 직접",
|
||||
"E2",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000470, 구분=E3).E",
|
||||
"E3입력",
|
||||
"단면형상 효율 직접",
|
||||
"E3",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001186",
|
||||
"E",
|
||||
"찾기(CC000472, 구분=E4).E",
|
||||
"E4입력",
|
||||
"해상조건 효율 직접",
|
||||
"E4",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"cm",
|
||||
"찾기(CC000476, 버킷용량=버킷용량).싸이클시간",
|
||||
"싸이클입력",
|
||||
"기준 싸이클시간 직접",
|
||||
"버킷용량",
|
||||
"sec",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"E",
|
||||
"찾기(CC000477, 구분=E1).E",
|
||||
"E1입력",
|
||||
"흙의 두께 효율 직접",
|
||||
"E1",
|
||||
"",
|
||||
EFF,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001187",
|
||||
"E",
|
||||
"찾기(CC000479, 구분=E2).E",
|
||||
"E2입력",
|
||||
"해상조건 효율 직접",
|
||||
"E2",
|
||||
"",
|
||||
EFF,
|
||||
), # fmt: skip
|
||||
("GC001188", "S", None, "S입력", "쇄암면적 직접", "중추중량", "㎡", None),
|
||||
("GC001188", "n", None, "n입력", "낙추횟수 직접", "S입력", "회", None),
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000486, 규격=규격).K",
|
||||
"K입력",
|
||||
"능력계수 직접",
|
||||
"규격",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000487, 스크린=스크린).S",
|
||||
"S입력",
|
||||
"스크린계수 직접",
|
||||
"스크린",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
(
|
||||
"GC001189",
|
||||
"결과",
|
||||
"찾기(CC000488, 작업조건=작업조건).E",
|
||||
"E입력",
|
||||
"작업효율 직접",
|
||||
"작업조건",
|
||||
"",
|
||||
None,
|
||||
), # fmt: skip
|
||||
("GC001190", "q", None, "q입력", "준설량 직접", "배송거리", "㎥/hr", None),
|
||||
("GC001190", "E", None, "E입력", "작업효율 직접", "유속", "", EFF),
|
||||
("GF000148", "f", None, "f입력", "체적환산계수 직접", "재료", "", None),
|
||||
("GF000148", "E", None, "E입력", "작업효율 직접", "f입력", "", EFF),
|
||||
]
|
||||
|
||||
# 지금 「0 = 표」 직접 칸 — 보이는 이름만(열쇠 · 기호 그대로)
|
||||
RENAME = {
|
||||
"E입력": "작업효율 직접",
|
||||
"싸이클입력": "싸이클시간 직접",
|
||||
"K입력": "버킷계수 직접",
|
||||
"α입력": "토질계수 직접",
|
||||
"f입력": "체적환산계수 직접",
|
||||
"k입력": "버킷계수 직접",
|
||||
"하역시간입력": "하역시간 직접",
|
||||
"대기시간입력": "대기시간 직접",
|
||||
"배출시간입력": "배출시간 직접",
|
||||
"적재시간입력": "적재시간 직접",
|
||||
}
|
||||
RENAME_ROW = {("GC001186", "q입력"): "준설능력 직접"}
|
||||
ROAD = "찾기(CC000054, 도로상태={road}).{col}"
|
||||
|
||||
|
||||
def _load(name: str) -> tuple[str, dict]:
|
||||
text = (MASTER / name).read_text(encoding="utf-8")
|
||||
return text, json.loads(text, parse_float=Decimal, parse_int=Decimal)
|
||||
|
||||
|
||||
def _save(name: str, text: str, before: dict, after: dict) -> None:
|
||||
from M01_MasterData import M01_MasterData_Store_Shape as shape
|
||||
|
||||
out = shape.keep_shape(text, before, after, "줄") or shape.dump(after)
|
||||
assert json.loads(out, parse_float=Decimal, parse_int=Decimal) == after
|
||||
(MASTER / name).write_text(out, encoding="utf-8", newline="\n")
|
||||
|
||||
|
||||
def _guard(key: str, body: str) -> str:
|
||||
return f"만약({key} > 0, {key}, {body})"
|
||||
|
||||
|
||||
def _is_guard(row: dict, name: str) -> bool:
|
||||
return any(re.search(rf"만약\({re.escape(name)} > 0, {re.escape(name)}, ", s["식"]) for s in row.get("중간") or []) # fmt: skip
|
||||
|
||||
|
||||
def _add_input(row: dict, spec: dict, after: str) -> None:
|
||||
ins = row["입력"]
|
||||
at = next(i for i, x in enumerate(ins) if x["이름"] == after)
|
||||
ins.insert(at + 1, spec)
|
||||
if isinstance(row.get("시험입력"), dict):
|
||||
row["시험입력"][spec["이름"]] = spec.pop("_시험", Decimal(0))
|
||||
spec.pop("_시험", None)
|
||||
|
||||
|
||||
def _table(row: dict, key: str, name: str, pick: bool = False) -> None:
|
||||
"""변수표 — 기호 · 아래 = 이름 규칙(`master_symbol.rule` · 같은 열쇠 = 같은 기호) · 이름 = 보이는 이름."""
|
||||
import master_symbol as msym
|
||||
|
||||
sign, sub = msym.rule(key, "변수", "고름" if pick else "")[:2]
|
||||
row.setdefault("변수표", {})[key] = {"기호": sign, "아래": sub, "이름": name}
|
||||
|
||||
|
||||
def apply_op(row: dict, op: tuple) -> None:
|
||||
_, step, sub, key, name, after, unit, rng = op
|
||||
target = row["결과"] if step == "결과" else next(s for s in row["중간"] if s["이름"] == step)
|
||||
text = target["식"]
|
||||
if sub is None:
|
||||
target["식"] = _guard(key, text)
|
||||
else:
|
||||
assert sub in text, (row["키"], step, sub)
|
||||
target["식"] = text.replace(sub, _guard(key, sub))
|
||||
if not name: # 같은 칸을 둘째 줄에도
|
||||
return
|
||||
assert key not in {x["이름"] for x in row["입력"]} | {x["이름"] for x in row.get("중간") or []}, key # fmt: skip
|
||||
spec = {
|
||||
"이름": key,
|
||||
"설명": f"{name.removesuffix(' 직접')} — 직접 넣을 때 · 0 이면 고르기(표) 값",
|
||||
}
|
||||
if unit:
|
||||
spec["단위"] = unit
|
||||
if rng:
|
||||
spec["범위"] = [Decimal(str(x)) for x in rng]
|
||||
spec["출처"] = row.get("출처") or ""
|
||||
_add_input(row, spec, after)
|
||||
_table(row, key, name)
|
||||
|
||||
|
||||
def rename(row: dict, docs: dict) -> int:
|
||||
"""지금 직접 칸 보이는 이름 — 기호 · 아래는 지금 수식 문서 그대로 옮겨 적음."""
|
||||
n = 0
|
||||
doc = docs.get(str(row["키"])) or {}
|
||||
for spec in row.get("입력") or []:
|
||||
key = spec["이름"]
|
||||
name = RENAME_ROW.get((row["키"], key)) or RENAME.get(key)
|
||||
if not name or not (_is_guard(row, key) or key == "적재시간입력"):
|
||||
continue
|
||||
now = next((v for v in doc.get("변수") or [] if v.get("열쇠") == key), None)
|
||||
assert now, (row["키"], key)
|
||||
look = row.setdefault("변수표", {}).setdefault(key, {})
|
||||
look |= {"기호": now["기호"], "아래": now.get("아래") or "", "이름": name}
|
||||
if now.get("위"):
|
||||
look["위"] = now["위"]
|
||||
n += 1
|
||||
return n
|
||||
|
||||
|
||||
def dump(row: dict) -> None:
|
||||
"""덤프 t2 = 구간 셋 · 속도 직접 · t2 ~ t5 직접."""
|
||||
mids = row["중간"]
|
||||
names = [m["이름"] for m in mids]
|
||||
assert "V1" not in names
|
||||
road = next(i for i in row["입력"] if i["이름"] == "도로상태")
|
||||
base_road = row["시험입력"]["도로상태"]
|
||||
speeds = []
|
||||
after = "도로상태"
|
||||
for n in (1, 2, 3):
|
||||
dist, rd = ("운반거리", "도로상태") if n == 1 else (f"구간{n}거리", f"구간{n}도로상태")
|
||||
tag = "" if n == 1 else f" {n}"
|
||||
if n > 1:
|
||||
_add_input(row, {"이름": dist, "설명": f"운반 구간 {n} 거리(편도) — 0 이면 안 씀", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
|
||||
_table(row, dist, f"운반거리{tag}")
|
||||
_add_input(row, {"이름": rd, "설명": f"운반 구간 {n} 도로 상태", "고르기": list(road["고르기"]), "출처": "건설품셈 공통 8-2-8 3", "_시험": base_road}, dist) # fmt: skip
|
||||
_table(row, rd, f"도로상태{tag}", pick=True)
|
||||
after = rd
|
||||
for k, col, what in ((2 * n - 1, "적재", "적재속도"), (2 * n, "공차", "공차속도")):
|
||||
key = f"V{k}입력"
|
||||
_add_input(row, {"이름": key, "설명": f"구간 {n} {col}시 평균주행속도를 직접 넣을 때(측정값 · 3 [주]) — 0 이면 도로상태 표", "단위": "㎞/hr", "출처": "건설품셈 공통 8-2-8 3"}, after) # fmt: skip
|
||||
_table(row, key, f"{what}{tag} 직접")
|
||||
after = key
|
||||
speeds.append({"이름": f"V{k}", "식": _guard(key, ROAD.format(road=rd, col=col)), "단위": "㎞/hr"}) # fmt: skip
|
||||
row["변수표"][f"V{k}"] = {"기호": "V", "아래": str(k), "이름": f"{col}시 평균주행속도{tag}"} # fmt: skip
|
||||
_add_input(row, {"이름": "t2입력", "설명": "왕복시간(t2)을 직접 넣을 때 — 0 이면 구간 거리 · 속도로 셈", "단위": "분", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
|
||||
_table(row, "t2입력", "왕복시간(t2) 직접")
|
||||
legs = ["운반거리 / V1 * 60 + 운반거리 / V2 * 60"] + [
|
||||
f"만약(구간{n}거리 > 0, 구간{n}거리 / V{2 * n - 1} * 60 + 구간{n}거리 / V{2 * n} * 60, 0)" for n in (2, 3)
|
||||
] # fmt: skip
|
||||
t2 = next(m for m in mids if m["이름"] == "t2")
|
||||
t2["식"] = _guard("t2입력", " + ".join(legs))
|
||||
at = names.index("t2")
|
||||
mids[at:at] = speeds
|
||||
for step, key, name, after_ in (
|
||||
("t3", "t3입력", "적하시간(t3) 직접", "적하조건"),
|
||||
("t4", "t4입력", "진입시간(t4) 직접", "적재장소"),
|
||||
("t5", "t5입력", "덮개시간(t5) 직접", "덮개"),
|
||||
):
|
||||
apply_op(row, (DUMP, step, None, key, name, after_, "분", None))
|
||||
row["비고"] = (
|
||||
str(row["비고"])
|
||||
+ " · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표"
|
||||
)
|
||||
|
||||
|
||||
def _call_fill(text: str, key: str, extra: str) -> str:
|
||||
pat = re.compile(rf"로직\({key},([^()]*(?:\([^()]*\)[^()]*)*)\)")
|
||||
return pat.sub(lambda m: f"로직({key},{m[1]}{extra})", text)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
import master_doc_link as ml
|
||||
|
||||
docs = ml.load_all()
|
||||
text, before = _load(C08)
|
||||
after = copy.deepcopy(before)
|
||||
rows = {str(r["키"]): r for r in after["줄"]}
|
||||
if any(m["이름"] == "V1" for m in rows[DUMP]["중간"]):
|
||||
print("이미 돌림 — 멈춤")
|
||||
return
|
||||
renamed = sum(rename(r, docs) for r in rows.values() if (r.get("부품") or {}).get("갈래") == "작업량 틀") # fmt: skip
|
||||
added: dict[str, list[str]] = {}
|
||||
for op in OPS:
|
||||
if op[0] in rows:
|
||||
apply_op(rows[op[0]], op)
|
||||
if op[4]:
|
||||
added.setdefault(op[0], []).append(op[3])
|
||||
dump(rows[DUMP])
|
||||
for k, keys in added.items():
|
||||
rows[k]["비고"] = (
|
||||
str(rows[k].get("비고") or "") + f" · 직접 칸 {' · '.join(keys)} 0 = 표(851-1)"
|
||||
)
|
||||
_save(C08, text, before, after)
|
||||
print("08장 — 이름만", renamed, "· 직접 칸", sum(map(len, added.values())), "식", len(added))
|
||||
|
||||
text, before = _load(F10)
|
||||
after = copy.deepcopy(before)
|
||||
rows = {str(r["키"]): r for r in after["줄"]}
|
||||
for op in OPS:
|
||||
if op[0] in rows:
|
||||
apply_op(rows[op[0]], op)
|
||||
_save(F10, text, before, after)
|
||||
print("10장 — GF000148 직접 칸 f입력 · E입력")
|
||||
|
||||
road = "'교차가 힘든 산간지도로 및 제방 등의 도로'"
|
||||
dump_extra = (
|
||||
", V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태=__R__, V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태=__R__,"
|
||||
" V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0"
|
||||
)
|
||||
extra = {k: "".join(f", {x}=0" for x in keys) for k, keys in added.items()}
|
||||
extra |= {"GF000148": ", f입력=0, E입력=0", DUMP: dump_extra}
|
||||
for name in sorted(p.name for p in MASTER.glob("로직_*.json")):
|
||||
text, before = _load(name)
|
||||
raw = json.dumps(before, ensure_ascii=False, default=str)
|
||||
hits = [k for k in extra if f"로직({k}," in raw or f"로직({k})" in raw]
|
||||
if not hits:
|
||||
continue
|
||||
after = copy.deepcopy(before)
|
||||
|
||||
def walk(x):
|
||||
if isinstance(x, dict):
|
||||
for k, v in x.items():
|
||||
if isinstance(v, str):
|
||||
for key in hits:
|
||||
first = extra[key].split("=")[0].lstrip(", ")
|
||||
if f"로직({key}" in v and f"{first}=" not in v:
|
||||
assert f"로직({key})" not in v, (
|
||||
name,
|
||||
key,
|
||||
) # 입력 없는 부름 — 손으로
|
||||
m = re.search(r"도로상태=('[^']*'|[^,()]+)", v)
|
||||
v = _call_fill(
|
||||
v, key, extra[key].replace("__R__", m[1] if m else road)
|
||||
)
|
||||
x[k] = v
|
||||
else:
|
||||
walk(v)
|
||||
elif isinstance(x, list):
|
||||
for v in x:
|
||||
walk(v)
|
||||
|
||||
walk(after)
|
||||
_save(name, text, before, after)
|
||||
print("부름 새 입력 0 —", name, " · ".join(hits))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,112 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""M01 로직 변수 기호 기본값 전부 채우기 (PLAN 800-1 · 요구 660-1 · 659-2) — 796-3 이어서.
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_변수기호_800_1.py [--check]
|
||||
- 입력 · 중간 변수 중 기호가 없는 것(이름이 한글 · 영문 낱말)에 `master_symbol` 규칙대로 `변수표` 기호 · 아래 · 위를 채움.
|
||||
원문 기호(796-3) · 사용자가 고친 칸은 덮지 않음 · 한 로직 안 겹치면 아래에 숫자 · 판마다 다시 돌려도 같은 결과.
|
||||
- 찾기 · 요소 · 합 · 결과 변수는 정의 칸이 없어 수식 내보내기가 `master_symbol.apply` 로 씌움(저장 안 함).
|
||||
- 엔진 열쇠 · 식 · 값은 그대로(보이기만). 저장 = M01 저장 길 · `AISLO_MASTER_DIR` 로 사본에 시험.
|
||||
- `--check` = 쓰지 않고 쓸 것이 남았는지만(남았으면 종료 코드 1).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE.parents[2]))
|
||||
import master_equation as meq # noqa: E402
|
||||
import master_symbol as sym # noqa: E402
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as st # noqa: E402
|
||||
|
||||
|
||||
def logic_rows(files: dict[str, dict]) -> list[dict]:
|
||||
return [r for d in files.values() if d.get("그룹") == "로직" for r in d.get("줄", [])]
|
||||
|
||||
|
||||
def needs(name: str) -> bool:
|
||||
"""기호를 정할 이름 — 이미 기호 꼴(영문 · 그리스 ≤ 6 자)이면 그대로."""
|
||||
return not sym.is_symbol(name)
|
||||
|
||||
|
||||
def _hints(rows: list[dict]) -> dict[str, str]:
|
||||
"""변수 이름 → 힌트(고름 > 중간 > 빈)."""
|
||||
rank = {"": 0, "중간": 1, "고름": 2}
|
||||
out: dict[str, str] = {}
|
||||
for r in rows:
|
||||
for kind in ("입력", "중간"):
|
||||
for spec in r.get(kind) or []:
|
||||
now = (
|
||||
"고름"
|
||||
if kind == "입력" and spec.get("고르기")
|
||||
else "중간"
|
||||
if kind == "중간"
|
||||
else ""
|
||||
)
|
||||
name = str(spec["이름"])
|
||||
if name not in out or rank[now] > rank[out[name]]:
|
||||
out[name] = now
|
||||
return out
|
||||
|
||||
|
||||
# ── 정본에 채우기 ──────────────────────────────────────────────────────
|
||||
def plan(files: dict[str, dict]) -> tuple[list[dict], dict]:
|
||||
"""(저장 묶음, 숫자) — 읽기 전용 · 고친 줄만 담음."""
|
||||
batch, stat = [], {"줄": 0, "변수": 0, "겹침비킴": 0}
|
||||
hints = _hints(logic_rows(files))
|
||||
for name, data in files.items():
|
||||
if data.get("그룹") != "로직":
|
||||
continue
|
||||
changes = []
|
||||
for row in data.get("줄", []):
|
||||
new, hit = copy.deepcopy(row), False
|
||||
table = {k: dict(v) for k, v in (new.get(meq.FIELD) or {}).items()}
|
||||
used = {sym_text for v in meq.table(new) for sym_text in (meq.token(v), v["이름"])}
|
||||
for kind in ("입력", "중간"):
|
||||
for spec in new.get(kind) or []:
|
||||
key = str(spec["이름"])
|
||||
look = table.get(key, {})
|
||||
if look.get("기호") or not needs(key):
|
||||
continue
|
||||
sign, low, up = sym.lookup(key, "변수", hints.get(key, ""))
|
||||
if look.get("아래") or look.get("위"):
|
||||
continue # 사용자가 첨자만 정한 칸 — 건드리지 않음
|
||||
one = {**look, "기호": sign, "아래": low}
|
||||
if up:
|
||||
one["위"] = up
|
||||
text = meq.token({"열쇠": key, **one})
|
||||
n, base = 1, low
|
||||
while text in used: # 한 로직 안 겹침 — 아래에 숫자
|
||||
n += 1
|
||||
one["아래"] = base[: sym.SUBMAX - len(str(n))] + str(n)
|
||||
text = meq.token({"열쇠": key, **one})
|
||||
stat["겹침비킴"] += 1
|
||||
used.add(text)
|
||||
table[key] = one
|
||||
stat["변수"] += 1
|
||||
hit = True
|
||||
if not hit:
|
||||
continue
|
||||
new[meq.FIELD] = table
|
||||
changes.append({"op": "edit", "key": row["키"], "row": new})
|
||||
stat["줄"] += 1
|
||||
if changes:
|
||||
batch.append({"file": name, "version": st.read(name)[1], "changes": changes})
|
||||
return batch, stat
|
||||
|
||||
|
||||
def main() -> None:
|
||||
files, _ = st.loaded()
|
||||
batch, stat = plan(files)
|
||||
print(f"쓸 것 — 줄 {stat['줄']} · 변수 {stat['변수']} · 겹침 비킴 {stat['겹침비킴']}")
|
||||
if "--check" in sys.argv:
|
||||
raise SystemExit(1 if batch else 0)
|
||||
if batch:
|
||||
print(st.save(batch))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,102 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""M01 로직 변수 국문 이름 · 기호 · 첨자 · 단위 기본값 채우기 (PLAN 796-3 · 요구 659-2 · 656-4).
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_변수표_796_3.py [--check]
|
||||
- 결정 자료 = `변수표_796_3.json` {줄: {로직 키: {열쇠: {이름?, 기호?, 위?, 아래?, 단위?, 근거, 확신}}}}
|
||||
(확신 = 원문 | 추정 · 값은 품셈 원문 「여기서 기호 : 풀이」 · 표 라벨 · 칸 설명 근거 · 지어 넣지 않음).
|
||||
- 쓰는 곳 = 로직 줄 `변수표` {열쇠: {이름?, 기호?, 위?, 아래?}}(보이기만 · 셈에 안 씀) +
|
||||
단위가 비어 있는 입력 · 중간 칸의 `단위`. 엔진 열쇠 · 식 · 값은 그대로.
|
||||
- 채우기만 함: 이미 `변수표` 에 있는 열쇠는 사용자 고침이라 덮지 않음 · 단위가 있으면 그대로.
|
||||
판마다 다시 돌려도 같은 결과(두 번째부터 쓸 것 없음).
|
||||
- 저장 = M01 저장 길(`M01_MasterData_Store.save` — 검사 · 글 모양 유지). `AISLO_MASTER_DIR` 로 사본에 시험.
|
||||
- `--check` = 쓰지 않고 쓸 것이 남았는지만 봄(남았으면 종료 코드 1).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE.parents[2]))
|
||||
import master_equation as meq # noqa: E402
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as st # noqa: E402
|
||||
|
||||
DATA = HERE / "변수표_796_3.json"
|
||||
LOOK = ("이름", "기호", "위", "아래")
|
||||
|
||||
|
||||
def decisions() -> dict[str, dict[str, dict]]:
|
||||
return json.loads(DATA.read_text(encoding="utf-8"))["줄"]
|
||||
|
||||
|
||||
def plan(files: dict[str, dict], want: dict[str, dict[str, dict]]) -> tuple[list[dict], dict]:
|
||||
"""(저장 묶음, 숫자) — 읽기 전용 · 고친 줄만 담음."""
|
||||
left, batch, stat = set(want), [], {"변수표": 0, "단위": 0, "이미있음": 0, "줄": 0}
|
||||
for name, data in files.items():
|
||||
if data.get("그룹") != "로직":
|
||||
continue
|
||||
changes = []
|
||||
for row in data.get("줄", []):
|
||||
decided = want.get(row.get("키"))
|
||||
if not decided:
|
||||
continue
|
||||
left.discard(row["키"])
|
||||
new, hit = copy.deepcopy(row), False
|
||||
table = dict(new.get(meq.FIELD) or {})
|
||||
specs = {s["이름"]: s for k in ("입력", "중간") for s in new.get(k) or []}
|
||||
for key, one in decided.items():
|
||||
spec = specs.get(key)
|
||||
if spec is None:
|
||||
raise SystemExit(f"{row['키']} · 없는 변수 「{key}」")
|
||||
if key in table:
|
||||
stat["이미있음"] += 1
|
||||
else:
|
||||
look = {f: one[f] for f in LOOK if one.get(f)}
|
||||
if look:
|
||||
table[key] = look
|
||||
stat["변수표"] += 1
|
||||
hit = True
|
||||
if one.get("단위") and not spec.get("단위"):
|
||||
spec["단위"] = one["단위"]
|
||||
stat["단위"] += 1
|
||||
hit = True
|
||||
if not hit:
|
||||
continue
|
||||
new[meq.FIELD] = table
|
||||
seen: dict[
|
||||
str, str
|
||||
] = {} # 변수 글 겹침 — 키보드 식이 갈리지 않게(화면 저장과 같은 검사)
|
||||
for v in meq.table(new):
|
||||
for word in {meq.token(v), v["이름"]}:
|
||||
if seen.get(word, v["열쇠"]) != v["열쇠"]:
|
||||
raise SystemExit(
|
||||
f"{row['키']} · 「{word}」 이 「{seen[word]}」 · 「{v['열쇠']}」 둘에 겹침"
|
||||
)
|
||||
seen.setdefault(word, v["열쇠"])
|
||||
changes.append({"op": "edit", "key": row["키"], "row": new})
|
||||
stat["줄"] += 1
|
||||
if changes:
|
||||
batch.append({"file": name, "version": st.read(name)[1], "changes": changes})
|
||||
if left:
|
||||
raise SystemExit(f"없는 로직 {sorted(left)[:5]}")
|
||||
return batch, stat
|
||||
|
||||
|
||||
def main() -> None:
|
||||
files, _ = st.loaded()
|
||||
batch, stat = plan(files, decisions())
|
||||
print(
|
||||
f"쓸 것 — 줄 {stat['줄']} · 변수표 칸 {stat['변수표']} · 단위 {stat['단위']} · 이미 있음 {stat['이미있음']}"
|
||||
)
|
||||
if "--check" in sys.argv:
|
||||
raise SystemExit(1 if batch else 0)
|
||||
if batch:
|
||||
print(st.save(batch))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,435 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""옛 M01 로직 → 수식 문서 빌더 + 금액 전수 대조 (PLAN 802-2 · 요구서_664 1 장 3).
|
||||
|
||||
python resources/master_data/scripts/build_수식문서_802_2.py # 변환 · 대조 · 저장
|
||||
· 목록
|
||||
python resources/master_data/scripts/build_수식문서_802_2.py --check # 다시 돌려 저장본
|
||||
· 목록과 같은지
|
||||
|
||||
- 변환 = `master_doc_convert.convert`(로직마다 · 기본 옵션 = 수식 탭 기본값)
|
||||
· 셈 = `master_doc_calc.calc`.
|
||||
- 대조 = 새 계산기 대 옛 엔진(`master_formula.run` → `master_cut.engine`) 노 · 재 · 경
|
||||
· 계(돈 아닌 로직 = 결과)
|
||||
원 단위 — 기본 옵션 전부 + 옵션 표본(로직마다 고르기 입력의 다른 갈래 하나씩 · 나머지 기본).
|
||||
둘 다 못 셈 = 같음(따로 셈). 보정 없음 — 다르면 목록에 까닭.
|
||||
- 채택된 차이(`ADOPTED`) = 사용자 요구 714-3 「1원 차이는 로직만 맞다면 문제 없음」 — 식 속 단가산출
|
||||
부름 값 = 끝수 뒤(새 계산기 그대로) · 목록에 남기고 저장은 막지 않음.
|
||||
- 저장 = 같은 것만(요구서_664 1 장 3) — 모든 대조가 같고(채택된 차이 빼고) 부르는 단가산출도 저장되는 문서 ·
|
||||
`resources/master_data/수식문서/수식_<옛 로직 파일 꼬리>.json`(로직 파일마다
|
||||
· 옛 로직 JSON 은 안 씀).
|
||||
- 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약).
|
||||
- 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`).
|
||||
- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 ·
|
||||
`손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림.
|
||||
- 이름표(855 L1) = 로직 줄 `원문번호 · 구분 · 상세구분 · 소유 · 비고 · 개정 · 별칭` → 문서 줄 머리 ·
|
||||
로직 파일 머리 `원문 · 부문 · 차례` → 문서 파일 머리(`master_doc.tag` · 셈 · 지문 밖 · `--check` 기준).
|
||||
- 빌더가 짓지 않는 저장본 문서(848-4 · 옛 로직 줄 없는 키 — 화면에서 만든 자체 로직 등) = 지우거나 덮지 않음 ·
|
||||
제 파일 끝에 그대로(`foreign`) · 실행 · `--check` 때 목록 · `--check` 는 그대로면 같음.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
for p in (str(ROOT), str(Path(__file__).resolve().parent)):
|
||||
if p not in sys.path:
|
||||
sys.path.insert(0, p)
|
||||
|
||||
import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만)
|
||||
import master_doc as md # noqa: E402
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_convert as cv # noqa: E402
|
||||
import master_doc_cover as mcv # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
import master_equation as meq # noqa: E402
|
||||
import master_formula as mf # noqa: E402
|
||||
|
||||
LIST = ROOT / "docs/raw/요구_1104/_목록_802-2_변환대조.xlsx"
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
HEAD = ("로직", "이름", "옵션", "옛", "새", "차이", "까닭")
|
||||
RAW_SUB = (
|
||||
"식 속 단가산출 부름 = 끝수 뒤 값"
|
||||
"(옛 엔진 = 끝수 전 날 값 · `master_formula.run` 결과를 식에 씀)"
|
||||
)
|
||||
# 채택된 차이 — (로직, 옵션) · 요구 714-3
|
||||
ADOPTED = {("GC000091", "지역=울산"), ("GC000093", "지역=경북"), ("GC000100", "지역=전북")}
|
||||
|
||||
|
||||
def rows_of(files: dict) -> list[tuple[str, dict]]:
|
||||
"""(옛 로직 파일 이름, 로직 줄) — 파일 · 줄 차례."""
|
||||
return [
|
||||
(name, row)
|
||||
for name, data in sorted(files.items())
|
||||
if data.get("그룹") == "로직"
|
||||
for row in data.get("줄") or []
|
||||
]
|
||||
|
||||
|
||||
def old_answer(whole, row: dict, given: dict):
|
||||
try:
|
||||
got = mcut.engine(whole, row["키"], mf.run(whole, row["키"], mf.fill_empty(row, given)))
|
||||
except Exception as e: # 옛 엔진 멈춤도 대조 값
|
||||
return f"못 셈 — {e}"
|
||||
return {"결과": got["결과"]} if "결과" in got else {k: got.get(k) for k in KEYS}
|
||||
|
||||
|
||||
def new_answer(links, doc: dict, given: dict | None = None):
|
||||
got = mc.calc(doc, links, given)
|
||||
if not got["셈됨"]:
|
||||
return "못 셈 — " + (" · ".join(m["글"] for m in got["표지"]) or got.get("까닭") or "")
|
||||
return {"결과": got["결과"]} if doc.get("결과") else {k: got.get(k) for k in KEYS}
|
||||
|
||||
|
||||
def cases_of(whole, row: dict) -> list[tuple]:
|
||||
"""(옵션 글, 옛 엔진 입력, 새 문서에 넘길 바뀐 입력) — 기본 + 고르기 입력의 다른 갈래 하나씩."""
|
||||
base = meq.given_of(whole, row)
|
||||
cases = [("", base, None)]
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
one = {spec["이름"]: opt}
|
||||
cases.append((f"{spec['이름']}={opt}", {**base, **one}, one))
|
||||
return cases
|
||||
|
||||
|
||||
def agree(old, new) -> bool:
|
||||
"""대조 같음 — 같은 값 · 둘 다 못 셈."""
|
||||
return old == new or (isinstance(old, str) and isinstance(new, str))
|
||||
|
||||
|
||||
def _text(v) -> str:
|
||||
if isinstance(v, str):
|
||||
return v
|
||||
return " · ".join(f"{k} {mc.plain_text(x) if x is not None else '—'}" for k, x in v.items())
|
||||
|
||||
|
||||
def _gap(a, b) -> str:
|
||||
if isinstance(a, str) or isinstance(b, str):
|
||||
return "한쪽 못 셈"
|
||||
return " · ".join(
|
||||
f"{k} {mc.plain_text((b.get(k) or 0) - (a.get(k) or 0))}" for k in a if a.get(k) != b.get(k)
|
||||
)
|
||||
|
||||
|
||||
def _uses_raw_sub(doc: dict) -> bool:
|
||||
"""식 줄이 단가산출 부름 기호를 씀(금액 줄 단가가 아닌 자리)."""
|
||||
subs = {
|
||||
md.var_id(v)
|
||||
for v in doc.get("변수") or []
|
||||
if (v.get("연결") or {}).get("갈래") == "단가산출"
|
||||
}
|
||||
for line in doc.get("식") or []:
|
||||
try:
|
||||
if subs & set(md.names(md.parse(line.get("식")))):
|
||||
return True
|
||||
except md.DocError:
|
||||
pass
|
||||
return False
|
||||
|
||||
|
||||
def why(doc: dict, old, new) -> str:
|
||||
"""다름 까닭 — 문서 꼴에서 바로 보이는 것만 · 아니면 「까닭 모름」(시험이 막음)."""
|
||||
if isinstance(old, str) and not isinstance(new, str):
|
||||
return f"옛 엔진 멈춤 · 새 계산기 셈 — {old}"
|
||||
if isinstance(new, str) and not isinstance(old, str):
|
||||
return f"새 계산기 못 셈 — {new}"
|
||||
if _uses_raw_sub(doc):
|
||||
return RAW_SUB + " · 채택(요구 714-3)"
|
||||
return "까닭 모름"
|
||||
|
||||
|
||||
def build(log=print) -> dict:
|
||||
"""변환 · 대조 전부 — {문서, 알림, 파일, 대조, 저장, 요약}."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
files, whole = m01.loaded()
|
||||
items = rows_of(files)
|
||||
docs, notes, by_file = {}, {}, {}
|
||||
for name, row in items:
|
||||
key = str(row["키"])
|
||||
docs[key], notes[key] = cv.convert(whole, row)
|
||||
by_file.setdefault(name, []).append(key)
|
||||
log(f"변환 {len(docs)}")
|
||||
links = ml.Links(whole, docs)
|
||||
runs, both_out = [], 0
|
||||
for _, row in items:
|
||||
key = str(row["키"])
|
||||
for label, given, changed in cases_of(whole, row):
|
||||
old = old_answer(whole, row, given)
|
||||
new = new_answer(links, docs[key], changed)
|
||||
same = agree(old, new)
|
||||
both_out += isinstance(old, str) and isinstance(new, str)
|
||||
runs.append(
|
||||
{
|
||||
"로직": key,
|
||||
"이름": row.get("이름") or "",
|
||||
"옵션": label,
|
||||
"옛": old,
|
||||
"새": new,
|
||||
"같음": same,
|
||||
}
|
||||
)
|
||||
for one in runs:
|
||||
if not one["같음"]:
|
||||
one["채택"] = (one["로직"], one["옵션"]) in ADOPTED
|
||||
one["까닭"] = why(docs[one["로직"]], one["옛"], one["새"])
|
||||
keep = _keep(docs, runs)
|
||||
for one in runs: # 같아도 못 넣는 것 — 부르는 단가산출이 빠짐
|
||||
if one["같음"] and one["로직"] not in keep and not one["옵션"]:
|
||||
one["빠짐"] = "부르는 단가산출이 빠짐 — " + " · ".join(
|
||||
sorted(_calls(docs[one["로직"]]) - keep)
|
||||
)
|
||||
summary = {
|
||||
"로직": len(docs),
|
||||
"기본 같음": sum(1 for x in runs if not x["옵션"] and x["같음"]),
|
||||
"기본 다름": sum(1 for x in runs if not x["옵션"] and not x["같음"]),
|
||||
"옵션 표본": sum(1 for x in runs if x["옵션"]),
|
||||
"옵션 같음": sum(1 for x in runs if x["옵션"] and x["같음"]),
|
||||
"옵션 다름": sum(1 for x in runs if x["옵션"] and not x["같음"]),
|
||||
"채택된 차이": sum(1 for x in runs if x.get("채택")),
|
||||
"둘 다 못 셈": both_out,
|
||||
"저장": len(keep),
|
||||
"변환 알림": sum(1 for v in notes.values() if v),
|
||||
}
|
||||
log(" · ".join(f"{k} {v}" for k, v in summary.items()))
|
||||
return {
|
||||
"문서": docs,
|
||||
"알림": notes,
|
||||
"파일": by_file,
|
||||
"대조": runs,
|
||||
"저장": keep,
|
||||
"요약": summary,
|
||||
"저장본": carried(),
|
||||
}
|
||||
|
||||
|
||||
def carried() -> dict[str, dict]:
|
||||
"""이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}."""
|
||||
if not ml.FOLDER.exists():
|
||||
return {}
|
||||
return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)}
|
||||
|
||||
|
||||
def hand_kept(result: dict) -> list[str]:
|
||||
"""저장본 그대로 둔 `손고침` 문서 키(저장되는 것만)."""
|
||||
have = result.get("저장본") or {}
|
||||
return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"])
|
||||
|
||||
|
||||
def _labels() -> tuple[dict[str, dict], dict[str, dict]]:
|
||||
"""855 L1 이름표 — ({키: 로직 줄}, {로직 파일: 머리 이름표}) · 셈 · 지문 밖."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
rows, heads = {}, {}
|
||||
for name, data in m01.loaded()[0].items():
|
||||
if data.get("그룹") == "로직":
|
||||
heads[name] = {k: data[k] for k in md.FILE_TAGS if k in data}
|
||||
rows.update({str(r["키"]): r for r in data.get("줄") or []})
|
||||
return rows, heads
|
||||
|
||||
|
||||
def _out_doc(result: dict, key: str, rows: dict | None = None) -> dict:
|
||||
"""쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서 ·
|
||||
이름표(855 L1) = 로직 줄 것(`rows` · 없으면 그대로)."""
|
||||
have = (result.get("저장본") or {}).get(key)
|
||||
if have and have.get(mcv.HAND):
|
||||
out = have
|
||||
elif have and have.get(mcv.COVER):
|
||||
out = {**result["문서"][key], mcv.COVER: have[mcv.COVER]}
|
||||
else:
|
||||
out = result["문서"][key]
|
||||
row = (rows or {}).get(key)
|
||||
return md.tag(out, row) if row is not None else out
|
||||
|
||||
|
||||
def _calls(doc: dict) -> set[str]:
|
||||
out = set()
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") == "단가산출" and "{" not in str(link.get("키")):
|
||||
out.add(str(link["키"]))
|
||||
return out
|
||||
|
||||
|
||||
def _keep(docs: dict, runs: list[dict]) -> set[str]:
|
||||
"""저장할 문서 — 모든 대조 같음 + 부르는 단가산출도 저장(닫힘).
|
||||
키 구멍 부름은 그 로직 대조로 판정."""
|
||||
keep = set(docs) - {x["로직"] for x in runs if not x["같음"] and not x.get("채택")}
|
||||
while True:
|
||||
drop = {k for k in keep if not _calls(docs[k]) <= keep}
|
||||
if not drop:
|
||||
return keep
|
||||
keep -= drop
|
||||
|
||||
|
||||
def saved_keys() -> set[str]:
|
||||
"""지금 저장본 수식 문서 키."""
|
||||
return {
|
||||
str(d.get("키"))
|
||||
for p in ml.FOLDER.glob("수식_*.json")
|
||||
for d in ml.load_file(p).get("줄") or []
|
||||
}
|
||||
|
||||
|
||||
def foreign(result: dict) -> dict[str, dict]:
|
||||
"""빌더가 짓지 않는 저장본 문서(옛 로직 줄 없는 키) {파일 이름: {머리 · 줄}} — 그대로 둠(848-4)."""
|
||||
out: dict[str, dict] = {}
|
||||
for path in sorted(ml.FOLDER.glob("수식_*.json")) if ml.FOLDER.exists() else []:
|
||||
data = ml.load_file(path)
|
||||
rows = [d for d in data.get("줄") or [] if str(d.get("키")) not in result["문서"]]
|
||||
if rows:
|
||||
out[path.name] = {**{k: v for k, v in data.items() if k != "줄"}, "줄": rows}
|
||||
return out
|
||||
|
||||
|
||||
def foreign_keys(result: dict) -> list[str]:
|
||||
return sorted(str(d.get("키")) for x in foreign(result).values() for d in x["줄"])
|
||||
|
||||
|
||||
def lost(result: dict) -> list[str]:
|
||||
"""저장본에 있는데 이번 빌드가 저장 밖으로 뺀 문서 — 「키 까닭」(빌더가 조용히 지우지 않게) ·
|
||||
빌더가 짓지 않는 문서는 그대로 두므로 뺌."""
|
||||
why = {}
|
||||
for one in result["대조"]:
|
||||
if one["로직"] not in result["저장"]:
|
||||
why.setdefault(one["로직"], one.get("까닭") or one.get("빠짐") or "")
|
||||
gone = saved_keys() - result["저장"] - set(foreign_keys(result))
|
||||
return [f"{k} {why.get(k) or '저장 밖'}" for k in sorted(gone)]
|
||||
|
||||
|
||||
def files_of(result: dict) -> dict[str, str]:
|
||||
"""저장 파일 이름 → 글 · 빌더가 짓지 않는 저장본 문서 = 제 파일 끝에 그대로."""
|
||||
bodies = {}
|
||||
rows, heads = _labels()
|
||||
for name, keys in result["파일"].items():
|
||||
kept = [_out_doc(result, k, rows) for k in keys if k in result["저장"]]
|
||||
head = heads.get(name) or {} # 855 L1 파일 머리 이름표
|
||||
bodies[ml.file_of(name)] = {"그룹": "수식문서", "로직파일": name, **head, "줄": kept}
|
||||
for file, data in foreign(result).items():
|
||||
if file in bodies:
|
||||
bodies[file]["줄"] += data["줄"]
|
||||
else:
|
||||
bodies[file] = data
|
||||
return {file: ml.dump(body) for file, body in bodies.items()}
|
||||
|
||||
|
||||
def table_rows(result: dict) -> list[list[str]]:
|
||||
rows = []
|
||||
for one in result["대조"]:
|
||||
if one["같음"] and not one.get("빠짐"):
|
||||
continue
|
||||
rows.append(
|
||||
[
|
||||
one["로직"],
|
||||
one["이름"],
|
||||
one["옵션"] or "기본",
|
||||
_text(one["옛"]),
|
||||
_text(one["새"]),
|
||||
"" if one["같음"] else _gap(one["옛"], one["새"]),
|
||||
one.get("까닭") or one.get("빠짐") or "",
|
||||
]
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
def write_list(result: dict, path: Path = LIST) -> None:
|
||||
from openpyxl import Workbook
|
||||
|
||||
book = Workbook()
|
||||
sheet = book.active
|
||||
sheet.title = "다름"
|
||||
sheet.append(list(HEAD))
|
||||
for row in table_rows(result):
|
||||
sheet.append(row)
|
||||
for col, width in zip("ABCDEFG", (11, 30, 26, 46, 46, 22, 70)):
|
||||
sheet.column_dimensions[col].width = width
|
||||
for title, rows in list(_sheets(result).items())[1:]:
|
||||
sheet = book.create_sheet(title)
|
||||
for row in rows:
|
||||
sheet.append(row)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
book.save(path)
|
||||
|
||||
|
||||
def read_list(path: Path = LIST) -> dict[str, list[list[str]]]:
|
||||
from openpyxl import load_workbook
|
||||
|
||||
book = load_workbook(path, read_only=True)
|
||||
out = {
|
||||
s.title: [
|
||||
["" if c is None else str(c) for c in row] for row in s.iter_rows(values_only=True)
|
||||
]
|
||||
for s in book.worksheets
|
||||
}
|
||||
book.close()
|
||||
return out
|
||||
|
||||
|
||||
def _sheets(result: dict) -> dict[str, list[list[str]]]:
|
||||
notes = [["로직", "알림"]] + [[k, t] for k, v in sorted(result["알림"].items()) for t in v]
|
||||
both = [["로직", "이름", "옵션", "옛", "새"]] + [
|
||||
[x["로직"], x["이름"], x["옵션"] or "기본", x["옛"], x["새"]]
|
||||
for x in result["대조"]
|
||||
if isinstance(x["옛"], str) and isinstance(x["새"], str)
|
||||
]
|
||||
return {
|
||||
"다름": [list(HEAD), *table_rows(result)],
|
||||
"요약": [[k, str(v)] for k, v in result["요약"].items()],
|
||||
"둘 다 못 셈": both,
|
||||
"변환 알림": notes,
|
||||
}
|
||||
|
||||
|
||||
def check(result: dict) -> list[str]:
|
||||
"""저장본 · 목록이 지금 빌드와 같은지 — 다른 것 목록."""
|
||||
out = []
|
||||
want = files_of(result)
|
||||
have = {p.name for p in ml.FOLDER.glob("수식_*.json")}
|
||||
for name in sorted(have - set(want)):
|
||||
out.append(f"남은 파일 {name}")
|
||||
for name, text in sorted(want.items()):
|
||||
path = ml.FOLDER / name
|
||||
if not path.exists() or path.read_text(encoding="utf-8") != text:
|
||||
out.append(f"다른 파일 {name}")
|
||||
if not LIST.exists() or read_list() != _sheets(result):
|
||||
out.append(f"다른 목록 {LIST.name}")
|
||||
return out
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만")
|
||||
args = parser.parse_args()
|
||||
result = build()
|
||||
if hand := hand_kept(result):
|
||||
print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}")
|
||||
if own := foreign_keys(result):
|
||||
print(f"빌더가 짓지 않는 문서 {len(own)} 장 — 저장본 그대로(안 지움): {' · '.join(own)}")
|
||||
if args.check:
|
||||
bad = check(result)
|
||||
for line in bad:
|
||||
print(line)
|
||||
print("같음" if not bad else f"다름 {len(bad)}")
|
||||
return 1 if bad else 0
|
||||
if gone := lost(result):
|
||||
for line in gone:
|
||||
print(f"저장본에서 빠질 문서 {line}")
|
||||
print(f"멈춤 — 저장본 문서 {len(gone)} 개가 빠짐(안 씀) · 까닭을 고친 뒤 다시")
|
||||
return 1
|
||||
ml.FOLDER.mkdir(parents=True, exist_ok=True)
|
||||
want = files_of(result)
|
||||
for path in ml.FOLDER.glob("수식_*.json"):
|
||||
if path.name not in want:
|
||||
path.unlink()
|
||||
for name, text in want.items():
|
||||
(ml.FOLDER / name).write_text(text, encoding="utf-8", newline="\n")
|
||||
write_list(result)
|
||||
print(f"저장 {len(want)} 파일 · 목록 {LIST}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,225 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""소요량 · 계수 표마다 「용도」(공종 · 대상 · 로직키) 채우기.
|
||||
|
||||
담당: 소요량_*.json · 계수_*.json (읽기+쓰기) · 로직_*.json · 원문 md (읽기만).
|
||||
다시 돌리면 같은 결과 — 순수 함수 + 정렬.
|
||||
"""
|
||||
|
||||
import glob
|
||||
import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[3]
|
||||
MASTER = ROOT / "resources" / "master_data"
|
||||
ORIG_KS = ROOT / "resources" / "knowledge" / "original" / "원가계산" / "건설공사_표준품셈" / "본문"
|
||||
ORIG_SR = ROOT / "resources" / "knowledge" / "original" / "원가계산" / "산림_표준품셈" / "본문"
|
||||
|
||||
CODE_RE = re.compile(r"\b([A-Z]{2}\d{6})\b")
|
||||
HEADING_RE = re.compile(r"^#{2,4}\s+([0-9]+(?:-[0-9]+)*)\.?\s+(.+?)\s*$")
|
||||
TRAIL_PAREN_RE = re.compile(r"(\s*\([^()]*\))+\s*$")
|
||||
|
||||
_heading_cache = {}
|
||||
|
||||
# 원문번호 절 이름이 표 내용과 안 맞는 예외 — 검증(ref/_검증_기계_용도.md) 반영.
|
||||
OVERRIDE_공종 = {
|
||||
"CC000074": "불도저·굴착기", # 8-4-8 은 「[70]기타기계」 절이나 내용은 불도저·굴착기 잡재료 비율
|
||||
}
|
||||
|
||||
|
||||
def _find_부문_dir(부문):
|
||||
if not ORIG_KS.exists():
|
||||
return None
|
||||
for d in sorted(ORIG_KS.iterdir()):
|
||||
if d.is_dir() and d.name.endswith(부문 + "부문"):
|
||||
return d
|
||||
return None
|
||||
|
||||
|
||||
def _find_장_dir(base, 장):
|
||||
m = re.match(r"(\d+)", 장 or "")
|
||||
if not m or not base or not base.exists():
|
||||
return None
|
||||
num = m.group(1).zfill(2)
|
||||
for d in sorted(base.iterdir()):
|
||||
if d.is_dir() and d.name.startswith(f"제{num}장"):
|
||||
return d
|
||||
return None
|
||||
|
||||
|
||||
def _heading_index(folder):
|
||||
key = str(folder)
|
||||
if key in _heading_cache:
|
||||
return _heading_cache[key]
|
||||
idx = {}
|
||||
if folder and folder.exists():
|
||||
for md in sorted(folder.glob("*.md")):
|
||||
for line in md.read_text(encoding="utf-8").splitlines():
|
||||
m = HEADING_RE.match(line)
|
||||
if not m:
|
||||
continue
|
||||
num, text = m.group(1), m.group(2)
|
||||
text = TRAIL_PAREN_RE.sub("", text).strip()
|
||||
idx.setdefault(num, text)
|
||||
_heading_cache[key] = idx
|
||||
return idx
|
||||
|
||||
|
||||
def resolve_공종(원문, 부문, 장, 원문번호):
|
||||
if 원문 == "건설품셈":
|
||||
base = _find_부문_dir(부문 or "")
|
||||
folder = _find_장_dir(base, 장 or "")
|
||||
elif 원문 == "산림품셈":
|
||||
folder = _find_장_dir(ORIG_SR, 장 or "")
|
||||
else:
|
||||
folder = None
|
||||
idx = _heading_index(folder)
|
||||
num = 원문번호 or ""
|
||||
parts = num.split("-")
|
||||
while parts:
|
||||
cand = "-".join(parts)
|
||||
if cand in idx:
|
||||
return idx[cand]
|
||||
parts = parts[:-1]
|
||||
return None
|
||||
|
||||
|
||||
def _load_names(path, key="이름"):
|
||||
d = json.load(open(path, encoding="utf-8"))
|
||||
return set(r[key] for r in d["줄"] if r.get(key))
|
||||
|
||||
|
||||
def load_masters():
|
||||
인력_이름 = _load_names(MASTER / "인력.json")
|
||||
import master_machine_files as mmf # 기계 = 폴더(826-2)
|
||||
|
||||
기계_d = mmf.table(MASTER)[0]
|
||||
기계_이름 = set()
|
||||
for r in 기계_d["줄"]:
|
||||
기계_이름.add(r["이름"])
|
||||
if r.get("상세구분"):
|
||||
기계_이름.add(r["상세구분"])
|
||||
재료_이름 = _load_names(MASTER / "재료_품셈재료.json")
|
||||
return 인력_이름, 기계_이름, 재료_이름
|
||||
|
||||
|
||||
def _strip_spec(key):
|
||||
return key.split("(", 1)[0].strip()
|
||||
|
||||
|
||||
def classify_대상(item, 인력_이름, 기계_이름, 재료_이름):
|
||||
대상 = set()
|
||||
이름 = item.get("이름", "")
|
||||
if "할증" in 이름:
|
||||
대상.add("할증")
|
||||
if "환산" in 이름:
|
||||
대상.add("환산")
|
||||
조건 = item.get("조건") or {}
|
||||
if 조건:
|
||||
대상.add("작업량 조건")
|
||||
|
||||
값칸 = item.get("값칸") or {}
|
||||
keys = list(값칸.keys())
|
||||
row_vals = set()
|
||||
for row in item.get("줄") or []:
|
||||
if isinstance(row, dict):
|
||||
for v in row.values():
|
||||
if isinstance(v, str):
|
||||
row_vals.add(v)
|
||||
|
||||
candidates = set(keys) | row_vals
|
||||
for c in candidates:
|
||||
base = _strip_spec(c)
|
||||
if c in 인력_이름 or base in 인력_이름:
|
||||
대상.add("인력")
|
||||
elif c in 기계_이름 or base in 기계_이름:
|
||||
대상.add("기계")
|
||||
elif c in 재료_이름 or base in 재료_이름:
|
||||
대상.add("재료")
|
||||
|
||||
for k in keys:
|
||||
if "시공량" in k:
|
||||
대상.add("작업량 조건")
|
||||
|
||||
if not 대상:
|
||||
대상.add("작업량 조건")
|
||||
return sorted(대상)
|
||||
|
||||
|
||||
def build_로직_index():
|
||||
idx = {}
|
||||
for fp in sorted(glob.glob(str(MASTER / "로직_*.json"))):
|
||||
d = json.load(open(fp, encoding="utf-8"))
|
||||
for row in d.get("줄", []):
|
||||
own = row.get("키")
|
||||
text = json.dumps(row, ensure_ascii=False)
|
||||
for code in set(CODE_RE.findall(text)):
|
||||
if code == own:
|
||||
continue
|
||||
idx.setdefault(code, set()).add(own)
|
||||
return idx
|
||||
|
||||
|
||||
def main():
|
||||
인력_이름, 기계_이름, 재료_이름 = load_masters()
|
||||
로직_idx = build_로직_index()
|
||||
|
||||
files = sorted(glob.glob(str(MASTER / "소요량_*.json"))) + sorted(
|
||||
glob.glob(str(MASTER / "계수_*.json"))
|
||||
)
|
||||
|
||||
총_항목 = 0
|
||||
공종_미확인 = []
|
||||
|
||||
for fp in files:
|
||||
d = json.load(open(fp, encoding="utf-8"))
|
||||
원문 = d.get("원문")
|
||||
부문 = d.get("부문")
|
||||
용도_map = {}
|
||||
for item in d.get("표", []):
|
||||
총_항목 += 1
|
||||
키 = item["키"]
|
||||
장 = item.get("상세구분")
|
||||
if 키 in OVERRIDE_공종:
|
||||
공종 = OVERRIDE_공종[키]
|
||||
else:
|
||||
공종 = resolve_공종(원문, 부문, 장, item.get("원문번호"))
|
||||
if 공종 is None:
|
||||
공종_미확인.append((키, fp, item.get("원문번호")))
|
||||
공종 = item.get("이름", "").split("(", 1)[0].strip()
|
||||
대상 = classify_대상(item, 인력_이름, 기계_이름, 재료_이름)
|
||||
로직키 = sorted(로직_idx.get(키, []))
|
||||
용도_map[키] = {"공종": 공종, "대상": 대상, "로직키": 로직키}
|
||||
|
||||
text = open(fp, encoding="utf-8").read()
|
||||
lines = text.split("\n")
|
||||
out = []
|
||||
cur_키 = None
|
||||
key_re = re.compile(r'"키":\s*"([A-Z]{2}\d{6})"')
|
||||
src_re = re.compile(r'^(\s*)"출처":\s*".*",\s*$')
|
||||
old_용도_re = re.compile(r'^\s*"용도":\s*\{.*\},\s*$')
|
||||
for line in lines:
|
||||
if old_용도_re.match(line):
|
||||
continue
|
||||
m = key_re.search(line)
|
||||
if m:
|
||||
cur_키 = m.group(1)
|
||||
out.append(line)
|
||||
sm = src_re.match(line)
|
||||
if sm and cur_키 in 용도_map:
|
||||
indent = sm.group(1)
|
||||
payload = json.dumps(용도_map[cur_키], ensure_ascii=False)
|
||||
out.append(f'{indent}"용도": {payload},')
|
||||
|
||||
new_text = "\n".join(out)
|
||||
with open(fp, "w", encoding="utf-8") as f:
|
||||
f.write(new_text)
|
||||
|
||||
print("총 항목:", 총_항목, "/ 공종 미확인:", len(공종_미확인))
|
||||
if 공종_미확인:
|
||||
for 키, fp, 번호 in 공종_미확인[:30]:
|
||||
print(" 미확인:", 키, 번호, fp)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,370 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""로직 재료 줄의 자재품목 키를 「기본 검색어」 로 바꿈 (PLAN 8-3 · 계약 8-1).
|
||||
|
||||
· 대표 키 박은 줄 · 대표가 재료 입력(`{철선}`)인 줄 · 조건만 있는 줄 — 요소를
|
||||
`{구분, 상세구분, 검색어}` 로. 검색어는 지금 잡히는 품목(자동값)이 8-1 찾기 규칙 ·
|
||||
자동값 차례로 첫째가 되게 지음(이름 핵심 + 규격 핵심 + 지역 낱말 · 모자라면 낱말을 더함)
|
||||
· 재료 입력 키 목록(고르기가 자재품목 키인 입력)은 걷음 — 그 입력을 넘기던 `이름=이름` 인자도
|
||||
· 지역·계약종별 조건 줄 · 유가전력 틀(`MO:경유:{지역}`)은 그대로 — 자재품목 키가 아님
|
||||
· 글 모양 그대로 — 바뀐 값 자리만 갈음 · 다시 돌려도 같은 결과
|
||||
|
||||
사용: python scripts/build_재료_검색어.py (마른 돌리기 — 파일 안 씀 · 못 맞춘 줄 목록)
|
||||
python scripts/build_재료_검색어.py --쓰기 (로직 파일 갱신)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
|
||||
import check_master as cm # noqa: E402
|
||||
import master_auto as mau # noqa: E402
|
||||
import master_formula as mf # noqa: E402
|
||||
import master_material as mm # noqa: E402
|
||||
import master_pick as mp # noqa: E402
|
||||
|
||||
MASTER = HERE.parent
|
||||
KEY = re.compile(r"MT\d{6}")
|
||||
|
||||
|
||||
# ── 판정 — 서버 찾기(`master_pick.search`) 그대로 ─────────────────────────
|
||||
def _has(word: str, row: dict) -> bool:
|
||||
"""`master_pick.search` 와 같은 맞대기 — 낱말이 이름 또는 규격에 듦."""
|
||||
w = mm.plain_spec(word)
|
||||
return w in mm.plain(row.get("이름")).replace("×", "x") or w in mm.plain_spec(row.get("규격"))
|
||||
|
||||
|
||||
def found(master: mf.Master, elem: dict, unit: str | None, env: dict) -> list[str]:
|
||||
return mp.search(master, elem, env, unit)
|
||||
|
||||
|
||||
def first(master, elem, unit, env) -> str | None:
|
||||
got = found(master, elem, unit, env)
|
||||
return got[0] if got else None
|
||||
|
||||
|
||||
# ── 지금 잡히는 품목 ──────────────────────────────────────────────────
|
||||
def material_inputs(row: dict) -> dict[str, list]:
|
||||
"""고르기가 자재품목 키 목록인 입력 — 걷을 것."""
|
||||
return {
|
||||
s["이름"]: s["고르기"]
|
||||
for s in row.get("입력", [])
|
||||
if isinstance(s.get("고르기"), list)
|
||||
and s["고르기"]
|
||||
and all(isinstance(x, str) and KEY.fullmatch(x) for x in s["고르기"])
|
||||
}
|
||||
|
||||
|
||||
def _holes(elem: dict) -> list[str]:
|
||||
return sorted({h for v in elem.values() if isinstance(v, str) for h in mf._HOLE.findall(v)})
|
||||
|
||||
|
||||
def envs(master: mf.Master, row: dict, elem: dict) -> list[dict]:
|
||||
"""줄을 판정할 입력 벌 — 자동값 하나 · 조건에 끼운 입력은 고르기 값마다."""
|
||||
base = mau.values(master, row)
|
||||
out = [base]
|
||||
for hole in _holes(elem):
|
||||
spec = next((s for s in row.get("입력", []) if s["이름"] == hole), {})
|
||||
if spec.get("고르기") and hole not in material_inputs(row):
|
||||
out = [{**e, hole: v} for e in out for v in spec["고르기"]]
|
||||
return out
|
||||
|
||||
|
||||
def old_pick(master: mf.Master, elem: dict, env: dict, unit: str | None) -> str | None:
|
||||
try:
|
||||
cond = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in elem.items()}
|
||||
return mm.pick(master, cond, env, unit)
|
||||
except mf.FormulaError:
|
||||
return None
|
||||
|
||||
|
||||
# ── 검색어 짓기 ───────────────────────────────────────────────────────
|
||||
def _name(v) -> str:
|
||||
"""품명 — 띄어 쓴 한글 글자는 붙임(「골 함 석」) · 쉼표 둘레 빈칸 뗌 · 영문 낱말 사이는 둠."""
|
||||
s = re.sub(r"\s*,\s*", ",", str(v or "").strip())
|
||||
return re.sub(r"(?<=[가-힣])\s+(?=[가-힣])", "", s)
|
||||
|
||||
|
||||
def _root(name: str) -> str:
|
||||
"""이름 핵심 — 빈칸 뗌 · 첫 괄호·쉼표 앞(「박 리 제(중유)」 → 박리제)."""
|
||||
return re.split(r"[(\[,]", _name(name))[0]
|
||||
|
||||
|
||||
def _pieces(spec) -> list[str]:
|
||||
"""규격 조각 — 빈칸·쉼표로 · 괄호 속 쉼표는 안 가름(「저유황(목재,합판용)」)."""
|
||||
return [p for p in re.split(r"\s+|,(?![^()]*\))", str(spec or "")) if p]
|
||||
|
||||
|
||||
def _core(row: dict) -> list[str]:
|
||||
"""이름 핵심(첫 쉼표 앞 · 괄호 그대로 「합판(내수)」) + 규격 핵심(첫 조각 · 「12t×1220×…」 →
|
||||
글자 든 첫 토막 12t)."""
|
||||
name = _name(row.get("이름")).split(",")[0]
|
||||
pieces = _pieces(row.get("규격"))
|
||||
spec = "".join(pieces[:2]) if pieces and len(pieces[0]) < 2 else (pieces or [""])[0]
|
||||
head = re.split(r"[×xX*]", spec)[0]
|
||||
if head != spec and re.search(r"[^\d.]", head):
|
||||
spec = head
|
||||
return [w for w in (name, spec) if w]
|
||||
|
||||
|
||||
def _tokens(row: dict) -> list[str]:
|
||||
"""더할 낱말 후보 — 이름 조각(쉼표로) · 이름 괄호 · 규격 조각(쉼표·빈칸·×로)."""
|
||||
name = _name(row.get("이름"))
|
||||
parts = [p for p in name.split(",") if p]
|
||||
out = parts + re.findall(r"\([^()]*\)", name)
|
||||
pieces = _pieces(row.get("규격"))
|
||||
out += pieces + [q for p in pieces for q in re.split(r"[×xX*]", p) if q and q != p]
|
||||
return list(dict.fromkeys(w for w in out if w))
|
||||
|
||||
|
||||
def _place(row: dict) -> str | None:
|
||||
tail = _name(row.get("이름")).split(",")[-1]
|
||||
return tail if tail in mp.REGIONS else None
|
||||
|
||||
|
||||
def _ok(master, elem, unit, cases) -> bool:
|
||||
"""판정 — 입력 벌마다 서버 찾기 첫째가 지금 품목."""
|
||||
for env, want in cases:
|
||||
filled = {k: mf.fill(v, env) if isinstance(v, str) else v for k, v in elem.items()}
|
||||
if first(master, filled, unit, env) != want:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def words_for(master, base: dict, words: list[str], unit, cases) -> list[str] | None:
|
||||
"""모자라면 첫 품목의 낱말을 하나씩 더함 — 앞선 줄을 가장 많이 떨구는 낱말부터."""
|
||||
target_rows = {want for _, want in cases}
|
||||
for _ in range(6):
|
||||
elem = {**base, "검색어": " ".join(words)}
|
||||
if _ok(master, elem, unit, cases):
|
||||
return words
|
||||
if len(target_rows) != 1 or None in target_rows:
|
||||
return None # 입력 따라 품목이 갈리는 줄 — 끼운 낱말로만
|
||||
want = master.get(next(iter(target_rows)))
|
||||
env = cases[0][0]
|
||||
got = found(master, {k: mf.fill(v, env) for k, v in elem.items()}, unit, env)
|
||||
ahead = got[: got.index(want["키"])] if want["키"] in got else got
|
||||
pick = None
|
||||
for w in _tokens(want):
|
||||
if w in words or not _has(w, want):
|
||||
continue
|
||||
cut = sum(not _has(w, master.get(k)) for k in set(ahead))
|
||||
if cut and (pick is None or cut > pick[0]):
|
||||
pick = (cut, w)
|
||||
if not pick:
|
||||
return None
|
||||
words.append(pick[1])
|
||||
return None
|
||||
|
||||
|
||||
def convert(master: mf.Master, row: dict, item: dict) -> tuple[dict | None, list]:
|
||||
"""재료 줄 하나 → 새 요소 · 판정 벌. 못 맞추면 (None, 벌)."""
|
||||
elem, unit = item["요소"], item.get("단위")
|
||||
cases = []
|
||||
for env in envs(master, row, elem):
|
||||
cases.append((env, old_pick(master, elem, env, unit)))
|
||||
base = {k: elem[k] for k in ("구분", "상세구분") if elem.get(k)}
|
||||
# 이미 좁혀 둔 이름·규격 낱말은 그대로 검색어로(`{관경}` 같은 끼운 칸도)
|
||||
words = [w for k in ("이름", "규격") for w in str(elem.get(k) or "").split()]
|
||||
targets = {want for _, want in cases}
|
||||
if targets == {None}:
|
||||
# 지금 같은 단위 후보 0 인 빈 줄 — 후보 단위가 줄 단위와 같은 성격(g ↔ kg 등)일 때만
|
||||
# 검색어로(값이 생김 · 금액 바뀜 · 줄마다 보고) · 성격이 다르면 빈칸 그대로
|
||||
probe = {**base, "검색어": _root(item.get("이름"))}
|
||||
got = mp.search(master, probe, mau.values(master, row), unit)
|
||||
if not got or not mp.same_kind(master.get(got[0])["단위"], unit):
|
||||
return None, cases
|
||||
name = _core(master.get(got[0]))[0]
|
||||
return {**base, "검색어": name}, cases
|
||||
if len(targets) == 1:
|
||||
want = master.get(next(iter(targets)))
|
||||
name, *spec = _core(want)
|
||||
if not any(mm.plain(w) in mm.plain(name) for w in words):
|
||||
words.insert(0, name) # 조건 이름 낱말이 이미 품명을 가리키면 그대로
|
||||
if spec and not elem.get("규격") and spec[0] not in words:
|
||||
words.append(spec[0])
|
||||
place = _place(want)
|
||||
if place and place not in words:
|
||||
words.append(place)
|
||||
else:
|
||||
roots = {_root(master.get(t)["이름"]) for t in targets if t}
|
||||
if (
|
||||
len(roots) == 1
|
||||
and (root := roots.pop())
|
||||
and not any(mm.plain(root) in mm.plain(w) for w in words)
|
||||
):
|
||||
words.insert(0, root)
|
||||
got = words_for(master, base, list(words), unit, cases)
|
||||
return ({**base, "검색어": " ".join(got)} if got else None), cases
|
||||
|
||||
|
||||
# ── 돌리기 ────────────────────────────────────────────────────────────
|
||||
def _targets(item: dict) -> bool:
|
||||
elem = item.get("요소")
|
||||
return (
|
||||
item.get("종류") == "재료"
|
||||
and isinstance(elem, dict)
|
||||
and "검색어" not in elem
|
||||
and elem.get("지역") != "입력"
|
||||
and elem.get("계약종별") != "입력"
|
||||
)
|
||||
|
||||
|
||||
def plan(master: mf.Master, files: dict[str, dict]) -> tuple[dict, list]:
|
||||
"""파일마다 {로직 키: {"요소": {호표 차례: 새 요소}, "걷음": [입력 이름]}} · 못 맞춘 줄."""
|
||||
out, misses = {}, []
|
||||
for name, data in files.items():
|
||||
if not name.startswith("로직_"):
|
||||
continue
|
||||
for row in data["줄"]:
|
||||
elems = {}
|
||||
for i, item in enumerate(row.get("호표", [])):
|
||||
if not _targets(item):
|
||||
continue
|
||||
elem, cases = convert(master, row, item)
|
||||
if elem is None:
|
||||
misses.append((row["키"], i, item.get("이름"), item["요소"], cases))
|
||||
else:
|
||||
elems[i] = elem
|
||||
gone = list(material_inputs(row))
|
||||
if elems or gone:
|
||||
out.setdefault(name, {})[row["키"]] = {"요소": elems, "걷음": gone}
|
||||
return out, misses
|
||||
|
||||
|
||||
_ARG = r"\s*,\s*{n}\s*=\s*{n}(?=\s*[,)])"
|
||||
# 걷는 입력을 식에서 품목 키로 쓰던 자리(`MT:{합판}`) — 같은 값의 호표 줄 금액으로
|
||||
# (GC000211 소모자재: 줄 금액 = 찾기 수량 × 합판율 × 단가 이므로 합판율을 줄 금액이 품음)
|
||||
SWAP = {
|
||||
"(찾기(QC000427).합판 * MT:{합판} + 찾기(QC000427).각재 * MT:{각재}) * 합판율 * ": (
|
||||
"(줄.'합판(내수 12㎜)' + 줄.'각재') * "
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
def _strip(text: str, names) -> str:
|
||||
"""부르는 식의 `, 철선=철선` 인자를 뗌 · 품목 키 자리는 줄 금액으로."""
|
||||
for n in names:
|
||||
text = re.sub(_ARG.format(n=re.escape(n)), "", text)
|
||||
for old, new in SWAP.items():
|
||||
text = text.replace(old, new)
|
||||
return text
|
||||
|
||||
|
||||
def apply(row: dict, change: dict) -> dict:
|
||||
"""바꿈을 줄 사본에 — 새 요소 · 재료 입력 걷음 · 그 입력을 넘기던 인자 뗌."""
|
||||
new = _copy(row)
|
||||
for i, elem in change["요소"].items():
|
||||
new["호표"][i]["요소"] = elem
|
||||
gone = change["걷음"]
|
||||
if gone:
|
||||
new["입력"] = [s for s in new["입력"] if s["이름"] not in gone]
|
||||
for group in ("중간", "호표", "덧줄"):
|
||||
for part in new.get(group, []):
|
||||
for k in ("식", "요소", "수량"):
|
||||
if isinstance(part.get(k), str):
|
||||
part[k] = _strip(part[k], gone)
|
||||
if "결과" in new:
|
||||
new["결과"]["식"] = _strip(new["결과"]["식"], gone)
|
||||
return new
|
||||
|
||||
|
||||
def _copy(v):
|
||||
if isinstance(v, dict):
|
||||
return {k: _copy(x) for k, x in v.items()}
|
||||
if isinstance(v, list):
|
||||
return [_copy(x) for x in v]
|
||||
return v
|
||||
|
||||
|
||||
# ── 글 모양 그대로 쓰기 ──────────────────────────────────────────────────
|
||||
_DEC = json.JSONDecoder()
|
||||
|
||||
|
||||
def _skip(text: str, pos: int) -> int:
|
||||
while text[pos] in " \t\r\n":
|
||||
pos += 1
|
||||
return pos
|
||||
|
||||
|
||||
def _items(text: str, pos: int) -> list[tuple[int, int]]:
|
||||
"""`[` 바로 뒤 `pos` 부터 목록 칸마다 (처음, 끝)."""
|
||||
spans = []
|
||||
while text[pos := _skip(text, pos)] != "]":
|
||||
_, end = _DEC.raw_decode(text, pos)
|
||||
spans.append((pos, end))
|
||||
pos = _skip(text, end)
|
||||
pos += text[pos] == ","
|
||||
return spans
|
||||
|
||||
|
||||
def _patch_row(text: str, row: dict, change: dict) -> str:
|
||||
"""줄 글 하나 — 바뀐 요소 값 자리 · 걷은 입력 칸 · 뗀 인자만 갈음."""
|
||||
spots = [m.end() for m in re.finditer(r'"요소"\s*:\s*', text)]
|
||||
if len(spots) != len(row.get("호표", [])):
|
||||
raise ValueError(f"{row['키']} 요소 자리 수가 호표와 다름")
|
||||
for i in sorted(change["요소"], reverse=True):
|
||||
at = spots[i]
|
||||
_, end = _DEC.raw_decode(text, at)
|
||||
text = text[:at] + json.dumps(change["요소"][i], ensure_ascii=False) + text[end:]
|
||||
gone = change["걷음"]
|
||||
if gone:
|
||||
m = re.search(r'"입력"\s*:\s*\[', text)
|
||||
spans = _items(text, m.end())
|
||||
keep = [text[s:e] for s, e in spans if json.loads(text[s:e]).get("이름") not in gone]
|
||||
lead, close = text[m.end() : spans[0][0]], _skip(text, spans[-1][1])
|
||||
tail = text[spans[-1][1] : close]
|
||||
body = lead + ("," + lead).join(keep) + tail if keep else ""
|
||||
text = text[: m.end()] + body + text[close:]
|
||||
text = re.sub(r'"(?:[^"\\]|\\.)*"', lambda s: _strip(s.group(0), gone), text)
|
||||
return text
|
||||
|
||||
|
||||
def patch(text: str, changes: dict) -> str:
|
||||
"""파일 글 — 바뀐 로직 줄만 손봄."""
|
||||
m = re.search(r'"줄"\s*:\s*\[', text)
|
||||
spans = _items(text, m.end())
|
||||
parts, at = [], 0
|
||||
for s, e in spans:
|
||||
row = json.loads(text[s:e])
|
||||
if row["키"] in changes:
|
||||
parts += [text[at:s], _patch_row(text[s:e], row, changes[row["키"]])]
|
||||
at = e
|
||||
return "".join(parts) + text[at:]
|
||||
|
||||
|
||||
def main(write: bool) -> int:
|
||||
files = cm.load()
|
||||
master = mf.Master(files)
|
||||
changes, misses = plan(master, files)
|
||||
lines = sum(len(c["요소"]) for rows in changes.values() for c in rows.values())
|
||||
inputs = sum(len(c["걷음"]) for rows in changes.values() for c in rows.values())
|
||||
for name, rows in changes.items():
|
||||
path = MASTER / name
|
||||
text = path.read_text(encoding="utf-8")
|
||||
new_text = patch(text, rows)
|
||||
want = json.loads(text)
|
||||
want["줄"] = [apply(r, rows[r["키"]]) if r["키"] in rows else r for r in want["줄"]]
|
||||
if json.loads(new_text) != want:
|
||||
raise SystemExit(f"{name} 글 갈음이 바꿈과 다름 — 안 씀")
|
||||
if write:
|
||||
path.write_text(new_text, encoding="utf-8", newline="\n")
|
||||
print(
|
||||
f"검색어로 바꾼 재료 줄 {lines} · 걷은 재료 입력 {inputs} · "
|
||||
f"로직 {sum(map(len, changes.values()))} · 파일 {len(changes)}"
|
||||
+ ("" if write else " (마른 돌리기)")
|
||||
)
|
||||
for key, i, name, elem, cases in misses:
|
||||
wants = sorted({str(w) for _, w in cases})
|
||||
print(f" 못 맞춤 {key} 호표[{i}] {name} {json.dumps(elem, ensure_ascii=False)} → {wants}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
sys.exit(main("--쓰기" in sys.argv))
|
||||
@@ -1,120 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""재료_자재품목.json 다섯 값 칸이 모두 빈 줄 가운데 로직이 실제로 가리키는 줄 — 읽기 전용 분석.
|
||||
|
||||
· 「빈 줄」 = 조달청·물가자료·유통물가·물가정보·거래가격·일반가격 여섯 칸이 모두 없음
|
||||
· 「로직이 가리킴」 = 로직 호표 요소가 그 키를 바로 적음 · 재료 고르기 조건(구분·상세구분·규격)의
|
||||
후보 줄 · 대표 줄로 콕 집음 · 품셈재료 연결(문자열 키 · 지역 조건)을 따라간 줄
|
||||
· 지역 조건(모래·자갈 등)은 실제 프로젝트 자재지역을 모르므로 지역을 안 가리고 이름·단위만 맞춤
|
||||
(후보를 넓게 잡아 「안 쓰임」 판정이 헛짚지 않게)
|
||||
· 값은 채우지 않음 · 마스터 파일을 고치지 않음
|
||||
|
||||
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/check_값없는줄.py
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
MASTER = HERE.parent
|
||||
sys.path.insert(0, str(HERE))
|
||||
|
||||
import check_master as cm # noqa: E402
|
||||
import master_material as mm # noqa: E402
|
||||
|
||||
PRICE = (*mm.SLOTS, mm.GOVT)
|
||||
|
||||
# 두 ref 표의 키 목록 — 로직이 지금도 부르는지 다시 잣대질할 때 씀 (`_관리자값_미확보.md`·`_없는_재료.md`)
|
||||
ADMIN_KEYS = (
|
||||
"MP000253 MP000290 MP000293 MP000048 MP000094 MP000216 MP000299 MP000359 "
|
||||
"MP000023 MP000052 MP000055 MP000060 MP000065 MP000066 MP000070 MP000076 MP000082 "
|
||||
"MP000095 MP000113 MP000129 MP000134 MP000144 MP000150 MP000169 MP000172 MP000176 "
|
||||
"MP000177 MP000201 MP000202 MP000209 MP000211 MP000215 MP000218 MP000235 MP000239 "
|
||||
"MP000241 MP000242 MP000250 MP000269 MP000294 MP000310 MP000314 MP000319 MP000357 "
|
||||
"MP000363"
|
||||
).split()
|
||||
NO_ITEM_KEYS = (
|
||||
"MP000012 MP000038 MP000048 MP000052 MP000055 MP000056 MP000057 MP000060 "
|
||||
"MP000065 MP000070 MP000076 MP000077 MP000078 MP000082 MP000095 MP000096 MP000101 "
|
||||
"MP000113 MP000129 MP000134 MP000139 MP000144 MP000148 MP000150 MP000169 MP000172 "
|
||||
"MP000176 MP000177 MP000201 MP000209 MP000210 MP000211 MP000212 MP000213 MP000214 "
|
||||
"MP000216 MP000218 MP000220 MP000221 MP000223 MP000235 MP000239 MP000240 MP000241 "
|
||||
"MP000242 MP000250 MP000253 MP000254 MP000255 MP000257 MP000258 MP000259 MP000260 "
|
||||
"MP000261 MP000262 MP000265 MP000269 MP000271 MP000272 MP000273 MP000274 MP000275 "
|
||||
"MP000276 MP000280 MP000281 MP000285 MP000286 MP000287 MP000288 MP000290 MP000293 "
|
||||
"MP000294 MP000295 MP000296 MP000297 MP000298 MP000299 MP000301 MP000302 MP000303 "
|
||||
"MP000304 MP000305 MP000306 MP000308 MP000309 MP000310 MP000314 MP000315 MP000319 "
|
||||
"MP000325 MP000326 MP000327 MP000328 MP000330 MP000334 MP000335 MP000336 MP000337 "
|
||||
"MP000338 MP000340 MP000341 MP000342 MP000343 MP000344 MP000345 MP000349 MP000351 "
|
||||
"MP000352 MP000353 MP000359 MP000363"
|
||||
).split()
|
||||
|
||||
|
||||
def all_empty(master) -> set[str]:
|
||||
"""MT 다섯 값 칸이 모두 빈 키."""
|
||||
return {
|
||||
key for key, row in master.index.get(mm.MARKET, {}).items() if not mm._offers(master, key)
|
||||
}
|
||||
|
||||
|
||||
def region_reach(master, name, unit) -> set[str]:
|
||||
"""MP 연결이 지역 조건(모래·자갈 등)일 때 이름 뿌리·단위만으로 넓게 잡은 후보."""
|
||||
want, need = mm.plain(name), (mm.plain_unit(unit) if unit else "")
|
||||
return {
|
||||
key
|
||||
for root, _, _, u, key in mm._market_index(master)
|
||||
if root.endswith(want) and (not need or u == need)
|
||||
}
|
||||
|
||||
|
||||
def reached(master) -> tuple[set[str], set[str]]:
|
||||
"""(로직이 가리키는 MT 키, 로직이 지금도 문자열로 부르는 MP 키)."""
|
||||
mt_hit: set[str] = set()
|
||||
mp_hit: set[str] = set()
|
||||
for path in sorted(MASTER.glob("로직_*.json")):
|
||||
rows = json.loads(path.read_text(encoding="utf-8")).get("줄", [])
|
||||
for row in rows:
|
||||
for h in row.get("호표") or []:
|
||||
e, unit = h.get("요소"), h.get("단위")
|
||||
if isinstance(e, str) and e[:2] == mm.MARKET:
|
||||
mt_hit.add(e)
|
||||
elif isinstance(e, dict) and "구분" in e:
|
||||
mt_hit.update(mm.candidates(master, e, None, unit))
|
||||
if e.get("대표"):
|
||||
mt_hit.add(str(e["대표"]))
|
||||
elif isinstance(e, str) and e[:2] == mm.LINKED:
|
||||
mp_hit.add(e)
|
||||
link = master.index.get(mm.LINKED, {}).get(e, {}).get("연결")
|
||||
if isinstance(link, str) and link[:2] == mm.MARKET:
|
||||
mt_hit.add(link)
|
||||
elif isinstance(link, dict) and "계약종별" not in link:
|
||||
mrow = master.index[mm.LINKED][e]
|
||||
mt_hit.update(region_reach(master, link.get("이름"), mrow.get("단위")))
|
||||
return mt_hit, mp_hit
|
||||
|
||||
|
||||
def main() -> int:
|
||||
master = cm.master()
|
||||
empty = all_empty(master)
|
||||
mt_hit, mp_hit = reached(master)
|
||||
gap = sorted(empty & mt_hit)
|
||||
print(f"MT 줄 {len(master.index.get(mm.MARKET, {}))}")
|
||||
print(f"다섯 칸 모두 빈 줄 {len(empty)} · 그 가운데 로직이 가리키는 줄 {len(gap)}")
|
||||
for key in gap:
|
||||
row = master.get(key)
|
||||
print(f" {key} {row.get('이름')} ({row.get('구분')}·{row.get('상세구분')})")
|
||||
print(f"\n로직이 지금도 MP 키를 문자열로 부르는 곳 {len(mp_hit)}")
|
||||
for title, keys in (
|
||||
("_관리자값_미확보.md 45종", ADMIN_KEYS),
|
||||
("_없는_재료.md 111줄", NO_ITEM_KEYS),
|
||||
):
|
||||
unused = [k for k in keys if k not in mp_hit]
|
||||
print(f"{title} 가운데 로직이 이제 안 씀 {len(unused)} — {unused}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.stdout.reconfigure(encoding="utf-8")
|
||||
sys.exit(main())
|
||||
@@ -1,649 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""옛 M01 로직 줄 → 수식 문서 변환 (PLAN 802-2 · 요구서_664 1 장 3 · 꼴 `_수식문서_틀.md`).
|
||||
|
||||
빌더 `build_수식문서_802_2.py` 가 부름 · 다시 돌리면 같은 결과.
|
||||
- 기호 = 800-1 · 800-5 기호(수식 탭이 보이는 것
|
||||
· `master_equation.export` + `master_equation_sign.settle`) ·
|
||||
못 내보내는 로직은 같은 규칙(`master_symbol`)으로 · 한 문서 안 겹침 = 아래첨자 끝 숫자.
|
||||
- 입력 = 선택(고르기) · 입력 · 값 = 기본 옵션(`master_equation.given_of`) · 중간 = 식 줄
|
||||
· 한 마디 중간
|
||||
(표 찾기 · 요소 · 로직 부름 하나) = 그 기호에 바로 연결 · 표 찾기 · 요소
|
||||
· 로직 부름 = 기호 + 연결.
|
||||
- 호표 = 금액 줄(수량 × 단가 · 단가 = 요소 · 재료 고르기 · 단가산출 묶음)
|
||||
· 덧줄 = 금액 줄(단가 = 식) ·
|
||||
`줄.'이름'` · 앞 덧줄 이름 = 그 금액 줄 기호 · 끝수 결과 · 표시 = 식 안 반올림
|
||||
· 금액 끝수 = 문서 `끝수`.
|
||||
- 변수 단위 = 끝에 `master_doc_unit.fill`(845-1 · 빈 단위를 원본 · 식 셈 · 금액 줄 역산으로)
|
||||
· 앞뒤 `master_doc_unit_rule`(847-2 · 일당 /일 · 기계 기준 글 · 금액 줄 표기).
|
||||
옛 엔진 셈은 안 함(기호 · 이름 보기만 export 를 씀).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from decimal import Decimal
|
||||
|
||||
import master_doc as md
|
||||
import master_doc_unit as mdu
|
||||
import master_doc_unit_rule as mdr
|
||||
import master_equation as meq
|
||||
import master_equation_edit as mee
|
||||
import master_equation_sign as mes
|
||||
import master_formula as mf
|
||||
import master_material as mm
|
||||
import master_symbol as msym
|
||||
|
||||
_ERR = (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError, IndexError)
|
||||
SUBMAX = msym.SUBMAX
|
||||
|
||||
|
||||
def _harvest(master, key: str) -> dict:
|
||||
"""수식 탭 내보내기 기호 — (꼴, 갈래, 식 | 열쇠) → 마디 · 못 내보내면 빈 것."""
|
||||
try:
|
||||
ex = mes.settle(meq.export(master, key))
|
||||
except _ERR:
|
||||
return {}
|
||||
out: dict = {}
|
||||
|
||||
def visit(t):
|
||||
if isinstance(t, list):
|
||||
for x in t:
|
||||
visit(x)
|
||||
elif isinstance(t, dict):
|
||||
if t.get("꼴") in ("변수", "블록"):
|
||||
out.setdefault((t["꼴"], t.get("갈래"), str(t.get("식") or t.get("열쇠"))), t)
|
||||
for k, v in t.items():
|
||||
if k != "나무" and isinstance(v, (dict, list)):
|
||||
visit(v)
|
||||
|
||||
for line in ex.get("줄") or []:
|
||||
visit(line.get("이름식"))
|
||||
if isinstance(line.get("결과"), dict):
|
||||
head = line["결과"]
|
||||
out.setdefault(("머리", line.get("갈래"), str(head.get("열쇠"))), head)
|
||||
return out
|
||||
|
||||
|
||||
_CODE = re.compile(r"^(?:EQ|MT|LB)\d")
|
||||
|
||||
|
||||
def res_low(master, link: dict, low: str) -> str:
|
||||
"""요소 키가 아래첨자로 샌 것(`k_EQ0006` · 804-7 · 요구 687-18) → 자원 이름 끝 낱말(`k_하베스터`) ·
|
||||
괄호 · 쉼표 뒤 · 숫자로 시작하는 규격 낱말 뺌 · 겹침은 부른 쪽이 2 · 3."""
|
||||
if not _CODE.match(low or "") or (link or {}).get("갈래") != "요소":
|
||||
return low
|
||||
try:
|
||||
row = master.get(str(link.get("키") or ""))
|
||||
except _ERR:
|
||||
return low
|
||||
name = re.sub(r"\(.*?\)", "", str(row.get("이름") or "")).split(",")[0]
|
||||
words = [w for w in name.split() if not w[:1].isdigit()]
|
||||
got = msym.short(words[-1]) if words else ""
|
||||
return got if got and got != "·" else low
|
||||
|
||||
|
||||
def _clean(text: str) -> str:
|
||||
"""기호 · 첨자 글 다듬기 — 낱말 아닌 글 뺌."""
|
||||
return re.sub(r"[^\w′'·]|_", "", str(text or ""))
|
||||
|
||||
|
||||
class _Reg:
|
||||
"""기호 자리 — 열쇠마다 (기호, 아래, 위) 제안 → 겹침 없는 이름."""
|
||||
|
||||
def __init__(self):
|
||||
self.props: dict[tuple, tuple[str, str, str]] = {}
|
||||
self.ids: dict[tuple, str] = {}
|
||||
self.used: set[str] = set()
|
||||
self.notes: list[str] = []
|
||||
|
||||
def want(self, key: tuple, parts: tuple[str, str, str]) -> None:
|
||||
self.props.setdefault(key, parts)
|
||||
|
||||
def settle(self) -> None:
|
||||
for key, (sign, low, up) in self.props.items():
|
||||
if key in self.ids:
|
||||
continue
|
||||
if not md.good_id(md.sym_id(sign, "", "")):
|
||||
fixed = _clean(sign)
|
||||
fixed = fixed if fixed and md.good_id(fixed) else "X"
|
||||
self.notes.append(f"기호 「{sign}」 → 「{fixed}」")
|
||||
sign = fixed
|
||||
n, base = 1, low
|
||||
while md.sym_id(sign, low, up) in self.used or not md.good_id(md.sym_id(sign, low, up)):
|
||||
n += 1
|
||||
low = (base or "")[: SUBMAX - len(str(n))] + str(n)
|
||||
if n > 99:
|
||||
raise ValueError(f"기호 못 가름 {key}")
|
||||
self.used.add(md.sym_id(sign, low, up))
|
||||
self.ids[key] = md.sym_id(sign, low, up)
|
||||
|
||||
def id(self, key: tuple) -> str:
|
||||
return self.ids.get(key, "?")
|
||||
|
||||
|
||||
class _Conv:
|
||||
def __init__(self, master, row: dict, given: dict):
|
||||
self.master, self.row, self.given = master, row, given
|
||||
self.key = str(row["키"])
|
||||
self.found = _harvest(master, self.key)
|
||||
self.table = {v["열쇠"]: v for v in meq.table(row, master)}
|
||||
self.reg = _Reg()
|
||||
self.links: dict[tuple, dict] = {} # 열쇠 → 변수 칸(이름 · 단위 · 연결)
|
||||
self.order: list[tuple] = []
|
||||
self.alias: dict[str, tuple] = {} # 한 마디 중간 식 → ('중간', 이름)
|
||||
self.names = {s["이름"] for s in row.get("입력") or []} | {
|
||||
s["이름"] for s in row.get("중간") or []
|
||||
}
|
||||
self.kinds = {s["이름"]: "입력" for s in row.get("입력") or []}
|
||||
self.kinds |= {s["이름"]: "중간" for s in row.get("중간") or []}
|
||||
self.notes: list[str] = []
|
||||
self.used_lines: set[tuple] = set() # 식이 부른 금액 줄 — ('합' | '덧', 이름)
|
||||
self.quiet = "" # 한 마디 중간 연결만 뜰 때(그 마디 식) — 기호 자리 안 잡음
|
||||
self.last: dict = {}
|
||||
|
||||
# 기호 제안
|
||||
def _look(self, kind: str, raw: str) -> dict | None:
|
||||
for k in (("변수", kind, raw), ("블록", None, raw), ("변수", "요소", raw)):
|
||||
if k in self.found:
|
||||
return self.found[k]
|
||||
return None
|
||||
|
||||
def _var(self, key: tuple, family: str, raw: str, name: str, link: dict, unit: str = "") -> str:
|
||||
if self.quiet and self.quiet == raw:
|
||||
self.quiet, self.last = "", link
|
||||
return "?"
|
||||
if key not in self.links:
|
||||
node = self._look(family, raw) or {}
|
||||
sign = str(node.get("기호") or "")
|
||||
if sign and node.get("기호") != node.get("열쇠"):
|
||||
parts = _merge(sign, str(node.get("아래") or ""), str(node.get("위") or ""))
|
||||
else:
|
||||
fam = {"블록": "결과"}.get(family, family)
|
||||
parts = msym.lookup(name or raw, fam if fam in msym.FAMILY else "요소")
|
||||
parts = (parts[0], res_low(self.master, link, parts[1]), parts[2])
|
||||
self.reg.want(key, parts)
|
||||
self.order.append(key)
|
||||
label = str(node.get("이름") or name or raw)
|
||||
self.links[key] = {
|
||||
"이름": label,
|
||||
"단위": str(node.get("단위") or unit or ""),
|
||||
"연결": link,
|
||||
}
|
||||
self.links[key]["연결"] = link # 두 번째 돌이 = 겹침 가른 이름으로 쓴 연결
|
||||
return self.reg.id(key)
|
||||
|
||||
def own(self, name: str) -> str:
|
||||
"""입력 · 중간 이름 → 기호."""
|
||||
if name not in self.names:
|
||||
self.notes.append(f"모르는 이름 「{name}」")
|
||||
return name if md.good_id(name) else "X_" + _clean(name)
|
||||
return self.reg.id((self.kinds[name], name))
|
||||
|
||||
def holes(self, text):
|
||||
if not isinstance(text, str):
|
||||
return text
|
||||
return md.HOLE.sub(lambda m: "{" + self.own(m.group(1)) + "}", text)
|
||||
|
||||
def _place(self) -> dict:
|
||||
out = {}
|
||||
if mm.REGION in self.kinds:
|
||||
out["지역"] = self.own(mm.REGION)
|
||||
if mm.TARIFF in self.kinds:
|
||||
out["계약종별"] = self.own(mm.TARIFF)
|
||||
return out
|
||||
|
||||
# 식
|
||||
def emit(self, node, money: dict | None = None):
|
||||
kind = node[0]
|
||||
if kind in ("num", "str"):
|
||||
return node
|
||||
if kind == "name":
|
||||
name = node[1]
|
||||
if money is not None and name in md.COSTS:
|
||||
return ("var", name)
|
||||
if money is not None and name in money:
|
||||
self.used_lines.add(money[name])
|
||||
return ("var", self.reg.id(money[name]))
|
||||
return ("var", self.own(name))
|
||||
if kind == "ref":
|
||||
return ("var", self.element(node[1]))
|
||||
if kind == "neg":
|
||||
return ("neg", self.emit(node[1], money))
|
||||
if kind == "bin":
|
||||
return ("bin", node[1], self.emit(node[2], money), self.emit(node[3], money))
|
||||
if kind == "call":
|
||||
return ("call", node[1], [self.emit(x, money) for x in node[2]])
|
||||
if kind == "find":
|
||||
return ("var", self.find(node, None))
|
||||
if kind == "logic":
|
||||
return ("var", self.block(node, None))
|
||||
base, col = node[1], node[2]
|
||||
if base[0] == "find":
|
||||
return ("var", self.find(base, col))
|
||||
if base[0] == "logic":
|
||||
return ("var", self.block(base, col))
|
||||
if base[0] == "ref":
|
||||
return ("var", self.element(base[1], col))
|
||||
if base[0] == "name" and base[1] == "줄" and money is not None:
|
||||
self.used_lines.add(("합", col))
|
||||
return ("var", self.reg.id(("합", col)))
|
||||
if base[0] == "field" and base[1][0] == "name" and base[1][1] in ("번지", "단계"):
|
||||
return ("field", ("field", ("var", base[1][1]), base[2]), col)
|
||||
return ("field", self.emit(base, money), col)
|
||||
|
||||
def text(self, raw, money: dict | None = None) -> str:
|
||||
return md.text_of(self.emit(mf.parse(raw), money))
|
||||
|
||||
# 연결 마디
|
||||
def find(self, node, col) -> str:
|
||||
raw = mee.raw_text(node if col is None else ("field", node, col))
|
||||
if raw in self.alias:
|
||||
return self.reg.id(self.alias[raw])
|
||||
link = {"갈래": "표", "표": self.holes(node[1])}
|
||||
link["조건"] = {k: md.text_of(self.emit(v)) for k, v in node[2]}
|
||||
if col is None:
|
||||
self.notes.append(f"칸 없는 찾기 「{raw}」")
|
||||
else:
|
||||
link["칸"] = col
|
||||
return self._var(("찾기", raw), "찾기", raw, col or raw, link)
|
||||
|
||||
def block(self, node, col) -> str:
|
||||
raw = mee.raw_text(node if col is None else ("field", node, col))
|
||||
if raw in self.alias:
|
||||
return self.reg.id(self.alias[raw])
|
||||
link = {"갈래": "단가산출", "키": self.holes(node[1])}
|
||||
link["입력"] = {k: md.text_of(self.emit(v)) for k, v in node[2]}
|
||||
if col is not None:
|
||||
link["칸"] = col
|
||||
try:
|
||||
sub = self.master.logic(mf.fill(node[1], {})) if "{" not in node[1] else {}
|
||||
except _ERR:
|
||||
sub = {}
|
||||
unit = str(sub.get("결과단위") or "")
|
||||
return self._var(("블록", raw), "블록", raw, str(sub.get("이름") or node[1]), link, unit)
|
||||
|
||||
def element(self, ref: str, col: str | None = None, unit: str | None = None) -> str:
|
||||
raw = ref if col is None else mee.raw_text(("field", ("ref", ref), col))
|
||||
if raw in self.alias and unit is None:
|
||||
return self.reg.id(self.alias[raw])
|
||||
link = {"갈래": "요소", "키": self.holes(ref)}
|
||||
if col is not None:
|
||||
link["칸"] = col
|
||||
if unit is not None:
|
||||
link["단위"] = unit
|
||||
link |= self._place()
|
||||
try:
|
||||
label = self.master.label(ref) if "{" not in ref else ref
|
||||
except _ERR:
|
||||
label = ref
|
||||
return self._var(("요소", raw, unit), "요소", raw, label, link)
|
||||
|
||||
def material(self, at: int, item: dict) -> str:
|
||||
cond = {k: self.holes(v) for k, v in item["요소"].items()}
|
||||
link = {"갈래": "요소", "재료": cond, "단위": item.get("단위") or ""} | self._place()
|
||||
name = str(item.get("이름") or "")
|
||||
return self._var(("재료", at), "요소", f"단가:{name}", f"{name}단가", link)
|
||||
|
||||
def lone(self, raw: str):
|
||||
"""한 마디 식(표 찾기 · 요소 · 로직 부름 하나) — 마디 · 아니면 None."""
|
||||
try:
|
||||
node = mf.parse(raw)
|
||||
except mf.FormulaError:
|
||||
return None
|
||||
if node[0] in ("ref", "logic"):
|
||||
return node
|
||||
if node[0] == "field" and node[1][0] in ("find", "logic", "ref"):
|
||||
return node
|
||||
return None
|
||||
|
||||
|
||||
def _merge(sign: str, low: str, up: str) -> tuple[str, str, str]:
|
||||
"""기호 칸에 첨자까지 든 것(「t_1」 · 「C_m」)을 가름."""
|
||||
if "_" in sign or "^" in sign:
|
||||
head, low0, up0 = md.split_id(sign)
|
||||
if head != sign:
|
||||
return head, low0 + low, up or up0
|
||||
return sign, low, up
|
||||
|
||||
|
||||
def _parts(var: dict) -> tuple[str, str, str]:
|
||||
return _merge(
|
||||
str(var.get("기호") or var["열쇠"]), str(var.get("아래") or ""), str(var.get("위") or "")
|
||||
)
|
||||
|
||||
|
||||
def _line_parts(c: _Conv, name: str) -> tuple[str, str, str]:
|
||||
head = c.found.get(("머리", "호표", name)) or c.found.get(("머리", "덧줄", name)) or {}
|
||||
if head.get("기호") and head.get("기호") != name:
|
||||
return str(head["기호"]), str(head.get("아래") or ""), str(head.get("위") or "")
|
||||
return msym.lookup(name, "합")
|
||||
|
||||
|
||||
def convert(master, row: dict, given: dict | None = None) -> tuple[dict, list[str]]:
|
||||
"""로직 줄 → (수식 문서, 알림). given = 기본 옵션(없으면 `given_of`)."""
|
||||
given = meq.given_of(master, row) if given is None else given
|
||||
c = _Conv(master, row, given)
|
||||
for spec in row.get("입력") or []:
|
||||
c.reg.want(
|
||||
("입력", spec["이름"]), _parts(c.table.get(spec["이름"], {"열쇠": spec["이름"]}))
|
||||
)
|
||||
for step in row.get("중간") or []:
|
||||
c.reg.want(
|
||||
("중간", step["이름"]), _parts(c.table.get(step["이름"], {"열쇠": step["이름"]}))
|
||||
)
|
||||
for item in row.get("호표") or []:
|
||||
c.reg.want(("합", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or "")))
|
||||
for item in row.get("덧줄") or []:
|
||||
c.reg.want(("덧", str(item.get("이름") or "")), _line_parts(c, str(item.get("이름") or "")))
|
||||
lone_steps = {}
|
||||
for step in row.get("중간") or []:
|
||||
node = c.lone(step["식"])
|
||||
if node is not None and step.get("표시") is None:
|
||||
raw = mee.raw_text(node)
|
||||
if raw not in c.alias:
|
||||
c.alias[raw] = ("중간", step["이름"])
|
||||
lone_steps[step["이름"]] = node
|
||||
doc = None
|
||||
for _ in range(2): # 한 번 = 기호 모음 · 두 번 = 겹침 가른 이름으로 글
|
||||
c.reg.settle()
|
||||
doc = _build(c, row, given, lone_steps)
|
||||
c.notes += c.reg.notes
|
||||
doc = slim_doc(doc)
|
||||
if hasattr(master, "numbers"): # 빌더 · 실행 중 변환 한 벌 — 변수 단위 채움(845-1)
|
||||
mdr.before(doc, master) # 847-2 일당 /일 · 기계 기준 글
|
||||
mdu.fill(doc, master)
|
||||
mdr.after(doc) # 847-2 금액 줄 kg · L 표기
|
||||
return doc, sorted(set(c.notes))
|
||||
|
||||
|
||||
def _is(node, value) -> bool:
|
||||
return node[0] == "num" and node[1] == value
|
||||
|
||||
|
||||
def slim(node):
|
||||
"""옮김 군더더기 걷기(802-3) — `+ 0` · `- 0` · `× 1` · `÷ 1` 지움 · `A × k ÷ 100` → `A × k%`(값 같음)."""
|
||||
kind = node[0]
|
||||
if kind == "bin":
|
||||
op, a, b = node[1], node[2], node[3]
|
||||
if op == "/" and _is(b, 100) and a[0] == "bin" and a[1] == "*" and a[3][0] == "num":
|
||||
return ("bin", "*", slim(a[2]), ("pct", a[3]))
|
||||
a, b = slim(a), slim(b)
|
||||
if (op in ("+", "-") and _is(b, 0)) or (op in ("*", "/") and _is(b, 1)):
|
||||
return a
|
||||
if (op == "+" and _is(a, 0)) or (op == "*" and _is(a, 1)):
|
||||
return b
|
||||
return ("bin", op, a, b)
|
||||
if kind in ("neg", "pct"):
|
||||
return (kind, slim(node[1]))
|
||||
if kind == "field":
|
||||
return ("field", slim(node[1]), node[2])
|
||||
if kind == "call":
|
||||
return ("call", node[1], [slim(x) for x in node[2]])
|
||||
return node
|
||||
|
||||
|
||||
def _slim_text(text):
|
||||
if not isinstance(text, str) or not text.strip():
|
||||
return text
|
||||
try:
|
||||
return md.text_of(slim(md.parse(text)))
|
||||
except md.DocError:
|
||||
return text
|
||||
|
||||
|
||||
def slim_doc(doc: dict) -> dict:
|
||||
"""식 줄 · 금액 줄(수량 · 단가) 글에 `slim`."""
|
||||
for line in doc.get("식") or []:
|
||||
line["식"] = _slim_text(line.get("식"))
|
||||
for line in doc.get("금액") or []:
|
||||
for k in ("수량", "단가"):
|
||||
if k in line:
|
||||
line[k] = _slim_text(line[k])
|
||||
return doc
|
||||
|
||||
|
||||
def _link_of(c: _Conv, node) -> dict:
|
||||
"""한 마디 중간의 연결 — 찾기 · 요소 · 로직 부름."""
|
||||
alias = dict(c.alias)
|
||||
c.alias, c.quiet, c.last = {}, mee.raw_text(node), {}
|
||||
try:
|
||||
c.emit(node)
|
||||
return dict(c.last)
|
||||
finally:
|
||||
c.alias, c.quiet = alias, ""
|
||||
|
||||
|
||||
def _build(c: _Conv, row: dict, given: dict, lone_steps: dict) -> dict:
|
||||
variables: list[dict] = []
|
||||
for spec in row.get("입력") or []:
|
||||
name = spec["이름"]
|
||||
look = c.table.get(name, {})
|
||||
value = given.get(name)
|
||||
if isinstance(value, (int, float)) and not isinstance(value, bool):
|
||||
value = Decimal(str(value))
|
||||
if "고르기" in spec:
|
||||
link = {"갈래": "선택", "목록": list(spec["고르기"]), "값": value}
|
||||
else:
|
||||
link = {"갈래": "입력", "값": value}
|
||||
if spec.get("범위"):
|
||||
link["범위"] = list(spec["범위"])
|
||||
variables.append(_var_row(c.reg.id(("입력", name)), name, look, spec, link))
|
||||
lines: list[dict] = []
|
||||
for step in row.get("중간") or []:
|
||||
name = step["이름"]
|
||||
look = c.table.get(name, {})
|
||||
me = c.reg.id(("중간", name))
|
||||
if name in lone_steps:
|
||||
variables.append(_var_row(me, name, look, step, _link_of(c, lone_steps[name])))
|
||||
continue
|
||||
try:
|
||||
text = c.text(step["식"])
|
||||
except mf.FormulaError as e:
|
||||
c.notes.append(f"중간 「{name}」 식 못 읽음 — {e}")
|
||||
text = str(step["식"])
|
||||
if step.get("표시") is not None:
|
||||
text = f"반올림({text}, {int(step['표시'])})"
|
||||
variables.append(_var_row(me, name, look, step, {"갈래": "식"}))
|
||||
lines.append({"기호": me, "식": text})
|
||||
doc = {
|
||||
"꼴": "수식문서",
|
||||
"판": 1,
|
||||
"키": c.key,
|
||||
"이름": row.get("이름") or "",
|
||||
"결과단위": row.get("결과단위") or "",
|
||||
"출처": row.get("출처") or "",
|
||||
**({"부품": row["부품"]} if row.get("부품") else {}), # 813-2 부품 표지
|
||||
}
|
||||
money: list[dict] = []
|
||||
if "결과" in row:
|
||||
head = c.found.get(("머리", "결과", "결과")) or {}
|
||||
sign = head.get("기호") if msym.is_symbol(str(head.get("기호") or "")) else ""
|
||||
parts = (sign, str(head.get("아래") or ""), str(head.get("위") or "")) if sign else None
|
||||
parts = parts or msym.rule(str(row.get("결과단위") or ""), "결과")[:3]
|
||||
c.reg.want(("결과", "결과"), parts)
|
||||
text = c.text(row["결과"]["식"])
|
||||
rule = row.get("끝수")
|
||||
if isinstance(rule, dict) and rule.get("대상") == "결과":
|
||||
text = f"{rule['방법']}({text}, {int(rule.get('자리') or 0)})"
|
||||
me = c.reg.id(("결과", "결과"))
|
||||
variables.append(
|
||||
{
|
||||
"열쇠": "결과",
|
||||
**_split(me),
|
||||
"이름": "결과",
|
||||
"단위": row.get("결과단위") or "",
|
||||
"연결": {"갈래": "식"},
|
||||
}
|
||||
)
|
||||
lines.append({"기호": me, "식": text})
|
||||
doc["결과"] = me
|
||||
else:
|
||||
money = _money(c, row)
|
||||
for key in c.order:
|
||||
if key[0] in ("입력", "중간") or key in [("결과", "결과")]:
|
||||
continue
|
||||
if any(alias == key for alias in c.alias.values()):
|
||||
continue
|
||||
one = c.links[key]
|
||||
me = c.reg.id(key)
|
||||
variables.append(
|
||||
{
|
||||
"열쇠": me,
|
||||
**_split(me),
|
||||
"이름": one["이름"],
|
||||
"단위": one["단위"],
|
||||
"연결": one["연결"],
|
||||
}
|
||||
)
|
||||
doc |= {"변수": variables, "식": lines, "금액": money}
|
||||
cut = {k: (dict(v) if isinstance(v, dict) else v) for k, v in md.CUT.items()}
|
||||
rule = row.get("끝수")
|
||||
if isinstance(rule, dict) and rule.get("대상") == "계":
|
||||
cut["계"] = {"방법": rule["방법"], "자리": int(rule.get("자리") or 0)}
|
||||
if row.get("끝전"):
|
||||
cut["끝전"] = row["끝전"]
|
||||
doc["끝수"] = cut
|
||||
for k in ("단계", "조정"):
|
||||
if row.get(k):
|
||||
doc[k] = row[k]
|
||||
return doc
|
||||
|
||||
|
||||
def _split(me: str) -> dict:
|
||||
sign, low, up = md.split_id(me)
|
||||
return {"기호": sign, "아래": low, "위": up}
|
||||
|
||||
|
||||
def _var_row(me: str, name: str, look: dict, spec: dict, link: dict) -> dict:
|
||||
out = {
|
||||
"열쇠": name,
|
||||
**_split(me),
|
||||
"이름": look.get("이름") or name,
|
||||
"단위": spec.get("단위") or "",
|
||||
}
|
||||
for k in ("설명", "출처"):
|
||||
if spec.get(k):
|
||||
out[k] = spec[k]
|
||||
out["연결"] = link
|
||||
return out
|
||||
|
||||
|
||||
def _hand(c: _Conv, at: int, item: dict) -> str:
|
||||
"""손 값 줄 — 값묶음(노 · 재 · 경) 또는 손 단가 = 숫자 연결."""
|
||||
name = str(item.get("이름") or "")
|
||||
given = item.get("값묶음")
|
||||
if given:
|
||||
if set(given) < set(md.COSTS):
|
||||
c.notes.append(f"호표 「{name}」 값묶음 일부 — 빠진 비목 0")
|
||||
value = {k: Decimal(str(given.get(k) or 0)) for k in md.COSTS}
|
||||
else:
|
||||
value = Decimal(str(item["단가"]))
|
||||
link = {"갈래": "숫자", "값": value}
|
||||
return c._var(("손", at), "요소", f"단가:{name}", f"{name}단가", link)
|
||||
|
||||
|
||||
def _group_name(items: list[dict]) -> str:
|
||||
kinds = []
|
||||
for x in items:
|
||||
k = x.get("종류") or str(x.get("이름") or "")
|
||||
if k not in kinds:
|
||||
kinds.append(k)
|
||||
return " · ".join(kinds)
|
||||
|
||||
|
||||
def _money(c: _Conv, row: dict) -> list[dict]:
|
||||
items, adds = row.get("호표") or [], row.get("덧줄") or []
|
||||
out: list[dict] = []
|
||||
for at, item in enumerate(items):
|
||||
name = str(item.get("이름") or "")
|
||||
line = {"이름": name}
|
||||
if item.get("규격"):
|
||||
line["규격"] = item["규격"]
|
||||
line["단위"] = item.get("단위") or ""
|
||||
try:
|
||||
qty = c.text(item["수량"])
|
||||
except mf.FormulaError as e:
|
||||
c.notes.append(f"호표 「{name}」 수량 못 읽음 — {e}")
|
||||
qty = str(item["수량"])
|
||||
kind = item.get("종류")
|
||||
if item.get("값묶음") or item.get("단가") is not None: # M02 손 값(값묶음 · 손 단가)
|
||||
price, line["비목"] = _hand(c, at, item), item.get("비목") or "묶음"
|
||||
if line["비목"] != "묶음" and item.get("값묶음"):
|
||||
price = f"{price}.계"
|
||||
elif kind == "로직":
|
||||
node = mf.parse(str(item["요소"]))
|
||||
price = md.text_of(c.emit(node))
|
||||
bundle = node[0] == "logic"
|
||||
if "비목" in item:
|
||||
line["비목"] = item["비목"]
|
||||
if bundle:
|
||||
price = f"{price}.계"
|
||||
else:
|
||||
line["비목"] = "묶음"
|
||||
elif isinstance(item.get("요소"), dict):
|
||||
line["비목"] = item["비목"]
|
||||
price = c.material(at, item)
|
||||
else:
|
||||
line["비목"] = item["비목"]
|
||||
ref = str(
|
||||
item["요소"]
|
||||
) # 품셈재료(MP)만 줄 단위로 값이 갈림 — 그 밖은 식 속 요소와 한 기호
|
||||
price = c.element(
|
||||
ref, None, str(item.get("단위") or "") if ref[:2] == mm.LINKED else None
|
||||
)
|
||||
line |= {"수량": qty, "단가": price}
|
||||
for k in (
|
||||
"번지",
|
||||
"합밖",
|
||||
"자리",
|
||||
"출처",
|
||||
"부착",
|
||||
): # 부착 = 같은 묶음 주 기계 줄을 따름(848-4)
|
||||
if k in item:
|
||||
line[k] = item[k]
|
||||
out.append(line)
|
||||
seen: dict[str, tuple] = {}
|
||||
for add in adds:
|
||||
name = str(add.get("이름") or "")
|
||||
try:
|
||||
price = c.text(add["식"], dict(seen))
|
||||
except mf.FormulaError as e:
|
||||
c.notes.append(f"덧줄 「{name}」 식 못 읽음 — {e}")
|
||||
price = str(add["식"])
|
||||
line = {"이름": name, "단위": "식", "비목": add["비목"], "단가": price}
|
||||
for k in ("번지", "합밖", "자리", "출처"):
|
||||
if k in add:
|
||||
line[k] = add[k]
|
||||
out.append(line)
|
||||
seen[name] = ("덧", name)
|
||||
last = {
|
||||
str(x.get("이름") or ""): i for i, x in enumerate(items)
|
||||
} # 같은 이름 = 뒤 줄(옛 `줄` 묶음)
|
||||
for i, line in enumerate(out):
|
||||
key = ("합", line["이름"]) if i < len(items) else ("덧", line["이름"])
|
||||
if key in c.used_lines and (i >= len(items) or last[line["이름"]] == i):
|
||||
line["기호"] = c.reg.id(key)
|
||||
_groups(out, [*items, *adds])
|
||||
return out
|
||||
|
||||
|
||||
def _groups(out: list[dict], items: list[dict]) -> None:
|
||||
"""묶음 — 단가산출 부름 줄마다 한 묶음 · 그 사이 다른 줄은 이어진 것끼리 · 묶음 하나면 안 둠 ·
|
||||
호표 `묶음`(848-4 · 기계 한 대 = 줄 하나) = 그 제목 · 이어진 같은 제목 부름 줄은 한 묶음."""
|
||||
runs: list[tuple[str, list[int]]] = []
|
||||
for i, item in enumerate(items):
|
||||
title = str(item.get("묶음") or "")
|
||||
if item.get("종류") == "로직" and title and runs and runs[-1][0] == title:
|
||||
runs[-1][1].append(i)
|
||||
elif item.get("종류") == "로직":
|
||||
runs.append((title or str(item.get("이름") or ""), [i]))
|
||||
elif runs and runs[-1][0] == "" and items[runs[-1][1][-1]].get("종류") != "로직":
|
||||
runs[-1][1].append(i)
|
||||
else:
|
||||
runs.append(("", [i]))
|
||||
if len(runs) < 2:
|
||||
return
|
||||
for name, members in runs:
|
||||
label = name or _group_name([items[i] for i in members])
|
||||
for i in members:
|
||||
out[i]["묶음"] = label
|
||||
@@ -1,7 +1,7 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""수식 문서 단위 채움 더함 (PLAN 847-2 · 요구 884).
|
||||
|
||||
변환(`master_doc_convert`)이 `master_doc_unit.fill` 앞뒤로 부름.
|
||||
불러오기 문서 짓기(`M02_San_ToDoc`)가 `master_doc_unit.fill` 앞뒤로 부름.
|
||||
|
||||
- `before` (채움 앞 — 식 셈이 새 단위로 셈):
|
||||
㉠ 일당 시공량 — 표 기준이 하루(「일당」 · 「1일」 · 「1대 1일당」 …)인 표의 수량 칸
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
"""산림품셈 로직 복잡도 재기 — 입력 수 · 표 찾기 수 · 로직 부르기 · 덧줄 · 재료 가짓수.
|
||||
|
||||
사용: python resources/master_data/scripts/로직_복잡도_재기.py [상위 N]
|
||||
점수 = 입력 + 찾기 + 로직부르기*2 + 덧줄 + 재료 (읽기 전용 · 아무것도 안 씀)
|
||||
"""
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
FIND = re.compile(r"찾기\(")
|
||||
CALL = re.compile(r"로직\(")
|
||||
|
||||
|
||||
def measure(row: dict) -> dict:
|
||||
ho = row.get("호표") or []
|
||||
text = " ".join(str(h.get("수량", "")) + str(h.get("요소", "")) for h in ho)
|
||||
text += " ".join(str(m.get("식", "")) for m in row.get("중간") or [])
|
||||
text += " ".join(str(m.get("식", "")) for m in row.get("덧줄") or [])
|
||||
m = {
|
||||
"입력": len(row.get("입력") or []),
|
||||
"찾기": len(FIND.findall(text)),
|
||||
"로직": len(CALL.findall(text)),
|
||||
"덧줄": len(row.get("덧줄") or []),
|
||||
"재료": sum(1 for h in ho if h.get("종류") == "재료"),
|
||||
}
|
||||
m["점수"] = m["입력"] + m["찾기"] + m["로직"] * 2 + m["덧줄"] + m["재료"]
|
||||
return m
|
||||
|
||||
|
||||
def main() -> None:
|
||||
top = int(sys.argv[1]) if len(sys.argv) > 1 else 25
|
||||
out = []
|
||||
for f in sorted(ROOT.glob("로직_산림품셈_*.json")):
|
||||
for row in json.loads(f.read_text(encoding="utf-8"))["줄"]:
|
||||
out.append(
|
||||
{"키": row["키"], "번호": row["원문번호"], "이름": row["이름"], **measure(row)}
|
||||
)
|
||||
out.sort(key=lambda r: -r["점수"])
|
||||
for r in out[:top]:
|
||||
print(
|
||||
r["키"],
|
||||
r["번호"],
|
||||
r["이름"],
|
||||
{k: r[k] for k in ("입력", "찾기", "로직", "덧줄", "재료", "점수")},
|
||||
)
|
||||
print("총", len(out))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,844 +0,0 @@
|
||||
{
|
||||
"판": "796-3",
|
||||
"줄": {
|
||||
"GC000088": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000089": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000090": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000169": {
|
||||
"t1": {"기호": "t", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"T": {"이름": "작업소요시간", "근거": "표 라벨/출처 「T(작업소요시간)」", "확신": "원문"}
|
||||
},
|
||||
"GC000176": {
|
||||
"t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"T": {"이름": "작업소요시간", "근거": "표 라벨/출처 「T(작업소요시간)」", "확신": "원문"}
|
||||
},
|
||||
"GC000178": {
|
||||
"T": {"이름": "천공시간", "근거": "표 라벨/출처 「T(천공시간)」", "확신": "원문"}
|
||||
},
|
||||
"GC000183": {
|
||||
"T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000185": {
|
||||
"t1": {"이름": "준비 및 이동시간", "기호": "t", "아래": "1", "단위": "초", "근거": "건설품셈 공통 5-2-3 「t_1 : 준비 및 이동시간(sec)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "건설품셈 공통 5-2-3 「cm : 1회 싸이클 타임(sec)」", "확신": "원문"},
|
||||
"Q": {"이름": "시간당 작업량", "단위": "m/hr", "근거": "건설품셈 공통 5-2-3 「Q : 시간당 작업량 (m/hr)」", "확신": "원문"}
|
||||
},
|
||||
"GC000187": {
|
||||
"타설길이": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 5-2-4 「L_1 : 타설길이」", "확신": "원문"}
|
||||
},
|
||||
"GC000189": {
|
||||
"t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t3": {"기호": "t", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t4": {"기호": "t", "아래": "4", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t5": {"기호": "t", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000191": {
|
||||
"T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000195": {
|
||||
"T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"T2": {"기호": "T", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000196": {
|
||||
"말뚝길이": {"기호": "L", "근거": "건설품셈 공통 5-3-5 「L : 말뚝길이(m)」", "확신": "원문"},
|
||||
"T3": {"기호": "T", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000206": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000207": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000208": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000253": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000322": {
|
||||
"W": {"이름": "빔 형식", "근거": "가드레일 판 「2W · 3W」 고르기", "확신": "추정"}
|
||||
},
|
||||
"GC000323": {
|
||||
"W": {"이름": "빔 형식", "근거": "가드레일 판 「2W · 3W」 고르기", "확신": "추정"}
|
||||
},
|
||||
"GC000422": {
|
||||
"a": {"이름": "표준고르기면적", "단위": "㎡/hr", "근거": "건설품셈 토목 7-2-5 「a : 표준고르기면적(㎡/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 토목 7-2-5 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC000510": {
|
||||
"GSD": {"이름": "지상표본거리", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000522": {
|
||||
"GSD": {"이름": "지상표본거리", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000561": {
|
||||
"K1": {"기호": "K", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC000876": {
|
||||
"SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000889": {
|
||||
"SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000891": {
|
||||
"SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000892": {
|
||||
"SCH": {"이름": "관 스케줄", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000901": {
|
||||
"보온두께": {"기호": "X", "단위": "㎜", "근거": "건설품셈 기계설비 13-3-1 「X : 보온두께(㎜)」", "확신": "원문"},
|
||||
"Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000902": {
|
||||
"Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000903": {
|
||||
"Lagging": {"이름": "래깅", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC000910": {
|
||||
"StackFillet": {"이름": "용접장(6㎜ 필렛 환산)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000911": {
|
||||
"CleanOutDoor": {"이름": "클린아웃 도어", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000912": {
|
||||
"Scaffolder": {"이름": "비계(Scaffolder) 조립설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Chain": {"이름": "체인블록 설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Tube": {"이름": "튜브패널 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Buckstay": {"이름": "버크스테이 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Tube2": {"이름": "튜브피스 조립조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Casing": {"이름": "케이싱 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Casing2": {"이름": "케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000914": {
|
||||
"drum": {"이름": "드럼 굴림운반", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"hanger": {"이름": "행거 · 서포트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Chain": {"이름": "체인블록 설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"drum2": {"이름": "드럼 위치조정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"drum3": {"이름": "드럼 내부품 조양 · 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000916": {
|
||||
"DUCT": {"이름": "덕트 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"DUCT2": {"이름": "덕트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000917": {
|
||||
"casing": {"이름": "케이싱 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Heating": {"이름": "히팅엘리먼트 삽입", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Sealing": {"이름": "시일플레이트 · 패킹링 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000918": {
|
||||
"Rotary": {"이름": "로터리 수트블로워 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Retractable": {"이름": "리트랙터블 수트블로워 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000920": {
|
||||
"Foundation": {"이름": "기초 치핑", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Foundation2": {"이름": "기초 마킹", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Sole": {"이름": "솔플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Grouting": {"이름": "그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Lower": {"이름": "하부 외부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Lower2": {"이름": "하부 내부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Rotor": {"이름": "로터 표면손질", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Nozzle": {"이름": "노즐플레이트 표면손질", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Nozzle2": {"이름": "노즐플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Rotor2": {"이름": "로터 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Rotor3": {"이름": "로터 간극 측정 · 교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Upper": {"이름": "상부 내부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Upper2": {"이름": "상부 외부케이싱 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Upper3": {"이름": "상부 케이싱 간극 측정 · 교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Bearing": {"이름": "베어링 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Turining": {"이름": "터닝기어 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Front": {"이름": "프론트 페데스탈 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Steam": {"이름": "스팀체스트 · 거버닝밸브 조립설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"coupling": {"이름": "커플링 조정 · 조립(개소)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"coupling2": {"이름": "커플링 조정 · 조립(대)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Bolt": {"이름": "볼트 비팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Foundation3": {"이름": "기초 침하 측정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000921": {
|
||||
"Foundation": {"이름": "기초 치핑", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Sole": {"이름": "솔플레이트 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Grouting": {"이름": "그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Lifting": {"이름": "리프팅장치 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Lifting2": {"이름": "리프팅장치 설치(철거)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Stator": {"이름": "고정자 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Rotor": {"이름": "회전자 삽입설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Shaft": {"이름": "축 끝단 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Coupling": {"이름": "커플링 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Exciter": {"이름": "여자기 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Hydrogen": {"이름": "수소냉각기 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000922": {
|
||||
"Foundation": {"이름": "기초 치핑 · 그라우팅", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"body": {"이름": "본체 조립설치(ton)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"body2": {"이름": "본체 조립설치(대)", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Tube": {"이름": "튜브 삽입설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000965": {
|
||||
"SCAFFOLDER": {"이름": "비계 조립설치 · 철거", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000969": {
|
||||
"Shell": {"이름": "쉘 플레이트", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Hand": {"이름": "핸드 레일", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Conveyor": {"이름": "컨베이어", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Lapping": {"이름": "래핑 디바이스", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Leveling": {"이름": "레벨 재교정", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000974": {
|
||||
"Tube": {"이름": "튜브패널 조립 · 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Buckstay": {"이름": "버크스테이 조립 · 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Sealing": {"이름": "시일 용접", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000975": {
|
||||
"Inner": {"이름": "이너플레이트 · 행거 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000976": {
|
||||
"Inner": {"이름": "이너플레이트 · 행거 조립", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"},
|
||||
"Sealing": {"이름": "시일 용접", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000983": {
|
||||
"Portable": {"이름": "이동식 벨트컨베이어 가산율", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC000990": {
|
||||
"Drift": {"이름": "드리프트 엘리미네이터 설치", "근거": "원문 표 영문 공정명 한글 표기", "확신": "추정"}
|
||||
},
|
||||
"GC001029": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001030": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001063": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001064": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001065": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001066": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001068": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001069": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001074": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001091": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001096": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001099": {
|
||||
"Type": {"이름": "유형", "근거": "직접 입력 칸 이름(원문 표 머리 영문)", "확신": "추정"}
|
||||
},
|
||||
"GC001140": {
|
||||
"운반거리": {"기호": "L", "근거": "건설품셈 공통 1-2-7 「L : 운반거리(m)」", "확신": "원문"},
|
||||
"실작업시간": {"기호": "T", "근거": "건설품셈 공통 1-2-7 「T : 1일 실작업시간(480분-30분)」", "확신": "원문"},
|
||||
"적재적하시간": {"기호": "t", "근거": "건설품셈 공통 1-2-7 「t : 적재적하 시간(분)」", "확신": "원문"},
|
||||
"평균왕복속도": {"기호": "V", "근거": "건설품셈 공통 1-2-7 「V : 평균왕복속도(m/hr)」", "확신": "원문"},
|
||||
"일운반회수": {"기호": "N", "근거": "건설품셈 공통 1-2-7 「N : 1일 운반횟수」", "확신": "원문"}
|
||||
},
|
||||
"GC001141": {
|
||||
"운반거리": {"기호": "L", "근거": "건설품셈 공통 1-2-7 「L : 운반거리(m)」", "확신": "원문"},
|
||||
"실작업시간": {"기호": "T", "근거": "건설품셈 공통 1-2-7 「T : 1일 실작업시간(480분-30분)」", "확신": "원문"},
|
||||
"왕복평균속도": {"기호": "V", "근거": "건설품셈 공통 1-2-7 「V : 왕복평균속도(km/hr)」", "확신": "원문"},
|
||||
"준비작업시간": {"기호": "t", "근거": "건설품셈 공통 1-2-7 「t : 준비작업시간(2분)」", "확신": "원문"}
|
||||
},
|
||||
"GC001143": {
|
||||
"작업량": {"기호": "q", "근거": "건설품셈 공통 8-1-4 「q : 1회 작업싸이클당 표준작업량(㎥ 또는 ton)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-1-4 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-1-4 「E : 작업효율」", "확신": "원문"},
|
||||
"n": {"이름": "시간당 작업싸이클 수", "근거": "건설품셈 공통 8-1-4 「n : 시간당 작업싸이클 수」", "확신": "원문"},
|
||||
"싸이클시간": {"기호": "cm", "근거": "설명 「1회 작업싸이클 시간(cm)」", "확신": "추정"}
|
||||
},
|
||||
"GC001144": {
|
||||
"운반거리": {"기호": "L", "근거": "건설품셈 공통 8-2-1 「L : 운반거리(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-1 「f : 체적환산계수」", "확신": "원문"},
|
||||
"q0": {"이름": "거리를 고려하지 않은 삽날의 용량", "기호": "q", "아래": "0", "근거": "건설품셈 공통 8-2-1 「q゚ : 거리를 고려하지 않은 삽날의 용량(㎥)」", "확신": "원문"},
|
||||
"e": {"이름": "운반거리계수", "근거": "건설품셈 공통 8-2-1 「e : 운반거리계수」", "확신": "원문"},
|
||||
"q": {"이름": "삽날의 용량", "근거": "건설품셈 공통 8-2-1 「q : 삽날의 용량(㎥)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-1 「E : 작업효율」", "확신": "원문"},
|
||||
"V1": {"이름": "전진속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-1 「V_1 : 전진속도(m/분)」", "확신": "원문"},
|
||||
"V2": {"이름": "후진속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-1 「V_2 : 후진속도(m/분)」", "확신": "원문"},
|
||||
"t": {"이름": "기어 변속시간", "근거": "건설품셈 공통 8-2-1 「t : 기어 변속시간(0.25분)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-1 「cm : 1회 싸이클 시간」", "확신": "원문"}
|
||||
},
|
||||
"GC001146": {
|
||||
"작업거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-2 「ℓ : 1회의 작업거리(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-2 「f : 체적환산계수」", "확신": "원문"},
|
||||
"An": {"이름": "1회 리핑 단면적", "근거": "건설품셈 공통 8-2-2 「An : 1회 리핑 단면적(㎡)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-2 「E : 작업효율」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-2 「cm : 1회 싸이클 시간(분)」", "확신": "원문"}
|
||||
},
|
||||
"GC001147": {
|
||||
"버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-3 「q : 버킷용량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-3 「f : 체적환산계수」", "확신": "원문"},
|
||||
"K": {"이름": "버킷계수", "근거": "건설품셈 공통 8-2-3 「K : 버킷계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-3 「E : 작업효율」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-3 「cm : 1회 싸이클 시간(초)」", "확신": "원문"}
|
||||
},
|
||||
"GC001149": {
|
||||
"작업거리": {"기호": "L", "근거": "건설품셈 공통 8-2-4 「L : 1열 실작업거리(편도m)」", "확신": "원문"},
|
||||
"전진거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-4 「L_1 : 1열 전진거리(m)」", "확신": "원문"},
|
||||
"후진거리": {"기호": "L", "아래": "2", "근거": "건설품셈 공통 8-2-4 「L_2 : 1열 후진거리(m)」", "확신": "원문"},
|
||||
"d": {"이름": "굴착심도계수", "근거": "건설품셈 공통 8-2-4 「d : 굴착심도계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-4 「E : 작업효율」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-4 「cm : 1회 싸이클시간(분)」", "확신": "원문"}
|
||||
},
|
||||
"GC001150": {
|
||||
"버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-5 「q : 버킷용량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-5 「f : 체적환산계수」", "확신": "원문"},
|
||||
"t1": {"이름": "버킷에 토량을 담는데 소요되는 시간", "기호": "t", "아래": "1", "근거": "건설품셈 공통 8-2-5 「t_1 : 버킷에 토량을 담는데 소요되는 시간(초)」", "확신": "원문"},
|
||||
"K": {"이름": "버킷계수", "근거": "건설품셈 공통 8-2-5 「K : 버킷계수」", "확신": "원문"},
|
||||
"m": {"이름": "계수", "근거": "건설품셈 공통 8-2-5 「m : 계수(초/m) 무한궤도식 : 2.0」", "확신": "원문"},
|
||||
"l": {"이름": "편도주행거리", "기호": "ℓ", "근거": "건설품셈 공통 8-2-5 「ℓ : 편도주행거리(표준을 8m로 한다)」", "확신": "원문"},
|
||||
"t2": {"이름": "기어변화 등 기본 시간과 다음 운반기계가 도착할 때까지의 시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-5 「t_2 : 기어변화 등 기본 시간과 다음 운반기계가 도착할 때까지의 시간(14초)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-5 「cm : 1회 싸이클 시간(초)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-5 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001152": {
|
||||
"적재주행거리": {"기호": "L", "아래": "1", "근거": "건설품셈 공통 8-2-6 「L_1 : 적재시의 주행거리(m)」", "확신": "원문"},
|
||||
"공차주행거리": {"기호": "L", "아래": "2", "근거": "건설품셈 공통 8-2-6 「L_2 : 공차시의 주행거리(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-6 「f : 체적환산계수」", "확신": "원문"},
|
||||
"q": {"이름": "적재함용적×적재계수", "근거": "건설품셈 공통 8-2-6 「q : 적재함용적×적재계수(k)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-6 「E : 작업효율」", "확신": "원문"},
|
||||
"V1": {"이름": "적재시의 주행속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-6 「V_1 : 적재시의 주행속도(m/분)」", "확신": "원문"},
|
||||
"V2": {"이름": "공차시의 주행속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-6 「V_2 : 공차시의 주행속도(m/분)」", "확신": "원문"},
|
||||
"t": {"이름": "적토, 사토 및 기어변속시간", "근거": "건설품셈 공통 8-2-6 「t : 적토, 사토 및 기어변속시간(푸쉬도우저를 사용할 때 1.6분, 사용하지 않을 때 2.8분)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-6 「cm : 1회 싸이클 시간」", "확신": "원문"}
|
||||
},
|
||||
"GC001153": {
|
||||
"작업거리": {"기호": "D", "근거": "건설품셈 공통 8-2-7 「D : 1회의 작업거리(편도 m)」", "확신": "원문"},
|
||||
"작업폭": {"기호": "W", "근거": "건설품셈 공통 8-2-7 「W : 작업장 전체의 폭(m)」", "확신": "원문"},
|
||||
"V1": {"이름": "작업속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-7 「V_1 : 작업속도(㎞/hr)」", "확신": "원문"},
|
||||
"V2": {"이름": "후진 또는 회송속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-7 「V_2 : 후진 또는 회송속도(㎞/hr)」", "확신": "원문"},
|
||||
"t": {"이름": "방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간", "근거": "건설품셈 공통 8-2-7 「t : 방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간(분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-7 「E : 작업효율」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001154": {
|
||||
"작업거리": {"기호": "D", "근거": "건설품셈 공통 8-2-7 「D : 1회의 작업거리(편도 m)」", "확신": "원문"},
|
||||
"두께": {"기호": "H", "근거": "건설품셈 공통 8-2-7 「H : 굴착 깊이 또는 흙고르기 두께(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-7 「f : 체적환산계수」", "확신": "원문"},
|
||||
"V1": {"이름": "작업속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-7 「V_1 : 작업속도(㎞/hr)」", "확신": "원문"},
|
||||
"V2": {"이름": "후진 또는 회송속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-7 「V_2 : 후진 또는 회송속도(㎞/hr)」", "확신": "원문"},
|
||||
"t": {"이름": "방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간", "근거": "건설품셈 공통 8-2-7 「t : 방향 변환 또는 블레이드 선회 기어변속에 소요되는 시간(분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-7 「E : 작업효율」", "확신": "원문"},
|
||||
"l": {"이름": "블레이드의 유효길이", "기호": "ℓ", "근거": "건설품셈 공통 8-2-7 「ℓ : 블레이드의 유효길이(m)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001155": {
|
||||
"적재용량": {"기호": "T", "근거": "건설품셈 공통 8-2-8 「T : 덤프트럭의 적재용량(ton)」", "확신": "원문"},
|
||||
"체적변화율": {"기호": "L", "근거": "건설품셈 공통 8-2-8 「L : 체적환산계수에서의 체적변화율」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-8 「f : 체적환산계수」", "확신": "원문"},
|
||||
"적재싸이클": {"기호": "cms", "근거": "건설품셈 공통 8-2-8 「cms : 적재기계의 1회 싸이클시간(초)」", "확신": "원문"},
|
||||
"버킷계수": {"기호": "k", "근거": "건설품셈 공통 8-2-8 「k : 리퍼 또는 버킷계수」", "확신": "원문"},
|
||||
"적재효율": {"기호": "Es", "근거": "건설품셈 공통 8-2-8 「Es : 적재기계의 작업효율」", "확신": "원문"},
|
||||
"q": {"이름": "흐트러진 상태의 덤프트럭 1회 적재량", "근거": "건설품셈 공통 8-2-8 「q : 흐트러진 상태의 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
|
||||
"n": {"이름": "덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수", "근거": "건설품셈 공통 8-2-8 「n : 덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-8 「cm : 1회 싸이클시간(분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-8 「E : 작업효율(0.9)」", "확신": "원문"},
|
||||
"t1": {"기호": "t", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t2": {"기호": "t", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t3": {"기호": "t", "아래": "3", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t4": {"기호": "t", "아래": "4", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t5": {"기호": "t", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"t6": {"기호": "t", "아래": "6", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC001157": {
|
||||
"다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"},
|
||||
"두께": {"기호": "D", "근거": "건설품셈 공통 8-2-9 「D : 펴는 흙의 두께(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-9 「f : 체적환산계수」", "확신": "원문"},
|
||||
"W": {"이름": "롤러의 유효폭", "근거": "건설품셈 공통 8-2-9 「W : 롤러의 유효폭(m)」", "확신": "원문"},
|
||||
"V": {"이름": "다짐속도", "근거": "건설품셈 공통 8-2-9 「V : 다짐속도(㎞/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-9 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001158": {
|
||||
"다짐횟수": {"기호": "N", "근거": "건설품셈 공통 8-2-9 「N : 소요다짐횟수」", "확신": "원문"},
|
||||
"W": {"이름": "롤러의 유효폭", "근거": "건설품셈 공통 8-2-9 「W : 롤러의 유효폭(m)」", "확신": "원문"},
|
||||
"V": {"이름": "다짐속도", "근거": "건설품셈 공통 8-2-9 「V : 다짐속도(㎞/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-9 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001161": {
|
||||
"W": {"이름": "유효혼합폭", "근거": "건설품셈 공통 8-2-11 「W : 유효혼합폭(m)」", "확신": "원문"},
|
||||
"V": {"이름": "작업속도", "근거": "건설품셈 공통 8-2-11 「V : 작업속도(1,000m/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-11 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001164": {
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001167": {
|
||||
"q": {"이름": "작업능력", "근거": "건설품셈 공통 8-2-14 「q : 작업능력(3.26㎥/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-14 「E : 작업효율(0.95)」", "확신": "원문"}
|
||||
},
|
||||
"GC001169": {
|
||||
"q": {"이름": "시간당 표준작업량", "근거": "건설품셈 공통 8-2-16 「q : 시간당 표준작업량(62.5㎥/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-16 「E : 작업효율(0.8)」", "확신": "원문"}
|
||||
},
|
||||
"GC001170": {
|
||||
"믹서용량": {"기호": "q", "근거": "건설품셈 공통 8-2-17 「q : 콘크리트 믹서용량(㎥)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-17 「E : 작업효율(0.8)」", "확신": "원문"}
|
||||
},
|
||||
"GC001171": {
|
||||
"q": {"이름": "믹서의 실용량", "근거": "건설품셈 공통 8-2-18 「q : 믹서의 실용량」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-18 「cm : 1회 싸이클시간(1.5분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-18 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001172": {
|
||||
"적재용량": {"기호": "W", "근거": "건설품셈 공통 8-2-19 「W : 적재용량」", "확신": "원문"},
|
||||
"t1": {"이름": "적입시간", "기호": "t", "아래": "1", "근거": "건설품셈 공통 8-2-19 「t_1 : 적입시간」", "확신": "원문"},
|
||||
"t2": {"이름": "주행시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-19 「t_2 : 주행시간」", "확신": "원문"},
|
||||
"t3": {"이름": "배출시간", "기호": "t", "아래": "3", "근거": "건설품셈 공통 8-2-19 「t_3 : 배출시간」", "확신": "원문"},
|
||||
"t4": {"이름": "대기시간", "기호": "t", "아래": "4", "근거": "건설품셈 공통 8-2-19 「t_4 : 대기시간」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-19 「E : 작업효율(0.95)」", "확신": "원문"},
|
||||
"플랜트실용량": {"기호": "q", "근거": "설명 「콘크리트플랜트 믹서 실용량(q)」", "확신": "추정"},
|
||||
"운반거리": {"기호": "L", "근거": "설명 「운반거리(편도)」", "확신": "추정"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001173": {
|
||||
"W": {"이름": "적재용량", "근거": "건설품셈 공통 8-2-19 「W : 적재용량」", "확신": "원문"},
|
||||
"cm1": {"이름": "1회 싸이클의 왕복 주행시간", "기호": "cm", "아래": "1", "근거": "건설품셈 공통 8-2-19 「cm_1 : 1회 싸이클의 왕복 주행시간(min)」", "확신": "원문"},
|
||||
"cm2": {"이름": "1회 싸이클의 작업하역시간 및 대기시간의 합계", "기호": "cm", "아래": "2", "근거": "건설품셈 공통 8-2-19 「cm_2 : 1회 싸이클의 작업하역시간 및 대기시간의 합계(min)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-19 「E : 작업효율(0.95)」", "확신": "원문"},
|
||||
"플랜트실용량": {"기호": "q", "근거": "설명 「콘크리트플랜트 믹서 실용량(q)」", "확신": "추정"},
|
||||
"운반거리": {"기호": "L", "근거": "설명 「편도운반거리(L · 15㎞까지)」", "확신": "추정"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001174": {
|
||||
"대차용량": {"기호": "q", "근거": "건설품셈 공통 8-2-20 「q : 대차의 용량(㎥)」", "확신": "원문"},
|
||||
"운반거리": {"기호": "L", "근거": "건설품셈 공통 8-2-20 「L : 평균 운반편도(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-20 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-20 「E : 작업효율」", "확신": "원문"},
|
||||
"n": {"이름": "1회운반시의 대차수", "근거": "건설품셈 공통 8-2-20 「n : 1회운반시의 대차수(5t일 때 12대, 7t일 때 15대)」", "확신": "원문"},
|
||||
"C": {"이름": "1회 운반토량", "근거": "건설품셈 공통 8-2-20 「C : 1회 운반토량(㎥)」", "확신": "원문"},
|
||||
"t2": {"이름": "적재 적하 소요시간", "기호": "t", "아래": "2", "근거": "건설품셈 공통 8-2-20 「t_2 : 적재 적하 소요시간(토사류는 17분, 석재류는 20분)」", "확신": "원문"},
|
||||
"N": {"이름": "1시간당 운반횟수", "근거": "건설품셈 공통 8-2-20 「N : 1시간당 운반횟수」", "확신": "원문"}
|
||||
},
|
||||
"GC001175": {
|
||||
"적재량": {"기호": "q", "근거": "건설품셈 공통 8-2-21 「q : 흐트러진 상태의 경운기 1회 적재량」", "확신": "원문"},
|
||||
"거리": {"기호": "L", "근거": "건설품셈 공통 8-2-21 「L : 거리(m)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-21 「f : 체적환산계수」", "확신": "원문"},
|
||||
"t": {"이름": "적재 적하시간", "근거": "건설품셈 공통 8-2-21 「t : 적재 적하시간(분)」", "확신": "원문"},
|
||||
"V1": {"이름": "적재시 속도", "기호": "V", "아래": "1", "근거": "건설품셈 공통 8-2-21 「V_1 : 적재시 속도(m/분)」", "확신": "원문"},
|
||||
"V2": {"이름": "공차시 속도", "기호": "V", "아래": "2", "근거": "건설품셈 공통 8-2-21 「V_2 : 공차시 속도(m/분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-21 「E : 작업효율(0.9)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GC001176": {
|
||||
"관입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-22 「L : 파일 끝이 들어가는 전층의 길이(m)」", "확신": "원문"},
|
||||
"세우기횟수": {"기호": "Ns", "근거": "건설품셈 공통 8-2-22 「Ns : 파일세우기 횟수」", "확신": "원문"},
|
||||
"평균간격": {"기호": "a", "근거": "건설품셈 공통 8-2-22 「a : 파일의 평균간격(m)」", "확신": "원문"},
|
||||
"블록간거리": {"기호": "LS", "근거": "건설품셈 공통 8-2-22 「LS : 블록간의 거리(m)」", "확신": "원문"},
|
||||
"블록수": {"기호": "S", "근거": "건설품셈 공통 8-2-22 「S : 블록수」", "확신": "원문"},
|
||||
"시공본수": {"기호": "n", "근거": "건설품셈 공통 8-2-22 「n : 파일의 전 시공 본수」", "확신": "원문"},
|
||||
"이음수": {"기호": "Nw", "근거": "건설품셈 공통 8-2-22 「Nw : 파일 1본당 이음수」", "확신": "원문"},
|
||||
"α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-22 「α : 토질계수」", "확신": "원문"},
|
||||
"N": {"이름": "파일 끝이 들어가는 전층의 평균 N치", "근거": "건설품셈 공통 8-2-22 「N : 파일 끝이 들어가는 전층의 평균 N치」", "확신": "원문"},
|
||||
"F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-22 「F : 작업계수」", "확신": "원문"},
|
||||
"β": {"이름": "해머 계수", "근거": "건설품셈 공통 8-2-22 「β : 해머 계수」", "확신": "원문"},
|
||||
"Tb": {"이름": "파일 1본당 타격시간", "근거": "건설품셈 공통 8-2-22 「Tb : 파일 1본당 타격시간(min)」", "확신": "원문"},
|
||||
"tw": {"이름": "이음 1개소당 용접시간", "근거": "건설품셈 공통 8-2-22 「tw : 이음 1개소당 용접시간(분)」", "확신": "원문"},
|
||||
"Tw": {"이름": "파일 1본당 용접시간", "근거": "건설품셈 공통 8-2-22 「Tw : 파일 1본당 용접시간(min)」", "확신": "원문"},
|
||||
"Ts": {"이름": "파일 1본당 세우기 및 위치 조정시간", "근거": "건설품셈 공통 8-2-22 「Ts : 파일 1본당 세우기 및 위치 조정시간(min)」", "확신": "원문"},
|
||||
"Tt": {"이름": "파일 1본당 해머의 이동 및 준비시간", "근거": "건설품셈 공통 8-2-22 「Tt : 파일 1본당 해머의 이동 및 준비시간(min)」", "확신": "원문"},
|
||||
"Te": {"이름": "파일 1본당 해머의 점검 및 급유 등 기타시간", "근거": "건설품셈 공통 8-2-22 「Te : 파일 1본당 해머의 점검 및 급유 등 기타시간(min)」", "확신": "원문"}
|
||||
},
|
||||
"GC001177": {
|
||||
"관입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-22 「L : 파일 끝이 들어가는 전층의 길이(m)」", "확신": "원문"},
|
||||
"세우기횟수": {"기호": "Ns", "근거": "건설품셈 공통 8-2-22 「Ns : 파일세우기 횟수」", "확신": "원문"},
|
||||
"α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-22 「α : 토질계수」", "확신": "원문"},
|
||||
"N": {"이름": "파일 끝이 들어가는 전층의 평균 N치", "근거": "건설품셈 공통 8-2-22 「N : 파일 끝이 들어가는 전층의 평균 N치」", "확신": "원문"},
|
||||
"F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-22 「F : 작업계수」", "확신": "원문"},
|
||||
"β": {"이름": "해머 계수", "근거": "건설품셈 공통 8-2-22 「β : 해머 계수」", "확신": "원문"},
|
||||
"Tb": {"이름": "파일 1본당 타격시간", "근거": "건설품셈 공통 8-2-22 「Tb : 파일 1본당 타격시간(min)」", "확신": "원문"},
|
||||
"Ts": {"이름": "파일 1본당 세우기 및 위치 조정시간", "근거": "건설품셈 공통 8-2-22 「Ts : 파일 1본당 세우기 및 위치 조정시간(min)」", "확신": "원문"},
|
||||
"Tt": {"이름": "파일 1본당 해머의 이동 및 준비시간", "근거": "건설품셈 공통 8-2-22 「Tt : 파일 1본당 해머의 이동 및 준비시간(min)」", "확신": "원문"},
|
||||
"Te": {"이름": "파일 1본당 해머의 점검 및 급유 등 기타시간", "근거": "건설품셈 공통 8-2-22 「Te : 파일 1본당 해머의 점검 및 급유 등 기타시간(min)」", "확신": "원문"}
|
||||
},
|
||||
"GC001178": {
|
||||
"α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-23 「α : 토질계수」", "확신": "원문"},
|
||||
"β": {"이름": "판두께계수", "근거": "건설품셈 공통 8-2-23 「β : 판두께계수」", "확신": "원문"},
|
||||
"Ta": {"이름": "파일규격에 따른 시공시간", "근거": "건설품셈 공통 8-2-23 「Ta : 파일규격에 따른 시공시간(min/본)」", "확신": "원문"}
|
||||
},
|
||||
"GC001179": {
|
||||
"α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-23 「α : 토질계수」", "확신": "원문"},
|
||||
"Ta": {"이름": "파일규격에 따른 시공시간", "근거": "건설품셈 공통 8-2-23 「Ta : 파일규격에 따른 시공시간(min/본)」", "확신": "원문"}
|
||||
},
|
||||
"GC001180": {
|
||||
"사질층길이": {"기호": "ℓ", "아래": "1", "근거": "건설품셈 공통 8-2-24 「ℓ_1 : r_1에 대한 근입장(m)」", "확신": "원문"},
|
||||
"점질층길이": {"기호": "ℓ", "아래": "2", "근거": "건설품셈 공통 8-2-24 「ℓ_2 : r_2에 대한 근입장(m)」", "확신": "원문"},
|
||||
"Ts": {"이름": "파일 1본당 준비시간", "근거": "건설품셈 공통 8-2-24 「Ts : 파일 1본당 준비시간(분)」", "확신": "원문"},
|
||||
"r1": {"이름": "사질토, 역질토에 대한 항타 단위 작업시간", "기호": "r", "아래": "1", "근거": "건설품셈 공통 8-2-24 「r_1 : 사질토, 역질토에 대한 항타 단위 작업시간(min/m)」", "확신": "원문"},
|
||||
"r2": {"이름": "점질토에 대한 항타 단위 작업시간", "기호": "r", "아래": "2", "근거": "건설품셈 공통 8-2-24 「r_2 : 점질토에 대한 항타 단위 작업시간(min/m)」", "확신": "원문"},
|
||||
"r": {"이름": "토질별 항타 또는 항발시간", "근거": "건설품셈 공통 8-2-24 「r : 토질별 항타 또는 항발시간(분/m)」", "확신": "원문"},
|
||||
"k": {"이름": "해머계수", "근거": "건설품셈 공통 8-2-24 「k : 해머계수」", "확신": "원문"},
|
||||
"Tb": {"이름": "파일 1본당 항타 또는 항발시간", "근거": "건설품셈 공통 8-2-24 「Tb : 파일 1본당 항타 또는 항발시간(분)」", "확신": "원문"},
|
||||
"F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-24 「F : 작업계수」", "확신": "원문"},
|
||||
"사질N": {"기호": "N", "아래": "1", "근거": "설명 「사질토 · 역질토 N치(N1)」", "확신": "추정"},
|
||||
"점질N": {"기호": "N", "아래": "2", "근거": "설명 「점질토 N치(N2)」", "확신": "추정"},
|
||||
"f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"},
|
||||
"f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"},
|
||||
"f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"},
|
||||
"f4": {"이름": "작업조건 보정계수 4", "기호": "f", "아래": "4", "근거": "칸 설명", "확신": "원문"}
|
||||
},
|
||||
"GC001181": {
|
||||
"근입길이": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-24 「ℓ : 파일 근입장(m)」", "확신": "원문"},
|
||||
"Nmax": {"이름": "최대 N치", "근거": "건설품셈 공통 8-2-24 「Nmax : 최대 N치」", "확신": "원문"},
|
||||
"K": {"이름": "강널말뚝 종류 및 기계 규격에 따른 계수", "근거": "건설품셈 공통 8-2-24 「K : 강널말뚝 종류 및 기계 규격에 따른 계수」", "확신": "원문"},
|
||||
"F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-24 「F : 작업계수」", "확신": "원문"},
|
||||
"f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"},
|
||||
"f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"},
|
||||
"f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"}
|
||||
},
|
||||
"GC001182": {
|
||||
"근입길이": {"기호": "L", "근거": "건설품셈 공통 8-2-25 「L : 근입길이(m)」", "확신": "원문"},
|
||||
"To": {"이름": "파일 1본(장)당 기본시공시간", "근거": "건설품셈 공통 8-2-25 「To : 파일 1본(장)당 기본시공시간(분)」", "확신": "원문"},
|
||||
"α": {"이름": "토질계수", "근거": "건설품셈 공통 8-2-25 「α : 토질계수」", "확신": "원문"},
|
||||
"F": {"이름": "현장의 조건에 따른 작업계수", "근거": "건설품셈 공통 8-2-25 「F : 현장의 조건에 따른 작업계수」", "확신": "원문"},
|
||||
"f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"},
|
||||
"f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"},
|
||||
"f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"},
|
||||
"f4": {"이름": "작업조건 보정계수 4", "기호": "f", "아래": "4", "근거": "칸 설명", "확신": "원문"}
|
||||
},
|
||||
"GC001183": {
|
||||
"파일길이": {"기호": "L", "근거": "건설품셈 공통 8-2-26 「L : 파일길이(m)」", "확신": "원문"},
|
||||
"압입길이": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-26 「ℓ : 강널말뚝 1본당 인발길이(m)」", "확신": "원문"},
|
||||
"Nmax": {"이름": "압입길이에 따른 최대 N치", "근거": "건설품셈 공통 8-2-26 「Nmax : 압입길이에 따른 최대 N치」", "확신": "원문"},
|
||||
"Ts": {"이름": "압입 강널말뚝 1본당 준비시간", "기호": "T", "아래": "s", "근거": "건설품셈 공통 8-2-26 「T_s : 압입 강널말뚝 1본당 준비시간(분/본)」", "확신": "원문"},
|
||||
"γ": {"이름": "압입단위 작업시간", "단위": "분/본", "근거": "건설품셈 공통 8-2-26 「γ : 압입단위 작업시간(분/본)」", "확신": "원문"},
|
||||
"Tb": {"이름": "압입 강널말뚝 1본당 압입시간", "기호": "T", "아래": "b", "근거": "건설품셈 공통 8-2-26 「T_b : 압입 강널말뚝 1본당 압입시간(분/본)」", "확신": "원문"},
|
||||
"F": {"이름": "작업계수", "근거": "건설품셈 공통 8-2-26 「F : 작업계수」", "확신": "원문"},
|
||||
"f1": {"이름": "작업조건 보정계수 1", "기호": "f", "아래": "1", "근거": "칸 설명", "확신": "원문"},
|
||||
"f2": {"이름": "작업조건 보정계수 2", "기호": "f", "아래": "2", "근거": "칸 설명", "확신": "원문"},
|
||||
"f3": {"이름": "작업조건 보정계수 3", "기호": "f", "아래": "3", "근거": "칸 설명", "확신": "원문"}
|
||||
},
|
||||
"GC001185": {
|
||||
"작업거리": {"기호": "ℓ", "근거": "건설품셈 공통 8-2-28 「ℓ : 1회의 작업거리(m)」", "확신": "원문"},
|
||||
"회전속도": {"기호": "R", "근거": "건설품셈 공통 8-2-28 「R : 굴착면의 분당 회전속도」", "확신": "원문"},
|
||||
"투과깊이": {"기호": "Pe", "근거": "건설품셈 공통 8-2-28 「Pe : 굴착면 1회전당 컷터의 투과깊이(cm / 회)」", "확신": "원문"},
|
||||
"A": {"이름": "굴착면적", "근거": "건설품셈 공통 8-2-28 「A : 굴착면적(㎡)」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-28 「cm : 1회의 싸이클 시간(분)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-28 「E : 작업효율」", "확신": "원문"},
|
||||
"굴착직경": {"기호": "D", "근거": "설명 「굴착직경(D)」", "확신": "추정"},
|
||||
"T1": {"기호": "T", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GC001186": {
|
||||
"전동환산출력": {"기호": "bo", "근거": "건설품셈 공통 8-2-29 「bo : 펌프준설선의 전동환산 출력(㎾)」", "확신": "원문"},
|
||||
"E1": {"이름": "흙의 두께에 따른 효율", "기호": "E", "아래": "1", "근거": "건설품셈 공통 8-2-29 「E_1 : 흙의 두께에 따른 효율」", "확신": "원문"},
|
||||
"E2": {"이름": "평면형상에 따른 효율", "기호": "E", "아래": "2", "근거": "건설품셈 공통 8-2-29 「E_2 : 평면형상에 따른 효율」", "확신": "원문"},
|
||||
"E3": {"이름": "단면형상에 따른 효율", "기호": "E", "아래": "3", "근거": "건설품셈 공통 8-2-29 「E_3 : 단면형상에 따른 효율」", "확신": "원문"},
|
||||
"E4": {"이름": "해상조건에 따른 효율", "기호": "E", "아래": "4", "근거": "건설품셈 공통 8-2-29 「E_4 : 해상조건에 따른 효율」", "확신": "원문"},
|
||||
"q": {"이름": "펌프준설선의 전동환산 746㎾의 1시간당 준설량", "근거": "건설품셈 공통 8-2-29 「q : 펌프준설선의 전동환산(電動換算) 746㎾의 1시간당 준설량(㎥/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-29 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001187": {
|
||||
"버킷용량": {"기호": "q", "근거": "건설품셈 공통 8-2-30 「q : 버킷 또는 디퍼의 용량(㎥)」", "확신": "원문"},
|
||||
"E1": {"이름": "흙의 두께에 따른 효율", "기호": "E", "아래": "1", "근거": "건설품셈 공통 8-2-30 「E_1 : 흙의 두께에 따른 효율」", "확신": "원문"},
|
||||
"E2": {"이름": "해상조건에 따른 효율", "기호": "E", "아래": "2", "근거": "건설품셈 공통 8-2-30 「E_2 : 해상조건에 따른 효율」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "건설품셈 공통 8-2-30 「f : 현 지반의 토량을 기준하였을 때와의 준설토량의 변화율(체적 환산계수)」", "확신": "원문"},
|
||||
"k": {"이름": "버킷 및 디퍼의 계수", "근거": "건설품셈 공통 8-2-30 「k : 버킷 및 디퍼의 계수」", "확신": "원문"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "건설품셈 공통 8-2-30 「cm : 1회 싸이클시간(초)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-30 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GC001188": {
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-31 「E : 작업효율」", "확신": "원문"},
|
||||
"S": {"이름": "1본당 쇄암면적", "근거": "건설품셈 공통 8-2-31 「S : 1본당 쇄암면적(㎡)」", "확신": "원문"},
|
||||
"n": {"이름": "1층의 쇄암깊이(d)를 쇄암하는데 필요한 낙추횟수", "근거": "건설품셈 공통 8-2-31 「n : 1층의 쇄암깊이(d)를 쇄암하는데 필요한 낙추횟수」", "확신": "원문"}
|
||||
},
|
||||
"GC001190": {
|
||||
"출력": {"기호": "b", "근거": "건설품셈 공통 8-2-33 「b : 하천골재채취선의 출력(㎾)」", "확신": "원문"},
|
||||
"q": {"이름": "하천골재채취선 746㎾의 시간당 준설량", "근거": "건설품셈 공통 8-2-33 「q : 하천골재채취선 746㎾의 시간당 준설량(㎥/hr)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "건설품셈 공통 8-2-33 「E : 작업효율」", "확신": "원문"}
|
||||
},
|
||||
"GF000003": {
|
||||
"q": {"이름": "버킷용량", "근거": "표 라벨/출처 「q(버킷용량)」", "확신": "원문"},
|
||||
"K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클의 시간)」", "확신": "원문"}
|
||||
},
|
||||
"GF000042": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클시간)」", "확신": "원문"}
|
||||
},
|
||||
"GF000043": {
|
||||
"작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 5-29 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
|
||||
},
|
||||
"GF000062": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000063": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000064": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000065": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000066": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000067": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000068": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000071": {
|
||||
"Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"}
|
||||
},
|
||||
"GF000072": {
|
||||
"Q": {"이름": "운재량", "근거": "표 열/행 이름 「운재량」", "확신": "원문"}
|
||||
},
|
||||
"GF000073": {
|
||||
"Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"}
|
||||
},
|
||||
"GF000074": {
|
||||
"Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"}
|
||||
},
|
||||
"GF000075": {
|
||||
"Q": {"이름": "운반량", "근거": "표 열/행 이름 「운반량」", "확신": "원문"}
|
||||
},
|
||||
"GF000088": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000090": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000092": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000094": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000098": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000112": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000114": {
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000115": {
|
||||
"T": {"이름": "표토두께", "근거": "산림품셈 9-15-1 「T : 표토두께(m)」", "확신": "원문"},
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"},
|
||||
"f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000116": {
|
||||
"T": {"이름": "표토두께", "근거": "산림품셈 9-15-1 「T : 표토두께(m)」", "확신": "원문"},
|
||||
"작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎡/hr", "근거": "산림품셈 9-15-1 「Q : 시간당 작업량(㎡/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
|
||||
},
|
||||
"GF000117": {
|
||||
"T": {"이름": "표토두께", "근거": "표 라벨/출처 「T(표토두께)」", "확신": "원문"},
|
||||
"L": {"이름": "운반거리", "근거": "표 라벨/출처 「L(운반거리)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"q0": {"이름": "거리를 고려하지 않은 삽날의 용량", "기호": "q", "아래": "0", "근거": "표 라벨/출처 「q0(거리를 고려하지 않은 삽날의 용량)」", "확신": "원문"},
|
||||
"e": {"이름": "운반거리계수", "근거": "표 라벨/출처 「e(운반거리계수)」", "확신": "원문"},
|
||||
"V1": {"이름": "전진속도", "기호": "V", "아래": "1", "근거": "표 라벨/출처 「V1(전진속도)」", "확신": "원문"},
|
||||
"V2": {"이름": "후진속도", "기호": "V", "아래": "2", "근거": "표 라벨/출처 「V2(후진속도)」", "확신": "원문"},
|
||||
"t": {"이름": "기어변속시간", "근거": "표 라벨/출처 「t(기어변속시간)」", "확신": "원문"},
|
||||
"f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000118": {
|
||||
"q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000120": {
|
||||
"V": {"이름": "다짐속도", "단위": "km/hr", "근거": "표 라벨/출처 「V(다짐속도)」", "확신": "원문"},
|
||||
"W": {"이름": "롤러 유효폭", "단위": "m", "근거": "표 라벨/출처 「W(롤러 유효폭)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"D": {"이름": "펴는 흙의 두께", "단위": "m", "근거": "표 라벨/출처 「D(펴는 흙의 두께)」", "확신": "원문"},
|
||||
"f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"},
|
||||
"N": {"이름": "소요다짐횟수", "근거": "표 라벨/출처 「N(소요다짐횟수)」", "확신": "원문"}
|
||||
},
|
||||
"GF000121": {
|
||||
"q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"V1": {"기호": "V", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"V2": {"기호": "V", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000122": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000131": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "표 라벨/출처 「K(버킷계수)」", "확신": "원문"},
|
||||
"f": {"이름": "토량환산계수", "근거": "표 라벨/출처 「f(토량환산계수)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "표 라벨/출처 「Cm(1회 사이클시간)」", "확신": "원문"}
|
||||
},
|
||||
"GF000132": {
|
||||
"작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 9-22 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
|
||||
},
|
||||
"GF000133": {
|
||||
"qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림품셈 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "산림품셈 10-3 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "산림품셈 10-3 「E : 작업효율」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000134": {
|
||||
"qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림품셈 10-3-1 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "산림품셈 10-3-1 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "산림품셈 10-3-1 「E : 작업효율」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"},
|
||||
"작업량": {"이름": "시간당 작업량", "기호": "Q", "단위": "㎥/hr", "근거": "산림품셈 10-3-1 「Q : 시간당 작업량(㎥/hr)」 · 식 = 로직 호출(시간당 작업량)", "확신": "원문"}
|
||||
},
|
||||
"GF000135": {
|
||||
"qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "산림 10-3 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "산림 10-3 「E : 작업효율」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"}
|
||||
},
|
||||
"GF000136": {
|
||||
"qt": {"이름": "덤프트럭 1회 적재량", "근거": "산림 10-3 「qt : 덤프트럭 1회 적재량(㎥)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "산림 10-3 「f : 체적환산계수」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "산림 10-3 「E : 작업효율」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "산림 10-3 골재운반 Q 식", "확신": "추정"}
|
||||
},
|
||||
"GF000137": {
|
||||
"t2": {"이름": "한 번 싣고 내리는 데 드는 시간", "기호": "t", "아래": "2", "근거": "칸 설명", "확신": "원문"}
|
||||
},
|
||||
"GF000148": {
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000153": {
|
||||
"q": {"이름": "버킷용량", "근거": "표 라벨/출처 「q(버킷용량)」", "확신": "원문"},
|
||||
"k": {"이름": "버킷계수", "근거": "표 라벨/출처 「k(버킷계수)」", "확신": "원문"},
|
||||
"f": {"이름": "체적환산계수", "근거": "표 라벨/출처 「f(체적환산계수)」", "확신": "원문"},
|
||||
"E": {"이름": "작업효율", "근거": "표 라벨/출처 「E(작업효율)」", "확신": "원문"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000168": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000193": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000194": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000239": {
|
||||
"q": {"이름": "버킷용량", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"f": {"이름": "체적환산계수", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"},
|
||||
"Cm": {"이름": "1회 싸이클시간", "단위": "초", "근거": "시공능력 기본식(건설 공통 8-1-4) 기호 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000256": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000257": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000258": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000259": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000260": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000261": {
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000277": {
|
||||
"Q1": {"기호": "Q", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"Q5": {"기호": "Q", "아래": "5", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GF000284": {
|
||||
"K": {"이름": "버킷계수", "근거": "산림품셈 10-12-1 「K : 버켓계수」", "확신": "원문"},
|
||||
"Es": {"이름": "적재기계의 작업효율", "근거": "산림품셈 10-12-1 「Es : 적재기계의 작업효율」", "확신": "원문"},
|
||||
"q": {"이름": "적재기계의 버킷용량", "단위": "㎥", "근거": "산림품셈 10-12-1 「q : 적재기계의 버켓용량(㎥)」", "확신": "원문"},
|
||||
"n": {"이름": "덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수", "근거": "산림품셈 10-12-1 「n : 덤프트럭 1대의 토량을 적재하는데 소요되는 적재기계의 싸이클 횟수」", "확신": "원문"},
|
||||
"q0": {"기호": "q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"E0": {"기호": "E", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"Q1": {"기호": "Q", "아래": "1", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"Q": {"이름": "시간당 작업량", "근거": "시공능력식 Q 준용", "확신": "추정"}
|
||||
},
|
||||
"GF000308": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000309": {
|
||||
"Q": {"이름": "수집량", "근거": "표 열/행 이름 「수집량」", "확신": "원문"}
|
||||
},
|
||||
"GF000312": {
|
||||
"Q0": {"기호": "Q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GF000313": {
|
||||
"Q0": {"기호": "Q", "아래": "0", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"}
|
||||
},
|
||||
"GF000314": {
|
||||
"Q": {"이름": "작업량", "근거": "표 열/행 이름 「작업량」", "확신": "원문"}
|
||||
},
|
||||
"GF000323": {
|
||||
"Q": {"이름": "작업량", "근거": "표 열/행 이름 「작업량」", "확신": "원문"}
|
||||
},
|
||||
"GX000004": {
|
||||
"Q2": {"기호": "Q", "아래": "2", "근거": "열쇠 꼴 ○○+숫자 = 첨자", "확신": "추정"},
|
||||
"K": {"이름": "버킷계수", "근거": "시공능력식 K 표(버킷계수) 준용", "확신": "추정"},
|
||||
"E": {"이름": "작업효율", "근거": "굴착기 작업효율 표(CC000043)", "확신": "추정"},
|
||||
"cm": {"이름": "1회 싸이클시간", "근거": "굴착기 싸이클시간 표(CC000045)", "확신": "추정"},
|
||||
"Q": {"이름": "시간당 작업량", "근거": "로직 GC001147(굴착기 시간당 작업량)", "확신": "원문"}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -25,7 +25,6 @@ mcut = importlib.import_module("master_cut")
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
meq = importlib.import_module("master_equation")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
KEYS = ("노무비", "재료비", "경비", "계")
|
||||
SEEN = "보임"
|
||||
@@ -152,7 +151,8 @@ def level(old, new, money: bool) -> str | None:
|
||||
|
||||
def adopted(key: str, label: str, lv: str) -> bool:
|
||||
"""채택된 차이(요구 714-3 · 빌더 `ADOPTED`) — 합계는 그 목록만 · 줄 비목은 같은 까닭
|
||||
(식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만."""
|
||||
(식 속 단가산출 부름 = 끝수 뒤 값)이 있는 문서만 · 빌더는 855-E L4 에서 은퇴(옛 대조 몫 — 부를 때만 읽음)."""
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
if lv == "L0":
|
||||
return (key, label) in build.ADOPTED
|
||||
return lv == "L1" and build._uses_raw_sub(world()[2][key])
|
||||
|
||||
@@ -1,200 +0,0 @@
|
||||
"""796-3 변수 국문 이름 · 기호 · 첨자 · 단위 기본값 지킴 (요구 659-2 · 656-4).
|
||||
|
||||
① 빌더(`build_변수표_796_3.py`) — 정본에서 변수표를 걷은 상태에 돌리면 결정 자료 그대로 채움 · 채운 뒤 또 돌리면 쓸 것 없음.
|
||||
② 변수표 열쇠 = 엔진 변수(입력 · 중간 이름) · 한 로직 안 기호(첨자 포함) · 이름 겹침 0.
|
||||
③ 보이기만 — 변수표 · 채운 단위를 걷어도 엔진 셈 · 끝수 지문 같음(결정 줄 전부).
|
||||
④ 표본 — GC001147(굴착기 8-2-3) · GC001140(인력운반 1-2-7) · GC001144(불도저 8-2-1) 기호 · 단위 = 품셈 원문 「여기서」.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
import re
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
meq = importlib.import_module("master_equation")
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
ma = importlib.import_module("master_auto")
|
||||
build = importlib.import_module("build_변수표_796_3")
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
BOOK = ROOT / "resources/knowledge/original/원가계산/건설공사_표준품셈/본문/01_공통부문"
|
||||
SIGN = re.compile(r"^[^\W\d_]\w{0,9}$") # master_equation_edit.SIGN_FORM 과 같게
|
||||
SUB = re.compile(r"^[\w′'*]{1,6}$")
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def loaded():
|
||||
return store.loaded()
|
||||
|
||||
|
||||
def logic_rows() -> list[dict]:
|
||||
return [r for d in loaded()[0].values() if d.get("그룹") == "로직" for r in d.get("줄", [])]
|
||||
|
||||
|
||||
def raw_state() -> dict[str, dict]:
|
||||
"""변수표를 걷고 결정 줄의 채운 단위를 걷은 사본(= 채우기 전) — 파일 이름 → 자료."""
|
||||
want = build.decisions()
|
||||
out = {}
|
||||
for name, data in loaded()[0].items():
|
||||
if data.get("그룹") != "로직":
|
||||
out[name] = data
|
||||
continue
|
||||
data = copy.deepcopy(data)
|
||||
for row in data["줄"]:
|
||||
row.pop(meq.FIELD, None)
|
||||
for key, one in (want.get(row["키"]) or {}).items():
|
||||
if not one.get("단위"):
|
||||
continue
|
||||
for kind in ("입력", "중간"):
|
||||
for spec in row.get(kind) or []:
|
||||
if spec["이름"] == key and spec.get("단위") == one["단위"]:
|
||||
spec.pop("단위")
|
||||
out[name] = data
|
||||
return out
|
||||
|
||||
|
||||
def test_결정_자료_꼴():
|
||||
want = build.decisions()
|
||||
assert len(want) >= 150
|
||||
names = {r["키"]: {s["이름"] for k in ("입력", "중간") for s in r[k]} for r in logic_rows()}
|
||||
n = 0
|
||||
for code, one in want.items():
|
||||
assert code in names, code
|
||||
for key, e in one.items():
|
||||
n += 1
|
||||
assert key in names[code], (code, key)
|
||||
assert e["확신"] in ("원문", "추정"), (code, key)
|
||||
assert e.get("근거"), (code, key)
|
||||
assert len(e.get("이름", "")) <= 40
|
||||
if e.get("기호"):
|
||||
assert SIGN.match(e["기호"]), (code, key)
|
||||
for f in ("위", "아래"):
|
||||
assert not e.get(f) or SUB.match(e[f]), (code, key, f)
|
||||
assert "원" not in e.get("단위", ""), (
|
||||
code,
|
||||
key,
|
||||
) # 엔진이 「원」 단위를 금액 입력으로 봄
|
||||
assert any(e.get(f) for f in ("이름", "기호", "아래", "위", "단위")), (code, key)
|
||||
assert n >= 500
|
||||
|
||||
|
||||
def test_빌더_채움_그리고_또_돌리면_쓸것_없음():
|
||||
want = build.decisions()
|
||||
batch, stat = build.plan(raw_state(), want) # 채우기 전 → 결정 그대로
|
||||
assert stat["줄"] == len(want) == len(batch and [c for b in batch for c in b["changes"]])
|
||||
assert stat["변수표"] == sum(
|
||||
1 for one in want.values() for e in one.values() if any(e.get(f) for f in build.LOOK)
|
||||
)
|
||||
assert stat["이미있음"] == 0
|
||||
batch2, stat2 = build.plan(loaded()[0], want) # 정본(이미 채움) → 쓸 것 없음
|
||||
assert batch2 == [] and stat2["변수표"] == 0 and stat2["단위"] == 0
|
||||
|
||||
|
||||
def test_변수표_열쇠는_엔진_변수_기호_이름_겹침_0():
|
||||
for r in logic_rows():
|
||||
names = {s["이름"] for k in ("입력", "중간") for s in r[k]}
|
||||
assert set(r.get(meq.FIELD) or {}) <= names, r["키"]
|
||||
seen: dict[str, str] = {}
|
||||
for v in meq.table(r):
|
||||
for word in {meq.token(v), v["이름"]}:
|
||||
assert seen.get(word, v["열쇠"]) == v["열쇠"], (r["키"], word)
|
||||
seen.setdefault(word, v["열쇠"])
|
||||
|
||||
|
||||
def _print(whole, row) -> str:
|
||||
try:
|
||||
raw = mf.run(
|
||||
whole,
|
||||
str(row["키"]),
|
||||
{
|
||||
**ma.values(whole, row),
|
||||
**{k: v for k, v in ma.defaults(whole, row).items() if v is not None},
|
||||
},
|
||||
)
|
||||
text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False)
|
||||
text += json.dumps(
|
||||
mcut.engine(whole, str(row["키"]), raw), default=str, sort_keys=True, ensure_ascii=False
|
||||
)
|
||||
except Exception as e: # 멈춤도 지문
|
||||
text = f"ERR {type(e).__name__} {e}"
|
||||
return hashlib.sha256(text.encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
def test_셈_전후_같음_결정_줄_전부():
|
||||
want = build.decisions()
|
||||
now = loaded()[1]
|
||||
before_files = raw_state()
|
||||
before = mf.Master(before_files)
|
||||
for code in want:
|
||||
row_now = now.logic(code)
|
||||
row_before = before.logic(code)
|
||||
assert meq.FIELD not in row_before
|
||||
assert _print(now, row_now) == _print(before, row_before), code
|
||||
|
||||
|
||||
def _table(code: str) -> dict[str, dict]:
|
||||
return {v["열쇠"]: v for v in meq.table(loaded()[1].logic(code))}
|
||||
|
||||
|
||||
def test_표본_기호_단위_원문_같음():
|
||||
excav = (BOOK / "제08장_건설기계/8-02-03_굴착기.md").read_text(encoding="utf-8")
|
||||
for line in (
|
||||
"q : 버킷용량(㎥)",
|
||||
"E : 작업효율",
|
||||
"K : 버킷계수",
|
||||
"f : 체적환산계수",
|
||||
"cm : 1회 싸이클 시간(초)",
|
||||
):
|
||||
assert line in excav, line
|
||||
t = _table("GC001147")
|
||||
assert (t["버킷용량"]["기호"], t["버킷용량"]["단위"]) == ("q", "㎥")
|
||||
assert (t["K"]["이름"], t["E"]["이름"], t["f"]["이름"]) == (
|
||||
"버킷계수",
|
||||
"작업효율",
|
||||
"체적환산계수",
|
||||
)
|
||||
assert (t["cm"]["이름"], t["cm"]["단위"]) == ("1회 싸이클시간", "sec") # 801-5 원문 표 머리 「싸이클시간(Sec)」 꼴
|
||||
|
||||
carry = (BOOK / "제01장_적용기준/1-02_설계_및_수량.md").read_text(encoding="utf-8")
|
||||
for line in (
|
||||
"T : 1일 실작업시간",
|
||||
"L : 운반거리(m)",
|
||||
"t : 적재적하 시간(분)",
|
||||
"V : 평균왕복속도(m/hr)",
|
||||
"N : 1일 운반횟수",
|
||||
):
|
||||
assert line in carry, line
|
||||
t = _table("GC001140")
|
||||
got = {
|
||||
k: meq.token(t[k])
|
||||
for k in ("운반거리", "실작업시간", "적재적하시간", "평균왕복속도", "일운반회수")
|
||||
}
|
||||
assert got == {
|
||||
"운반거리": "L",
|
||||
"실작업시간": "T",
|
||||
"적재적하시간": "t",
|
||||
"평균왕복속도": "V",
|
||||
"일운반회수": "N",
|
||||
}
|
||||
|
||||
dozer = (BOOK / "제08장_건설기계/8-02-01_불도저.md").read_text(encoding="utf-8")
|
||||
for line in ("V_1 : 전진속도(m/분)", "V_2 : 후진속도(m/분)", "e : 운반거리계수"):
|
||||
assert line in dozer, line
|
||||
t = _table("GC001144")
|
||||
assert (t["V1"]["기호"], t["V1"]["아래"], t["V1"]["이름"]) == ("V", "1", "전진속도")
|
||||
assert (t["V2"]["기호"], t["V2"]["아래"], t["V2"]["이름"]) == ("V", "2", "후진속도")
|
||||
assert meq.token(t["V1"]) == "V_1" and t["e"]["이름"] == "운반거리계수"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-q"])
|
||||
@@ -1,213 +0,0 @@
|
||||
"""800-1 변수 기호 기본값 지킴 (요구 660-1 · 659-2) — 수식 탭 왼쪽 식에 한글 변수가 안 보임.
|
||||
|
||||
① 규칙(`master_symbol.rule`) 표본 — 끝말 → 머리글자 · 아래첨자 · 갈래별(찾기 위 「표」 · 요소 · 합 · 결과).
|
||||
② 입력 · 중간 변수 — 기호에 한글 0 · 한 로직 안 겹침 0 · 같은 이름 같은 기호(원문 796-3 제외).
|
||||
(한글 0 · 겹침 0 = 기본 로직 차례 고르게 600 · 전수 = `AISLO_TEST_ALL=1`)
|
||||
③ 빌더 — 채운 정본에 쓸 것 없음 · 채운 것을 걷으면 같은 수만큼 다시 채움.
|
||||
④ 수식 내보내기 — 표본 로직 전 변수 기호에 한글 0(찾기 · 요소 · 합 · 결과 포함) · 한 로직 안 겹침 없음.
|
||||
⑤ 보이기만 — 변수표를 걷어도 엔진 셈 · 끝수 지문 같음(금액 전후 같음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import importlib
|
||||
import json
|
||||
import re
|
||||
from functools import lru_cache
|
||||
|
||||
import pytest
|
||||
from helper_test_all import spread
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
meq = importlib.import_module("master_equation")
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
ma = importlib.import_module("master_auto")
|
||||
sym = importlib.import_module("master_symbol")
|
||||
build = importlib.import_module("build_변수기호_800_1")
|
||||
build796 = importlib.import_module("build_변수표_796_3")
|
||||
|
||||
HAN = re.compile(r"[가-힣]")
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def loaded():
|
||||
return store.loaded()
|
||||
|
||||
|
||||
def logic_rows() -> list[dict]:
|
||||
return [r for d in loaded()[0].values() if d.get("그룹") == "로직" for r in d.get("줄", [])]
|
||||
|
||||
|
||||
def test_규칙_표본():
|
||||
rule = sym.rule
|
||||
assert rule("합판율")[:3] == ("r", "합판", "")
|
||||
assert rule("사용횟수")[:3] == ("n", "사용", "")
|
||||
assert rule("지형계수")[:3] == ("k", "지형", "")
|
||||
assert rule("작업효율")[:3] == ("E", "작업", "")
|
||||
assert rule("운반거리")[:3] == ("L", "운반", "")
|
||||
assert rule("교량받침중량")[:3] == ("W", "교량받침", "") # 「량」 보다 「중량」 먼저
|
||||
assert rule("버킷용량")[:3] == ("q", "버킷", "")
|
||||
assert rule("보통인부")[:3] == ("Q", "보통인부", "")
|
||||
assert rule("지역")[:3] == ("S", "지역", "") # 고르는 말
|
||||
assert rule("E입력")[:3] == ("E", "입력", "") # 앞 영문 = 기호
|
||||
assert rule("폼타이", hint="고름")[0] == "S" and rule("구멍땜")[0] == "X"
|
||||
assert rule("시공량", "찾기")[:3] == ("Q", "시공", "표") # 표 칸 = 위 「표」
|
||||
assert rule("보통인부노임", "요소")[:3] == ("w", "보통인부", "")
|
||||
assert rule("합판단가", "요소")[:3] == ("P", "합판", "")
|
||||
assert rule("형틀목공", "합")[:3] == ("C", "형틀목공", "")
|
||||
assert rule("원/㎡", "결과")[:3] == ("P", "", "") and rule("㎥/hr", "결과")[:3] == ("Q", "", "")
|
||||
assert sym.short("폼타이 12.7㎜") == "폼타이127" and len(sym.short("플랜트기계설치공")) <= 6
|
||||
assert sym.is_symbol("K") and sym.is_symbol("V_1") and not sym.is_symbol("합판율")
|
||||
|
||||
|
||||
def test_기호에_한글_0_한_로직_겹침_0():
|
||||
for r in spread(logic_rows(), 600):
|
||||
seen: dict[str, str] = {}
|
||||
for v in meq.table(r):
|
||||
assert not HAN.search(v["기호"]), (r["키"], v["열쇠"], v["기호"])
|
||||
for word in {meq.token(v), v["이름"]}:
|
||||
assert seen.get(word, v["열쇠"]) == v["열쇠"], (r["키"], word)
|
||||
seen.setdefault(word, v["열쇠"])
|
||||
|
||||
|
||||
def test_같은_이름_같은_기호():
|
||||
orig = build796.decisions()
|
||||
got: dict[str, set[str]] = {}
|
||||
for r in logic_rows():
|
||||
for key, look in (r.get(meq.FIELD) or {}).items():
|
||||
if (orig.get(r["키"]) or {}).get(key, {}).get("기호") or not look.get("기호"):
|
||||
continue # 원문 · 추정(796-3) · 기호 없음
|
||||
if HAN.search(key) or not sym.is_symbol(key):
|
||||
got.setdefault(key, set()).add(look["기호"])
|
||||
rules = {sym.rule(key, "변수", h)[:2] for h in ("", "고름", "중간")}
|
||||
assert look["기호"] in {a for a, _ in rules}, (r["키"], key)
|
||||
assert any(look.get("아래", "").startswith(b[:4]) for _, b in rules), (r["키"], key)
|
||||
assert len(got) >= 1000
|
||||
assert all(len(v) == 1 for v in got.values())
|
||||
|
||||
|
||||
def test_빌더_쓸것_없음_그리고_걷으면_다시_채움():
|
||||
batch, stat = build.plan(loaded()[0])
|
||||
assert batch == [] and stat["변수"] == 0
|
||||
orig, files, cut = build796.decisions(), copy.deepcopy(loaded()[0]), 0
|
||||
for data in files.values():
|
||||
if data.get("그룹") != "로직":
|
||||
continue
|
||||
for r in data["줄"]:
|
||||
for key in list((r.get(meq.FIELD) or {}).keys()):
|
||||
if not (orig.get(r["키"]) or {}).get(key, {}).get("기호"):
|
||||
look = r[meq.FIELD][key]
|
||||
if look.get("기호") and not set(look) - {"기호", "아래", "위"}:
|
||||
del r[meq.FIELD][key]
|
||||
cut += 1
|
||||
_, again = build.plan(files)
|
||||
assert cut >= 6000 and again["변수"] == cut
|
||||
|
||||
|
||||
def _words(tree, out: list) -> None:
|
||||
if isinstance(tree, dict):
|
||||
if tree.get("꼴") == "변수":
|
||||
out.append(tree)
|
||||
for v in tree.values():
|
||||
_words(v, out)
|
||||
elif isinstance(tree, list):
|
||||
for v in tree:
|
||||
_words(v, out)
|
||||
|
||||
|
||||
SAMPLE = ("GC000211", "GF000089", "GC001147", "GC001140", "GC001144", "GC000087", "GC000303")
|
||||
|
||||
|
||||
def test_수식_내보내기_표본_한글_기호_0():
|
||||
whole = loaded()[1]
|
||||
rows = [r["키"] for r in logic_rows()]
|
||||
for code in (*SAMPLE, *rows[::60]):
|
||||
eq = meq.export(whole, str(code))
|
||||
found: list[dict] = []
|
||||
_words(eq["줄"], found)
|
||||
_words(eq["풀이"], found)
|
||||
assert found, code
|
||||
for v in found:
|
||||
assert not HAN.search(v.get("기호") or v.get("열쇠") or ""), (
|
||||
code,
|
||||
v["갈래"],
|
||||
v["열쇠"],
|
||||
)
|
||||
|
||||
|
||||
def test_합판거푸집_표본_글():
|
||||
eq = meq.export(loaded()[1], "GC000211")
|
||||
head = {x["열쇠"]: x for x in eq["줄"]}
|
||||
tok = lambda n: sym._text(n["기호"], n.get("아래", ""), n.get("위", "")) # noqa: E731
|
||||
assert tok(head["합판율"]["결과"]) == "r_합판"
|
||||
found: list[dict] = []
|
||||
_words(head["합판율"]["이름식"], found)
|
||||
assert {tok(v) for v in found} >= {"n_사용", "Q_합판^표"}
|
||||
tokens = []
|
||||
_words(eq["줄"], found := [])
|
||||
tokens = {tok(v) for v in found}
|
||||
assert {"Q_시공", "Q_시공^표", "w_형틀목공", "C_형틀목공", "P_합판", "S_폼타이"} <= tokens
|
||||
|
||||
|
||||
def test_한_로직_안_다른_이름_같은_글이면_숫자():
|
||||
out = {
|
||||
"결과단위": "원/㎡",
|
||||
"변수표": [],
|
||||
"줄": [
|
||||
{
|
||||
"갈래": "호표",
|
||||
"결과": {
|
||||
"꼴": "변수",
|
||||
"갈래": "합",
|
||||
"열쇠": n,
|
||||
"이름": n,
|
||||
"기호": n,
|
||||
"아래": "",
|
||||
"위": "",
|
||||
},
|
||||
}
|
||||
for n in ("공기압축기 21㎥/min", "공기압축기 10.5㎥/min", "공기압축기 21㎥/min")
|
||||
],
|
||||
}
|
||||
sym.apply(out)
|
||||
got = [meq.token(x["결과"]) for x in out["줄"]]
|
||||
assert got == ["C_공기압축기", "C_공기압축기2", "C_공기압축기"]
|
||||
|
||||
|
||||
def _print(whole, row) -> str:
|
||||
try:
|
||||
raw = mf.run(
|
||||
whole,
|
||||
str(row["키"]),
|
||||
{
|
||||
**ma.values(whole, row),
|
||||
**{k: v for k, v in ma.defaults(whole, row).items() if v is not None},
|
||||
},
|
||||
)
|
||||
text = json.dumps(raw, default=str, sort_keys=True, ensure_ascii=False)
|
||||
text += json.dumps(
|
||||
mcut.engine(whole, str(row["키"]), raw), default=str, sort_keys=True, ensure_ascii=False
|
||||
)
|
||||
except Exception as e: # 멈춤도 지문
|
||||
text = f"ERR {type(e).__name__} {e}"
|
||||
return hashlib.sha256(text.encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
def test_셈_전후_같음_변수표_걷어도():
|
||||
now = loaded()[1]
|
||||
files = copy.deepcopy(loaded()[0])
|
||||
for data in files.values():
|
||||
if data.get("그룹") == "로직":
|
||||
for row in data["줄"]:
|
||||
row.pop(meq.FIELD, None)
|
||||
before = mf.Master(files)
|
||||
for code in [r["키"] for r in logic_rows()][::6]:
|
||||
assert _print(now, now.logic(code)) == _print(before, before.logic(code)), code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-q"])
|
||||
@@ -1,118 +0,0 @@
|
||||
"""801-5 M01 로직 단위 글 = 건설품셈 원문 꼴(요구 663-2) 지킴 — 글만 바꿈 · 금액 그대로.
|
||||
|
||||
① 대응표 근거 — 규칙마다 근거 절 파일이 있고 그 안에 원문 글이 실제로 있음(+ 지금 글은 같은 꼴로 안 쓰임)
|
||||
② 섞임 0 — M01 로직 입력 · 중간 · 결과단위가 원문 꼴로 다 바뀌어 있음(규칙이 더 바꿀 것 없음 · 두 번 돌려도 같음)
|
||||
③ 금액 같음 — 변수 단위 글을 지워도 엔진 셈 · 끝수 지문이 같음(단위 글은 셈에 안 듦)
|
||||
④ M02 사본 도구 — 같은 규칙으로 사본 줄 단위만 바뀌고 `판` 다시 셈
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import importlib
|
||||
import re
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
ut = importlib.import_module("master_unit_text")
|
||||
mf = importlib.import_module("master_formula")
|
||||
build = importlib.import_module("build_단위표기_801_5")
|
||||
|
||||
|
||||
def _rows():
|
||||
for data in store.loaded()[0].values():
|
||||
if data.get("그룹") == "로직":
|
||||
yield from data["줄"]
|
||||
|
||||
|
||||
def test_대응표_근거_절에_원문_글이_있음():
|
||||
assert len(ut.RULES) >= 7
|
||||
for name, _, to, token, files in ut.RULES:
|
||||
assert files and to == token, name
|
||||
for rel in files:
|
||||
path = ut.EVIDENCE_ROOT / rel
|
||||
assert path.is_file(), (name, rel)
|
||||
assert token in path.read_text(encoding="utf-8"), (name, rel)
|
||||
|
||||
|
||||
def test_규칙_예():
|
||||
got = {
|
||||
u: ut.canon(u)
|
||||
for u in ("㎥/시간", "㎡/시간", "㎢/시간", "원/시간", "초", "초/m", "mm", "TON/㎡")
|
||||
}
|
||||
assert got == {
|
||||
"㎥/시간": "㎥/hr",
|
||||
"㎡/시간": "㎡/hr",
|
||||
"㎢/시간": "㎢/시간", # 원문 9-5-4 가 쓰는 꼴 — 안 건드림
|
||||
"원/시간": "원/시간",
|
||||
"초": "sec",
|
||||
"초/m": "sec/m",
|
||||
"mm": "㎜",
|
||||
"TON/㎡": "ton/㎡",
|
||||
}
|
||||
for u in got.values():
|
||||
assert ut.canon(u) == u # 두 번 돌려도 같음
|
||||
|
||||
|
||||
def test_섞임_0_원문_꼴로_다_바뀜():
|
||||
left = []
|
||||
for row in _rows():
|
||||
units = [row.get("결과단위")] + [
|
||||
s.get("단위") for k in ("입력", "중간") for s in row.get(k) or []
|
||||
]
|
||||
left += [(row["키"], u) for u in units if u and ut.canon(u) != u]
|
||||
assert not left, left[:5]
|
||||
|
||||
|
||||
def test_굴착기_Cm_sec_Q_hr():
|
||||
row = store.loaded()[1].logic("GF000088") # 토사깍기(굴착기 0.7㎥) 시간당 작업량
|
||||
assert {s["단위"] for s in row["중간"] if s["이름"] == "Cm"} == {"sec"}
|
||||
assert row["결과단위"] == "㎥/hr"
|
||||
|
||||
|
||||
_OLD = ( # 원문 꼴 → 옛 글(되돌려 본 꼴) — 두 꼴로 셈이 같음을 대조
|
||||
(re.compile(r"(?<![가-힣A-Za-z])sec(?![A-Za-z])"), "초"),
|
||||
(re.compile(r"(?<=[㎥㎡])/hr"), "/시간"),
|
||||
(re.compile("㎜"), "mm"),
|
||||
(re.compile("㎝"), "cm"),
|
||||
(re.compile("㎏"), "kg"),
|
||||
(re.compile("㎞/hr"), "km/hr"),
|
||||
)
|
||||
|
||||
|
||||
def _legacy(text: str) -> str:
|
||||
for pat, old in _OLD:
|
||||
text = pat.sub(old, text)
|
||||
return text
|
||||
|
||||
|
||||
def test_금액_같음_옛_글로_되돌려도_셈_지문_같음():
|
||||
files = store.loaded()[0]
|
||||
old = copy.deepcopy(files)
|
||||
for data in old.values():
|
||||
if data.get("그룹") == "로직":
|
||||
for row in data["줄"]:
|
||||
for k in ("입력", "중간"):
|
||||
for s in row.get(k) or []:
|
||||
s["단위"] = _legacy(s.get("단위") or "")
|
||||
row["결과단위"] = _legacy(row.get("결과단위") or "")
|
||||
now, was = mf.Master(files), mf.Master(old)
|
||||
keys = [r["키"] for r in _rows()]
|
||||
hit = {
|
||||
r["키"]
|
||||
for r in _rows()
|
||||
if any(
|
||||
_legacy(s.get("단위") or "") != (s.get("단위") or "")
|
||||
for k in ("입력", "중간")
|
||||
for s in r.get(k) or []
|
||||
)
|
||||
}
|
||||
assert len(hit) >= 40
|
||||
for key in sorted(hit) + keys[::25]:
|
||||
assert build.fingerprint(now, now.logic(key)) == build.fingerprint(was, was.logic(key)), key
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-q"])
|
||||
@@ -1,120 +0,0 @@
|
||||
"""802-2 옛 M01 로직 → 수식 문서 변환 · 금액 전수 대조 지킴 시험.
|
||||
|
||||
빌더 `resources/master_data/scripts/build_수식문서_802_2.py`(한 번 돌림 · 2 분 안팎):
|
||||
① --check — 다시 돌린 결과 = 저장본(`resources/master_data/수식문서/`) · 목록 xlsx.
|
||||
② 로직 1,519 전수 기본 옵션 = 옛 엔진 노 · 재 · 경 · 계(결과) 원 단위 같음.
|
||||
③ 옵션 표본 — 로직마다 고르기 입력의 모든 갈래 한 번 이상 · 같음 수 · 다름 = 목록 · 까닭 모름 0.
|
||||
④ 저장 = 같은 것만(부르는 단가산출까지 · 채택된 차이 GC000100 지역=경북 재료비 1 원 빼고) · 저장본을 읽어 다시 셈해도 같음.
|
||||
⑤ 791 실무 손 옮김 견본 넷(번지 · 단계 · 합밖 · 줄 자리 · 끝전 · 조정 · 값묶음)도 변환 셈 = 엑셀 금액.
|
||||
"""
|
||||
|
||||
import importlib
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
cv = importlib.import_module("master_doc_convert")
|
||||
mf = importlib.import_module("master_formula")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def result():
|
||||
return build.build(log=lambda *a: None)
|
||||
|
||||
|
||||
def test_빌더_check_저장본_목록_같음(result):
|
||||
assert build.lost(result) == [] # 저장본 문서를 조용히 빼지 않음(842-3 뒤 · 빌더가 멈추고 알림)
|
||||
assert build.check(result) == []
|
||||
|
||||
|
||||
def test_로직_전수_기본_옵션_같음(result):
|
||||
files, _ = m01.loaded()
|
||||
count = sum(len(d.get("줄") or []) for d in files.values() if d.get("그룹") == "로직")
|
||||
info = result["요약"]
|
||||
assert info["로직"] == count >= 1513 # 813-2 지움 6
|
||||
assert info["기본 같음"] == count and info["기본 다름"] == 0
|
||||
assert info["변환 알림"] == 0
|
||||
|
||||
|
||||
def test_옵션_표본_모든_갈래_한_번_이상(result):
|
||||
files, _ = m01.loaded()
|
||||
seen = {(x["로직"], x["옵션"]) for x in result["대조"] if x["옵션"]}
|
||||
want = 0
|
||||
for _, row in build.rows_of(files):
|
||||
base = build.meq.given_of(_whole(), row)
|
||||
for spec in row.get("입력") or []:
|
||||
for opt in spec.get("고르기") or []:
|
||||
if str(opt) != str(base.get(spec["이름"])):
|
||||
want += 1
|
||||
assert (row["키"], f"{spec['이름']}={opt}") in seen
|
||||
info = result["요약"]
|
||||
assert info["옵션 표본"] == want == info["옵션 같음"] + info["옵션 다름"]
|
||||
assert (
|
||||
info["옵션 같음"] >= 18400 and info["옵션 다름"] == info["채택된 차이"] == 3
|
||||
) # 813-2: 지운 6 문서 표본 빠져 18,438 · 840-5 조종원 환산 뒤 채택 셋
|
||||
|
||||
|
||||
def _whole():
|
||||
return m01.loaded()[1]
|
||||
|
||||
|
||||
def test_다름_목록_까닭(result):
|
||||
rows = build.table_rows(result)
|
||||
sheet = build.read_list()["다름"]
|
||||
assert sheet[0] == list(build.HEAD) and sheet[1:] == rows
|
||||
diff = [x for x in result["대조"] if not x["같음"]]
|
||||
assert all(x["까닭"] != "까닭 모름" for x in diff)
|
||||
# 채택된 차이(요구 714-3) — 식 속 단가산출 부름 값 = 끝수 뒤 · 재료비 1 원 · 저장은 함
|
||||
assert [(x["로직"], x["옵션"], x["채택"]) for x in diff] == [
|
||||
("GC000091", "지역=울산", True),
|
||||
("GC000093", "지역=경북", True),
|
||||
("GC000100", "지역=전북", True),
|
||||
] # 840-5 조종원 1/8 × 16/12 × 25/20 뒤 — 같은 까닭 1 원 셋(옛 GC000100 경북 = 같아짐)
|
||||
assert diff[0]["까닭"].startswith(build.RAW_SUB)
|
||||
assert diff[0]["옛"]["재료비"] != diff[0]["새"]["재료비"]
|
||||
assert abs(diff[0]["새"]["재료비"] - diff[0]["옛"]["재료비"]) == 1
|
||||
assert {k: diff[0]["옛"][k] for k in ("노무비", "경비")} == {
|
||||
k: diff[0]["새"][k] for k in ("노무비", "경비")
|
||||
}
|
||||
|
||||
|
||||
def test_저장_같은_것만_다시_셈(result):
|
||||
saved = ml.load_all()
|
||||
assert set(saved) == result["저장"]
|
||||
assert "GC000100" in saved and len(saved) == result["요약"]["저장"] >= 1513
|
||||
base = next(x for x in result["대조"] if x["로직"] == "GC000100" and not x["옵션"])
|
||||
assert (
|
||||
base["같음"]
|
||||
and build.new_answer(ml.Links(_whole(), saved), saved["GC000100"]) == base["옛"]
|
||||
)
|
||||
for key in ("GC000211", "GC001147", "GF000294", "GC000087"):
|
||||
doc = saved[key]
|
||||
got = build.new_answer(ml.Links(_whole(), saved), doc)
|
||||
old = next(x for x in result["대조"] if x["로직"] == key and not x["옵션"])["옛"]
|
||||
assert got == old
|
||||
|
||||
|
||||
# ── ⑤ 791 실무 견본 ────────────────────────────────────────────────────
|
||||
def _semantics():
|
||||
sys.path.insert(0, str(HERE))
|
||||
return importlib.import_module("test_791_1_engine_semantics")
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", ["봉화", "소광", "영월", "임도"])
|
||||
def test_791_실무_견본_변환_셈_같음(name):
|
||||
t = _semantics()
|
||||
master, row, want = getattr(t, name)()
|
||||
old = mcut.engine(master, row["키"], mf.run(master, row["키"], {}))
|
||||
doc, notes = cv.convert(master, row, {})
|
||||
got = mc.calc(doc, ml.Links(master, {row["키"]: doc}))
|
||||
assert got["셈됨"], got["표지"]
|
||||
assert {k: got[k] for k in want} == {k: old[k] for k in want} == want
|
||||
assert not [x for x in notes if not x.startswith("기호")]
|
||||
@@ -198,30 +198,3 @@ def test_표_하나(client):
|
||||
table = client.get("/api/m01/logic/doc/table", params={"key": "QF000249"}).json()
|
||||
assert "조건" in table and table["줄"]
|
||||
assert "끊김" in client.get("/api/m01/logic/doc/table", params={"key": "LB000002"}).json()
|
||||
|
||||
|
||||
def test_옮김_군더더기_없음():
|
||||
"""저장 문서 식 · 금액 글에 `+ 0` · `× 1` · `÷ 1` · `× k ÷ 100` 없음(옮김 `slim` · 값 같음)."""
|
||||
import master_doc as md
|
||||
import master_doc_convert as cv
|
||||
import master_doc_link as ml
|
||||
|
||||
def junk(n) -> bool:
|
||||
if n[0] == "bin":
|
||||
a, b = n[2], n[3]
|
||||
if n[1] in ("+", "-", "*", "/") and cv.slim(n) != n:
|
||||
return True
|
||||
return junk(a) or junk(b)
|
||||
if n[0] in ("neg", "pct", "field"):
|
||||
return junk(n[1])
|
||||
return n[0] == "call" and any(junk(x) for x in n[2])
|
||||
|
||||
bad = []
|
||||
for key, doc in ml.load_all().items():
|
||||
texts = [x.get("식") for x in doc.get("식") or []]
|
||||
texts += [x.get(k) for x in doc.get("금액") or [] for k in ("수량", "단가")]
|
||||
for t in texts:
|
||||
if t and junk(md.parse(t)):
|
||||
bad.append((key, t))
|
||||
assert not bad, bad[:5]
|
||||
assert md.text_of(cv.slim(md.parse("(r + 0) × 1 × 2 ÷ 100 ÷ 1"))) == "r × 2%"
|
||||
|
||||
@@ -170,12 +170,6 @@ def test_요소키_기호_이름_0_전수() -> None:
|
||||
assert bad == []
|
||||
ids = {doc_screen.md.var_id(v) for v in docs["GF000011"]["변수"]}
|
||||
assert {"k_하베스터", "P_하베스터", "k_굴착기", "P_굴착기"} <= ids
|
||||
import master_doc_convert as cv
|
||||
|
||||
whole = store.loaded()[1]
|
||||
for key in ("GF000011", "GF000145", "GC001043"):
|
||||
got, _ = cv.convert(whole, store.logic(key)["logic"])
|
||||
assert not [v for v in got["변수"] if CODE.match(str(v.get("아래") or ""))], key
|
||||
|
||||
|
||||
def test_단위_고르기_공용_친글() -> None:
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
"""848-4 기계 한 대 = 줄 하나 — 조합 줄 나눔 금액 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸 · 빌더가 모르는 문서 지킴.
|
||||
"""848-4 기계 한 대 = 줄 하나 — 조합 줄 나눔 금액 · 부착 줄 따름 · 묶음 끝수 · 버킷계수 직접 칸.
|
||||
|
||||
① 216 짝(굴착기 × 집게 · 브레이커 × 보정작업) — 부착 조합 굴착기 식(GC001202) + 부착 손료(GC000273) = 옛 조합 식
|
||||
(GC000270 · 271) 노 · 재 · 경 같음(8-4 주⑤ 잡재료 16 % 가 식 안).
|
||||
@@ -6,7 +6,6 @@
|
||||
③ 부착 줄 수량 = 주 기계 줄 수량 — 주 줄을 시간당으로 · 변수 고침 · 되돌림에 같이 · 부착 줄 고침은 안 걸림 ·
|
||||
저장 정리에서 지움 · 답 꼴 「따름」.
|
||||
④ 굴착기 작업량 식 `K입력` — 넣으면 그 값 · 0 = 표(버킷조건).
|
||||
⑤ 빌더 — 옛 로직 줄 없는 저장본 문서(자체 로직 · 화면에서 만든 문서)를 안 지우고 제 파일 그대로 · 빠짐 목록에 안 듦.
|
||||
⑥ 불러오기 조합 첫 줄 = 부착 조합 굴착기 식 · 기계 식 고름은 GC001202 를 안 고름.
|
||||
⑦ 거울 — 부착 줄 따름 · 묶음 끝수를 파이썬 · TS 가 같게.
|
||||
"""
|
||||
@@ -15,7 +14,6 @@ import importlib
|
||||
import itertools
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
from decimal import Decimal as D
|
||||
|
||||
@@ -31,7 +29,6 @@ mw = importlib.import_module("master_doc_work")
|
||||
mcut = importlib.import_module("master_cut")
|
||||
mf = importlib.import_module("master_formula")
|
||||
meq = importlib.import_module("master_equation")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
@@ -153,49 +150,6 @@ def test_버킷계수_직접_칸(links):
|
||||
assert mc.calc(tpl, links, {"K입력": 0})["결과"] == base["결과"]
|
||||
|
||||
|
||||
# ── ⑤ 빌더가 모르는 문서 ───────────────────────────────────────────────
|
||||
@pytest.fixture
|
||||
def docs_tmp(tmp_path, monkeypatch):
|
||||
dst = tmp_path / "수식문서"
|
||||
dst.mkdir()
|
||||
name = "로직_건설품셈_08장_건설기계.json"
|
||||
shutil.copy(ml.FOLDER / ml.file_of(name), dst)
|
||||
shutil.copy(ml.FOLDER / "수식_자체.json", dst)
|
||||
monkeypatch.setattr(ml, "FOLDER", dst)
|
||||
return dst, name
|
||||
|
||||
|
||||
def test_빌더_모르는_문서_안_지움_그대로(docs_tmp):
|
||||
dst, name = docs_tmp
|
||||
files, whole = m01.loaded()
|
||||
rows = files[name]["줄"]
|
||||
own = dst / "수식_자체.json"
|
||||
data = ml.load_file(own)
|
||||
data["줄"].append(ml._norm({**data["줄"][0], "키": "GX999999", "이름": "sub2임시 화면 자체"}))
|
||||
own.write_text(ml.dump(data), encoding="utf-8", newline="\n")
|
||||
loose = dst / "수식_손.json" # 빌더 모르는 파일
|
||||
loose.write_text(ml.dump({"그룹": "수식문서", "로직파일": "", "줄": [{**data["줄"][0], "키": "GX999998"}]}),
|
||||
encoding="utf-8", newline="\n") # fmt: skip
|
||||
before = {p.name: p.read_text(encoding="utf-8") for p in dst.iterdir()}
|
||||
keys = [str(r["키"]) for r in rows]
|
||||
result = {
|
||||
"문서": {str(r["키"]): build.cv.convert(whole, r)[0] for r in rows},
|
||||
"파일": {name: keys},
|
||||
"저장": set(keys),
|
||||
"저장본": build.carried(),
|
||||
"대조": [],
|
||||
"알림": {},
|
||||
"요약": {},
|
||||
}
|
||||
want = build.files_of(result)
|
||||
assert want["수식_손.json"] == before["수식_손.json"]
|
||||
assert want["수식_자체.json"] == before["수식_자체.json"] # GX 자체 문서 · 화면 문서 그대로
|
||||
assert want[ml.file_of(name)] == before[ml.file_of(name)]
|
||||
assert build.lost(result) == []
|
||||
assert {"GX000004", "GX999999", "GX999998"} <= set(build.foreign_keys(result))
|
||||
assert [x for x in build.check(result) if not x.startswith("다른 목록")] == []
|
||||
|
||||
|
||||
# ── ⑥ 불러오기 조합 · 기계 식 고름 ────────────────────────────────────
|
||||
def test_불러오기_조합_첫_줄_부착_조합_식(monkeypatch):
|
||||
from M02_MasterTemplete import M02_Machine_Hourly as mh
|
||||
|
||||
@@ -1,74 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""PLAN 8-3 — 로직 재료 줄 키 → 기본 검색어 바꿔 넣기(`build_재료_검색어.py`)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
sys.path.insert(0, str(ROOT / "resources/master_data/scripts"))
|
||||
|
||||
import build_재료_검색어 as bw # noqa: E402
|
||||
import check_master as cm # noqa: E402
|
||||
import master_auto as mau # noqa: E402
|
||||
import master_formula as mf # noqa: E402
|
||||
import master_pick as mp # noqa: E402
|
||||
|
||||
|
||||
@pytest.fixture(scope="module")
|
||||
def master() -> mf.Master:
|
||||
return mf.Master(cm.load())
|
||||
|
||||
|
||||
def _material(master, key: str, name: str) -> dict:
|
||||
return next(h for h in master.logic(key)["호표"] if h.get("이름") == name)
|
||||
|
||||
|
||||
def test_결속선은_원문대로_고른_어닐링철선이_그대로_첫째(master) -> None:
|
||||
item = _material(master, "GC000037", "결속선 # 10")
|
||||
assert "대표" not in item["요소"] and item["요소"]["검색어"].startswith("어닐링철선")
|
||||
row = master.logic("GC000037")
|
||||
got = mp.search(master, item["요소"], mau.values(master, row), item["단위"])
|
||||
assert got[0] == "MT000204" # 어닐링철선 #10 서울 — 옛 입력 「결속선」 목록 첫째
|
||||
|
||||
|
||||
def test_재료_입력_키_목록은_걷히고_넘기던_인자도_없음(master) -> None:
|
||||
for name, data in cm.load().items():
|
||||
if not name.startswith("로직_"):
|
||||
continue
|
||||
for row in data["줄"]:
|
||||
assert not bw.material_inputs(row), row["키"]
|
||||
call = next(h["요소"] for h in master.logic("GF000169")["호표"] if "GF000160" in h["요소"])
|
||||
assert "횟수=" in call and "철선=철선" not in call and "합판=합판" not in call
|
||||
|
||||
|
||||
def test_남은_대표는_값_빈_자리표_품목만(master) -> None:
|
||||
"""검색어로 못 가르는 줄(규격 빈 자리표 MT030…)만 대표가 남음 — 목록으로 알린 줄."""
|
||||
reps = {
|
||||
str(h["요소"]["대표"])
|
||||
for data in cm.load().values()
|
||||
for row in data.get("줄", [])
|
||||
if "호표" in row
|
||||
for h in row["호표"]
|
||||
if isinstance(h.get("요소"), dict) and h["요소"].get("대표")
|
||||
}
|
||||
assert reps and all(k.startswith("MT0306") for k in reps), reps
|
||||
|
||||
|
||||
def test_글_갈음은_바뀐_값_자리만(master) -> None:
|
||||
text = (
|
||||
'{ "키": "GX1", "입력": [\n { "이름": "철선", "고르기": ["MT000199"] },\n'
|
||||
' { "이름": "횟수", "고르기": ["1회"] }\n],\n "호표": [\n'
|
||||
' { "종류": "재료", "요소": {"구분": "철근·강재", "대표": "{철선}"}, "수량": "1" },\n'
|
||||
' { "종류": "로직", "요소": "로직(GF000160, 횟수=횟수, 철선=철선)", "수량": "1" }\n] }'
|
||||
)
|
||||
row = json.loads(text)
|
||||
change = {"요소": {0: {"구분": "철근·강재", "검색어": "어닐링철선 #8 서울"}}, "걷음": ["철선"]}
|
||||
got = bw._patch_row(text, row, change)
|
||||
assert json.loads(got) == bw.apply(row, change)
|
||||
assert '"이름": "횟수"' in got and "철선=철선" not in got and "횟수=횟수" in got
|
||||
assert got.count("\n") == text.count("\n") - 1 # 걷은 입력 한 줄만 빠짐
|
||||
Reference in New Issue
Block a user