python-pdffiller 1.1.2__tar.gz → 2.0.0__tar.gz

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-pdffiller
-Version: 1.1.2
+Version: 2.0.0
 Summary: Interact with PDF by inspecting or filling it
 Author-email: Jacques Raphanel <jraphanel@sismic.fr>
 License-Expression: MIT
@@ -26,7 +26,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: COPYING
 License-File: AUTHORS.rst
-Requires-Dist: pypdf
+Requires-Dist: pymupdf==1.24.10
 Requires-Dist: colorama
 Requires-Dist: pyyaml
 Dynamic: license-file

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/pdffiller/_version.py

@@ -3,4 +3,4 @@ __copyright__ = "Copyright 2025 SISMIC"
 __email__ = "jraphanel@sismic.fr"
 __license__ = "MIT"
 __title__ = "pdffiller"
-__version__ = "1.1.2"
+__version__ = "2.0.0"

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/pdffiller/cli/commands/dump_data_fields.py

@@ -30,7 +30,8 @@ def dump_fields_text_formatter(pdf: Pdf) -> None:
 
 def dump_fields_json_formatter(pdf: Pdf) -> None:
     """Print output text for dump_fields command as simple text"""
-
+    if not pdf:
+        return
     cli_out_write(json.dumps(pdf.schema, indent=4, ensure_ascii=False))
 
 

python_pdffiller-2.0.0/pdffiller/pdf.py

@@ -0,0 +1,221 @@
+"""
+A module for wrapping PDF form operations, providing a high-level interface
+for filling, and manipulating PDF forms.
+
+This module simplifies common tasks such as:
+- Filling PDF forms with data from a dictionary.
+- Fetching PDF forms fields
+
+The core class, `Pdf`, encapsulates a PDF document and provides
+methods for interacting with its form fields and content.
+"""
+
+from collections import OrderedDict
+
+import pymupdf
+
+from pdffiller.exceptions import PdfFillerException
+from pdffiller.io.output import PdfFillerOutput
+
+from .typing import Any, cast, Dict, List, Optional, PathLike, StreamType, Type
+from .widgets.base import Widget
+from .widgets.checkbox import CheckBoxWidget
+from .widgets.radio import RadioWidget
+from .widgets.text import TextWidget
+
+
+class PdfAttributes:  # pylint: disable=too-few-public-methods
+    """Various constants, enums, and flags to aid readability."""
+
+    READ_ONLY = 1 << 0
+
+
+class Pdf:
+    """
+    A class to wrap PDF form operations, providing a simplified interface
+    for common tasks such as filling, creating, and manipulating PDF forms.
+
+    The `Pdf` class encapsulates a PDF document and provides methods
+    for interacting with its form fields (widgets) and content.
+
+    """
+
+    TYPE_TO_OBJECT: Dict[str, Type[Widget]] = {
+        "Text": TextWidget,
+        "RadioButton": RadioWidget,
+        "CheckBox": CheckBoxWidget,
+    }
+
+    def __init__(
+        self, filename: Optional[PathLike] = None, stream: Optional[StreamType] = None
+    ) -> None:
+        """
+        Constructor method for the `Pdf` class.
+
+        Initializes a new `Pdf` object with the given template PDF and optional keyword arguments.
+
+        Args:
+            filename (Optional[PathLike]): Path to the input pdf
+            stream (Optional[StreamType]): An open file-like object containing the PDF data.
+        """
+
+        super().__init__()
+        self.widgets: OrderedDict[str, Widget] = OrderedDict()
+        self._init_helper(filename, stream)
+
+    def _init_helper(
+        self, filename: Optional[PathLike] = None, stream: Optional[StreamType] = None
+    ) -> None:
+        """
+        Helper method to initialize widgets
+
+        Args:
+            filename (Optional[PathLike]): Path to the input pdf
+            stream (Optional[StreamType]): An open file-like object containing the PDF data.
+        """
+        if not filename and not stream:
+            return
+
+        output = PdfFillerOutput()
+        output.info("loading file in memory")
+        loaded_widgets: OrderedDict[str, Widget] = OrderedDict()
+        try:
+            doc = pymupdf.open(filename=filename, stream=stream)
+        except Exception as ex:  # pylint: disable=broad-exception-caught
+            PdfFillerOutput().error(str(ex))
+            raise PdfFillerException(
+                f"failed to load {filename or 'file from input string'}"
+            ) from ex
+
+        for i, page in enumerate(doc.pages()):
+            output.verbose(f"loading page {i+1}/{doc.page_count}")
+            for widget in page.widgets():
+                button_states = widget.button_states()
+                choices = button_states["normal"] if button_states else None
+
+                if widget.field_name not in loaded_widgets:
+                    if widget.field_type_string not in self.TYPE_TO_OBJECT:
+                        output.verbose(f"unsupported {widget.field_type_string} widget type")
+                        continue
+                    new_widget = self.TYPE_TO_OBJECT[widget.field_type_string](
+                        widget.field_name, i, widget.field_value, widget.field_flags & (1 << 0)
+                    )
+                    if choices and isinstance(new_widget, CheckBoxWidget):
+                        new_widget.choices = choices
+                    elif isinstance(new_widget, TextWidget):
+                        new_widget.max_length = widget.text_maxlen
+                    loaded_widgets[widget.field_name] = new_widget
+                else:
+                    new_widget = loaded_widgets[widget.field_name]
+                    if choices and isinstance(new_widget, CheckBoxWidget):
+                        for each in choices:
+                            if new_widget.choices is not None:
+                                if each not in new_widget.choices:
+                                    new_widget.choices.append(each)
+                            else:
+                                new_widget.choices = [each]
+
+                        cast(CheckBoxWidget, loaded_widgets[widget.field_name]).choices = (
+                            new_widget.choices
+                        )
+
+        self.widgets = loaded_widgets
+
+    @property
+    def schema(self) -> List[Dict[str, Any]]:
+        """
+        Returns the JSON schema of the PDF form, describing the structure and data
+        types of the form fields.
+
+        This schema can be used to generate user interfaces or validate data before
+        filling the form.
+
+        Returns:
+            dict: A dictionary representing the JSON schema of the PDF form.
+        """
+
+        return [widget.schema_definition for widget in self.widgets.values()]
+
+    def fill(
+        self,
+        input_file: PathLike,
+        output_file: PathLike,
+        data: Dict[str, str],
+        flatten: bool = True,
+    ) -> "Pdf":
+        """
+        Fill the PDF form with data from a dictionary.
+
+        Args:
+            input_file (PathLike): The input file path.
+            output_file (PathLike): The output file path.
+            data (Dict[str, Union[str, bool, int]]): A dictionary where keys are form field names
+                and values are the data to fill the fields with.  Values can be strings, booleans,
+                or integers.
+            flatten (bool): Whether to flatten the form after filling, making the fields read-only
+                (default: False).
+
+        Returns:
+            Pdf: The `Pdf` object, allowing for method chaining.
+        """
+        try:
+            document = pymupdf.open(filename=input_file)
+        except Exception as ex:
+            PdfFillerOutput().error(str(ex))
+            raise PdfFillerException(f"failed to open {input_file}") from ex
+
+        output = PdfFillerOutput()
+
+        output.info("filling pdf with input values")
+        # Iterate over all pages and process fields
+        for page in document:
+            for field in page.widgets():
+                if field.field_name in data:
+                    value = data[field.field_name]
+
+                    # Handling checkboxes
+                    if (
+                        field.field_type
+                        == pymupdf.PDF_WIDGET_TYPE_CHECKBOX  # pylint: disable=no-member
+                    ):
+                        print(f"{field.field_name} => {field.on_state()} vs {value}")
+                        if value.strip() and "Off" != value.strip():
+                            output.verbose(
+                                f"updating checkbox with {value} from {field.field_value}"
+                            )
+                            field.field_value = True
+                        else:
+                            field.field_value = False
+
+                    # Handling radio buttons
+                    elif (
+                        field.field_type
+                        == pymupdf.PDF_WIDGET_TYPE_RADIOBUTTON  # pylint: disable=no-member
+                    ):
+                        if value == field.on_state():
+                            output.verbose(
+                                f"updating radiobutton with {value} from {field.field_value}"
+                            )
+                            field.field_value = value
+
+                    # Handling other fields types
+                    else:
+                        output.verbose(
+                            f"updating {field.field_name} with {value} from {field.field_value}"
+                        )
+                        field.field_value = value
+
+                    # Update the widget!
+                    field.update()
+
+        try:
+            if flatten:
+                output.info("remove all annotations")
+                document.bake(annots=False)
+
+            # Save the modified PDF
+            document.save(output_file)
+        except Exception:  # pylint: disable=broad-exception-caught
+            output.warning("an error occurs when saving file")
+
+        return self

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/pdffiller/typing.py

