PyPDFForm 5.2.3__tar.gz → 5.2.5__tar.gz

{pypdfform-5.2.3 → pypdfform-5.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 5.2.3
+Version: 5.2.5
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT

{pypdfform-5.2.3 → pypdfform-5.2.5}/PyPDFForm/__init__.py

@@ -18,7 +18,7 @@ from Python code or from the command line.
 
 import logging
 
-__version__ = "5.2.3"
+__version__ = "5.2.5"
 
 from .lib.annotations import Annotations
 from .lib.assets.blank import BlankPage

pypdfform-5.2.5/PyPDFForm/lib/egress.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+"""
+A module for egress functions.
+
+This module provides functionalities that prepare the final PDF for output (egress),
+ensuring that it is properly formatted and ready for the end-user. This includes
+managing appearance streams (so form fields display correctly after being filled),
+handling the /NeedAppearances flag, and preserving or updating document-level
+properties like metadata, title, and OpenAction scripts. It can also rebuild the
+AcroForm `/Fields` array from the widget annotations present on each page. These
+functions are typically called right before the final PDF byte stream is returned by
+the wrapper module.
+"""
+
+from functools import lru_cache
+from io import BytesIO
+from warnings import catch_warnings, filterwarnings
+
+from pikepdf import Pdf
+from pypdf import PdfReader, PdfWriter
+from pypdf.generic import ArrayObject, DictionaryObject, NameObject, TextStringObject
+
+from .constants import (
+    JS,
+    XFA,
+    AcroForm,
+    Annots,
+    Fields,
+    JavaScript,
+    OpenAction,
+    Parent,
+    Root,
+    S,
+    Title,
+)
+from .template import get_widget_key
+
+
+@lru_cache(maxsize=128)
+def appearance_streams_handler(pdf: bytes, generate_appearance_streams: bool) -> bytes:
+    """
+    Handles appearance streams and the /NeedAppearances flag for a PDF form.
+
+    This function prepares a PDF for output by:
+    1. Removing the XFA dictionary if present, as it can interfere with standard
+       AcroForm processing.
+    2. Setting the /NeedAppearances flag in the AcroForm dictionary, which asks
+       PDF viewers to generate appearance streams for form fields.
+    3. Optionally generating appearance streams explicitly using pikepdf if
+       `generate_appearance_streams` is True.
+
+    The result is cached using lru_cache for performance.
+
+    Args:
+        pdf (bytes): The PDF file content as a bytes stream.
+        generate_appearance_streams (bool): Whether to explicitly generate appearance streams for all form fields.
+
+    Returns:
+        bytes: The modified PDF content as a bytes stream.
+    """
+    reader = PdfReader(BytesIO(pdf))
+    writer = PdfWriter()
+
+    if AcroForm in reader.trailer[Root] and XFA in reader.trailer[Root][AcroForm]:
+        del reader.trailer[Root][AcroForm][XFA]
+
+    writer.append(reader)
+    writer.set_need_appearances_writer()
+
+    with BytesIO() as f:
+        writer.write(f)
+        f.seek(0)
+        result = f.read()
+
+    if generate_appearance_streams:
+        with Pdf.open(BytesIO(result)) as f, catch_warnings():
+            filterwarnings(
+                "ignore", message=".*/AcroForm.*"
+            )  # handled by rebuild_acroform_fields
+
+            f.generate_appearance_streams()
+            with BytesIO() as r:
+                f.save(r, deterministic_id=True)
+                r.seek(0)
+                result = r.read()
+
+    return result
+
+
+def preserve_pdf_properties(
+    pdf: bytes, title: str, script: str, metadata: dict
+) -> bytes:
+    """
+    Preserves and updates PDF properties such as metadata, title, and OpenAction scripts.
+
+    This function allows setting or updating the PDF's title and metadata, and
+    attaching a JavaScript script that executes when the PDF is opened. Metadata
+    is merged into the reader's current metadata when provided; the title and
+    OpenAction JavaScript are written only when non-empty values are supplied.
+
+    Args:
+        pdf (bytes): The PDF file content as a bytes stream.
+        title (str): The title to be set in the PDF metadata.
+        script (str): JavaScript code to be executed when the PDF is opened.
+        metadata (dict): The original metadata to preserve.
+
+    Returns:
+        bytes: The modified PDF content as a bytes stream.
+    """
+    reader = PdfReader(BytesIO(pdf))
+    writer = PdfWriter()
+    writer.append(reader)
+
+    if title or metadata:
+        _metadata = reader.metadata or {}
+        if metadata:
+            _metadata.update(metadata)
+        if title:
+            _metadata[NameObject(Title)] = TextStringObject(title)
+
+        writer.add_metadata(_metadata)
+
+    if script:
+        open_action = DictionaryObject()
+        open_action[NameObject(S)] = NameObject(JavaScript)
+        open_action[NameObject(JS)] = TextStringObject(script)
+
+        writer._root_object.update({NameObject(OpenAction): open_action})  # type: ignore # noqa: SLF001 # # pylint: disable=W0212
+
+    with BytesIO() as f:
+        writer.write(f)
+        f.seek(0)
+        return f.read()
+
+
+def rebuild_acroform_fields(
+    pdf: bytes, widget_keys: set, use_full_widget_name: bool
+) -> bytes:
+    """
+    Rebuilds the AcroForm `/Fields` array from matching page annotations.
+
+    The existing `/Fields` array is replaced, creating an AcroForm dictionary
+    when necessary. Each page annotation is resolved to a widget key, and only
+    annotations whose keys are present in `widget_keys` contribute their
+    top-level field object to the new array. Page annotation arrays are left
+    unchanged. When no matching page annotations are found, the original PDF
+    stream is returned unchanged to avoid an unnecessary rewrite.
+
+    Args:
+        pdf (bytes): The PDF stream whose AcroForm fields should be rebuilt.
+        widget_keys (set): Widget keys to include in the rebuilt `/Fields` array.
+        use_full_widget_name (bool): Whether to resolve annotations using their
+            full widget names, including parent names.
+
+    Returns:
+        bytes: The PDF stream with a rebuilt AcroForm `/Fields` array, or the
+            original stream when there are no matching widgets to rebuild.
+    """
+    if not widget_keys:
+        return pdf
+
+    writer = PdfWriter(BytesIO(pdf))
+    root = writer._root_object  # type: ignore # noqa: SLF001 # # pylint: disable=W0212
+
+    fields = ArrayObject([])
+    seen_fields = set()
+    for page in writer.pages:
+        for annot in page.get(Annots, []):
+            key = get_widget_key(annot.get_object(), use_full_widget_name)
+            if key in widget_keys:
+                field_ref = _get_root_field_reference(writer, annot)
+                field_key = _field_reference_key(field_ref)
+                if field_key not in seen_fields:
+                    fields.append(field_ref)
+                    seen_fields.add(field_key)
+
+    if not seen_fields:
+        return pdf
+
+    if AcroForm not in root:
+        root[NameObject(AcroForm)] = DictionaryObject({})
+    root[AcroForm][NameObject(Fields)] = fields
+
+    with BytesIO() as f:
+        writer.write(f)
+        f.seek(0)
+        return f.read()
+
+
+def _get_root_field_reference(writer: PdfWriter, annot):
+    """
+    Returns the top-level AcroForm field reference for an annotation.
+
+    Widget annotations can be leaf nodes under a parent field dictionary. The
+    catalog `/AcroForm/Fields` array must point at root fields rather than
+    child widgets, otherwise readers such as pypdf will not expose hierarchical
+    fields like radio groups via `get_fields`.
+
+    Args:
+        writer (PdfWriter): The PDF writer that owns the annotation objects.
+        annot: The widget annotation reference or object.
+
+    Returns:
+        IndirectObject: The top-level AcroForm field reference.
+    """
+    field = annot
+    field_object = field.get_object()
+    visited = set()
+
+    while Parent in field_object and id(field_object) not in visited:
+        visited.add(id(field_object))
+        field = field_object[Parent]
+        field_object = field.get_object()
+
+    return _ensure_indirect_reference(writer, field)
+
+
+def _ensure_indirect_reference(writer: PdfWriter, field):
+    """
+    Returns an indirect reference for a field object.
+
+    pypdf expects entries in `/AcroForm/Fields` to have an indirect reference
+    when it builds field objects. Parent fields cloned from page annotations can
+    appear as direct dictionaries that still know their original indirect
+    reference, so prefer that before adding a new indirect object.
+
+    Args:
+        writer (PdfWriter): The PDF writer that will own newly added objects.
+        field: The field reference or direct field object to normalize.
+
+    Returns:
+        IndirectObject: An indirect reference to the field object.
+    """
+    field_object = field.get_object()
+    indirect_reference = getattr(field_object, "indirect_reference", None)
+    if indirect_reference is not None:
+        return indirect_reference
+
+    result = field
+    if not hasattr(field, "idnum"):
+        result = writer._add_object(field_object)  # type: ignore[attr-defined] # noqa: SLF001 # pylint: disable=W0212
+
+    return result
+
+
+def _field_reference_key(field_ref) -> tuple:
+    """
+    Returns a stable key for deduplicating root fields in one writer.
+
+    Args:
+        field_ref: The field reference to identify.
+
+    Returns:
+        tuple: A stable key for the field reference.
+    """
+    field_object = field_ref.get_object()
+    indirect_reference = getattr(field_object, "indirect_reference", field_ref)
+    idnum = getattr(indirect_reference, "idnum", None)
+    generation = getattr(indirect_reference, "generation", None)
+
+    result = (id(field_object),)
+    if idnum is not None:
+        result = idnum, generation
+
+    return result

{pypdfform-5.2.3 → pypdfform-5.2.5}/PyPDFForm/lib/utils.py

@@ -21,7 +21,13 @@ from typing import Any, List
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import ArrayObject, DictionaryObject, NameObject
 
-from .constants import SLASH, UNIQUE_SUFFIX_LENGTH, Annots
+from .constants import (
+    SLASH,
+    UNIQUE_SUFFIX_LENGTH,
+    VERSION_IDENTIFIER_PREFIX,
+    VERSION_IDENTIFIERS,
+    Annots,
+)
 
 
 @lru_cache(maxsize=128)
@@ -329,3 +335,72 @@ def generate_unique_suffix() -> str:
             for _ in range(UNIQUE_SUFFIX_LENGTH)
         ]
     )
