python-hwpx 2.4__tar.gz → 2.6__tar.gz

{python_hwpx-2.4 → python_hwpx-2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 2.4
+Version: 2.6
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License

{python_hwpx-2.4 → python_hwpx-2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "2.4"
+version = "2.6"
 description = "Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE" }
@@ -50,6 +50,9 @@ Issues = "https://github.com/airmang/python-hwpx/issues"
 
 [project.scripts]
 hwpx-validate = "hwpx.tools.validator:main"
+hwpx-validate-package = "hwpx.tools.package_validator:main"
+hwpx-page-guard = "hwpx.tools.page_guard:main"
+hwpx-text-extract = "hwpx.tools.text_extract_cli:main"
 
 [tool.setuptools]
 package-dir = { "" = "src" }

{python_hwpx-2.4 → python_hwpx-2.6}/src/hwpx/document.py

@@ -1280,7 +1280,7 @@ class HwpxDocument:
         """
         from .tools.validator import validate_document
 
-        return validate_document(self._to_bytes_raw())
+        return validate_document(self._to_bytes_raw(reset_dirty=False))
 
     def _run_pre_save_validation(self) -> None:
         """Raise if validate_on_save is enabled and the document is invalid."""
@@ -1318,11 +1318,16 @@ class HwpxDocument:
         self._run_pre_save_validation()
         return self._to_bytes_raw()
 
-    def _to_bytes_raw(self) -> bytes:
-        """Serialize without validation (used by :meth:`validate`)."""
+    def _to_bytes_raw(self, *, reset_dirty: bool = True) -> bytes:
+        """Serialize without validation.
+
+        When ``reset_dirty`` is ``False``, the document remains marked as
+        modified after the archive snapshot is generated.
+        """
         updates = self._root.serialize()
         result = self._package.save(None, updates)
-        self._root.reset_dirty()
+        if reset_dirty:
+            self._root.reset_dirty()
         if isinstance(result, bytes):
             return result
         raise TypeError("package.save(None) must return bytes")

{python_hwpx-2.4 → python_hwpx-2.6}/src/hwpx/oxml/document.py

@@ -2541,7 +2541,12 @@ class HwpxOxmlTable:
                     existing_target.set_size(col_width, row_height)
                     continue
 
-                new_cell_element = ET.Element(f"{_HP}tc", dict(template_attrs))
+                # Use makeelement() so the new cell matches the XML engine
+                # of the existing tree (stdlib ET or lxml).  ET.Element()
+                # always produces stdlib elements which cannot be appended to
+                # an lxml tree (and vice-versa), causing TypeError at runtime
+                # when splitting cells in documents parsed via lxml.
+                new_cell_element = row_element.makeelement(f"{_HP}tc", dict(template_attrs))
                 for child in preserved_children:
                     new_cell_element.append(deepcopy(child))
 

{python_hwpx-2.4 → python_hwpx-2.6}/src/hwpx/tools/__init__.py

@@ -6,6 +6,16 @@ from .exporter import (
     export_text,
 )
 from .object_finder import FoundElement, ObjectFinder
+from .package_validator import (
+    PackageValidationIssue,
+    PackageValidationReport,
+    validate_package,
+)
+from .page_guard import (
+    DocumentMetrics,
+    collect_metrics,
+    compare_metrics,
+)
 from .text_extractor import (
     DEFAULT_NAMESPACES,
     ParagraphInfo,
@@ -33,6 +43,12 @@ __all__ = [
     "strip_namespace",
     "FoundElement",
     "ObjectFinder",
+    "PackageValidationIssue",
+    "PackageValidationReport",
+    "validate_package",
+    "DocumentMetrics",
+    "collect_metrics",
+    "compare_metrics",
     "DocumentSchemas",
     "ValidationIssue",
     "ValidationReport",

python_hwpx-2.6/src/hwpx/tools/package_validator.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import argparse
+import io
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO, Sequence
+from zipfile import ZIP_STORED, BadZipFile, ZipFile
+
+EXPECTED_MIMETYPE = "application/hwp+zip"
+CONTAINER_PATH = "META-INF/container.xml"
+MANIFEST_PATH = "Contents/content.hpf"
+HEADER_PATH = "Contents/header.xml"
+VERSION_PATH = "version.xml"
+REQUIRED_CORE_FILES = ("mimetype", CONTAINER_PATH, MANIFEST_PATH, HEADER_PATH, VERSION_PATH)
+OPF_NS = {"opf": "http://www.idpf.org/2007/opf/"}
+CONTAINER_NS = {
+    "ct": "urn:oasis:names:tc:opendocument:xmlns:container",
+    "ocf": "urn:oasis:names:tc:opendocument:xmlns:container",
+}
+
+__all__ = [
+    "PackageValidationIssue",
+    "PackageValidationReport",
+    "validate_package",
+    "main",
+]
+
+
+@dataclass(frozen=True)
+class PackageValidationIssue:
+    part_name: str
+    message: str
+
+    def __str__(self) -> str:  # pragma: no cover - human readable helper
+        return f"{self.part_name}: {self.message}"
+
+
+@dataclass(frozen=True)
+class PackageValidationReport:
+    checked_parts: tuple[str, ...]
+    issues: tuple[PackageValidationIssue, ...]
+
+    @property
+    def ok(self) -> bool:
+        return not self.issues
+
+    def __bool__(self) -> bool:  # pragma: no cover - convenience alias
+        return self.ok
+
+
+def _open_zip(source: str | Path | bytes | BinaryIO) -> ZipFile:
+    if isinstance(source, (str, Path)):
+        return ZipFile(source, "r")
+    if isinstance(source, bytes):
+        return ZipFile(io.BytesIO(source), "r")
+    return ZipFile(source, "r")
+
+
+def _parse_xml(payload: bytes) -> ET.Element:
+    try:
+        return ET.fromstring(payload)
+    except ET.ParseError as exc:
+        raise ValueError(f"malformed XML: {exc}") from exc
+
+
+def _container_rootfiles(container_root: ET.Element) -> list[str]:
+    paths: list[str] = []
+    for namespace in CONTAINER_NS.values():
+        paths.extend(
+            elem.get("full-path")
+            or elem.get("fullPath")
+            or elem.get("full_path")
+            for elem in container_root.findall(f".//{{{namespace}}}rootfile")
+        )
+    return [path for path in paths if path]
+
+
+def _manifest_hrefs(manifest_root: ET.Element) -> set[str]:
+    hrefs: set[str] = set()
+    for item in manifest_root.findall(".//opf:item", OPF_NS):
+        href = item.get("href")
+        if href:
+            hrefs.add(href)
+    return hrefs
+
+
+def _spine_hrefs(manifest_root: ET.Element) -> list[str]:
+    hrefs: list[str] = []
+    id_to_href: dict[str, str] = {}
+    for item in manifest_root.findall(".//opf:item", OPF_NS):
+        item_id = item.get("id")
+        href = item.get("href")
+        if item_id and href:
+            id_to_href[item_id] = href
+
+    for itemref in manifest_root.findall(".//opf:itemref", OPF_NS):
+        idref = itemref.get("idref")
+        if idref and idref in id_to_href:
+            hrefs.append(id_to_href[idref])
+    return hrefs
+
+
+def validate_package(source: str | Path | bytes | BinaryIO) -> PackageValidationReport:
+    checked_parts: list[str] = []
+    issues: list[PackageValidationIssue] = []
+
+    try:
+        archive = _open_zip(source)
+    except BadZipFile:
+        return PackageValidationReport(
+            checked_parts=(),
+            issues=(PackageValidationIssue("archive", "not a valid ZIP archive"),),
+        )
+
+    with archive as zf:
+        names = zf.namelist()
+        checked_parts.extend(names)
+
+        for required in REQUIRED_CORE_FILES:
+            if required not in names:
+                issues.append(PackageValidationIssue(required, "missing required file"))
+
+        if not names:
+            issues.append(PackageValidationIssue("archive", "empty archive"))
+            return PackageValidationReport(tuple(checked_parts), tuple(issues))
+
+        if "mimetype" in names:
+            try:
+                mimetype = zf.read("mimetype").decode("utf-8").strip()
+            except UnicodeDecodeError:
+                mimetype = "<binary>"
+            if mimetype != EXPECTED_MIMETYPE:
+                issues.append(
+                    PackageValidationIssue(
+                        "mimetype",
+                        f"expected {EXPECTED_MIMETYPE!r}, got {mimetype!r}",
+                    )
+                )
+            if names[0] != "mimetype":
+                issues.append(PackageValidationIssue("mimetype", "must be the first ZIP entry"))
+            if zf.getinfo("mimetype").compress_type != ZIP_STORED:
+                issues.append(PackageValidationIssue("mimetype", "must use ZIP_STORED"))
+
+        xml_roots: dict[str, ET.Element] = {}
+        for name in names:
+            if not (name.endswith(".xml") or name.endswith(".hpf")):
+                continue
+            try:
+                xml_roots[name] = _parse_xml(zf.read(name))
+            except ValueError as exc:
+                issues.append(PackageValidationIssue(name, str(exc)))
+
+        container_root = xml_roots.get(CONTAINER_PATH)
+        if container_root is not None:
+            rootfiles = _container_rootfiles(container_root)
+            if not rootfiles:
+                issues.append(PackageValidationIssue(CONTAINER_PATH, "declares no rootfile entries"))
+            for rootfile in rootfiles:
+                if rootfile not in names:
+                    issues.append(
+                        PackageValidationIssue(
+                            CONTAINER_PATH,
+                            f"rootfile points to missing part {rootfile!r}",
+                        )
+                    )
+
+        manifest_root = xml_roots.get(MANIFEST_PATH)
+        if manifest_root is not None:
+            hrefs = _manifest_hrefs(manifest_root)
+            for href in sorted(hrefs):
+                if href not in names:
+                    issues.append(
+                        PackageValidationIssue(
+                            MANIFEST_PATH,
+                            f"manifest href missing from archive: {href}",
+                        )
+                    )
+
+            spine_hrefs = _spine_hrefs(manifest_root)
+            if not spine_hrefs:
+                issues.append(PackageValidationIssue(MANIFEST_PATH, "spine declares no section parts"))
+            for href in spine_hrefs:
+                if href not in names:
+                    issues.append(
+                        PackageValidationIssue(
+                            MANIFEST_PATH,
+                            f"spine item missing from archive: {href}",
+                        )
+                    )
+
+            if HEADER_PATH in names and HEADER_PATH not in hrefs:
+                issues.append(
+                    PackageValidationIssue(MANIFEST_PATH, "header.xml is not referenced in manifest")
+                )
+
+    return PackageValidationReport(tuple(checked_parts), tuple(issues))
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Validate HWPX package structure")
+    parser.add_argument("source", help="Path to the HWPX file")
+    args = parser.parse_args(argv)
+
+    report = validate_package(args.source)
+    if report.issues:
+        for issue in report.issues:
+            print(f"ERROR: {issue}")
+        return 1
+
+    print("All package validations passed.")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI convenience
+    raise SystemExit(main())

python_hwpx-2.6/src/hwpx/tools/page_guard.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import argparse
+import io
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import BinaryIO, Iterable, Sequence
+from zipfile import ZipFile
+
+from lxml import etree
+
+NS = {
+    "hp": "http://www.hancom.co.kr/hwpml/2011/paragraph",
+    "hs": "http://www.hancom.co.kr/hwpml/2011/section",
+    "opf": "http://www.idpf.org/2007/opf/",
+}
+
+__all__ = [
+    "DocumentMetrics",
+    "collect_metrics",
+    "compare_metrics",
+    "main",
+]
+
+
+@dataclass(frozen=True)
+class DocumentMetrics:
+    section_count: int
+    paragraph_count: int
+    page_break_count: int
+    column_break_count: int
+    table_count: int
+    table_shapes: list[tuple[str, str, str, str, str, str]]
+    text_char_total: int
+    text_char_total_nospace: int
+    paragraph_text_lengths: list[int]
+
+
+def _section_files(zf: ZipFile) -> list[str]:
+    try:
+        root = etree.fromstring(zf.read("Contents/content.hpf"))
+    except KeyError:
+        return [
+            name
+            for name in zf.namelist()
+            if name.startswith("Contents/section") and name.endswith(".xml")
+        ]
+
+    id_to_href: dict[str, str] = {}
+    for item in root.findall(".//opf:item", namespaces=NS):
+        item_id = item.get("id")
+        href = item.get("href")
+        if item_id and href:
+            id_to_href[item_id] = href
+
+    files: list[str] = []
+    for itemref in root.findall(".//opf:itemref", namespaces=NS):
+        idref = itemref.get("idref")
+        if idref and idref in id_to_href:
+            files.append(id_to_href[idref])
+    return files
+
+
+def _text_of_t_node(node: etree._Element) -> str:
+    return "".join(node.itertext())
+
+
+def _iter_section_roots(source: str | Path | bytes | BinaryIO) -> Iterable[etree._Element]:
+    if isinstance(source, bytes):
+        archive = ZipFile(io.BytesIO(source), "r")
+    else:
+        archive = ZipFile(source, "r")
+
+    try:
+        for name in _section_files(archive):
+            yield etree.fromstring(archive.read(name))
+    finally:
+        archive.close()
+
+
+def collect_metrics(source: str | Path | bytes | BinaryIO) -> DocumentMetrics:
+    section_roots = list(_iter_section_roots(source))
+
+    paragraphs: list[etree._Element] = []
+    tables: list[etree._Element] = []
+    table_shapes: list[tuple[str, str, str, str, str, str]] = []
+    paragraph_text_lengths: list[int] = []
+    text_char_total = 0
+    text_char_total_nospace = 0
+    page_break_count = 0
+    column_break_count = 0
+
+    for root in section_roots:
+        section_paragraphs = root.xpath(".//hs:sec/hp:p", namespaces=NS)
+        if not section_paragraphs:
+            section_paragraphs = root.xpath(".//hp:p", namespaces=NS)
+        paragraphs.extend(section_paragraphs)
+
+        section_tables = root.xpath(".//hp:tbl", namespaces=NS)
+        tables.extend(section_tables)
+
+        for table in section_tables:
+            size = table.find("hp:sz", namespaces=NS)
+            table_shapes.append(
+                (
+                    table.get("rowCnt", ""),
+                    table.get("colCnt", ""),
+                    size.get("width", "") if size is not None else "",
+                    size.get("height", "") if size is not None else "",
+                    table.get("repeatHeader", ""),
+                    table.get("pageBreak", ""),
+                )
+            )
+
+        for paragraph in section_paragraphs:
+            if paragraph.get("pageBreak") == "1":
+                page_break_count += 1
+            if paragraph.get("columnBreak") == "1":
+                column_break_count += 1
+            paragraph_length = 0
+            for text_node in paragraph.xpath(".//hp:t", namespaces=NS):
+                text = _text_of_t_node(text_node)
+                paragraph_length += len(text)
+                text_char_total += len(text)
+                text_char_total_nospace += len("".join(text.split()))
+            paragraph_text_lengths.append(paragraph_length)
+
+    return DocumentMetrics(
+        section_count=len(section_roots),
+        paragraph_count=len(paragraphs),
+        page_break_count=page_break_count,
+        column_break_count=column_break_count,
+        table_count=len(tables),
+        table_shapes=table_shapes,
+        text_char_total=text_char_total,
+        text_char_total_nospace=text_char_total_nospace,
+        paragraph_text_lengths=paragraph_text_lengths,
+    )
+
+
+def _ratio_delta(reference_value: int, output_value: int) -> float:
+    base = max(reference_value, 1)
+    return abs(output_value - reference_value) / base
+
+
+def compare_metrics(
+    reference: DocumentMetrics,
+    output: DocumentMetrics,
+    *,
+    max_text_delta_ratio: float = 0.15,
+    max_paragraph_delta_ratio: float = 0.25,
+) -> list[str]:
+    errors: list[str] = []
+
+    if reference.section_count != output.section_count:
+        errors.append(
+            f"section count mismatch: ref={reference.section_count}, out={output.section_count}"
+        )
+    if reference.paragraph_count != output.paragraph_count:
+        errors.append(
+            f"paragraph count mismatch: ref={reference.paragraph_count}, out={output.paragraph_count}"
+        )
+    if reference.page_break_count != output.page_break_count:
+        errors.append(
+            "pageBreak count mismatch: "
+            f"ref={reference.page_break_count}, out={output.page_break_count}"
+        )
+    if reference.column_break_count != output.column_break_count:
+        errors.append(
+            "columnBreak count mismatch: "
+            f"ref={reference.column_break_count}, out={output.column_break_count}"
+        )
+    if reference.table_count != output.table_count:
+        errors.append(f"table count mismatch: ref={reference.table_count}, out={output.table_count}")
+    if reference.table_shapes != output.table_shapes:
+        errors.append("table shape mismatch (rowCnt/colCnt/width/height/repeatHeader/pageBreak)")
+
+    text_delta = _ratio_delta(reference.text_char_total_nospace, output.text_char_total_nospace)
+    if text_delta > max_text_delta_ratio:
+        errors.append(
+            "total text length drift exceeded: "
+            f"ref={reference.text_char_total_nospace}, out={output.text_char_total_nospace}, "
+            f"delta={text_delta:.2%}, limit={max_text_delta_ratio:.2%}"
+        )
+
+    if len(reference.paragraph_text_lengths) == len(output.paragraph_text_lengths):
+        for index, (ref_len, out_len) in enumerate(
+            zip(reference.paragraph_text_lengths, output.paragraph_text_lengths),
+            start=1,
+        ):
+            if ref_len == 0 and out_len == 0:
+                continue
+            delta = _ratio_delta(ref_len, out_len)
+            if delta > max_paragraph_delta_ratio:
+                errors.append(
+                    f"paragraph {index} text drift exceeded: "
+                    f"ref={ref_len}, out={out_len}, delta={delta:.2%}, "
+                    f"limit={max_paragraph_delta_ratio:.2%}"
+                )
+    return errors
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Reference-vs-output HWPX page drift guard")
+    parser.add_argument("--reference", "-r", required=True, help="Reference HWPX path")
+    parser.add_argument("--output", "-o", required=True, help="Output HWPX path")
+    parser.add_argument("--max-text-delta-ratio", type=float, default=0.15)
+    parser.add_argument("--max-paragraph-delta-ratio", type=float, default=0.25)
+    parser.add_argument("--json", action="store_true", help="Print collected metrics as JSON")
+    args = parser.parse_args(argv)
+
+    reference = collect_metrics(args.reference)
+    output = collect_metrics(args.output)
+
+    if args.json:
+        print(
+            json.dumps(
+                {"reference": asdict(reference), "output": asdict(output)},
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+
+    errors = compare_metrics(
+        reference,
+        output,
+        max_text_delta_ratio=args.max_text_delta_ratio,
+        max_paragraph_delta_ratio=args.max_paragraph_delta_ratio,
+    )
+    if errors:
+        print("FAIL: page guard")
+        for error in errors:
+            print(f" - {error}")
+        return 1
+
+    print("PASS: page guard")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI convenience
+    raise SystemExit(main())

python_hwpx-2.6/src/hwpx/tools/text_extract_cli.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Sequence
+
+from .text_extractor import TextExtractor
+
+__all__ = [
+    "extract_plain",
+    "extract_markdown",
+    "main",
+]
+
+
+def extract_plain(hwpx_path: str, *, include_tables: bool = False) -> str:
+    with TextExtractor(hwpx_path) as extractor:
+        return extractor.extract_text(
+            include_nested=include_tables,
+            object_behavior="skip",
+            skip_empty=True,
+        )
+
+
+def extract_markdown(hwpx_path: str) -> str:
+    lines: list[str] = []
+    with TextExtractor(hwpx_path) as extractor:
+        for section in extractor.iter_sections():
+            if lines:
+                lines.extend(["", "---", ""])
+            for paragraph in extractor.iter_paragraphs(section, include_nested=True):
+                text = paragraph.text(object_behavior="skip")
+                if not text.strip():
+                    continue
+                lines.append(f"  {text}" if paragraph.is_nested else text)
+    return "\n".join(lines)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Extract text from an HWPX document")
+    parser.add_argument("input", help="Path to the .hwpx file")
+    parser.add_argument("--format", "-f", choices=["plain", "markdown"], default="plain")
+    parser.add_argument("--include-tables", action="store_true", help="Include nested table text")
+    parser.add_argument("--output", "-o", help="Write output to a file instead of stdout")
+    args = parser.parse_args(argv)
+
+    input_path = Path(args.input)
+    if not input_path.is_file():
+        print(f"Error: File not found: {args.input}", file=sys.stderr)
+        return 1
+
+    if args.format == "markdown":
+        result = extract_markdown(str(input_path))
+    else:
+        result = extract_plain(str(input_path), include_tables=args.include_tables)
+
+    if args.output:
+        Path(args.output).write_text(result, encoding="utf-8")
+    else:
+        print(result)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI convenience
+    raise SystemExit(main())

{python_hwpx-2.4 → python_hwpx-2.6}/src/python_hwpx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 2.4
+Version: 2.6
 Summary: Hancom HWPX 패키지를 로드하고 편집하기 위한 Python 유틸리티 모음
 Author: python-hwpx Maintainers
 License: Non-Commercial License

{python_hwpx-2.4 → python_hwpx-2.6}/src/python_hwpx.egg-info/SOURCES.txt

@@ -26,6 +26,9 @@ src/hwpx/oxml/utils.py
 src/hwpx/tools/__init__.py
 src/hwpx/tools/exporter.py
 src/hwpx/tools/object_finder.py
+src/hwpx/tools/package_validator.py
+src/hwpx/tools/page_guard.py
+src/hwpx/tools/text_extract_cli.py
 src/hwpx/tools/text_extractor.py
 src/hwpx/tools/validator.py
 src/hwpx/tools/_schemas/header.xsd
@@ -40,6 +43,7 @@ tests/test_coverage_targets.py
 tests/test_document_context_manager.py
 tests/test_document_formatting.py
 tests/test_document_save_api.py
+tests/test_gap_closure_tools.py
 tests/test_inline_models.py
 tests/test_integration_hwpx_compatibility.py
 tests/test_integration_roundtrip.py
@@ -51,6 +55,7 @@ tests/test_packaging_py_typed.py
 tests/test_paragraph_section_management.py
 tests/test_repr_snapshots.py
 tests/test_section_headers.py
+tests/test_split_merged_cell.py
 tests/test_tables_default_border.py
 tests/test_text_extractor_annotations.py
 tests/test_version_metadata.py

python_hwpx-2.6/src/python_hwpx.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+hwpx-page-guard = hwpx.tools.page_guard:main
+hwpx-text-extract = hwpx.tools.text_extract_cli:main
+hwpx-validate = hwpx.tools.validator:main
+hwpx-validate-package = hwpx.tools.package_validator:main

python_hwpx-2.6/tests/test_gap_closure_tools.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import io
+import subprocess
+import sys
+from pathlib import Path
+from zipfile import ZIP_DEFLATED, ZipFile
+
+from hwpx import HwpxDocument
+from hwpx.tools.package_validator import validate_package
+from hwpx.tools.page_guard import collect_metrics, compare_metrics
+from hwpx.tools.text_extract_cli import extract_markdown, extract_plain
+
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+_CONTAINER_XML = (
+    b'<?xml version="1.0" encoding="UTF-8"?>'
+    b'<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container">'
+    b"<rootfiles>"
+    b'<rootfile full-path="Contents/content.hpf" media-type="application/hwpml-package+xml"/>'
+    b"</rootfiles>"
+    b"</container>"
+)
+_MANIFEST_XML = (
+    b'<?xml version="1.0" encoding="UTF-8"?>'
+    b'<opf:package xmlns:opf="http://www.idpf.org/2007/opf/">'
+    b"<opf:manifest>"
+    b'<opf:item id="header" href="Contents/header.xml" media-type="application/xml"/>'
+    b'<opf:item id="section0" href="Contents/section0.xml" media-type="application/xml"/>'
+    b"</opf:manifest>"
+    b"<opf:spine>"
+    b'<opf:itemref idref="section0"/>'
+    b"</opf:spine>"
+    b"</opf:package>"
+)
+_VERSION_XML = b'<?xml version="1.0" encoding="UTF-8"?><version/>'
+_HEADER_XML = b'<?xml version="1.0" encoding="UTF-8"?><header/>'
+_SECTION_XML = b'<?xml version="1.0" encoding="UTF-8"?><section/>'
+
+
+def _build_invalid_package() -> bytes:
+    buffer = io.BytesIO()
+    with ZipFile(buffer, "w", compression=ZIP_DEFLATED) as archive:
+        archive.writestr("META-INF/container.xml", _CONTAINER_XML)
+        archive.writestr("Contents/content.hpf", _MANIFEST_XML)
+        archive.writestr("Contents/header.xml", _HEADER_XML)
+        archive.writestr("Contents/section0.xml", _SECTION_XML)
+        archive.writestr("version.xml", _VERSION_XML)
+    return buffer.getvalue()
+
+
+def test_package_validator_accepts_valid_document() -> None:
+    document = HwpxDocument.new()
+    document.add_paragraph("validator smoke test")
+
+    report = validate_package(document.to_bytes())
+
+    assert report.ok
+    assert "Contents/header.xml" in report.checked_parts
+
+
+def test_package_validator_reports_missing_mimetype() -> None:
+    report = validate_package(_build_invalid_package())
+
+    assert not report.ok
+    assert any(issue.part_name == "mimetype" for issue in report.issues)
+
+
+def test_page_guard_detects_text_drift() -> None:
+    reference = HwpxDocument.new()
+    reference.add_paragraph("alpha")
+    reference.add_paragraph("beta")
+
+    output = HwpxDocument.new()
+    output.add_paragraph("alpha" * 12)
+    output.add_paragraph("beta" * 12)
+
+    errors = compare_metrics(
+        collect_metrics(reference.to_bytes()),
+        collect_metrics(output.to_bytes()),
+        max_text_delta_ratio=0.05,
+        max_paragraph_delta_ratio=0.05,
+    )
+
+    assert any("total text length drift exceeded" in error for error in errors)
+
+
+def test_text_extract_cli_functions_include_table_text(tmp_path: Path) -> None:
+    document = HwpxDocument.new()
+    document.add_paragraph("Title")
+    table = document.add_table(1, 1)
+    table.cell(0, 0).text = "Cell"
+
+    source = tmp_path / "sample.hwpx"
+    source.write_bytes(document.to_bytes())
+
+    plain = extract_plain(str(source), include_tables=True)
+    markdown = extract_markdown(str(source))
+
+    assert "Title" in plain
+    assert "Cell" in plain
+    assert "Title" in markdown
+    assert "Cell" in markdown
+
+
+def test_validate_preserves_dirty_state() -> None:
+    document = HwpxDocument.new()
+    document.add_paragraph("dirty paragraph")
+
+    section = document.sections[-1]
+    assert section.dirty
+
+    document.validate()
+
+    assert section.dirty
+
+
+def test_office_pack_unpack_roundtrip(tmp_path: Path) -> None:
+    document = HwpxDocument.new()
+    document.add_paragraph("Roundtrip")
+    table = document.add_table(1, 1)
+    table.cell(0, 0).text = "A1"
+
+    source = tmp_path / "source.hwpx"
+    unpack_dir = tmp_path / "unpacked"
+    repacked = tmp_path / "repacked.hwpx"
+    source.write_bytes(document.to_bytes())
+
+    subprocess.run(
+        [sys.executable, str(_REPO_ROOT / "scripts" / "office" / "unpack.py"), str(source), str(unpack_dir)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    subprocess.run(
+        [sys.executable, str(_REPO_ROOT / "scripts" / "office" / "pack.py"), str(unpack_dir), str(repacked)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    assert validate_package(repacked.read_bytes()).ok
+    assert compare_metrics(
+        collect_metrics(source.read_bytes()),
+        collect_metrics(repacked.read_bytes()),
+    ) == []
+
+
+def test_analyze_template_script_smoke(tmp_path: Path) -> None:
+    source = tmp_path / "template.hwpx"
+    source.write_bytes(HwpxDocument.new().to_bytes())
+
+    result = subprocess.run(
+        [sys.executable, str(_REPO_ROOT / "scripts" / "analyze_template.py"), str(source)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    assert "== header summary ==" in result.stdout
+    assert "== section summary ==" in result.stdout

python_hwpx-2.6/tests/test_split_merged_cell.py

@@ -0,0 +1,185 @@
+"""Regression tests for split_merged_cell – ET / lxml mixing fix.
+
+The root cause of the original crash (TypeError: append() argument 1
+must be xml.etree.ElementTree.Element, not lxml.etree._Element) was that
+``split_merged_cell`` created new cell elements with stdlib
+``ET.Element()`` while the existing document tree consisted of lxml
+elements (parsed via ``lxml.etree.fromstring``).  The fix uses
+``row_element.makeelement()`` so that new cells always match the XML
+engine of the surrounding tree.
+
+Choice A was applied: *all runtime element creation inside
+``split_merged_cell`` is now engine-agnostic* by delegating to
+``makeelement`` / ``SubElement`` (which itself delegates to
+``makeelement``), so the code works identically with both stdlib ET
+and lxml trees.
+"""
+
+from __future__ import annotations
+
+import io
+
+import pytest
+
+from hwpx.document import HwpxDocument
+
+
+# --------------------------------------------------------------------------- #
+# Helpers
+# --------------------------------------------------------------------------- #
+
+
+def _new_doc_with_table(rows: int = 3, cols: int = 3) -> tuple[HwpxDocument, object]:
+    """Return (document, table) backed by lxml (via HwpxDocument.new())."""
+    doc = HwpxDocument.new()
+    table = doc.add_table(rows, cols)
+    return doc, table
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 1 – horizontal merge then split
+# --------------------------------------------------------------------------- #
+
+
+def test_split_horizontal_merge_no_type_error() -> None:
+    """Splitting a horizontally merged cell must not raise TypeError.
+
+    This is the exact code-path that triggered the original crash when
+    an lxml-backed table was modified with stdlib ET elements.
+    """
+    doc, table = _new_doc_with_table(3, 3)
+
+    # Merge (0,0)–(0,1) horizontally
+    table.merge_cells(0, 0, 0, 1)
+    merged = table.cell(0, 0)
+    assert merged.span == (1, 2), "pre-condition: cell should be merged"
+
+    # Split – this used to crash with TypeError
+    result = table.split_merged_cell(0, 0)
+    assert result is not None
+
+    # Master cell span reset to (1, 1)
+    assert table.cell(0, 0).span == (1, 1)
+    # Restored cell exists and is independent
+    assert table.cell(0, 1).span == (1, 1)
+    assert table.cell(0, 0).element is not table.cell(0, 1).element
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 2 – vertical merge then split
+# --------------------------------------------------------------------------- #
+
+
+def test_split_vertical_merge_no_type_error() -> None:
+    """Splitting a vertically merged cell must not raise TypeError."""
+    doc, table = _new_doc_with_table(3, 3)
+
+    # Merge (0,0)–(1,0) vertically
+    table.merge_cells(0, 0, 1, 0)
+    assert table.cell(0, 0).span == (2, 1)
+
+    result = table.split_merged_cell(0, 0)
+    assert result is not None
+
+    assert table.cell(0, 0).span == (1, 1)
+    assert table.cell(1, 0).span == (1, 1)
+    assert table.cell(0, 0).element is not table.cell(1, 0).element
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 3 – 2×2 block merge then split
+# --------------------------------------------------------------------------- #
+
+
+def test_split_block_merge_restores_all_cells() -> None:
+    """A 2×2 block merge should produce 4 independent cells after split."""
+    doc, table = _new_doc_with_table(3, 3)
+
+    table.merge_cells(0, 0, 1, 1)
+    assert table.cell(0, 0).span == (2, 2)
+
+    table.split_merged_cell(0, 0)
+
+    for r in range(2):
+        for c in range(2):
+            cell = table.cell(r, c)
+            assert cell.span == (1, 1), f"cell ({r},{c}) span should be (1,1)"
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 4 – save → reopen round-trip after split
+# --------------------------------------------------------------------------- #
+
+
+def test_split_then_save_reopen_roundtrip(tmp_path) -> None:
+    """After splitting, the document must survive save → reopen."""
+    doc, table = _new_doc_with_table(3, 3)
+
+    # Write identifiable text before merge
+    table.set_cell_text(0, 0, "A")
+    table.set_cell_text(0, 1, "B")
+    table.set_cell_text(0, 2, "C")
+
+    # Merge (0,0)–(0,1) then split
+    table.merge_cells(0, 0, 0, 1)
+    table.split_merged_cell(0, 0)
+
+    # Set text in the restored cell
+    table.cell(0, 1).text = "B-restored"
+
+    # Save to bytes and reopen
+    buf = io.BytesIO()
+    doc.save(buf)
+    buf.seek(0)
+
+    reopened = HwpxDocument.open(buf.getvalue())
+    # Collect tables from all paragraphs
+    rt_tables = [
+        t
+        for para in reopened.paragraphs
+        for t in para.tables
+    ]
+    assert len(rt_tables) >= 1
+
+    rt_table = rt_tables[0]
+    assert rt_table.cell(0, 0).span == (1, 1)
+    assert rt_table.cell(0, 1).span == (1, 1)
+    # Master cell kept its original text
+    assert rt_table.cell(0, 0).text == "A"
+    # Restored cell has the text we set
+    assert rt_table.cell(0, 1).text == "B-restored"
+    # Untouched cell is intact
+    assert rt_table.cell(0, 2).text == "C"
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 5 – split via set_cell_text logical API
+# --------------------------------------------------------------------------- #
+
+
+def test_set_cell_text_split_merged_flag() -> None:
+    """``set_cell_text(split_merged=True)`` must trigger split correctly."""
+    doc, table = _new_doc_with_table(3, 3)
+
+    table.merge_cells(0, 0, 0, 1)
+    # Write to the covered column with split_merged=True
+    table.set_cell_text(0, 1, "Split-Write", logical=True, split_merged=True)
+
+    assert table.cell(0, 0).span == (1, 1)
+    assert table.cell(0, 1).text == "Split-Write"
+    assert table.cell(0, 1).span == (1, 1)
+
+
+# --------------------------------------------------------------------------- #
+# Scenario 6 – splitting an already-unmerged cell is a no-op
+# --------------------------------------------------------------------------- #
+
+
+def test_split_unmerged_cell_is_noop() -> None:
+    """Splitting a cell that is not merged should return it unchanged."""
+    doc, table = _new_doc_with_table(2, 2)
+
+    cell_before = table.cell(0, 0)
+    cell_after = table.split_merged_cell(0, 0)
+    assert cell_before.element is cell_after.element
+    assert cell_after.span == (1, 1)

python_hwpx-2.4/src/python_hwpx.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-hwpx-validate = hwpx.tools.validator:main