@@ -43,7 +43,7 @@ __all__ = [
     "Type",
     "Union",
     "SubParserType",
-    "StrByteType",
+    "StreamType",
     "TextIO",
 ]
 
@@ -52,7 +52,6 @@ ExitCode = Union[str, int, None]
 PathLike = Union[str, Path]
 
 StreamType = IO[Any]
-StrByteType = Union[PathLike, StreamType]
 
 if TYPE_CHECKING:
     # pylint: disable=protected-access,line-too-long

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-pdffiller"
-version = "1.1.2"
+version = "2.0.0"
 description="Interact with PDF by inspecting or filling it"
 requires-python = ">=3.9"
 license ="MIT"
@@ -26,7 +26,7 @@ classifiers = [
 readme = "README.rst"
 authors = [{ name = "Jacques Raphanel", email = "jraphanel@sismic.fr" }]
 keywords = ["development", "pdf"]
-dependencies = ["pypdf", "colorama", "pyyaml"]
+dependencies = ["pymupdf==1.24.10", "colorama", "pyyaml"]
 
 [project.scripts]
 pdffiller = "pdffiller.cli:main"
@@ -92,6 +92,7 @@ logging_use_named_masks = false
 major_on_zero = true
 tag_format = "v{version}"
 build_command = """
+    apt update && apt install -y --no-install-recommends pkg-config gcc g++ swig && \
     python -m pip install build -rrequirements.txt && \
     python -m build . && \
     python installer/build.py

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/python_pdffiller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-pdffiller
-Version: 1.1.2
+Version: 2.0.0
 Summary: Interact with PDF by inspecting or filling it
 Author-email: Jacques Raphanel <jraphanel@sismic.fr>
 License-Expression: MIT
@@ -26,7 +26,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: COPYING
 License-File: AUTHORS.rst
-Requires-Dist: pypdf
+Requires-Dist: pymupdf==1.24.10
 Requires-Dist: colorama
 Requires-Dist: pyyaml
 Dynamic: license-file

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/python_pdffiller.egg-info/SOURCES.txt

@@ -48,7 +48,6 @@ pdffiller/cli/commands/dump_data_fields.py
 pdffiller/cli/commands/fill_form.py
 pdffiller/io/__init__.py
 pdffiller/io/colors.py
-pdffiller/io/custom_pdf_writer.py
 pdffiller/io/output.py
 pdffiller/widgets/__init__.py
 pdffiller/widgets/base.py
@@ -63,6 +62,9 @@ python_pdffiller.egg-info/requires.txt
 python_pdffiller.egg-info/top_level.txt
 tests/__init__.py
 tests/conftest.py
+tests/cli/__init__.py
+tests/cli/test_dump_data_field.py
+tests/cli/test_fill_form.py
 tests/data/empty.pdf
 tests/data/input.pdf
 tests/unit/__init__.py

python_pdffiller-2.0.0/python_pdffiller.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pymupdf==1.24.10
+colorama
+pyyaml

python_pdffiller-2.0.0/requirements.txt

@@ -0,0 +1,3 @@
+pymupdf==1.24.10
+colorama
+pyyaml

python_pdffiller-2.0.0/tests/cli/test_dump_data_field.py

@@ -0,0 +1,106 @@
+import json
+from unittest import mock
+
+import pytest
+
+from pdffiller.cli import cli
+from pdffiller.cli.exit_codes import (
+    ERROR_COMMAND_NAME,
+    ERROR_UNEXPECTED,
+    SUCCESS,
+)
+
+
+def test_incomplete_no_action():
+    """test empty command-line"""
+
+    with mock.patch("sys.argv", []):
+        assert cli.main() == ERROR_COMMAND_NAME
+
+
+@pytest.mark.parametrize("argv", [])
+def test_incomplete(argv):
+    """test empty command-line"""
+
+    # Test through direct command-line
+    with mock.patch("sys.argv", ["pdffiller", "dump_data_fields"] + argv):
+        assert cli.main() == ERROR_UNEXPECTED
+
+    # Test with direct call to main function
+    assert cli.main(["dump_data_fields"] + argv) == ERROR_UNEXPECTED
+
+
+def test_complete(test_data_dir, capsys):
+    """test complete command-line"""
+
+    argv = [
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    json_fields = """[
+    {
+        "FieldType": "text",
+        "FieldName": "Lastname"
+    },
+    {
+        "FieldType": "text",
+        "FieldName": "Firstname"
+    },
+    {
+        "FieldType": "checkbox",
+        "FieldOptions": [
+            "Off",
+            "Oui"
+        ],
+        "FieldName": "Men"
+    },
+    {
+        "FieldType": "checkbox",
+        "FieldOptions": [
+            "Off",
+            "Oui"
+        ],
+        "FieldName": "Women"
+    },
+    {
+        "FieldType": "radio",
+        "FieldOptions": [
+            "Off",
+            "Single",
+            "Married",
+            "Divorced"
+        ],
+        "FieldName": "MaritalStatus",
+        "FieldValue": "Off"
+    }
+]"""
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "dump_data_fields", "-fjson"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        out, err = capsys.readouterr()
+        assert "loading file in memory" == err.strip()
+        assert json.loads(json_fields) == json.loads(out)
+
+    # Test with direct call to main function
+    assert cli.main(["dump_data_fields"] + argv) == SUCCESS
+
+
+def test_complete_with_invalid_file(test_data_dir):
+    """test complete command-line"""
+
+    argv = [
+        str(test_data_dir / "empty.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "dump_data_fields"] + argv,
+    ):
+        assert cli.main() == ERROR_UNEXPECTED
+
+    # Test with direct call to main function
+    assert cli.main(["dump_data_fields"] + argv) == ERROR_UNEXPECTED

python_pdffiller-2.0.0/tests/cli/test_fill_form.py

@@ -0,0 +1,103 @@
+import json
+from unittest import mock
+
+import pytest
+
+from pdffiller.cli import cli
+from pdffiller.cli.exit_codes import (
+    ERROR_COMMAND_NAME,
+    ERROR_UNEXPECTED,
+    SUCCESS,
+)
+
+
+def test_incomplete_no_action():
+    """test empty command-line"""
+
+    with mock.patch("sys.argv", []):
+        assert cli.main() == ERROR_COMMAND_NAME
+
+
+@pytest.mark.parametrize("argv", [])
+def test_incomplete(argv):
+    """test empty command-line"""
+
+    # Test through direct command-line
+    with mock.patch("sys.argv", ["pdffiller", "fill_form"] + argv):
+        assert cli.main() == ERROR_UNEXPECTED
+
+    # Test with direct call to main function
+    assert cli.main(["fill_form"] + argv) == ERROR_UNEXPECTED
+
+
+def test_complete_with_files_only(test_data_dir, input_json_fields, output_pdf_path):
+    """test complete command-line"""
+
+    argv = [
+        "-d",
+        str(input_json_fields),
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "fill_form"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        assert output_pdf_path.exists()
+        output_pdf_path.unlink()
+
+    # Test with direct call to main function
+    assert cli.main(["fill_form"] + argv) == SUCCESS
+    assert output_pdf_path.exists()
+
+
+def test_complete_with_invalid_file(test_data_dir, input_json_fields, output_pdf_path):
+    """test complete command-line"""
+
+    argv = [
+        "-d",
+        input_json_fields,
+        "-o",
+        output_pdf_path,
+        str(test_data_dir / "empty.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "fill_form"] + argv,
+    ):
+        assert cli.main() == ERROR_UNEXPECTED
+
+    # Test with direct call to main function
+    assert cli.main(["fill_form"] + argv) == ERROR_UNEXPECTED
+
+
+def test_complete_with_file_and_string(test_data_dir, input_json_fields, output_pdf_path):
+    """test complete command-line"""
+
+    json_fields = input_json_fields.read_text()
+    argv = [
+        "-i",
+        json_fields,
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "fill_form"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        assert output_pdf_path.exists()
+        output_pdf_path.unlink()
+
+    # Test with direct call to main function
+    assert cli.main(["fill_form"] + argv) == SUCCESS
+    assert output_pdf_path.exists()

python_pdffiller-2.0.0/tests/conftest.py

@@ -0,0 +1,70 @@
+import shutil
+from pathlib import Path
+
+import pytest
+
+import time
+from pdffiller.typing import Generator
+
+
+@pytest.fixture(scope="session")
+def test_dir(pytestconfig) -> Path:
+    """Retrieve path to tests directory from test environment"""
+    return pytestconfig.rootdir / "tests"
+
+
+@pytest.fixture(scope="session")
+def test_data_dir(pytestconfig) -> Path:
+    """Retrieve path to tests data directory from test environment"""
+    return pytestconfig.rootdir / "tests" / "data"
+
+
+@pytest.fixture(name="tmp_output_dir")
+def fixture_tmp_output_dir(tmp_path) -> Generator[Path, None, None]:
+    """Generate temporary history file"""
+    local_output_dir = tmp_path / "_output"
+    local_output_dir.mkdir(parents=True)
+    yield local_output_dir
+    shutil.rmtree(local_output_dir)
+
+
+@pytest.fixture(name="input_json_fields")
+def fixture_dynamic_config_file(tmp_path) -> Generator[Path, None, None]:
+    """Generate temporary input json file"""
+    config_path = tmp_path / "input.json"
+
+    json_content = """[
+    {
+        "name": "Lastname",
+        "value": "Doe"
+    },
+    {
+        "name": "Firstname",
+        "value": "John"
+    },
+    {
+        "name": "Men",
+        "value": "On"
+    },
+    {
+        "name": "Women",
+        "value": ""
+    },
+    {
+        "name": "MaritalStatus",
+        "value": "Single"
+    }
+]
+    """
+    config_path.write_text(json_content)
+    yield config_path
+    config_path.unlink()
+
+
+@pytest.fixture(name="output_pdf_path")
+def fixture_output_pdf_path(tmp_path) -> Generator[Path, None, None]:
+    """Generate temporary output pdf file"""
+    output_path = tmp_path / f"{time.time()}.pdf"
+    yield output_path
+    if output_path.exists():
+        output_path.unlink()

{python_pdffiller-1.1.2 → python_pdffiller-2.0.0}/tests/unit/test_form_field.py

@@ -1,6 +1,7 @@
 import pytest
 
 from pdffiller.pdf import Pdf
+from pdffiller.exceptions import PdfFillerException
 
 
 def test_valid_pdf(test_data_dir):
@@ -14,11 +15,11 @@ def test_valid_pdf(test_data_dir):
     assert schema[3]["FieldName"] == "Women"
     assert schema[4]["FieldName"] == "MaritalStatus"
     assert len(schema[4]["FieldOptions"]) == 4
-    assert schema[4]["FieldOptions"][0] == "Divorced"
-    assert schema[4]["FieldOptions"][1] == "Off"
-    assert schema[4]["FieldValue"] == "Married"
+    assert "Divorced" in schema[4]["FieldOptions"]
+    assert "Off" in schema[4]["FieldOptions"]
+    assert schema[4]["FieldValue"] == "Off"
 
 
 def test_invalid_pdf(test_data_dir):
-    reader = Pdf(str(test_data_dir / "empty.pdf"))
-    assert len(reader.widgets) == 0
+    with pytest.raises(PdfFillerException):
+        Pdf(str(test_data_dir / "empty.pdf"))