PyPDFForm 4.7.3__tar.gz → 4.7.5__tar.gz

{pypdfform-4.7.3 → pypdfform-4.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 4.7.3
+Version: 4.7.5
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -24,7 +24,7 @@ Requires-Dist: cryptography<47.0.0,>=46.0.3
 Requires-Dist: fonttools<5.0.0,>=4.60.1
 Requires-Dist: pikepdf<11.0.0,>=10.5.0
 Requires-Dist: pillow<13.0.0,>=12.0.0
-Requires-Dist: pypdf<7.0.0,>=6.3.0
+Requires-Dist: pypdf<7.0.0,>=6.9.0
 Requires-Dist: reportlab<5.0.0,>=4.4.6
 Provides-Extra: dev
 Requires-Dist: black<27.0.0,>=25.11.0; extra == "dev"

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/__init__.py

@@ -22,7 +22,7 @@ PyPDFForm aims to simplify PDF form manipulation, making it accessible to develo
 
 import logging
 
-__version__ = "4.7.3"
+__version__ = "4.7.5"
 
 from .annotations import Annotations
 from .assets.blank import BlankPage

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/coordinate.py

@@ -7,6 +7,7 @@ It allows developers to visualize the coordinate system of each page in a PDF, w
 for debugging and precisely positioning elements when filling or drawing on PDF forms.
 """
 
+from io import BytesIO
 from typing import Tuple
 
 from pypdf import PdfReader
@@ -14,7 +15,6 @@ from reportlab.pdfbase.pdfmetrics import stringWidth
 
 from .constants import COORDINATE_GRID_FONT_SIZE_MARGIN_RATIO, DEFAULT_FONT
 from .middleware.text import Text
-from .utils import stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
@@ -39,7 +39,7 @@ def generate_coordinate_grid(
     Returns:
         bytes: The PDF file with the coordinate grid overlay as bytes.
     """
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     lines_by_page = {}
     texts_by_page = {}
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/egress.py

@@ -19,7 +19,6 @@ from pypdf.generic import DictionaryObject, NameObject, TextStringObject
 
 from .constants import (JS, XFA, AcroForm, JavaScript, OpenAction, Root, S,
                         Title)
-from .utils import stream_to_io
 
 
 @lru_cache
@@ -44,7 +43,7 @@ def appearance_streams_handler(pdf: bytes, generate_appearance_streams: bool) ->
     Returns:
         bytes: The modified PDF content as a bytes stream.
     """
-    reader = PdfReader(stream_to_io(pdf))
+    reader = PdfReader(BytesIO(pdf))
     writer = PdfWriter()
 
     if AcroForm in reader.trailer[Root] and XFA in reader.trailer[Root][AcroForm]:
@@ -59,7 +58,7 @@ def appearance_streams_handler(pdf: bytes, generate_appearance_streams: bool) ->
         result = f.read()
 
     if generate_appearance_streams:
-        with Pdf.open(stream_to_io(result)) as f:
+        with Pdf.open(BytesIO(result)) as f:
             f.generate_appearance_streams()
             with BytesIO() as r:
                 f.save(r)
@@ -87,7 +86,7 @@ def preserve_pdf_properties(
     Returns:
         bytes: The modified PDF content as a bytes stream.
     """
-    reader = PdfReader(stream_to_io(pdf))
+    reader = PdfReader(BytesIO(pdf))
     writer = PdfWriter()
     writer.append(reader)
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/filler.py

@@ -27,7 +27,6 @@ from .middleware.text import Text
 from .patterns import (get_widget_key, update_checkbox_value,
                        update_dropdown_value, update_radio_value,
                        update_text_value)
-from .utils import stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
@@ -177,7 +176,7 @@ def fill(
                The image drawn stream is only returned if there are any image or signature widgets
                in the form.
     """
-    pdf = PdfReader(stream_to_io(template))
+    pdf = PdfReader(BytesIO(template))
     out = PdfWriter()
     out.append(pdf)
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/font.py

@@ -7,17 +7,21 @@ allowing these fonts to be used when filling form fields. The module also provid
 for extracting font information from TTF streams and managing font names within a PDF.
 """
 
+from contextlib import contextmanager
 from functools import lru_cache
 from io import BytesIO
+from typing import Generator
+from uuid import uuid4
 from zlib import compress
 
 from fontTools.ttLib import TTFont as FT_TTFont
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import (ArrayObject, DictionaryObject, FloatObject,
                            NameObject, NumberObject, StreamObject)
-from reportlab.pdfbase.pdfmetrics import registerFont
+from reportlab.pdfbase.pdfmetrics import _fonts
 from reportlab.pdfbase.ttfonts import TTFError, TTFont
 
+from .assets.blank import BlankPage
 from .constants import (DEFAULT_ASSUMED_GLYPH_WIDTH, DR, EM_TO_PDF_FACTOR,
                         ENCODING_TABLE_SIZE, FIRST_CHAR_CODE, FONT_NAME_PREFIX,
                         LAST_CHAR_CODE, AcroForm, BaseFont, Encoding, Fields,
@@ -26,26 +30,26 @@ from .constants import (DEFAULT_ASSUMED_GLYPH_WIDTH, DR, EM_TO_PDF_FACTOR,
                         FontName, FontNotdef, LastChar, Length, Length1,
                         MissingWidth, Resources, Subtype, TrueType, Type,
                         Widths, WinAnsiEncoding)
-from .utils import stream_to_io
-from .watermark import get_watermark_with_font
+from .raw.text import RawText
+from .watermark import create_watermarks_and_draw
 
 
 @lru_cache
-def register_font(font_name: str, ttf_stream: bytes) -> bool:
+def validate_font(font_name: str, ttf_stream: bytes) -> bool:
     """
-    Registers a TrueType font with the ReportLab library.
+    Validates a TrueType font stream.
 
-    This allows the font to be used for generating PDF documents with ReportLab.
+    This checks if the provided stream is a valid TrueType font by parsing it
+    with ReportLab's TTFont.
 
     Args:
-        font_name (str): The name to register the font under. This name will be used
-            to reference the font when creating PDF documents with ReportLab.
+        font_name (str): The name of the font.
         ttf_stream (bytes): The font file data in TTF format. This should be the raw
             bytes of the TTF file.
 
     Returns:
-        bool: True if the font was registered successfully, False otherwise.
-            Returns False if a TTFError occurs during registration, which usually
+        bool: True if the font stream is valid, False otherwise.
+            Returns False if a TTFError occurs during parsing, which usually
             indicates an invalid TTF stream.
     """
     buff = BytesIO()
@@ -53,7 +57,7 @@ def register_font(font_name: str, ttf_stream: bytes) -> bool:
     buff.seek(0)
 
     try:
-        registerFont(TTFont(name=font_name, filename=buff))
+        TTFont(name=font_name, filename=buff)
         result = True
     except TTFError:
         result = False
@@ -62,7 +66,7 @@ def register_font(font_name: str, ttf_stream: bytes) -> bool:
     return result
 
 
-def get_additional_font_params(pdf: bytes, base_font_name: str) -> tuple:
+def _get_additional_font_params(pdf: bytes, base_font_name: str) -> tuple:
     """
     Retrieves additional font parameters from a PDF document for a given base font name.
 
@@ -83,7 +87,7 @@ def get_additional_font_params(pdf: bytes, base_font_name: str) -> tuple:
     """
     font_descriptor_params = {}
     font_dict_params = {}
-    reader = PdfReader(stream_to_io(pdf))
+    reader = PdfReader(BytesIO(pdf))
     first_page = reader.get_page(0)
 
     for font in first_page[Resources][Font].values():
@@ -144,8 +148,58 @@ def compute_font_glyph_widths(ttf_file: BytesIO, missing_width: float) -> list[f
     return widths
 
 
+@contextmanager
+def temporary_font_registration(
+    fonts: list[tuple[str, bytes]],
+) -> Generator[dict[str, str], None, None]:
+    """
+    Registers a list of fonts temporarily with unique names, yielding a mapping
+    from the original font names to the unique names.
+
+    Args:
+        fonts (list[tuple[str, bytes]]): A list of tuples, each containing a font name and its TTF stream.
+
+    Yields:
+        dict: A mapping of the original font names to the temporary unique names used by ReportLab.
+    """
+    font_mapping = {}
+    for font_name, ttf_stream in fonts:
+        rl_name = uuid4().hex
+        font_mapping[font_name] = rl_name
+        _fonts[rl_name] = TTFont(rl_name, BytesIO(ttf_stream))
+
+    try:
+        yield font_mapping
+    finally:
+        for rl_name in font_mapping.values():
+            if rl_name in _fonts:
+                del _fonts[rl_name]
+
+
+@lru_cache
+def _get_watermark_with_font(ttf_stream: bytes) -> bytes:
+    """
+    Creates a watermark PDF with a single space character using the specified font.
+
+    This function is primarily used to generate a dummy PDF page that includes
+    a specific font, which can then be merged with another PDF to ensure the
+    font is available or embedded. The result is cached for performance.
+
+    Args:
+        ttf_stream (bytes): The TrueType font stream to use.
+
+    Returns:
+        bytes: The watermark PDF as a byte stream.
+    """
+    with temporary_font_registration([("temp", ttf_stream)]) as font_mapping:
+        return create_watermarks_and_draw(
+            BlankPage().read(),
+            [RawText(" ", 1, 0, 0, font=font_mapping["temp"]).to_draw],
+        )[0]
+
+
 def register_font_acroform(
-    pdf: bytes, font_name: str, ttf_stream: bytes, need_appearances: bool
+    pdf: bytes, ttf_stream: bytes, need_appearances: bool
 ) -> tuple:
     """
     Registers a TrueType font within the PDF's AcroForm dictionary.
@@ -157,7 +211,6 @@ def register_font_acroform(
     Args:
         pdf (bytes): The PDF file data as bytes. This is the PDF document that
             will be modified to include the new font.
-        font_name (str): The name of the font being registered.
         ttf_stream (bytes): The font file data in TTF format as bytes. This is the
             raw data of the TrueType font file.
         need_appearances (bool): If True, attempts to retrieve existing font parameters
@@ -168,16 +221,16 @@ def register_font_acroform(
         tuple: A tuple containing the modified PDF data as bytes and the new font name
             (str) that was assigned to the registered font within the PDF.
     """
-    base_font_name = get_base_font_name(ttf_stream)
-    reader = PdfReader(stream_to_io(pdf))
+    base_font_name = _get_base_font_name(ttf_stream)
+    reader = PdfReader(BytesIO(pdf))
     writer = PdfWriter()
     writer.append(reader)
 
     font_descriptor_params = {}
     font_dict_params = {}
     if need_appearances:
-        font_descriptor_params, font_dict_params = get_additional_font_params(
-            get_watermark_with_font(font_name), base_font_name
+        font_descriptor_params, font_dict_params = _get_additional_font_params(
+            _get_watermark_with_font(ttf_stream), base_font_name
         )
 
     font_file_stream = StreamObject()
@@ -245,7 +298,7 @@ def register_font_acroform(
         dr[NameObject(Font)] = DictionaryObject()
     fonts = dr[Font]
 
-    new_font_name = get_new_font_name(fonts)
+    new_font_name = _get_new_font_name(fonts)
     fonts[NameObject(new_font_name)] = font_dict_ref
 
     with BytesIO() as f:
@@ -255,7 +308,7 @@ def register_font_acroform(
 
 
 @lru_cache
-def get_base_font_name(ttf_stream: bytes) -> str:
+def _get_base_font_name(ttf_stream: bytes) -> str:
     """
     Extracts the base font name from a TrueType font stream.
 
@@ -269,12 +322,10 @@ def get_base_font_name(ttf_stream: bytes) -> str:
     Returns:
         str: The base font name, prefixed with a forward slash.
     """
-    return (
-        f"/{TTFont(name='new_font', filename=stream_to_io(ttf_stream)).face.name.ustr}"
-    )
+    return f"/{TTFont(name='new_font', filename=BytesIO(ttf_stream)).face.name.ustr}"
 
 
-def get_new_font_name(fonts: dict) -> str:
+def _get_new_font_name(fonts: dict) -> str:
     """
     Generates a new unique font name to avoid conflicts with existing fonts in the PDF.
 
@@ -314,7 +365,7 @@ def get_all_available_fonts(pdf: bytes) -> dict:
             (without the leading slash) and the values are the corresponding font
             identifiers in the PDF. Returns an empty dictionary if no fonts are found.
     """
-    reader = PdfReader(stream_to_io(pdf))
+    reader = PdfReader(BytesIO(pdf))
     try:
         fonts = reader.root_object[AcroForm][DR][Font]
     except KeyError:

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/hooks.py

@@ -24,7 +24,6 @@ from .constants import (AA, COMB, DA, FONT_COLOR_IDENTIFIER,
                         JavaScript, MaxLen, Opt, Parent, Q, Rect, S, Type, U,
                         X)
 from .patterns import get_widget_key
-from .utils import stream_to_io
 
 
 def trigger_widget_hooks(
@@ -52,7 +51,7 @@ def trigger_widget_hooks(
     Returns:
         bytes: The modified PDF data as bytes, with the widget hooks applied.
     """
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     output = PdfWriter()
     output.append(pdf_file)
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/template.py

@@ -28,7 +28,7 @@ from .patterns import (WIDGET_DESCRIPTION_PATTERNS, WIDGET_TYPE_PATTERNS,
                        get_field_hidden, get_field_rect, get_radio_value,
                        get_text_field_alignment, get_text_field_max_length,
                        get_text_value, get_widget_key, update_annotation_name)
-from .utils import extract_widget_property, find_pattern_match, stream_to_io
+from .utils import extract_widget_property, find_pattern_match
 
 
 @lru_cache
@@ -45,7 +45,7 @@ def get_metadata(pdf: bytes) -> dict:
     if not pdf:
         return {}
 
-    reader = PdfReader(stream_to_io(pdf))
+    reader = PdfReader(BytesIO(pdf))
     return reader.metadata or {}
 
 
@@ -218,7 +218,7 @@ def get_widgets_by_page(pdf: bytes) -> Dict[int, List[dict]]:
         Dict[int, List[dict]]: A dictionary where keys are page numbers (1-indexed)
             and values are lists of widget dictionaries.
     """
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
 
     result = {}
 
@@ -335,7 +335,7 @@ def create_annotations(
     Returns:
         bytes: The updated PDF stream with the added annotations.
     """
-    writer = PdfWriter(stream_to_io(template))
+    writer = PdfWriter(BytesIO(template))
     annotations_by_page = _group_annotations_by_page(annotations)
 
     for i, page in enumerate(writer.pages):
@@ -382,7 +382,7 @@ def update_widget_keys(
     Returns:
         bytes: The updated PDF template as a byte stream.
     """
-    pdf = PdfReader(stream_to_io(template))
+    pdf = PdfReader(BytesIO(template))
     out = PdfWriter()
     out.append(pdf)
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/utils.py

@@ -18,7 +18,7 @@ from functools import lru_cache
 from io import BytesIO
 from secrets import choice
 from string import ascii_letters, digits, punctuation
-from typing import Any, BinaryIO, List
+from typing import Any, List
 
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import ArrayObject, DictionaryObject, NameObject
@@ -26,28 +26,6 @@ from pypdf.generic import ArrayObject, DictionaryObject, NameObject
 from .constants import SLASH, UNIQUE_SUFFIX_LENGTH, Annots
 
 
-def stream_to_io(stream: bytes) -> BinaryIO:
-    """
-    Converts a bytes stream to a BinaryIO object, which can be used by PyPDFForm.
-
-    This function takes a bytes stream as input and returns a BinaryIO object
-    that represents the same data. This is useful because PyPDFForm often
-    works with BinaryIO objects, so this function allows you to easily convert
-    a bytes stream to the correct format.
-
-    Args:
-        stream (bytes): The bytes stream to convert.
-
-    Returns:
-        BinaryIO: A BinaryIO object representing the stream.
-    """
-    result = BytesIO()
-    result.write(stream)
-    result.seek(0)
-
-    return result
-
-
 @lru_cache
 def remove_all_widgets(pdf: bytes) -> bytes:
     """
@@ -63,7 +41,7 @@ def remove_all_widgets(pdf: bytes) -> bytes:
     Returns:
         bytes: The PDF with all widgets removed, as a bytes stream.
     """
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     result_stream = BytesIO()
     writer = PdfWriter()
     for page in pdf_file.pages:
@@ -89,7 +67,7 @@ def get_page_streams(pdf: bytes) -> List[bytes]:
     Returns:
         List[bytes]: A list of bytes streams, one for each page.
     """
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     result = []
 
     for page in pdf_file.pages:
@@ -167,8 +145,8 @@ def merge_two_pdfs(pdf: bytes, other: bytes) -> bytes:
         bytes: The merged PDF file as a byte stream.
     """
     output = PdfWriter()
-    pdf_file = PdfReader(stream_to_io(pdf))
-    other_file = PdfReader(stream_to_io(other))
+    pdf_file = PdfReader(BytesIO(pdf))
+    other_file = PdfReader(BytesIO(other))
     result = BytesIO()
 
     for page in pdf_file.pages:
@@ -179,7 +157,7 @@ def merge_two_pdfs(pdf: bytes, other: bytes) -> bytes:
     output.write(result)
     result.seek(0)
 
-    merged_no_widgets = PdfReader(stream_to_io(remove_all_widgets(result.read())))
+    merged_no_widgets = PdfReader(BytesIO(remove_all_widgets(result.read())))
     output = PdfWriter()
     output.append(merged_no_widgets)
 

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/watermark.py

@@ -9,7 +9,6 @@ and to copy specific widgets from the watermarks to the original PDF.
 """
 
 from collections import defaultdict
-from functools import lru_cache
 from io import BytesIO
 from typing import Any, Dict, List, Optional
 
@@ -18,11 +17,8 @@ from pypdf.generic import ArrayObject, NameObject
 from reportlab.lib.utils import ImageReader
 from reportlab.pdfgen.canvas import Canvas
 
-from .assets.blank import BlankPage
 from .constants import Annots
 from .patterns import get_widget_key
-from .raw.text import RawText
-from .utils import stream_to_io
 
 
 def draw_text(canvas: Canvas, **kwargs) -> None:
@@ -43,9 +39,10 @@ def draw_text(canvas: Canvas, **kwargs) -> None:
     widget = kwargs["widget"]
     coordinate_x = kwargs["x"]
     coordinate_y = kwargs["y"]
+    font_mapping = kwargs.get("font_mapping", {})
 
     text_to_draw = widget.value
-    canvas.setFont(widget.font, widget.font_size)
+    canvas.setFont(font_mapping.get(widget.font, widget.font), widget.font_size)
     canvas.setFillColorRGB(
         widget.font_color[0], widget.font_color[1], widget.font_color[2]
     )
@@ -225,7 +222,9 @@ def draw_image(canvas: Canvas, **kwargs) -> None:
     image_buff.close()
 
 
-def create_watermarks_and_draw(pdf: bytes, to_draw: List[dict]) -> List[bytes]:
+def create_watermarks_and_draw(
+    pdf: bytes, to_draw: List[dict], font_mapping: Optional[Dict[str, str]] = None
+) -> List[bytes]:
     """
     Creates a watermark PDF for each page of the input PDF based on the drawing instructions.
 
@@ -238,6 +237,8 @@ def create_watermarks_and_draw(pdf: bytes, to_draw: List[dict]) -> List[bytes]:
         to_draw (List[dict]): A list of drawing instructions, where each dictionary
             must contain a "page_number" key (1-based) and a "type" key ("image", "text", or "line")
             along with type-specific parameters.
+        font_mapping (Optional[Dict[str, str]]): A dictionary mapping original font names
+            to temporary unique font names used by ReportLab.
 
     Returns:
         List[bytes]: A list of watermark PDF byte streams. An empty byte string (b"")
@@ -258,7 +259,7 @@ def create_watermarks_and_draw(pdf: bytes, to_draw: List[dict]) -> List[bytes]:
     for each in to_draw:
         page_to_to_draw[each["page_number"]].append(each)
 
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     buff = BytesIO()
 
     for i, page in enumerate(pdf_file.pages):
@@ -279,7 +280,9 @@ def create_watermarks_and_draw(pdf: bytes, to_draw: List[dict]) -> List[bytes]:
         )
 
         for element in elements:
-            type_to_func[element["type"]](canvas, **element)
+            type_to_func[element["type"]](
+                canvas, **element, font_mapping=font_mapping or {}
+            )
 
         canvas.save()
         buff.seek(0)
@@ -306,13 +309,13 @@ def merge_watermarks_with_pdf(
         bytes: A byte stream representing the merged PDF with watermarks applied.
     """
     result = BytesIO()
-    pdf_file = PdfReader(stream_to_io(pdf))
+    pdf_file = PdfReader(BytesIO(pdf))
     output = PdfWriter()
     output.append(pdf_file)
 
     for i, page in enumerate(output.pages):
         if watermarks[i]:
-            watermark = PdfReader(stream_to_io(watermarks[i]))
+            watermark = PdfReader(BytesIO(watermarks[i]))
             if watermark.pages:
                 page.merge_page(watermark.pages[0])
 
@@ -321,26 +324,6 @@ def merge_watermarks_with_pdf(
     return result.read()
 
 
-@lru_cache
-def get_watermark_with_font(font_name: str) -> bytes:
-    """
-    Creates a watermark PDF with a single space character using the specified font.
-
-    This function is primarily used to generate a dummy PDF page that includes
-    a specific font, which can then be merged with another PDF to ensure the
-    font is available or embedded. The result is cached for performance.
-
-    Args:
-        font_name (str): The name of the font to use.
-
-    Returns:
-        bytes: The watermark PDF as a byte stream.
-    """
-    return create_watermarks_and_draw(
-        BlankPage().read(), [RawText(" ", 1, 0, 0, font=font_name).to_draw]
-    )[0]
-
-
 def _clone_page_widgets(
     writer: PdfWriter,
     page: PageObject,
@@ -384,7 +367,7 @@ def _collect_from_single_watermark_specific_page(
         Dict[int, List[Any]]: A dictionary mapping the first output page (index 0) to cloned widgets.
     """
     widgets_to_copy = defaultdict(list)
-    watermark_reader = PdfReader(stream_to_io(watermark))
+    watermark_reader = PdfReader(BytesIO(watermark))
     if page_num < len(watermark_reader.pages):
         widgets_to_copy[0] = _clone_page_widgets(
             writer, watermark_reader.pages[page_num], keys
@@ -409,7 +392,7 @@ def _collect_from_single_watermark_1_to_1(
         Dict[int, List[Any]]: A dictionary mapping output page indices to cloned widgets.
     """
     widgets_to_copy = defaultdict(list)
-    watermark_reader = PdfReader(stream_to_io(watermark))
+    watermark_reader = PdfReader(BytesIO(watermark))
     for i, page in enumerate(watermark_reader.pages):
         widgets_to_copy[i] = _clone_page_widgets(writer, page, keys)
     return widgets_to_copy
@@ -437,7 +420,7 @@ def _collect_from_multiple_watermarks(
     for i, watermark_stream in enumerate(watermarks):
         if not watermark_stream:
             continue
-        watermark_reader = PdfReader(stream_to_io(watermark_stream))
+        watermark_reader = PdfReader(BytesIO(watermark_stream))
         for j, page in enumerate(watermark_reader.pages):
             if page_num is None or j == page_num:
                 widgets_to_copy[i].extend(_clone_page_widgets(writer, page, keys))
@@ -525,7 +508,7 @@ def copy_watermark_widgets(
         bytes: The modified PDF byte stream with copied widgets.
     """
     pdf_writer = PdfWriter()
-    pdf_writer.append(PdfReader(stream_to_io(pdf)))
+    pdf_writer.append(PdfReader(BytesIO(pdf)))
 
     widgets_to_copy = _collect_widgets_to_copy(pdf_writer, watermarks, keys, page_num)
     _apply_widgets_to_pages(pdf_writer, widgets_to_copy)

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/widgets/base.py

@@ -24,7 +24,6 @@ from reportlab.lib.colors import Color
 from reportlab.pdfgen.canvas import Canvas
 
 from ..constants import fieldFlags, required
-from ..utils import stream_to_io
 
 
 class Widget:
@@ -177,7 +176,7 @@ class Widget:
         """
         result = []
 
-        pdf = PdfReader(stream_to_io(stream))
+        pdf = PdfReader(BytesIO(stream))
         watermark = BytesIO()
 
         widgets_by_page = {}

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/widgets/signature.py

@@ -26,7 +26,6 @@ from reportlab.pdfgen.canvas import Canvas
 from ..assets.bedrock import BEDROCK_PDF
 from ..constants import Annots, Rect, T
 from ..patterns import get_widget_key
-from ..utils import stream_to_io
 from .base import Field
 
 
@@ -34,10 +33,11 @@ class SignatureWidget:
     """
     Represents a signature widget in a PDF form.
 
-    This class is responsible for handling the creation, rendering, and
-    integration of signature fields in a PDF document. It inherits from
-    the base Widget class and provides specific functionality for handling
-    signatures.
+    This class is responsible for handling the creation and integration of
+    signature fields in a PDF document. Unlike other widget types, it does not
+    inherit from the base Widget class — instead of using ReportLab's AcroForm
+    API, it copies a pre-built signature annotation from a bedrock PDF and
+    places it at the specified coordinates.
 
     Attributes:
         OPTIONAL_PARAMS (list): A list of tuples, where each tuple contains the
@@ -111,9 +111,9 @@ class SignatureWidget:
         for widget in widgets:
             page_to_widgets[widget.page_number].append(widget)
 
-        input_pdf = PdfReader(stream_to_io(stream))
+        input_pdf = PdfReader(BytesIO(stream))
 
-        bedrock = PdfReader(stream_to_io(BEDROCK_PDF))
+        bedrock = PdfReader(BytesIO(BEDROCK_PDF))
         page = bedrock.pages[0]
         annot_type_to_annot = {}
         for annot in page.get(Annots, []):  # pylint: disable=E1101

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm/wrapper.py

@@ -31,8 +31,8 @@ from .constants import VERSION_IDENTIFIER_PREFIX, VERSION_IDENTIFIERS
 from .coordinate import generate_coordinate_grid
 from .egress import appearance_streams_handler, preserve_pdf_properties
 from .filler import fill
-from .font import (get_all_available_fonts, register_font,
-                   register_font_acroform)
+from .font import (get_all_available_fonts, register_font_acroform,
+                   temporary_font_registration, validate_font)
 from .hooks import trigger_widget_hooks
 from .middleware.dropdown import Dropdown
 from .middleware.signature import Signature
@@ -765,9 +765,10 @@ class PdfWrapper:
             PdfWrapper: The `PdfWrapper` object, allowing for method chaining.
         """
 
-        watermarks = create_watermarks_and_draw(
-            self._read(), [each.to_draw for each in elements]
-        )
+        with temporary_font_registration(self._font_register_events) as font_mapping:
+            watermarks = create_watermarks_and_draw(
+                self._read(), [each.to_draw for each in elements], font_mapping
+            )
 
         stream_with_widgets = self._read()
         self._stream = merge_watermarks_with_pdf(self._read(), watermarks)
@@ -801,9 +802,9 @@ class PdfWrapper:
 
         ttf_file = fp_or_f_obj_or_stream_to_stream(ttf_file)
 
-        if register_font(font_name, ttf_file) if ttf_file is not None else False:
+        if validate_font(font_name, ttf_file) if ttf_file is not None else False:
             self._stream, new_font_name = register_font_acroform(
-                self._read(), font_name, 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-4.7.3 → pypdfform-4.7.5}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 4.7.3
+Version: 4.7.5
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -24,7 +24,7 @@ Requires-Dist: cryptography<47.0.0,>=46.0.3
 Requires-Dist: fonttools<5.0.0,>=4.60.1
 Requires-Dist: pikepdf<11.0.0,>=10.5.0
 Requires-Dist: pillow<13.0.0,>=12.0.0
-Requires-Dist: pypdf<7.0.0,>=6.3.0
+Requires-Dist: pypdf<7.0.0,>=6.9.0
 Requires-Dist: reportlab<5.0.0,>=4.4.6
 Provides-Extra: dev
 Requires-Dist: black<27.0.0,>=25.11.0; extra == "dev"

{pypdfform-4.7.3 → pypdfform-4.7.5}/PyPDFForm.egg-info/requires.txt

@@ -2,7 +2,7 @@ cryptography<47.0.0,>=46.0.3
 fonttools<5.0.0,>=4.60.1
 pikepdf<11.0.0,>=10.5.0
 pillow<13.0.0,>=12.0.0
-pypdf<7.0.0,>=6.3.0
+pypdf<7.0.0,>=6.9.0
 reportlab<5.0.0,>=4.4.6
 
 [dev]

{pypdfform-4.7.3 → pypdfform-4.7.5}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "fonttools>=4.60.1,<5.0.0",
     "pikepdf>=10.5.0,<11.0.0",
     "pillow>=12.0.0,<13.0.0",
-    "pypdf>=6.3.0,<7.0.0",
+    "pypdf>=6.9.0,<7.0.0",
     "reportlab>=4.4.6,<5.0.0",
 ]
 
@@ -136,5 +136,5 @@ include = ["PyPDFForm*"]
 
 [tool.pytest.ini_options]
 markers = [
-    "posix_only",
+    "posix_only", # mainly because of zlib vs zlib-ng
 ]