PyPDFForm 1.5.6__tar.gz → 2.0.0__tar.gz

{pypdfform-1.5.6 → pypdfform-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 1.5.6
+Version: 2.0.0
 Summary: The Python library for PDF forms.
 Home-page: https://github.com/chinapandaman/PyPDFForm
 Author: Jinge Li
@@ -29,6 +29,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -43,6 +44,15 @@ Dynamic: summary
     <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?logo=pypi&logoColor=white&label=downloads&labelColor=black&color=blue&style=for-the-badge"></a>
 </p>
 
+## Important Announcements
+
+Hello fellow Python developers! With the release of v2.0.0, there are some important changes I'm making to the library:
+
+* Since I started developing the library, versioning releases has been quite unorthodox, and there isn't any convention I followed. Starting with v2.0.0, PyPDFForm will version releases following the conventions defined by [Semantic Versioning](https://semver.org/).
+* PyPDFForm now renders PDF form widgets! Ever since its ancestral stage, the library has only been able to render the data you filled into a PDF form. Now if you fill a PDF form using `PdfWrapper`, the result will render the whole widget instead of just the value that got filled. If you would like to disable this behavior, please refer to the docs [here](https://chinapandaman.github.io/PyPDFForm/fill/#disable-rendering-widgets).
+
+Happy hacking!
+
 ## Introduction
 
 PyPDFForm is a free and open source pure-Python 3 library for PDF form processing. It contains the essential 

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Contains any object users might need."""
 
-__version__ = "1.5.6"
+__version__ = "2.0.0"
 
 from .wrapper import FormWrapper, PdfWrapper
 

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/constants.py

@@ -50,6 +50,13 @@ Ch = "/Ch"
 Opt = "/Opt"
 MK = "/MK"
 CA = "/CA"
+BC = "/BC"
+BG = "/BG"
+BS = "/BS"
+W = "/W"
+S = "/S"
+D = "/D"
+U = "/U"
 AS = "/AS"
 Yes = "/Yes"
 Off = "/Off"
@@ -66,6 +73,7 @@ COMB = 1 << 24
 
 FONT_SIZE_IDENTIFIER = "Tf"
 FONT_COLOR_IDENTIFIER = " rg"
+DEFAULT_BORDER_WIDTH = 1
 DEFAULT_FONT = "Helvetica"
 DEFAULT_FONT_SIZE = 12
 DEFAULT_FONT_COLOR = (0, 0, 0)

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/coordinate.py

@@ -10,21 +10,58 @@ from reportlab.pdfbase.pdfmetrics import stringWidth
 from .constants import (COORDINATE_GRID_FONT_SIZE_MARGIN_RATIO, DEFAULT_FONT,
                         Rect)
 from .middleware.text import Text
-from .template import (get_char_rect_width, get_widget_alignment,
-                       is_text_multiline)
-from .utils import stream_to_io
+from .patterns import WIDGET_ALIGNMENT_PATTERNS
+from .template import get_char_rect_width, is_text_multiline
+from .utils import extract_widget_property, handle_color, stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
+def get_draw_border_coordinates(widget: dict, shape: str) -> List[float]:
+    """Returns coordinates to draw each widget's border."""
+
+    result = [
+        float(widget[Rect][0]),
+        float(widget[Rect][1]),
+        abs(float(widget[Rect][0]) - float(widget[Rect][2])),
+        abs(float(widget[Rect][1]) - float(widget[Rect][3])),
+    ]
+
+    if shape == "ellipse":
+        width = abs(float(widget[Rect][0]) - float(widget[Rect][2]))
+        height = abs(float(widget[Rect][1]) - float(widget[Rect][3]))
+
+        width_mid = (float(widget[Rect][0]) + float(widget[Rect][2])) / 2
+        height_mid = (float(widget[Rect][1]) + float(widget[Rect][3])) / 2
+
+        less = min(width, height)
+
+        result = [
+            width_mid - less / 2,
+            height_mid - less / 2,
+            width_mid + less / 2,
+            height_mid + less / 2,
+        ]
+    elif shape == "line":
+        result = [
+            float(widget[Rect][0]),
+            float(widget[Rect][1]),
+            float(widget[Rect][2]),
+            float(widget[Rect][1]),
+        ]
+
+    return result
+
+
 def get_draw_checkbox_radio_coordinates(
     widget: dict,
     widget_middleware: Text,
+    border_width: int,
 ) -> Tuple[Union[float, int], Union[float, int]]:
     """Returns coordinates to draw at given a PDF form checkbox/radio widget."""
 
-    string_height = widget_middleware.font_size * 96 / 72
+    string_height = widget_middleware.font_size * 72 / 96
     width_mid_point = (float(widget[Rect][0]) + float(widget[Rect][2])) / 2
-    height_mid_point = (float(widget[Rect][1]) + float(widget[Rect][3])) / 2
+    half_widget_height = abs(float(widget[Rect][1]) - float(widget[Rect][3])) / 2
 
     return (
         width_mid_point
@@ -34,7 +71,9 @@ def get_draw_checkbox_radio_coordinates(
             widget_middleware.font_size,
         )
         / 2,
-        (height_mid_point - string_height / 2 + height_mid_point) / 2,
+        float(widget[Rect][1])
+        + (half_widget_height - string_height / 2)
+        + border_width / 2,
     )
 
 
@@ -96,7 +135,9 @@ def get_draw_text_coordinates(
         else widget_middleware.character_paddings
     )
 
-    alignment = get_widget_alignment(widget) or 0
+    alignment = (
+        extract_widget_property(widget, WIDGET_ALIGNMENT_PATTERNS, None, int) or 0
+    )
     x = float(widget[Rect][0])
 
     if int(alignment) != 0:
@@ -196,12 +237,16 @@ def generate_coordinate_grid(
 
         current = margin
         while current < width:
-            lines_by_page[i + 1].append([current, 0, current, height, r, g, b])
+            lines_by_page[i + 1].append(
+                [current, 0, current, height, handle_color([r, g, b]), None, 1, None]
+            )
             current += margin
 
         current = margin
         while current < height:
-            lines_by_page[i + 1].append([0, current, width, current, r, g, b])
+            lines_by_page[i + 1].append(
+                [0, current, width, current, handle_color([r, g, b]), None, 1, None]
+            )
             current += margin
 
         x = margin

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/filler.py

@@ -7,8 +7,10 @@ from typing import Dict, Tuple, Union, cast
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import BooleanObject, DictionaryObject, NameObject
 
-from .constants import WIDGET_TYPES, AcroForm, Annots, NeedAppearances, Root
-from .coordinate import (get_draw_checkbox_radio_coordinates,
+from .constants import (BUTTON_STYLES, DEFAULT_RADIO_STYLE, WIDGET_TYPES,
+                        AcroForm, Annots, NeedAppearances, Root, U)
+from .coordinate import (get_draw_border_coordinates,
+                         get_draw_checkbox_radio_coordinates,
                          get_draw_image_coordinates_resolutions,
                          get_draw_text_coordinates,
                          get_text_line_x_coordinates)
@@ -20,12 +22,13 @@ from .middleware.image import Image
 from .middleware.radio import Radio
 from .middleware.signature import Signature
 from .middleware.text import Text
-from .patterns import (simple_flatten_generic, simple_flatten_radio,
-                       simple_update_checkbox_value,
+from .patterns import (WIDGET_KEY_PATTERNS, simple_flatten_generic,
+                       simple_flatten_radio, simple_update_checkbox_value,
                        simple_update_dropdown_value, simple_update_radio_value,
                        simple_update_text_value)
-from .template import get_widget_key, get_widgets_by_page
-from .utils import checkbox_radio_to_draw, stream_to_io
+from .template import get_widgets_by_page
+from .utils import (checkbox_radio_to_draw, extract_widget_property,
+                    stream_to_io)
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
@@ -38,7 +41,9 @@ def check_radio_handler(
         checkbox_radio_font_size(widget) if middleware.size is None else middleware.size
     )
     to_draw = checkbox_radio_to_draw(middleware, font_size)
-    x, y = get_draw_checkbox_radio_coordinates(widget, to_draw)
+    x, y = get_draw_checkbox_radio_coordinates(
+        widget, to_draw, border_width=middleware.border_width
+    )
     text_needs_to_be_drawn = False
     if type(middleware) is Checkbox and middleware.value:
         text_needs_to_be_drawn = True
@@ -91,6 +96,45 @@ def text_handler(
     return to_draw, x, y, text_needs_to_be_drawn
 
 
+def border_handler(
+    widget: dict,
+    middleware: WIDGET_TYPES,
+    rect_borders_to_draw: list,
+    ellipse_borders_to_draw: list,
+    line_borders_to_draw: list,
+) -> None:
+    """Handles draw parameters for each widget's border."""
+
+    if (
+        isinstance(middleware, Radio)
+        and BUTTON_STYLES.get(middleware.button_style) == DEFAULT_RADIO_STYLE
+    ):
+        list_to_append = ellipse_borders_to_draw
+        shape = "ellipse"
+    elif middleware.border_style == U:
+        list_to_append = line_borders_to_draw
+        shape = "line"
+    else:
+        list_to_append = rect_borders_to_draw
+        shape = "rect"
+
+    list_to_append.append(
+        get_draw_border_coordinates(widget, shape)
+        + [
+            middleware.border_color,
+            middleware.background_color,
+            middleware.border_width,
+            middleware.dash_array,
+        ]
+    )
+
+    if shape == "line":
+        rect_borders_to_draw.append(
+            get_draw_border_coordinates(widget, "rect")
+            + [None, middleware.background_color, 0, None]
+        )
+
+
 def get_drawn_stream(to_draw: dict, stream: bytes, action: str) -> bytes:
     """Generates a stream of an input PDF stream with stuff drawn on it."""
 
@@ -113,6 +157,9 @@ def fill(
 
     texts_to_draw = {}
     images_to_draw = {}
+    rect_borders_to_draw = {}
+    ellipse_borders_to_draw = {}
+    line_borders_to_draw = {}
     any_image_to_draw = False
 
     radio_button_tracker = {}
@@ -120,11 +167,23 @@ def fill(
     for page, widget_dicts in get_widgets_by_page(template_stream).items():
         texts_to_draw[page] = []
         images_to_draw[page] = []
+        rect_borders_to_draw[page] = []
+        ellipse_borders_to_draw[page] = []
+        line_borders_to_draw[page] = []
         for widget_dict in widget_dicts:
-            key = get_widget_key(widget_dict)
+            key = extract_widget_property(widget_dict, WIDGET_KEY_PATTERNS, None, str)
             text_needs_to_be_drawn = False
             to_draw = x = y = None
 
+            if widgets[key].render_widget:
+                border_handler(
+                    widget_dict,
+                    widgets[key],
+                    rect_borders_to_draw[page],
+                    ellipse_borders_to_draw[page],
+                    line_borders_to_draw[page],
+                )
+
             if isinstance(widgets[key], (Checkbox, Radio)):
                 to_draw, x, y, text_needs_to_be_drawn = check_radio_handler(
                     widget_dict, widgets[key], radio_button_tracker
@@ -154,7 +213,11 @@ def fill(
                     ]
                 )
 
-    result = get_drawn_stream(texts_to_draw, template_stream, "text")
+    result = template_stream
+    result = get_drawn_stream(rect_borders_to_draw, result, "rect")
+    result = get_drawn_stream(ellipse_borders_to_draw, result, "ellipse")
+    result = get_drawn_stream(line_borders_to_draw, result, "line")
+    result = get_drawn_stream(texts_to_draw, result, "text")
 
     if any_image_to_draw:
         result = get_drawn_stream(images_to_draw, result, "image")
@@ -189,7 +252,9 @@ def simple_fill(
     for page in out.pages:
         for annot in page.get(Annots, []):  # noqa
             annot = cast(DictionaryObject, annot.get_object())
-            key = get_widget_key(annot.get_object())
+            key = extract_widget_property(
+                annot.get_object(), WIDGET_KEY_PATTERNS, None, str
+            )
 
             widget = widgets.get(key)
             if widget is None or widget.value is None:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/font.py

@@ -16,7 +16,7 @@ from .constants import (DEFAULT_FONT, FONT_COLOR_IDENTIFIER,
                         MARGIN_BETWEEN_LINES, Rect)
 from .middleware.text import Text
 from .patterns import TEXT_FIELD_APPEARANCE_PATTERNS
-from .utils import traverse_pattern
+from .utils import extract_widget_property
 
 
 def register_font(font_name: str, ttf_stream: bytes) -> bool:
@@ -72,19 +72,14 @@ def extract_font_from_text_appearance(text_appearance: str) -> Union[str, None]:
 def auto_detect_font(widget: dict) -> str:
     """Returns the font of the text field if it is one of the standard fonts."""
 
-    result = DEFAULT_FONT
-
-    text_appearance = None
-    for pattern in TEXT_FIELD_APPEARANCE_PATTERNS:
-        text_appearance = traverse_pattern(pattern, widget)
-
-        if text_appearance:
-            break
+    text_appearance = extract_widget_property(
+        widget, TEXT_FIELD_APPEARANCE_PATTERNS, None, None
+    )
 
     if not text_appearance:
-        return result
+        return DEFAULT_FONT
 
-    return extract_font_from_text_appearance(text_appearance) or result
+    return extract_font_from_text_appearance(text_appearance) or DEFAULT_FONT
 
 
 def text_field_font_size(widget: dict) -> Union[float, int]:
@@ -115,13 +110,14 @@ def get_text_field_font_size(widget: dict) -> Union[float, int]:
     """Returns the font size of the text field if presented or zero."""
 
     result = 0
-    for pattern in TEXT_FIELD_APPEARANCE_PATTERNS:
-        text_appearance = traverse_pattern(pattern, widget)
-        if text_appearance:
-            properties = text_appearance.split(" ")
-            for i, val in enumerate(properties):
-                if val.startswith(FONT_SIZE_IDENTIFIER):
-                    return float(properties[i - 1])
+    text_appearance = extract_widget_property(
+        widget, TEXT_FIELD_APPEARANCE_PATTERNS, None, None
+    )
+    if text_appearance:
+        properties = text_appearance.split(" ")
+        for i, val in enumerate(properties):
+            if val.startswith(FONT_SIZE_IDENTIFIER):
+                return float(properties[i - 1])
 
     return result
 
@@ -132,21 +128,22 @@ def get_text_field_font_color(
     """Returns the font color tuple of the text field if presented or black."""
 
     result = (0, 0, 0)
-    for pattern in TEXT_FIELD_APPEARANCE_PATTERNS:
-        text_appearance = traverse_pattern(pattern, widget)
-        if text_appearance:
-            if FONT_COLOR_IDENTIFIER not in text_appearance:
-                return result
-
-            text_appearance = text_appearance.split(" ")
-            for i, val in enumerate(text_appearance):
-                if val.startswith(FONT_COLOR_IDENTIFIER.replace(" ", "")):
-                    result = (
-                        float(text_appearance[i - 3]),
-                        float(text_appearance[i - 2]),
-                        float(text_appearance[i - 1]),
-                    )
-                    break
+    text_appearance = extract_widget_property(
+        widget, TEXT_FIELD_APPEARANCE_PATTERNS, None, None
+    )
+    if text_appearance:
+        if FONT_COLOR_IDENTIFIER not in text_appearance:
+            return result
+
+        text_appearance = text_appearance.split(" ")
+        for i, val in enumerate(text_appearance):
+            if val.startswith(FONT_COLOR_IDENTIFIER.replace(" ", "")):
+                result = (
+                    float(text_appearance[i - 3]),
+                    float(text_appearance[i - 2]),
+                    float(text_appearance[i - 1]),
+                )
+                break
 
     return result
 

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/middleware/base.py

@@ -19,6 +19,12 @@ class Widget:
         self.full_name = None
         self._value = value
         self.desc = None
+        self.border_color = None
+        self.background_color = None
+        self.border_width = None
+        self.border_style = None
+        self.dash_array = None
+        self.render_widget = None
 
     @property
     def name(self) -> str:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/middleware/checkbox.py

@@ -25,7 +25,7 @@ class Checkbox(Widget):
         super().__init__(name, value)
 
         self.size = None
-        self._button_style = None
+        self._button_style = self.BUTTON_STYLE_MAPPING["check"]
 
     @property
     def schema_definition(self) -> dict:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/middleware/radio.py

@@ -7,7 +7,18 @@ from .checkbox import Checkbox
 class Radio(Checkbox):
     """A class to represent a radiobutton widget."""
 
-    number_of_options = 0
+    def __init__(
+        self,
+        name: str,
+        value: int = None,
+    ) -> None:
+        """Constructs all attributes for the radiobutton."""
+
+        super().__init__(name, value)
+
+        self.size = None
+        self.number_of_options = 0
+        self._button_style = self.BUTTON_STYLE_MAPPING["circle"]
 
     @property
     def schema_definition(self) -> dict:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/patterns.py

@@ -4,9 +4,10 @@
 from pypdf.generic import (DictionaryObject, NameObject, NumberObject,
                            TextStringObject)
 
-from .constants import (AP, AS, CA, DA, DV, FT, IMAGE_FIELD_IDENTIFIER, JS, MK,
-                        MULTILINE, READ_ONLY, TU, A, Btn, Ch, Ff, N, Off, Opt,
-                        Parent, Q, Sig, T, Tx, V, Yes)
+from .constants import (AP, AS, BC, BG, BS, CA, DA, DV, FT,
+                        IMAGE_FIELD_IDENTIFIER, JS, MK, MULTILINE, READ_ONLY,
+                        TU, A, Btn, Ch, D, Ff, N, Off, Opt, Parent, Q, S, Sig,
+                        T, Tx, V, W, Yes)
 from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
 from .middleware.image import Image
@@ -94,6 +95,20 @@ BUTTON_STYLE_PATTERNS = [
     {MK: {CA: True}},
 ]
 
+BORDER_COLOR_PATTERNS = [
+    {MK: {BC: True}},
+]
+
+BACKGROUND_COLOR_PATTERNS = [
+    {MK: {BG: True}},
+]
+
+BORDER_WIDTH_PATTERNS = [{BS: {W: True}}]
+
+BORDER_STYLE_PATTERNS = [{BS: {S: True}}]
+
+BORDER_DASH_ARRAY_PATTERNS = [{BS: {D: True}}]
+
 
 def simple_update_checkbox_value(annot: DictionaryObject, check: bool = False) -> None:
     """Patterns to update values for checkbox annotations."""

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/template.py

@@ -10,8 +10,9 @@ from pypdf import PdfReader, PdfWriter
 from pypdf.generic import DictionaryObject
 from reportlab.pdfbase.pdfmetrics import stringWidth
 
-from .constants import (COMB, DEFAULT_FONT_SIZE, MULTILINE, NEW_LINE_SYMBOL,
-                        WIDGET_TYPES, Annots, MaxLen, Parent, Rect, T)
+from .constants import (COMB, DEFAULT_BORDER_WIDTH, DEFAULT_FONT_SIZE,
+                        MULTILINE, NEW_LINE_SYMBOL, WIDGET_TYPES, Annots,
+                        MaxLen, Parent, Rect, T)
 from .font import (adjust_paragraph_font_size, adjust_text_field_font_size,
                    auto_detect_font, get_text_field_font_color,
                    get_text_field_font_size, text_field_font_size)
@@ -19,12 +20,14 @@ from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
 from .middleware.radio import Radio
 from .middleware.text import Text
-from .patterns import (BUTTON_STYLE_PATTERNS, DROPDOWN_CHOICE_PATTERNS,
-                       TEXT_FIELD_FLAG_PATTERNS, WIDGET_ALIGNMENT_PATTERNS,
+from .patterns import (BACKGROUND_COLOR_PATTERNS, BORDER_COLOR_PATTERNS,
+                       BORDER_DASH_ARRAY_PATTERNS, BORDER_STYLE_PATTERNS,
+                       BORDER_WIDTH_PATTERNS, BUTTON_STYLE_PATTERNS,
+                       DROPDOWN_CHOICE_PATTERNS, TEXT_FIELD_FLAG_PATTERNS,
                        WIDGET_DESCRIPTION_PATTERNS, WIDGET_KEY_PATTERNS,
                        WIDGET_TYPE_PATTERNS, update_annotation_name)
-from .utils import find_pattern_match, stream_to_io, traverse_pattern
-from .watermark import create_watermarks_and_draw
+from .utils import (extract_widget_property, find_pattern_match, handle_color,
+                    stream_to_io)
 
 
 def set_character_x_paddings(
@@ -34,7 +37,7 @@ def set_character_x_paddings(
 
     for _widgets in get_widgets_by_page(pdf_stream).values():
         for widget in _widgets:
-            key = get_widget_key(widget)
+            key = extract_widget_property(widget, WIDGET_KEY_PATTERNS, None, str)
             _widget = widgets[key]
 
             if isinstance(_widget, Text) and _widget.comb is True:
@@ -44,7 +47,9 @@ def set_character_x_paddings(
 
 
 def build_widgets(
-    pdf_stream: bytes, use_full_widget_name: bool
+    pdf_stream: bytes,
+    use_full_widget_name: bool,
+    render_widgets: bool,
 ) -> Dict[str, WIDGET_TYPES]:
     """Builds a widget dict given a PDF form stream."""
 
@@ -52,18 +57,44 @@ def build_widgets(
 
     for widgets in get_widgets_by_page(pdf_stream).values():
         for widget in widgets:
-            key = get_widget_key(widget)
+            key = extract_widget_property(widget, WIDGET_KEY_PATTERNS, None, str)
             _widget = construct_widget(widget, key)
             if _widget is not None:
-                _widget.full_name = get_widget_full_key(widget)
-                _widget.desc = get_widget_description(widget)
+                if use_full_widget_name:
+                    _widget.full_name = get_widget_full_key(widget)
+
+                _widget.render_widget = render_widgets
+                _widget.desc = extract_widget_property(
+                    widget, WIDGET_DESCRIPTION_PATTERNS, None, str
+                )
+                _widget.border_color = extract_widget_property(
+                    widget, BORDER_COLOR_PATTERNS, None, handle_color
+                )
+                _widget.background_color = extract_widget_property(
+                    widget, BACKGROUND_COLOR_PATTERNS, None, handle_color
+                )
+                _widget.border_width = extract_widget_property(
+                    widget, BORDER_WIDTH_PATTERNS, DEFAULT_BORDER_WIDTH, float
+                )
+                _widget.border_style = extract_widget_property(
+                    widget, BORDER_STYLE_PATTERNS, None, str
+                )
+                _widget.dash_array = extract_widget_property(
+                    widget, BORDER_DASH_ARRAY_PATTERNS, None, list
+                )
+
                 if isinstance(_widget, Text):
                     _widget.max_length = get_text_field_max_length(widget)
                     if _widget.max_length is not None and is_text_field_comb(widget):
                         _widget.comb = True
 
                 if isinstance(_widget, (Checkbox, Radio)):
-                    _widget.button_style = get_button_style(widget)
+                    _widget.button_style = (
+                        extract_widget_property(
+                            widget, BUTTON_STYLE_PATTERNS, None, str
+                        )
+                        or _widget.button_style
+                    )
 
                 if isinstance(_widget, Dropdown):
                     _widget.choices = get_dropdown_choices(widget)
@@ -81,32 +112,14 @@ def build_widgets(
     return results
 
 
-def widget_rect_watermarks(pdf: bytes) -> List[bytes]:
-    """Draws the rectangular border of each widget and returns watermarks."""
-
-    watermarks = []
-
-    for page, widgets in get_widgets_by_page(pdf).items():
-        to_draw = []
-        for widget in widgets:
-            rect = widget[Rect]
-            x = rect[0]
-            y = rect[1]
-            width = abs(rect[0] - rect[2])
-            height = abs(rect[1] - rect[3])
-
-            to_draw.append([x, y, width, height])
-        watermarks.append(
-            create_watermarks_and_draw(pdf, page, "rect", to_draw)[page - 1]
-        )
-
-    return watermarks
-
-
 def dropdown_to_text(dropdown: Dropdown) -> Text:
     """Converts a dropdown widget to a text widget."""
 
     result = Text(dropdown.name)
+    result.border_color = dropdown.border_color
+    result.background_color = dropdown.background_color
+    result.border_width = dropdown.border_width
+    result.render_widget = dropdown.render_widget
 
     if dropdown.value is not None:
         result.value = (
@@ -126,7 +139,7 @@ def update_text_field_attributes(
 
     for _widgets in get_widgets_by_page(template_stream).values():
         for _widget in _widgets:
-            key = get_widget_key(_widget)
+            key = extract_widget_property(_widget, WIDGET_KEY_PATTERNS, None, str)
 
             if isinstance(widgets[key], Text):
                 should_adjust_font_size = False
@@ -183,48 +196,24 @@ def get_widgets_by_page(pdf: bytes) -> Dict[int, List[dict]]:
     return result
 
 
-def get_widget_key(widget: dict) -> Union[str, list, None]:
-    """Finds a PDF widget's annotated key by pattern matching."""
-
-    result = None
-    for pattern in WIDGET_KEY_PATTERNS:
-        value = traverse_pattern(pattern, widget)
-        if value:
-            result = value
-            break
-    return result
-
-
 def get_widget_full_key(widget: dict) -> Union[str, None]:
     """
     Returns a PDF widget's full annotated key by prepending its
     parent widget's key.
     """
 
-    key = get_widget_key(widget)
+    key = extract_widget_property(widget, WIDGET_KEY_PATTERNS, None, str)
 
     if (
         Parent in widget
         and T in widget[Parent].get_object()
-        and widget[Parent][T] != key
+        and widget[Parent].get_object()[T] != key
     ):
-        return f"{widget[Parent][T]}.{key}"
+        return f"{widget[Parent].get_object()[T]}.{key}"
 
     return None
 
 
-def get_widget_alignment(widget: dict) -> Union[str, list, None]:
-    """Finds a PDF widget's alignment by pattern matching."""
-
-    result = None
-    for pattern in WIDGET_ALIGNMENT_PATTERNS:
-        value = traverse_pattern(pattern, widget)
-        if value:
-            result = value
-            break
-    return result
-
-
 def construct_widget(widget: dict, key: str) -> Union[WIDGET_TYPES, None]:
     """Finds a PDF widget's annotated type by pattern matching."""
 
@@ -246,26 +235,10 @@ def get_text_field_max_length(widget: dict) -> Union[int, None]:
     return int(widget[MaxLen]) or None if MaxLen in widget else None
 
 
-def get_widget_description(widget: dict) -> Union[str, None]:
-    """Returns the description of the widget if presented or None."""
-
-    result = None
-    for pattern in WIDGET_DESCRIPTION_PATTERNS:
-        value = traverse_pattern(pattern, widget)
-        if value:
-            result = str(value)
-            break
-    return result
-
-
 def check_field_flag_bit(widget: dict, bit: int) -> bool:
     """Checks if a bit is set in a widget's field flag."""
 
-    field_flag = None
-    for pattern in TEXT_FIELD_FLAG_PATTERNS:
-        field_flag = traverse_pattern(pattern, widget)
-        if field_flag is not None:
-            break
+    field_flag = extract_widget_property(widget, TEXT_FIELD_FLAG_PATTERNS, None, int)
 
     if field_flag is None:
         return False
@@ -288,27 +261,12 @@ def is_text_multiline(widget: dict) -> bool:
 def get_dropdown_choices(widget: dict) -> Union[Tuple[str, ...], None]:
     """Returns string options of a dropdown field."""
 
-    result = None
-    for pattern in DROPDOWN_CHOICE_PATTERNS:
-        choices = traverse_pattern(pattern, widget)
-        if choices:
-            result = tuple(
-                (each if isinstance(each, str) else str(each[1])) for each in choices
-            )
-            break
-
-    return result
-
-
-def get_button_style(widget: dict) -> Union[str, None]:
-    """Returns the button style of a checkbox or radiobutton."""
-
-    for pattern in BUTTON_STYLE_PATTERNS:
-        style = traverse_pattern(pattern, widget)
-        if style is not None:
-            return str(style)
-
-    return None
+    return tuple(
+        (each if isinstance(each, str) else str(each[1]))
+        for each in extract_widget_property(
+            widget, DROPDOWN_CHOICE_PATTERNS, None, None
+        )
+    )
 
 
 def get_char_rect_width(widget: dict, widget_middleware: Text) -> float:
@@ -462,7 +420,9 @@ def update_widget_keys(
         for page in out.pages:
             for annot in page.get(Annots, []):  # noqa
                 annot = cast(DictionaryObject, annot.get_object())
-                key = get_widget_key(annot.get_object())
+                key = extract_widget_property(
+                    annot.get_object(), WIDGET_KEY_PATTERNS, None, str
+                )
 
                 widget = widgets.get(key)
                 if widget is None:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/utils.py

@@ -1,13 +1,15 @@
 # -*- coding: utf-8 -*-
 """Contains utility helpers."""
 
+from collections.abc import Callable
 from io import BytesIO
 from secrets import choice
 from string import ascii_letters, digits, punctuation
-from typing import BinaryIO, List, Union
+from typing import Any, BinaryIO, List, Union
 
 from pypdf import PdfReader, PdfWriter
-from pypdf.generic import DictionaryObject
+from pypdf.generic import ArrayObject, DictionaryObject
+from reportlab.lib.colors import CMYKColor, Color
 
 from .constants import (BUTTON_STYLES, DEFAULT_CHECKBOX_STYLE, DEFAULT_FONT,
                         DEFAULT_FONT_COLOR, DEFAULT_FONT_SIZE,
@@ -28,6 +30,22 @@ def stream_to_io(stream: bytes) -> BinaryIO:
     return result
 
 
+def handle_color(color: Union[list, ArrayObject]) -> Union[Color, CMYKColor, None]:
+    """Converts a color array to an RGB or CMYK color."""
+
+    result = None
+
+    if len(color) == 1:
+        result = CMYKColor(black=1 - color[0])
+    elif len(color) == 3:
+        result = Color(red=color[0], green=color[1], blue=color[2])
+    # write a test case for this
+    # elif len(color) == 4:
+    #     result = CMYKColor(cyan=color[0], magenta=color[1], yellow=color[2], black=color[3])
+
+    return result
+
+
 def checkbox_radio_to_draw(
     widget: Union[Checkbox, Radio], font_size: Union[float, int]
 ) -> Text:
@@ -47,17 +65,20 @@ def checkbox_radio_to_draw(
     return new_widget
 
 
-def preview_widget_to_draw(widget: WIDGET_TYPES) -> Text:
+def preview_widget_to_draw(widget: WIDGET_TYPES, with_preview_text: bool) -> Text:
     """Converts a widget to a preview text widget."""
 
     new_widget = Text(
         name=widget.name,
-        value="{" + f" {widget.name} " + "}",
+        value="{" + f" {widget.name} " + "}" if with_preview_text else None,
     )
     new_widget.font = DEFAULT_FONT
     new_widget.font_size = DEFAULT_FONT_SIZE
     new_widget.font_color = PREVIEW_FONT_COLOR
-    new_widget.preview = True
+    new_widget.preview = with_preview_text
+    new_widget.border_color = handle_color([0, 0, 0])
+    new_widget.border_width = 1
+    new_widget.render_widget = True
 
     return new_widget
 
@@ -155,6 +176,25 @@ def traverse_pattern(
     return None
 
 
+def extract_widget_property(
+    widget: Union[dict, DictionaryObject],
+    patterns: list,
+    default_value: Any,
+    func_before_return: Union[Callable, None],
+) -> Any:
+    """Returns a property value given a PDF widget dict and a pattern."""
+
+    result = default_value
+
+    for pattern in patterns:
+        value = traverse_pattern(pattern, widget)
+        if value:
+            result = func_before_return(value) if func_before_return else value
+            break
+
+    return result
+
+
 def generate_unique_suffix() -> str:
     """Generates a unique suffix string for widgets during form merging."""
 

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/watermark.py

@@ -72,6 +72,36 @@ def draw_text(*args) -> None:
         canvas.restoreState()
 
 
+def draw_rect(*args) -> None:
+    """Draws a rectangle on the watermark."""
+
+    canvas = args[0]
+    x = args[1]
+    y = args[2]
+    width = args[3]
+    height = args[4]
+
+    canvas.saveState()
+    stroke, fill = set_border_and_background_styles(*args)
+    canvas.rect(x, y, width, height, stroke=stroke, fill=fill)
+    canvas.restoreState()
+
+
+def draw_ellipse(*args) -> None:
+    """Draws an ellipse on the watermark."""
+
+    canvas = args[0]
+    x1 = args[1]
+    y1 = args[2]
+    x2 = args[3]
+    y2 = args[4]
+
+    canvas.saveState()
+    stroke, fill = set_border_and_background_styles(*args)
+    canvas.ellipse(x1, y1, x2, y2, stroke=stroke, fill=fill)
+    canvas.restoreState()
+
+
 def draw_line(*args) -> None:
     """Draws a line on the watermark."""
 
@@ -80,26 +110,36 @@ def draw_line(*args) -> None:
     src_y = args[2]
     dest_x = args[3]
     dest_y = args[4]
-    r = args[5]
-    g = args[6]
-    b = args[7]
 
     canvas.saveState()
-    canvas.setStrokeColorRGB(r, g, b)
+    set_border_and_background_styles(*args)
     canvas.line(src_x, src_y, dest_x, dest_y)
     canvas.restoreState()
 
 
-def draw_rect(*args) -> None:
-    """Draws a rectangle on the watermark."""
+def set_border_and_background_styles(*args) -> tuple:
+    """Sets colors for both border and background before drawing."""
 
     canvas = args[0]
-    x = args[1]
-    y = args[2]
-    width = args[3]
-    height = args[4]
+    border_color = args[5]
+    background_color = args[6]
+    border_width = args[7]
+    dash_array = args[8]
 
-    canvas.rect(x, y, width, height)
+    stroke = 0
+    fill = 0
+    if border_color is not None and border_width:
+        canvas.setStrokeColor(border_color)
+        canvas.setLineWidth(border_width)
+        stroke = 1
+    if background_color is not None:
+        canvas.setFillColor(background_color)
+        fill = 1
+
+    if dash_array is not None:
+        canvas.setDash(array=dash_array)
+
+    return stroke, fill
 
 
 def draw_image(*args) -> None:
@@ -159,6 +199,9 @@ def create_watermarks_and_draw(
     elif action_type == "rect":
         for each in actions:
             draw_rect(*([canvas, *each]))
+    elif action_type == "ellipse":
+        for each in actions:
+            draw_ellipse(*([canvas, *each]))
 
     canvas.save()
     buff.seek(0)

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/widgets/base.py

@@ -10,9 +10,8 @@ from reportlab.lib.colors import Color
 from reportlab.pdfgen.canvas import Canvas
 
 from ..constants import Annots
-from ..patterns import NON_ACRO_FORM_PARAM_TO_FUNC
-from ..template import get_widget_key
-from ..utils import stream_to_io
+from ..patterns import NON_ACRO_FORM_PARAM_TO_FUNC, WIDGET_KEY_PATTERNS
+from ..utils import extract_widget_property, stream_to_io
 
 
 class Widget:
@@ -101,7 +100,9 @@ def handle_non_acro_form_params(pdf: bytes, key: str, params: list) -> bytes:
     for page in out.pages:
         for annot in page.get(Annots, []):  # noqa
             annot = cast(DictionaryObject, annot.get_object())
-            _key = get_widget_key(annot.get_object())
+            _key = extract_widget_property(
+                annot.get_object(), WIDGET_KEY_PATTERNS, None, str
+            )
 
             if _key == key:
                 for param in params:

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm/wrapper.py

@@ -18,7 +18,7 @@ from .middleware.dropdown import Dropdown
 from .middleware.text import Text
 from .template import (build_widgets, dropdown_to_text,
                        set_character_x_paddings, update_text_field_attributes,
-                       update_widget_keys, widget_rect_watermarks)
+                       update_widget_keys)
 from .utils import (generate_unique_suffix, get_page_streams, merge_two_pdfs,
                     preview_widget_to_draw, remove_all_widgets)
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
@@ -52,7 +52,7 @@ class FormWrapper:
     ) -> FormWrapper:
         """Fills a PDF form."""
 
-        widgets = build_widgets(self.stream, False) if self.stream else {}
+        widgets = build_widgets(self.stream, False, False) if self.stream else {}
 
         for key, value in data.items():
             if key in widgets:
@@ -72,10 +72,11 @@ class PdfWrapper(FormWrapper):
     """A class to represent a PDF form."""
 
     USER_PARAMS = [
-        "global_font",
-        "global_font_size",
-        "global_font_color",
-        "use_full_widget_name",
+        ("global_font", None),
+        ("global_font_size", None),
+        ("global_font_color", None),
+        ("use_full_widget_name", False),
+        ("render_widgets", True),
     ]
 
     def __init__(
@@ -89,8 +90,8 @@ class PdfWrapper(FormWrapper):
         self.widgets = {}
         self._keys_to_update = []
 
-        for each in self.USER_PARAMS:
-            setattr(self, each, kwargs.get(each))
+        for attr, default in self.USER_PARAMS:
+            setattr(self, attr, kwargs.get(attr, default))
 
         self._init_helper()
 
@@ -99,7 +100,11 @@ class PdfWrapper(FormWrapper):
 
         refresh_not_needed = {}
         new_widgets = (
-            build_widgets(self.read(), getattr(self, "use_full_widget_name"))
+            build_widgets(
+                self.read(),
+                getattr(self, "use_full_widget_name"),
+                getattr(self, "render_widgets"),
+            )
             if self.read()
             else {}
         )
@@ -141,7 +146,7 @@ class PdfWrapper(FormWrapper):
 
         return [
             self.__class__(
-                each, **{param: getattr(self, param) for param in self.USER_PARAMS}
+                each, **{param: getattr(self, param) for param, _ in self.USER_PARAMS}
             )
             for each in get_page_streams(self.stream)
         ]
@@ -180,15 +185,12 @@ class PdfWrapper(FormWrapper):
         """Inspects all supported widgets' names for the PDF form."""
 
         return remove_all_widgets(
-            merge_watermarks_with_pdf(
-                fill(
-                    self.stream,
-                    {
-                        key: preview_widget_to_draw(value)
-                        for key, value in self.widgets.items()
-                    },
-                ),
-                widget_rect_watermarks(self.read()),
+            fill(
+                self.stream,
+                {
+                    key: preview_widget_to_draw(value, True)
+                    for key, value in self.widgets.items()
+                },
             )
         )
 
@@ -198,8 +200,14 @@ class PdfWrapper(FormWrapper):
         """Inspects a coordinate grid of the PDF."""
 
         self.stream = generate_coordinate_grid(
-            merge_watermarks_with_pdf(
-                remove_all_widgets(self.read()), widget_rect_watermarks(self.read())
+            remove_all_widgets(
+                fill(
+                    self.stream,
+                    {
+                        key: preview_widget_to_draw(value, False)
+                        for key, value in self.widgets.items()
+                    },
+                )
             ),
             color,
             margin,

{pypdfform-1.5.6 → pypdfform-2.0.0}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 1.5.6
+Version: 2.0.0
 Summary: The Python library for PDF forms.
 Home-page: https://github.com/chinapandaman/PyPDFForm
 Author: Jinge Li
@@ -29,6 +29,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -43,6 +44,15 @@ Dynamic: summary
     <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?logo=pypi&logoColor=white&label=downloads&labelColor=black&color=blue&style=for-the-badge"></a>
 </p>
 
+## Important Announcements
+
+Hello fellow Python developers! With the release of v2.0.0, there are some important changes I'm making to the library:
+
+* Since I started developing the library, versioning releases has been quite unorthodox, and there isn't any convention I followed. Starting with v2.0.0, PyPDFForm will version releases following the conventions defined by [Semantic Versioning](https://semver.org/).
+* PyPDFForm now renders PDF form widgets! Ever since its ancestral stage, the library has only been able to render the data you filled into a PDF form. Now if you fill a PDF form using `PdfWrapper`, the result will render the whole widget instead of just the value that got filled. If you would like to disable this behavior, please refer to the docs [here](https://chinapandaman.github.io/PyPDFForm/fill/#disable-rendering-widgets).
+
+Happy hacking!
+
 ## Introduction
 
 PyPDFForm is a free and open source pure-Python 3 library for PDF form processing. It contains the essential 

{pypdfform-1.5.6 → pypdfform-2.0.0}/README.md

@@ -8,6 +8,15 @@
     <a href="https://pypistats.org/packages/pypdfform"><img src="https://img.shields.io/pypi/dm/pypdfform?logo=pypi&logoColor=white&label=downloads&labelColor=black&color=blue&style=for-the-badge"></a>
 </p>
 
+## Important Announcements
+
+Hello fellow Python developers! With the release of v2.0.0, there are some important changes I'm making to the library:
+
+* Since I started developing the library, versioning releases has been quite unorthodox, and there isn't any convention I followed. Starting with v2.0.0, PyPDFForm will version releases following the conventions defined by [Semantic Versioning](https://semver.org/).
+* PyPDFForm now renders PDF form widgets! Ever since its ancestral stage, the library has only been able to render the data you filled into a PDF form. Now if you fill a PDF form using `PdfWrapper`, the result will render the whole widget instead of just the value that got filled. If you would like to disable this behavior, please refer to the docs [here](https://chinapandaman.github.io/PyPDFForm/fill/#disable-rendering-widgets).
+
+Happy hacking!
+
 ## Introduction
 
 PyPDFForm is a free and open source pure-Python 3 library for PDF form processing. It contains the essential