PyPDFForm 1.4.11__tar.gz → 1.4.13__tar.gz

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PKG-INFO

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

PyPDFForm-1.4.13/PyPDFForm/__init__.py

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

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm/constants.py

@@ -26,6 +26,7 @@ WIDGET_TYPES = Union[Text, Checkbox, Radio, Dropdown, Signature]
 
 DEPRECATION_NOTICE = "{} will be deprecated soon. Use {} instead."
 
+ANNOTATION_KEY = "/Annots"
 ANNOTATION_FIELD_KEY = "/T"
 ANNOTATION_RECTANGLE_KEY = "/Rect"
 SUBTYPE_KEY = "/Subtype"
@@ -34,6 +35,8 @@ WIDGET_TYPE_KEY = "/FT"
 PARENT_KEY = "/Parent"
 FIELD_FLAG_KEY = "/Ff"
 TEXT_FIELD_IDENTIFIER = "/Tx"
+TEXT_VALUE_IDENTIFIER = "/V"
+TEXT_VALUE_SHOW_UP_IDENTIFIER = "/AP"
 SIGNATURE_FIELD_IDENTIFIER = "/Sig"
 TEXT_FIELD_APPEARANCE_IDENTIFIER = "/DA"
 SELECTABLE_IDENTIFIER = "/Btn"
@@ -43,6 +46,7 @@ CHOICE_FIELD_IDENTIFIER = "/Ch"
 CHOICES_IDENTIFIER = "/Opt"
 BUTTON_IDENTIFIER = "/MK"
 BUTTON_STYLE_IDENTIFIER = "/CA"
+SELECTED_IDENTIFIER = "/AS"
 
 # Field flag bits
 MULTILINE = 1 << 12
@@ -60,9 +64,11 @@ NEW_LINE_SYMBOL = "\n"
 DEFAULT_CHECKBOX_STYLE = "\u2713"
 DEFAULT_RADIO_STYLE = "\u25CF"
 BUTTON_STYLES = {
-    "4": "\u2713",
-    "5": "\u00D7",
-    "l": "\u25CF",
+    "4": "\u2713",  # check
+    "5": "\u00D7",  # cross
+    "l": "\u25CF",  # circle
 }
 
+CHECKBOX_SELECT = "/Yes"
+
 COORDINATE_GRID_FONT_SIZE_MARGIN_RATIO = DEFAULT_FONT_SIZE / 100

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm/filler.py

@@ -1,9 +1,15 @@
 # -*- coding: utf-8 -*-
 """Contains helpers for filling a PDF form."""
 
-from typing import Dict
+from io import BytesIO
+from typing import Dict, cast
 
