PyPDFForm 3.0.1__tar.gz → 3.1.1__tar.gz

{pypdfform-3.0.1 → pypdfform-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.0.1
+Version: 3.1.1
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/__init__.py

@@ -20,7 +20,7 @@ The library supports various PDF form features, including:
 PyPDFForm aims to simplify PDF form manipulation, making it accessible to developers of all skill levels.
 """
 
-__version__ = "3.0.1"
+__version__ = "3.1.1"
 
 from .middleware.text import Text  # exposing for setting global font attrs
 from .wrapper import PdfWrapper

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/constants.py

@@ -67,6 +67,7 @@ Opt = "/Opt"
 AS = "/AS"
 Yes = "/Yes"
 Off = "/Off"
+XObject = "/XObject"
 
 # Font dict
 Length1 = "/Length1"
@@ -105,3 +106,5 @@ IMAGE_FIELD_IDENTIFIER = "event.target.buttonImportIcon();"
 
 COORDINATE_GRID_FONT_SIZE_MARGIN_RATIO = DEFAULT_FONT_SIZE / 100
 UNIQUE_SUFFIX_LENGTH = 20
+
+SLASH = "/"

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/filler.py

@@ -15,6 +15,7 @@ from pypdf import PdfReader, PdfWriter
 from pypdf.generic import DictionaryObject
 
 from .constants import WIDGET_TYPES, Annots
+from .hooks import flatten_generic, flatten_radio
 from .image import get_draw_image_resolutions, get_image_dimensions
 from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
@@ -22,9 +23,8 @@ from .middleware.image import Image
 from .middleware.radio import Radio
 from .middleware.signature import Signature
 from .middleware.text import Text
-from .patterns import (flatten_generic, flatten_radio, update_checkbox_value,
-                       update_dropdown_value, update_radio_value,
-                       update_text_value)
+from .patterns import (update_checkbox_value, update_dropdown_value,
+                       update_radio_value, update_text_value)
 from .template import get_widget_key
 from .utils import stream_to_io
 from .watermark import create_watermarks_and_draw, merge_watermarks_with_pdf
@@ -145,7 +145,9 @@ def fill(
 
             # flatten all
             if flatten:
-                (flatten_radio if isinstance(widget, Radio) else flatten_generic)(annot)
+                (flatten_radio if isinstance(widget, Radio) else flatten_generic)(
+                    annot, True
+                )
             if widget.value is None:
                 continue
 

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/hooks.py

@@ -4,7 +4,8 @@ This module defines widget hooks that allow for dynamic modification of PDF form
 
 It provides functions to trigger these hooks, enabling changes to text field properties
 like font, font size, color, alignment, and multiline settings, as well as the size
-of checkbox and radio button widgets. These hooks are triggered during the PDF form
+of checkbox and radio button widgets. It also provides functions for flattening
+generic and radio button widgets. These hooks are triggered during the PDF form
 filling process, allowing for customization of the form's appearance and behavior.
 """
 
@@ -17,7 +18,7 @@ from pypdf.generic import (ArrayObject, DictionaryObject, FloatObject,
                            NameObject, NumberObject, TextStringObject)
 
 from .constants import (COMB, DA, FONT_COLOR_IDENTIFIER, FONT_SIZE_IDENTIFIER,
-                        MULTILINE, Annots, Ff, Opt, Parent, Q, Rect)
+                        MULTILINE, READ_ONLY, Annots, Ff, Opt, Parent, Q, Rect)
 from .template import get_widget_key
 from .utils import stream_to_io
 
@@ -249,8 +250,78 @@ def update_dropdown_choices(annot: DictionaryObject, val: list) -> None:
 
     Args:
         annot (DictionaryObject): The annotation dictionary for the dropdown field.
