refactor(855-E L3b ③): 로직 JSON 59 파일 지움 — 기초 = 수식 문서 하나 · 검사 = 문서 검사

- resources/master_data/로직_*.json 59 지움(브레인이 tmp/archive_894 에 보관)
- master_base.GROUPS 「로직」 뺌 · M01 Store.GROUPS = 요소 그룹 + 로직(= 수식 문서 · 화면 그룹 그대로)
- check_master: 로직 틀 · 시험입력 · calc · calc_all · 계산 갈래 걷음 · 「로직」 = 문서 막힘 · 키 겹침 · 대장 ·
  「조합」 = master_doc_block.combo_row · 「단위」 · 「배」 = 문서 대상(전후 27 · 7 건 같음)
- master_combo.check_row · check_all 지움 · master_basis.check_times(files, docs) · master_doc_unit 단가산출 단위 = M01 문서
- build_로직_개정 = 수식 문서 대상(--check 바뀐 파일 0 · 채움 1,257)
- 로직 거름 표지 걷음(Alias · Item_Bundle)
- 시험: 로직 줄 · 로직 파일을 견주던 줄 → 문서(712_3 · 713_1 · 794_2b · 813_2 · 821_4 · 826_2 · 843 · 845_1 · 848_5 · 855_l1 ·
  m01_api · masterdata_check 견본 · 단위) · 지운 함수 시험(시험입력 · calc_all) 지움 · 813_2 변환기 시험 지움
