python-hwpx 6.4.0__tar.gz → 6.5.0__tar.gz

{python_hwpx-6.4.0/src/python_hwpx.egg-info → python_hwpx-6.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 6.4.0
+Version: 6.5.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 문서 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-hwpx"
-version = "6.4.0"
+version = "6.5.0"
 description = "한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 문서 라이브러리"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = "Apache-2.0"

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/hwpx/equation/authoring.py

@@ -78,6 +78,11 @@ _LATEX_TO_EQEDIT.update(
         "\\forall": "FORALL",
         "\\iint": "dint",
         "\\iiint": "tint",
+        # ``triangle`` is accepted when reading (observed in real documents) but
+        # only the documented uppercase spelling is emitted when authoring: the
+        # lowercase form has not been render-verified, and lowercase ``forall``
+        # already turned out to render as literal text.
+        "\\triangle": "TRIANGLE",
         # Common LaTeX aliases sharing a verified target.
         "\\le": "leq",
         "\\ge": "geq",

python_hwpx-6.5.0/src/hwpx/equation/mathml.py

@@ -0,0 +1,135 @@
+# SPDX-License-Identifier: Apache-2.0
+"""LaTeX → MathML conversion via the optional ``latex2mathml`` dependency.
+
+MathML keeps the preview self-contained: browsers render ``<math>`` natively, so
+no script or font bundle is shipped.  ``latex2mathml`` is an optional extra
+(``python-hwpx[preview]``); when it is absent the caller fails closed to a LaTeX
+code block rather than dropping the equation.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Callable
+
+from .tokens import EQEDIT_MATHML_OPERATOR_COMMANDS
+
+# ``False`` marks a resolved-but-unavailable converter; ``None`` means "not yet
+# probed" so the import is attempted lazily on first use.
+_converter: Callable[[str], str] | bool | None = None
+_LATEX_WORD_COMMAND_RE = re.compile(r"\\[A-Za-z]+")
+_TEXT_COMMAND = "\\text{"
+
+
+class MathMLUnavailableError(RuntimeError):
+    """Raised when ``latex2mathml`` is not installed."""
+
+
+def _load_converter() -> Callable[[str], str] | bool:
+    global _converter
+    cached = _converter
+    if cached is not None:
+        return cached
+    try:
+        from latex2mathml.converter import convert
+    except ImportError:
+        _converter = False
+        return False
+    _converter = convert
+    return convert
+
+
+def latex2mathml_available() -> bool:
+    """Return ``True`` when the optional ``latex2mathml`` extra is importable."""
+
+    return _load_converter() is not False
+
+
+def latex_to_mathml(latex: str) -> str:
+    """Convert a LaTeX fragment to an inline ``<math>`` MathML string.
+
+    Raises:
+        MathMLUnavailableError: when ``latex2mathml`` is not installed.
+        ValueError: when ``latex2mathml`` cannot parse the fragment.
+    """
+
+    convert = _load_converter()
+    if convert is False:
+        raise MathMLUnavailableError(
+            "latex2mathml is required for MathML rendering; install python-hwpx[preview]"
+        )
+    assert not isinstance(convert, bool)  # narrowed for type-checkers
+    try:
+        return convert(latex)
+    except MathMLUnavailableError:
+        raise
+    except Exception as exc:  # latex2mathml raises bare Exception on bad input
+        raise ValueError(f"latex2mathml could not render fragment: {exc}") from exc
+
+
+def eqedit_latex_to_mathml(latex: str) -> str:
+    """Convert EqEdit-derived LaTeX while preserving known token roles.
+
+    ``latex2mathml`` classifies plain ``\\triangle`` as an identifier. EqEdit's
+    token map identifies it as a mathematical symbol, so the MathML-only input
+    receives an operator wrapper before conversion. The returned/public LaTeX
+    is not rewritten, and serialized MathML is never patched afterward.
+    """
+
+    def annotate_role(match: re.Match[str]) -> str:
+        command = match.group(0)
+        if command in EQEDIT_MATHML_OPERATOR_COMMANDS:
+            return rf"\mathop{{{command}}}"
+        return command
+
+    return latex_to_mathml(
+        "".join(
+            segment if literal else _LATEX_WORD_COMMAND_RE.sub(annotate_role, segment)
+            for segment, literal in _split_text_literals(latex)
+        )
+    )
+
+
+def _split_text_literals(latex: str) -> list[tuple[str, bool]]:
+    """Split ``latex`` into ``(segment, is_text_literal)`` pieces.
+
+    Quoted EqEdit literals become ``\\text{...}``; their content is prose, so
+    the role annotation must not rewrite a ``\\triangle`` typed inside quotes.
+    Braces inside the literal are balanced; an unterminated group is passed
+    through untouched so ``latex2mathml`` reports it instead of this splitter.
+    """
+
+    pieces: list[tuple[str, bool]] = []
+    cursor = 0
+    while True:
+        start = latex.find(_TEXT_COMMAND, cursor)
+        if start < 0:
+            break
+        depth = 0
+        end = -1
+        for index in range(start + len(_TEXT_COMMAND) - 1, len(latex)):
+            char = latex[index]
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+                if depth == 0:
+                    end = index + 1
+                    break
+        if end < 0:
+            break
+        if start > cursor:
+            pieces.append((latex[cursor:start], False))
+        pieces.append((latex[start:end], True))
+        cursor = end
+    if cursor < len(latex):
+        pieces.append((latex[cursor:], False))
+    return pieces
+
+
+__all__ = [
+    "MathMLUnavailableError",
+    "eqedit_latex_to_mathml",
+    "latex2mathml_available",
+    "latex_to_mathml",
+]

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/hwpx/equation/render.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 import html
 
 from .eqedit import EquationConversionError, eqedit_to_latex
-from .mathml import MathMLUnavailableError, latex_to_mathml
+from .mathml import MathMLUnavailableError, eqedit_latex_to_mathml
 
 # Fidelity labels surfaced in the preview (Constitution IX, honest reporting).
 LABEL_MATHML = "수식 MathML 렌더"
@@ -63,7 +63,7 @@ def render_equation(script: str) -> EquationRender:
         return _fallback_block("script", LABEL_SCRIPT, script, latex=None)
 
     try:
-        mathml = latex_to_mathml(latex)
+        mathml = eqedit_latex_to_mathml(latex)
     except MathMLUnavailableError:
         return _fallback_block("latex", LABEL_LATEX_NO_LIB, latex, latex=latex)
     except ValueError:

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/hwpx/equation/tokens.py

@@ -116,6 +116,11 @@ OPERATORS: dict[str, str] = {
     "partial": r"\partial",
     "nabla": r"\nabla",
     "angle": r"\angle",
+    # Hancom's symbol guide spells this token in uppercase, while legacy
+    # documents also contain the exact lowercase form. Mixed-case variants are
+    # intentionally not accepted because the reader uses exact token lookup.
+    "triangle": r"\triangle",
+    "TRIANGLE": r"\triangle",
     "cdots": r"\cdots",
     "ldots": r"\ldots",
     "vdots": r"\vdots",
@@ -254,11 +259,17 @@ DELIMITERS: dict[str, str] = {
 # Structural keywords handled directly by the parser (not simple substitution).
 STRUCTURAL = frozenset({"over", "atop", "sqrt", "root", "of", "LEFT", "RIGHT", "left", "right"})
 
+# LaTeX commands emitted from EqEdit operator tokens that latex2mathml otherwise
+# classifies as identifiers. The render boundary uses this metadata only while
+# producing MathML; the public LaTeX remains the canonical command above.
+EQEDIT_MATHML_OPERATOR_COMMANDS = frozenset({OPERATORS["triangle"]})
+
 
 __all__ = [
     "ACCENTS",
     "BIG_OPERATORS",
     "DELIMITERS",
+    "EQEDIT_MATHML_OPERATOR_COMMANDS",
     "FUNCTIONS",
     "GREEK",
     "MATRIX_ENVIRONMENTS",

python_hwpx-6.5.0/src/hwpx/oxml/_paragraph_text_edit.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Small helpers for a style-preserving paragraph text edit."""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+
+from ..errors import HwpxValueError
+from ._document_primitives import _is_tab_control_element
+from .namespaces import tag_local_name
+
+
+def plain_text_nodes_for_edit(runs: list[ET.Element]) -> list[ET.Element]:
+    nodes: list[ET.Element] = []
+    for run in runs:
+        for child in run:
+            if tag_local_name(child.tag) == "t":
+                if len(child):
+                    raise HwpxValueError(
+                        "mixed text markup cannot be edited safely",
+                        code="paragraph-mixed-text-unsupported",
+                    )
+                nodes.append(child)
+            elif tag_local_name(child.tag) == "tab" or _is_tab_control_element(child):
+                raise HwpxValueError(
+                    "tab controls require an explicit run target",
+                    code="paragraph-tab-target-required",
+                )
+    return nodes
+
+
+def edit_node_candidates(
+    nodes: list[ET.Element], prefix: int, end: int
+) -> list[tuple[ET.Element, int]]:
+    offset = 0
+    candidates: list[tuple[ET.Element, int]] = []
+    for node in nodes:
+        length = len(node.text or "")
+        if offset <= prefix and end <= offset + length:
+            candidates.append((node, offset))
+        offset += length
+    return candidates

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/hwpx/oxml/paragraph.py

@@ -40,6 +40,7 @@ from .note_authoring import (
     _paragraph_endnotes,
     _paragraph_footnotes,
 )
+from ._paragraph_text_edit import edit_node_candidates, plain_text_nodes_for_edit
 from .objects import (
     HwpxOxmlInlineObject,
     _create_picture_element,
@@ -336,6 +337,42 @@ class HwpxOxmlParagraph:
         _clear_paragraph_layout_cache(self.element)
         self.section.mark_dirty()
 
+    def set_text_preserving_runs(self, value: str) -> None:
+        """Replace one unambiguous text span without changing run boundaries.
+
+        The edit must fit inside one plain ``hp:t`` node. This covers a
+        correction within a styled run while retaining every other run and
+        control; cross-style replacements require an explicit run target.
+        """
+        from ..errors import HwpxValueError
+
+        nodes = plain_text_nodes_for_edit(self._run_elements())
+        old = "".join(node.text or "" for node in nodes)
+        if old == value:
+            return
+        if not nodes:
+            raise HwpxValueError("paragraph has no plain text node", code="paragraph-text-missing")
+        prefix = 0
+        while prefix < min(len(old), len(value)) and old[prefix] == value[prefix]:
+            prefix += 1
+        suffix = 0
+        while (suffix < len(old) - prefix and suffix < len(value) - prefix
+               and old[len(old) - suffix - 1] == value[len(value) - suffix - 1]):
+            suffix += 1
+        end = len(old) - suffix
+        replacement = value[prefix:len(value) - suffix if suffix else len(value)]
+        candidates = edit_node_candidates(nodes, prefix, end)
+        if len(candidates) != 1:
+            raise HwpxValueError(
+                "text edit crosses run boundaries or has ambiguous insertion style",
+                code="paragraph-text-style-ambiguous",
+            )
+        node, offset = candidates[0]
+        current = node.text or ""
+        node.text = _sanitize_text(current[:prefix - offset] + replacement + current[end - offset:])
+        _clear_paragraph_layout_cache(self.element)
+        self.section.mark_dirty()
+
     def clear_text(self) -> None:
         """Remove all text content while preserving styles and non-text elements.
 

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/hwpx/oxml/table.py

@@ -464,6 +464,30 @@ class HwpxOxmlTable:
             ")"
         )
 
+    @property
+    def height(self) -> int:
+        """Declared table height in HWP units."""
+        size = self.element.find(f"{_HP}sz")
+        return int(size.get("height", "0")) if size is not None else 0
+
+    @property
+    def treat_as_char(self) -> bool:
+        """Whether Hancom lays out this table as one inline character."""
+        position = self.element.find(f"{_HP}pos")
+        return position is not None and position.get("treatAsChar", "1") == "1"
+
+    def set_treat_as_char(self, value: bool) -> None:
+        """Choose inline layout or flowing table layout across pages."""
+        position = self.element.find(f"{_HP}pos")
+        if position is None:
+            from ..errors import HwpxValueError
+
+            raise HwpxValueError("table has no hp:pos", code="table-position-missing")
+        desired = "1" if value else "0"
+        if position.get("treatAsChar") != desired:
+            position.set("treatAsChar", desired)
+            self.mark_dirty()
+
     # --- caption (hp:caption) -----------------------------------------
 
     @property

{python_hwpx-6.4.0 → python_hwpx-6.5.0/src/python_hwpx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hwpx
-Version: 6.4.0
+Version: 6.5.0
 Summary: 한글 없이 HWPX 문서를 열고, 편집하고, 생성하고, 검증하는 Python 문서 라이브러리
 Author: python-hwpx Maintainers
 License-Expression: Apache-2.0

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/src/python_hwpx.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/hwpx/opc/xml_utils.py
 src/hwpx/oxml/__init__.py
 src/hwpx/oxml/_document_impl.py
 src/hwpx/oxml/_document_primitives.py
+src/hwpx/oxml/_paragraph_text_edit.py
 src/hwpx/oxml/body.py
 src/hwpx/oxml/canonical_defaults.py
 src/hwpx/oxml/color.py
@@ -306,6 +307,7 @@ tests/test_table_cell_equalize.py
 tests/test_table_cleanup.py
 tests/test_table_label.py
 tests/test_table_navigation.py
+tests/test_table_page_flow.py
 tests/test_table_patch.py
 tests/test_table_patch_dryrun.py
 tests/test_table_patch_m105.py

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/tests/test_equation_authoring.py

@@ -222,6 +222,7 @@ class TestLatexToEqedit:
             (r"$x + 1$", "x + 1"),
             (r"\le \ge \ne", "leq geq neq"),
             (r"a \times b \cdot c \div d", "a times b cdot c div d"),
+            (r"\triangle P_1 P_2 Q", "TRIANGLE P _{1} P _{2} Q"),
             (r"\lim_{x \to 0} \frac{1}{x}", "lim _{x -> 0} {1} over {x}"),
             (r"a \to b", "a -> b"),
             (r"x \rightarrow y , u \leftarrow v", "x -> y , u leftarrow v"),
@@ -274,6 +275,7 @@ class TestRoundtripStability:
         r"\begin{vmatrix} a & b \\ c & d \end{vmatrix}",
         r"\log_{2} x + \ln y",
         r"a \times b \pm c \mp d",
+        r"\triangle P_1 P_2 Q",
         r"\infty + \partial + \nabla",
     ]
 

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/tests/test_equation_converter.py

@@ -112,6 +112,31 @@ def test_times_and_relations() -> None:
     assert eqedit_to_latex("a >= b") == r"a \geq b"
 
 
+@pytest.mark.parametrize("token", ["triangle", "TRIANGLE"])
+def test_triangle_symbol_uses_exact_evidence_backed_tokens(token: str) -> None:
+    assert eqedit_to_latex(f"{token} P_1 P_2 Q") == r"\triangle P_1 P_2 Q"
+
+
+@pytest.mark.parametrize(
+    "script",
+    [
+        "Triangle PQR",
+        "triAngle PQR",
+        "triangles PQR",
+        "mytriangle PQR",
+        "triangleidentifier PQR",
+        "rmtriangle PQR",
+        "rm text",
+    ],
+)
+def test_triangle_support_does_not_split_identifiers_or_rm_text(script: str) -> None:
+    assert eqedit_to_latex(script) == script
+
+
+def test_existing_angle_symbol_remains_distinct_from_triangle() -> None:
+    assert eqedit_to_latex("angle ABC") == r"\angle ABC"
+
+
 def test_parentheses_and_braces_passthrough() -> None:
     assert eqedit_to_latex("( a + b )") == "( a + b )"
     assert eqedit_to_latex("LEFT ( x RIGHT )") == r"\left( x \right)"

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/tests/test_equation_render.py

@@ -3,8 +3,11 @@
 
 from __future__ import annotations
 
+from xml.etree import ElementTree
+
 import pytest
 
+from hwpx.equation.mathml import _split_text_literals
 from hwpx.equation import (
     LABEL_LATEX_ERROR,
     LABEL_LATEX_NO_LIB,
@@ -25,6 +28,37 @@ def test_success_path_renders_inline_mathml() -> None:
     assert result.latex == r"\frac{\alpha}{\beta} + \pi"
 
 
+@pytest.mark.parametrize("token", ["triangle", "TRIANGLE"])
+def test_triangle_renders_as_mathml_operator_without_changing_latex(token: str) -> None:
+    pytest.importorskip("latex2mathml")
+    result = render_equation(f"{token} P_1 P_2 Q")
+    assert result.mode == "mathml"
+    assert result.latex == r"\triangle P_1 P_2 Q"
+    root = ElementTree.fromstring(result.html)
+    namespace = "{http://www.w3.org/1998/Math/MathML}"
+    triangle_operators = [
+        operator
+        for operator in root.iter(f"{namespace}mo")
+        if "△" in "".join(operator.itertext())
+    ]
+    assert len(triangle_operators) == 1
+    assert "triangle" not in "".join(root.itertext()).lower()
+
+
+def test_quoted_triangle_literal_stays_text_and_is_not_annotated() -> None:
+    pytest.importorskip("latex2mathml")
+    # A quoted EqEdit literal becomes \text{...}; its content is prose and must
+    # not receive the operator wrapper (review on #93).
+    result = render_equation(r'"\triangle" + x')
+    assert result.mode == "mathml"
+    root = ElementTree.fromstring(result.html)
+    namespace = "{http://www.w3.org/1998/Math/MathML}"
+    texts = ["".join(node.itertext()) for node in root.iter(f"{namespace}mtext")]
+    assert texts == [r"\triangle"]
+    assert "mathop" not in result.html
+    assert "△" not in result.html
+
+
 def test_eqedit_failure_falls_back_to_original_script_block() -> None:
     # A brace/frac bomb exceeds the depth guard -> EqEdit->LaTeX fails.
     bomb = "{" * 200 + "x" + "}" * 200
@@ -67,3 +101,16 @@ def test_no_mode_ever_returns_empty_html() -> None:
 def test_latex2mathml_available_reflects_installation() -> None:
     # In the test extra latex2mathml is installed, so this is True.
     assert latex2mathml_available() is True
+
+
+@pytest.mark.parametrize(
+    ("latex", "expected"),
+    [
+        (r"\triangle + x", [(r"\triangle + x", False)]),
+        (r"\text{\triangle} + x", [(r"\text{\triangle}", True), (" + x", False)]),
+        (r"a \text{b {c} d} \triangle", [("a ", False), (r"\text{b {c} d}", True), (r" \triangle", False)]),
+        (r"\text{open", [(r"\text{open", False)]),
+    ],
+)
+def test_split_text_literals_keeps_quoted_content_opaque(latex: str, expected: list[tuple[str, bool]]) -> None:
+    assert _split_text_literals(latex) == expected

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/tests/test_golden_api.py

@@ -9,6 +9,7 @@ belong in this suite.
 from __future__ import annotations
 
 import json
+import subprocess
 import sys
 from collections.abc import Callable
 from io import BytesIO
@@ -19,7 +20,6 @@ import pytest
 
 from hwpx import HwpxDocument
 
-
 CONTRACT_PATH = Path(__file__).parent / "data" / "golden_api_contract.json"
 Scenario = Callable[[Path], None]
 
@@ -278,9 +278,28 @@ def test_golden_api_contract_is_complete() -> None:
 
 @pytest.mark.parametrize("scenario_id", CONTRACT["scenarios"])
 def test_core_only_golden_scenario(scenario_id: str, tmp_path: Path) -> None:
-    SCENARIOS[scenario_id](tmp_path)
-    assert not any(
-        module_name == prefix or module_name.startswith(f"{prefix}.")
-        for prefix in CONTRACT["forbiddenImportPrefixes"]
-        for module_name in sys.modules
+    # A fresh interpreter tests core-only imports even when another collected
+    # test imported automation into the pytest process.
+    code = """
+import importlib.util
+import json
+import sys
+from pathlib import Path
+spec = importlib.util.spec_from_file_location('golden_api_scenarios', sys.argv[1])
+module = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = module
+spec.loader.exec_module(module)
+module.SCENARIOS[sys.argv[2]](Path(sys.argv[3]))
+assert not any(
+    name == prefix or name.startswith(prefix + '.')
+    for prefix in module.CONTRACT['forbiddenImportPrefixes']
+    for name in sys.modules
+)
+"""
+    result = subprocess.run(
+        [sys.executable, "-c", code, str(Path(__file__).resolve()), scenario_id, str(tmp_path)],
+        capture_output=True,
+        text=True,
+        check=False,
     )
+    assert result.returncode == 0, result.stdout + result.stderr

{python_hwpx-6.4.0 → python_hwpx-6.5.0}/tests/test_product_boundary.py

@@ -298,7 +298,8 @@ def test_real_tree_gate_runs_from_a_gitless_source_copy(tmp_path: Path) -> None:
     # (oxml/note_authoring.py) — restores real headroom (1452/1600)
     # instead of the 5 lines left after train 48/㊽b's PATH delegator.
     # 전부 module-ownership.json 에 개별 rationale 과 함께 등재돼 있다.
-    assert report["classifiedFiles"] == 147
+    # +1: format-level plain-text edit helpers extracted from paragraph.py.
+    assert report["classifiedFiles"] == 148
 
 
 def test_gitless_cli_reproduces_literal_dynamic_import_failure_without_mutating_source(

python_hwpx-6.5.0/tests/test_table_page_flow.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from hwpx.document import HwpxDocument
+
+
+def test_table_treat_as_char_is_explicit_and_persists() -> None:
+    with HwpxDocument.new() as document:
+        table = document.add_table(2, 1)
+        assert table.treat_as_char is True
+        original_height = table.height
+        table.set_treat_as_char(False)
+        assert table.treat_as_char is False
+        reopened = HwpxDocument.open(document.to_bytes())
+        try:
+            assert reopened.tables.all[0].treat_as_char is False
+            assert reopened.tables.all[0].height == original_height
+        finally:
+            reopened.close()

python_hwpx-6.4.0/src/hwpx/equation/mathml.py

@@ -1,69 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0
-"""LaTeX → MathML conversion via the optional ``latex2mathml`` dependency.
-
-MathML keeps the preview self-contained: browsers render ``<math>`` natively, so
-no script or font bundle is shipped.  ``latex2mathml`` is an optional extra
-(``python-hwpx[preview]``); when it is absent the caller fails closed to a LaTeX
-code block rather than dropping the equation.
-"""
-
-from __future__ import annotations
-
-from typing import Callable
-
-# ``False`` marks a resolved-but-unavailable converter; ``None`` means "not yet
-# probed" so the import is attempted lazily on first use.
-_converter: Callable[[str], str] | bool | None = None
-
-
-class MathMLUnavailableError(RuntimeError):
-    """Raised when ``latex2mathml`` is not installed."""
-
-
-def _load_converter() -> Callable[[str], str] | bool:
-    global _converter
-    cached = _converter
-    if cached is not None:
-        return cached
-    try:
-        from latex2mathml.converter import convert
-    except ImportError:
-        _converter = False
-        return False
-    _converter = convert
-    return convert
-
-
-def latex2mathml_available() -> bool:
-    """Return ``True`` when the optional ``latex2mathml`` extra is importable."""
-
-    return _load_converter() is not False
-
-
-def latex_to_mathml(latex: str) -> str:
-    """Convert a LaTeX fragment to an inline ``<math>`` MathML string.
-
-    Raises:
-        MathMLUnavailableError: when ``latex2mathml`` is not installed.
-        ValueError: when ``latex2mathml`` cannot parse the fragment.
-    """
-
-    convert = _load_converter()
-    if convert is False:
-        raise MathMLUnavailableError(
-            "latex2mathml is required for MathML rendering; install python-hwpx[preview]"
-        )
-    assert not isinstance(convert, bool)  # narrowed for type-checkers
-    try:
-        return convert(latex)
-    except MathMLUnavailableError:
-        raise
-    except Exception as exc:  # latex2mathml raises bare Exception on bad input
-        raise ValueError(f"latex2mathml could not render fragment: {exc}") from exc
-
-
-__all__ = [
-    "MathMLUnavailableError",
-    "latex2mathml_available",
-    "latex_to_mathml",
-]