PyPDFForm 1.4.23__tar.gz → 1.4.24__tar.gz

{pypdfform-1.4.23 → pypdfform-1.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPDFForm
-Version: 1.4.23
+Version: 1.4.24
 Summary: The Python library for PDF forms.
 Home-page: https://github.com/chinapandaman/PyPDFForm
 Author: Jinge Li

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """Contains any object users might need."""
 
-__version__ = "1.4.23"
+__version__ = "1.4.24"
 
 from .wrapper import FormWrapper, PdfWrapper, PyPDFForm

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/constants.py

@@ -51,6 +51,7 @@ Opt = "/Opt"
 MK = "/MK"
 CA = "/CA"
 AS = "/AS"
+Yes = "/Yes"
 Off = "/Off"
 
 # Field flag bits
@@ -78,3 +79,7 @@ BUTTON_STYLES = {
 }
 
 COORDINATE_GRID_FONT_SIZE_MARGIN_RATIO = DEFAULT_FONT_SIZE / 100
+
+# Used for adjusting paragraph font size
+FONT_SIZE_REDUCE_STEP = 0.5
+MARGIN_BETWEEN_LINES = 2

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/filler.py

@@ -2,7 +2,7 @@
 """Contains helpers for filling a PDF form."""
 
 from io import BytesIO
-from typing import Dict, cast
+from typing import Dict, Tuple, Union, cast
 
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import DictionaryObject
@@ -29,6 +29,80 @@ from .utils import checkbox_radio_to_draw, stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
+def check_radio_handler(
+    widget: dict, middleware: Union[Checkbox, Radio], radio_button_tracker: dict
+) -> Tuple[Text, Union[float, int], Union[float, int], bool]:
+    """Handles draw parameters for checkbox and radio button widgets."""
+
+    font_size = (
+        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)
+    text_needs_to_be_drawn = False
+    if type(middleware) is Checkbox and middleware.value:
+        text_needs_to_be_drawn = True
+    elif isinstance(middleware, Radio):
+        if middleware.name not in radio_button_tracker:
+            radio_button_tracker[middleware.name] = 0
+        radio_button_tracker[middleware.name] += 1
+        if middleware.value == radio_button_tracker[middleware.name] - 1:
+            text_needs_to_be_drawn = True
+
+    return to_draw, x, y, text_needs_to_be_drawn
+
+
+def signature_image_handler(
+    widget: dict, middleware: Union[Signature, Image], images_to_draw: list
+) -> bool:
+    """Handles draw parameters for signature and image widgets."""
+
+    stream = middleware.stream
+    any_image_to_draw = False
+    if stream is not None:
+        any_image_to_draw = True
+        stream = any_image_to_jpg(stream)
+        x, y, width, height = get_draw_image_coordinates_resolutions(widget)
+        images_to_draw.append(
+            [
+                stream,
+                x,
+                y,
+                width,
+                height,
+            ]
+        )
+
+    return any_image_to_draw
+
+
+def text_handler(
+    widget: dict, middleware: Text
+) -> Tuple[Text, Union[float, int], Union[float, int], bool]:
+    """Handles draw parameters for text field widgets."""
+
+    middleware.text_line_x_coordinates = get_text_line_x_coordinates(widget, middleware)
+    x, y = get_draw_text_coordinates(widget, middleware)
+    to_draw = middleware
+    text_needs_to_be_drawn = True
+
+    return to_draw, x, y, text_needs_to_be_drawn
+
+
+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."""
+
+    watermark_list = []
+    for page, stuffs in to_draw.items():
+        watermark_list.append(b"")
+        watermarks = create_watermarks_and_draw(stream, page, action, stuffs)
+        for i, watermark in enumerate(watermarks):
+            if watermark:
+                watermark_list[i] = watermark
+
+    return merge_watermarks_with_pdf(stream, watermark_list)
+
+
 def fill(
     template_stream: bytes,
     widgets: Dict[str, WIDGET_TYPES],
@@ -38,95 +112,50 @@ def fill(
     texts_to_draw = {}
     images_to_draw = {}
     any_image_to_draw = False
-    text_watermarks = []
-    image_watermarks = []
 
     radio_button_tracker = {}
 
-    for page, _widgets in get_widgets_by_page(template_stream).items():
+    for page, widget_dicts in get_widgets_by_page(template_stream).items():
         texts_to_draw[page] = []
         images_to_draw[page] = []
-        text_watermarks.append(b"")
-        image_watermarks.append(b"")
-        for _widget in _widgets:
-            key = get_widget_key(_widget)
+        for widget_dict in widget_dicts:
+            key = get_widget_key(widget_dict)
             text_needs_to_be_drawn = False
-            _to_draw = x = y = None
+            to_draw = x = y = None
 
             if isinstance(widgets[key], (Checkbox, Radio)):
-                font_size = (
-                    checkbox_radio_font_size(_widget)
-                    if widgets[key].size is None
-                    else widgets[key].size
+                to_draw, x, y, text_needs_to_be_drawn = check_radio_handler(
+                    widget_dict, widgets[key], radio_button_tracker
                 )
-                _to_draw = checkbox_radio_to_draw(widgets[key], font_size)
-                x, y = get_draw_checkbox_radio_coordinates(_widget, _to_draw)
-                if type(widgets[key]) is Checkbox and widgets[key].value:
-                    text_needs_to_be_drawn = True
-                elif isinstance(widgets[key], Radio):
-                    if key not in radio_button_tracker:
-                        radio_button_tracker[key] = 0
-                    radio_button_tracker[key] += 1
-                    if widgets[key].value == radio_button_tracker[key] - 1:
-                        text_needs_to_be_drawn = True
             elif isinstance(widgets[key], (Signature, Image)):
-                stream = widgets[key].stream
-                if stream is not None:
-                    any_image_to_draw = True
-                    stream = any_image_to_jpg(stream)
-                    x, y, width, height = get_draw_image_coordinates_resolutions(
-                        _widget
-                    )
-                    images_to_draw[page].append(
-                        [
-                            stream,
-                            x,
-                            y,
-                            width,
-                            height,
-                        ]
-                    )
+                any_image_to_draw = signature_image_handler(
+                    widget_dict, widgets[key], images_to_draw[page]
+                )
             else:
-                widgets[key].text_line_x_coordinates = get_text_line_x_coordinates(
-                    _widget, widgets[key]
+                to_draw, x, y, text_needs_to_be_drawn = text_handler(
+                    widget_dict, widgets[key]
                 )
-                x, y = get_draw_text_coordinates(_widget, widgets[key])
-                _to_draw = widgets[key]
-                text_needs_to_be_drawn = True
 
             if all(
                 [
                     text_needs_to_be_drawn,
-                    _to_draw is not None,
+                    to_draw is not None,
                     x is not None,
                     y is not None,
                 ]
             ):
                 texts_to_draw[page].append(
                     [
-                        _to_draw,
+                        to_draw,
                         x,
                         y,
                     ]
                 )
 
-    for page, texts in texts_to_draw.items():
-        _watermarks = create_watermarks_and_draw(template_stream, page, "text", texts)
-        for i, watermark in enumerate(_watermarks):
-            if watermark:
-                text_watermarks[i] = watermark
-
-    result = merge_watermarks_with_pdf(template_stream, text_watermarks)
+    result = get_drawn_stream(texts_to_draw, template_stream, "text")
 
     if any_image_to_draw:
-        for page, images in images_to_draw.items():
-            _watermarks = create_watermarks_and_draw(
-                template_stream, page, "image", images
-            )
-            for i, watermark in enumerate(_watermarks):
-                if watermark:
-                    image_watermarks[i] = watermark
-        result = merge_watermarks_with_pdf(result, image_watermarks)
+        result = get_drawn_stream(images_to_draw, result, "image")
 
     return result
 

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/font.py

@@ -33,20 +33,11 @@ def register_font(font_name: str, ttf_stream: bytes) -> bool:
     return result
 
 
-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
-
-    if not text_appearance:
-        return result
+def extract_font_from_text_appearance(text_appearance: str) -> Union[str, None]:
+    """
+    Uses regex to pattern match out the font from the text
+    appearance string of a text field widget.
+    """
 
     text_appearance = text_appearance.split(" ")
 
@@ -72,7 +63,25 @@ def auto_detect_font(widget: dict) -> str:
                 if found:
                     return font
 
-    return result
+    return 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
+
+    if not text_appearance:
+        return result
+
+    return extract_font_from_text_appearance(text_appearance) or result
 
 
 def text_field_font_size(widget: dict) -> Union[float, int]:

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/patterns.py

@@ -6,7 +6,7 @@ from pypdf.generic import (DictionaryObject, NameObject, NumberObject,
 
 from .constants import (AP, AS, CA, DA, FT, IMAGE_FIELD_IDENTIFIER, JS, MK,
                         READ_ONLY, A, Btn, Ch, D, Ff, Off, Opt, Parent, Q, Sig,
-                        Subtype, T, Tx, V, Widget)
+                        Subtype, T, Tx, V, Widget, Yes)
 from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
 from .middleware.image import Image
@@ -28,7 +28,10 @@ WIDGET_TYPE_PATTERNS = [
         Text,
     ),
     (
-        ({FT: Btn},),
+        (
+            {FT: Btn},
+            {AS: (Yes, Off)},
+        ),
         Checkbox,
     ),
     (
@@ -47,11 +50,15 @@ WIDGET_TYPE_PATTERNS = [
         (
             {Parent: {FT: Btn}},
             {Parent: {Subtype: Widget}},
+            {AS: (Yes, Off)},
         ),
         Checkbox,
     ),
     (
-        ({Parent: {FT: Btn}},),
+        (
+            {Parent: {FT: Btn}},
+            {AS: (Yes, Off)},
+        ),
         Radio,
     ),
 ]

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/template.py

@@ -8,7 +8,8 @@ from typing import Dict, List, Tuple, Union
 from pypdf import PdfReader
 from reportlab.pdfbase.pdfmetrics import stringWidth
 
-from .constants import (COMB, DEFAULT_FONT_SIZE, MULTILINE, NEW_LINE_SYMBOL,
+from .constants import (COMB, DEFAULT_FONT_SIZE, FONT_SIZE_REDUCE_STEP,
+                        MARGIN_BETWEEN_LINES, MULTILINE, NEW_LINE_SYMBOL,
                         WIDGET_TYPES, MaxLen, Rect)
 from .font import (auto_detect_font, get_text_field_font_color,
                    get_text_field_font_size, text_field_font_size)
@@ -122,21 +123,27 @@ def update_text_field_attributes(
             key = get_widget_key(_widget)
 
             if isinstance(widgets[key], Text):
+                should_adjust_font_size = False
+                is_paragraph = is_text_multiline(_widget)
                 if widgets[key].font is None:
                     widgets[key].font = auto_detect_font(_widget)
                 if widgets[key].font_size is None:
-                    widgets[key].font_size = get_text_field_font_size(_widget) or (
+                    template_font_size = get_text_field_font_size(_widget)
+                    widgets[key].font_size = template_font_size or (
                         text_field_font_size(_widget)
-                        if not is_text_multiline(_widget)
+                        if not is_paragraph
                         else DEFAULT_FONT_SIZE
                     )
+                    should_adjust_font_size = is_paragraph and not template_font_size
                 if widgets[key].font_color is None:
                     widgets[key].font_color = get_text_field_font_color(_widget)
-                if is_text_multiline(_widget) and widgets[key].text_wrap_length is None:
+                if is_paragraph and widgets[key].text_wrap_length is None:
                     widgets[key].text_lines = get_paragraph_lines(_widget, widgets[key])
                     widgets[key].text_wrap_length = get_paragraph_auto_wrap_length(
                         widgets[key]
                     )
+                    if widgets[key].value and should_adjust_font_size:
+                        adjust_paragraph_font_size(_widget, widgets[key])
 
 
 @lru_cache()
@@ -290,27 +297,23 @@ def get_character_x_paddings(widget: dict, widget_middleware: Text) -> List[floa
     return result
 
 
-def get_paragraph_lines(widget: dict, widget_middleware: Text) -> List[str]:
-    """Splits the paragraph field's text to a list of lines."""
+def split_characters_into_lines(
+    split_by_new_line_symbol: List[str], middleware: Text, width: float
+) -> List[str]:
+    """
+    Given a long string meant to be filled for a paragraph widget
+    split by the new line symbol already, splits it further into lines
+    where each line would fit into the widget's width.
+    """
 
     lines = []
-    result = []
-    value = widget_middleware.value or ""
-    if widget_middleware.max_length is not None:
-        value = value[: widget_middleware.max_length]
-
-    width = abs(float(widget[Rect][0]) - float(widget[Rect][2]))
-
-    split_by_new_line_symbol = value.split(NEW_LINE_SYMBOL)
     for line in split_by_new_line_symbol:
         characters = line.split(" ")
         current_line = ""
         for each in characters:
             line_extended = f"{current_line} {each}" if current_line else each
             if (
-                stringWidth(
-                    line_extended, widget_middleware.font, widget_middleware.font_size
-                )
+                stringWidth(line_extended, middleware.font, middleware.font_size)
                 <= width
             ):
                 current_line = line_extended
@@ -323,14 +326,23 @@ def get_paragraph_lines(widget: dict, widget_middleware: Text) -> List[str]:
             else current_line
         )
 
