python-hwpx 2.8.2__py3-none-any.whl → 2.9.0__py3-none-any.whl

hwpx/__init__.py

@@ -10,8 +10,12 @@ def _resolve_version() -> str:
     except PackageNotFoundError:
         return "0+unknown"
 
+def __getattr__(name: str) -> object:
+    """Resolve dynamic module attributes."""
 
-__version__ = _resolve_version()
+    if name == "__version__":
+        return _resolve_version()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 from .tools.text_extractor import (
     DEFAULT_NAMESPACES,

hwpx/document.py

@@ -10,7 +10,7 @@ import logging
 import uuid
 
 from os import PathLike
-from typing import Any, BinaryIO, Iterator, Sequence, overload
+from typing import TYPE_CHECKING, Any, BinaryIO, Iterator, Mapping, Sequence, overload
 
 from lxml import etree
 
@@ -53,6 +53,9 @@ _HH = f"{{{_HH_NS}}}"
 
 logger = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    from .tools.table_navigation import TableFillResult, TableLabelSearchResult, TableMapResult
+
 
 def _append_element(
     parent: Any,
@@ -741,6 +744,34 @@ class HwpxDocument:
             char_pr_id_ref=char_pr_id_ref,
         )
 
+    def get_table_map(self) -> TableMapResult:
+        """Return compact metadata for every table in document order."""
+
+        from .tools.table_navigation import get_table_map
+
+        return get_table_map(self)
+
+    def find_cell_by_label(
+        self,
+        label_text: str,
+        direction: str = "right",
+    ) -> TableLabelSearchResult:
+        """Return every label/target cell pair that matches *label_text*."""
+
+        from .tools.table_navigation import find_cell_by_label
+
+        return find_cell_by_label(self, label_text, direction=direction)
+
+    def fill_by_path(
+        self,
+        mappings: Mapping[str, str],
+    ) -> TableFillResult:
+        """Fill table cells using ``label > direction > ...`` navigation paths."""
+
+        from .tools.table_navigation import fill_by_path
+
+        return fill_by_path(self, mappings)
+
     def add_shape(
         self,
         shape_type: str,

hwpx/tools/__init__.py

@@ -25,6 +25,19 @@ from .text_extractor import (
     describe_element_path,
     strip_namespace,
 )
+from .table_navigation import (
+    TableCellReference,
+    TableFillApplied,
+    TableFillFailed,
+    TableFillResult,
+    TableLabelMatch,
+    TableLabelSearchResult,
+    TableMapEntry,
+    TableMapResult,
+    fill_by_path,
+    find_cell_by_label,
+    get_table_map,
+)
 from .validator import (
     DocumentSchemas,
     ValidationIssue,
@@ -41,6 +54,17 @@ __all__ = [
     "build_parent_map",
     "describe_element_path",
     "strip_namespace",
+    "TableCellReference",
+    "TableFillApplied",
+    "TableFillFailed",
+    "TableFillResult",
+    "TableLabelMatch",
+    "TableLabelSearchResult",
+    "TableMapEntry",
+    "TableMapResult",
+    "fill_by_path",
+    "find_cell_by_label",
+    "get_table_map",
     "FoundElement",
     "ObjectFinder",
     "PackageValidationIssue",

hwpx/tools/table_navigation.py

@@ -0,0 +1,457 @@
+"""Reusable helpers for HWPX table discovery and form-like navigation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import TYPE_CHECKING, Literal, Mapping, TypedDict
+
+from ..oxml import HwpxOxmlParagraph, HwpxOxmlTable
+
+if TYPE_CHECKING:
+    from ..document import HwpxDocument
+
+__all__ = [
+    "SearchDirection",
+    "PathDirection",
+    "TableCellReference",
+    "TableFillApplied",
+    "TableFillFailed",
+    "TableFillResult",
+    "TableLabelMatch",
+    "TableLabelSearchResult",
+    "TableMapEntry",
+    "TableMapResult",
+    "fill_by_path",
+    "find_cell_by_label",
+    "get_table_map",
+]
+
+_HP_NS = "http://www.hancom.co.kr/hwpml/2011/paragraph"
+_HP = f"{{{_HP_NS}}}"
+_WHITESPACE_RE = re.compile(r"\s+")
+
+SearchDirection = Literal["right", "down"]
+PathDirection = Literal["left", "right", "up", "down"]
+
+
+class TableMapEntry(TypedDict):
+    """Compact metadata describing a table in document order."""
+
+    table_index: int
+    paragraph_index: int
+    rows: int
+    cols: int
+    header_text: str
+    first_row_preview: list[str]
+    is_empty: bool
+
+
+class TableMapResult(TypedDict):
+    """Collection of table metadata entries."""
+
+    tables: list[TableMapEntry]
+
+
+class TableCellReference(TypedDict):
+    """A logical table cell position and its current text."""
+
+    row: int
+    col: int
+    text: str
+
+
+class TableLabelMatch(TypedDict):
+    """A label cell and the cell reached from it."""
+
+    table_index: int
+    label_cell: TableCellReference
+    target_cell: TableCellReference
+
+
+class TableLabelSearchResult(TypedDict):
+    """Result payload returned by :func:`find_cell_by_label`."""
+
+    matches: list[TableLabelMatch]
+    count: int
+
+
+class TableFillApplied(TypedDict):
+    """A successfully applied path-based fill operation."""
+
+    path: str
+    table_index: int
+    row: int
+    col: int
+    value: str
+
+
+class TableFillFailed(TypedDict):
+    """A failed path-based fill operation and its reason."""
+
+    path: str
+    reason: str
+
+
+class TableFillResult(TypedDict):
+    """Batch fill summary for :func:`fill_by_path`."""
+
+    applied: list[TableFillApplied]
+    failed: list[TableFillFailed]
+    applied_count: int
+    failed_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class _AnchoredTable:
+    table: HwpxOxmlTable
+    paragraph_index: int
+    header_text: str
+
+
+@dataclass(frozen=True, slots=True)
+class _IndexedTable:
+    table_index: int
+    table: HwpxOxmlTable
+    paragraph_index: int
+    header_text: str
+
+
+@dataclass(frozen=True, slots=True)
+class _LabelCandidate:
+    table_index: int
+    table: HwpxOxmlTable
+    row: int
+    col: int
+    text: str
+
+
+def _collapse_whitespace(value: str) -> str:
+    return _WHITESPACE_RE.sub(" ", value).strip()
+
+
+def _normalize_label_text(value: str) -> str:
+    normalized = _collapse_whitespace(value).casefold()
+    while normalized.endswith((":", "：")):
+        normalized = normalized[:-1].rstrip()
+    return normalized
+
+
+def _direct_paragraph_text(paragraph: HwpxOxmlParagraph) -> str:
+    parts: list[str] = []
+    for run in paragraph.element.findall(f"{_HP}run"):
+        for child in run:
+            if child.tag == f"{_HP}t" and child.text:
+                parts.append(child.text)
+    return _collapse_whitespace("".join(parts))
+
+
+def _collect_tables_from_table(
+    table: HwpxOxmlTable,
+    *,
+    anchor_paragraph_index: int,
+    inherited_header_text: str,
+    sink: list[_AnchoredTable],
+) -> str:
+    last_header_text = inherited_header_text
+    for row in table.rows:
+        for cell in row.cells:
+            for paragraph in cell.paragraphs:
+                last_header_text = _collect_tables_from_paragraph(
+                    paragraph,
+                    anchor_paragraph_index=anchor_paragraph_index,
+                    inherited_header_text=last_header_text,
+                    sink=sink,
+                )
+    return last_header_text
+
+
+def _collect_tables_from_paragraph(
+    paragraph: HwpxOxmlParagraph,
+    *,
+    anchor_paragraph_index: int,
+    inherited_header_text: str,
+    sink: list[_AnchoredTable],
+) -> str:
+    paragraph_text_parts: list[str] = []
+    last_header_text = inherited_header_text
+
+    for run in paragraph.element.findall(f"{_HP}run"):
+        for child in run:
+            if child.tag == f"{_HP}t":
+                if child.text:
+                    paragraph_text_parts.append(child.text)
+                continue
+            if child.tag != f"{_HP}tbl":
+                continue
+
+            paragraph_prefix_text = _collapse_whitespace("".join(paragraph_text_parts))
+            header_text = paragraph_prefix_text or last_header_text
+            table = HwpxOxmlTable(child, paragraph)
+            sink.append(
+                _AnchoredTable(
+                    table=table,
+                    paragraph_index=anchor_paragraph_index,
+                    header_text=header_text,
+                )
+            )
+            last_header_text = _collect_tables_from_table(
+                table,
+                anchor_paragraph_index=anchor_paragraph_index,
+                inherited_header_text=header_text,
+                sink=sink,
+            )
+
+    paragraph_text = _collapse_whitespace("".join(paragraph_text_parts))
+    return paragraph_text or last_header_text
+
+
+def _collect_document_tables(document: HwpxDocument) -> list[_IndexedTable]:
+    anchored_tables: list[_AnchoredTable] = []
+    last_top_level_text = ""
+
+    for paragraph_index, paragraph in enumerate(document.paragraphs):
+        _collect_tables_from_paragraph(
+            paragraph,
+            anchor_paragraph_index=paragraph_index,
+            inherited_header_text=last_top_level_text,
+            sink=anchored_tables,
+        )
+        paragraph_text = _direct_paragraph_text(paragraph)
+        if paragraph_text:
+            last_top_level_text = paragraph_text
+
+    return [
+        _IndexedTable(
+            table_index=table_index,
+            table=item.table,
+            paragraph_index=item.paragraph_index,
+            header_text=item.header_text,
+        )
+        for table_index, item in enumerate(anchored_tables)
+    ]
+
+
+def _cell_text(table: HwpxOxmlTable, row_index: int, col_index: int) -> str:
+    return table.cell(row_index, col_index).text
+
+
+def _table_is_empty(table: HwpxOxmlTable) -> bool:
+    for row_index in range(table.row_count):
+        for col_index in range(table.column_count):
+            if _cell_text(table, row_index, col_index).strip():
+                return False
+    return True
+
+
+def _first_row_preview(table: HwpxOxmlTable) -> list[str]:
+    if table.row_count == 0:
+        return []
+    return [_cell_text(table, 0, col_index) for col_index in range(table.column_count)]
+
+
+def _direction_delta(direction: PathDirection) -> tuple[int, int]:
+    if direction == "right":
+        return (0, 1)
+    if direction == "left":
+        return (0, -1)
+    if direction == "down":
+        return (1, 0)
+    return (-1, 0)
+
+
+def _move(
+    table: HwpxOxmlTable,
+    row_index: int,
+    col_index: int,
+    direction: PathDirection,
+) -> tuple[int, int] | None:
+    row_delta, col_delta = _direction_delta(direction)
+    target_row = row_index + row_delta
+    target_col = col_index + col_delta
+    if target_row < 0 or target_col < 0:
+        return None
+    if target_row >= table.row_count or target_col >= table.column_count:
+        return None
+    return (target_row, target_col)
+
+
+def _find_label_candidates(
+    tables: list[_IndexedTable],
+    label_text: str,
+) -> list[_LabelCandidate]:
+    normalized_label = _normalize_label_text(label_text)
+    if not normalized_label:
+        raise ValueError("label_text must contain at least one non-whitespace character")
+
+    candidates: list[_LabelCandidate] = []
+    for table_ref in tables:
+        for row_index in range(table_ref.table.row_count):
+            for col_index in range(table_ref.table.column_count):
+                cell_text = _cell_text(table_ref.table, row_index, col_index)
+                if _normalize_label_text(cell_text) != normalized_label:
+                    continue
+                candidates.append(
+                    _LabelCandidate(
+                        table_index=table_ref.table_index,
+                        table=table_ref.table,
+                        row=row_index,
+                        col=col_index,
+                        text=cell_text,
+                    )
+                )
+    return candidates
+
+
+def _cell_reference(
+    table: HwpxOxmlTable,
+    row_index: int,
+    col_index: int,
+) -> TableCellReference:
+    return {
+        "row": row_index,
+        "col": col_index,
+        "text": _cell_text(table, row_index, col_index),
+    }
+
+
+def _parse_path(path: str) -> tuple[str | None, list[str], str | None]:
+    tokens = [token.strip() for token in path.split(">")]
+    if not tokens or not tokens[0]:
+        return (None, [], "path must start with a label")
+
+    label_text = tokens[0]
+    raw_directions = [token for token in tokens[1:] if token]
+    if not raw_directions:
+        return (label_text, [], "path must include at least one direction")
+    return (label_text, raw_directions, None)
+
+
+def get_table_map(document: HwpxDocument) -> TableMapResult:
+    """Return compact metadata for every table in document order."""
+
+    tables: list[TableMapEntry] = []
+    for table_ref in _collect_document_tables(document):
+        tables.append(
+            {
+                "table_index": table_ref.table_index,
+                "paragraph_index": table_ref.paragraph_index,
+                "rows": table_ref.table.row_count,
+                "cols": table_ref.table.column_count,
+                "header_text": table_ref.header_text,
+                "first_row_preview": _first_row_preview(table_ref.table),
+                "is_empty": _table_is_empty(table_ref.table),
+            }
+        )
+    return {"tables": tables}
+
+
+def find_cell_by_label(
+    document: HwpxDocument,
+    label_text: str,
+    direction: SearchDirection = "right",
+) -> TableLabelSearchResult:
+    """Find label cells and return the adjacent target cells that remain in bounds."""
+
+    if direction not in {"right", "down"}:
+        raise ValueError("direction must be one of: right, down")
+
+    matches: list[TableLabelMatch] = []
+    for candidate in _find_label_candidates(_collect_document_tables(document), label_text):
+        target = _move(candidate.table, candidate.row, candidate.col, direction)
+        if target is None:
+            continue
+        target_row, target_col = target
+        matches.append(
+            {
+                "table_index": candidate.table_index,
+                "label_cell": {
+                    "row": candidate.row,
+                    "col": candidate.col,
+                    "text": candidate.text,
+                },
+                "target_cell": _cell_reference(candidate.table, target_row, target_col),
+            }
+        )
+
+    return {
+        "matches": matches,
+        "count": len(matches),
+    }
+
+
+def fill_by_path(
+    document: HwpxDocument,
+    mappings: Mapping[str, str],
+) -> TableFillResult:
+    """Fill multiple table cells using label-based navigation paths."""
+
+    indexed_tables = _collect_document_tables(document)
+    applied: list[TableFillApplied] = []
+    failed: list[TableFillFailed] = []
+
+    for path, value in mappings.items():
+        label_text, raw_directions, path_error = _parse_path(path)
+        if path_error is not None or label_text is None:
+            failed.append({"path": path, "reason": path_error or "invalid path"})
+            continue
+
+        try:
+            candidates = _find_label_candidates(indexed_tables, label_text)
+        except ValueError as exc:
+            failed.append({"path": path, "reason": str(exc)})
+            continue
+
+        if not candidates:
+            failed.append({"path": path, "reason": "label not found"})
+            continue
+        if len(candidates) > 1:
+            failed.append({"path": path, "reason": "ambiguous label"})
+            continue
+
+        candidate = candidates[0]
+        current_row = candidate.row
+        current_col = candidate.col
+        navigation_failed = False
+
+        for raw_direction in raw_directions:
+            direction = raw_direction.casefold()
+            if direction not in {"left", "right", "up", "down"}:
+                failed.append(
+                    {
+                        "path": path,
+                        "reason": f"unsupported direction: {raw_direction}",
+                    }
+                )
+                navigation_failed = True
+                break
+
+            next_position = _move(candidate.table, current_row, current_col, direction)
+            if next_position is None:
+                failed.append({"path": path, "reason": "navigation out of bounds"})
+                navigation_failed = True
+                break
+
+            current_row, current_col = next_position
+
+        if navigation_failed:
+            continue
+
+        text_value = str(value)
+        candidate.table.set_cell_text(current_row, current_col, text_value, logical=True)
+        applied.append(
+            {
+                "path": path,
+                "table_index": candidate.table_index,
+                "row": current_row,
+                "col": current_col,
+                "value": text_value,
+            }
+        )
+
+    return {
+        "applied": applied,
+        "failed": failed,
+        "applied_count": len(applied),
+        "failed_count": len(failed),
+    }

{python_hwpx-2.8.2.dist-info → python_hwpx-2.9.0.dist-info}/METADATA

@@ -1,48 +1,15 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 2.8.2
+Version: 2.9.0
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
-License: Non-Commercial License
-        
-        Copyright (c) 2024 python-hwpx Maintainers
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to use,
-        copy, modify, merge, publish, distribute, and sublicense the Software only for
-        non-commercial purposes, subject to the following conditions:
-        
-        1. Non-Commercial Use Only. The Software may be used, copied, modified,
-        	merged, published, distributed, and sublicensed only for non-commercial
-        	purposes. "Non-Commercial" means use that is not primarily intended for or
-        	directed toward commercial advantage, monetary compensation, or any form of
-        	direct or indirect commercial exploitation.
-        
-        2. Attribution. The above copyright notice and this permission notice shall be
-        	included in all copies or substantial portions of the Software.
-        
-        3. No Warranty of Commercial Support. The maintainers are not obligated to
-        	provide commercial support, maintenance, or updates.
-        
-        THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-        If you require permissions to use this Software for commercial purposes,
-        please contact the copyright holders to negotiate an alternative licensing
-        arrangement.
-        
+License-Expression: LicenseRef-python-hwpx-NonCommercial
 Project-URL: Homepage, https://github.com/airmang/python-hwpx
 Project-URL: Documentation, https://github.com/airmang/python-hwpx/tree/main/docs
 Project-URL: Issues, https://github.com/airmang/python-hwpx/issues
 Keywords: hwp,hwpx,hancom,opc,xml
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -58,6 +25,7 @@ Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: twine>=4.0; extra == "dev"
 Requires-Dist: pytest>=7.4; extra == "dev"
 Provides-Extra: test
+Requires-Dist: build>=1.0; extra == "test"
 Requires-Dist: pytest>=7.4; extra == "test"
 Requires-Dist: pytest-cov>=5.0; extra == "test"
 Provides-Extra: typecheck
@@ -73,7 +41,7 @@ Dynamic: license-file
   <p align="center">
     <a href="https://pypi.org/project/python-hwpx/"><img src="https://img.shields.io/pypi/v/python-hwpx?color=blue&label=PyPI" alt="PyPI"></a>
     <a href="https://pypi.org/project/python-hwpx/"><img src="https://img.shields.io/pypi/pyversions/python-hwpx" alt="Python"></a>
-    <a href="https://github.com/airmang/python-hwpx/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green" alt="License"></a>
+    <a href="https://github.com/airmang/python-hwpx/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Custom%20Noncommercial-orange" alt="License: Custom Non-Commercial"></a>
     <a href="https://airmang.github.io/python-hwpx/"><img src="https://img.shields.io/badge/docs-Sphinx-8CA1AF" alt="Docs"></a>
   </p>
 </p>
@@ -153,6 +121,7 @@ doc.save_to_path("결과물.hwpx")
 | 📝 **단락** | 추가/삭제/편집/서식 | 텍스트 설정, 단락 삭제(`remove_paragraph`), 스타일 참조 |
 | ✏️ **Run** | 텍스트 조각 | 추가, 교체, 볼드/이탤릭/밑줄/색상 서식 |
 | 📊 **표(Table)** | 생성/편집/병합 | N×M 표 생성, 셀 텍스트, 셀 병합/분할, 중첩 테이블 |
+| 🧭 **표 자동화** | 탐색/채우기 | 테이블 맵, 라벨 기반 셀 탐색, 경로 기반 배치 채우기 |
 | 📑 **섹션** | 추가/삭제 | `add_section(after=)`, `remove_section()`, manifest 자동 관리 |
 | 🖼️ **이미지** | 임베드/삭제 | 바이너리 데이터 관리, manifest 자동 등록 |
 | ✏️ **도형** | 선/사각형/타원 | OWPML 명세 준수 도형 삽입 |
@@ -193,6 +162,17 @@ doc.set_footer_text("1 / 10", page_type="BOTH")
 # 표 셀 병합·분할
 table.merge_cells(0, 0, 1, 1)   # (0,0)~(1,1) 병합
 table.set_cell_text(0, 0, "병합된 셀", logical=True, split_merged=True)
+
+# 양식형 표 자동 채우기
+form = doc.add_table(2, 2)
+form.cell(0, 0).text = "성명:"
+form.cell(1, 0).text = "소속"
+
+doc.find_cell_by_label("성명")    # {"matches": [...], "count": 1}
+doc.fill_by_path({
+    "성명 > right": "홍길동",
+    "소속 > right": "플랫폼팀",
+})
 ```
 
 ### 🔍 텍스트 추출 & 검색
@@ -353,13 +333,15 @@ pytest
 
 ## License
 
-[MIT](LICENSE) © 고규현 (Kyuhyun Koh)
+[Custom Non-Commercial License](LICENSE) © python-hwpx Maintainers
+
+Commercial use requires separate permission from the copyright holders.
 
 <br>
 
-## Author
+## Maintainer
 
-**고규현** — 광교고등학교 정보·컴퓨터 교사
+Primary maintainer/contact: **고규현** — 광교고등학교 정보·컴퓨터 교사
 
 - ✉️ [kokyuhyun@hotmail.com](mailto:kokyuhyun@hotmail.com)
 - 🐙 [@airmang](https://github.com/airmang)

{python_hwpx-2.8.2.dist-info → python_hwpx-2.9.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-hwpx/__init__.py,sha256=RZ4O84G3Zp_L8ELArtwO3KVPvhx1vLYyKC2Ka1M5mwc,857
-hwpx/document.py,sha256=UnM61gSf9Hno5n0YWrVSTod9USmA3WtRQeeQadLbYdQ,48133
+hwpx/__init__.py,sha256=pReUJ2NBbrnHKZfAipQIxge5hCmgdUM1j7m-xxQyIkA,1046
+hwpx/document.py,sha256=B9qHnM6ttQPAz8-f47p0WdxUdz2QYeMLIt9qpAqBsvY,49124
 hwpx/package.py,sha256=YK4oYEPk7la2BZKZepoVHzrjGIPMDnDdPa02Hh-RTBw,1103
 hwpx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hwpx/templates.py,sha256=kZ_gV0bP-DIvr5CJuzs-uGnt8XVncJCI3cGFq083uTg,1149
@@ -21,21 +21,22 @@ hwpx/oxml/schema.py,sha256=THswXdMNpAiSoLxpvUGbdbI66hW-SKuUqSw4vdkIYmA,1246
 hwpx/oxml/section.py,sha256=WwxZ6PWPeMrj2L9mz4JlqFGXwd7E7qAuSBuM5dgRjZk,199
 hwpx/oxml/table.py,sha256=pdO2TTAcbEC6Z4cnaOnB-bcmuZ1KVado7J3RiY_zOfE,193
 hwpx/oxml/utils.py,sha256=to0yytS7vtLSvWl-dQyegT6MWClMK55b1Sp1uagEkI4,2591
-hwpx/tools/__init__.py,sha256=e1OaIVdbkmjTvLOzQ7qVRfuuQ1611225pNZByB2ln9w,1270
+hwpx/tools/__init__.py,sha256=kKcFSwpWFHRmXLL6AzLeS39-hWE6aBXPkp5yTbh9QuM,1800
 hwpx/tools/archive_cli.py,sha256=FauetaiLsU9dNtm7dswGrF9Q4f_UEse4_vwDk9qTyPE,11233
 hwpx/tools/exporter.py,sha256=GcbNtV4rIWOJv5nBcgdX0yfkXQa-xQhfrCzXWgaNbTE,8862
 hwpx/tools/object_finder.py,sha256=vbZ8FuIpGF-2vpbWDeZWi4UgZ2-3PK_ddQCs0oq1dRw,13440
 hwpx/tools/package_validator.py,sha256=jUwAV1L2SzDpNGLoZZJU7-YaA70Ob4WgQGsy7x9MXV0,12560
 hwpx/tools/page_guard.py,sha256=BFBIR2sB7-GjT1d0gWsGDD5PdB3xTvfUUvbRpmRgV1w,9663
+hwpx/tools/table_navigation.py,sha256=lIduw2JgEsHHvrrUtMinRLN7-dP9JXR3gNuFXj28mjs,13482
 hwpx/tools/template_analyzer.py,sha256=nYo3kvqXkkO4-NRizKWdyJcXfxN24-KMQPOZWbpwp5M,8459
 hwpx/tools/text_extract_cli.py,sha256=pIBMIFuFX10IEegw7fQ3gtUbQyjNgbAUYkQWh2S3aQs,2150
 hwpx/tools/text_extractor.py,sha256=LQOll7EZBP_QhRjiGofJAoMdZg7SUYVzeEr4JhMKYOg,25142
 hwpx/tools/validator.py,sha256=KThqBQKKQfZkuLMGtzONbPkzy877-2FgT22FHPmt_gI,5979
 hwpx/tools/_schemas/header.xsd,sha256=mJXuFMuHGT1JnFFaluUpYUglwjMCNlfbFCRVM26eHXE,664
 hwpx/tools/_schemas/section.xsd,sha256=MgvavVHG05RDfUnVPxVU10H4FQOja5ON04_m9Uk_m7E,522
-python_hwpx-2.8.2.dist-info/licenses/LICENSE,sha256=3F1-JUTcmjmxMpHGeB77ZzaSdhms3h8p1DBBa3lvV08,1609
-python_hwpx-2.8.2.dist-info/METADATA,sha256=GKeVKkR5JTyAZCzI0p83l9xJrX3ehK_s9PQw2Wf90qc,15325
-python_hwpx-2.8.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-python_hwpx-2.8.2.dist-info/entry_points.txt,sha256=zKneV9VceQKwbJUo-mUUbwRmQjNyNSzrv44XuMhsaUU,368
-python_hwpx-2.8.2.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
-python_hwpx-2.8.2.dist-info/RECORD,,
+python_hwpx-2.9.0.dist-info/licenses/LICENSE,sha256=3F1-JUTcmjmxMpHGeB77ZzaSdhms3h8p1DBBa3lvV08,1609
+python_hwpx-2.9.0.dist-info/METADATA,sha256=WB7KBgMf6DzWclgB9UnOKbOlOzxwphhHHCUDnlg60Mk,14084
+python_hwpx-2.9.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_hwpx-2.9.0.dist-info/entry_points.txt,sha256=zKneV9VceQKwbJUo-mUUbwRmQjNyNSzrv44XuMhsaUU,368
+python_hwpx-2.9.0.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
+python_hwpx-2.9.0.dist-info/RECORD,,

{python_hwpx-2.8.2.dist-info → python_hwpx-2.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.0)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any