- 서버 답 243 건 다름 0 · check_master 틀 · 로직 · 조합 0 건
- 깨지는 옛 엔진 · 옛 견본 시험 = sub6(엔진 몸 지움) · sub5(견본 옮김) 몫 — 표 tmp/s894/표_855_L3b.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 13:52:52 +09:00
co-authored by Claude Opus 5.5
parent badceff991
commit cd608862fa
80 changed files with 114 additions and 71010 deletions
@@ -1,23 +1,20 @@
"""로직 줄 칸 「개정」 — 원문 절 머리 개정 연도 목록 자동 채움(PLAN 794-2b · 분석 652-794-2a 5 장).
"""단가산출 기초(수식 문서) 줄 머리 「개정」 — 원문 절 머리 개정 연도 목록 자동 채움(PLAN 794-2b · 855-E L4).
건설 = 본문 md 절 머리 괄호 「('08, '20, 25년 보완)」 · 「('19년 신설, '24년 보완)」 의 연도 전부.
산림 = [2026](2026-01-01 제정 · 절 머리에 연도 없음). 절 머리에 연도가 없으면 윗절로 올라감.
못 찾음 = 칸 없음(빈칸). 글 꼴 그대로 — 줄 「출처」 바로 뒤에 끼우거나 옛 값만 갈음.
사람 입력 없음 · 셈 값 바뀜 0. 수식 문서 줄 머리 「개정」 도 같은 값(855 L1 이름표).
못 찾음 = 칸 없음(빈칸). 이름표 칸만 고침(`master_doc.tag`) · 사람 입력 없음 · 셈 값 바뀜 0.
./venv/Scripts/python.exe resources/master_data/scripts/build_로직_개정.py [--check]
"""
from __future__ import annotations
import json
import re
import sys
from collections import Counter
from pathlib import Path
ROOT = Path(__file__).resolve().parents[3]
MASTER = ROOT / "resources/master_data"
SRC = ROOT / "resources/knowledge/original/원가계산"
PART = {"01": "공통", "02": "토목", "03": "건축", "04": "기계설비", "05": "유지관리"}
HEAD = re.compile(r"^#{2,4}\s*(\d+(?:-\d+)+)\.?\s+(.*)$")
@@ -65,87 +62,33 @@ def revision(h: dict, row: dict, book: str) -> tuple[list[int] | None, str]:
return None, "머리에 연도 없음" if seen else "절 머리 못 찾음"
def _spans(text: str) -> list[tuple[int, int]]:
"""「줄」 배열 속 줄 하나하나의 글 자리."""
m = re.search(r'"줄"\s*:\s*\[', text)
dec, pos, out = json.JSONDecoder(), m.end(), []
while True:
while text[pos] in " \t\r\n,":
pos += 1
if text[pos] == "]":
return out
_, end = dec.raw_decode(text, pos)
out.append((pos, end))
pos = end
def put(row_text: str, value: list[int] | None) -> str:
"""줄 글에 「개정」 끼움 · 갈음 · 지움 — 출처 바로 뒤 · 출처와 같은 구분자(한 줄이면 「, 」)."""
old = re.search(r'"개정": \[[^\]]*\](,\s*)?', row_text)
if old:
row_text = row_text[: old.start()] + row_text[old.end() :]
if value is None:
return row_text
src = re.search(r'"출처": "(?:[^"\\]|\\.)*"(,\s*)', row_text)
if not src:
raise ValueError("줄 출처 없음")
sep = src.group(1)
return row_text[: src.end()] + f'"개정": {json.dumps(value)}' + sep + row_text[src.end() :]
def build(check: bool = False) -> Counter:
h, why, revs = heads(), Counter(), {}
for path in sorted(MASTER.glob("로직_*.json")):
raw = path.read_bytes().decode("utf-8")
data = json.loads(raw)
if data.get("원문") not in ("건설품셈", "산림품셈"):
continue
rows, spans = data["줄"], _spans(raw)
assert len(rows) == len(spans), path.name
parts, last = [], 0
for row, (s, e) in zip(rows, spans):
value, tag = revision(h, row, data["원문"])
why[tag] += 1
why[row["키"][:2] + (" 채움" if value else " 빈칸")] += 1
parts += [raw[last:s], put(raw[s:e], value)]
if value:
row["개정"] = value
else:
row.pop("개정", None)
revs[str(row["키"])] = value
last = e
out = "".join(parts + [raw[last:]])
assert json.loads(out) == data, path.name # 끼운 칸 말고 같음
if out != raw:
why["바뀐 파일"] += 1
if not check:
path.write_bytes(out.encode("utf-8"))
_docs(revs, why, check)
return why
def _docs(revs: dict, why: Counter, check: bool) -> None:
"""수식 문서 줄 머리 「개정」 도 같게(855 L1 이름표 · 로직 줄과 두 곳)."""
"""수식 문서 파일마다(원문 = 건설 · 산림) 줄 머리 「개정」 을 원문 절 머리 연도로 — 바뀐 파일만 씀."""
sys.path.insert(0, str(Path(__file__).resolve().parent))
import master_doc as md
import master_doc_link as ml
h, why = heads(), Counter()
for path in sorted(ml.FOLDER.glob("수식_*.json")):
data, hit = ml.load_file(path), False
if data.get("원문") not in ("건설품셈", "산림품셈"):
continue
rows = data.get("줄") or []
for at, doc in enumerate(rows):
key = str(doc.get("키"))
if key not in revs:
continue
want = {**md.tags_of(doc), "개정": revs[key]} if revs[key] else md.tags_of(doc)
if not revs[key]:
want.pop("개정", None)
if want != md.tags_of(doc):
tags = md.tags_of(doc)
value, tag = revision(h, tags, data["원문"])
why[tag] += 1
why[str(doc.get("키"))[:2] + (" 채움" if value else " 빈칸")] += 1
want = (
{**tags, "개정": value} if value else {k: v for k, v in tags.items() if k != "개정"}
)
if want != tags:
rows[at], hit = md.tag(doc, want), True
if hit:
why["바뀐 문서 파일"] += 1
if not check:
path.write_bytes(ml.dump(data).encode("utf-8")) # LF 그대로
return why
if __name__ == "__main__":
+33 -131
View File
@@ -1,16 +1,15 @@
# -*- coding: utf-8 -*-
"""마스터 데이터 검사 도구 (`resources/master_data/_틀.md`).
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/check_master.py [틀|본문|로직|조합|목차] [파일 …]
./venv/Scripts/python.exe resources/master_data/scripts/check_master.py 계산 GF000123 뒷길이=35 돌=견치돌 …
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/check_master.py [틀|본문|로직|조합|단위|목차|배] [파일 …]
(1) 틀 — 파일 이름 · 머리 칸 · 줄 칸 · 출처 모양 · 키 모양·겹침 · 대장
(2) 본문(`check_master_body.py`) — 표형 요소의 출처 절을 본문 md 에서 찾아 수를 맞댐 · 결손(본문 표에 있고 요소에 없음)·허구(요소에 있고 본문 절에 없음)
(3) 로직 — 변수가 가리키는 요소·표·칸 · 찾기 조건 이름 · 로직 입력 · 재료 고르기 조건 · 돌고 도는 참조 · 끊긴 키
(4) 조합 — 일위대가 조합이 담은 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음 (`master_combo.py`)
(3) 로직 — 단가산출 기초 = 수식 문서(`수식문서/`) 막힘 · 돌고 도는 참조(`master_doc_block`) · 키 겹침 · 대장 ·
품셈재료 연결 · 인력 준용
(4) 조합 — 일위대가 조합이 담은 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음(`master_doc_block.combo_row`)
(목차) 건설품셈 공통 1장 원문 절 목록 ↔ 마스터 전수 — 통째 빠진 절 · 로직 없는 품·표·식 절(`check_master_toc.py`)
(배) 로직 결과단위 배 ↔ 부르는 표 기준배(10㎡당 표를 원/㎡ 로직이 「/ 10」 없이 씀) (`master_basis.py`)
(5) 계산 — 로직 키와 입력값으로 호표 줄별 수량·단가·금액 · 비목 합 (`master_formula.py`)
(배) 기초 결과단위 배 ↔ 부르는 표 기준배(10㎡당 표를 원/㎡ 기초가 「/ 10」 없이 씀) (`master_basis.py`)
수 뽑기는 `resources/knowledge/original/_pipeline/pum_md_tool.py` 의 것을 씀.
"""
@@ -30,6 +29,8 @@ sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline"))
import master_basis as mbs # noqa: E402
import master_combo as mcb # noqa: E402
import master_doc_block as mb # noqa: E402
import master_doc_link as ml # noqa: E402
import master_formula as mf # noqa: E402
import master_keys as mk # noqa: E402
import master_machine_crew as mcrew # noqa: E402
@@ -83,19 +84,6 @@ ROW_KEYS = {
"줄",
"주",
),
"로직": (
"키",
"원문번호",
"구분",
"상세구분",
"이름",
"결과단위",
"출처",
"소유",
"입력",
"중간",
"끝수",
),
"품셈재료": ("키", "원문번호", "이름", "규격", "단위", "요구절", "연결", "고르기"),
}
# 한 테이블 파일 — 줄의 갈래 칸 · 머리의 갈래 묶음 (칸 이름은 `master_keys.MERGED` 한 곳에서)
@@ -165,15 +153,6 @@ def master(folder: Path = MASTER) -> mf.Master:
return mf.Master(load(folder=folder))
def calc(files: dict[str, dict], ref: str, given: dict) -> dict:
"""시험 계산(M01) — `ref` = 로직 키 · 멈추면 FormulaError ·
금액 끝수 = 품셈 1-2-2(`master_cut` · 751-3)."""
import master_cut as mcut # B09 끝수 함수를 부름 — 검사만 돌 때는 안 읽음
master = mf.Master(files)
return mcut.engine(master, ref, mf.run(master, ref, given))
# ── (1) 틀 ────────────────────────────────────────────────────────────
def _source_ok(source) -> bool:
if isinstance(source, dict):
@@ -197,7 +176,7 @@ def _head(name: str, data: dict, m) -> list[str]:
if head not in data:
out.append(f"{name} · 머리 「{head}」 없음")
chapter = bool(m.group(4))
if (data.get("그룹") in (*mf.TABLE_GROUPS, "로직") and data.get("원문") != "자체") != chapter:
if (data.get("그룹") in mf.TABLE_GROUPS and data.get("원문") != "자체") != chapter:
out.append(f"{name} · 파일 이름이 「그룹_원문_NN장_장 제목.json」 아님")
if chapter and not isinstance(data.get("차례"), Decimal):
out.append(f"{name} · 머리 「차례」 없음")
@@ -267,7 +246,7 @@ def check_form(name: str, data: dict) -> list[str]:
return out + [f"{name} · 테이블ID 없는 그룹·원문"]
merged = MERGED.get(data.get("그룹"))
table = data.get("그룹") in mf.TABLE_GROUPS
kind = "표" if table else "로직" if data.get("그룹") == "로직" else "요소"
kind = "표" if table else "요소"
if book == "품셈재료":
kind = "품셈재료"
rows = data.get("표" if table else "줄")
@@ -293,9 +272,8 @@ def check_form(name: str, data: dict) -> list[str]:
f" 이 파일 머리·이름 「{want[0]} · {want[1]}」 과 다름"
)
cols = COLS.get(book)
flow = isinstance(row.get("흐름"), dict) # 흐름 로직 — 옛 식 칸 없음
for need in cols or ROW_KEYS[kind]:
if need not in row and not (flow and need in mf.CALC_FIELDS):
if need not in row:
out.append(f"{where} · 칸 「{need}」 없음")
if "출처" in row and not _source_ok(row["출처"]):
out.append(f"{where} · 출처 모양 「{row['출처']}」")
@@ -325,8 +303,6 @@ def check_form(name: str, data: dict) -> list[str]:
out.append(f"{where} · 「{bundle}」 묶음 칸이 값 묶음과 다름")
if kind == "표":
out += _check_table(where, row)
if kind == "로직" and "결과" not in row and "호표" not in row and not flow:
out.append(f"{where} · 「호표」 도 「결과」 도 없음")
return out
@@ -391,20 +367,22 @@ def check_links(whole: mf.Master) -> list[str]:
def check_units(files: dict[str, dict], whole: mf.Master) -> list[str]:
"""단위 경고 — 재료 고르기 조건의 후보 단위가 그 줄 단위와 다름(호표 줄 · 품셈재료 줄).
데이터가 틀린 것이 아니라 조건을 더 좁혀야 하는 자리라 로직 검사와 따로 봄."""
데이터가 틀린 것이 아니라 조건을 더 좁혀야 하는 자리라 로직 검사와 따로 봄(기초 = 수식 문서 막힘 몫)."""
out = []
for key, row in whole.index.get("MP", {}).items():
cond = row.get("고르기")
if isinstance(cond, dict):
out += mf.check_unit(whole, whole.label(key) + " 고르기", cond, row.get("단위"))
for name, data in files.items():
if data.get("그룹") != "로직":
continue
for row in data.get("줄", []):
for item in row.get("호표", []):
if isinstance(item.get("요소"), dict):
where = f"{name} · {row.get('키')} 호표 {item.get('이름', '')} 요소"
out += mf.check_unit(whole, where, item["요소"], item.get("단위"))
for (
key,
doc,
) in ml.load_all().items(): # 기초 재료 고르기 = 그 단가를 쓰는 금액 줄 단위(855-E L3)
unit = {str(a.get("단가")): a.get("단위") for a in doc.get("금액") or []}
for v in doc.get("변수") or []:
cond = (v.get("연결") or {}).get("재료")
if isinstance(cond, dict):
where = f"{key} 연결 {v.get('열쇠')}"
out += mf.check_unit(whole, where, cond, unit.get(str(v.get("열쇠"))))
return out
@@ -437,26 +415,12 @@ def _check_table(where: str, table: dict) -> list[str]:
return out
# ── (3) 로직 ──────────────────────────────────────────────────────────
def check_logics(
files: dict[str, dict], whole: mf.Master, book: dict | None = None, narrow=None
) -> list[str]:
"""`narrow` = (검사할 로직 키, 안 보는 줄이 부르는 키) — 주면 그 키만 검사하고
품셈재료 연결 · 인력 준용(`check_links`)도 건너뜀(로직 줄 고침이 못 건드리는 자리)."""
only, graph = narrow or (None, {})
out, graph = [], dict(graph)
for name, data in files.items():
if data.get("그룹") != "로직":
continue
for row in data.get("줄", []):
key = str(row.get("키"))
if only is not None and key not in only:
continue
found, calls = mf.check_logic(whole, row)
out += [f"{name} · {x}" for x in found]
graph[key] = calls
out += [f"돌고 도는 참조 · {' → '.join(loop)}" for loop in mf.find_loops(graph)]
return out + duplicate_keys(files, book) + ([] if only is not None else check_links(whole))
# ── (3) 로직 = 수식 문서 ──────────────────────────────────────────────
def check_docs(files: dict[str, dict], whole: mf.Master, book: dict | None = None) -> list[str]:
"""단가산출 기초(수식 문서) — 막힘 · 돌고 도는 참조 · 키 겹침 · 대장 · 품셈재료 연결 · 인력 준용."""
docs = ml.load_all()
view = {**files, "수식문서": {"그룹": "로직", "줄": list(docs.values())}}
return mb.check_docs(docs, None, whole) + duplicate_keys(view, book) + check_links(whole)
def duplicate_keys(files: dict[str, dict], book: dict | None = None) -> list[str]:
@@ -494,73 +458,8 @@ def duplicate_keys(files: dict[str, dict], book: dict | None = None) -> list[str
return out
# ── (4) 계산 ──────────────────────────────────────────────────────────
def show(result: dict) -> str:
if "결과" in result:
return f"결과 {result['결과']}"
rows = [
f" {r['이름']} | {r['단위']} | 수량 {r['수량']:.6f} | 단가 {r['단가']} | 금액 {r['금액']:.2f}"
for r in result["줄"]
]
rows += [f" {k} {result[k]:.2f}" for k in (*mf.COST_ITEMS, "계")]
return "\n".join(rows)
def 시험입력(row: dict) -> dict:
"""일괄 시험 계산용 입력 한 벌 — 고르기 첫 값 · 범위 위끝 · 줄의 「시험입력」 이 이김.
시험 계산 전용 — 정본 계산은 화면이 준 값만 씀."""
given = {}
for spec in row.get("입력", []):
if "고르기" in spec:
given[spec["이름"]] = spec["고르기"][0]
elif "범위" in spec:
given[spec["이름"]] = spec["범위"][1]
else:
given[spec["이름"]] = Decimal(1)
given.update(row.get("시험입력") or {})
return given
def calc_all(files: dict[str, dict], whole: mf.Master) -> tuple[int, list[str], list[str]]:
"""로직 전부를 시험 입력으로 돌림 — (통과 수, 멈춘 줄 목록, 건너뜀 키 목록).
고르기 목록이 빈 입력이 있는 로직(GC001199~1201 = 내 기계 전용 식 · M01 정본 기계가 안 씀)은
고를 값이 없어 건너뜀 — 멈춤으로 세지 않음."""
passed, stuck, skipped = 0, [], []
for data in files.values():
if data.get("그룹") != "로직":
continue
for row in data.get("줄", []):
if any(i.get("고르기") == [] for i in row.get("입력", [])):
skipped.append(str(row["키"]))
continue
try:
mf.run(whole, str(row["키"]), 시험입력(row))
passed += 1
except mf.FormulaError as err:
stuck.append(f"{row['키']} {row.get('이름')} · {err}")
return passed, stuck, skipped
def _value(text: str):
try:
return Decimal(text)
except ArithmeticError:
return text
def main(argv: list[str]) -> int:
mode = argv[0] if argv else "전부"
if mode == "계산":
given = dict(arg.split("=", 1) for arg in argv[2:])
print(show(mf.run(master(), argv[1], {k: _value(v) for k, v in given.items()})))
return 0
if mode == "계산전부":
files, whole = load(), master()
passed, stuck, skipped = calc_all(files, whole)
print(f"(계산) 통과 {passed} · 멈춤 {len(stuck)} · 건너뜀 {len(skipped)} {skipped}")
for line in stuck:
print(" " + line)
return 0
names = argv[1:] or None
files, whole = load(names), master()
report = {}
@@ -569,15 +468,18 @@ def main(argv: list[str]) -> int:
if mode in ("본문", "전부"):
report["본문"] = check_body(files)
if mode in ("로직", "전부"):
report["로직"] = check_logics(files, whole)
report["로직"] = check_docs(files, whole)
if mode in ("조합", "전부"):
report["조합"] = mcb.check_all(files, whole)
docs = ml.load_all()
report["조합"] = [
f"{n} · {x}" for n, row in mcb.rows(files) for x in mb.combo_row(row, docs)
]
if mode in ("단위", "전부"):
report["단위"] = check_units(files, whole)
if mode in ("목차", "전부") and "계수_건설품셈_01장_적용기준.json" in files:
report["목차"] = check_toc(files) # 공통 1장 원문 절 목록 ↔ 마스터 전수
if mode in ("배", "전부"): # 결과단위 배 ↔ 부르는 표 기준배(읽을 때 파생 · `master_basis`)
report["배"] = mbs.check_times(files)
report["배"] = mbs.check_times(files, ml.load_all())
for title, found in report.items():
print(f"({title}) {len(found)}건")
for line in found:
+4 -3
View File
@@ -12,9 +12,10 @@ from decimal import Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
# 마스터 첫 층 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸) ·
# 단가산출 기초(로직)는 수식 문서(`수식문서/` · 855-E L3)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
+8 -11
View File
@@ -98,8 +98,10 @@ def result_per(result_unit) -> list[tuple[Decimal, str]]:
return [(n, unit(u)) for n, u in mu.per(result_unit)]
def _formula_text(row: dict) -> str:
return str([row.get(k) for k in ("중간", "호표", "덧줄")])
def _formula_text(doc: dict) -> str:
"""수식 문서 식 · 금액 글 — 「×」 「÷」 「N%」 = 「*」 「/」 「N / 100」(나눔 찾기 꼴)."""
text = str([doc.get(k) for k in ("식", "금액")]).replace("×", "*").replace("÷", "/")
return re.sub(r"(\d+(?:\.\d+)?)\s*%", r"\1 / 100", text)
def _divides(text: str, times: Decimal) -> bool:
@@ -110,15 +112,10 @@ def _divides(text: str, times: Decimal) -> bool:
return re.search(pattern, text) is not None
def check_times(files: dict[str, dict]) -> list[str]:
"""배 어긋남 — 로직이 부르는 표(`용도.로직키`)의 기준배 ≠ 1 인데 결과단위가 같은 배가 아니고
식에서도 그 배로 나누지 않는 짝(시스템 관리자 원문 확인 거리)."""
logic_rows = {
str(r.get("키")): r
for d in files.values()
if d.get("그룹") == "로직"
for r in d.get("줄") or []
}
def check_times(files: dict[str, dict], docs: dict[str, dict]) -> list[str]:
"""배 어긋남 — 기초(수식 문서 `docs`)가 부르는 표(`용도.로직키`)의 기준배 ≠ 1 인데 결과단위가 같은 배가
아니고 식에서도 그 배로 나누지 않는 짝(시스템 관리자 원문 확인 거리)."""
logic_rows = docs
out = []
for name, data in files.items():
for table in data.get("표") or []:
+1 -41
View File
@@ -11,7 +11,6 @@ from __future__ import annotations
from decimal import Decimal
import master_formula as mf
import master_keys as mk
GROUP = "일위대가조합"
FILE = "일위대가조합.json"
@@ -41,46 +40,7 @@ def logic_keys(row: dict) -> list[str]:
return [str(one.get("로직") or "") for one in items(row) if isinstance(one, dict)]
# ── 검사 ──────────────────────────────────────────────────────────────
def check_row(whole: mf.Master, row: dict) -> list[str]:
"""조합 한 줄 — 빈 조합 · 없는 로직 키 · 같은 로직 두 번 · 조합을 담음(1단만) · 메모 모양."""
where = f"{row.get('키')} {row.get('이름') or ''}".strip()
got = items(row)
out = [] if got else [f"{where} · 빈 조합 — 담은 로직이 없음"]
if row.get("담은로직") is not None and not isinstance(row.get("담은로직"), list):
out.append(f"{where} · 「담은로직」 이 목록 아님")
seen: set[str] = set()
for at, one in enumerate(got, start=1):
if not isinstance(one, dict):
out.append(f"{where} 줄{at} · 담은 로직 줄이 묶음 아님 「{one}」")
continue
extra = set(one) - set(ITEM_COLS)
if extra:
out.append(f"{where} 줄{at} · 모르는 칸 {sorted(extra)}")
memo = one.get("메모")
if memo is not None and not isinstance(memo, str):
out.append(f"{where} 줄{at} · 「메모」 가 글자 아님 「{memo}」 — 수량·계산은 두지 않음")
key = str(one.get("로직") or "")
if not mk.KEY.fullmatch(key):
out.append(f"{where} 줄{at} · 로직 키 모양 아님 「{key}」")
continue
if mk.id_of(key) == TID:
out.append(f"{where} 줄{at} · 조합은 조합을 담지 못함 「{key}」 — 단가산출 로직만")
continue
try:
whole.logic(key)
except mf.FormulaError as e:
out.append(f"{where} 줄{at} · {e}")
continue
if key in seen:
out.append(f"{where} 줄{at} · 같은 로직을 두 번 담음 「{key}」")
seen.add(key)
return out
def check_all(files: dict[str, dict], whole: mf.Master) -> list[str]:
"""조합 전부 — 파일 이름을 앞에 붙임."""
return [f"{name} · {x}" for name, row in rows(files) for x in check_row(whole, row)]
# ── 검사 = `master_doc_block.combo_row`(있는 기초 = 수식 문서 · 855-E L3) ─────────────
def using(files: dict[str, dict], key: str) -> list[dict]:
@@ -2,11 +2,11 @@
"""수식 문서 변수 단위 채움 · 단위 셈 (PLAN 845-1 · 요구 880).
보이는 변수 `단위` 칸만 고침 — 셈 · 연결(연결 안 `단위` = 재료 환산) 안 건드림.
빌더(`build_수식문서_802_2.py`)가 변환 뒤 문서마다 `fill` 을 부름 — 빈 단위만 채우고 적힌 단위는
불러오기 문서 짓기(`M02_San_ToDoc`)가 문서마다 `fill` 을 부름 — 빈 단위만 채우고 적힌 단위는
그대로(자리표시 「줄 따름」 류 · 「수」 만 고침). 채움 근거는 원본 · 셈만(지어내지 않음):
- 표 칸 = 표 `값칸` 단위 · 「줄 따름」 류 = 고를 수 있는 행이 모두 같은 `단위` 칸일 때 그 단위.
- 요소 = 기계 칸 단위(`기계/*.json` 단위) · 노임 · 재료 · 유가 = 「원/요소 단위」.
- 단가산출 = 부른 문서 결과단위 · 수 고르기 = 이름 끝에 적힌 단위(「두께mm이하」).
- 단가산출 = 부른 문서(M01 수식 문서 · 855-E L3) 결과단위 · 수 고르기 = 이름 끝에 적힌 단위(「두께mm이하」).
- 식 = 식 속 변수 단위로 셈(`infer`) — 2 배 밖 수(× 8 · ÷ 15)가 끼면 단위를 품을 수 있어 안 채움.
- 금액 줄 역산 = 줄 단위가 단가 단위와 맞을 때 수량을 더하기로만 이은 변수 = 줄 단위.
무차원(계수 · 비 · 글 고르기)은 빈 단위가 맞음 — `dimensionless` 가 가름.
@@ -18,6 +18,7 @@ import re
from fractions import Fraction
import master_doc as md
import master_doc_link as ml
import master_unit_text as ut
# 행마다 단위가 다른 표 칸 — 행의 `단위` 칸이 참값
@@ -413,6 +414,17 @@ def _is_num(x) -> bool:
return False
_DOCS: dict = {}
def _m01_docs() -> dict[str, dict]:
"""M01 수식 문서 {키: 문서} — 폴더 파일 자국이 같으면 다시 안 읽음."""
mark = tuple((p.name, p.stat().st_mtime_ns) for p in sorted(ml.FOLDER.glob("수식_*.json")))
if _DOCS.get("자국") != mark:
_DOCS.update(자국=mark, 문서=ml.load_all())
return _DOCS["문서"]
def source_unit(master, doc: dict, var: dict) -> tuple[str | None, str]:
"""변수 하나의 원본 단위 — (단위 | 「글」 | 「」 무차원 | None 모름, 근거)."""
link = var.get("연결") or {}
@@ -423,10 +435,10 @@ def source_unit(master, doc: dict, var: dict) -> tuple[str | None, str]:
if kind == "요소":
return element_unit(master, link, choices)
if kind == "단가산출":
try:
unit = master.logic(str(link.get("키") or "")).get("결과단위") or ""
except Exception: # noqa: BLE001
doc = _m01_docs().get(str(link.get("키") or ""))
if doc is None:
return None, "부른 문서 없음"
unit = doc.get("결과단위") or ""
return (show(unit), "부른 문서 결과단위") if unit else (None, "부른 문서 결과단위 없음")
if dimensionless(var):
return "", "글 고르기 · 글 값"