+    return lines
+
+
+def adjust_each_line(lines: List[str], middleware: Text, width: float) -> List[str]:
+    """
+    Given a list of strings which is the return value of
+    `split_characters_into_lines`, further adjusts each line
+    so that there is neither overflow nor over-splitting into
+    unnecessary lines.
+    """
+
+    result = []
     for each in lines:
         tracker = ""
         for char in each:
             check = tracker + char
-            if (
-                stringWidth(check, widget_middleware.font, widget_middleware.font_size)
-                > width
-            ):
+            if stringWidth(check, middleware.font, middleware.font_size) > width:
                 result.append(tracker)
                 tracker = char
             else:
@@ -342,8 +354,8 @@ def get_paragraph_lines(widget: dict, widget_middleware: Text) -> List[str]:
                 result
                 and stringWidth(
                     f"{each} {result[-1]}",
-                    widget_middleware.font,
-                    widget_middleware.font_size,
+                    middleware.font,
+                    middleware.font_size,
                 )
                 <= width
                 and NEW_LINE_SYMBOL not in result[-1]
@@ -361,6 +373,23 @@ def get_paragraph_lines(widget: dict, widget_middleware: Text) -> List[str]:
     return result
 
 
+def get_paragraph_lines(widget: dict, widget_middleware: Text) -> List[str]:
+    """Splits the paragraph field's text to a list of lines."""
+
+    value = widget_middleware.value or ""
+    if widget_middleware.max_length is not None:
+        value = value[: widget_middleware.max_length]
+
+    width = abs(float(widget[Rect][0]) - float(widget[Rect][2]))
+
+    split_by_new_line_symbol = value.split(NEW_LINE_SYMBOL)
+    lines = split_characters_into_lines(
+        split_by_new_line_symbol, widget_middleware, width
+    )
+
+    return adjust_each_line(lines, widget_middleware, width)
+
+
 def get_paragraph_auto_wrap_length(widget_middleware: Text) -> int:
     """Calculates the text wrap length of a paragraph field."""
 
