python-hwpx 1.3__tar.gz → 1.5__tar.gz

{python-hwpx-1.3/src/python_hwpx.egg-info → python-hwpx-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hwpx
-Version: 1.3
+Version: 1.5
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License
@@ -38,7 +38,8 @@ Requires-Dist: pytest>=7.4; extra == "test"
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
 - **텍스트 추출 파이프라인** – `hwpx.tools.text_extractor.TextExtractor`는 하이라이트, 각주, 컨트롤을 원하는 방식으로 표현하며 문단 텍스트를 반환합니다.
@@ -78,6 +79,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -89,6 +91,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.3 → python-hwpx-1.5}/README.md

@@ -8,7 +8,8 @@
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
 - **텍스트 추출 파이프라인** – `hwpx.tools.text_extractor.TextExtractor`는 하이라이트, 각주, 컨트롤을 원하는 방식으로 표현하며 문단 텍스트를 반환합니다.
@@ -48,6 +49,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -59,6 +61,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.3 → python-hwpx-1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "1.3"
+version = "1.5"
 description = "Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "Non-Commercial License" }

{python-hwpx-1.3 → python-hwpx-1.5}/src/hwpx/document.py

@@ -11,15 +11,19 @@ from typing import BinaryIO, Iterator, List, Tuple
 
 from .oxml import (
     Bullet,
+    GenericElement,
     HwpxOxmlDocument,
     HwpxOxmlHeader,
+    HwpxOxmlHistory,
     HwpxOxmlInlineObject,
+    HwpxOxmlMasterPage,
     HwpxOxmlMemo,
     HwpxOxmlParagraph,
     HwpxOxmlRun,
     HwpxOxmlSection,
     HwpxOxmlSectionHeaderFooter,
     HwpxOxmlTable,
+    HwpxOxmlVersion,
     MemoShape,
     ParagraphProperty,
     RunStyle,
@@ -89,6 +93,32 @@ class HwpxDocument:
         """Return the header parts referenced by the document."""
         return self._root.headers
 
+    @property
+    def master_pages(self) -> List[HwpxOxmlMasterPage]:
+        """Return the master-page parts declared in the manifest."""
+        return self._root.master_pages
+
+    @property
+    def histories(self) -> List[HwpxOxmlHistory]:
+        """Return document history parts referenced by the manifest."""
+        return self._root.histories
+
+    @property
+    def version(self) -> HwpxOxmlVersion | None:
+        """Return the version metadata part if present."""
+        return self._root.version
+
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        """Return border fill definitions declared in the headers."""
+
+        return self._root.border_fills
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        """Return the border fill definition referenced by *border_fill_id_ref*."""
+
+        return self._root.border_fill(border_fill_id_ref)
+
     @property
     def memo_shapes(self) -> dict[str, MemoShape]:
         """Return memo shapes available in the header reference lists."""
@@ -511,7 +541,7 @@ class HwpxDocument:
         section_index: int | None = None,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
         para_pr_id_ref: str | int | None = None,
         style_id_ref: str | int | None = None,
         char_pr_id_ref: str | int | None = None,
@@ -520,6 +550,10 @@ class HwpxDocument:
     ) -> HwpxOxmlTable:
         """Create a table in a new paragraph and return it."""
 
+        resolved_border_fill: str | int | None = border_fill_id_ref
+        if resolved_border_fill is None:
+            resolved_border_fill = self._root.ensure_basic_border_fill()
+
         paragraph = self.add_paragraph(
             "",
             section=section,
@@ -535,7 +569,7 @@ class HwpxDocument:
             cols,
             width=width,
             height=height,
-            border_fill_id_ref=border_fill_id_ref,
+            border_fill_id_ref=resolved_border_fill,
             run_attributes=run_attributes,
             char_pr_id_ref=char_pr_id_ref,
         )

{python-hwpx-1.3 → python-hwpx-1.5}/src/hwpx/oxml/__init__.py

@@ -19,7 +19,9 @@ from .document import (
     DocumentNumbering,
     HwpxOxmlDocument,
     HwpxOxmlHeader,
+    HwpxOxmlHistory,
     HwpxOxmlInlineObject,
+    HwpxOxmlMasterPage,
     HwpxOxmlMemo,
     HwpxOxmlMemoGroup,
     HwpxOxmlParagraph,
@@ -30,6 +32,7 @@ from .document import (
     HwpxOxmlTable,
     HwpxOxmlTableCell,
     HwpxOxmlTableRow,
+    HwpxOxmlVersion,
     PageMargins,
     PageSize,
     RunStyle,
@@ -126,7 +129,9 @@ __all__ = [
     "DocumentNumbering",
     "HwpxOxmlDocument",
     "HwpxOxmlHeader",
+    "HwpxOxmlHistory",
     "HwpxOxmlInlineObject",
+    "HwpxOxmlMasterPage",
     "HwpxOxmlMemo",
     "HwpxOxmlMemoGroup",
     "HwpxOxmlParagraph",
@@ -137,6 +142,7 @@ __all__ = [
     "HwpxOxmlTable",
     "HwpxOxmlTableCell",
     "HwpxOxmlTableRow",
+    "HwpxOxmlVersion",
     "KeyDerivation",
     "KeyEncryption",
     "LinkInfo",

{python-hwpx-1.3 → python-hwpx-1.5}/src/hwpx/oxml/document.py

@@ -11,6 +11,7 @@ import xml.etree.ElementTree as ET
 from lxml import etree as LET
 
 from . import body
+from .common import GenericElement
 from .header import (
     Bullet,
     MemoProperties,
@@ -21,6 +22,7 @@ from .header import (
     TrackChangeAuthor,
     memo_shape_from_attributes,
     parse_bullets,
+    parse_border_fills,
     parse_paragraph_properties,
     parse_styles,
     parse_track_change_authors,
@@ -44,6 +46,23 @@ _DEFAULT_PARAGRAPH_ATTRS = {
 _DEFAULT_CELL_WIDTH = 7200
 _DEFAULT_CELL_HEIGHT = 3600
 
+_BASIC_BORDER_FILL_ATTRIBUTES = {
+    "threeD": "0",
+    "shadow": "0",
+    "centerLine": "NONE",
+    "breakCellSeparateLine": "0",
+}
+
+_BASIC_BORDER_CHILDREN: Tuple[Tuple[str, dict[str, str]], ...] = (
+    ("slash", {"type": "NONE", "Crooked": "0", "isCounter": "0"}),
+    ("backSlash", {"type": "NONE", "Crooked": "0", "isCounter": "0"}),
+    ("leftBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("rightBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("topBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("bottomBorder", {"type": "SOLID", "width": "0.12 mm", "color": "#000000"}),
+    ("diagonal", {"type": "SOLID", "width": "0.1 mm", "color": "#000000"}),
+)
+
 T = TypeVar("T")
 
 
@@ -107,6 +126,59 @@ def _element_local_name(node: ET.Element) -> str:
     return tag
 
 
+def _normalize_length(value: str | None) -> str:
+    if value is None:
+        return ""
+    return value.replace(" ", "").lower()
+
+
+def _border_fill_is_basic_solid_line(element: ET.Element) -> bool:
+    if _element_local_name(element) != "borderFill":
+        return False
+
+    for attr, expected in _BASIC_BORDER_FILL_ATTRIBUTES.items():
+        actual = element.get(attr)
+        if attr == "centerLine":
+            if (actual or "").upper() != expected:
+                return False
+        else:
+            if actual != expected:
+                return False
+
+    for child_name, child_attrs in _BASIC_BORDER_CHILDREN:
+        child = element.find(f"{_HH}{child_name}")
+        if child is None:
+            return False
+        for attr, expected in child_attrs.items():
+            actual = child.get(attr)
+            if attr == "type":
+                if (actual or "").upper() != expected:
+                    return False
+            elif attr == "width":
+                if _normalize_length(actual) != _normalize_length(expected):
+                    return False
+            elif attr == "color":
+                if (actual or "").upper() != expected.upper():
+                    return False
+            else:
+                if actual != expected:
+                    return False
+
+    for child in element:
+        if _element_local_name(child) == "fillBrush":
+            return False
+
+    return True
+
+
+def _create_basic_border_fill_element(border_id: str) -> ET.Element:
+    attrs = {"id": border_id, **_BASIC_BORDER_FILL_ATTRIBUTES}
+    element = ET.Element(f"{_HH}borderFill", attrs)
+    for child_name, child_attrs in _BASIC_BORDER_CHILDREN:
+        ET.SubElement(element, f"{_HH}{child_name}", dict(child_attrs))
+    return element
+
+
 def _distribute_size(total: int, parts: int) -> List[int]:
     """Return *parts* integers that sum to *total* and are as even as possible."""
 
@@ -1525,13 +1597,15 @@ class HwpxOxmlTable:
         *,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
     ) -> ET.Element:
         if rows <= 0 or cols <= 0:
             raise ValueError("rows and cols must be positive integers")
 
         table_width = width if width is not None else cols * _DEFAULT_CELL_WIDTH
         table_height = height if height is not None else rows * _DEFAULT_CELL_HEIGHT
+        if border_fill_id_ref is None:
+            raise ValueError("border_fill_id_ref must be provided")
         border_fill = str(border_fill_id_ref)
 
         table_attrs = {
@@ -1864,10 +1938,19 @@ class HwpxOxmlParagraph:
         *,
         width: int | None = None,
         height: int | None = None,
-        border_fill_id_ref: str | int = "0",
+        border_fill_id_ref: str | int | None = None,
         run_attributes: dict[str, str] | None = None,
         char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlTable:
+        if border_fill_id_ref is None:
+            document = self.section.document
+            if document is not None:
+                resolved_border_fill: str | int = document.ensure_basic_border_fill()
+            else:
+                resolved_border_fill = "0"
+        else:
+            resolved_border_fill = border_fill_id_ref
+
         run = self._create_run_for_object(
             run_attributes,
             char_pr_id_ref=char_pr_id_ref,
@@ -1877,7 +1960,7 @@ class HwpxOxmlParagraph:
             cols,
             width=width,
             height=height,
-            border_fill_id_ref=border_fill_id_ref,
+            border_fill_id_ref=resolved_border_fill,
         )
         run.append(table_element)
         self.section.mark_dirty()
@@ -1999,6 +2082,61 @@ class HwpxOxmlParagraph:
             self.section.mark_dirty()
 
 
+class _HwpxOxmlSimplePart:
+    """Common base for standalone XML parts that are not sections or headers."""
+
+    def __init__(
+        self,
+        part_name: str,
+        element: ET.Element,
+        document: "HwpxOxmlDocument" | None = None,
+    ):
+        self.part_name = part_name
+        self._element = element
+        self._document = document
+        self._dirty = False
+
+    @property
+    def element(self) -> ET.Element:
+        return self._element
+
+    @property
+    def document(self) -> "HwpxOxmlDocument" | None:
+        return self._document
+
+    def attach_document(self, document: "HwpxOxmlDocument") -> None:
+        self._document = document
+
+    @property
+    def dirty(self) -> bool:
+        return self._dirty
+
+    def mark_dirty(self) -> None:
+        self._dirty = True
+
+    def reset_dirty(self) -> None:
+        self._dirty = False
+
+    def replace_element(self, element: ET.Element) -> None:
+        self._element = element
+        self.mark_dirty()
+
+    def to_bytes(self) -> bytes:
+        return _serialize_xml(self._element)
+
+
+class HwpxOxmlMasterPage(_HwpxOxmlSimplePart):
+    """Represents a master page part in the package."""
+
+
+class HwpxOxmlHistory(_HwpxOxmlSimplePart):
+    """Represents a document history part."""
+
+
+class HwpxOxmlVersion(_HwpxOxmlSimplePart):
+    """Represents the ``version.xml`` part."""
+
+
 class HwpxOxmlSection:
     """Represents the contents of a section XML part."""
 
@@ -2198,6 +2336,16 @@ class HwpxOxmlHeader:
             self.mark_dirty()
         return element
 
+    def _border_fills_element(self, create: bool = False) -> ET.Element | None:
+        ref_list = self._ref_list_element(create=create)
+        if ref_list is None:
+            return None
+        element = ref_list.find(f"{_HH}borderFills")
+        if element is None and create:
+            element = ET.SubElement(ref_list, f"{_HH}borderFills", {"itemCnt": "0"})
+            self.mark_dirty()
+        return element
+
     def _char_properties_element(self, create: bool = False) -> ET.Element | None:
         ref_list = self._ref_list_element(create=create)
         if ref_list is None:
@@ -2212,6 +2360,10 @@ class HwpxOxmlHeader:
         count = len(list(element.findall(f"{_HH}charPr")))
         element.set("itemCnt", str(count))
 
+    def _update_border_fills_item_count(self, element: ET.Element) -> None:
+        count = len(list(element.findall(f"{_HH}borderFill")))
+        element.set("itemCnt", str(count))
+
     def _allocate_char_property_id(
         self,
         element: ET.Element,
@@ -2242,6 +2394,26 @@ class HwpxOxmlHeader:
             candidate = str(next_id)
         return candidate
 
+    def _allocate_border_fill_id(self, element: ET.Element) -> str:
+        existing: set[str] = {
+            child.get("id") or ""
+            for child in element.findall(f"{_HH}borderFill")
+        }
+        existing.discard("")
+
+        numeric_ids: List[int] = []
+        for value in existing:
+            try:
+                numeric_ids.append(int(value))
+            except ValueError:
+                continue
+        next_id = 0 if not numeric_ids else max(numeric_ids) + 1
+        candidate = str(next_id)
+        while candidate in existing:
+            next_id += 1
+            candidate = str(next_id)
+        return candidate
+
     def ensure_char_property(
         self,
         *,
@@ -2331,6 +2503,59 @@ class HwpxOxmlHeader:
             return None
         return ref_list.find(f"{_HH}trackChangeAuthors")
 
+    def find_basic_border_fill_id(self) -> str | None:
+        element = self._border_fills_element()
+        if element is None:
+            return None
+        for child in element.findall(f"{_HH}borderFill"):
+            if _border_fill_is_basic_solid_line(child):
+                identifier = child.get("id")
+                if identifier:
+                    return identifier
+        return None
+
+    def ensure_basic_border_fill(self) -> str:
+        element = self._border_fills_element(create=True)
+        if element is None:  # pragma: no cover - defensive branch
+            raise RuntimeError("failed to create <borderFills> element")
+
+        existing = self.find_basic_border_fill_id()
+        if existing is not None:
+            return existing
+
+        new_id = self._allocate_border_fill_id(element)
+        element.append(_create_basic_border_fill_element(new_id))
+        self._update_border_fills_item_count(element)
+        self.mark_dirty()
+        return new_id
+
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        element = self._border_fills_element()
+        if element is None:
+            return {}
+
+        fill_list = parse_border_fills(self._convert_to_lxml(element))
+        mapping: dict[str, GenericElement] = {}
+        for border_fill in fill_list.fills:
+            raw_id = border_fill.attributes.get("id")
+            keys: List[str] = []
+            if raw_id:
+                keys.append(raw_id)
+                try:
+                    normalized = str(int(raw_id))
+                except ValueError:
+                    normalized = None
+                if normalized and normalized not in keys:
+                    keys.append(normalized)
+            for key in keys:
+                if key not in mapping:
+                    mapping[key] = border_fill
+        return mapping
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        return self._lookup_by_id(self.border_fills, border_fill_id_ref)
+
     @staticmethod
     def _convert_to_lxml(element: ET.Element) -> LET._Element:
         return LET.fromstring(ET.tostring(element, encoding="utf-8"))
@@ -2540,16 +2765,29 @@ class HwpxOxmlDocument:
         manifest: ET.Element,
         sections: Sequence[HwpxOxmlSection],
         headers: Sequence[HwpxOxmlHeader],
+        *,
+        master_pages: Sequence[HwpxOxmlMasterPage] | None = None,
+        histories: Sequence[HwpxOxmlHistory] | None = None,
+        version: HwpxOxmlVersion | None = None,
     ):
         self._manifest = manifest
         self._sections = list(sections)
         self._headers = list(headers)
+        self._master_pages = list(master_pages or [])
+        self._histories = list(histories or [])
+        self._version = version
         self._char_property_cache: dict[str, RunStyle] | None = None
 
         for section in self._sections:
             section.attach_document(self)
         for header in self._headers:
             header.attach_document(self)
+        for master_page in self._master_pages:
+            master_page.attach_document(self)
+        for history in self._histories:
+            history.attach_document(self)
+        if self._version is not None:
+            self._version.attach_document(self)
 
     @classmethod
     def from_package(cls, package: "HwpxPackage") -> "HwpxOxmlDocument":
@@ -2561,12 +2799,35 @@ class HwpxOxmlDocument:
         manifest = package.get_xml(package.MANIFEST_PATH)
         section_paths = package.section_paths()
         header_paths = package.header_paths()
+        master_page_paths = package.master_page_paths()
+        history_paths = package.history_paths()
+        version_path = package.version_path()
 
         sections = [
             HwpxOxmlSection(path, package.get_xml(path)) for path in section_paths
         ]
         headers = [HwpxOxmlHeader(path, package.get_xml(path)) for path in header_paths]
-        return cls(manifest, sections, headers)
+        master_pages = [
+            HwpxOxmlMasterPage(path, package.get_xml(path))
+            for path in master_page_paths
+            if package.has_part(path)
+        ]
+        histories = [
+            HwpxOxmlHistory(path, package.get_xml(path))
+            for path in history_paths
+            if package.has_part(path)
+        ]
+        version = None
+        if version_path and package.has_part(version_path):
+            version = HwpxOxmlVersion(version_path, package.get_xml(version_path))
+        return cls(
+            manifest,
+            sections,
+            headers,
+            master_pages=master_pages,
+            histories=histories,
+            version=version,
+        )
 
     @property
     def manifest(self) -> ET.Element:
@@ -2580,6 +2841,18 @@ class HwpxOxmlDocument:
     def headers(self) -> List[HwpxOxmlHeader]:
         return list(self._headers)
 
+    @property
+    def master_pages(self) -> List[HwpxOxmlMasterPage]:
+        return list(self._master_pages)
+
+    @property
+    def histories(self) -> List[HwpxOxmlHistory]:
+        return list(self._histories)
+
+    @property
+    def version(self) -> HwpxOxmlVersion | None:
+        return self._version
+
     def _ensure_char_property_cache(self) -> dict[str, RunStyle]:
         if self._char_property_cache is None:
             mapping: dict[str, RunStyle] = {}
@@ -2685,6 +2958,27 @@ class HwpxOxmlDocument:
             raise RuntimeError("charPr element is missing an id")
         return char_id
 
+    @property
+    def border_fills(self) -> dict[str, GenericElement]:
+        mapping: dict[str, GenericElement] = {}
+        for header in self._headers:
+            mapping.update(header.border_fills)
+        return mapping
+
+    def border_fill(self, border_fill_id_ref: int | str | None) -> GenericElement | None:
+        return HwpxOxmlHeader._lookup_by_id(self.border_fills, border_fill_id_ref)
+
+    def ensure_basic_border_fill(self) -> str:
+        if not self._headers:
+            return "0"
+
+        for header in self._headers:
+            existing = header.find_basic_border_fill_id()
+            if existing is not None:
+                return existing
+
+        return self._headers[0].ensure_basic_border_fill()
+
     @property
     def memo_shapes(self) -> dict[str, MemoShape]:
         shapes: dict[str, MemoShape] = {}
@@ -2812,6 +3106,14 @@ class HwpxOxmlDocument:
                 headers_dirty = True
         if headers_dirty:
             self.invalidate_char_property_cache()
+        for master_page in self._master_pages:
+            if master_page.dirty:
+                updates[master_page.part_name] = master_page.to_bytes()
+        for history in self._histories:
+            if history.dirty:
+                updates[history.part_name] = history.to_bytes()
+        if self._version is not None and self._version.dirty:
+            updates[self._version.part_name] = self._version.to_bytes()
         return updates
 
     def reset_dirty(self) -> None:
@@ -2820,3 +3122,9 @@ class HwpxOxmlDocument:
             section.reset_dirty()
         for header in self._headers:
             header.reset_dirty()
+        for master_page in self._master_pages:
+            master_page.reset_dirty()
+        for history in self._histories:
+            history.reset_dirty()
+        if self._version is not None:
+            self._version.reset_dirty()

{python-hwpx-1.3 → python-hwpx-1.5}/src/hwpx/package.py

@@ -11,6 +11,21 @@ from zipfile import ZIP_DEFLATED, ZipFile
 _OPF_NS = "http://www.idpf.org/2007/opf/"
 
 
+def _normalized_manifest_value(element: ET.Element) -> str:
+    values = [
+        element.attrib.get("id", ""),
+        element.attrib.get("href", ""),
+        element.attrib.get("media-type", ""),
+        element.attrib.get("properties", ""),
+    ]
+    return " ".join(part.lower() for part in values if part)
+
+
+def _manifest_matches(element: ET.Element, *candidates: str) -> bool:
+    normalized = _normalized_manifest_value(element)
+    return any(candidate in normalized for candidate in candidates if candidate)
+
+
 def _ensure_bytes(value: bytes | str | ET.Element) -> bytes:
     if isinstance(value, bytes):
         return value
@@ -38,6 +53,10 @@ class HwpxPackage:
         self._spine_cache: list[str] | None = None
         self._section_paths_cache: list[str] | None = None
         self._header_paths_cache: list[str] | None = None
+        self._master_page_paths_cache: list[str] | None = None
+        self._history_paths_cache: list[str] | None = None
+        self._version_path_cache: str | None = None
+        self._version_path_cache_resolved = False
 
     # -- construction ----------------------------------------------------
     @classmethod
@@ -85,6 +104,12 @@ class HwpxPackage:
             self._spine_cache = None
             self._section_paths_cache = None
             self._header_paths_cache = None
+            self._master_page_paths_cache = None
+            self._history_paths_cache = None
+            self._version_path_cache = None
+            self._version_path_cache_resolved = False
+        elif part_name == "version.xml":
+            self._version_path_cache_resolved = False
 
     def get_xml(self, part_name: str) -> ET.Element:
         return ET.fromstring(self.get_part(part_name))
@@ -101,6 +126,11 @@ class HwpxPackage:
             self._manifest_tree = self.get_xml(self.MANIFEST_PATH)
         return self._manifest_tree
 
+    def _manifest_items(self) -> list[ET.Element]:
+        manifest = self.manifest_tree()
+        ns = {"opf": _OPF_NS}
+        return list(manifest.findall("./opf:manifest/opf:item", ns))
+
     def _resolve_spine_paths(self) -> list[str]:
         if self._spine_cache is None:
             manifest = self.manifest_tree()
@@ -155,6 +185,64 @@ class HwpxPackage:
             self._header_paths_cache = paths
         return list(self._header_paths_cache)
 
+    def master_page_paths(self) -> list[str]:
+        if self._master_page_paths_cache is None:
+            from pathlib import PurePosixPath
+
+            paths = [
+                item.attrib.get("href", "")
+                for item in self._manifest_items()
+                if _manifest_matches(item, "masterpage", "master-page")
+                and item.attrib.get("href")
+            ]
+
+            if not paths:
+                paths = [
+                    name
+                    for name in self._parts.keys()
+                    if "master" in PurePosixPath(name).name.lower()
+                    and "page" in PurePosixPath(name).name.lower()
+                ]
+
+            self._master_page_paths_cache = paths
+        return list(self._master_page_paths_cache)
+
+    def history_paths(self) -> list[str]:
+        if self._history_paths_cache is None:
+            from pathlib import PurePosixPath
+
+            paths = [
+                item.attrib.get("href", "")
+                for item in self._manifest_items()
+                if _manifest_matches(item, "history")
+                and item.attrib.get("href")
+            ]
+
+            if not paths:
+                paths = [
+                    name
+                    for name in self._parts.keys()
+                    if "history" in PurePosixPath(name).name.lower()
+                ]
+
+            self._history_paths_cache = paths
+        return list(self._history_paths_cache)
+
+    def version_path(self) -> str | None:
+        if not self._version_path_cache_resolved:
+            path: str | None = None
+            for item in self._manifest_items():
+                if _manifest_matches(item, "version"):
+                    href = item.attrib.get("href", "").strip()
+                    if href:
+                        path = href
+                        break
+            if path is None and self.has_part("version.xml"):
+                path = "version.xml"
+            self._version_path_cache = path
+            self._version_path_cache_resolved = True
+        return self._version_path_cache
+
     # -- saving ----------------------------------------------------------
     def save(
         self,

{python-hwpx-1.3 → python-hwpx-1.5/src/python_hwpx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-hwpx
-Version: 1.3
+Version: 1.5
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License
@@ -38,7 +38,8 @@ Requires-Dist: pytest>=7.4; extra == "test"
 - **문서 편집 API** – `hwpx.document.HwpxDocument`는 문단과 표, 메모, 헤더 속성을 파이썬 객체로 노출하고 새 콘텐츠를 손쉽게 추가합니다. 섹션 머리말·꼬리말을 수정하면 `<hp:headerApply>`/`<hp:footerApply>`와 마스터 페이지 링크도 함께 갱신합니다.
 - **타입이 지정된 본문 모델** – `hwpx.oxml.body`는 표·컨트롤·인라인 도형·변경 추적 태그를 데이터 클래스에 매핑하고, `HwpxOxmlParagraph.model`/`HwpxOxmlRun.model`로 이를 조회·수정한 뒤 XML로 되돌릴 수 있도록 지원합니다.
 - **메모와 필드 앵커** – `add_memo_with_anchor()`로 메모를 생성하면서 MEMO 필드 컨트롤을 자동 삽입해 한/글에서 바로 표시되도록 합니다.
-- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **헤더 참조 목록 탐색** – 글머리표, 문단 속성, 테두리 채우기, 스타일, 변경 추적 항목, 작성자 정보를 데이터클래스로 파싱하고 `document.border_fills`·`document.bullets`·`document.styles` 같은 조회 헬퍼로 ID 기반 검색을 단순화했습니다.
+- **바탕쪽·이력·버전 파트 제어** – 매니페스트에 포함된 master-page/history/version 파트를 `document.master_pages`, `document.histories`, `document.version`으로 직접 편집하고 저장합니다.
 - **스타일 기반 텍스트 치환** – 런 서식(색상, 밑줄, `charPrIDRef`)으로 필터링해 텍스트를 선택적으로 교체하거나 삭제합니다. 하이라이트
   마커나 태그로 분리된 문자열도 서식을 유지한 채 치환합니다.
 - **텍스트 추출 파이프라인** – `hwpx.tools.text_extractor.TextExtractor`는 하이라이트, 각주, 컨트롤을 원하는 방식으로 표현하며 문단 텍스트를 반환합니다.
@@ -78,6 +79,7 @@ print("sections:", len(document.sections))
 # 2) 문단과 표, 메모 추가
 section = document.sections[0]
 paragraph = document.add_paragraph("자동 생성한 문단", section=section)
+# 표에 사용할 기본 실선 테두리 채우기가 없으면 add_table()이 자동으로 생성합니다.
 table = document.add_table(rows=2, cols=2, section=section)
 table.set_cell_text(0, 0, "항목")
 table.set_cell_text(0, 1, "값")
@@ -89,6 +91,8 @@ document.add_memo_with_anchor("배포 전 검토", paragraph=paragraph, memo_sha
 document.save("output/example.hwpx")
 ```
 
+`HwpxDocument.add_table()`은 문서에 정의된 테두리 채우기가 없으면 헤더 참조 목록에 "기본 실선" `borderFill`을 만들어 표와 모든 셀에 참조를 연결합니다.
+
 더 많은 실전 패턴은 [빠른 시작](docs/quickstart.md)과 [사용 가이드](docs/usage.md)의 "빠른 예제 모음"에서 확인할 수 있습니다.
 
 ## 문서

{python-hwpx-1.3 → python-hwpx-1.5}/src/python_hwpx.egg-info/SOURCES.txt

@@ -33,4 +33,5 @@ tests/test_integration_hwpx_compatibility.py
 tests/test_memo_and_style_editing.py
 tests/test_oxml_parsing.py
 tests/test_section_headers.py
+tests/test_tables_default_border.py
 tests/test_text_extractor_annotations.py

{python-hwpx-1.3 → python-hwpx-1.5}/tests/test_integration_hwpx_compatibility.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import io
+import xml.etree.ElementTree as ET
 from pathlib import Path
 from zipfile import ZIP_DEFLATED, ZIP_STORED, ZipFile
 
@@ -9,6 +10,7 @@ import pytest
 from hwpx.document import HwpxDocument
 from hwpx.package import HwpxPackage
 from hwpx.tools import load_default_schemas, validate_document
+from hwpx.templates import blank_document_bytes
 
 _MIMETYPE = b"application/hwp+zip"
 _VERSION_XML = (
@@ -137,3 +139,90 @@ def test_fixture_validates_against_reference_schemas(
 
     bytes_report = validate_document(sample_document_bytes)
     assert bytes_report.ok, "Generated sample failed schema validation from bytes"
+
+
+def test_master_page_history_and_version_round_trip(tmp_path: Path) -> None:
+    package = HwpxPackage.open(blank_document_bytes())
+
+    manifest = package.manifest_tree()
+    ns = {"opf": "http://www.idpf.org/2007/opf/"}
+    manifest_list = manifest.find(f"{{{ns['opf']}}}manifest")
+    assert manifest_list is not None
+
+    def add_manifest_item(item_id: str, href: str) -> None:
+        ET.SubElement(
+            manifest_list,
+            f"{{{ns['opf']}}}item",
+            {"id": item_id, "href": href, "media-type": "application/xml"},
+        )
+
+    add_manifest_item("master-page-0", "Contents/masterPages/masterPage0.xml")
+    add_manifest_item("history", "Contents/history.xml")
+    add_manifest_item("version", "version.xml")
+    package.set_xml(package.MANIFEST_PATH, manifest)
+
+    hm_ns = "http://www.hancom.co.kr/hwpml/2011/master-page"
+    master_root = ET.Element(f"{{{hm_ns}}}masterPage")
+    ET.SubElement(
+        master_root,
+        f"{{{hm_ns}}}masterPageItem",
+        {"id": "0", "type": "BOTH", "name": "초기 바탕쪽"},
+    )
+    package.set_xml("Contents/masterPages/masterPage0.xml", master_root)
+
+    hhs_ns = "http://www.hancom.co.kr/hwpml/2011/history"
+    history_root = ET.Element(f"{{{hhs_ns}}}history")
+    history_entry = ET.SubElement(history_root, f"{{{hhs_ns}}}historyEntry", {"id": "0"})
+    comment = ET.SubElement(history_entry, f"{{{hhs_ns}}}comment")
+    comment.text = "초기 내역"
+    package.set_xml("Contents/history.xml", history_root)
+
+    document = HwpxDocument.from_package(package)
+
+    assert len(document.master_pages) == 1
+    assert len(document.histories) == 1
+    version_part = document.version
+    assert version_part is not None
+
+    master_page = document.master_pages[0]
+    master_item = master_page.element.find(f"{{{hm_ns}}}masterPageItem")
+    assert master_item is not None
+    master_item.set("name", "검토용 바탕쪽")
+    master_page.mark_dirty()
+
+    history_part = document.histories[0]
+    history_comment = history_part.element.find(
+        f"{{{hhs_ns}}}historyEntry/{{{hhs_ns}}}comment"
+    )
+    assert history_comment is not None
+    history_comment.text = "업데이트된 변경 기록"
+    history_part.mark_dirty()
+
+    version_part.element.set("appVersion", "15.0.0.100 WIN32")
+    version_part.mark_dirty()
+
+    output_path = tmp_path / "master_history_roundtrip.hwpx"
+    document.save(output_path)
+
+    reopened = HwpxDocument.open(output_path)
+    assert reopened.master_pages
+    assert reopened.histories
+    reopened_version = reopened.version
+    assert reopened_version is not None
+
+    reopened_master_item = reopened.master_pages[0].element.find(
+        f"{{{hm_ns}}}masterPageItem"
+    )
+    assert reopened_master_item is not None
+    assert reopened_master_item.get("name") == "검토용 바탕쪽"
+
+    reopened_history_comment = reopened.histories[0].element.find(
+        f"{{{hhs_ns}}}historyEntry/{{{hhs_ns}}}comment"
+    )
+    assert reopened_history_comment is not None
+    assert reopened_history_comment.text == "업데이트된 변경 기록"
+
+    assert reopened_version.element.get("appVersion") == "15.0.0.100 WIN32"
+    assert "Contents/masterPages/masterPage0.xml" in reopened.package.master_page_paths()
+    assert "Contents/history.xml" in reopened.package.history_paths()
+    assert reopened.package.version_path() == "version.xml"

python-hwpx-1.5/tests/test_tables_default_border.py

@@ -0,0 +1,81 @@
+"""Integration tests for automatic table border fills."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+from hwpx.document import HwpxDocument
+
+HP_NS = "http://www.hancom.co.kr/hwpml/2011/paragraph"
+HH_NS = "http://www.hancom.co.kr/hwpml/2011/head"
+HP = f"{{{HP_NS}}}"
+HH = f"{{{HH_NS}}}"
+
+
+def test_add_table_injects_basic_border_fill_when_missing() -> None:
+    document = HwpxDocument.new()
+
+    header = document.headers[0]
+    ref_list = header.element.find(f"{HH}refList")
+    if ref_list is not None:
+        existing = ref_list.find(f"{HH}borderFills")
+        if existing is not None:
+            ref_list.remove(existing)
+    header.reset_dirty()
+
+    section = document.sections[0]
+    section.reset_dirty()
+
+    table = document.add_table(2, 2, section=section)
+    assert table is not None
+
+    updates = document.oxml.serialize()
+
+    assert header.part_name in updates
+    header_root = ET.fromstring(updates[header.part_name])
+
+    border_fills_element = header_root.find(f".//{HH}borderFills")
+    assert border_fills_element is not None
+    assert border_fills_element.get("itemCnt") == "1"
+
+    border_fill_element = border_fills_element.find(f"{HH}borderFill")
+    assert border_fill_element is not None
+    border_id = border_fill_element.get("id")
+    assert border_id == "0"
+    assert border_fill_element.get("threeD") == "0"
+    assert border_fill_element.get("shadow") == "0"
+    assert border_fill_element.get("centerLine") == "NONE"
+    assert border_fill_element.get("breakCellSeparateLine") == "0"
+
+    slash = border_fill_element.find(f"{HH}slash")
+    assert slash is not None
+    assert slash.get("type") == "NONE"
+
+    back_slash = border_fill_element.find(f"{HH}backSlash")
+    assert back_slash is not None
+    assert back_slash.get("type") == "NONE"
+
+    for child_name in ("leftBorder", "rightBorder", "topBorder", "bottomBorder"):
+        child = border_fill_element.find(f"{HH}{child_name}")
+        assert child is not None
+        assert child.get("type") == "SOLID"
+        assert child.get("width") == "0.12 mm"
+        assert child.get("color") == "#000000"
+
+    diagonal = border_fill_element.find(f"{HH}diagonal")
+    assert diagonal is not None
+    assert diagonal.get("type") == "SOLID"
+    assert diagonal.get("width") == "0.1 mm"
+    assert diagonal.get("color") == "#000000"
+
+    assert section.part_name in updates
+    section_root = ET.fromstring(updates[section.part_name])
+
+    table_element = section_root.find(f".//{HP}tbl")
+    assert table_element is not None
+    assert table_element.get("borderFillIDRef") == border_id
+
+    cells = section_root.findall(f".//{HP}tc")
+    assert cells
+    for cell in cells:
+        assert cell.get("borderFillIDRef") == border_id