PyPDFForm 3.5.1__py3-none-any.whl → 4.2.0__py3-none-any.whl

PyPDFForm/widgets/radio.py

@@ -10,41 +10,15 @@ 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
+from typing import List, Optional, Type
 
 from reportlab.pdfgen.canvas import Canvas
 
+from .base import Widget
 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 +73,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:
+        _widget_class (Type[Widget]): The widget class associated with this field type.
+        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.
+    """
+
+    _widget_class: Type[Widget] = RadioWidget
+
+    x: List[float]
+    y: List[float]
+    shape: Optional[str] = None

PyPDFForm/widgets/signature.py

@@ -11,43 +11,23 @@ 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 __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass
 from io import BytesIO
-from typing import List, Optional
+from typing import List, Optional, Type
 
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import (ArrayObject, FloatObject, NameObject,
                            TextStringObject)
+from reportlab.pdfgen.canvas import Canvas
 
+from ..assets.bedrock import BEDROCK_PDF
 from ..constants import Annots, Rect, T
 from ..template import get_widget_key
 from ..utils import stream_to_io
 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:
@@ -106,52 +86,108 @@ class SignatureWidget:
             if each in kwargs:
                 self.hook_params.append((each, kwargs.get(each)))
 
-    def watermarks(self, stream: bytes) -> List[bytes]:
+    @staticmethod
+    def bulk_watermarks(widgets: List[SignatureWidget], stream: bytes) -> List[bytes]:
         """
-        Generates watermarks for the signature widget.
+        Generates watermarks for multiple signature widgets in bulk.
 
-        This method takes a PDF stream as input, reads a "bedrock" PDF, and
-        creates a new PDF with the signature widget added as a watermark on the
-        specified page. The signature's name and rectangle are then added to the
-        new PDF.
+        This static method processes a list of SignatureWidget objects and a PDF stream
+        to create a list of watermark PDF streams, one for each page of the input PDF.
+        Each watermark PDF contains all the signature widgets that belong to that page.
+        This is more efficient than generating watermarks one by one.
 
         Args:
-            stream (bytes): The PDF stream.
+            widgets (List[SignatureWidget]): A list of SignatureWidget objects to be
+                added as watermarks.
+            stream (bytes): The PDF stream of the document to be watermarked.
 
         Returns:
-            List[bytes]: A list of watermarks for the signature widget. Each
-            element in the list represents a page in the PDF. If the current
-            page matches the signature's page number, the corresponding element
-            will contain the watermark data. Otherwise, the element will be an
-            empty byte string.
+            List[bytes]: A list of watermark PDF streams. Each element corresponds to
+            a page in the input PDF.
         """
-        input_pdf = PdfReader(stream_to_io(stream))
-        page_count = len(input_pdf.pages)
-        pdf = PdfReader(stream_to_io(BEDROCK_PDF))
-        out = PdfWriter()
-        out.append(pdf)
+        result = []
 
-        for page in out.pages:
-            for annot in page.get(Annots, []):
-                key = get_widget_key(annot.get_object(), False)
+        page_to_widgets = defaultdict(list)
+        for widget in widgets:
+            page_to_widgets[widget.page_number].append(widget)
 
-                if key != self.BEDROCK_WIDGET_TO_COPY:
-                    continue
+        input_pdf = PdfReader(stream_to_io(stream))
 
-                annot.get_object()[NameObject(T)] = TextStringObject(self.name)
-                annot.get_object()[NameObject(Rect)] = ArrayObject(
+        bedrock = PdfReader(stream_to_io(BEDROCK_PDF))
+        page = bedrock.pages[0]
+        annot_type_to_annot = {}
+        for annot in page.get(Annots, []):  # pylint: disable=E1101
+            key = get_widget_key(annot.get_object(), False)
+            annot_type_to_annot[key] = annot.get_object()
+
+        watermark = BytesIO()
+
+        for i, p in enumerate(input_pdf.pages):
+            # pylint: disable=R0801
+            watermark.seek(0)
+            watermark.flush()
+            canvas = Canvas(
+                watermark,
+                pagesize=(
+                    float(p.mediabox[2]),
+                    float(p.mediabox[3]),
+                ),
+            )
+            canvas.showPage()
+            canvas.save()
+            watermark.seek(0)
+
+            out = PdfWriter(watermark)
+
+            page_widgets = page_to_widgets.get(i + 1, [])
+
+            widgets_to_copy = []
+            for widget in page_widgets:
+                widget_to_copy = annot_type_to_annot[
+                    widget.BEDROCK_WIDGET_TO_COPY
+                ].clone(out, force_duplicate=True)
+
+                widget_to_copy.get_object()[NameObject(T)] = TextStringObject(
+                    widget.name
+                )
+                widget_to_copy.get_object()[NameObject(Rect)] = ArrayObject(
                     [
-                        FloatObject(self.x),
-                        FloatObject(self.y),
-                        FloatObject(self.x + self.optional_params.get("width")),
-                        FloatObject(self.y + self.optional_params.get("height")),
+                        FloatObject(widget.x),
+                        FloatObject(widget.y),
+                        FloatObject(widget.x + widget.optional_params.get("width")),
+                        FloatObject(widget.y + widget.optional_params.get("height")),
                     ]
                 )
 
-        with BytesIO() as f:
-            out.write(f)
-            f.seek(0)
-            return [
-                f.read() if i == self.page_number - 1 else b""
-                for i in range(page_count)
-            ]
+                widgets_to_copy.append(widget_to_copy)
+
+            out.pages[0][NameObject(Annots)] = ArrayObject(  # pylint: disable=E1137
+                widgets_to_copy
+            )
+
+            with BytesIO() as f:
+                out.write(f)
+                f.seek(0)
+                result.append(f.read())
+
+        return result
+
+
+@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:
+        _widget_class (Type[SignatureWidget]): The widget class associated with this field type.
+        width (Optional[float]): The width of the signature field.
+        height (Optional[float]): The height of the signature field.
+    """
+
+    _widget_class: Type[SignatureWidget] = SignatureWidget
+
+    width: Optional[float] = None
+    height: Optional[float] = None