@@ -369,3 +398,18 @@ def get_paragraph_auto_wrap_length(widget_middleware: Text) -> int:
         result = min(result, len(line))
 
     return result
+
+
+def adjust_paragraph_font_size(widget: dict, widget_middleware: Text) -> None:
+    """Reduces the font size of a paragraph field until texts fits."""
+
+    height = abs(float(widget[Rect][1]) - float(widget[Rect][3]))
+
+    while (
+        widget_middleware.font_size > FONT_SIZE_REDUCE_STEP
+        and len(widget_middleware.text_lines)
+        * (widget_middleware.font_size + MARGIN_BETWEEN_LINES)
+        > height
+    ):
+        widget_middleware.font_size -= FONT_SIZE_REDUCE_STEP
+        widget_middleware.text_lines = get_paragraph_lines(widget, widget_middleware)

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm/utils.py

@@ -122,7 +122,10 @@ def find_pattern_match(pattern: dict, widget: Union[dict, DictionaryObject]) ->
             ):
                 result = find_pattern_match(pattern[key], value)
             else:
-                result = pattern[key] == value
+                if isinstance(pattern[key], tuple):
+                    result = value in pattern[key]
+                else:
+                    result = pattern[key] == value
         if result:
             return result
     return False

{pypdfform-1.4.23 → pypdfform-1.4.24}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyPDFForm
-Version: 1.4.23
+Version: 1.4.24
 Summary: The Python library for PDF forms.
 Home-page: https://github.com/chinapandaman/PyPDFForm
 Author: Jinge Li