python-hwpx 5.2.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

hwpx/_document/layout.py

@@ -425,17 +425,28 @@ def add_hyperlink(
     paragraph: HwpxOxmlParagraph | None = None,
     section: HwpxOxmlSection | None = None,
     section_index: int | None = None,
+    char_pr_id_ref: str | int | None = None,
 ) -> HwpxOxmlInlineObject:
     """Insert a hyperlink (fieldBegin + text + fieldEnd).
 
+    The display text follows the Hancom convention (blue ``#0000FF`` text
+    with a blue bottom underline — dominant styling across real-corpus
+    hyperlinks) unless ``char_pr_id_ref`` overrides it.
+
     Returns the ``<hp:ctrl>`` wrapper containing the ``<hp:fieldBegin>``.
     """
+    if char_pr_id_ref is None:
+        char_pr_id_ref = doc.ensure_run_style(
+            underline=True,
+            color="#0000FF",
+            underline_color="#0000FF",
+        )
     if paragraph is None:
         paragraph = doc.add_paragraph(
             "", section=section, section_index=section_index,
             include_run=False,
         )
-    return paragraph.add_hyperlink(url, display_text)
+    return paragraph.add_hyperlink(url, display_text, char_pr_id_ref=char_pr_id_ref)
 
 
 def _resolve_section(

hwpx/_document/shapes.py

@@ -282,3 +282,78 @@ def add_equation(
     raise RuntimeError(
         "created equation was not recognized by the standard section scan"
     )
+
+
+def add_chart(
+    doc: "HwpxDocument",
+    chart_xml: bytes | str,
+    *,
+    paragraph: HwpxOxmlParagraph | None = None,
+    section: HwpxOxmlSection | None = None,
+    section_index: int | None = None,
+    size: tuple[int, int] | None = None,
+    treat_as_char: bool = False,
+    char_pr_id_ref: str | int | None = None,
+) -> HwpxOxmlInlineObject:
+    """Add a chartML part and its ``<hp:chart>`` anchor, then prove recognition.
+
+    The part is stored under ``Chart/chartN.xml`` and addressed directly by
+    the anchor's ``chartIDRef`` — real Hancom registers chart parts in no
+    manifest and draws the chart from the ECMA-376 chartML alone
+    (specs/055-chart-authoring/evidence/p0/chart-contract.md). The chartML is
+    validated to parse and to carry the ``c:chartSpace`` root before any part
+    is written; after insertion the anchor is re-read through the standard
+    section scan — creation fails loudly if it did not land (no
+    special-casing by design).
+    """
+    from lxml import etree as _etree  # type: ignore[reportAttributeAccessIssue]  # lxml has no complete bundled typing
+
+    from ..oxml.namespaces import HP
+
+    _CHART_SPACE = "{http://schemas.openxmlformats.org/drawingml/2006/chart}chartSpace"
+
+    data = chart_xml.encode("utf-8") if isinstance(chart_xml, str) else bytes(chart_xml)
+    if not data.strip():
+        raise ValueError("chart_xml must be non-empty chartML")
+    try:
+        root = _etree.fromstring(data)
+    except _etree.XMLSyntaxError as exc:
+        raise ValueError(f"chart_xml is not well-formed XML: {exc}") from exc
+    if root.tag != _CHART_SPACE:
+        raise ValueError(
+            "chart_xml root must be the ECMA-376 c:chartSpace element, "
+            f"got {root.tag!r}"
+        )
+
+    existing = {name for name in doc._package.part_names() if name.startswith("Chart/")}
+    n = 1
+    while f"Chart/chart{n}.xml" in existing:
+        n += 1
+    part_path = f"Chart/chart{n}.xml"
+
+    if paragraph is None:
+        paragraph = doc.add_paragraph(
+            "", section=section, section_index=section_index,
+            include_run=False,
+        )
+    doc._package.write(part_path, data)
+    inline_object = paragraph.add_chart(
+        part_path,
+        size=size,
+        treat_as_char=treat_as_char,
+        char_pr_id_ref=char_pr_id_ref,
+    )
+
+    created_id = inline_object.element.get("id", "")
+    for owning_section in doc.sections:
+        for candidate in owning_section.element.iter(f"{HP}chart"):
+            if candidate.get("id") != created_id:
+                continue
+            if candidate.get("chartIDRef") != part_path:
+                raise RuntimeError(
+                    "created chart anchor does not reference its part"
+                )
+            return inline_object
+    raise RuntimeError(
+        "created chart was not recognized by the standard section scan"
+    )

hwpx/document.py

@@ -264,14 +264,21 @@ class HwpxDocument:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Sequence[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
-        """Return a borderFill id matching the requested border/fill attributes."""
+        """Return a borderFill id matching the requested border/fill attributes.
+
+        ``border_type`` selects the OWPML line style (``SOLID``, ``DASH``,
+        ``DOT``, ``DOUBLE_SLIM``, ``WAVE``, …); values outside the OWPML
+        vocabulary are rejected.
+        """
 
         return self._root.ensure_border_fill(
             border_color=border_color,
             border_width=border_width,
             fill_color=fill_color,
             active_borders=active_borders,
+            border_type=border_type,
         )
 
     @property
@@ -594,9 +601,22 @@ class HwpxDocument:
         size: int | float | None = None,
         highlight: str | None = None,
         strike: bool | None = None,
+        underline_shape: str | None = None,
+        underline_color: str | None = None,
+        strike_shape: str | None = None,
+        ratio: int | None = None,
+        letter_spacing: int | None = None,
+        shadow: str | None = None,
+        script: str | None = None,
         base_char_pr_id: str | int | None = None,
     ) -> str:
-        """Return a ``charPr`` identifier matching the requested flags."""
+        """Return a ``charPr`` identifier matching the requested flags.
+
+        5.4.0 additions (render-verified vocabulary; invalid values are
+        rejected): ``underline_shape``/``underline_color``, ``strike_shape``,
+        ``ratio`` (장평 %), ``letter_spacing`` (자간 %), ``shadow`` (drop
+        shadow colour), ``script`` (``"sup"``/``"sub"``).
+        """
 
         return self._root.ensure_run_style(
             bold=bold,
@@ -607,6 +627,13 @@ class HwpxDocument:
             size=size,
             highlight=highlight,
             strike=strike,
+            underline_shape=underline_shape,
+            underline_color=underline_color,
+            strike_shape=strike_shape,
+            ratio=ratio,
+            letter_spacing=letter_spacing,
+            shadow=shadow,
+            script=script,
             base_char_pr_id=base_char_pr_id,
         )
 
@@ -1373,9 +1400,13 @@ class HwpxDocument:
         paragraph: HwpxOxmlParagraph | None = None,
         section: HwpxOxmlSection | None = None,
         section_index: int | None = None,
+        char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlInlineObject:
         """Insert a hyperlink (fieldBegin + text + fieldEnd).
 
+        The display text follows the Hancom convention (blue underlined)
+        unless ``char_pr_id_ref`` overrides it.
+
         Returns the ``<hp:ctrl>`` wrapper containing the ``<hp:fieldBegin>``.
         """
 
@@ -1386,6 +1417,7 @@ class HwpxDocument:
             paragraph=paragraph,
             section=section,
             section_index=section_index,
+            char_pr_id_ref=char_pr_id_ref,
         )
 
     def add_form_field(
@@ -1431,6 +1463,48 @@ class HwpxDocument:
         )
 
 
+    def add_chart(
+        self,
+        chart_xml: bytes | str,
+        *,
+        paragraph: HwpxOxmlParagraph | None = None,
+        section: HwpxOxmlSection | None = None,
+        section_index: int | None = None,
+        size: tuple[int, int] | None = None,
+        treat_as_char: bool = False,
+        char_pr_id_ref: str | int | None = None,
+    ) -> HwpxOxmlInlineObject:
+        """Insert a native chart from ECMA-376 chartML. **Experimental contract.**
+
+        Stores *chart_xml* as a ``Chart/chartN.xml`` package part and emits the
+        real-Hancom ``<hp:chart>`` anchor referencing it via ``chartIDRef``
+        (contract: ``specs/055-chart-authoring/evidence/p0/chart-contract.md``).
+        Hancom draws the chart from the chartML alone — no OLE fallback or
+        pre-rendered image is written. The chartML must parse and carry the
+        ``c:chartSpace`` root (typed rejection otherwise), and the created
+        anchor is re-read through the standard section scan — creation fails
+        loudly if the standard consumer would not see it.
+
+        Args:
+            chart_xml: ECMA-376 chartML document (``c:chartSpace``).
+            paragraph: Target paragraph (e.g. inside a table cell). When
+                omitted a new paragraph is appended to *section*.
+            size: Optional ``(width, height)`` HWPUNIT pair for the anchor.
+            treat_as_char: ``True`` places the chart inline in the text flow;
+                default mirrors the render-verified gold float placement.
+        """
+
+        return _shapes.add_chart(
+            self,
+            chart_xml,
+            paragraph=paragraph,
+            section=section,
+            section_index=section_index,
+            size=size,
+            treat_as_char=treat_as_char,
+            char_pr_id_ref=char_pr_id_ref,
+        )
+
     def add_equation(
         self,
         script: str,

hwpx/oxml/_document_primitives.py

@@ -422,9 +422,10 @@ def _border_fill_child_attrs(
     active: bool,
     color: str,
     width: str,
+    border_type: str = "SOLID",
 ) -> dict[str, str]:
     return {
-        "type": "SOLID" if active else "NONE",
+        "type": border_type if active else "NONE",
         "width": width,
         "color": color,
     }
@@ -465,6 +466,7 @@ def _border_fill_matches(
     border_width: str,
     fill_color: str | None,
     active_borders: set[str],
+    border_type: str = "SOLID",
 ) -> bool:
     if _element_local_name(element) != "borderFill":
         return False
@@ -484,7 +486,7 @@ def _border_fill_matches(
         child = element.find(f"{_HH}{child_name}")
         if child is None:
             return False
-        expected_type = "SOLID" if side in active_borders else "NONE"
+        expected_type = border_type if side in active_borders else "NONE"
         if (child.get("type") or "").upper() != expected_type:
             return False
         if _normalize_length(child.get("width")) != _normalize_length(border_width):
@@ -509,6 +511,7 @@ def _create_border_fill_element(
     border_width: str,
     fill_color: str | None,
     active_borders: set[str],
+    border_type: str = "SOLID",
 ) -> ET.Element:
     element = ET.Element(f"{_HH}borderFill", {"id": border_id, **_BASIC_BORDER_FILL_ATTRIBUTES})
     ET.SubElement(element, f"{_HH}slash", {"type": "NONE", "Crooked": "0", "isCounter": "0"})
@@ -521,6 +524,7 @@ def _create_border_fill_element(
                 active=side in active_borders,
                 color=border_color,
                 width=border_width,
+                border_type=border_type,
             ),
         )
     ET.SubElement(
@@ -579,6 +583,17 @@ def _default_cell_margin_attributes() -> dict[str, str]:
     return {"left": "0", "right": "0", "top": "0", "bottom": "0"}
 
 
+def _default_cell_inner_margin_attributes() -> dict[str, str]:
+    """Hancom's new-table cell padding: 1.8 mm left/right, 0.5 mm top/bottom.
+
+    Measured from real Hancom-authored gold documents
+    (specs/056-authoring-fidelity-audit — the audit found our former 0
+    padding makes text hug the borders, visibly unlike a Hancom table).
+    """
+
+    return {"left": "510", "right": "510", "top": "141", "bottom": "141"}
+
+
 def _get_int_attr(element: ET.Element, name: str, default: int = 0) -> int:
     """Return *name* attribute of *element* as an integer."""
 

hwpx/oxml/document_parts.py

@@ -59,6 +59,13 @@ class _RunStyleSpec:
     height: str | None
     strike: bool | None
     font_ref: dict[str, str] | None
+    underline_shape: str | None = None
+    underline_color: str | None = None
+    strike_shape: str | None = None
+    ratio: int | None = None
+    letter_spacing: int | None = None
+    shadow_color: str | None = None
+    script: str | None = None
 
 
 def _run_style_element_flags(element: ET.Element) -> tuple[bool, bool, bool]:
@@ -78,6 +85,81 @@ def _run_style_element_strike(element: ET.Element) -> bool:
     return strike_element.get("shape", "").upper() != "NONE"
 
 
+def _validated_line_shape(
+    value: str | None, vocabulary: frozenset[str], label: str
+) -> str | None:
+    if value is None:
+        return None
+    normalized = str(value).upper()
+    if normalized not in vocabulary:
+        raise ValueError(f"unsupported {label} {value!r}")
+    return normalized
+
+
+def _run_style_underline_matches(element: ET.Element, spec: _RunStyleSpec) -> bool:
+    if spec.underline_shape is None and spec.underline_color is None:
+        return True
+    underline = element.find(f"{_HH}underline")
+    if underline is None:
+        return False
+    if spec.underline_shape is not None and (
+        underline.get("shape", "").upper() != spec.underline_shape
+    ):
+        return False
+    if spec.underline_color is not None and (
+        (underline.get("color") or "").upper() != spec.underline_color.upper()
+    ):
+        return False
+    return True
+
+
+def _run_style_lang_value_matches(
+    element: ET.Element, tag: str, value: int | None
+) -> bool:
+    if value is None:
+        return True
+    node = element.find(f"{_HH}{tag}")
+    return node is not None and node.get("hangul") == str(value)
+
+
+def _run_style_extensions_match(element: ET.Element, spec: _RunStyleSpec) -> bool:
+    if not _run_style_underline_matches(element, spec):
+        return False
+    if spec.strike_shape is not None:
+        strike_el = element.find(f"{_HH}strikeout")
+        if strike_el is None or strike_el.get("shape", "").upper() != spec.strike_shape:
+            return False
+    if not _run_style_lang_value_matches(element, "ratio", spec.ratio):
+        return False
+    if not _run_style_lang_value_matches(element, "spacing", spec.letter_spacing):
+        return False
+    if not _run_style_shadow_matches(element, spec.shadow_color):
+        return False
+    if not _run_style_script_matches(element, spec.script):
+        return False
+    return True
+
+
+def _run_style_shadow_matches(element: ET.Element, shadow_color: str | None) -> bool:
+    if shadow_color is None:
+        return True
+    shadow_el = element.find(f"{_HH}shadow")
+    if shadow_el is None or shadow_el.get("type", "").upper() == "NONE":
+        return False
+    return (shadow_el.get("color") or "").upper() == shadow_color.upper()
+
+
+def _run_style_script_matches(element: ET.Element, script: str | None) -> bool:
+    if script is None:
+        return True
+    if not _run_style_lang_value_matches(element, "relSz", 67):
+        return False
+    off_el = element.find(f"{_HH}offset")
+    # 실한컴 렌더 실측: offset 음수=위로(위첨자), 양수=아래로(아래첨자).
+    wanted_offset = "-30" if script == "sup" else "30"
+    return off_el is not None and off_el.get("hangul") == wanted_offset
+
+
 def _run_style_predicate(element: ET.Element, spec: _RunStyleSpec) -> bool:
     if _run_style_element_flags(element) != spec.flags:
         return False
@@ -92,6 +174,8 @@ def _run_style_predicate(element: ET.Element, spec: _RunStyleSpec) -> bool:
         return False
     if spec.strike is not None and _run_style_element_strike(element) != bool(spec.strike):
         return False
+    if not _run_style_extensions_match(element, spec):
+        return False
     if spec.font_ref is not None:
         font_ref = element.find(f"{_HH}fontRef")
         if font_ref is None:
@@ -127,9 +211,10 @@ def _run_style_apply_underline(
 ) -> None:
     underline_attrs = dict(base_underline_attrs)
     if want_underline:
-        underline_attrs.setdefault("type", "SOLID")
-        if underline_attrs.get("type", "").upper() == "NONE":
-            underline_attrs["type"] = "SOLID"
+        # 실한컴 gold 관례: hh:underline type은 위치 어휘(BOTTOM/CENTER/TOP).
+        underline_attrs.setdefault("type", "BOTTOM")
+        if underline_attrs.get("type", "").upper() in ("NONE", "SOLID"):
+            underline_attrs["type"] = "BOTTOM"
         underline_attrs.setdefault(
             "shape", base_underline_attrs.get("shape", "SOLID")
         )
@@ -159,6 +244,56 @@ def _run_style_apply_strikeout(
         _append_child(element, f"{_HH}strikeout", strike_attrs)
 
 
+def _run_style_set_lang_values(element: ET.Element, tag: str, value: int) -> None:
+    node = element.find(f"{_HH}{tag}")
+    if node is None:
+        node = _append_child(element, f"{_HH}{tag}")
+    for lang in ("hangul", "latin", "hanja", "japanese", "other", "symbol", "user"):
+        node.set(lang, str(value))
+
+
+def _run_style_apply_underline_extension(
+    element: ET.Element, spec: _RunStyleSpec
+) -> None:
+    if spec.underline_shape is None and spec.underline_color is None:
+        return
+    underline = element.find(f"{_HH}underline")
+    if underline is None:
+        return
+    if underline.get("type", "").upper() == "NONE":
+        underline.set("type", "BOTTOM")
+    if spec.underline_shape is not None:
+        underline.set("shape", spec.underline_shape)
+    if spec.underline_color is not None:
+        underline.set("color", spec.underline_color)
+
+
+def _run_style_apply_extensions(element: ET.Element, spec: _RunStyleSpec) -> None:
+    _run_style_apply_underline_extension(element, spec)
+    if spec.strike_shape is not None:
+        strike_el = element.find(f"{_HH}strikeout")
+        if strike_el is None:
+            strike_el = _append_child(element, f"{_HH}strikeout")
+        strike_el.set("shape", spec.strike_shape)
+        if not strike_el.get("color"):
+            strike_el.set("color", "#000000")
+    if spec.ratio is not None:
+        _run_style_set_lang_values(element, "ratio", spec.ratio)
+    if spec.letter_spacing is not None:
+        _run_style_set_lang_values(element, "spacing", spec.letter_spacing)
+    if spec.shadow_color is not None:
+        shadow_el = element.find(f"{_HH}shadow")
+        if shadow_el is None:
+            shadow_el = _append_child(element, f"{_HH}shadow")
+        shadow_el.set("type", "DROP")
+        shadow_el.set("color", spec.shadow_color)
+        shadow_el.set("offsetX", "12")
+        shadow_el.set("offsetY", "12")
+    if spec.script is not None:
+        _run_style_set_lang_values(element, "relSz", 67)
+        _run_style_set_lang_values(element, "offset", -30 if spec.script == "sup" else 30)
+
+
 def _run_style_modifier(element: ET.Element, spec: _RunStyleSpec) -> None:
     underline_nodes = list(element.findall(f"{_HH}underline"))
     base_underline_attrs = (
@@ -186,6 +321,8 @@ def _run_style_modifier(element: ET.Element, spec: _RunStyleSpec) -> None:
     _run_style_apply_underline(element, base_underline_attrs, spec.flags[2])
     _run_style_apply_strikeout(element, base_strike_attrs, spec.strike)
 
+    _run_style_apply_extensions(element, spec)
+
 
 class HwpxOxmlDocument:
     """Aggregates the XML parts that make up an HWPX document."""
@@ -357,6 +494,12 @@ class HwpxOxmlDocument:
             return None
         return cache.get(normalized)
 
+    _UNDERLINE_SHAPES = frozenset({
+        "SOLID", "DASH", "DOT", "DASH_DOT", "DASH_DOT_DOT", "LONG_DASH",
+        "CIRCLE", "DOUBLE_SLIM", "SLIM_THICK", "THICK_SLIM",
+        "SLIM_THICK_SLIM", "WAVE", "DOUBLEWAVE",
+    })
+
     def ensure_run_style(
         self,
         *,
@@ -368,13 +511,45 @@ class HwpxOxmlDocument:
         size: int | float | None = None,
         highlight: str | None = None,
         strike: bool | None = None,
+        underline_shape: str | None = None,
+        underline_color: str | None = None,
+        strike_shape: str | None = None,
+        ratio: int | None = None,
+        letter_spacing: int | None = None,
+        shadow: str | None = None,
+        script: str | None = None,
         base_char_pr_id: str | int | None = None,
     ) -> str:
-        """Return a char property identifier matching the requested flags."""
+        """Return a char property identifier matching the requested flags.
+
+        The 5.4.0 additions mirror what the fidelity audit render-verified on
+        real Hancom: ``underline_shape``/``underline_color`` (implies an
+        underline), ``strike_shape`` (implies a strikeout), ``ratio`` (장평 %),
+        ``letter_spacing`` (자간 %), ``shadow`` (drop-shadow colour), and
+        ``script`` (``"sup"``/``"sub"``). Values outside the OWPML vocabulary
+        are rejected — no silent approximation.
+        """
 
         if not self._headers:
             raise ValueError("document does not contain any headers")
 
+        normalized_underline_shape = _validated_line_shape(
+            underline_shape, self._UNDERLINE_SHAPES, "underline_shape"
+        )
+        if normalized_underline_shape is not None or underline_color is not None:
+            underline = True
+        normalized_strike_shape = _validated_line_shape(
+            strike_shape, self._UNDERLINE_SHAPES, "strike_shape"
+        )
+        if normalized_strike_shape is not None:
+            strike = True
+        if ratio is not None and not 10 <= int(ratio) <= 400:
+            raise ValueError("ratio must be a percentage between 10 and 400")
+        if letter_spacing is not None and not -50 <= int(letter_spacing) <= 100:
+            raise ValueError("letter_spacing must be between -50 and 100")
+        if script is not None and script not in ("sup", "sub"):
+            raise ValueError('script must be "sup" or "sub"')
+
         header = self._headers[0]
         spec = _RunStyleSpec(
             flags=(bool(bold), bool(italic), bool(underline)),
@@ -383,6 +558,13 @@ class HwpxOxmlDocument:
             height=_char_height_from_points(size),
             strike=strike,
             font_ref=header.font_ref_for_face(font) if font is not None else None,
+            underline_shape=normalized_underline_shape,
+            underline_color=_normalize_color(underline_color),
+            strike_shape=normalized_strike_shape,
+            ratio=int(ratio) if ratio is not None else None,
+            letter_spacing=int(letter_spacing) if letter_spacing is not None else None,
+            shadow_color=_normalize_color(shadow),
+            script=script,
         )
         element = header.ensure_char_property(
             predicate=lambda el: _run_style_predicate(el, spec),
@@ -425,6 +607,7 @@ class HwpxOxmlDocument:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Iterable[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
         if not self._headers:
             return "0"
@@ -433,6 +616,7 @@ class HwpxOxmlDocument:
             border_width=border_width,
             fill_color=fill_color,
             active_borders=active_borders,
+            border_type=border_type,
         )
 
     def ensure_shading_border_fill(

hwpx/oxml/header_part.py

@@ -898,6 +898,13 @@ class HwpxOxmlHeader:
         self.mark_dirty()
         return new_id
 
+    _BORDER_LINE_TYPES = frozenset({
+        "SOLID", "DASH", "DOT", "DASH_DOT", "DASH_DOT_DOT", "LONG_DASH",
+        "CIRCLE", "DOUBLE_SLIM", "SLIM_THICK", "THICK_SLIM", "SLIM_THICK_SLIM",
+        "WAVE", "DOUBLEWAVE", "THICK_3D", "THICK_3D_REVERSE_LIGHTING",
+        "SLIM_3D", "SLIM_3D_REVERSE_LIGHTING",
+    })
+
     def ensure_border_fill(
         self,
         *,
@@ -905,11 +912,18 @@ class HwpxOxmlHeader:
         border_width: str = "0.12 mm",
         fill_color: str | None = None,
         active_borders: Iterable[str] | None = None,
+        border_type: str = "SOLID",
     ) -> str:
         element = self._border_fills_element(create=True)
         if element is None:  # pragma: no cover - defensive branch
             raise RuntimeError("failed to create <borderFills> element")
 
+        normalized_border_type = str(border_type or "SOLID").upper()
+        if normalized_border_type not in self._BORDER_LINE_TYPES:
+            raise ValueError(
+                f"unsupported border_type {border_type!r}; expected one of "
+                + ", ".join(sorted(self._BORDER_LINE_TYPES))
+            )
         normalized_border_color = _normalize_color(border_color) or "#BFBFBF"
         normalized_border_width = str(border_width or "0.12 mm")
         normalized_active_borders = _normalize_border_side_names(active_borders)
@@ -922,6 +936,7 @@ class HwpxOxmlHeader:
                 border_width=normalized_border_width,
                 fill_color=normalized_fill_color,
                 active_borders=normalized_active_borders,
+                border_type=normalized_border_type,
             ):
                 border_id = border_fill.get("id")
                 if border_id:
@@ -934,6 +949,7 @@ class HwpxOxmlHeader:
             border_width=normalized_border_width,
             fill_color=normalized_fill_color,
             active_borders=normalized_active_borders,
+            border_type=normalized_border_type,
         )
         if isinstance(element, LET._Element):
             new_border_fill = LET.fromstring(ET.tostring(new_border_fill, encoding="utf-8"))

hwpx/oxml/paragraph.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING, Sequence, cast
 import warnings
 import xml.etree.ElementTree as ET
 
@@ -405,6 +405,59 @@ class HwpxOxmlParagraph:
                     tables.append(HwpxOxmlTable(child, self))
         return tables
 
+    def _context_table_width(self) -> int | None:
+        """Hancom-like default table width for this paragraph's context.
+
+        Inside a table cell the parent cell's usable width bounds the new
+        (nested) table — the fidelity audit reproduced silent content loss
+        when the fixed per-cell default exceeded it. At body level Hancom
+        fits a new table to the text width (page width minus margins).
+        Returns ``None`` when neither context is measurable.
+        """
+
+        # stdlib ET has no getparent; lxml-backed elements do. Guarded getattr
+        # keeps both backends working (19 suite failures without the guard).
+        get_parent = getattr(self.element, "getparent", None)
+        ancestor = cast(
+            "ET.Element | None", get_parent() if callable(get_parent) else None
+        )
+        while ancestor is not None:
+            if tag_local_name(ancestor.tag) == "tc":
+                cell_sz = ancestor.find(f"{_HP}cellSz")
+                margin = ancestor.find(f"{_HP}cellMargin")
+                if cell_sz is not None:
+                    try:
+                        width = int(cell_sz.get("width", "0"))
+                    except ValueError:
+                        return None
+                    pad = 0
+                    if margin is not None:
+                        try:
+                            pad = int(margin.get("left", "0")) + int(
+                                margin.get("right", "0")
+                            )
+                        except ValueError:
+                            pad = 0
+                    usable = width - pad
+                    return usable if usable > 0 else None
+                return None
+            next_parent = getattr(ancestor, "getparent", None)
+            ancestor = cast(
+                "ET.Element | None",
+                next_parent() if callable(next_parent) else None,
+            )
+
+        try:
+            properties = self.section.properties
+            page = properties.page_size
+            margins = properties.page_margins
+        except Exception:
+            return None
+        if page.width <= 0:
+            return None
+        usable = page.width - margins.left - margins.right - margins.gutter
+        return usable if usable > 0 else None
+
     def add_table(
         self,
         rows: int,
@@ -416,6 +469,8 @@ class HwpxOxmlParagraph:
         run_attributes: dict[str, str] | None = None,
         char_pr_id_ref: str | int | None = None,
     ) -> HwpxOxmlTable:
+        if width is None:
+            width = self._context_table_width()
         if border_fill_id_ref is None:
             document = self.section.document
             if document is not None:
@@ -809,8 +864,10 @@ class HwpxOxmlParagraph:
         """
         field_id = _object_id()
 
-        # Run 1: fieldBegin
-        run1 = self._create_run_for_object(char_pr_id_ref=char_pr_id_ref)
+        # 실한컴 gold 관례: 링크 서식(charPr)은 표시 텍스트 런에만 싣고
+        # fieldBegin/fieldEnd 런은 주변 서식을 유지한다 — 뒤에 추가되는
+        # 문단이 링크 서식을 상속(파랑 전염)하지 않게 하는 조건이기도 하다.
+        run1 = self._create_run_for_object()
         ctrl1 = _append_child(run1, f"{_HP}ctrl", {})
         fb_attrs: dict[str, str] = {
             "id": field_id,
@@ -827,13 +884,85 @@ class HwpxOxmlParagraph:
         t.text = _sanitize_text(display_text)
 
         # Run 3: fieldEnd
-        run3 = self._create_run_for_object(char_pr_id_ref=char_pr_id_ref)
+        run3 = self._create_run_for_object()
         ctrl3 = _append_child(run3, f"{_HP}ctrl", {})
         _append_child(ctrl3, f"{_HP}fieldEnd", {"beginIDRef": field_id})
 
         self.section.mark_dirty()
         return HwpxOxmlInlineObject(ctrl1, self)
 
+    def add_chart(
+        self,
+        chart_id_ref: str,
+        *,
+        size: tuple[int, int] | None = None,
+        treat_as_char: bool = False,
+        char_pr_id_ref: str | int | None = None,
+        run_attributes: dict[str, str] | None = None,
+    ) -> HwpxOxmlInlineObject:
+        """Insert a native ``<hp:chart>`` anchor referencing a chartML part.
+
+        Emits the real-Hancom chart anchor (contract reverse-engineered in
+        specs/055-chart-authoring/evidence/p0/chart-contract.md): the chart
+        content lives in an ECMA-376 chartML part addressed directly by
+        ``chartIDRef`` (real Hancom registers the part in no manifest), and
+        Hancom lays the chart out from the chartML alone — no OLE fallback or
+        pre-rendered image is required.
+
+        Args:
+            chart_id_ref: Package path of the chartML part
+                (e.g. ``Chart/chart1.xml``).
+            size: Optional ``(width, height)`` HWPUNIT pair for ``<hp:sz>``;
+                defaults to the gold document's 32250x18750.
+            treat_as_char: ``True`` places the chart inline in the text flow;
+                the default mirrors the gold float placement.
+        """
+        reference = chart_id_ref.strip()
+        if not reference:
+            raise ValueError("chart_id_ref must be a non-empty package path")
+        width, height = size if size is not None else (32250, 18750)
+        run = self._create_run_for_object(
+            run_attributes, char_pr_id_ref=char_pr_id_ref
+        )
+        chart = _append_child(run, f"{_HP}chart", {
+            "id": _object_id(),
+            "zOrder": "0",
+            "numberingType": "PICTURE",
+            "textWrap": "TOP_AND_BOTTOM" if treat_as_char else "SQUARE",
+            "textFlow": "BOTH_SIDES",
+            "lock": "0",
+            "dropcapstyle": "None",
+            "chartIDRef": reference,
+        })
+        _append_child(chart, f"{_HP}sz", {
+            "width": str(width),
+            "widthRelTo": "ABSOLUTE",
+            "height": str(height),
+            "heightRelTo": "ABSOLUTE",
+            "protect": "0",
+        })
+        _append_child(chart, f"{_HP}pos", {
+            "treatAsChar": "1" if treat_as_char else "0",
+            "affectLSpacing": "0",
+            "flowWithText": "1",
+            "allowOverlap": "0",
+            "holdAnchorAndSO": "0",
+            "vertRelTo": "PARA",
+            "horzRelTo": "PARA" if treat_as_char else "COLUMN",
+            "vertAlign": "TOP",
+            "horzAlign": "LEFT",
+            "vertOffset": "0",
+            "horzOffset": "0",
+        })
+        _append_child(chart, f"{_HP}outMargin", {
+            "left": "0",
+            "right": "0",
+            "top": "0",
+            "bottom": "0",
+        })
+        self.section.mark_dirty()
+        return HwpxOxmlInlineObject(chart, self)
+
     def add_equation(
         self,
         script: str,

hwpx/oxml/section.py

@@ -25,6 +25,7 @@ from ._document_primitives import (
 from .memo import HwpxOxmlMemo, HwpxOxmlMemoGroup
 from .paragraph import HwpxOxmlParagraph
 from .section_format import HwpxOxmlSectionProperties
+from .namespaces import tag_local_name
 from .section_story import HwpxOxmlSectionHeaderFooter
 
 if TYPE_CHECKING:
@@ -176,6 +177,55 @@ class HwpxOxmlSection:
             paragraph = paras[paragraph]
         paragraph.remove()
 
+    def _inherited_paragraph_refs(
+        self,
+    ) -> tuple[str | None, str | None, str | None]:
+        """Style refs the next appended paragraph inherits from the last one.
+
+        A list paragraph (bullet/numbered paraPr) must not leak into the next
+        paragraph — in Hancom, Enter continues the list but programmatic
+        appends of ordinary text are body text. The fidelity audit reproduced
+        every following paragraph turning into a list item without this guard.
+        """
+
+        existing = self.paragraphs
+        if not existing:
+            return None, None, None
+        last = existing[-1]
+        prev_para_ref = last.para_pr_id_ref
+        prev_style_ref = last.style_id_ref
+        prev_char_ref = last.char_pr_id_ref
+        if prev_para_ref is not None and self._para_pr_is_list(prev_para_ref):
+            prev_para_ref = None
+            prev_style_ref = None
+        return prev_para_ref, prev_style_ref, prev_char_ref
+
+    def _para_pr_is_list(self, para_pr_id_ref: str | int) -> bool:
+        """True when the paraPr carries a bullet/numbered heading."""
+
+        document = self.document
+        if document is None:
+            return False
+        wanted = str(para_pr_id_ref)
+        for header in getattr(document, "_headers", []):
+            para_properties = getattr(header, "_para_properties_element", None)
+            if para_properties is None:
+                continue
+            container = para_properties()
+            if container is None:
+                continue
+            for para_pr in container:
+                if para_pr.get("id") != wanted:
+                    continue
+                for child in para_pr:
+                    if tag_local_name(child.tag) == "heading":
+                        return str(child.get("type", "")).upper() in {
+                            "BULLET",
+                            "NUMBER",
+                        }
+                return False
+        return False
+
     def add_paragraph(
         self,
         text: str = "",
@@ -202,16 +252,9 @@ class HwpxOxmlSection:
         """
 
         # Collect style refs from the last paragraph for inheritance.
-        prev_para_ref: str | None = None
-        prev_style_ref: str | None = None
-        prev_char_ref: str | None = None
-        if inherit_style:
-            existing = self.paragraphs
-            if existing:
-                last = existing[-1]
-                prev_para_ref = last.para_pr_id_ref
-                prev_style_ref = last.style_id_ref
-                prev_char_ref = last.char_pr_id_ref
+        prev_para_ref, prev_style_ref, prev_char_ref = (
+            self._inherited_paragraph_refs() if inherit_style else (None, None, None)
+        )
 
         attrs = {"id": _paragraph_id(), **_DEFAULT_PARAGRAPH_ATTRS}
         attrs.update(extra_attrs)

hwpx/oxml/table.py

@@ -12,6 +12,7 @@ import xml.etree.ElementTree as ET
 from ._document_primitives import (
     _DEFAULT_CELL_HEIGHT,
     _DEFAULT_CELL_WIDTH,
+    _default_cell_inner_margin_attributes,
     _DEFAULT_PARAGRAPH_ATTRS,
     _HP,
     _append_child,
@@ -459,7 +460,7 @@ class HwpxOxmlTable:
             },
         )
         ET.SubElement(table, f"{_HP}outMargin", _default_cell_margin_attributes())
-        ET.SubElement(table, f"{_HP}inMargin", _default_cell_margin_attributes())
+        ET.SubElement(table, f"{_HP}inMargin", _default_cell_inner_margin_attributes())
 
         column_widths = _distribute_size(max(table_width, 0), cols)
         row_heights = _distribute_size(max(table_height, 0), rows)
@@ -486,7 +487,7 @@ class HwpxOxmlTable:
                         "height": str(row_heights[row_index] if row_heights else 0),
                     },
                 )
-                ET.SubElement(cell, f"{_HP}cellMargin", _default_cell_margin_attributes())
+                ET.SubElement(cell, f"{_HP}cellMargin", _default_cell_inner_margin_attributes())
         return table
 
     def mark_dirty(self) -> None:
@@ -647,6 +648,18 @@ class HwpxOxmlTable:
         entry = self._grid_entry(row_index, col_index)
         return entry.cell
 
+    def set_cell_border_fill(
+        self, row_index: int, col_index: int, border_fill_id_ref: str | int
+    ) -> None:
+        """Point one cell at a header ``borderFill`` definition.
+
+        Pairs with :meth:`set_cell_shading`; obtain ids from
+        ``document.ensure_border_fill`` (line style/width/color/fill).
+        """
+        cell = self.cell(row_index, col_index)
+        cell.element.set("borderFillIDRef", str(border_fill_id_ref))
+        self.mark_dirty()
+
     def set_cell_shading(self, row_index: int, col_index: int, color: str) -> None:
         cell = self.cell(row_index, col_index)
         document = self.paragraph.section.document

{python_hwpx-5.2.0.dist-info → python_hwpx-5.4.0.dist-info}/METADATA

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

{python_hwpx-5.2.0.dist-info → python_hwpx-5.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 hwpx/__init__.py,sha256=WmlWHk6vfjr2HQa6Dzp6rmIXIUJXKWKDZJZ-LBpL3Nc,15936
 hwpx/body_patch.py,sha256=XfwrTMThS9vPLA62PDnEleCGuvYv61URxelbD_LHe8w,25730
-hwpx/document.py,sha256=3N90Ra8krX4Skj5WUTDl4ezHf1q0yaBQCKqficnR1p8,64169
+hwpx/document.py,sha256=XV8T-ucd0F-Uup6XBUe_ZLliSNuImq7MgGhefIwMQD0,67298
 hwpx/errors.py,sha256=l3QK2Izwkpm25ar7QnNQvyg0yosoLfQt7kW5wn5MCG0,3033
 hwpx/experimental.py,sha256=BfD3fvXDgiEEm8G66TuUe_OPETitGwFU0VurUXUuV9Q,1693
 hwpx/mutation_report.py,sha256=6hurhDdgGiONeLIeWZJT8lwLtWJZ1VHp1l6G0zy0mQo,19409
@@ -12,11 +12,11 @@ hwpx/templates.py,sha256=28bYqeJVeDb1Cq8G9NZG9Mhnu4K2GamAKC4QhxvUZyA,1187
 hwpx/_document/__init__.py,sha256=REiNqMbuk_TS4NVC27FIo1rUt3Z8nhJrTBGOgNtxBRg,90
 hwpx/_document/_units.py,sha256=qyC8YtnvV2VlSGltJntDaIMF_sHy_XJZCwwe-g080TQ,386
 hwpx/_document/fields.py,sha256=6VB7FV69cWcHLONj_Bn_DUGH5k9IMn94SRhRCia6wvI,22935
-hwpx/_document/layout.py,sha256=TicBhdxXW2lQkLyG5bg6PHW-OP-X4oWdP6XAgAXw8mg,23089
+hwpx/_document/layout.py,sha256=_fNHVqI2zFUn6L1-JsdyO8Z4UShmIi9G29Y5YJtQtKw,23553
 hwpx/_document/media.py,sha256=kamsFJZ4K9aoKhjyztMHC64MVFR_ZQ50rDVgouZqxFA,11592
 hwpx/_document/memos.py,sha256=_tscEhNfPe9-iAkcEtJGjwHTN42_lx4stFoPrgJxk3o,7481
 hwpx/_document/persistence.py,sha256=NgWeFmm6jWV11194kdx32lwRQ6dyqiQYnc1ZBzJcIbE,16003
-hwpx/_document/shapes.py,sha256=XoCp41A6AmemOv9tGSMXRyu7sE7SMVBSzXSZfkelKWA,8825
+hwpx/_document/shapes.py,sha256=NC3eaA4H2cXDdTi3REMaSZifXqwpChAhS4LPGCSDUc0,11702
 hwpx/_document/tracked.py,sha256=1sQ9Q3-_wOAH2SQPbJQAeCG9E9HjV3y1gCORzrPUEPo,5010
 hwpx/data/Skeleton.hwpx,sha256=yR-3epkzo-VkWiV3ji0rmemBN-2ZVypdHdKe8MD9TJg,7490
 hwpx/equation/__init__.py,sha256=0wks0_pS_tBokCVMeWUJGE6tbW35Ptc0I5Z_36FY-Jo,1328
@@ -43,28 +43,28 @@ hwpx/opc/security.py,sha256=hsA73sZxUoGIgy2zue9EnV7ChHMfasnplmqzxFs3Mp4,4419
 hwpx/opc/xml_utils.py,sha256=L_fHY1-D5I_TfdRkDQV-bn55EnXc6AqEDWItfMpawVs,3840
 hwpx/oxml/__init__.py,sha256=pqHqOK2snS74U_mkmkFcgyCUCLiGmbS84TKFBrwxF5I,5507
 hwpx/oxml/_document_impl.py,sha256=41cxktJqXHER37fjA5HIFR8kw7dHMoISTxEv53PRBYo,5367
-hwpx/oxml/_document_primitives.py,sha256=IrruWTqHevJZpfnpZNmedeYErpyNIlRSYlkWyEUOA8k,18636
+hwpx/oxml/_document_primitives.py,sha256=4nMOkaDmNbpg_kKRG0_Nr0k5TqmDGRWR_f9jhCykdZY,19207
 hwpx/oxml/body.py,sha256=qd_t8bPdK4QaW_y7hEIOsqM_qiB1UAKQXzvGI4xriGA,32163
 hwpx/oxml/canonical_defaults.py,sha256=WHAK7u_W-PDv3P3N1-1-aWAoiUgBh4x-UybFL4NqW-w,3791
 hwpx/oxml/color.py,sha256=K2lbU_JdqRxFkQelGD6BbBkH1IspJSQyGlKHNz1Nmf4,2393
 hwpx/oxml/common.py,sha256=TJkafzg7x4T3J29tZchRZk57ZTsrM9PEiqGT3rX3w5o,1044
 hwpx/oxml/document.py,sha256=0Ml-t2fwa4f2xMfu5jbkOoh_KDKCCf3gNpaYICRV-KY,1172
-hwpx/oxml/document_parts.py,sha256=fbj_MA8imnKhz6XN2ufNAMPYNI5xi0dCNjEv0nGESwo,41692
+hwpx/oxml/document_parts.py,sha256=NSlCmXKfItIaTEYruu6zUh-XHZRRDI9XZ2U-5rD2UUU,49240
 hwpx/oxml/header.py,sha256=4LtTDPe7YW0o_4jPv3Rd-vyv5suRfebecxtTWbF65Uw,50011
-hwpx/oxml/header_part.py,sha256=BIwdzDlwJSxcVIErZ8jQuT2vQ4Tndr4Xa87beYbpSFU,50640
+hwpx/oxml/header_part.py,sha256=JBOw3Ljkt0PCYYKP7IlFpxA1ZRbrBHqDo8hjvE-yMsk,51409
 hwpx/oxml/memo.py,sha256=QlmuELEzywnmywgjm94S3vzJB8wPpoFOmI8KVuzoNPw,9484
 hwpx/oxml/namespaces.py,sha256=c7JfdOdJbzrhyHvjbxoeeeloRE3xPuoB7v3YI8SmKDk,6524
 hwpx/oxml/numbering.py,sha256=9a0ARGW1DkKsTF7mEEXM4FA5loQmzIBuqE4APA8UFIQ,669
 hwpx/oxml/objects.py,sha256=8ErDXWvkjLm3FTsx0Z_IovUXbiv2uc-j0B5Y2-OtihA,20864
-hwpx/oxml/paragraph.py,sha256=U-bGkgMs3wiEBE1TXW6jSJj0SYwzN9xtWeOyOhLLJt0,44238
+hwpx/oxml/paragraph.py,sha256=eZHoEnwiVhk9HvvhCZ77WMo1iulOD6BtLU_RvVHoDNY,49635
 hwpx/oxml/parser.py,sha256=pIfyNdW3WdFkCcE8JFY7hn1fobRbMngzfhVZICvWeVs,2937
 hwpx/oxml/run.py,sha256=F939J1W6zQjr-JQ1Z8-nKh2s7NQ_0Okov4QJAEyw_5M,15503
 hwpx/oxml/schema.py,sha256=ElR3_IIhhPPZEqJtNKMNCHA-VFVLdhL454W_4spuvlc,1284
-hwpx/oxml/section.py,sha256=i3t1SKIMneA1qWAajDlmZ-yrWJF9VvqT-aoq3mRXtxE,11638
+hwpx/oxml/section.py,sha256=W91Si7-kaUvl2y_VLV5kpsXPGtT5fUwOyIRh6qQLGyM,13395
 hwpx/oxml/section_format.py,sha256=EKqod989mzcaPz-lDKM1Y7atdpFX9x_SdQ8zfCL3BpU,18320
 hwpx/oxml/section_story.py,sha256=zvUV7O4dtogWcM9-zudRAszCHRwfzTBMW2GGI1Q24kg,22410
 hwpx/oxml/simple_parts.py,sha256=dOVKWlUCQV8GePH0WRWPUmRylvH5O8bu0B6jj_4lejk,1864
-hwpx/oxml/table.py,sha256=DhvbAlD9ZX0t2dhsR-XfrGbL3Iw-Xtq8KBJDXWtyxLA,42198
+hwpx/oxml/table.py,sha256=sImxS7SMgfhgvaAVUg-zILeMqlrRY3BD2GmmLtTbREQ,42727
 hwpx/oxml/utils.py,sha256=2L9au3SD_MFkFt2DXx3udXBT5caYuYO623lhGhgldVo,2972
 hwpx/quality/__init__.py,sha256=zvOvfOYh0nlKH5ywpj9ZQHov0sdRIouicv9DamKmHLU,1478
 hwpx/quality/ledger.py,sha256=MvrUxd6LlJPD_dWoD5yH9ceFPNcjBR6tr6STqQqAdk0,3534
@@ -104,10 +104,10 @@ hwpx/tools/toc_fidelity.py,sha256=rvoKH8QJ65WNVrxS0d-i2AtODvBy-4O8NRudfQ244v4,19
 hwpx/tools/validator.py,sha256=U856izL9NcJZOiKDYoCpwOSaFNQ2Un8Jn4pzL20A96Q,7100
 hwpx/tools/_schemas/header.xsd,sha256=mJXuFMuHGT1JnFFaluUpYUglwjMCNlfbFCRVM26eHXE,664
 hwpx/tools/_schemas/section.xsd,sha256=MgvavVHG05RDfUnVPxVU10H4FQOja5ON04_m9Uk_m7E,522
-python_hwpx-5.2.0.dist-info/licenses/LICENSE,sha256=_ubz4wv-BkkT3l3gu-QuH7JGeVjuRYGZoZK95eNsCHU,9688
-python_hwpx-5.2.0.dist-info/licenses/NOTICE,sha256=auRgKYGdrOgWrj4kZfAuXQnqgDnx5myI9TI17IztIzQ,3466
-python_hwpx-5.2.0.dist-info/METADATA,sha256=dTDpJNzdORyUZnVj8fANpARJ74j3QOekvJ9Mu_O5mYc,13162
-python_hwpx-5.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_hwpx-5.2.0.dist-info/entry_points.txt,sha256=JUKRxbly9UaeHV7YzOea23y8IiqSTcrhUlooP3fS_Zc,405
-python_hwpx-5.2.0.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
-python_hwpx-5.2.0.dist-info/RECORD,,
+python_hwpx-5.4.0.dist-info/licenses/LICENSE,sha256=_ubz4wv-BkkT3l3gu-QuH7JGeVjuRYGZoZK95eNsCHU,9688
+python_hwpx-5.4.0.dist-info/licenses/NOTICE,sha256=auRgKYGdrOgWrj4kZfAuXQnqgDnx5myI9TI17IztIzQ,3466
+python_hwpx-5.4.0.dist-info/METADATA,sha256=hd6N3Fnhn5arZdkRj-BfKR4or0Zceejz27w-lyHaQS8,13162
+python_hwpx-5.4.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_hwpx-5.4.0.dist-info/entry_points.txt,sha256=JUKRxbly9UaeHV7YzOea23y8IiqSTcrhUlooP3fS_Zc,405
+python_hwpx-5.4.0.dist-info/top_level.txt,sha256=R1iToqDh80Nf2oQhRjTN0rbN2X6kyDUizIocZjkhuxc,5
+python_hwpx-5.4.0.dist-info/RECORD,,