+
+
+def get_version(pdf: bytes) -> str | None:
+    """
+    Extracts the PDF header version from a byte stream.
+
+    The stream is checked against the supported PDF header identifiers defined
+    in constants. The function inspects the original bytes directly so callers
+    can capture a document's version before handing it to tools that may rewrite
+    the header during output processing.
+
+    Args:
+        pdf (bytes): The PDF stream to inspect.
+
+    Returns:
+        str | None: The PDF version string, or None when the stream does not
+            start with a known PDF version identifier.
+    """
+
+    version_identifier_length = len(VERSION_IDENTIFIERS[0])
+    version_identifier = pdf[:version_identifier_length]
+    if version_identifier not in VERSION_IDENTIFIERS:
+        return None
+
+    return version_identifier[len(VERSION_IDENTIFIER_PREFIX) :].decode()
+
+
+def set_version(pdf: bytes, old: str | None, new: str | None) -> bytes:
+    """
+    Replaces the first PDF header version marker in a byte stream.
+
+    This helper only changes the literal header marker, such as `%PDF-1.7`; it
+    does not validate or rewrite the document for version-specific feature
+    compatibility. It is used after egress rewrites so output keeps the wrapper's
+    cached version instead of inheriting a writer-selected version.
+
+    Args:
+        pdf (bytes): The PDF stream to update.
+        old (str | None): The currently present PDF version string. When
+            None, the header token after `%PDF-` is replaced if one exists.
+        new (str | None): The PDF version string to write into the header. When
+            None, the PDF stream is returned unchanged.
+
+    Returns:
+        bytes: The PDF stream with the first matching version marker replaced.
+    """
+
+    if new is None or old == new:
+        return pdf
+
+    new_header = VERSION_IDENTIFIER_PREFIX + new.encode()
+
+    if old is None:
+        if not pdf.startswith(VERSION_IDENTIFIER_PREFIX):
+            return pdf
+
+        header_end = len(pdf)
+        for separator in (b"\r", b"\n"):
+            separator_index = pdf.find(separator, len(VERSION_IDENTIFIER_PREFIX))
+            if separator_index != -1:
+                header_end = min(header_end, separator_index)
+
+        return new_header + pdf[header_end:]
+
+    old_header = VERSION_IDENTIFIER_PREFIX + old.encode()
+    if pdf.startswith(old_header):
+        return new_header + pdf[len(old_header) :]
+
+    return pdf.replace(old_header, new_header, 1)

{pypdfform-5.2.3 → pypdfform-5.2.5}/PyPDFForm/lib/wrapper.py

@@ -37,9 +37,12 @@ from .adapter import (
     fp_or_f_obj_or_f_content_to_content,
     fp_or_f_obj_or_stream_to_stream,
 )
-from .constants import VERSION_IDENTIFIER_PREFIX, VERSION_IDENTIFIERS
 from .coordinate import generate_coordinate_grid
-from .egress import appearance_streams_handler, preserve_pdf_properties
+from .egress import (
+    appearance_streams_handler,
+    preserve_pdf_properties,
+    rebuild_acroform_fields,
+)
 from .filler import fill
 from .font import (
     get_all_available_fonts,
@@ -62,8 +65,10 @@ from .types import PdfArray
 from .utils import (
     generate_unique_suffix,
     get_page_streams,
+    get_version,
     merge_pdfs,
     remove_all_widgets,
+    set_version,
 )
 from .watermark import (
     copy_watermark_widgets,
@@ -144,12 +149,14 @@ class PdfWrapper:
         self._stream = fp_or_f_obj_or_stream_to_stream(template)
         self.widgets = {}
         self.title: Optional[str] = None
+
+        self._version = None
         self._metadata = (
             get_metadata(self._read()) if kwargs.get("preserve_metadata") else {}
         )
         self._on_open_javascript = None
         self._available_fonts = {}  # for setting /F1
-        self._available_fonts_loaded = False
+        self._available_fonts_loaded = None  # for lazy loading fonts
         self._font_register_events = []  # for reregister
         self._key_update_tracker = {}  # for update key preserve old key attrs
         self._keys_to_update = []  # for bulk update keys
@@ -221,8 +228,8 @@ class PdfWrapper:
         It rebuilds the widget dictionary and invalidates the lazily loaded font cache.
         """
 
-        stream = self._read()
         self._available_fonts_loaded = False
+        stream = self._read()
         new_widgets = (
             build_widgets(
                 stream,
@@ -363,15 +370,18 @@ class PdfWrapper:
         """
         Returns the PDF version of the underlying PDF document.
 
+        The version is read from the PDF header lazily and cached so egress-only
+        rewrites can restore the wrapper's original version even if an underlying
+        PDF writer emits a different default header.
+
         Returns:
             str | None: The PDF version as a string, or None if the version cannot be determined.
         """
 
-        for each in VERSION_IDENTIFIERS:
-            if self._read().startswith(each):
-                return each.replace(VERSION_IDENTIFIER_PREFIX, b"").decode()
+        if self._version is None:
+            self._version = get_version(self._read())
 
-        return None
+        return self._version
 
     @property
     def fonts(self) -> list:
@@ -452,6 +462,11 @@ class PdfWrapper:
            generating appearance streams.
         3. If `preserve_metadata`, title, or on-open JavaScript are set, it preserves
            or updates the corresponding PDF properties accordingly.
+        4. Rebuilds the AcroForm `/Fields` array from page annotations for
+           widgets known to this wrapper, leaving the stream unchanged when no
+           matching widget annotations are found.
+        5. Restores the wrapper's cached PDF header version after egress
+           processing, since PDF writers may emit their own default version.
         The wrapper's stored stream is not replaced by these final egress-only changes.
 
         Returns:
@@ -464,8 +479,15 @@ class PdfWrapper:
                 result, getattr(self, "generate_appearance_streams")
             )  # cached
 
-        if any(
-            [getattr(self, "preserve_metadata"), self.title, self.on_open_javascript]
+        if (
+            any(
+                [
+                    getattr(self, "preserve_metadata"),
+                    self.title,
+                    self.on_open_javascript,
+                ]
+            )
+            and result
         ):
             result = preserve_pdf_properties(
                 result,
@@ -474,6 +496,12 @@ class PdfWrapper:
                 self._metadata if getattr(self, "preserve_metadata") else None,
             )
 
+        if result:
+            result = rebuild_acroform_fields(
+                result, set(self.widgets.keys()), getattr(self, "use_full_widget_name")
+            )
+            if self.version:
+                result = set_version(result, get_version(result), self.version)
         return result
 
     def _read(self) -> bytes:
@@ -546,9 +574,9 @@ class PdfWrapper:
         """
         Changes the PDF version of the underlying document.
 
-        The method replaces the first PDF header version marker in the current stream.
-        It does not otherwise validate or rewrite the document for version-specific
-        compatibility.
+        The method replaces the first PDF header version marker in the current stream
+        and updates the cached version used by later egress processing. It does not
+        otherwise validate or rewrite the document for version-specific compatibility.
 
         Args:
             version (str): The new PDF version string (e.g., "1.7").
@@ -557,11 +585,11 @@ class PdfWrapper:
             PdfWrapper: The `PdfWrapper` object, allowing for method chaining.
         """
 
-        self._stream = self._read().replace(
-            VERSION_IDENTIFIER_PREFIX + bytes(self.version, "utf-8"),
-            VERSION_IDENTIFIER_PREFIX + bytes(version, "utf-8"),
-            1,
-        )
+        current_stream = self._read()
+        updated_stream = set_version(current_stream, self.version, version)
+        if updated_stream != current_stream:
+            self._stream = updated_stream
+            self._version = version
 
         return self
 

{pypdfform-5.2.3 → pypdfform-5.2.5}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 5.2.3
+Version: 5.2.5
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT

{pypdfform-5.2.3 → pypdfform-5.2.5}/pyproject.toml

@@ -140,6 +140,6 @@ include = ["PyPDFForm*"]
 
 [tool.pytest.ini_options]
 markers = [
-    "posix_only", # mainly because of zlib vs zlib-ng
+    "requires_zlib_over_zlib_ng", # expected PDF streams differ when Python uses zlib-ng
     "cli_test",
 ]

{pypdfform-5.2.3 → pypdfform-5.2.5}/tests/test_bulk_create_fields.py

@@ -10,7 +10,7 @@ from PyPDFForm import BlankPage, Fields, PdfWrapper
 from PyPDFForm.lib.constants import Annots, Subtype, Widget
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_bulk_create_fields_stress_max(pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "bulk_create_fields", "test_bulk_create_fields_stress_max.pdf"
@@ -86,7 +86,7 @@ def test_bulk_create_fields_stress_max(pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_bulk_create_fields_stress_max_mixed(pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples,

{pypdfform-5.2.3 → pypdfform-5.2.5}/tests/test_create_widget.py

@@ -7,7 +7,7 @@ import pytest
 from PyPDFForm import Fields, PdfWrapper
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_checkbox_complex_fill(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_checkbox_complex_fill.pdf"
@@ -42,7 +42,7 @@ def test_create_checkbox_complex_fill(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_checkbox_check_fill(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_checkbox_check_fill.pdf"
@@ -70,7 +70,7 @@ def test_create_checkbox_check_fill(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_checkbox_circle_fill(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_checkbox_circle_fill.pdf"
@@ -98,7 +98,7 @@ def test_create_checkbox_circle_fill(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_checkbox_cross_fill(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_checkbox_cross_fill.pdf"
@@ -126,7 +126,7 @@ def test_create_checkbox_cross_fill(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_text_alpha_bg_color(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_text_alpha_bg_color.pdf"
@@ -154,7 +154,7 @@ def test_create_text_alpha_bg_color(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_text_align_center(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_text_align_center.pdf"
@@ -182,7 +182,7 @@ def test_create_text_align_center(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_text_multiline(template_stream, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_text_align_multiline.pdf"
@@ -210,7 +210,7 @@ def test_create_text_multiline(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_text_complex_filled(
     template_stream, pdf_samples, sample_font_stream, request
 ):
@@ -252,7 +252,7 @@ def test_create_text_complex_filled(
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_text_comb(template_stream, pdf_samples, request):
     expected_path = os.path.join(pdf_samples, "widget", "test_create_text_comb.pdf")
     with open(expected_path, "rb+") as f:
@@ -278,7 +278,7 @@ def test_create_text_comb(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_checkbox_persist_old_widgets_fill(
     template_stream, pdf_samples, request
 ):
@@ -310,7 +310,7 @@ def test_create_checkbox_persist_old_widgets_fill(
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_widget_sejda_fill_flatten_before(sejda_template, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_widget_sejda_fill_flatten_before.pdf"
@@ -344,7 +344,7 @@ def test_create_widget_sejda_fill_flatten_before(sejda_template, pdf_samples, re
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_widget_sejda_fill_flatten_after(sejda_template, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_widget_sejda_fill_flatten_after.pdf"
@@ -422,7 +422,7 @@ def test_fill_cmyk_color(pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_radio_complex(template_stream, pdf_samples, request):
     expected_path = os.path.join(pdf_samples, "widget", "test_create_radio_complex.pdf")
     with open(expected_path, "rb+") as f:
@@ -454,7 +454,7 @@ def test_create_radio_complex(template_stream, pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_required_fields(pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_required_fields.pdf"
@@ -505,7 +505,7 @@ def test_create_required_fields(pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_not_required_fields(pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_not_required_fields.pdf"
@@ -556,7 +556,7 @@ def test_create_not_required_fields(pdf_samples, request):
         assert obj.read() == expected
 
 
-@pytest.mark.posix_only
+@pytest.mark.requires_zlib_over_zlib_ng
 def test_create_fields_with_tooltips(pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "widget", "test_create_fields_with_tooltips.pdf"