PyPDFForm 3.7.2__tar.gz → 3.7.4__tar.gz

{pypdfform-3.7.2 → pypdfform-3.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.7.2
+Version: 3.7.4
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -79,7 +79,7 @@ A sample PDF form can be found [here](https://chinapandaman.github.io/PyPDFForm/
 ```python
 from PyPDFForm import PdfWrapper
 
-filled = PdfWrapper("sample_template.pdf", generate_appearance_streams=True).fill(
+filled = PdfWrapper("sample_template.pdf", need_appearances=True).fill(
     {
         "test": "test_1",
         "check": True,

{pypdfform-3.7.2 → pypdfform-3.7.4}/PyPDFForm/__init__.py

@@ -20,7 +20,7 @@ The library supports various PDF form features, including:
 PyPDFForm aims to simplify PDF form manipulation, making it accessible to developers of all skill levels.
 """
 
-__version__ = "3.7.2"
+__version__ = "3.7.4"
 
 from .middleware.text import Text  # exposing for setting global font attrs
 from .widgets import Fields

pypdfform-3.7.4/PyPDFForm/ap.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""
+A module for handling PDF appearance streams.
+
+This module provides functionality to manage appearance streams in PDF forms,
+which are necessary for form fields to display correctly after being filled.
+It uses both pypdf and pikepdf for manipulation.
+"""
+
+from functools import lru_cache
+from io import BytesIO
+
+from pikepdf import Pdf
+from pypdf import PdfReader, PdfWriter
+
+from .constants import XFA, AcroForm, Root
+from .utils import stream_to_io
+
+
+@lru_cache
+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 form filling 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 instructs
+       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(stream_to_io(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(stream_to_io(result)) as f:
+            f.generate_appearance_streams()
+            with BytesIO() as r:
+                f.save(r)
+                r.seek(0)
+                result = r.read()
+
+    return result

{pypdfform-3.7.2 → pypdfform-3.7.4}/PyPDFForm/constants.py

@@ -92,10 +92,6 @@ FontCmap = "cmap"
 FontHmtx = "hmtx"
 FontNotdef = ".notdef"
 
-# AP stream
-BBox = "/BBox"
-Td = b"Td"
-
 FIRST_CHAR_CODE = 0
 LAST_CHAR_CODE = 255
 ENCODING_TABLE_SIZE = 256

{pypdfform-3.7.2 → pypdfform-3.7.4}/PyPDFForm/wrapper.py

@@ -24,7 +24,7 @@ from functools import cached_property
 from typing import TYPE_CHECKING, BinaryIO, Dict, List, Sequence, Tuple, Union
 
 from .adapter import fp_or_f_obj_or_stream_to_stream
-from .ap import appearance_streams_handler, appearance_streams_post_processing
+from .ap import appearance_streams_handler
 from .constants import (DEFAULT_FONT, DEFAULT_FONT_COLOR, DEFAULT_FONT_SIZE,
                         VERSION_IDENTIFIER_PREFIX, VERSION_IDENTIFIERS)
 from .coordinate import generate_coordinate_grid
@@ -141,10 +141,10 @@ class PdfWrapper:
             PdfWrapper: A new `PdfWrapper` object containing the merged PDFs.
         """
 
-        if not self._read():
+        if not self.read():
             return other
 
-        if not other._read():
+        if not other.read():
             return self
 
         unique_suffix = generate_unique_suffix()
@@ -156,7 +156,7 @@ class PdfWrapper:
 
         # user params are based on the first object
         result = self.__class__(
-            merge_two_pdfs(self._read(), other._read()),
+            merge_two_pdfs(self.read(), other.read()),
             **{each[0]: getattr(self, each[0], each[1]) for each in self.USER_PARAMS},
         )
 
@@ -177,10 +177,10 @@ class PdfWrapper:
 
         new_widgets = (
             build_widgets(
-                self._read(),
+                self.read(),
                 getattr(self, "use_full_widget_name"),
             )
-            if self._read()
+            if self.read()
             else {}
         )
         # ensure old widgets don't get overwritten
@@ -200,8 +200,8 @@ class PdfWrapper:
 
         self.widgets = new_widgets
 
-        if self._read():
-            self._available_fonts.update(**get_all_available_fonts(self._read()))
+        if self.read():
+            self._available_fonts.update(**get_all_available_fonts(self.read()))
 
     def _reregister_font(self) -> PdfWrapper:
         """
@@ -279,7 +279,7 @@ class PdfWrapper:
         """
 
         for each in VERSION_IDENTIFIERS:
-            if self._read().startswith(each):
+            if self.read().startswith(each):
                 return each.replace(VERSION_IDENTIFIER_PREFIX, b"").decode()
 
         return None
@@ -308,10 +308,10 @@ class PdfWrapper:
 
         result = [
             self.__class__(
-                copy_watermark_widgets(each, self._read(), None, i),
+                copy_watermark_widgets(each, self.read(), None, i),
                 **{param: getattr(self, param) for param, _ in self.USER_PARAMS},
             )
-            for i, each in enumerate(get_page_streams(remove_all_widgets(self._read())))
+            for i, each in enumerate(get_page_streams(remove_all_widgets(self.read())))
         ]
 
         # because copy_watermark_widgets and remove_all_widgets
@@ -324,41 +324,15 @@ class PdfWrapper:
 
     def read(self) -> bytes:
         """
-        Returns the current PDF content as a byte string.
+        Reads the PDF content from the underlying stream.
 
-        This method retrieves the PDF content, ensuring all necessary pre-read
-        operations (like widget hook execution and setting /NeedAppearances) are
-        complete. If appearance streams were explicitly generated (via
-        `generate_appearance_streams=True`), it performs post-processing, such as
-        correcting text alignment, before returning the final PDF data.
+        This method returns the current state of the PDF as a byte string.
+        It also triggers any pending widget hooks and applies necessary PDF settings
+        like setting the `NeedAppearances` flag or generating appearance streams
+        if configured.
 
         Returns:
-            bytes: The byte string representation of the PDF document.
-        """
-
-        result = self._read()
-
-        if getattr(self, "generate_appearance_streams") and result:
-            result = appearance_streams_post_processing(
-                result,
-                self.widgets,
-                getattr(self, "use_full_widget_name"),
-                self._available_fonts,
-            )
-
-        return result
-
-    def _read(self) -> bytes:
-        """
-        Internal method to retrieve the raw PDF content stream.
-
-        This method applies necessary pre-read modifications to the PDF stream,
-        such as triggering widget hooks for dynamic content and ensuring
-        appearance stream handling (setting the NeedAppearances flag) is
-        performed if configured.
-
-        Returns:
-            bytes: The raw byte string of the PDF document stream.
+            bytes: The PDF content as bytes.
         """
 
         if any(widget.hooks_to_trigger for widget in self.widgets.values()):
@@ -378,7 +352,6 @@ class PdfWrapper:
                 getattr(self, "use_full_widget_name"),
             )
 
-        # TODO: move to public .read()
         if getattr(self, "need_appearances") and self._stream:
             self._stream = appearance_streams_handler(
                 self._stream, getattr(self, "generate_appearance_streams")
@@ -413,7 +386,7 @@ class PdfWrapper:
             PdfWrapper: The `PdfWrapper` object, allowing for method chaining.
         """
 
-        self._stream = self._read().replace(
+        self._stream = self.read().replace(
             VERSION_IDENTIFIER_PREFIX + bytes(self.version, "utf-8"),
             VERSION_IDENTIFIER_PREFIX + bytes(version, "utf-8"),
             1,
@@ -435,10 +408,10 @@ class PdfWrapper:
             PdfWrapper: The `PdfWrapper` object, allowing for method chaining.
         """
 
-        stream_with_widgets = self._read()
+        stream_with_widgets = self.read()
         self._stream = copy_watermark_widgets(
             generate_coordinate_grid(
-                remove_all_widgets(self._read()),
+                remove_all_widgets(self.read()),
                 color,
                 margin,
             ),
@@ -474,7 +447,7 @@ class PdfWrapper:
                 self.widgets[key].value = value
 
         filled_stream, image_drawn_stream = fill(
-            self._read(),
+            self.read(),
             self.widgets,
             need_appearances=getattr(self, "need_appearances"),
             use_full_widget_name=getattr(self, "use_full_widget_name"),
@@ -581,9 +554,9 @@ class PdfWrapper:
                 )
             )
 
-        watermarks = getattr(widget_class, "bulk_watermarks")(widgets, self._read())
+        watermarks = getattr(widget_class, "bulk_watermarks")(widgets, self.read())
         self._stream = copy_watermark_widgets(
-            self._read(),
+            self.read(),
             watermarks,
             [widget.name for widget in widgets],
             None,
@@ -688,9 +661,9 @@ class PdfWrapper:
             return self
 
         obj = _class(name=name, page_number=page_number, x=x, y=y, **kwargs)
-        watermarks = obj.watermarks(self._read())
+        watermarks = obj.watermarks(self.read())
 
-        self._stream = copy_watermark_widgets(self._read(), watermarks, [name], None)
+        self._stream = copy_watermark_widgets(self.read(), watermarks, [name], None)
         hook_params = obj.hook_params
 
         self._init_helper()
@@ -729,7 +702,7 @@ class PdfWrapper:
 
         self._key_update_tracker[new_key] = old_key
         self._stream = update_widget_keys(
-            self._read(), self.widgets, [old_key], [new_key], [index]
+            self.read(), self.widgets, [old_key], [new_key], [index]
         )
         self._init_helper()
 
@@ -754,7 +727,7 @@ class PdfWrapper:
         indices = [each[2] for each in self._keys_to_update]
 
         self._stream = update_widget_keys(
-            self._read(), self.widgets, old_keys, new_keys, indices
+            self.read(), self.widgets, old_keys, new_keys, indices
         )
 
         for each in self._keys_to_update:
@@ -796,7 +769,7 @@ class PdfWrapper:
         new_widget.font_color = kwargs.get("font_color", DEFAULT_FONT_COLOR)
 
         watermarks = create_watermarks_and_draw(
-            self._read(),
+            self.read(),
             page_number,
             "text",
             [
@@ -808,10 +781,10 @@ class PdfWrapper:
             ],
         )
 
-        stream_with_widgets = self._read()
-        self._stream = merge_watermarks_with_pdf(self._read(), watermarks)
+        stream_with_widgets = self.read()
+        self._stream = merge_watermarks_with_pdf(self.read(), watermarks)
         self._stream = copy_watermark_widgets(
-            remove_all_widgets(self._read()), stream_with_widgets, None, None
+            remove_all_widgets(self.read()), stream_with_widgets, None, None
         )
         # because copy_watermark_widgets and remove_all_widgets
         self._reregister_font()
@@ -850,16 +823,16 @@ class PdfWrapper:
         image = fp_or_f_obj_or_stream_to_stream(image)
         image = rotate_image(image, rotation)
         watermarks = create_watermarks_and_draw(
-            self._read(),
+            self.read(),
             page_number,
             "image",
             [{"stream": image, "x": x, "y": y, "width": width, "height": height}],
         )
 
-        stream_with_widgets = self._read()
-        self._stream = merge_watermarks_with_pdf(self._read(), watermarks)
+        stream_with_widgets = self.read()
+        self._stream = merge_watermarks_with_pdf(self.read(), watermarks)
         self._stream = copy_watermark_widgets(
-            remove_all_widgets(self._read()), stream_with_widgets, None, None
+            remove_all_widgets(self.read()), stream_with_widgets, None, None
         )
         # because copy_watermark_widgets and remove_all_widgets
         self._reregister_font()
@@ -894,7 +867,7 @@ class PdfWrapper:
             if first_time and getattr(self, "need_appearances"):
                 self.draw_text(" ", 1, 0, 0, font=font_name)
             self._stream, new_font_name = register_font_acroform(
-                self._read(), ttf_file, getattr(self, "need_appearances")
+                self.read(), ttf_file, getattr(self, "need_appearances")
             )
             self._available_fonts[font_name] = new_font_name
             self._font_register_events.append((font_name, ttf_file))

{pypdfform-3.7.2 → pypdfform-3.7.4}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.7.2
+Version: 3.7.4
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -79,7 +79,7 @@ A sample PDF form can be found [here](https://chinapandaman.github.io/PyPDFForm/
 ```python
 from PyPDFForm import PdfWrapper
 
-filled = PdfWrapper("sample_template.pdf", generate_appearance_streams=True).fill(
+filled = PdfWrapper("sample_template.pdf", need_appearances=True).fill(
     {
         "test": "test_1",
         "check": True,

{pypdfform-3.7.2 → pypdfform-3.7.4}/README.md

@@ -37,7 +37,7 @@ A sample PDF form can be found [here](https://chinapandaman.github.io/PyPDFForm/
 ```python
 from PyPDFForm import PdfWrapper
 
-filled = PdfWrapper("sample_template.pdf", generate_appearance_streams=True).fill(
+filled = PdfWrapper("sample_template.pdf", need_appearances=True).fill(
     {
         "test": "test_1",
         "check": True,

{pypdfform-3.7.2 → pypdfform-3.7.4}/tests/test_generate_appearance_streams.py

@@ -121,40 +121,6 @@ def test_issue_613(pdf_samples, request):
         request.config.results["skip_regenerate"] = len(obj.read()) == len(expected)
 
 
-@pytest.mark.posix_only
-def test_default_font_reportlab_text_alignment(pdf_samples, request):
-    expected_path = os.path.join(
-        pdf_samples,
-        "generate_appearance_streams",
-        "test_default_font_reportlab_text_alignment.pdf",
-    )
-    with open(expected_path, "rb+") as f:
-        obj = (
-            PdfWrapper(
-                os.path.join(pdf_samples, "dummy.pdf"),
-                generate_appearance_streams=True,
-            )
-            .create_field(
-                Fields.TextField(
-                    "new_text_field_widget",
-                    1,
-                    100,
-                    100,
-                    alignment=1,
-                )
-            )
-            .fill({"new_text_field_widget": "foo"})
-        )
-
-        request.config.results["expected_path"] = expected_path
-        request.config.results["stream"] = obj.read()
-
-        expected = f.read()
-
-        assert len(obj.read()) == len(expected)
-        request.config.results["skip_regenerate"] = len(obj.read()) == len(expected)
-
-
 @pytest.mark.posix_only
 def test_sample_template_library(
     pdf_samples, image_samples, sample_font_stream, request
@@ -239,7 +205,9 @@ def test_sample_template_library(
 
         obj.widgets["new_text_field_widget"].font = "new_font"
         obj.widgets["new_text_field_widget"].font_color = (1, 0, 0)
-        obj.widgets["new_text_field_widget"].alignment = 2
+        obj.widgets["new_text_field_widget"].alignment = (
+            2  # TODO: why is alignment not rendered right in the appearance stream?
+        )
         obj.widgets["new_checkbox_widget"].size = 40
         obj.widgets["new_radio_group"].size = 50
 

pypdfform-3.7.2/PyPDFForm/ap.py

@@ -1,182 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Contains functions for handling and post-processing PDF appearance streams (AP).
-
-This module is responsible for:
-1. Preparing a PDF form by removing XFA data and setting the /NeedAppearances flag.
-2. Optionally generating appearance streams explicitly using pikepdf.
-3. Post-processing appearance streams, specifically adjusting text alignment for
-   ReportLab-generated text fields.
-"""
-
-from contextlib import suppress
-from functools import lru_cache
-from io import BytesIO
-
-from pikepdf import Pdf
-from pypdf import PdfReader, PdfWriter
-from pypdf.generic import DictionaryObject
-from reportlab.pdfbase.pdfmetrics import getFont
-
-from .constants import (AP, DEFAULT_FONT, FONT_SIZE_IDENTIFIER, XFA, AcroForm,
-                        Annots, BBox, N, Root, Td)
-from .middleware.text import Text
-from .template import get_widget_key
-from .utils import stream_to_io
-
-
-@lru_cache
-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 form filling 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 instructs
-       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(stream_to_io(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(stream_to_io(result)) as f:
-            f.generate_appearance_streams()
-            with BytesIO() as r:
-                f.save(r)
-                r.seek(0)
-                result = r.read()
-
-    return result
-
-
-def appearance_streams_post_processing(
-    pdf: bytes, widgets: dict, use_full_widget_name: bool, available_fonts: dict
-) -> bytes:
-    """
-    Performs post-processing on appearance streams, primarily for text field alignment.
-
-    This function is called after appearance streams have been generated (either by
-    the PDF viewer or explicitly by pikepdf). It iterates through all annotations
-    (form fields) and applies necessary adjustments, such as correcting text
-    alignment for ReportLab-generated appearance streams.
-
-    Args:
-        pdf (bytes): The PDF file content as a bytes stream.
-        widgets (dict): A dictionary of `PyPDFForm` widget objects keyed by field name.
-        use_full_widget_name (bool): Whether full widget names are used.
-        available_fonts (dict): A dictionary of available fonts for calculating text width.
-
-    Returns:
-        bytes: The modified PDF content as a bytes stream, or the original stream
-               if no updates were necessary.
-    """
-    reader = PdfReader(stream_to_io(pdf))
-    writer = PdfWriter()
-    writer.append(reader)
-
-    needs_update = False
-    for page in writer.pages:
-        for annot in page.get(Annots, []):
-            key = get_widget_key(annot, use_full_widget_name)
-            widget = widgets[key]
-
-            with suppress(Exception):
-                needs_update = (
-                    needs_update
-                    or ap_processing_reportlab_text_field_alignment(
-                        annot, widget, available_fonts
-                    )
-                )
-
-    if not needs_update:
-        return pdf
-
-    with BytesIO() as f:
-        writer.write(f)
-        f.seek(0)
-        return f.read()
-
-
-def ap_processing_reportlab_text_field_alignment(
-    annot: DictionaryObject, widget: Text, available_fonts: dict
-) -> bool:
-    """
-    Adjusts the text alignment coordinates for text fields whose appearance streams
-    were generated by ReportLab.
-
-    ReportLab's appearance stream generation may not correctly handle alignment
-    (center or right alignment). This function calculates the necessary coordinate
-    shift based on the text width and updates the appearance stream's text
-    positioning operator (Td).
-
-    Args:
-        annot (DictionaryObject): The pypdf annotation dictionary object for the field.
-        widget (Text): The `PyPDFForm` Text widget object containing alignment and value.
-        available_fonts (dict): A dictionary of available fonts for calculating text width.
-
-    Returns:
-        bool: True if the appearance stream was modified, False otherwise.
-    """
-    if (not widget.alignment) or (not widget.value):
-        return False
-
-    ap_stream = annot[AP][N].get_data()
-    bbox = annot[AP][N][BBox]
-
-    # calculate width
-    font_size = float(
-        ap_stream.split(bytes(" " + FONT_SIZE_IDENTIFIER, encoding="utf-8"))[0].split(
-            b" "
-        )[-1]
-    )
-    if widget.font:
-        width = None
-        for k, v in available_fonts.items():
-            if v == widget.font:
-                width = getFont(k).stringWidth(widget.value, font_size)
-                break
-    else:
-        width = getFont(DEFAULT_FONT).stringWidth(widget.value, font_size)
-
-    # new alignment coordinate stream
-    alignment_coord = b" ".join(
-        ap_stream.split(b" " + Td)[0].split(b" ")[-2:] + [Td]
-    ).split(b"\n")[1]
-    new_x_coord = (
-        bbox[2] - bbox[1] - width - float(alignment_coord.split(b" ")[0])
-        if widget.alignment == 2
-        else (bbox[2] - bbox[1] - width) / 2
-    )
-    new_alignment_coord = b" ".join(
-        [
-            bytes(str(new_x_coord), encoding="utf-8"),
-        ]
-        + alignment_coord.split(b" ")[1:]
-    )
-
-    annot[AP][N].set_data(ap_stream.replace(alignment_coord, new_alignment_coord))
-
-    return True