-from .constants import WIDGET_TYPES
+from pypdf import PdfReader, PdfWriter
+from pypdf.generic import DictionaryObject, NameObject, TextStringObject
+
+from .constants import (ANNOTATION_KEY, CHECKBOX_SELECT, SELECTED_IDENTIFIER,
+                        TEXT_VALUE_IDENTIFIER, TEXT_VALUE_SHOW_UP_IDENTIFIER,
+                        WIDGET_TYPES)
 from .coordinate import (get_draw_checkbox_radio_coordinates,
                          get_draw_sig_coordinates_resolutions,
                          get_draw_text_coordinates,
@@ -11,10 +17,12 @@ from .coordinate import (get_draw_checkbox_radio_coordinates,
 from .font import checkbox_radio_font_size
 from .image import any_image_to_jpg
 from .middleware.checkbox import Checkbox
+from .middleware.dropdown import Dropdown
 from .middleware.radio import Radio
 from .middleware.signature import Signature
+from .middleware.text import Text
 from .template import get_widget_key, get_widgets_by_page
-from .utils import checkbox_radio_to_draw
+from .utils import checkbox_radio_to_draw, stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
 
 
@@ -44,10 +52,14 @@ def fill(
             _to_draw = x = y = None
 
             if isinstance(widgets[key], (Checkbox, Radio)):
-                font_size = checkbox_radio_font_size(_widget)
+                font_size = (
+                    checkbox_radio_font_size(_widget)
+                    if widgets[key].size is None
+                    else widgets[key].size
+                )
                 _to_draw = checkbox_radio_to_draw(widgets[key], font_size)
                 x, y = get_draw_checkbox_radio_coordinates(_widget, _to_draw)
-                if isinstance(widgets[key], Checkbox) and widgets[key].value:
+                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:
@@ -113,3 +125,55 @@ def fill(
         result = merge_watermarks_with_pdf(result, image_watermarks)
 
     return result
+
+
+def simple_fill(
+    template: bytes,
+    widgets: Dict[str, WIDGET_TYPES],
+) -> bytes:
+    """Fills a PDF form in place."""
+
+    pdf = PdfReader(stream_to_io(template))
+    out = PdfWriter()
+    out.append(pdf)
+
+    radio_button_tracker = {}
+
+    for page in out.pages:
+        for annot in page.get(ANNOTATION_KEY, []):  # noqa
+            annot = cast(DictionaryObject, annot.get_object())
+            key = get_widget_key(annot.get_object())
+
+            widget = widgets.get(key)
+            if widget is None:
+                continue
+
+            if isinstance(widget, Checkbox) and widget.value is True:
+                annot[NameObject(SELECTED_IDENTIFIER)] = NameObject(CHECKBOX_SELECT)
+            elif isinstance(widget, Radio):
+                if key not in radio_button_tracker:
+                    radio_button_tracker[key] = 0
+                radio_button_tracker[key] += 1
+                if widget.value == radio_button_tracker[key] - 1:
+                    annot[NameObject(SELECTED_IDENTIFIER)] = NameObject(
+                        f"/{widget.value}"
+                    )
+            elif isinstance(widget, Dropdown) and widget.value is not None:
+                annot[NameObject(TEXT_VALUE_IDENTIFIER)] = TextStringObject(
+                    widget.choices[widget.value]
+                )
+                annot[NameObject(TEXT_VALUE_SHOW_UP_IDENTIFIER)] = TextStringObject(
+                    widget.choices[widget.value]
+                )
+            elif isinstance(widget, Text) and widget.value:
+                annot[NameObject(TEXT_VALUE_IDENTIFIER)] = TextStringObject(
+                    widget.value
+                )
+                annot[NameObject(TEXT_VALUE_SHOW_UP_IDENTIFIER)] = TextStringObject(
+                    widget.value
+                )
+
+    with BytesIO() as f:
+        out.write(f)
+        f.seek(0)
+        return f.read()

PyPDFForm-1.4.13/PyPDFForm/middleware/checkbox.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+"""Contains checkbox middleware."""
+
+from typing import Union
+
+from .base import Widget
+
+
+class Checkbox(Widget):
+    """A class to represent a checkbox widget."""
+
+    BUTTON_STYLE_MAPPING = {
+        "check": "4",
+        "cross": "5",
+        "circle": "l",
+    }
+
+    def __init__(
+        self,
+        name: str,
+        value: bool = None,
+    ) -> None:
+        """Constructs all attributes for the checkbox."""
+
+        super().__init__(name, value)
+
+        self.size = None
+        self._button_style = None
+
+    @property
+    def schema_definition(self) -> dict:
+        """Json schema definition of the checkbox."""
+
+        return {"type": "boolean"}
+
+    @property
+    def sample_value(self) -> bool:
+        """Sample value of the checkbox."""
+
+        return True
+
+    @property
+    def button_style(self) -> Union[str, None]:
+        """Shape of the tick for the checkbox."""
+
+        return self._button_style
+
+    @button_style.setter
+    def button_style(self, value) -> None:
+        """Converts user specified button styles to acroform values."""
+
+        if value in self.BUTTON_STYLE_MAPPING:
+            self._button_style = self.BUTTON_STYLE_MAPPING[value]
+        elif value in self.BUTTON_STYLE_MAPPING.values():
+            self._button_style = value

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm/middleware/radio.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 """Contains radio middleware."""
 
-from .base import Widget
+from .checkbox import Checkbox
 
 
-class Radio(Widget):
+class Radio(Checkbox):
     """A class to represent a radiobutton widget."""
 
     def __init__(
@@ -16,7 +16,6 @@ class Radio(Widget):
 
         super().__init__(name, value)
 
-        self.button_style = None
         self.number_of_options = 0
 
     @property

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm/utils.py

@@ -38,7 +38,7 @@ def checkbox_radio_to_draw(
     new_widget.font_size = font_size
     new_widget.font_color = DEFAULT_FONT_COLOR
     new_widget.value = BUTTON_STYLES.get(widget.button_style) or (
-        DEFAULT_CHECKBOX_STYLE if isinstance(widget, Checkbox) else DEFAULT_RADIO_STYLE
+        DEFAULT_CHECKBOX_STYLE if type(widget) is Checkbox else DEFAULT_RADIO_STYLE
     )
 
     return new_widget

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm/wrapper.py

@@ -11,7 +11,7 @@ from .constants import (DEFAULT_FONT, DEFAULT_FONT_COLOR, DEFAULT_FONT_SIZE,
                         DEPRECATION_NOTICE, VERSION_IDENTIFIER_PREFIX,
                         VERSION_IDENTIFIERS)
 from .coordinate import generate_coordinate_grid
-from .filler import fill
+from .filler import fill, simple_fill
 from .font import register_font
 from .image import any_image_to_jpg, rotate_image
 from .middleware.dropdown import Dropdown
@@ -26,7 +26,40 @@ from .widgets.checkbox import CheckBoxWidget
 from .widgets.text import TextWidget
 
 
-class PdfWrapper:
+class FormWrapper:
+    """A simple base wrapper for just filling a PDF form."""
+
+    def __init__(
+        self,
+        template: Union[bytes, str, BinaryIO] = b"",
+    ) -> None:
+        """Constructs all attributes for the object."""
+
+        self.stream = fp_or_f_obj_or_stream_to_stream(template)
+
+    def read(self) -> bytes:
+        """Reads the file stream of a PDF form."""
+
+        return self.stream
+
+    def fill(
+        self,
+        data: Dict[str, Union[str, bool, int]],
+    ) -> FormWrapper:
+        """Fills a PDF form."""
+
+        widgets = build_widgets(self.stream) if self.stream else {}
+
+        for key, value in data.items():
+            if key in widgets:
+                widgets[key].value = value
+
+        self.stream = simple_fill(self.read(), widgets)
+
+        return self
+
+
+class PdfWrapper(FormWrapper):
     """A class to represent a PDF form."""
 
     def __init__(
@@ -36,7 +69,7 @@ class PdfWrapper:
     ) -> None:
         """Constructs all attributes for the object."""
 
-        self.stream = fp_or_f_obj_or_stream_to_stream(template)
+        super().__init__(template)
         self.widgets = build_widgets(self.stream) if self.stream else {}
 
         self.global_font = kwargs.get("global_font")
@@ -49,11 +82,6 @@ class PdfWrapper:
                 each.font_size = self.global_font_size
                 each.font_color = self.global_font_color
 
-    def read(self) -> bytes:
-        """Reads the file stream of a PDF form."""
-
-        return self.stream
-
     @property
     def elements(self) -> dict:
         """ToDo: deprecate this."""

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm.egg-info/PKG-INFO

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

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/PyPDFForm.egg-info/SOURCES.txt

@@ -31,8 +31,12 @@ PyPDFForm/widgets/checkbox.py
 PyPDFForm/widgets/text.py
 tests/test_create_widget.py
 tests/test_dropdown.py
+tests/test_dropdown_simple.py
 tests/test_fill_max_length_text_field.py
+tests/test_fill_max_length_text_field_simple.py
 tests/test_functional.py
+tests/test_functional_simple.py
 tests/test_paragraph.py
+tests/test_paragraph_simple.py
 tests/test_preview.py
 tests/test_signature.py

PyPDFForm-1.4.13/tests/test_dropdown_simple.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from PyPDFForm import FormWrapper
+
+
+def test_dropdown_not_specified(sample_template_with_dropdown):
+    assert (
+        FormWrapper(sample_template_with_dropdown)
+        .fill(
+            {
+                "test_1": "test_1",
+                "test_2": "test_2",
+                "test_3": "test_3",
+                "check_1": True,
+                "check_2": True,
+                "check_3": True,
+                "radio_1": 1,
+            }
+        )
+        .read()
+    )
+
+
+def test_dropdown_one(sample_template_with_dropdown, pdf_samples, request):
+    expected_path = os.path.join(pdf_samples, "simple", "dropdown", "dropdown_one.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_dropdown).fill(
+            {
+                "test_1": "test_1",
+                "test_2": "test_2",
+                "test_3": "test_3",
+                "check_1": True,
+                "check_2": True,
+                "check_3": True,
+                "radio_1": 1,
+                "dropdown_1": 0,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_dropdown_two(sample_template_with_dropdown, pdf_samples, request):
+    expected_path = os.path.join(pdf_samples, "simple", "dropdown", "dropdown_two.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_dropdown).fill(
+            {
+                "test_1": "test_1",
+                "test_2": "test_2",
+                "test_3": "test_3",
+                "check_1": True,
+                "check_2": True,
+                "check_3": True,
+                "radio_1": 1,
+                "dropdown_1": 1,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_dropdown_three(sample_template_with_dropdown, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "dropdown", "dropdown_three.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_dropdown).fill(
+            {
+                "test_1": "test_1",
+                "test_2": "test_2",
+                "test_3": "test_3",
+                "check_1": True,
+                "check_2": True,
+                "check_3": True,
+                "radio_1": 1,
+                "dropdown_1": 2,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_dropdown_four(sample_template_with_dropdown, pdf_samples, request):
+    expected_path = os.path.join(pdf_samples, "simple", "dropdown", "dropdown_four.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_dropdown).fill(
+            {
+                "test_1": "test_1",
+                "test_2": "test_2",
+                "test_3": "test_3",
+                "check_1": True,
+                "check_2": True,
+                "check_3": True,
+                "radio_1": 1,
+                "dropdown_1": 3,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_dropdown_alignment(dropdown_alignment, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "dropdown", "dropdown_alignment_expected.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(dropdown_alignment).fill(
+            {
+                "dropdown_left": 0,
+                "dropdown_center": 1,
+                "dropdown_right": 2,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected

PyPDFForm-1.4.13/tests/test_fill_max_length_text_field_simple.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from PyPDFForm import FormWrapper
+
+
+def test_fill_max_length_text_field_all_chars(
+    sample_template_with_max_length_text_field, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples,
+        "simple",
+        "max_length_text_field_related",
+        "max_length_text_field_all_chars.pdf",
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_max_length_text_field).fill(
+            {
+                "FirstName": "John",
+                "MiddleName": "Joe",
+                "LastName": "XXXXXXXXXX",
+                "Awesomeness": True,
+                "Gender": 0,
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.stream) == len(expected)
+        assert obj.stream == expected
+
+
+def test_fill_max_length_text_field_odd_chars(
+    sample_template_with_max_length_text_field, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples,
+        "simple",
+        "max_length_text_field_related",
+        "max_length_text_field_odd_chars.pdf",
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_max_length_text_field).fill(
+            {
+                "FirstName": "John",
+                "MiddleName": "Joe",
+                "LastName": "XXX",
+                "Awesomeness": True,
+                "Gender": 0,
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.stream) == len(expected)
+        assert obj.stream == expected
+
+
+def test_fill_max_length_text_field_even_chars(
+    sample_template_with_max_length_text_field, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples,
+        "simple",
+        "max_length_text_field_related",
+        "max_length_text_field_even_chars.pdf",
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_max_length_text_field).fill(
+            {
+                "FirstName": "John",
+                "MiddleName": "Joe",
+                "LastName": "XXXX",
+                "Awesomeness": True,
+                "Gender": 0,
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.stream) == len(expected)
+        assert obj.stream == expected

{PyPDFForm-1.4.11 → PyPDFForm-1.4.13}/tests/test_functional.py

@@ -550,3 +550,63 @@ def test_generate_coordinate_grid_margin_50(template_stream, pdf_samples, reques
 
         assert len(obj.read()) == len(expected)
         assert obj.stream == expected
+
+
+def test_checkbox_change_size_and_button_style(template_stream, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "test_checkbox_change_size_and_button_style.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(template_stream)
+        obj.widgets["check"].size = 50
+        obj.widgets["check"].button_style = "cross"
+        obj.widgets["check_2"].size = 40
+        obj.widgets["check_2"].button_style = "circle"
+        obj.widgets["check_3"].size = 60
+        obj.widgets["check_3"].button_style = "check"
+        obj = obj.fill(
+            {
+                "check": True,
+                "check_2": True,
+                "check_3": True,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_radio_change_size_and_button_style(
+    template_with_radiobutton_stream, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "test_radio_change_size_and_button_style.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(template_with_radiobutton_stream)
+        obj.widgets["radio_1"].size = 50
+        obj.widgets["radio_1"].button_style = "cross"
+        obj.widgets["radio_2"].size = 40
+        obj.widgets["radio_2"].button_style = "circle"
+        obj.widgets["radio_3"].size = 60
+        obj.widgets["radio_3"].button_style = "check"
+        obj = obj.fill(
+            {
+                "radio_1": 0,
+                "radio_2": 1,
+                "radio_3": 2,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected

PyPDFForm-1.4.13/tests/test_functional_simple.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from PyPDFForm import FormWrapper
+
+
+def test_fill(template_stream, pdf_samples, data_dict, request):
+    expected_path = os.path.join(pdf_samples, "simple", "sample_filled.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(template_stream).fill(data_dict)
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.stream) == len(expected)
+        assert obj.stream == expected
+
+
+def test_fill_radiobutton(pdf_samples, template_with_radiobutton_stream, request):
+    expected_path = os.path.join(pdf_samples, "simple", "sample_filled_radiobutton.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(template_with_radiobutton_stream).fill(
+            {
+                "radio_1": 0,
+                "radio_2": 1,
+                "radio_3": 2,
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_fill_right_aligned(
+    sample_template_with_right_aligned_text_field, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "sample_filled_right_aligned.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_right_aligned_text_field).fill(
+            {
+                "name": "Hans Mustermann",
+                "fulladdress": "Musterstr. 12, 82903 Musterdorf, Musterland",
+                "advisorname": "Karl Test",
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_fill_font_color(sample_template_with_font_colors, pdf_samples, request):
+    expected_path = os.path.join(pdf_samples, "simple", "test_fill_font_color.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_font_colors).fill(
+            {
+                "red_12": "red",
+                "green_14": "green",
+                "blue_16": "blue",
+                "mixed_auto": "mixed",
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected
+
+
+def test_fill_complex_fonts(sample_template_with_complex_fonts, pdf_samples, request):
+    expected_path = os.path.join(pdf_samples, "simple", "test_fill_complex_fonts.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_complex_fonts).fill(
+            {
+                "Courier": "Test",
+                "Courier-Bold": "Test",
+                "Courier-BoldOblique": "Test",
+                "Courier-Oblique": "Test",
+                "Helvetica": "Test",
+                "Helvetica-Bold": "Test",
+                "Helvetica-BoldOblique": "Test",
+                "Helvetica-Oblique": "Test",
+                "Times-Bold": "Test",
+                "Times-BoldItalic": "Test",
+                "Times-Italic": "Test",
+                "Times-Roman": "Test",
+            },
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected

PyPDFForm-1.4.13/tests/test_paragraph_simple.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=line-too-long
+
+import os
+
+from PyPDFForm import FormWrapper
+
+
+def test_paragraph_y_coordinate(sample_template_with_paragraph, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_y_coordinate.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_paragraph).fill(
+            {"paragraph_1": "test paragraph"}
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_paragraph_auto_wrap(sample_template_with_paragraph, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_auto_wrap.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_paragraph).fill(
+            {
+                "paragraph_1": "t xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx t"
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.stream == expected
+
+
+def test_paragraph_auto_font(
+    sample_template_with_paragraph_auto_font, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_auto_font.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_paragraph_auto_font).fill(
+            {"paragraph": "test paragraph"}
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected
+
+
+def test_paragraph_auto_font_auto_wrap(
+    sample_template_with_paragraph_auto_font, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_auto_font_auto_wrap.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_paragraph_auto_font).fill(
+            {
+                "paragraph": "t xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx t"
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected
+
+
+def test_paragraph_complex(sample_template_paragraph_complex, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_complex.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_paragraph_complex).fill(
+            {
+                "paragraph_font_auto_left": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "paragraph_font_auto_right": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "paragraph_font_auto_center": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "paragraph_font_ten_left": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "paragraph_font_ten_right": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "paragraph_font_ten_center": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected
+
+
+def test_paragraph_max_length(
+    sample_template_with_paragraph_max_length, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "simple", "paragraph", "test_paragraph_max_length.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = FormWrapper(sample_template_with_paragraph_max_length).fill(
+            {
+                "paragraph": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+            }
+        )
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        if os.name != "nt":
+            assert len(obj.read()) == len(expected)
+            assert obj.stream == expected

PyPDFForm-1.4.11/PyPDFForm/__init__.py

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

PyPDFForm-1.4.11/PyPDFForm/middleware/checkbox.py

@@ -1,31 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Contains checkbox middleware."""
-
-from .base import Widget
-
-
-class Checkbox(Widget):
-    """A class to represent a checkbox widget."""
-
-    def __init__(
-        self,
-        name: str,
-        value: bool = None,
-    ) -> None:
-        """Constructs all attributes for the checkbox."""
-
-        super().__init__(name, value)
-
-        self.button_style = None
-
-    @property
-    def schema_definition(self) -> dict:
-        """Json schema definition of the checkbox."""
-
-        return {"type": "boolean"}
-
-    @property
-    def sample_value(self) -> bool:
-        """Sample value of the checkbox."""
-
-        return True