python-pdffiller 1.0.0__py3-none-any.whl

pdffiller/cli/commands/dump_data_fields.py

@@ -0,0 +1,75 @@
+import json
+import os
+
+from pdffiller.cli.args import add_global_arguments
+from pdffiller.cli.command import pdffiller_command, PdfFillerArgumentParser
+from pdffiller.exceptions import (
+    AbortExecution,
+    CommandLineError,
+    FileNotExistsError,
+    PdfFillerException,
+)
+from pdffiller.io.output import cli_out_write, PdfFillerOutput
+from pdffiller.pdf import Pdf
+from pdffiller.typing import Any
+
+from ..exit_codes import ERROR_ENCOUNTERED
+
+
+def dump_fields_text_formatter(pdf: Pdf) -> None:
+    """Print output text for dump_fields command as simple text"""
+    for widget in pdf.schema:
+        cli_out_write("----------")
+        for key, value in widget.items():
+            if isinstance(value, list):
+                for subvalue in value:
+                    cli_out_write(f"{key}: {subvalue}")
+            else:
+                cli_out_write(f"{key}: {value}")
+
+
+def dump_fields_json_formatter(pdf: Pdf) -> None:
+    """Print output text for dump_fields command as simple text"""
+
+    cli_out_write(json.dumps(pdf.schema, indent=4, ensure_ascii=False))
+
+
+@pdffiller_command(
+    group=None,  # "Extract",
+    formatters={"text": dump_fields_text_formatter, "json": dump_fields_json_formatter},
+)
+def dump_data_fields(parser: PdfFillerArgumentParser, *args: Any) -> Any:
+    """
+    Dump form fields present in a pdf given its file path
+    """
+    options_group = parser.add_argument_group("options")
+    parser.add_argument(
+        "file",
+        metavar="INPUT_PATH",
+        type=str,
+        nargs="?",
+        help="""Path to the input PDF file.""",
+    )
+
+    add_global_arguments(options_group, True, parser)
+
+    opts = parser.parse_args(*args)
+
+    output = PdfFillerOutput()
+    if not opts.file:
+        raise CommandLineError("no input file given")
+
+    if not os.path.isfile(opts.file):
+        raise FileNotExistsError(opts.file)
+
+    try:
+        pdf = Pdf(opts.file)
+        return pdf
+    except PdfFillerException as exp:
+        output.error(str(exp))
+    except Exception as exg:  # pylint: disable=broad-except # pragma: no cover
+        output.error(f"unexpected error when adding {opts.file} with the following error:")
+        output.error(exg)
+        raise AbortExecution(ERROR_ENCOUNTERED) from exg
+
+    return None

pdffiller/cli/commands/fill_form.py

@@ -0,0 +1,142 @@
+import html
+import json
+import os
+import sys
+
+import yaml
+
+from pdffiller.cli.args import add_global_arguments
+from pdffiller.cli.boolean_action import BooleanAction
+from pdffiller.cli.command import pdffiller_command, PdfFillerArgumentParser
+from pdffiller.cli.once_argument import OnceArgument
+from pdffiller.exceptions import (
+    AbortExecution,
+    CommandLineError,
+    FileNotExistsError,
+    PdfFillerException,
+)
+from pdffiller.io.output import PdfFillerOutput
+from pdffiller.pdf import Pdf
+from pdffiller.typing import Any, Dict, Union
+
+from ..exit_codes import ERROR_ENCOUNTERED
+
+
+@pdffiller_command(
+    group=None,
+)
+def fill_form(parser: PdfFillerArgumentParser, *args: Any) -> Any:
+    """
+    Fill an input PDF's form fields with the data from
+    """
+    options_group = parser.add_argument_group("options")
+
+    options_group.add_argument(
+        "-d",
+        "--data",
+        metavar="DATA_PATH",
+        type=str,
+        help="""Path to the data file defining the field/value pairs.
+                It can be a json or yaml file format.
+                It can be also - to read data file from stdin with JSON format.
+             """,
+        action=OnceArgument,
+    )
+
+    options_group.add_argument(
+        "-i",
+        "--input-data",
+        metavar="DATA",
+        type=str,
+        help="""Input data with JSON format defining the field/value pairs.
+             """,
+        action=OnceArgument,
+    )
+
+    options_group.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT_PATH",
+        type=str,
+        help="""Path to the output PDF file.""",
+        action=OnceArgument,
+    )
+
+    options_group.add_argument(
+        "-f",
+        "--flatten",
+        action=BooleanAction,
+        default=False,
+        help="Use this option to merge an input PDF's interactive form fields"
+        "(and their data) with the PDF's pages. Defaults to False.",
+    )
+
+    parser.add_argument(
+        "file",
+        metavar="INPUT_PATH",
+        type=str,
+        nargs="?",
+        help="""Path to the input PDF file.""",
+        action=OnceArgument,
+    )
+
+    add_global_arguments(options_group, True, parser)
+
+    opts = parser.parse_args(*args)
+
+    output = PdfFillerOutput()
+    if not opts.file:
+        raise CommandLineError("no input file given")
+
+    if not opts.output:
+        raise CommandLineError("no output file path given")
+
+    if not opts.data and not opts.input_data:
+        raise CommandLineError("no data file path given")
+
+    input_data: Dict[str, Union[str, int, float, bool]] = {}
+    if opts.input_data:
+        try:
+            input_data = json.loads(opts.input_data)
+        except Exception as exg:  # pylint: disable=broad-except
+            output.error("Failed to load json input data")
+            raise AbortExecution(ERROR_ENCOUNTERED) from exg
+    else:
+        if "-" != opts.data:
+            if not os.path.isfile(opts.file):
+                raise FileNotExistsError(opts.file)
+            if not os.path.isfile(opts.data):
+                raise FileNotExistsError(opts.data)
+
+            with open(opts.data, "r", encoding="utf-8") as stream:
+                try:
+                    if os.path.splitext(opts.data)[1] in [".yaml", ".yml"]:
+                        input_data = yaml.safe_load(stream)
+                    else:
+                        input_data = json.load(stream)
+                except Exception as exg:  # pylint: disable=broad-except
+                    output.error(f"Failed to load {opts.data} input data file")
+                    raise AbortExecution(ERROR_ENCOUNTERED) from exg
+        elif not os.isatty(sys.stdin.fileno()):
+            try:
+                input_data = json.load(sys.stdin)
+            except Exception as exg:  # pylint: disable=broad-except
+                output.error(f"Failed to load {opts.data} input data file : " + str(exg))
+                raise AbortExecution(ERROR_ENCOUNTERED) from exg
+
+    if isinstance(input_data, list) and isinstance(input_data[0], dict):
+        input_dict = {}
+        for field in input_data:
+            if "name" in field and "value" in field:
+                input_dict[html.unescape(field["name"])] = html.unescape(field["value"])
+        input_data = input_dict
+
+    try:
+        pdf = Pdf(opts.file)
+        pdf.fill(opts.file, opts.output, input_data, opts.flatten)
+    except PdfFillerException as exp:
+        output.error(str(exp))
+    except Exception as exg:  # pylint: disable=broad-except # pragma: no cover
+        output.error(f"unexpected error when adding {opts.file} with the following error:")
+        output.error(exg)
+        raise AbortExecution(ERROR_ENCOUNTERED) from exg

pdffiller/cli/exit_codes.py

@@ -0,0 +1,10 @@
+# Exit codes for pdffiller command:
+SUCCESS = 0  # 0: Success
+ERROR_GENERAL = 1  # 1: General exception error
+USER_CTRL_C = 2  # 2: Ctrl+C
+USER_CTRL_BREAK = 3  # 3: Ctrl+Break
+ERROR_SIGTERM = 4  # 4: SIGTERM
+ERROR_UNEXPECTED = 5  # 5: Unexpected error
+ERROR_ENCOUNTERED = 6  # 6: Error occurs during command execution
+ERROR_COMMAND_NAME = 7  # 7: Action/command name missing
+ERROR_SUBCOMMAND_NAME = 8  # 8: Sub-command name missing

pdffiller/cli/formatters.py

@@ -0,0 +1,16 @@
+import json
+
+from pdffiller.io.output import cli_out_write
+from pdffiller.typing import Any
+
+
+def default_json_formatter(data: Any) -> None:
+    """Default JSON formatter"""
+    data_json = json.dumps(data, indent=4)
+    cli_out_write(data_json)
+
+
+def default_text_formatter(data: Any) -> None:
+    """Default TEXT formatter"""
+    for key, value in data.items():
+        cli_out_write(f"{key}: {value}")

pdffiller/cli/once_argument.py

@@ -0,0 +1,19 @@
+import argparse
+
+from pdffiller.typing import Any, Optional, Sequence, Union
+
+
+class OnceArgument(argparse.Action):
+    """Allows declaring a parameter that can have only one value."""
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: Union[str, Any, Sequence[Any], None],
+        option_string: Optional[str] = None,
+    ) -> None:
+        if getattr(namespace, self.dest) is not None and self.default is None:
+            msg = f"{option_string or 'undefined'} can only be specified once"
+            raise argparse.ArgumentError(None, msg)
+        setattr(namespace, self.dest, values)

pdffiller/cli/smart_formatter.py

@@ -0,0 +1,10 @@
+import argparse
+import textwrap
+
+
+class SmartFormatter(argparse.HelpFormatter):
+    """Text formatter for DbDumpToPG commands"""
+
+    def _fill_text(self, text: str, width: int, indent: str) -> str:
+        text = textwrap.dedent(text)
+        return "".join(indent + line for line in text.splitlines(True))

pdffiller/const.py

@@ -0,0 +1,22 @@
+""" pdffiller constants. """
+
+__all__ = [
+    "ENV_NO_COLOR",
+    "ENV_CLICOLOR_FORCE",
+    "ENV_PDFFILLER_COLOR_DARK",
+]
+
+ENV_NO_COLOR = "NO_COLOR"
+""" Disable ANSI colors. """
+
+ENV_CLICOLOR_FORCE = "CLICOLOR_FORCE"
+"""ANSI colors should be enabled.
+
+Different from 0 to enforce ANSI colors
+"""
+
+ENV_PDFFILLER_COLOR_DARK = "PDFFILLER_COLOR_DARK"
+"""Use dark ANSI color scheme.
+
+It must be different from 0 to enforce dark colors
+"""

pdffiller/exceptions.py

@@ -0,0 +1,59 @@
+from pdffiller.typing import Optional, PathLike
+
+
+#
+# Generic exception
+#
+class PdfFillerException(Exception):
+    """PdfFiller based exception object"""
+
+    def __init__(self, message: str) -> None:
+        Exception.__init__(self, message)
+        self.message = message
+
+
+#
+# Command-line utility exception
+#
+
+
+class AbortExecution(PdfFillerException):
+    """Abort but with success the current execution"""
+
+    def __init__(self, exitcode: int = 0) -> None:
+        self.exitcode = exitcode
+        PdfFillerException.__init__(self, "")
+
+
+class CommandLineError(PdfFillerException):
+    """One command-line argument is not defined properly"""
+
+    def __init__(self, message: str) -> None:
+        PdfFillerException.__init__(self, message)
+
+
+class InvalidCommandNameException(PdfFillerException):
+    """Invalid command or action name"""
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        if name:
+            PdfFillerException.__init__(self, f"Unknown '{name}' command")
+        else:
+            PdfFillerException.__init__(self, "No command name given")
+
+
+class InvalidSubCommandNameException(PdfFillerException):
+    """Invalid sub-command name"""
+
+    def __init__(self, name: Optional[str] = None) -> None:
+        if name:
+            PdfFillerException.__init__(self, f"Unknown '{name}' sub-command")
+        else:
+            PdfFillerException.__init__(self, "No sub-command name given")
+
+
+class FileNotExistsError(PdfFillerException):
+    """File not found"""
+
+    def __init__(self, pathname: PathLike) -> None:
+        PdfFillerException.__init__(self, f"{pathname} : file not found")

pdffiller/io/colors.py

@@ -0,0 +1,52 @@
+import os
+
+import colorama
+
+from pdffiller import const
+from pdffiller.typing import Any
+
+
+def is_terminal(stream: Any) -> bool:
+    """Determine whether a stream is interactive or not.
+
+    :return: True if ``stream`` interactive else False
+    """
+    return hasattr(stream, "isatty") and stream.isatty()
+
+
+def color_enabled(stream: object) -> bool:
+    """Determine whether a stream  can support colorred output.
+
+    This function follows https://bixense.com/clicolors convention, so you can
+    define one of the following variable to enforce a mode, else the function
+    will just check if `stream` is interactive or not:
+    * :const:`~pdffiller.const.ENV_NO_COLOR`: No colors by just testing its existance
+    * :const:`~pdffiller.const.ENV_CLICOLOR_FORCE`: Force color if defined and
+      value is not **0**
+
+    :param stream: The stream to be tested.
+
+    :return: True if colorred output is enabled, else False
+    """
+
+    if os.getenv(const.ENV_NO_COLOR, "0") != "0":
+        # CLICOLOR_FORCE != 0, ANSI colors should be enabled no matter what.
+        return True
+
+    if os.getenv(const.ENV_CLICOLOR_FORCE) is not None:
+        # Enable fully colorred mode
+        return True
+
+    return is_terminal(stream)
+
+
+def init_colorama(stream: object) -> None:
+    """Initialize colorama.
+    :param stream: The stream to be used to determine if colorred mode is supported not
+    """
+    if color_enabled(stream):
+        if os.getenv(const.ENV_CLICOLOR_FORCE, "0") != "0":
+            # Otherwise it is not really forced if colorama doesn't feel it
+            colorama.init(strip=False, convert=False)
+        else:
+            colorama.init()