-        val (list): A list of strings representing the new choices for the dropdown.
+        val (list): A list of strings or tuples representing the new choices for the dropdown.
     """
     annot[NameObject(Opt)] = ArrayObject(
-        [ArrayObject([TextStringObject(each), TextStringObject(each)]) for each in val]
+        [
+            (
+                ArrayObject([TextStringObject(each[1]), TextStringObject(each[0])])
+                if isinstance(each, tuple)
+                else ArrayObject([TextStringObject(each), TextStringObject(each)])
+            )
+            for each in val
+        ]
     )
+
+
+def flatten_radio(annot: DictionaryObject, val: bool) -> None:
+    """
+    Flattens a radio button annotation by setting or unsetting the ReadOnly flag,
+    making it non-editable or editable based on the `val` parameter.
+
+    This function modifies the Ff (flags) entry in the radio button's annotation
+    dictionary or its parent dictionary if `Parent` exists in `annot`, to set or
+    unset the ReadOnly flag, preventing or allowing the user from changing the
+    selected option.
+
+    Args:
+        annot (DictionaryObject): The radio button annotation dictionary.
+        val (bool): True to flatten (make read-only), False to unflatten (make editable).
+    """
+    if Parent in annot:
+        annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
+            (
+                int(annot[NameObject(Parent)].get(NameObject(Ff), 0)) | READ_ONLY
+                if val
+                else int(annot[NameObject(Parent)].get(NameObject(Ff), 0)) & ~READ_ONLY
+            )
+        )
+    else:
+        annot[NameObject(Ff)] = NumberObject(
+            (
+                int(annot.get(NameObject(Ff), 0)) | READ_ONLY
+                if val
+                else int(annot.get(NameObject(Ff), 0)) & ~READ_ONLY
+            )
+        )
+
+
+def flatten_generic(annot: DictionaryObject, val: bool) -> None:
+    """
+    Flattens a generic annotation by setting or unsetting the ReadOnly flag,
+    making it non-editable or editable based on the `val` parameter.
+
+    This function modifies the Ff (flags) entry in the annotation dictionary to
+    set or unset the ReadOnly flag, preventing or allowing the user from
+    interacting with the form field.
+
+    Args:
+        annot (DictionaryObject): The annotation dictionary.
+        val (bool): True to flatten (make read-only), False to unflatten (make editable).
+    """
+    if Parent in annot and Ff not in annot:
+        annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
+            (
+                int(annot.get(NameObject(Ff), 0)) | READ_ONLY
+                if val
+                else int(annot.get(NameObject(Ff), 0)) & ~READ_ONLY
+            )
+        )
+    else:
+        annot[NameObject(Ff)] = NumberObject(
+            (
+                int(annot.get(NameObject(Ff), 0)) | READ_ONLY
+                if val
+                else int(annot.get(NameObject(Ff), 0)) & ~READ_ONLY
+            )
+        )

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/middleware/base.py

@@ -21,7 +21,9 @@ class Widget:
     as name, value, and schema definition.
     """
 