PyPDFForm/widgets/text.py

@@ -11,11 +11,48 @@ functionality for interacting with text form fields in PDFs.
 """
 
 from dataclasses import dataclass
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Type
 
 from .base import Field, Widget
 
 
+class TextWidget(Widget):
+    """
+    Represents a text widget in a PDF form.
+
+    This class inherits from the base Widget class and provides specific
+    parameters for text field styling, such as width, height, font size,
+    font color, background color, border color, border width, and maximum
+    length.
+
+    Attributes:
+        USER_PARAMS (list): A list of tuples, where each tuple contains the
+            user-facing parameter name and the corresponding AcroForm parameter name.
+        COLOR_PARAMS (list): A list of user-facing parameter names that represent colors.
+        ALLOWED_HOOK_PARAMS (list): A list of allowed hook parameters.
+        NONE_DEFAULTS (list): A list of parameters that default to None.
+        ACRO_FORM_FUNC (str): The name of the AcroForm function to use for
+            creating the text field.
+    """
+
+    USER_PARAMS = [
+        ("required", "required"),
+        ("tooltip", "tooltip"),
+        ("width", "width"),
+        ("height", "height"),
+        ("font_size", "fontSize"),
+        ("font_color", "textColor"),
+        ("bg_color", "fillColor"),
+        ("border_color", "borderColor"),
+        ("border_width", "borderWidth"),
+        ("max_length", "maxlen"),
+    ]
+    COLOR_PARAMS = ["font_color", "bg_color", "border_color"]
+    ALLOWED_HOOK_PARAMS = ["alignment", "multiline", "comb", "font"]
+    NONE_DEFAULTS = ["max_length"]
+    ACRO_FORM_FUNC = "textfield"
+
+
 @dataclass
 class TextField(Field):
     """
@@ -25,7 +62,7 @@ class TextField(Field):
     attributes that can be configured for a text input field.
 
     Attributes:
-        _field_type (str): The type of the field, fixed as "text".
+        _widget_class (Type[Widget]): The widget class associated with this field type.
         width (Optional[float]): The width of the text field.
         height (Optional[float]): The height of the text field.
         max_length (Optional[int]): The maximum number of characters allowed in the text field.
@@ -41,7 +78,7 @@ class TextField(Field):
         multiline (Optional[bool]): If True, the text field can display multiple lines of text.
     """
 
-    _field_type: str = "text"
+    _widget_class: Type[Widget] = TextWidget
 
     width: Optional[float] = None
     height: Optional[float] = None
@@ -55,40 +92,3 @@ class TextField(Field):
     border_width: Optional[float] = None
     alignment: Optional[int] = None
     multiline: Optional[bool] = None
-
-
-class TextWidget(Widget):
-    """
-    Represents a text widget in a PDF form.
-
-    This class inherits from the base Widget class and provides specific
-    parameters for text field styling, such as width, height, font size,
-    font color, background color, border color, border width, and maximum
-    length.
-
-    Attributes:
-        USER_PARAMS (list): A list of tuples, where each tuple contains the
-            user-facing parameter name and the corresponding AcroForm parameter name.
-        COLOR_PARAMS (list): A list of user-facing parameter names that represent colors.
-        ALLOWED_HOOK_PARAMS (list): A list of allowed hook parameters.
-        NONE_DEFAULTS (list): A list of parameters that default to None.
-        ACRO_FORM_FUNC (str): The name of the AcroForm function to use for
-            creating the text field.
-    """
-
-    USER_PARAMS = [
-        ("required", "required"),
-        ("tooltip", "tooltip"),
-        ("width", "width"),
-        ("height", "height"),
-        ("font_size", "fontSize"),
-        ("font_color", "textColor"),
-        ("bg_color", "fillColor"),
-        ("border_color", "borderColor"),
-        ("border_width", "borderWidth"),
-        ("max_length", "maxlen"),
-    ]
-    COLOR_PARAMS = ["font_color", "bg_color", "border_color"]
-    ALLOWED_HOOK_PARAMS = ["alignment", "multiline", "comb", "font"]
-    NONE_DEFAULTS = ["max_length"]
-    ACRO_FORM_FUNC = "textfield"