Merge remote-tracking branch 'origin/sub_laptop_4' into main_laptop_1

M02_MasterTemplete/M02_Hopyo_Basis.py

@@ -6,7 +6,8 @@
 출처 = 「…품셈」(오타 「품줌」) 뒤 20 글자 안 절 번호 — 앞 글에 산림 · 임도 = 산림품셈 ·
 그 밖 = 건설품셈 ·
 직종 = 「이름 : 수」 줄의 빈칸 뺀 이름이 우리 인력(LB) 이름 · 옛이름일 때만(지금 이름으로) ·
-글(338) = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안(맞춤 지문 재료).
+글(338) = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안(맞춤 지문 재료) · 산출근거 열이 빈 줄은
+그 오른쪽 ~ 돈 머리(맨 오른쪽 묶음) 앞 칸을 빈칸으로 이어 붙임(거창 꼴 · 돈 머리 없으면 `WIDE` 열).
 견줌(`candidates`) = 같은 책 조항 같음 1.0 · 윗마디 0.9(엑셀 6-2 ⊃ 우리 6-2-2) ·
 앞 마디 같음 0.5(조항이 안 맞으면 후보 아님 · `clause`) · 조항 오타 「13-114」 = 「13-11-4」 ·
 건설 공통 · 토목 덤 0.1 · 직종 겹침(보통인부 뺌) 0.5 · 단위 0.15 · 직종도 뜻 낱말도 안 겹치면 버림 ·
@@ -34,7 +35,7 @@ _HEAD = re.compile(r"^(\d+)\.\s*(.*?)\s*\[([^\[\]]*)\]\s*$")
 _BOOK = re.compile(r"품[셈줌]")
 _TRADE = re.compile(r"^[\s*·\-]*([가-힣][가-힣\s]*?)\s*:\s*[\d,]")
 _TYPO_CLAUSE = re.compile(r"^(\d+)-(\d)(\d)(\d)$")  # 「13-114」 = 13-11-4
-GLINES, GCHARS = 200, 300
+GLINES, GCHARS, WIDE = 200, 300, 140
 _TYPOS = (("깍기", "깎기"),)
 _PLAIN_WORDS = frozenset({"인력", "기계", "장비"})  # 방법 낱말 — 「터널굴착 1발파당 인력」
 _MONEY = {"합계": "계", "노무비": "노무비", "재료비": "재료비", "경비": "경비"}
@@ -45,6 +46,12 @@ def _flat(value: Any) -> str:
 
 
 # ── 엑셀 블록 읽기 ─────────────────────────────────────────────────────
+def _cell_text(value: Any) -> str:
+    if isinstance(value, float) and value == int(value):
+        value = int(value)
+    return str(value).strip() if value is not None else ""
+
+
 @lru_cache(maxsize=2)
 def _trade_names(whole_id: int) -> dict[str, str]:
     """{빈칸 뺀 이름 · 옛이름: 지금 이름} — 우리 인력(LB)."""
@@ -78,11 +85,15 @@ def sources(text: str) -> list[list[str]]:
 
 
 def _columns(rows: list[list[Any]]) -> tuple[int, int, dict[str, int]]:
-    """(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {})."""
+    """(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {}) ·
+    돈 머리가 둘 묶음이면 맨 오른쪽(거창 꼴 · 값이 든 쪽)."""
     for at, row in enumerate(rows[:10]):
         flat = [_flat(v) for v in row]
         if "산출근거" in flat:
-            money = {key: flat.index(head) for head, key in _MONEY.items() if head in flat}
+            last = len(flat) - 1
+            money = {
+                key: last - flat[::-1].index(head) for head, key in _MONEY.items() if head in flat
+            }
             return at + 1, flat.index("산출근거"), money
     return 0, 1, {}
 
@@ -93,14 +104,19 @@ def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]:
     if not rows:
         return {}
     start, col, money = _columns(rows)
+    end = min(money.values()) if money and min(money.values()) > col + 1 else WIDE
     names = trade_names()
     blocks: dict[int, dict[str, Any]] = {}
     block: dict[str, Any] | None = None
     for at, row in enumerate(rows[start:], start + 1):
         text = row[col] if col < len(row) else None
-        if not isinstance(text, str) or not text.strip():
-            continue
-        head = None if text[:1].isspace() else _HEAD.match(text)
+        head = None
+        if isinstance(text, str) and text.strip():
+            head = None if text[:1].isspace() else _HEAD.match(text)
+        else:
+            text = " ".join(_cell_text(v) for v in row[col + 1 : end] if _cell_text(v))
+            if not text:
+                continue
         if head:
             block = blocks.setdefault(
                 int(head.group(1)),

M02_MasterTemplete/M02_Hopyo_Excel.py

@@ -7,7 +7,12 @@
 호표 줄 = 「제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(줄 금액 합) · 총괄표 합계 —
 어긋남은 글 목록(막지 않음).
@@ -25,6 +30,7 @@ from decimal import ROUND_FLOOR, Decimal, InvalidOperation
 from typing import Any
 
 from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
+from M02_MasterTemplete import M02_Hopyo_Stmate as hopyo_stmate
 
 SHEET = "일위대가"
 SUMMARY = "일위대가총괄표"
@@ -32,7 +38,9 @@ COSTS = ("노무비", "재료비", "경비")
 HEADS = ("호표", "품명", "규격", "수량", "단위", "비고")
 NO_SHEET = "일위대가 시트 없음"
 _HOPYO = re.compile(r"제\s*(\d+)\s*호표")
-_REF = re.compile(r"^(단산|일위)\s*(\d+)\s*참조$")
+_REF = re.compile(r"^(?:(단산|산근|단가산출)|(일위대가|일위|대가))(\d+)(?:참조|호표)?$")
+DRM = "문서 보안(DRM)으로 잠긴 파일 — 보안을 푼 사본으로 저장해 올림"
+_OLE = b"\xd0\xcf\x11\xe0"
 _MACHINE_UNITS = ("hr", "시간", "h")
 
 
@@ -77,11 +85,15 @@ def _sheets(name: str, data: bytes) -> dict[str, list[list[Any]]]:
     wanted = (SHEET, SUMMARY, hopyo_basis.SHEET)
     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]):
