PyPDFForm 3.5.3__tar.gz → 3.5.5__tar.gz

{pypdfform-3.5.3 → pypdfform-3.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.5.3
+Version: 3.5.5
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -10,14 +10,14 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cryptography
@@ -49,7 +49,7 @@ Dynamic: license-file
     <a href="https://github.com/chinapandaman/PyPDFForm/actions/workflows/python-package.yml"><img src="https://img.shields.io/badge/coverage-100%25-green"></a>
     <a href="https://github.com/chinapandaman/PyPDFForm/raw/master/LICENSE"><img src="https://img.shields.io/github/license/chinapandaman/pypdfform?label=license&color=orange"></a>
     <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/pypi/pyversions/pypdfform?label=python&color=gold"></a>
-    <a href="https://pepy.tech/projects/pypdfform"><img src="https://static.pepy.tech/badge/pypdfform/month"></a>
+    <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?color=blue"></a>
 </p>
 
 ## Introduction

{pypdfform-3.5.3 → pypdfform-3.5.5}/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.5.3"
+__version__ = "3.5.5"
 
 from .middleware.text import Text  # exposing for setting global font attrs
 from .widgets import Fields

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/adapter.py

@@ -9,7 +9,6 @@ filling operations, where the input PDF template can be provided in different
 forms. The module ensures that the input is properly converted into a byte
 stream before further processing.
 """
-# TODO: For large PDF files, reading the entire file into memory using `_file.read()` in `fp_or_f_obj_or_stream_to_stream` can be inefficient. Consider streaming or chunking if downstream processing allows.
 
 from os.path import isfile
 from typing import Any, BinaryIO, Union

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/coordinate.py

@@ -6,8 +6,6 @@ This module provides functionality to generate coordinate grids on existing PDF
 It allows developers to visualize the coordinate system of each page in a PDF, which can be helpful
 for debugging and precisely positioning elements when filling or drawing on PDF forms.
 """
-# TODO: The `PdfReader` object is initialized twice (lines 42 and implicitly within `create_watermarks_and_draw` if it re-reads the PDF). Consider initializing it once and passing the object or its relevant parts to avoid redundant parsing, especially for large PDFs.
-# TODO: Drawing operations for lines and texts are performed and merged separately. It might be more efficient to combine all drawing operations for a page into a single `create_watermarks_and_draw` call or to merge all watermarks in one final step to reduce PDF processing overhead.
 
 from typing import Tuple
 

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/filler.py

@@ -7,11 +7,6 @@ It includes functions for handling various form field types, such as text fields
 checkboxes, radio buttons, dropdowns, images, and signatures. The module also
 supports flattening the filled form to prevent further modifications.
 """
-# TODO: In `fill` function, `PdfReader(stream_to_io(template))` and `out.append(pdf)` might involve re-parsing or copying the entire PDF. For very large PDFs, consider if `pypdf` offers more efficient ways to modify in-place or stream processing.
-# TODO: The `get_widget_key` function is called repeatedly in a loop. If its internal logic is complex, consider caching its results or optimizing its implementation to avoid redundant computations.
-# TODO: The `signature_image_handler` function involves `get_image_dimensions` and `get_draw_image_resolutions`. If image processing is a bottleneck, consider optimizing these image-related operations, perhaps by using faster image libraries or pre-calculating dimensions if images are reused.
-# TODO: Similar to `coordinate.py`, `get_drawn_stream` involves multiple `create_watermarks_and_draw` and `merge_watermarks_with_pdf` calls. Combining drawing operations or merging watermarks in a single pass could reduce overhead.
-# TODO: The `radio_button_tracker` logic involves iterating through all radio buttons. For forms with many radio buttons, consider optimizing the lookup or update mechanism if performance becomes an issue.
 
 from io import BytesIO
 from typing import Dict, Union, cast

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/font.py

@@ -6,11 +6,6 @@ It includes functions for registering fonts with ReportLab and within the PDF's
 allowing these fonts to be used when filling form fields. The module also provides utilities
 for extracting font information from TTF streams and managing font names within a PDF.
 """
-# TODO: In `get_additional_font_params`, iterating through `reader.pages[0][Resources][Font].values()` can be inefficient for PDFs with many fonts. Consider building a font lookup dictionary once per PDF or caching results if this function is called frequently with the same PDF.
-# TODO: In `register_font_acroform`, `PdfReader(stream_to_io(pdf))` and `writer.append(reader)` involve re-parsing and appending the PDF. For large PDFs, passing `PdfReader` and `PdfWriter` objects directly could reduce overhead.
-# TODO: In `register_font_acroform`, `compress(ttf_stream)` can be CPU-intensive. If the same font stream is registered multiple times within a single PDF processing session, consider caching the compressed stream to avoid redundant compression.
-# TODO: In `get_new_font_name`, while `existing` is a set, if `n` needs to increment many times due to a dense range of existing font names, the `while` loop could be slow. However, this is likely a minor bottleneck in typical scenarios.
-# TODO: In `get_all_available_fonts`, the `replace("/", "")` operation on `BaseFont` could be avoided if font names are consistently handled with or without the leading slash to prevent string manipulation overhead in a loop.
 
 from functools import lru_cache
 from io import BytesIO

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/hooks.py

@@ -8,10 +8,6 @@ of checkbox and radio button widgets. It also provides functions for flattening
 generic and radio button widgets. These hooks are triggered during the PDF form
 filling process, allowing for customization of the form's appearance and behavior.
 """
-# TODO: In `trigger_widget_hooks`, the PDF is read and written in each call. If this function is part of a larger workflow, consider passing `PdfReader` and `PdfWriter` objects to avoid redundant parsing and writing, allowing modifications to be accumulated and written once.
-# TODO: String manipulations (split/join) in `update_text_field_font`, `update_text_field_font_size`, and `update_text_field_font_color` could be optimized for very long `DA` strings, potentially using more efficient string manipulation techniques or regex if the structure is consistent.
-# TODO: The `get_widget_key` function is called in a loop within `trigger_widget_hooks`. If its internal logic is complex, consider caching its results or optimizing its implementation to avoid redundant computations.
-# TODO: In `flatten_radio` and `flatten_generic`, `annot.get(NameObject(Ff), 0)` is called twice within the conditional. Store this value in a local variable to avoid redundant dictionary lookups.
 
 import sys
 from io import BytesIO
@@ -216,9 +212,7 @@ def update_text_field_multiline(annot: DictionaryObject, val: bool) -> None:
         val (bool): True to enable multiline, False to disable.
     """
     if val:
-        # TODO: investigate this more
-        # may need to change everywhere how feature flags precedence work
-        # https://github.com/chinapandaman/PyPDFForm/issues/1162#issuecomment-3326233842
+        # Ff in annot[Parent] only in hooks.py, or when editing instead of retrieving
         if Parent in annot and Ff in annot[Parent]:
             annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
                 int(
@@ -247,7 +241,7 @@ def update_text_field_comb(annot: DictionaryObject, val: bool) -> None:
         val (bool): True to enable comb, False to disable.
     """
     if val:
-        if Parent in annot and Ff not in annot:
+        if Parent in annot and Ff in annot[Parent]:
             annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
                 int(
                     annot[NameObject(Parent)][NameObject(Ff)]
@@ -367,7 +361,7 @@ def flatten_generic(annot: DictionaryObject, val: bool) -> None:
         annot (DictionaryObject): The annotation dictionary.
         val (bool): True to flatten (make read-only), False to unflatten (make editable).
     """
-    if Parent in annot and Ff not in annot:
+    if Parent in annot and (Ff in annot[Parent] or Ff not in annot):
         annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
             (
                 int(annot.get(NameObject(Ff), 0)) | READ_ONLY
@@ -412,20 +406,19 @@ def update_field_required(annot: DictionaryObject, val: bool) -> None:
         annot (DictionaryObject): The annotation dictionary for the form field.
         val (bool): True to set the field as required, False to make it optional.
     """
-    # TODO: add a test case when supporting edit required
-    # if Parent in annot and Ff not in annot:
-    #     annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
-    #         (
-    #             int(annot.get(NameObject(Ff), 0)) | REQUIRED
-    #             if val
-    #             else int(annot.get(NameObject(Ff), 0)) & ~REQUIRED
-    #         )
-    #     )
-    # else:
-    annot[NameObject(Ff)] = NumberObject(
-        (
-            int(annot.get(NameObject(Ff), 0)) | REQUIRED
-            if val
-            else int(annot.get(NameObject(Ff), 0)) & ~REQUIRED
+    if Parent in annot and Ff in annot[Parent]:
+        annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
+            (
+                int(annot.get(NameObject(Ff), 0)) | REQUIRED
+                if val
+                else int(annot.get(NameObject(Ff), 0)) & ~REQUIRED
+            )
+        )
+    else:
+        annot[NameObject(Ff)] = NumberObject(
+            (
+                int(annot.get(NameObject(Ff), 0)) | REQUIRED
+                if val
+                else int(annot.get(NameObject(Ff), 0)) & ~REQUIRED
+            )
         )
-    )

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/image.py

@@ -6,9 +6,6 @@ It includes functions for rotating images, retrieving image dimensions, and
 calculating the resolutions for drawing an image on a PDF page, taking into
 account whether to preserve the aspect ratio.
 """
-# TODO: In `rotate_image` and `get_image_dimensions`, `BytesIO` is used to wrap the image stream. While necessary for PIL, consider if the `image_stream` is already a file-like object in some calling contexts, which could avoid redundant copying to `BytesIO`.
-# TODO: The `rotate_image` function creates a new `BytesIO` object and saves the image to it. For multiple rotations or image manipulations, consider keeping the `PIL.Image.Image` object in memory and performing operations on it directly before a final save to bytes, to avoid repeated I/O operations.
-# TODO: The `get_image_dimensions` function opens the image to get its size. If image dimensions are frequently needed for the same image, consider caching the dimensions to avoid re-opening and re-parsing the image data.
 
 from io import BytesIO
 from typing import Tuple, Union

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/middleware/base.py

@@ -42,8 +42,7 @@ class Widget:
         super().__init__()
         self._name = name
         self._value = value
-        self.desc: str = None
-        self.tooltip: str = None  # TODO: sync tooltip and desc
+        self.tooltip: str = None
         self.readonly: bool = None
         self.required: bool = None
         self.hooks_to_trigger: list = []
@@ -107,8 +106,8 @@ class Widget:
         """
         result = {}
 
-        if self.desc is not None:
-            result["description"] = self.desc
+        if self.tooltip is not None:
+            result["description"] = self.tooltip
 
         return result
 

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/middleware/signature.py

@@ -6,7 +6,6 @@ This module defines the Signature class, which is a subclass of the
 Widget class. It represents a signature form field in a PDF document,
 allowing users to add their signature as an image.
 """
-# TODO: In the `stream` property, `fp_or_f_obj_or_stream_to_stream` is called every time the property is accessed. If the signature image is large or the property is accessed frequently, consider caching the result of `fp_or_f_obj_or_stream_to_stream` to avoid redundant file reads.
 
 from os.path import expanduser
 from typing import Union

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/patterns.py

@@ -7,10 +7,6 @@ checkboxes, radio buttons, dropdowns, images, and signatures) based on their
 properties in the PDF's annotation dictionary. It also provides utility functions
 for updating these widgets.
 """
-# TODO: The `WIDGET_TYPE_PATTERNS` list is iterated through to determine widget types. For very large numbers of annotations or complex pattern matching, consider optimizing this lookup, perhaps by pre-compiling regexes or using a more efficient data structure if the patterns allow.
-# TODO: In `update_checkbox_value` and `update_radio_value`, iterating through `annot[AP][N]` to find the correct appearance state might be slow if `N` contains many entries. If possible, a direct lookup or a more optimized search could improve performance.
-# TODO: In `update_dropdown_value`, the list comprehension for `ArrayObject` can be computationally intensive for dropdowns with many choices, as it creates new `TextStringObject` and `ArrayObject` instances for each choice. Consider optimizing this if dropdowns have a very large number of options.
-# TODO: The `get_checkbox_value` and `get_radio_value` functions involve dictionary lookups and comparisons. While generally fast, repeated calls in a tight loop for many widgets could accumulate overhead.
 
 from typing import Union
 

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/template.py

@@ -7,11 +7,6 @@ in PDF form templates. It leverages the pypdf library for PDF manipulation
 and defines specific patterns for identifying and constructing different
 types of widgets.
 """
-# TODO: In `build_widgets`, the `get_widgets_by_page` function is called, which then iterates through pages and annotations. For very large PDFs, this initial parsing and iteration can be a bottleneck. Consider optimizing the widget extraction process if possible, perhaps by using a more direct method to access annotations if `pypdf` allows.
-# TODO: The `construct_widget` function iterates through `WIDGET_TYPE_PATTERNS` for each widget. If there are many patterns or many widgets, this repeated iteration could be optimized by pre-compiling patterns or using a more efficient lookup mechanism.
-# TODO: In `get_widget_key`, the recursive call for `Parent` can lead to deep recursion for deeply nested widgets, potentially impacting performance or hitting recursion limits for extremely complex forms. Consider an iterative approach if deep nesting is common.
-# TODO: In `update_widget_keys`, the nested loops iterating through `old_keys`, `out.pages`, and `page.get(Annots, [])` can be very inefficient for large numbers of keys, pages, or annotations. Consider creating a lookup structure for annotations by key to avoid repeated linear scans.
-# TODO: In `update_widget_keys`, `PdfReader(stream_to_io(template))` and `out.append(pdf)` involve re-parsing and appending the PDF. For large PDFs, passing `PdfReader` and `PdfWriter` objects directly could reduce overhead.
 
 from functools import lru_cache
 from io import BytesIO
@@ -62,7 +57,7 @@ def build_widgets(
             key = get_widget_key(widget, use_full_widget_name)
             _widget = construct_widget(widget, key)
             if _widget is not None:
-                _widget.desc = extract_widget_property(
+                _widget.__dict__["tooltip"] = extract_widget_property(
                     widget, WIDGET_DESCRIPTION_PATTERNS, None, str
                 )
 

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/utils.py

@@ -12,14 +12,6 @@ It includes functions for:
 - Generating unique suffixes for internal use.
 - Enabling Adobe-specific settings in the PDF to ensure proper rendering of form fields.
 """
-# TODO: In `enable_adobe_mode`, `PdfReader(stream_to_io(pdf))` and `writer.append(reader)` involve re-parsing and appending the PDF. For large PDFs, passing `PdfReader` and `PdfWriter` objects directly could reduce overhead.
-# TODO: In `remove_all_widgets`, `PdfReader(stream_to_io(pdf))` and iterating through pages to add them to a new writer can be inefficient for large PDFs. Consider if `pypdf` offers a more direct way to remove annotations without reconstructing the entire PDF.
-# TODO: In `get_page_streams`, `PdfReader(stream_to_io(pdf))` and then creating a new `PdfWriter` for each page can be very inefficient. It would be more performant to iterate through the pages of a single `PdfReader` and extract their content streams directly if possible, or to use a single `PdfWriter` to extract multiple pages.
-# TODO: In `merge_two_pdfs`, the function reads and writes PDFs multiple times (`PdfReader`, `PdfWriter`, `remove_all_widgets`, then another `PdfReader` and `PdfWriter`). This is highly inefficient. The PDF objects should be passed around and modified in-place as much as possible, with a single final write operation.
-# TODO: The `merge_two_pdfs` function has a `TODO: refactor duplicate logic with copy_watermark_widgets` comment. This indicates a potential for code duplication and inefficiency. Refactoring this to a shared helper function would improve maintainability and potentially performance.
-# TODO: In `find_pattern_match` and `traverse_pattern`, the recursive nature and repeated dictionary lookups (`widget.items()`, `value.get_object()`) can be slow for deeply nested or complex widget structures. Consider optimizing these traversals, perhaps by pre-flattening the widget dictionary or using a more direct access method if `pypdf` allows.
-# TODO: In `extract_widget_property`, the loop iterates through `patterns` and calls `traverse_pattern` for each. If `patterns` is long or `traverse_pattern` is expensive, this could be a bottleneck. Consider optimizing the pattern matching or lookup.
-# TODO: `generate_unique_suffix` uses `choice` in a loop. While generally fast, for extremely high call volumes, pre-generating a pool of characters or using a faster random string generation method might offer minor improvements.
 
 from collections.abc import Callable
 from functools import lru_cache

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/watermark.py

@@ -7,13 +7,6 @@ It supports drawing text, lines, and images as watermarks.
 The module also includes functions to merge these watermarks with the original PDF content
 and to copy specific widgets from the watermarks to the original PDF.
 """
-# TODO: In `draw_image`, `ImageReader(image_buff)` is created for each image. If the same image is drawn multiple times, consider caching `ImageReader` objects or passing pre-processed image data to avoid redundant processing.
-# TODO: In `create_watermarks_and_draw`, `PdfReader(stream_to_io(pdf))` is called, which re-parses the PDF. If this function is called repeatedly for the same PDF, consider passing the `PdfReader` object directly to avoid redundant parsing.
-# TODO: In `create_watermarks_and_draw`, the function returns a list of watermarks where only one element is populated. This can be inefficient for memory if there are many pages but only one watermark is created. Consider returning only the created watermark and its page number, and let the caller handle placement.
-# TODO: In `merge_watermarks_with_pdf`, `PdfReader(stream_to_io(pdf))` and `PdfReader(stream_to_io(watermarks[i]))` are called in a loop. This leads to repeated parsing of the base PDF and each watermark. It would be more efficient to parse the base PDF once and then merge watermark pages directly into the existing `PdfWriter` object.
-# TODO: In `copy_watermark_widgets`, the function reads the PDF and watermarks multiple times. Similar to `merge_watermarks_with_pdf`, optimize by parsing the base PDF and watermarks once and then manipulating the `PdfWriter` object.
-# TODO: The `copy_watermark_widgets` function has a `TODO: refactor duplicate logic with merge_two_pdfs` comment. This indicates a potential for code duplication and inefficiency. Refactoring this to a shared helper function would improve maintainability and potentially performance.
-# TODO: In `copy_watermark_widgets`, the nested loops iterating through `watermarks`, `watermark_file.pages`, and `page.get(Annots, [])` can be very inefficient for large numbers of watermarks, pages, or annotations. Consider creating a lookup structure for annotations by key to avoid repeated linear scans.
 
 from io import BytesIO
 from typing import List, Union

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/widgets/base.py

@@ -12,9 +12,6 @@ Classes:
       functionality for rendering and manipulation.
 """
 
-# TODO: In `watermarks`, `PdfReader(stream_to_io(stream))` is called, which re-parses the PDF for each widget. If multiple widgets are being processed, consider passing the `PdfReader` object directly to avoid redundant parsing.
-# TODO: In `watermarks`, the list comprehension `[watermark.read() if i == self.page_number - 1 else b"" for i in range(page_count)]` creates a new `BytesIO` object and reads from it for each widget. If many widgets are created, this could be optimized by creating the `BytesIO` object once and passing it around, or by directly returning the watermark bytes and its page number.
-
 from dataclasses import dataclass
 from inspect import signature
 from io import BytesIO
@@ -28,35 +25,6 @@ from ..constants import fieldFlags, required
 from ..utils import stream_to_io
 
 
-@dataclass
-class Field:
-    """
-    Base dataclass for all PDF form fields.
-
-    This class defines the common properties that all types of form fields
-    (e.g., text fields, checkboxes, radio buttons) share. Specific field types
-    will extend this class to add their unique attributes.
-
-    Attributes:
-        name (str): The name of the form field. This is used to identify the
-            field within the PDF document.
-        page_number (int): The 1-based page number on which the field is located.
-        x (float): The x-coordinate of the field's position on the page.
-        y (float): The y-coordinate of the field's position on the page.
-        required (Optional[bool]): Indicates whether the field is required to be
-            filled by the user. Defaults to None, meaning not explicitly set.
-        tooltip (Optional[str]): A tooltip message that appears when the user
-            hovers over the field. Defaults to None.
-    """
-
-    name: str
-    page_number: int
-    x: float
-    y: float
-    required: Optional[bool] = None
-    tooltip: Optional[str] = None
-
-
 class Widget:
     """
     Base class for all widgets in PyPDFForm.
@@ -222,3 +190,32 @@ class Widget:
             watermark.read() if i == self.page_number - 1 else b""
             for i in range(page_count)
         ]
+
+
+@dataclass
+class Field:
+    """
+    Base dataclass for all PDF form fields.
+
+    This class defines the common properties that all types of form fields
+    (e.g., text fields, checkboxes, radio buttons) share. Specific field types
+    will extend this class to add their unique attributes.
+
+    Attributes:
+        name (str): The name of the form field. This is used to identify the
+            field within the PDF document.
+        page_number (int): The 1-based page number on which the field is located.
+        x (float): The x-coordinate of the field's position on the page.
+        y (float): The y-coordinate of the field's position on the page.
+        required (Optional[bool]): Indicates whether the field is required to be
+            filled by the user. Defaults to None, meaning not explicitly set.
+        tooltip (Optional[str]): A tooltip message that appears when the user
+            hovers over the field. Defaults to None.
+    """
+
+    name: str
+    page_number: int
+    x: float
+    y: float
+    required: Optional[bool] = None
+    tooltip: Optional[str] = None

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/widgets/radio.py

@@ -10,8 +10,6 @@ The `RadioWidget` class extends the base `CheckBoxWidget` class to provide
 specific functionality for interacting with radio button form fields in PDFs.
 """
 
-# TODO: In `canvas_operations`, `self.acro_form_params.copy()` creates a shallow copy of the dictionary in each iteration of the loop. For a large number of radio buttons, this repeated copying can be inefficient. Consider modifying the dictionary in place and then reverting changes if necessary, or restructuring the data to avoid repeated copying.
-
 from dataclasses import dataclass
 from typing import List, Optional
 
@@ -20,31 +18,6 @@ from reportlab.pdfgen.canvas import Canvas
 from .checkbox import CheckBoxField, CheckBoxWidget
 
 
-@dataclass
-class RadioGroup(CheckBoxField):
-    """
-    Represents a group of radio buttons in a PDF document.
-
-    This dataclass extends the `CheckBoxField` base class and defines the specific
-    attributes that can be configured for a radio button group. Unlike a single
-    checkbox, a radio group allows for multiple positions (x, y coordinates)
-    where individual radio buttons can be placed, but only one can be selected.
-
-    Attributes:
-        _field_type (str): The type of the field, fixed as "radio".
-        x (List[float]): A list of x-coordinates for each radio button in the group.
-        y (List[float]): A list of y-coordinates for each radio button in the group.
-        shape (Optional[str]): The shape of the radio button. Valid values are
-            "circle" or "square". Defaults to None, which typically means a default circle shape.
-    """
-
-    _field_type: str = "radio"
-
-    x: List[float]
-    y: List[float]
-    shape: Optional[str] = None
-
-
 class RadioWidget(CheckBoxWidget):
     """
     Represents a radio button widget in a PDF form.
@@ -99,3 +72,28 @@ class RadioWidget(CheckBoxWidget):
             new_acro_form_params["y"] = y
             new_acro_form_params["value"] = str(i)
             getattr(canvas.acroForm, self.ACRO_FORM_FUNC)(**new_acro_form_params)
+
+
+@dataclass
+class RadioGroup(CheckBoxField):
+    """
+    Represents a group of radio buttons in a PDF document.
+
+    This dataclass extends the `CheckBoxField` base class and defines the specific
+    attributes that can be configured for a radio button group. Unlike a single
+    checkbox, a radio group allows for multiple positions (x, y coordinates)
+    where individual radio buttons can be placed, but only one can be selected.
+
+    Attributes:
+        _field_type (str): The type of the field, fixed as "radio".
+        x (List[float]): A list of x-coordinates for each radio button in the group.
+        y (List[float]): A list of y-coordinates for each radio button in the group.
+        shape (Optional[str]): The shape of the radio button. Valid values are
+            "circle" or "square". Defaults to None, which typically means a default circle shape.
+    """
+
+    _field_type: str = "radio"
+
+    x: List[float]
+    y: List[float]
+    shape: Optional[str] = None

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/widgets/signature.py

@@ -11,10 +11,6 @@ signature form fields in PDFs, including handling their creation, rendering, and
 integration into the document.
 """
 
-# TODO: In `watermarks`, `PdfReader(stream_to_io(BEDROCK_PDF))` is called every time the method is invoked. If `BEDROCK_PDF` is static, consider parsing it once and caching the `PdfReader` object to avoid redundant I/O and parsing.
-# TODO: In `watermarks`, the list comprehension `[f.read() if i == self.page_number - 1 else b"" for i in range(page_count)]` reads the entire `BytesIO` object `f` multiple times if `page_count` is large. Read `f` once into a variable and then use that variable in the list comprehension.
-# TODO: The `input_pdf` is created in `watermarks` but only its page count is used. If the `PdfReader` object is not needed for other operations, consider a lighter way to get the page count or pass the `PdfReader` object from the caller if it's already available.
-
 from dataclasses import dataclass
 from io import BytesIO
 from typing import List, Optional
@@ -30,26 +26,6 @@ from .base import Field
 from .bedrock import BEDROCK_PDF
 
 
-@dataclass
-class SignatureField(Field):
-    """
-    Represents a signature field in a PDF document.
-
-    This dataclass extends the `Field` base class and defines the specific
-    attributes that can be configured for a signature input field.
-
-    Attributes:
-        _field_type (str): The type of the field, fixed as "signature".
-        width (Optional[float]): The width of the signature field.
-        height (Optional[float]): The height of the signature field.
-    """
-
-    _field_type: str = "signature"
-
-    width: Optional[float] = None
-    height: Optional[float] = None
-
-
 class SignatureWidget:
     """
     Represents a signature widget in a PDF form.
@@ -155,3 +131,23 @@ class SignatureWidget:
                 f.read() if i == self.page_number - 1 else b""
                 for i in range(page_count)
             ]
+
+
+@dataclass
+class SignatureField(Field):
+    """
+    Represents a signature field in a PDF document.
+
+    This dataclass extends the `Field` base class and defines the specific
+    attributes that can be configured for a signature input field.
+
+    Attributes:
+        _field_type (str): The type of the field, fixed as "signature".
+        width (Optional[float]): The width of the signature field.
+        height (Optional[float]): The height of the signature field.
+    """
+
+    _field_type: str = "signature"
+
+    width: Optional[float] = None
+    height: Optional[float] = None

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm/wrapper.py

@@ -15,17 +15,6 @@ methods for interacting with its form fields and content. It leverages
 lower-level modules within the `PyPDFForm` library to handle the
 underlying PDF manipulation.
 """
-# TODO: The `__add__` method (merging PDFs) involves multiple `self.read()` and `other.read()` calls, leading to redundant PDF parsing. Consider optimizing by passing `PdfReader` objects directly or by performing a single read and then merging.
-# TODO: In `_init_helper`, `build_widgets` and `get_all_available_fonts` both call `self.read()`, causing the PDF to be parsed multiple times. Optimize by parsing the PDF once and passing the `PdfReader` object to these functions.
-# TODO: The `pages` property's implementation involves `get_page_streams(remove_all_widgets(self.read()))` and `copy_watermark_widgets(each, self.read(), None, i)`. This leads to excessive PDF parsing, widget removal, and copying for each page. Refactor to minimize PDF I/O operations, possibly by working with `pypdf` page objects directly.
-# TODO: The `read` method triggers `trigger_widget_hooks` and `enable_adobe_mode`, both of which can involve PDF parsing and writing. Since `read` is called frequently, this can be a performance bottleneck. Consider a more granular dirty-flag system to only apply changes when necessary, or accumulate changes and apply them in a single PDF write operation.
-# TODO: The `write` method calls `self.read()`, which in turn triggers all pending operations. This can lead to redundant processing if `read()` has already been called or if multiple `write()` calls are made.
-# TODO: In `change_version`, replacing a byte string in the entire PDF stream can be inefficient for very large PDFs. Consider if `pypdf` offers a more direct way to update the PDF version without full stream manipulation.
-# TODO: In `generate_coordinate_grid`, `self.read()` is called multiple times, and then `remove_all_widgets`, `generate_coordinate_grid`, and `copy_watermark_widgets` are called, all of which involve PDF parsing and manipulation. Optimize by minimizing PDF I/O and object re-creation.
-# TODO: In `fill`, `self.read()` is called, and then `fill` (from `filler.py`), `remove_all_widgets`, and `copy_watermark_widgets` are called. This is a major operation and likely a performance hotspot due to repeated PDF processing. Streamline the PDF modification workflow to reduce redundant parsing and writing.
-# TODO: In `create_widget`, `obj.watermarks(self.read())` and `copy_watermark_widgets(self.read(), watermarks, [name], None)` involve reading the PDF multiple times. Optimize by passing the PDF stream or `PdfReader` object more efficiently.
-# TODO: The `commit_widget_key_updates` method calls `update_widget_keys`, which involves re-parsing and writing the PDF. For bulk updates, consider a mechanism to apply all key changes in a single PDF modification operation.
-# TODO: General: Many methods repeatedly call `self.read()`, which re-parses the PDF. Consider maintaining a persistent `pypdf.PdfReader` and `pypdf.PdfWriter` object internally and only writing to a byte stream when explicitly requested (e.g., by the `read()` or `write()` methods) to avoid redundant I/O and parsing overhead.
 
 from __future__ import annotations
 

{pypdfform-3.5.3 → pypdfform-3.5.5}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.5.3
+Version: 3.5.5
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -10,14 +10,14 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cryptography
@@ -49,7 +49,7 @@ Dynamic: license-file
     <a href="https://github.com/chinapandaman/PyPDFForm/actions/workflows/python-package.yml"><img src="https://img.shields.io/badge/coverage-100%25-green"></a>
     <a href="https://github.com/chinapandaman/PyPDFForm/raw/master/LICENSE"><img src="https://img.shields.io/github/license/chinapandaman/pypdfform?label=license&color=orange"></a>
     <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/pypi/pyversions/pypdfform?label=python&color=gold"></a>
-    <a href="https://pepy.tech/projects/pypdfform"><img src="https://static.pepy.tech/badge/pypdfform/month"></a>
+    <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?color=blue"></a>
 </p>
 
 ## Introduction

{pypdfform-3.5.3 → pypdfform-3.5.5}/README.md

@@ -8,7 +8,7 @@
     <a href="https://github.com/chinapandaman/PyPDFForm/actions/workflows/python-package.yml"><img src="https://img.shields.io/badge/coverage-100%25-green"></a>
     <a href="https://github.com/chinapandaman/PyPDFForm/raw/master/LICENSE"><img src="https://img.shields.io/github/license/chinapandaman/pypdfform?label=license&color=orange"></a>
     <a href="https://www.python.org/downloads/"><img src="https://img.shields.io/pypi/pyversions/pypdfform?label=python&color=gold"></a>
-    <a href="https://pepy.tech/projects/pypdfform"><img src="https://static.pepy.tech/badge/pypdfform/month"></a>
+    <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?color=blue"></a>
 </p>
 
 ## Introduction

{pypdfform-3.5.3 → pypdfform-3.5.5}/pyproject.toml

@@ -17,15 +17,15 @@ classifiers = [
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
     "cryptography",
     "fonttools",
@@ -132,3 +132,8 @@ version = {attr = "PyPDFForm.__version__"}
 
 [tool.setuptools.packages.find]
 include = ["PyPDFForm*"]
+
+[tool.pytest.ini_options]
+markers = [
+    "posix_only",
+]

{pypdfform-3.5.3 → pypdfform-3.5.5}/tests/test_adobe_mode.py

@@ -2,6 +2,8 @@
 
 import os
 
+import pytest
+
 from PyPDFForm import Fields, PdfWrapper
 
 
@@ -110,6 +112,7 @@ def test_issue_613(pdf_samples, request):
         assert obj.read() == expected
 
 
+@pytest.mark.posix_only
 def test_sample_template_library(
     pdf_samples, image_samples, sample_font_stream, request
 ):