eomsangdonandClaude Opus 5.5
a8acaed6f5
- 책 낱말 표(ReadEst.book_of) — 임도 · 사방 = 옛 책 「(옛)」 · 공통 · 토목 · 건축 · 기계설비 · 유지관리 = 「건설품셈 <부문>」 · 그 밖 건설품셈(부문 모름) 그대로 - 출처 풀이(Basis.settle · Excel.read_book 끝 한 곳 · 두 형식) — 건설품셈(부문 모름) 번호 → 블록 이름(안 맞으면 글 두 묶음)이 원문 제목 · 같은 번호 로직 이름과 뜻 낱말을 나누는 부문 하나 = 그 부문 · 둘 이상 = 모름 · 없음 = (옛) · 임도 옛 번호 → 지식DB 대응표 확정 한 대응(가 · 나 항 = 현행 윗마디 · 일대다 안 옮김) - 조항 견줌(Basis.clause) 한 줄 — 책 또는 구분 같음 · (옛) = 없음 - 기초 없음 표지(Basis.no_basis) — 출처 조항(윗 · 아랫마디 포함) 로직 0 = 「근거 조항 우리 기초에 없음 — 건설품셈 공통 1-2-7 운반」 · 옛 번호 = 「옛 번호 — 대응 미확인」 · 맞춤셈 꼬리표 · 맞음 아닌 후보 글 「참고 후보 — 근거 조항 아님」 · 단가산출 근거 꼬리표 1위 대신 표지(1위 맞음이면 1위) - 시험: 새 test_628 · test_621 단계 해시 다시 굳힘(달라진 칸 = 출처뿐 · S1 수 · 그래프 그대로) · test_m02_hopyo_basis · finger · stmate · excel 출처 기대값 새 책 꼴로(낡은 기대 「임도 = 산림품셈」 · 「건설품셈」 부문 없음) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
389 lines
17 KiB
Python
389 lines
17 KiB
Python
"""M02 일위대가 실무자료 읽기(PLAN 324-1) — 설계내역서 엑셀 「일위대가」 시트 →
|
||
호표 · 줄 · 갈래 · 검산.
|
||
|
||
읽기 = .xls `xlrd`(경고가 stdout 으로 안 나가게 logfile) · .xlsx `openpyxl`(빈 칸 None) ·
|
||
시트 · 열은 머리 글(빈칸 뺌)로 찾음 — 호표 · 품명 · 규격 · 수량 · 단위 · 합계 · 노무비 ·
|
||
재료비 · 경비 · 비고(돈 머리 = 단가 열 · 다음 열 = 금액).
|
||
호표 줄 = 「제N호표」 · 호표 1 단위 값 = 금액 열 · 구성 줄 = 호표 칸 빔 · 품명 있음 ·
|
||
끝 = 다음 호표.
|
||
갈래 = % · 호표(비고 일위N참조) · 단가산출(단산N참조) · 기계(단위 hr) · 별도계상(값 없음) ·
|
||
자재(재료비만) · 노임(단위 인 + 우리 인력 이름) · 기타 — 규격은 원문 그대로 둠.
|
||
이음(338) = 비고 「단산 · 산근 · 단가산출 N(참조 · 호표)」 → 단산 N · 「일위 · 대가 · 일위대가 N」 →
|
||
호표 N(빈칸 무시) · 비고 빈 줄(노무비 · 경비 단가 있음)은 품명 + 단위가 같은 블록이 하나뿐이면
|
||
이음(줄 `이음` = 「이름」) · 하이퍼링크 안 읽음.
|
||
STmate 꼴(「일위대가표」 · 「단가산출근거」 시트) = `M02_Hopyo_Stmate.read` ·
|
||
문서 보안(DRM) 파일 = 400 글.
|
||
검산 = 줄 금액 floor(단가 × 수량 × 10) / 10 · 합계 단가 = 셋 합 ·
|
||
% 줄 = floor(바탕 × 율 / 100 × 10) / 10 · 호표 비목 = floor(줄 금액 합) · 총괄표 합계 —
|
||
어긋남은 글 목록(막지 않음).
|
||
행(329-1) = 호표 [제N호표 줄, 마지막 구성 줄] · 구성 줄 한 줄(엑셀 1부터) ·
|
||
근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_Basis.read`) ·
|
||
`단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`(338 · 글 = 머리 뺀 몸 줄) ·
|
||
`꼴` = 「엑셀꼴」 · 두 형식 끝에 `UnitLine.settle`(단위 줄 하위 · 재현 · 덮음 · 일위대가 줄
|
||
투영 · 778-3).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import io
|
||
import re
|
||
from decimal import ROUND_FLOOR, Decimal, InvalidOperation
|
||
from typing import Any
|
||
|
||
from M02_MasterTemplete import M02_Hopyo_Basis as source_basis # 출처 풀이(781-1)
|
||
from M02_MasterTemplete import M02_Hopyo_ReadEst as hopyo_basis # EST 단가산출 어댑터(776-2)
|
||
from M02_MasterTemplete import M02_Hopyo_Stmate as hopyo_stmate
|
||
from M02_MasterTemplete import M02_Hopyo_UnitLine as unit_line
|
||
|
||
SHEET = "일위대가"
|
||
SUMMARY = "일위대가총괄표"
|
||
LISTS = ("단가산출총괄표", "일위대가목록표") # 엑셀 보기 목록 시트(779-1 격자) — 같이 읽음
|
||
COSTS = ("노무비", "재료비", "경비")
|
||
HEADS = ("호표", "품명", "규격", "수량", "단위", "비고")
|
||
NO_SHEET = "일위대가 시트 없음"
|
||
_HOPYO = re.compile(r"제\s*(\d+)\s*호표")
|
||
_REF = re.compile(r"^(?:(단산|산근|단가산출)|(일위대가|일위|대가))(\d+)(?:참조|호표)?$")
|
||
DRM = "문서 보안(DRM)으로 잠긴 파일 — 보안을 푼 사본으로 저장해 올림"
|
||
_OLE = b"\xd0\xcf\x11\xe0"
|
||
_MACHINE_UNITS = ("hr", "시간", "h")
|
||
_CODE_KIND = {
|
||
"D": "단가산출",
|
||
"B": "호표",
|
||
"L": "노임",
|
||
"X": "기계",
|
||
"S": "별도계상",
|
||
"W": "별도계상",
|
||
}
|
||
# ponytail: 마지막 연 책 하나(올림 길 read_book → Grid.read 가 같은 바이트) — 여럿 동시면 다시 엶
|
||
_OPENED: tuple[bytes, dict[str, list[list[Any]]], Any] | None = None
|
||
|
||
|
||
class ExcelError(ValueError):
|
||
"""엉터리 파일 · 시트 없음 — 길이 400 으로 답함."""
|
||
|
||
|
||
def _flat(value: Any) -> str:
|
||
return re.sub(r"\s+", "", str(value or ""))
|
||
|
||
|
||
def _text(value: Any) -> str:
|
||
if isinstance(value, float) and value == int(value):
|
||
value = int(value)
|
||
return str(value if value is not None else "").strip()
|
||
|
||
|
||
def _num(value: Any) -> Decimal | None:
|
||
if value is None or isinstance(value, bool) or value == "":
|
||
return None
|
||
try:
|
||
got = Decimal(str(value).replace(",", "").strip())
|
||
except InvalidOperation:
|
||
return None
|
||
return got if got.is_finite() else None
|
||
|
||
|
||
def _floor(value: Decimal, places: int = 1) -> Decimal:
|
||
step = Decimal(1).scaleb(-places)
|
||
return value.quantize(step, rounding=ROUND_FLOOR)
|
||
|
||
|
||
def _out(value: Decimal | None) -> int | float | None:
|
||
if value is None:
|
||
return None
|
||
return int(value) if value == value.to_integral_value() else float(value)
|
||
|
||
|
||
# ── 파일 → 시트 표(줄마다 값 목록) ────────────────────────────────────────
|
||
def _sheets(name: str, data: bytes, wanted: tuple[str, ...] = ()) -> dict[str, list[list[Any]]]:
|
||
"""시트 이름 → 줄 목록 — 일위대가 · 총괄표 · 단가산출만 읽음(`wanted` = 더 읽을 시트)."""
|
||
return _open(name, data, wanted)[0]
|
||
|
||
|
||
def opened(name: str, data: bytes, wanted: tuple[str, ...] = ()) -> tuple[dict[str, Any], Any]:
|
||
"""(시트 줄, xls 책 | None) — 방금 `read_book` 이 연 같은 바이트면 그 책(한 번 열기 · 776-2) ·
|
||
아니면 엶. xls 책 = xlrd `formatting_info`(격자 서식)."""
|
||
global _OPENED
|
||
got, _OPENED = _OPENED, None
|
||
if got is not None and got[0] is data: # read_book 은 목록 시트(LISTS)까지 읽어 둠
|
||
return got[1], got[2]
|
||
return _open(name, data, wanted)
|
||
|
||
|
||
def _open(
|
||
name: str, data: bytes, wanted: tuple[str, ...] = ()
|
||
) -> tuple[dict[str, list[list[Any]]], Any]:
|
||
keep = (SHEET, SUMMARY, hopyo_basis.SHEET, *wanted)
|
||
if not data:
|
||
raise ExcelError("빈 파일")
|
||
if b"DRMONE" in data[:256] and data[:4] not in (b"PK\x03\x04", _OLE):
|
||
raise ExcelError(DRM)
|
||
try:
|
||
if data[:4] == b"PK\x03\x04" or name.lower().endswith(".xlsx"):
|
||
import openpyxl
|
||
|
||
book = openpyxl.load_workbook(io.BytesIO(data), read_only=True, data_only=True)
|
||
if hopyo_stmate.is_stmate([t.strip() for t in book.sheetnames]):
|
||
keep = (*hopyo_stmate.SHEETS, *wanted)
|
||
out = {
|
||
ws.title.strip(): [list(row) for row in ws.iter_rows(values_only=True)]
|
||
for ws in book.worksheets
|
||
if ws.title.strip() in keep
|
||
}
|
||
book.close()
|
||
return out, None
|
||
import xlrd
|
||
|
||
try:
|
||
book = xlrd.open_workbook(
|
||
file_contents=data, formatting_info=True, logfile=io.StringIO()
|
||
)
|
||
except Exception: # 서식 표가 깨진 파일 — 값만(격자는 그때 서식 없이 다시 엶)
|
||
book = xlrd.open_workbook(file_contents=data, logfile=io.StringIO())
|
||
rows = {
|
||
sh.name.strip(): [sh.row_values(r) for r in range(sh.nrows)]
|
||
for sh in book.sheets()
|
||
if sh.name.strip() in keep
|
||
}
|
||
return rows, book
|
||
except ExcelError:
|
||
raise
|
||
except Exception as error: # 라이브러리마다 다른 예외 — 깨진 파일 · 엑셀 아님
|
||
raise ExcelError("엑셀 파일을 읽지 못함 — xls · xlsx 가 아니거나 깨진 파일") from error
|
||
|
||
|
||
def _columns(rows: list[list[Any]], money: tuple[str, ...]) -> tuple[int, dict[str, int]]:
|
||
"""(자료 첫 줄, {머리: 열}) — 머리 글은 앞 10 줄 안 「호표」 · 「품명」 이 든 줄."""
|
||
for at, row in enumerate(rows[:10]):
|
||
flat = [_flat(v) for v in row]
|
||
if "호표" not in flat or "품명" not in flat:
|
||
continue
|
||
cols = {head: flat.index(head) for head in (*HEADS, *money) if head in flat}
|
||
below = [_flat(v) for v in rows[at + 1]] if at + 1 < len(rows) else []
|
||
start = at + 2 if "단가" in below or "금액" in below else at + 1
|
||
return start, cols
|
||
raise ExcelError(f"{SHEET} 시트 머리 글(호표 · 품명)을 못 찾음")
|
||
|
||
|
||
def _cell(row: list[Any], col: int | None) -> Any:
|
||
return row[col] if col is not None and col < len(row) else None
|
||
|
||
|
||
def _money(row: list[Any], cols: dict[str, int], offset: int) -> dict[str, Decimal | None]:
|
||
"""비목 넷(합계 = 계) — `offset` 0 = 단가 열 · 1 = 금액 열."""
|
||
return {
|
||
("계" if head == "합계" else head): _num(_cell(row, None if c is None else c + offset))
|
||
for head in ("합계", *COSTS)
|
||
for c in [cols.get(head)]
|
||
}
|
||
|
||
|
||
# ── 갈래 · 검산 ─────────────────────────────────────────────────────────
|
||
def kind_of(line: dict[str, Any]) -> str:
|
||
"""구성 줄 갈래 한 규칙(776-2 · EST · STmate · 붙여넣기) — 단가산출 · 자재 · 기계 · 노임 ·
|
||
호표 · % · 별도계상 · 기타. STmate 코드가 있으면 코드 머리 글자 · 없으면 칸(비고 참조 ·
|
||
단위 · 단가) · 끝에 노임 올림(단위 「인」 + 우리 직종 · 괄호 글 풂)."""
|
||
kind = _code_kind(line) if line.get("코드") else _cell_kind(line)
|
||
if kind in ("기타", "자재", "노임") and _flat(line.get("단위")) == "인":
|
||
return "노임" if hopyo_basis.trade(line.get("이름")) else kind
|
||
return kind
|
||
|
||
|
||
def _code_kind(line: dict[str, Any]) -> str:
|
||
code, price = str(line["코드"]), line["단가"]
|
||
if code.startswith("PR") or _flat(line.get("단위")) == "%":
|
||
return "%"
|
||
if code[0] == "M":
|
||
apart = str(line.get("비고") or "").startswith("별산")
|
||
apart = apart or "별도계상" in f"{line.get('규격')}{line.get('이름')}"
|
||
return "별도계상" if apart or not any(price.values()) else "자재"
|
||
if code[0] == "D" and price.get("재료비") and not price.get("노무비") and not price.get("경비"):
|
||
return "자재" # 재료비만 = 자재(358-2 · 엑셀꼴과 같음)
|
||
return _CODE_KIND.get(code[0], "기타")
|
||
|
||
|
||
def _cell_kind(line: dict[str, Any]) -> str:
|
||
ref = line.get("참조") or {}
|
||
unit = _flat(line.get("단위")).lower()
|
||
price = line["단가"]
|
||
if unit == "%":
|
||
return "%"
|
||
if ref.get("종류") == "일위":
|
||
return "호표"
|
||
if price.get("재료비") and not price.get("노무비") and not price.get("경비"):
|
||
return "자재" # 재료비만 = 자재(「단산N참조」여도 · 358-2)
|
||
if ref.get("종류") == "단산":
|
||
return "단가산출"
|
||
if unit in _MACHINE_UNITS:
|
||
return "기계"
|
||
if unit == "인" and _flat(line.get("이름")) in hopyo_basis.trade_names():
|
||
return "노임"
|
||
if not any(price.get(k) for k in ("계", *COSTS)):
|
||
return "별도계상"
|
||
return "기타"
|
||
|
||
|
||
def _check_line(where: str, line: dict[str, Any]) -> list[str]:
|
||
qty, price, amount = line["수량"], line["단가"], line["금액"]
|
||
bad = []
|
||
if line["갈래"] == "%":
|
||
base = price.get("계")
|
||
want = _floor(base * qty / 100) if base is not None and qty else None
|
||
got = sum((amount.get(k) or Decimal(0)) for k in COSTS)
|
||
if want is not None and got != want:
|
||
bad.append(f"{where} · % 금액 {got} ≠ {want}")
|
||
return bad
|
||
if qty is None:
|
||
return bad
|
||
for k in COSTS:
|
||
if price.get(k) is None:
|
||
continue
|
||
want = _floor(price[k] * qty)
|
||
if (amount.get(k) or Decimal(0)) != want:
|
||
bad.append(f"{where} · {k} 금액 {amount.get(k)} ≠ {want}")
|
||
parts = [price.get(k) for k in COSTS]
|
||
if price.get("계") is not None and any(p is not None for p in parts):
|
||
total = sum((p or Decimal(0)) for p in parts)
|
||
if total != price["계"]:
|
||
bad.append(f"{where} · 합계 단가 {price['계']} ≠ {total}")
|
||
return bad
|
||
|
||
|
||
def _check_hopyo(hopyo: dict[str, Any], lines: list[dict[str, Any]]) -> list[str]:
|
||
where = f"제{hopyo['번']}호표"
|
||
bad = []
|
||
for line in lines:
|
||
bad += _check_line(f"{where} {line['차례'] + 1}째 줄 「{line['이름']}」", line)
|
||
if not lines:
|
||
return bad
|
||
for k in COSTS:
|
||
total = sum((line["금액"].get(k) or Decimal(0)) for line in lines)
|
||
want, got = _floor(total, 0), hopyo["금액"].get(k) or Decimal(0)
|
||
if got != want:
|
||
bad.append(f"{where} · {k} {got} ≠ 줄 합 {want}")
|
||
return bad
|
||
|
||
|
||
def _summary(rows: list[list[Any]] | None) -> dict[int, Decimal]:
|
||
"""총괄표 {호표 번: 합계} — 머리 글이 없으면 빈 것."""
|
||
if not rows:
|
||
return {}
|
||
try:
|
||
start, cols = _columns(rows, ("합계",))
|
||
except ExcelError:
|
||
return {}
|
||
out = {}
|
||
for row in rows[start:]:
|
||
hit = _HOPYO.fullmatch(_flat(_cell(row, cols.get("호표"))))
|
||
total = _num(_cell(row, cols.get("합계")))
|
||
if hit and total is not None:
|
||
out[int(hit.group(1))] = total
|
||
return out
|
||
|
||
|
||
def _by_name(raw: list[list[dict[str, Any]]], blocks: dict[int, dict[str, Any]]) -> None:
|
||
"""비고 빈 줄(노무비 · 경비 단가 있음) → 품명 + 단위가 같은 블록이 하나뿐이면 단산 이음."""
|
||
index: dict[tuple[str, str], list[int]] = {}
|
||
for no, block in blocks.items():
|
||
index.setdefault((_flat(block["이름"]), _flat(block["단위"]).lower()), []).append(no)
|
||
for line in (one for lines in raw for one in lines):
|
||
if line["참조"] or line["비고"] or line["갈래"] == "%":
|
||
continue
|
||
if not (line["단가"].get("노무비") or line["단가"].get("경비")):
|
||
continue
|
||
hit = index.get((_flat(line["이름"]), _flat(line["단위"]).lower())) or []
|
||
if len(hit) == 1:
|
||
line["참조"], line["이음"] = {"종류": "단산", "번": hit[0]}, "이름"
|
||
line["갈래"] = kind_of(line)
|
||
|
||
|
||
# ── 읽기 ──────────────────────────────────────────────────────────────
|
||
def read_book(name: str, data: bytes) -> dict[str, Any]:
|
||
"""엑셀 → `{시트, 호표: [...], 검산: {어긋남: [글 …], 총괄표: 맞춘 수}}` — 값은 JSON 수."""
|
||
global _OPENED
|
||
sheets, xls = _open(name, data, LISTS)
|
||
_OPENED = (data, sheets, xls) # 격자(`Grid.read`)가 이어 씀 — 한 번 열기
|
||
if hopyo_stmate.is_stmate(sheets):
|
||
return unit_line.settle(source_basis.settle(hopyo_stmate.read(sheets)))
|
||
rows = sheets.get(SHEET)
|
||
if rows is None:
|
||
raise ExcelError(NO_SHEET)
|
||
start, cols = _columns(rows, ("합계", *COSTS))
|
||
hopyos: list[dict[str, Any]] = []
|
||
raw: list[list[dict[str, Any]]] = []
|
||
for at, row in enumerate(rows[start:], start + 1):
|
||
head = _flat(_cell(row, cols.get("호표")))
|
||
name_ = _text(_cell(row, cols.get("품명")))
|
||
hit = _HOPYO.fullmatch(head)
|
||
if hit:
|
||
hopyos.append(
|
||
{
|
||
"번": int(hit.group(1)),
|
||
"이름": name_,
|
||
"규격": _text(_cell(row, cols.get("규격"))),
|
||
"단위": _text(_cell(row, cols.get("단위"))),
|
||
"금액": _money(row, cols, 1),
|
||
"행": [at, at],
|
||
}
|
||
)
|
||
raw.append([])
|
||
continue
|
||
if head or not name_ or not hopyos:
|
||
continue
|
||
note = _text(_cell(row, cols.get("비고")))
|
||
ref = _REF.match(_flat(note))
|
||
line = {
|
||
"차례": len(raw[-1]),
|
||
"이름": name_,
|
||
"규격": _text(_cell(row, cols.get("규격"))),
|
||
"수량": _num(_cell(row, cols.get("수량"))),
|
||
"단위": _text(_cell(row, cols.get("단위"))),
|
||
"단가": _money(row, cols, 0),
|
||
"금액": _money(row, cols, 1),
|
||
"비고": note,
|
||
"참조": {"종류": "단산" if ref.group(1) else "일위", "번": int(ref.group(3))}
|
||
if ref
|
||
else None,
|
||
}
|
||
line["갈래"] = kind_of(line)
|
||
line["행"] = hopyos[-1]["행"][1] = at
|
||
raw[-1].append(line)
|
||
if not hopyos:
|
||
raise ExcelError(f"{SHEET} 시트에 호표(제N호표)가 없음")
|
||
blocks = hopyo_basis.read(sheets.get(hopyo_basis.SHEET))
|
||
_by_name(raw, blocks)
|
||
for line in (one for lines in raw for one in lines):
|
||
ref = line["참조"] or {}
|
||
if ref.get("종류") == "단산" and (block := blocks.get(ref["번"])):
|
||
line["근거"] = {k: block[k] for k in ("출처", "직종", "행")}
|
||
wrong: list[str] = []
|
||
totals = _summary(sheets.get(SUMMARY))
|
||
for hopyo, lines in zip(hopyos, raw, strict=True):
|
||
wrong += _check_hopyo(hopyo, lines)
|
||
total = hopyo["금액"].get("계")
|
||
if hopyo["번"] in totals and total is not None and totals[hopyo["번"]] != total:
|
||
wrong.append(f"제{hopyo['번']}호표 · 총괄표 합계 {totals[hopyo['번']]} ≠ {total}")
|
||
out = [
|
||
{**_json(hopyo), "줄": [_json(line) for line in lines]}
|
||
for hopyo, lines in zip(hopyos, raw, strict=True)
|
||
]
|
||
keep = ("번", "이름", "단위", "행", "출처", "직종", "글", "금액", "항목")
|
||
basis = [{k: b[k] for k in keep} for b in blocks.values()]
|
||
book = {
|
||
"꼴": "엑셀꼴",
|
||
"시트": SHEET,
|
||
"호표": out,
|
||
"단산": basis,
|
||
"검산": {"어긋남": wrong, "총괄표": len(totals)},
|
||
}
|
||
return unit_line.settle(
|
||
source_basis.settle(book)
|
||
) # 출처 풀이(781-1) · 단위 줄 하위 · 재현 · 덮음 · 일위대가 줄 투영(778-3)
|
||
|
||
|
||
def _json(value: Any) -> Any:
|
||
if isinstance(value, Decimal):
|
||
return _out(value)
|
||
if isinstance(value, dict):
|
||
return {k: _json(v) for k, v in value.items()}
|
||
return value
|