+                wanted = hopyo_stmate.SHEETS
             out = {
                 ws.title.strip(): [list(row) for row in ws.iter_rows(values_only=True)]
                 for ws in book.worksheets
@@ -143,6 +155,8 @@ def kind_of(line: dict[str, Any]) -> str:
         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 "별도계상"
     if price.get("재료비") and not price.get("노무비") and not price.get("경비"):
@@ -208,10 +222,28 @@ def _summary(rows: list[list[Any]] | None) -> dict[int, Decimal]:
     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 수."""
     sheets = _sheets(name, data)
+    if hopyo_stmate.is_stmate(sheets):
+        return hopyo_stmate.read(sheets)
     rows = sheets.get(SHEET)
     if rows is None:
         raise ExcelError(NO_SHEET)
@@ -238,7 +270,7 @@ def read_book(name: str, data: bytes) -> dict[str, Any]:
         if head or not name_ or not hopyos:
             continue
         note = _text(_cell(row, cols.get("비고")))
-        ref = _REF.match(note.replace(" ", ""))
+        ref = _REF.match(_flat(note))
         line = {
             "차례": len(raw[-1]),
             "이름": name_,
@@ -248,7 +280,9 @@ def read_book(name: str, data: bytes) -> dict[str, Any]:
             "단가": _money(row, cols, 0),
             "금액": _money(row, cols, 1),
             "비고": note,
-            "참조": {"종류": ref.group(1), "번": int(ref.group(2))} if ref else None,
+            "참조": {"종류": "단산" if ref.group(1) else "일위", "번": int(ref.group(3))}
+            if ref
+            else None,
         }
         line["갈래"] = kind_of(line)
         line["행"] = hopyos[-1]["행"][1] = at
@@ -256,6 +290,7 @@ def read_book(name: str, data: bytes) -> dict[str, Any]:
     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["번"])):

M02_MasterTemplete/M02_Hopyo_Grid.py

@@ -1,11 +1,12 @@
-"""M02 일위대가 실무자료 엑셀꼴 격자(PLAN 329-1) — 올린 엑셀 「일위대가」 · 「단가산출」 시트 →
+"""M02 일위대가 실무자료 엑셀꼴 격자(PLAN 329-1) — 올린 엑셀 「일위대가」 · 「단가산출」 시트
+(STmate = 「일위대가표」 · 「단가산출근거」 · 338) →
 A00 산출근거 스프레드시트 Workbook(`A00_Common/spreadsheet/spreadsheet_types.ts` 꼴 ·
 읽기 전용 보기).
 
 xls = xlrd `formatting_info` — 값 · 병합 · 열 폭(÷256 글자) ·
 행 높이(÷20 pt · 시트 기본과 다른 것만) · 서식 표(글꼴 · 굵게 · 맞춤 · 줄바꿈 · 테두리 · 채움 ·
 숫자 형식) · 틀고정(파일 값 · 없으면 머리 4행).
-xlsx = 값만 · 넓은 시트는 머리 글(앞 4 줄) 마지막 열까지.
+xlsx = 값만 · 넓은 시트는 머리 글(앞 4 줄) 마지막 열까지 · STmate 숨은 칸 글(「_x0005_`BDCOD…」) 뺌.
 결과 `{책, 호표: [{번, 이름, 행}], 단산: [{번, 이름, 행}]}` — 행 = 엑셀 1부터 [시작, 끝].
 """
 
@@ -18,8 +19,9 @@ from openpyxl.utils import get_column_letter
 
 from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
 from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel
+from M02_MasterTemplete import M02_Hopyo_Stmate as hopyo_stmate
 
-SHEETS = (hopyo_excel.SHEET, hopyo_basis.SHEET)
+SHEETS = (hopyo_excel.SHEET, hopyo_basis.SHEET, hopyo_stmate.SHEET, hopyo_stmate.CALC)
 HEAD_ROWS = 4
 _HALIGN = {1: "left", 2: "center", 3: "right", 6: "centerContinuous", 7: "distributed"}
 _VALIGN = {0: "top", 1: "center"}
@@ -192,7 +194,7 @@ def _xlsx(name: str, data: bytes) -> dict[str, Any]:
             }
             for r, row in enumerate(rows)
             for c, v in enumerate(row[:width])
-            if v not in (None, "")
+            if v not in (None, "") and not str(v).startswith("_x000")  # STmate 숨은 칸 글
         }
         sheets.append({"id": f"s{at}", "이름": title, "칸": cells, "틀고정": {"행": HEAD_ROWS}})
     return {"서식": [{}], "시트": sheets}

M02_MasterTemplete/M02_Hopyo_Stmate.py

@@ -0,0 +1,264 @@
+"""M02 일위대가 실무자료 STmate 꼴 읽기(PLAN 338-2b) — 「일위대가표」 · 「단가산출근거」 시트 +
+목록표(노무비 · 중기 · 재료비 · 경비 · 단가산출근거) → 엑셀꼴과 같은 HP 꼴
+(`M02_Hopyo_Excel.read_book`).
+
+일위대가표 = A 열 「제N호표」 줄(B~Z 열 「BDCOD|B…」 = 호표 코드) → 다음 줄 A 이름 · B 규격 ·
+D 단위 → 구성 줄(A 이름 · B 규격 · C 수량 · D 단위 · E 계 · G 노무비 · I 재료비 · K 경비 단가 ·
+다음 열 금액 · M 비고) → 「합계」 줄에서 끝.
+줄 코드 = M~Z 열에서 `_CODE` 꼴 첫 것(판마다 열 수가 달라도 읽힘 · 하이퍼링크 안 읽음) ·
+코드 없는 줄 = 호표 `근거글`.
+갈래 = D 단가산출(참조 단산 · 번 = 코드 숫자) · B 호표(참조 일위 · 번 = 호표 코드 표) · L 노임 ·
+X 기계 · M 자재(비고 「별산」 · 규격 「별도계상」 · 값 없음 = 별도계상) · S · W 별도계상 ·
+PR · 단위 % = % · 그 밖 기타.
+단가산출근거 = 「BDCOD|D…」 머리 → 다음 머리 · 「총계」 앞까지 한 블록 · 글 = B 열(머리 이름 줄 ·
+소계 · 계 뺌) · 자원 = M 열 「X00000_n」 줄(품 = H 열 · 이름 · 규격 = X 열 「이름 / 규격」 ·
+비면 목록표 · 기계 셋 줄(노무비 · 재료비 · 경비)은 하나로 · 절 = 그 앞 번호 절 제목) ·
+머리 이름 · 규격 · 단위 = 단가산출근거목록표 · 출처 = 블록 글 `Basis.sources` ·
+직종 = 자원 L 이름(우리 인력 · 옛이름 = 지금 이름).
+검산 안 함 — `검산 {어긋남: [], 총괄표: 0}`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
+from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel  # 서로 부름 — 부를 때만 씀
+
+SHEET = "일위대가표"
+CALC = "단가산출근거"
+LISTS = ("단가산출근거목록표", "노무비목록표", "중기목록표", "재료비목록표", "경비목록표")
+SHEETS = (SHEET, CALC, *LISTS)
+_CODE = re.compile(r"^(?:COD\|)?([A-Z]{1,2}\d{5}|PR[A-Z]?\d+|[TC]\d+)(?:_\d+)?(?: →)?$")
+_META = re.compile(r"(?<![A-Z])COD\|([A-Z]{1,2}\d{5})")  # 숨은 칸 「`COD|L00001」
+_HEAD_B = re.compile(r"BDCOD\|(B\d{5})")
+_HEAD_D = re.compile(r"BDCOD\|(D\d{5})")
+_RES = re.compile(r"^([LMXS])(\d{5})_\d+$")
+_RES_A = re.compile(r"^([LMXS]\d{5})[LMS]$")  # A 열 「L00002L」
+_RES_G = re.compile(r"&([LMXS]\d{5})[LMS]&")  # G 열 식 「&L00002L&」
+_SECTION = re.compile(r"^\s*(?:\d+\s*[.)]|[①-⑩])\s*(.*\S)")
+_COLS = {"합계": 4, "노무비": 6, "재료비": 8, "경비": 10}
+NOTE, CODE_COLS, RES_COL, QTY_COL, NAME_COL = 12, range(12, 26), 12, 7, 23
+_KIND = {"D": "단가산출", "B": "호표", "L": "노임", "X": "기계", "S": "별도계상", "W": "별도계상"}
+
+
+def is_stmate(names: Any) -> bool:
+    return SHEET in names and CALC in names
+
+
+def _cell(row: list[Any], col: int) -> Any:
+    return row[col] if col < len(row) else None
+
+
+def _s(value: Any) -> str:
+    return hopyo_excel._text(value)
+
+
+def _flat(value: Any) -> str:
+    return re.sub(r"\s+", "", str(value or ""))
+
+
+def _code(row: list[Any], cols: Any = CODE_COLS) -> str | None:
+    for col in cols:
+        hit = _CODE.match(_s(_cell(row, col)))
+        if hit:
+            return hit.group(1)
+    return None
+
+
+def _lists(sheets: dict[str, list[list[Any]]]) -> dict[str, dict[str, str]]:
+    """목록표 → {코드: {이름, 규격, 단위}} — B 이름 · C 규격 · D 단위 · 코드 = 숨은 칸
+    「COD|…」 · 없으면 코드 꼴 첫 칸(판마다 A 열 · 뒤 열)."""
+    out: dict[str, dict[str, str]] = {}
+    for title in LISTS:
+        for row in sheets.get(title) or []:
+            meta = _META.search(" ".join(_s(v) for v in row))
+            code = meta.group(1) if meta else _code(row, range(len(row)))
+            if code and _s(_cell(row, 1)):
+                out[code] = {
+                    "이름": _s(row[1]),
+                    "규격": _s(_cell(row, 2)),
+                    "단위": _s(_cell(row, 3)),
+                }
+    return out
+
+
+# ── 단가산출근거 블록 ──────────────────────────────────────────────────
+def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]:
+    """{D 코드: {번, 코드, 이름, 규격, 단위, 행, 출처, 직종, 글, 자원}}."""
+    names = hopyo_basis.trade_names()
+    out: dict[str, dict[str, Any]] = {}
+    block: dict[str, Any] | None = None
+    title = ""
+    for at, row in enumerate(rows, 1):
+        head = next(
+            (hit for v in row[:8] if (hit := _HEAD_D.search(_s(v)))), None
+        )  # 머리 = G 열(판마다 B 열 글이 다름)
+        if head:
+            code = head.group(1)
+            info = table.get(code) or {}
+            block = out.setdefault(
+                code,
+                {
+                    "번": int(code[1:]),
+                    "코드": code,
+                    "이름": info.get("이름", ""),
+                    "규격": info.get("규격", ""),
+                    "단위": info.get("단위", ""),
+                    "행": [at, at],
+                    "글": [],
+                    "자원": [],
+                },
+            )
+            title = ""
+            continue
+        if block is None:
+            continue
+        first = _flat(_cell(row, 0))
+        if first.startswith("총계"):
+            block["행"][1] = at
+            block = None
+            continue
+        text = _s(_cell(row, 1))
+        res = _RES.match(_s(_cell(row, RES_COL)))
+        code = res.group(1) + res.group(2) if res else None
+        if not code:
+            alt = _RES_A.match(first) or _RES_G.search(_s(_cell(row, 6)))
+            code = alt.group(1) if alt else None
+        if not text and not code:
+            continue
+        block["행"][1] = at
+        if _s(_cell(row, RES_COL)) == block["코드"]:  # 머리 이름 줄 「이름 규격 / 단위」
+            if not block["이름"]:
+                name, _, unit = text.rpartition("/")
+                block["이름"], block["단위"] = name.strip() or text, unit.strip()
+            continue
+        if text and _flat(text) not in ("소계", "계"):
+            if len(block["글"]) < hopyo_basis.GLINES:
+                block["글"].append(text[: hopyo_basis.GCHARS])
+            if (sec := _SECTION.match(text)) and not re.match(r"^\s*\d+\.\d", text):
+                title = sec.group(1).strip()
+        if not code:
+            continue
+        last = block["자원"][-1] if block["자원"] else None
+        if code[0] == "X" and last and last["코드"] == code and last["절"] == title:
+            continue  # 기계 노무비 · 재료비 · 경비 셋 줄 = 하나
+        name, _, spec = _s(_cell(row, NAME_COL)).partition("/")
+        info = table.get(code) or {}
+        qty = hopyo_excel._num(_cell(row, QTY_COL))
+        block["자원"].append(
+            {
+                "갈래": code[0],
+                "코드": code,
+                "이름": name.strip() or info.get("이름", ""),
+                "규격": spec.strip() if name.strip() else info.get("규격", ""),
+                "품": float(qty) if qty is not None else None,
+                "절": title,
+            }
+        )
+    for block in out.values():
+        block["출처"] = hopyo_basis.sources(" ".join(block["글"]))
+        trades = [names.get(_flat(r["이름"])) for r in block["자원"] if r["갈래"] == "L"]
+        block["직종"] = list(dict.fromkeys(t for t in trades if t))
+    return out
+
+
+# ── 일위대가표 ────────────────────────────────────────────────────────
+def _kind(code: str, line: dict[str, Any]) -> str:
+    if code.startswith("PR") or _flat(line["단위"]) == "%":
+        return "%"
+    if code[0] == "M":
+        apart = line["비고"].startswith("별산") or line["규격"] == "별도계상"
+        return "별도계상" if apart or not any(line["단가"].values()) else "자재"
+    return _KIND.get(code[0], "기타")
+
+
+def _hopyos(rows: list[list[Any]]) -> tuple[list[dict[str, Any]], list[list[dict[str, Any]]]]:
+    hopyos: list[dict[str, Any]] = []
+    raw: list[list[dict[str, Any]]] = []
+    want_head = done = False
+    for at, row in enumerate(rows, 1):
+        first = _s(_cell(row, 0))
+        hit = hopyo_excel._HOPYO.fullmatch(_flat(first))
+        if hit:
+            code = next((m.group(1) for v in row[1:26] if (m := _HEAD_B.search(_s(v)))), None)
+            hopyos.append({"번": int(hit.group(1)), "코드": code, "행": [at, at], "근거글": []})
+            raw.append([])
+            want_head, done = True, False
+            continue
+        if not hopyos or done:
+            continue
+        hopyo = hopyos[-1]
+        if want_head:
+            hopyo.update(이름=first, 규격=_s(_cell(row, 1)), 단위=_s(_cell(row, 3)))
+            hopyo["금액"] = {}
+            want_head = False
+            continue
+        if _flat(first).startswith("합계") or _flat(first) == "계":
+            hopyo["금액"] = hopyo_excel._money(row, _COLS, 1)
+            done = True  # 끝 — 다음 호표까지 줄 안 받음
+            continue
+        if not first:
+            continue
+        code = _code(row)
+        hopyo["행"][1] = at
+        if not code:
+            if re.search(r"[0-9A-Za-z가-힣]", first):
+                hopyo["근거글"].append(f"{first} {_s(_cell(row, 1))}".strip())
+            continue
+        if code[0] in "TC" and code[1].isdigit():
+            continue  # 계 · 소계 · 계약단가
+        line = {
+            "차례": len(raw[-1]),
+            "이름": first,
+            "규격": _s(_cell(row, 1)),
+            "수량": hopyo_excel._num(_cell(row, 2)),
+            "단위": _s(_cell(row, 3)),
+            "단가": hopyo_excel._money(row, _COLS, 0),
+            "금액": hopyo_excel._money(row, _COLS, 1),
+            "비고": _s(_cell(row, NOTE)),
+            "코드": code,
+            "행": at,
+        }
+        line["갈래"] = _kind(code, line)
+        line["참조"] = (
+            {"종류": "단산", "번": int(code[1:]), "코드": code}
+            if code[0] == "D"
+            else {"종류": "일위", "번": None, "코드": code}
+            if code[0] == "B"
+            else None
+        )
+        raw[-1].append(line)
+    return hopyos, raw
+
+
+def read(sheets: dict[str, list[list[Any]]]) -> dict[str, Any]:
+    """STmate 시트 → HP 꼴 `{꼴, 시트, 호표, 단산, 검산}`(값은 JSON 수)."""
+    hopyos, raw = _hopyos(sheets.get(SHEET) or [])
+    if not hopyos:
+        raise hopyo_excel.ExcelError(f"{SHEET} 시트에 호표(제N호표)가 없음")
+    table = _lists(sheets)
+    blocks = _blocks(sheets.get(CALC) or [], table)
+    by_code = {h["코드"]: h["번"] for h in hopyos if h["코드"]}
+    for line in (one for lines in raw for one in lines):
+        ref = line["참조"] or {}
+        if ref.get("종류") == "일위":
+            ref["번"] = by_code.get(ref["코드"])
+        elif ref.get("종류") == "단산" and (block := blocks.get(ref["코드"])):
+            line["근거"] = {k: block[k] for k in ("출처", "직종", "행")}
+    out = []
+    for hopyo, lines in zip(hopyos, raw, strict=True):
+        for key in ("이름", "규격", "단위"):
+            hopyo.setdefault(key, "")
+        if not hopyo["근거글"]:
+            del hopyo["근거글"]
+        out.append({**hopyo_excel._json(hopyo), "줄": [hopyo_excel._json(x) for x in lines]})
+    keep = ("번", "코드", "이름", "규격", "단위", "행", "출처", "직종", "글", "자원")
+    return {
+        "꼴": "STmate",
+        "시트": SHEET,
+        "호표": out,
+        "단산": [{k: b[k] for k in keep} for b in blocks.values()],
+        "검산": {"어긋남": [], "총괄표": 0},
+    }