-    SET_ATTR_TRIGGER_HOOK_MAP = {}
+    SET_ATTR_TRIGGER_HOOK_MAP = {
+        "readonly": "flatten_generic",
+    }
 
     def __init__(
         self,
@@ -39,6 +41,7 @@ class Widget:
         self._name = name
         self._value = value
         self.desc = None
+        self.readonly = None
         self.hooks_to_trigger = []
 
     def __setattr__(self, name: str, value: Any) -> None:

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/middleware/checkbox.py

@@ -20,10 +20,6 @@ class Checkbox(Widget):
     implements the schema_definition and sample_value properties.
     """
 
-    SET_ATTR_TRIGGER_HOOK_MAP = {
-        "size": "update_check_radio_size",
-    }
-
     def __init__(
         self,
         name: str,
@@ -39,6 +35,11 @@ class Checkbox(Widget):
         Attributes:
             size (int): The size of the checkbox. Defaults to None.
         """
+        self.SET_ATTR_TRIGGER_HOOK_MAP.update(
+            {
+                "size": "update_check_radio_size",
+            }
+        )
         super().__init__(name, value)
 
         self.size = None

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/middleware/dropdown.py

@@ -26,11 +26,6 @@ class Dropdown(Widget):
         sample_value: Returns a sample value for the dropdown.
     """
 
-    SET_ATTR_TRIGGER_HOOK_MAP = {
-        "font": "update_text_field_font",
-        "choices": "update_dropdown_choices",
-    }
-
     def __init__(
         self,
         name: str,
@@ -47,6 +42,12 @@ class Dropdown(Widget):
             font (str): The font of the dropdown field.
             choices (List[str]): The list of choices for the dropdown.
         """
+        self.SET_ATTR_TRIGGER_HOOK_MAP.update(
+            {
+                "font": "update_text_field_font",
+                "choices": "update_dropdown_choices",
+            }
+        )
         super().__init__(name, value)
 
         self.font = None

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/middleware/radio.py

@@ -34,6 +34,11 @@ class Radio(Checkbox):
         Attributes:
             number_of_options (int): The number of options for the radio button.
         """
+        self.SET_ATTR_TRIGGER_HOOK_MAP.update(
+            {
+                "readonly": "flatten_radio",
+            }
+        )
         super().__init__(name, value)
 
         self.number_of_options = 0

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/middleware/text.py

@@ -22,15 +22,6 @@ class Text(Widget):
     font_size, font_color, comb, alignment, and multiline.
     """
 
-    SET_ATTR_TRIGGER_HOOK_MAP = {
-        "font": "update_text_field_font",
-        "font_size": "update_text_field_font_size",
-        "font_color": "update_text_field_font_color",
-        "comb": "update_text_field_comb",
-        "alignment": "update_text_field_alignment",
-        "multiline": "update_text_field_multiline",
-    }
-
     def __init__(
         self,
         name: str,
@@ -52,6 +43,16 @@ class Text(Widget):
             multiline (bool): Whether the text field is multiline. Defaults to None.
             max_length (int): The maximum length of the text field. Defaults to None.
         """
+        self.SET_ATTR_TRIGGER_HOOK_MAP.update(
+            {
+                "font": "update_text_field_font",
+                "font_size": "update_text_field_font_size",
+                "font_color": "update_text_field_font_color",
+                "comb": "update_text_field_comb",
+                "alignment": "update_text_field_alignment",
+                "multiline": "update_text_field_multiline",
+            }
+        )
         super().__init__(name, value)
 
         self.font = None

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/patterns.py

@@ -5,15 +5,17 @@ This module defines patterns and utility functions for interacting with PDF form
 It includes patterns for identifying different types of widgets (e.g., text fields,
 checkboxes, radio buttons, dropdowns, images, and signatures) based on their
 properties in the PDF's annotation dictionary. It also provides utility functions
-for updating and flattening these widgets.
+for updating these widgets.
 """
 
+from typing import Union
+
 from pypdf.generic import (ArrayObject, DictionaryObject, NameObject,
                            NumberObject, TextStringObject)
 
-from .constants import (AP, AS, DV, FT, IMAGE_FIELD_IDENTIFIER, JS, READ_ONLY,
-                        TU, A, Btn, Ch, Ff, I, N, Off, Opt, Parent, Sig, T, Tx,
-                        V, Yes)
+from .constants import (AP, AS, DV, FT, IMAGE_FIELD_IDENTIFIER, JS, SLASH, TU,
+                        A, Btn, Ch, I, N, Off, Opt, Parent, Resources, Sig, T,
+                        Tx, V, XObject, Yes)
 from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
 from .middleware.image import Image
@@ -22,6 +24,14 @@ from .middleware.signature import Signature
 from .middleware.text import Text
 
 WIDGET_TYPE_PATTERNS = [
+    # barcode? see pdf_samples/scenario/issues/1087.pdf
+    (
+        (
+            {FT: Tx},
+            {AP: {N: {Resources: {XObject: True}}}},
+        ),
+        None,
+    ),
     (
         ({A: {JS: IMAGE_FIELD_IDENTIFIER}},),
         Image,
@@ -43,7 +53,7 @@ WIDGET_TYPE_PATTERNS = [
         (
             {FT: Btn},
             {Parent: {FT: Btn}},
-            {AS: (Yes, Off)},
+            {AS: (Yes, Off, SLASH)},
         ),
         Radio,
     ),
@@ -77,7 +87,7 @@ WIDGET_TYPE_PATTERNS = [
     (
         (
             {Parent: {FT: Btn}},
-            {AS: (Yes, Off)},
+            {AS: (Yes, Off, SLASH)},
         ),
         Radio,
     ),
@@ -114,6 +124,23 @@ def update_checkbox_value(annot: DictionaryObject, check: bool = False) -> None:
             break
 
 
+def get_checkbox_value(annot: DictionaryObject) -> Union[bool, None]:
+    """
+    Retrieves the boolean value of a checkbox annotation.
+
+    This function checks the value (V) of the checkbox annotation. If the value
+    is not 'Off', it means the checkbox is checked, and True is returned.
+    Otherwise, if the value is 'Off' or not present, None is returned.
+
+    Args:
+        annot (DictionaryObject): The checkbox annotation dictionary.
+
+    Returns:
+        Union[bool, None]: True if the checkbox is checked, None otherwise.
+    """
+    return True if annot.get(V, Off) != Off else None
+
+
 def update_radio_value(annot: DictionaryObject) -> None:
     """
     Updates the value of a radio button annotation, selecting it.
@@ -134,6 +161,28 @@ def update_radio_value(annot: DictionaryObject) -> None:
             break
 
 
+def get_radio_value(annot: DictionaryObject) -> bool:
+    """
+    Retrieves the boolean value of a radio button annotation.
+
+    This function iterates through the appearance states (AP) of the radio button
+    annotation. If the value (V) of the parent dictionary matches any of these
+    appearance states, it means the radio button is selected, and True is returned.
+    Otherwise, False is returned.
+
+    Args:
+        annot (DictionaryObject): The radio button annotation dictionary.
+
+    Returns:
+        bool: True if the radio button is selected, False otherwise.
+    """
+    for each in annot.get(AP, {}).get(N, []):
+        if annot.get(Parent, {}).get(V) == each:
+            return True
+
+    return False
+
+
 def update_dropdown_value(annot: DictionaryObject, widget: Dropdown) -> None:
     """
     Updates the value of a dropdown annotation, selecting an option from the list.
@@ -158,6 +207,29 @@ def update_dropdown_value(annot: DictionaryObject, widget: Dropdown) -> None:
         annot[NameObject(I)] = ArrayObject([NumberObject(widget.value)])
 
 
+def get_dropdown_value(annot: DictionaryObject, widget: Dropdown) -> None:
+    """
+    Retrieves the selected value of a dropdown annotation and updates the widget.
+
+    This function determines the current value of the dropdown, considering
+    whether it's a child annotation or a top-level one. It then iterates
+    through the widget's choices to find a match and sets the widget's
+    value to the index of the matched choice.
+
+    Args:
+        annot (DictionaryObject): The dropdown annotation dictionary.
+        widget (Dropdown): The Dropdown widget object to update with the retrieved value.
+    """
+    if Parent in annot and T not in annot:
+        to_compare = annot.get(Parent, {}).get(V)
+    else:
+        to_compare = annot.get(V)
+
+    for i, each in enumerate(widget.choices):
+        if each == to_compare:
+            widget.value = i or None  # set None when 0
+
+
 def update_text_value(annot: DictionaryObject, widget: Text) -> None:
     """
     Updates the value of a text annotation, setting the text content.
@@ -177,40 +249,22 @@ def update_text_value(annot: DictionaryObject, widget: Text) -> None:
         annot[NameObject(AP)] = TextStringObject(widget.value)
 
 
-def flatten_radio(annot: DictionaryObject) -> None:
+def get_text_value(annot: DictionaryObject, widget: Text) -> None:
     """
-    Flattens a radio button annotation by setting the ReadOnly flag, making it non-editable.
+    Retrieves the text value of a text annotation and updates the widget.
 
-    This function modifies the Ff (flags) entry in the radio button's parent
-    dictionary to set the ReadOnly flag, preventing the user from changing the
-    selected option.
+    This function determines the current text value of the annotation, considering
+    whether it's a child annotation or a top-level one, and then sets the
+    widget's value accordingly.
 
     Args:
-        annot (DictionaryObject): The radio button annotation dictionary.
-    """
-    annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
-        int(annot[NameObject(Parent)].get(NameObject(Ff), 0)) | READ_ONLY
-    )
-
-
-def flatten_generic(annot: DictionaryObject) -> None:
-    """
-    Flattens a generic annotation by setting the ReadOnly flag, making it non-editable.
-
-    This function modifies the Ff (flags) entry in the annotation dictionary to
-    set the ReadOnly flag, preventing the user from interacting with the form field.
-
-    Args:
-        annot (DictionaryObject): The annotation dictionary.
+        annot (DictionaryObject): The text annotation dictionary.
+        widget (Text): The Text widget object to update with the retrieved value.
     """
-    if Parent in annot and Ff not in annot:
-        annot[NameObject(Parent)][NameObject(Ff)] = NumberObject(
-            int(annot.get(NameObject(Ff), 0)) | READ_ONLY
-        )
+    if Parent in annot and T not in annot:
+        widget.value = annot[Parent].get(V)
     else:
-        annot[NameObject(Ff)] = NumberObject(
-            int(annot.get(NameObject(Ff), 0)) | READ_ONLY
-        )
+        widget.value = annot.get(V)
 
 
 def update_annotation_name(annot: DictionaryObject, val: str) -> None:

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/template.py

@@ -16,12 +16,14 @@ from pypdf import PdfReader, PdfWriter
 from pypdf.generic import DictionaryObject
 
 from .constants import WIDGET_TYPES, Annots, MaxLen, Parent, T
+from .middleware.checkbox import Checkbox
 from .middleware.dropdown import Dropdown
 from .middleware.radio import Radio
 from .middleware.text import Text
 from .patterns import (DROPDOWN_CHOICE_PATTERNS, WIDGET_DESCRIPTION_PATTERNS,
                        WIDGET_KEY_PATTERNS, WIDGET_TYPE_PATTERNS,
-                       update_annotation_name)
+                       get_checkbox_value, get_dropdown_value, get_radio_value,
+                       get_text_value, update_annotation_name)
 from .utils import extract_widget_property, find_pattern_match, stream_to_io
 
 
@@ -61,11 +63,16 @@ def build_widgets(
                 if isinstance(_widget, Text):
                     # mostly for schema for now
                     _widget.max_length = get_text_field_max_length(widget)
+                    get_text_value(widget, _widget)
+
+                if type(_widget) is Checkbox:
+                    _widget.value = get_checkbox_value(widget)
 
                 if isinstance(_widget, Dropdown):
                     # actually used for filling value
                     # doesn't trigger hook
                     _widget.__dict__["choices"] = get_dropdown_choices(widget)
+                    get_dropdown_value(widget, _widget)
 
                 if isinstance(_widget, Radio):
                     if key not in results:
@@ -73,6 +80,9 @@ def build_widgets(
 
                     # for schema
                     results[key].number_of_options += 1
+
+                    if get_radio_value(widget):
+                        results[key].value = results[key].number_of_options - 1
                     continue
 
                 results[key] = _widget
@@ -172,7 +182,7 @@ def construct_widget(widget: dict, key: str) -> Union[WIDGET_TYPES, None]:
         for pattern in patterns:
             check = check and find_pattern_match(pattern, widget)
         if check:
-            result = _type(key)
+            result = _type(key) if _type else None
             break
     return result
 

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm/utils.py

@@ -23,7 +23,7 @@ from typing import Any, BinaryIO, List, Union
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import ArrayObject, DictionaryObject, NameObject
 
-from .constants import UNIQUE_SUFFIX_LENGTH, XFA, AcroForm, Annots, Root
+from .constants import SLASH, UNIQUE_SUFFIX_LENGTH, XFA, AcroForm, Annots, Root
 
 
 @lru_cache
@@ -220,6 +220,10 @@ def find_pattern_match(pattern: dict, widget: Union[dict, DictionaryObject]) ->
             else:
                 if isinstance(pattern[key], tuple):
                     result = value in pattern[key]
+                    if not result and SLASH in pattern[key] and value.startswith(SLASH):
+                        result = True
+                elif pattern[key] is True:
+                    result = True
                 else:
                     result = pattern[key] == value
         if result:

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 3.0.1
+Version: 3.1.1
 Summary: The Python library for PDF forms.
 Author: Jinge Li
 License-Expression: MIT

{pypdfform-3.0.1 → pypdfform-3.1.1}/PyPDFForm.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ PyPDFForm/widgets/text.py
 tests/test_adobe_mode.py
 tests/test_create_widget.py
 tests/test_dropdown.py
+tests/test_extract_values.py
 tests/test_fill_max_length_text_field.py
 tests/test_fill_method.py
 tests/test_functional.py

{pypdfform-3.0.1 → pypdfform-3.1.1}/tests/test_create_widget.py

@@ -832,6 +832,34 @@ def test_create_dropdown(template_stream, pdf_samples, sample_font_stream, reque
         assert obj.read() == expected
 
 
+def test_create_dropdown_with_export_values(template_stream, pdf_samples, request):
+    expected_path = os.path.join(
+        pdf_samples, "widget", "test_create_dropdown_with_export_values.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(template_stream).create_widget(
+            widget_type="dropdown",
+            name="new_dropdown_widget",
+            page_number=1,
+            x=57,
+            y=700,
+            options=[
+                ("foo", "foo_export"),
+                ("bar", "bar_export"),
+                ("foobar", "foobar_export"),
+            ],
+        )
+        assert obj.schema["properties"]["new_dropdown_widget"]["type"] == "integer"
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected
+
+
 def test_fill_cmyk_color(pdf_samples, request):
     expected_path = os.path.join(pdf_samples, "widget", "test_fill_cmyk_color.pdf")
     with open(expected_path, "rb+") as f:

{pypdfform-3.0.1 → pypdfform-3.1.1}/tests/test_dropdown.py

@@ -290,6 +290,33 @@ def test_dropdown_alignment_flatten(dropdown_alignment, pdf_samples, request):
             assert obj.read() == expected
 
 
+def test_dropdown_alignment_flatten_then_unflatten(
+    dropdown_alignment, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "dropdown", "test_dropdown_alignment_flatten_then_unflatten.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(dropdown_alignment).fill(
+            {
+                "dropdown_left": 0,
+                "dropdown_center": 1,
+                "dropdown_right": 2,
+            },
+            flatten=True,
+        )
+        obj.widgets["dropdown_center"].readonly = False
+
+        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.read() == expected
+
+
 def test_dropdown_alignment_sejda(dropdown_alignment_sejda, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "dropdown", "test_dropdown_alignment_sejda.pdf"
@@ -343,6 +370,37 @@ def test_dropdown_alignment_sejda_flatten(
         assert obj.read() == expected
 
 
+def test_dropdown_alignment_sejda_flatten_then_unflatten(
+    dropdown_alignment_sejda, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples,
+        "dropdown",
+        "test_dropdown_alignment_sejda_flatten_then_unflatten.pdf",
+    )
+    with open(
+        expected_path,
+        "rb+",
+    ) as f:
+        obj = PdfWrapper(dropdown_alignment_sejda).fill(
+            {
+                "dropdown_left": 0,
+                "dropdown_center": 1,
+                "dropdown_right": 2,
+            },
+            flatten=True,
+        )
+        obj.widgets["dropdown_center"].readonly = False
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected
+
+
 def test_change_dropdown_choices(sample_template_with_dropdown, pdf_samples, request):
     expected_path = os.path.join(
         pdf_samples, "dropdown", "test_change_dropdown_choices.pdf"
@@ -358,3 +416,25 @@ def test_change_dropdown_choices(sample_template_with_dropdown, pdf_samples, req
 
         assert len(obj.read()) == len(expected)
         assert obj.read() == expected
+
+
+def test_change_dropdown_choices_with_export_values(
+    sample_template_with_dropdown, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "dropdown", "test_change_dropdown_choices_with_export_values.pdf"
+    )
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(sample_template_with_dropdown, adobe_mode=True)
+        obj.widgets["dropdown_1"].choices = [
+            ("apple", "apple_export"),
+            ("banana", "banana_export"),
+        ]
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected

pypdfform-3.1.1/tests/test_extract_values.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+from PyPDFForm import PdfWrapper
+
+
+def test_text_check_values(pdf_samples, data_dict):
+    obj = PdfWrapper(os.path.join(pdf_samples, "test_fill.pdf"))
+
+    for k, v in data_dict.items():
+        if v is False:
+            assert obj.widgets[k].value is None
+        else:
+            assert obj.widgets[k].value == v
+
+
+def test_radio_values(pdf_samples):
+    data_dict = {
+        "radio_1": 0,
+        "radio_2": 1,
+        "radio_3": 2,
+    }
+    obj = PdfWrapper(os.path.join(pdf_samples, "test_fill_radiobutton.pdf"))
+
+    for k, v in data_dict.items():
+        assert obj.widgets[k].value == v
+
+
+def test_sejda_values(pdf_samples, sejda_data):
+    obj = PdfWrapper(os.path.join(pdf_samples, "test_fill_sejda.pdf"))
+
+    for k, v in sejda_data.items():
+        if v is False:
+            assert obj.widgets[k].value is None
+        else:
+            assert obj.widgets[k].value == v
+
+
+def test_dropdown_values(pdf_samples):
+    obj = PdfWrapper(os.path.join(pdf_samples, "dropdown", "test_dropdown_two.pdf"))
+
+    assert obj.widgets["dropdown_1"].value == 1
+
+
+def test_dropdown_default_values(pdf_samples):
+    obj = PdfWrapper(os.path.join(pdf_samples, "dropdown", "test_dropdown_one.pdf"))
+
+    assert obj.widgets["dropdown_1"].value is None
+
+
+def test_sejda_dropdown_values(pdf_samples):
+    obj = PdfWrapper(
+        os.path.join(pdf_samples, "dropdown", "test_dropdown_alignment_sejda.pdf")
+    )
+
+    assert obj.widgets["dropdown_left"].value is None
+    assert obj.widgets["dropdown_center"].value == 1
+    assert obj.widgets["dropdown_right"].value == 2
+
+
+def test_addition_operator_3_times_values(template_stream, data_dict):
+    result = PdfWrapper()
+
+    for _ in range(3):
+        result += PdfWrapper(template_stream).fill(data_dict)
+
+    obj = PdfWrapper(result.read())
+
+    for k, v in obj.widgets.items():
+        if k.split("-")[0] in data_dict:
+            assert (v.value or False) == data_dict[k.split("-")[0]]

{pypdfform-3.0.1 → pypdfform-3.1.1}/tests/test_functional.py

@@ -55,6 +55,24 @@ def test_fill_flatten(template_stream, pdf_samples, data_dict, request):
         assert obj.read() == expected
 
 
+def test_fill_flatten_then_unflatten(template_stream, pdf_samples, data_dict, request):
+    expected_path = os.path.join(pdf_samples, "test_fill_flatten_then_unflatten.pdf")
+    with open(expected_path, "rb+") as f:
+        obj = PdfWrapper(template_stream).fill(data_dict, flatten=True)
+        obj.widgets["test_2"].readonly = False
+        obj.widgets["check_3"].readonly = False
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+        assert len(obj.read()) == len(obj.read())
+        assert obj.read() == obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected
+
+
 def test_register_bad_fonts():
     assert not PdfWrapper().register_font("foo", b"foo").read()
     assert not PdfWrapper().register_font("foo", "foo").read()
@@ -324,6 +342,35 @@ def test_fill_radiobutton_flatten(
         assert obj.read() == expected
 
 
+def test_fill_radiobutton_flatten_then_unflatten(
+    template_with_radiobutton_stream, pdf_samples, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "test_fill_radiobutton_flatten_then_unflatten.pdf"
+    )
+    with open(
+        expected_path,
+        "rb+",
+    ) as f:
+        obj = PdfWrapper(template_with_radiobutton_stream).fill(
+            {
+                "radio_1": 0,
+                "radio_2": 1,
+                "radio_3": 2,
+            },
+            flatten=True,
+        )
+        obj.widgets["radio_2"].readonly = False
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected
+
+
 def test_fill_sejda(sejda_template, pdf_samples, sejda_data, request):
     expected_path = os.path.join(pdf_samples, "test_fill_sejda.pdf")
     with open(
@@ -361,6 +408,33 @@ def test_fill_sejda_flatten(sejda_template, pdf_samples, sejda_data, request):
         assert obj.read() == expected
 
 
+def test_fill_sejda_flatten_then_unflatten(
+    sejda_template, pdf_samples, sejda_data, request
+):
+    expected_path = os.path.join(
+        pdf_samples, "test_fill_sejda_flatten_then_unflatten.pdf"
+    )
+    with open(
+        expected_path,
+        "rb+",
+    ) as f:
+        obj = PdfWrapper(sejda_template).fill(
+            sejda_data,
+            flatten=True,
+        )
+        obj.widgets["buyer_name"].readonly = False
+        obj.widgets["at_future_date"].readonly = False
+        obj.widgets["purchase_option"].readonly = False
+
+        request.config.results["expected_path"] = expected_path
+        request.config.results["stream"] = obj.read()
+
+        expected = f.read()
+
+        assert len(obj.read()) == len(expected)
+        assert obj.read() == expected
+
+
 def test_draw_text_on_one_page(template_stream, pdf_samples, request):
     expected_path = os.path.join(pdf_samples, "test_draw_text_on_one_page.pdf")
     with open(expected_path, "rb+") as f: