python-pdffiller 2.0.2__tar.gz → 2.0.4__tar.gz

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-pdffiller
-Version: 2.0.2
+Version: 2.0.4
 Summary: Interact with PDF by inspecting or filling it
 Author-email: Jacques Raphanel <jraphanel@sismic.fr>
 License-Expression: MIT

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/docs/source/cli-commands.rst

@@ -12,6 +12,8 @@ This section describe the **pdffiller** built-in commands, like ``pdffiller dump
 
    commands/dump_data_fields
    commands/fill_form
+   commands/sanitize
 
 - :doc:`pdffiller dump_data_fields <commands/dump_data_fields>`: Dump form fields present in a pdf given its file path
 - :doc:`pdffiller fill_form <commands/fill_form>`: Fill an input PDF's form fields with the data from
+- :doc:`pdffiller sanitize <commands/sanitize>`: Sanitize a PDF by removing MaxLen constraints from text fields

python_pdffiller-2.0.4/docs/source/commands/sanitize.rst

@@ -0,0 +1,89 @@
+.. _commands_sanitize:
+
+pdffiller sanitize
+==================
+
+.. code-block:: text
+
+    $ pdffiller sanitize -h
+    usage: pdffiller sanitize [-o OUTPUT_PATH] [--deep] [-L PATH] [-V [LEVEL]] [-f NAME] [-h] [INPUT_PATH]
+
+    Sanitize a PDF by removing MaxLen constraints from text fields.
+    This fixes PDFs where MaxLen is incorrectly set, causing text truncation.
+
+    positional arguments:
+      INPUT_PATH            Path to the input PDF file.
+
+    options:
+      -o OUTPUT_PATH, --output OUTPUT_PATH
+                            Path to the output PDF file.
+      --deep                Perform a deep sanitization: also clear the Comb flag
+                            from text fields.
+      -f NAME, --format NAME
+                            Output format: text or json. Defaults to text.
+      -L PATH, --log-file PATH
+                            Send output to PATH instead of stderr.
+      -V [LEVEL], --verbosity [LEVEL]
+                            Level of detail of the output. Valid options from less verbose to more
+                            verbose: -Vquiet, -Verror, -Vwarning, -Vnotice, -Vstatus, -V or -Vverbose, -VV or
+                            -Vdebug, -VVV or -vtrace
+      -h, --help            show this help message and exit
+
+Sanitizes a single input PDF by removing ``/MaxLen`` constraints from text fields.
+This fixes PDFs where ``/MaxLen`` is incorrectly set on widget annotations or
+inherited from parent field dictionaries, causing text truncation when filling forms.
+
+By default (light mode), fields with the Comb flag (``Bande de X caracteres`` in Adobe) are
+**skipped**, as their ``/MaxLen`` is intentional. Only text fields without the Comb flag are sanitized.
+
+With the ``--deep`` option, **all** text fields are sanitized: ``/MaxLen`` is removed and
+the Comb flag (bit 25 of ``/Ff``) is also cleared.
+
+.. code-block:: text
+
+    pdffiller sanitize -o output.pdf input.pdf
+    pdffiller sanitize --deep -o output.pdf input.pdf
+    pdffiller sanitize -f json -o output.pdf input.pdf
+
+The ``pdffiller sanitize`` command will:
+
+* Load the input PDF file
+* Walk through all text fields and their parent field dictionaries
+* Skip fields with the Comb flag (unless ``--deep`` is used)
+* Remove ``/MaxLen`` entries from each node in the hierarchy
+* With ``--deep``: also clear the Comb flag (``Bande de X caracteres``) from ``/Ff``
+* Save the sanitized PDF to the output path
+* Report all sanitized fields (name, type, and previous MaxLen value)
+
+Output formats
+--------------
+
+**Text** (default):
+
+.. code-block:: text
+
+    ----------
+    FieldName: nom_souscripteur
+    FieldType: Text
+    MaxLen: 4
+    ----------
+    FieldName: prenom_souscripteur
+    FieldType: Text
+    MaxLen: 4
+
+**JSON** (``-f json``):
+
+.. code-block:: json
+
+    [
+        {
+            "FieldName": "nom_souscripteur",
+            "FieldType": "Text",
+            "MaxLen": 4
+        },
+        {
+            "FieldName": "prenom_souscripteur",
+            "FieldType": "Text",
+            "MaxLen": 4
+        }
+    ]

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/pdffiller/_version.py

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

python_pdffiller-2.0.4/pdffiller/cli/commands/sanitize.py

@@ -0,0 +1,100 @@
+import json
+import os
+
+from pdffiller.cli.args import add_global_arguments
+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 cli_out_write, PdfFillerOutput
+from pdffiller.pdf import Pdf
+from pdffiller.typing import Any, Dict, List
+
+from ..exit_codes import ERROR_ENCOUNTERED
+
+
+def sanitize_text_formatter(sanitized: List[Dict[str, Any]]) -> None:
+    """Print sanitized fields as plain text"""
+    if not sanitized:
+        cli_out_write("No fields were sanitized.")
+        return
+    for field in sanitized:
+        cli_out_write("----------")
+        for key, value in field.items():
+            cli_out_write(f"{key}: {value}")
+
+
+def sanitize_json_formatter(sanitized: List[Dict[str, Any]]) -> None:
+    """Print sanitized fields as JSON"""
+    if not sanitized:
+        return
+    cli_out_write(json.dumps(sanitized, indent=4, ensure_ascii=False))
+
+
+@pdffiller_command(
+    group=None,
+    formatters={"text": sanitize_text_formatter, "json": sanitize_json_formatter},
+)
+def sanitize(parser: PdfFillerArgumentParser, *args: Any) -> Any:
+    """
+    Sanitize a PDF by removing MaxLen constraints from text fields.
+    This fixes PDFs where MaxLen is incorrectly set, causing text truncation.
+    """
+    options_group = parser.add_argument_group("options")
+
+    options_group.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT_PATH",
+        type=str,
+        help="""Path to the output PDF file.""",
+        action=OnceArgument,
+    )
+
+    options_group.add_argument(
+        "--deep",
+        action="store_true",
+        default=False,
+        help="Perform a deep sanitization: also clear the Comb flag from text fields.",
+    )
+
+    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 os.path.isfile(opts.file):
+        raise FileNotExistsError(opts.file)
+
+    try:
+        pdf = Pdf()
+        sanitized = pdf.sanitize(opts.file, opts.output, opts.deep)
+        output.info(f"sanitized pdf saved to {opts.output}")
+        return sanitized
+    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 sanitizing {opts.file} with the following error:")
+        output.error(exg)
+        raise AbortExecution(ERROR_ENCOUNTERED) from exg
+
+    return None

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/pdffiller/pdf.py

@@ -88,7 +88,7 @@ class Pdf:
             ) from ex
 
         for i, page in enumerate(doc.pages()):
-            output.verbose(f"loading page {i+1}/{doc.page_count}")
+            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
@@ -105,7 +105,7 @@ class Pdf:
                             choices.insert(0, "Off")
                         new_widget.choices = [choice.replace("#20", " ") for choice in choices]
                     elif isinstance(new_widget, TextWidget):
-                        new_widget.max_length = widget.text_maxlen
+                        new_widget.max_length = self._resolve_text_maxlen(doc, widget)
                     loaded_widgets[widget.field_name] = new_widget
                 else:
                     new_widget = loaded_widgets[widget.field_name]
@@ -128,6 +128,186 @@ class Pdf:
 
         self.widgets = loaded_widgets
 
+    @staticmethod
+    def _resolve_text_maxlen(doc: pymupdf.Document, widget: Any) -> Optional[int]:
+        """
+        Resolve the MaxLen value for a text widget by walking up the PDF object hierarchy.
+
+        PyMuPDF's widget.text_maxlen may not reflect the actual MaxLen when it is
+        defined on a parent field dictionary rather than on the widget annotation itself.
+        This method checks the widget xref and its parents for /MaxLen.
+
+        Args:
+            doc: The pymupdf Document.
+            widget: The pymupdf Widget.
+
+        Returns:
+            The resolved max length, or None if not found.
+        """
+        max_length: Optional[int] = widget.text_maxlen
+        xref = widget.xref
+        while xref > 0:
+            key_type, value = doc.xref_get_key(xref, "MaxLen")
+            if key_type != "null" and value:
+                try:
+                    int_value = int(value)
+                    if max_length is None or max_length < int_value:
+                        max_length = int_value
+                    # return int(value)
+                except (ValueError, TypeError):
+                    pass
+            # Walk up to parent
+            key_type, value = doc.xref_get_key(xref, "Parent")
+            if key_type == "xref":
+                parent_xref = int(value.split()[0])
+                if parent_xref == xref:
+                    break
+                xref = parent_xref
+            else:
+                break
+
+        return max_length
+
+    COMB_FLAG = 1 << 24  # Bit 25 in PDF spec (Comb option)
+
+    @staticmethod
+    def _has_comb_flag(doc: pymupdf.Document, widget: Any) -> bool:
+        """
+        Check if the Comb flag is set on the widget or any of its parents.
+
+        Args:
+            doc: The pymupdf Document.
+            widget: The pymupdf Widget.
+
+        Returns:
+            True if the Comb flag is set on any node in the hierarchy.
+        """
+        xref = widget.xref
+        while xref > 0:
+            key_type, ff_value = doc.xref_get_key(xref, "Ff")
+            if key_type != "null" and ff_value:
+                try:
+                    if int(ff_value) & Pdf.COMB_FLAG:
+                        return True
+                except (ValueError, TypeError):
+                    pass
+            key_type, value = doc.xref_get_key(xref, "Parent")
+            if key_type == "xref":
+                parent_xref = int(value.split()[0])
+                if parent_xref == xref:
+                    break
+                xref = parent_xref
+            else:
+                break
+        return False
+
+    @staticmethod
+    def _remove_maxlen(doc: pymupdf.Document, widget: Any, deep: bool = False) -> None:
+        """
+        Remove /MaxLen from the widget and all its parent field dictionaries.
+
+        In deep mode, also clears the Comb flag (bit 25 of /Ff).
+        In normal mode, /MaxLen is only removed on nodes where Comb is not set.
+
+        Args:
+            doc: The pymupdf Document.
+            widget: The pymupdf Widget.
+            deep: If True, also clear the Comb flag from /Ff.
+        """
+        xref = widget.xref
+        while xref > 0:
+            # Check Comb flag on this node
+            has_comb = False
+            key_type, ff_value = doc.xref_get_key(xref, "Ff")
+            if key_type != "null" and ff_value:
+                try:
+                    flags = int(ff_value)
+                    has_comb = bool(flags & Pdf.COMB_FLAG)
+                except (ValueError, TypeError):
+                    pass
+
+            if deep:
+                # Deep mode: remove /MaxLen and clear Comb flag
+                if doc.xref_get_key(xref, "MaxLen")[0] != "null":
+                    doc.xref_set_key(xref, "MaxLen", "null")
+                if has_comb:
+                    doc.xref_set_key(xref, "Ff", str(flags & ~Pdf.COMB_FLAG))
+            else:
+                # Normal mode: only remove /MaxLen if Comb is not set on this node
+                if not has_comb and doc.xref_get_key(xref, "MaxLen")[0] != "null":
+                    doc.xref_set_key(xref, "MaxLen", "null")
+
+            # Walk up to parent
+            key_type, value = doc.xref_get_key(xref, "Parent")
+            if key_type == "xref":
+                parent_xref = int(value.split()[0])
+                if parent_xref == xref:
+                    break
+                xref = parent_xref
+            else:
+                break
+        widget.text_maxlen = 0
+
+    def sanitize(
+        self,
+        input_file: PathLike,
+        output_file: PathLike,
+        deep: bool = False,
+    ) -> List[Dict[str, Any]]:
+        """
+        Sanitize a PDF by removing /MaxLen constraints from all text fields.
+
+        This fixes PDFs where /MaxLen is set incorrectly (e.g. 4 instead of 27),
+        which causes text truncation when filling the form.
+
+        Args:
+            input_file (PathLike): The input file path.
+            output_file (PathLike): The output file path.
+            deep: If True, also clear the Comb flag from /Ff.
+
+        Returns:
+            A list of dicts describing each sanitized field:
+            [{"FieldName": ..., "FieldType": "text", "MaxLen": <old_value>}, ...]
+        """
+        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("sanitizing pdf text fields")
+
+        sanitized: List[Dict[str, Any]] = []
+        for page in document:
+            for field in page.widgets():
+                if (
+                    field.field_type == pymupdf.PDF_WIDGET_TYPE_TEXT  # pylint: disable=no-member
+                    and field.text_maxlen
+                ):
+                    # Skip fields with Comb flag in normal mode
+                    if not deep and self._has_comb_flag(document, field):
+                        output.verbose(f"skipping {field.field_name} (Comb flag active)")
+                        continue
+                    old_maxlen = field.text_maxlen
+                    output.verbose(f"removing MaxLen={old_maxlen} from {field.field_name}")
+                    self._remove_maxlen(document, field, deep)
+                    field.update()
+                    sanitized.append(
+                        {
+                            "FieldName": field.field_name,
+                            "FieldType": field.field_type_string,
+                            "MaxLen": old_maxlen,
+                        }
+                    )
+
+        try:
+            document.save(output_file)
+        except Exception:  # pylint: disable=broad-exception-caught
+            output.warning("an error occurs when saving file")
+
+        return sanitized
+
     @property
     def schema(self) -> List[Dict[str, Any]]:
         """
@@ -217,11 +397,12 @@ class Pdf:
 
                     # Handling other fields types
                     else:
+                        # Remove MaxLen constraint from the PDF object to avoid truncation
+                        self._remove_maxlen(document, field)
                         output.verbose(
                             f"updating {field.field_name} with {value} from {field.field_value}"
                         )
                         field.field_value = value
-
                     # Update the widget!
                     field.update()
         try:

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-pdffiller"
-version = "2.0.2"
+version = "2.0.4"
 description="Interact with PDF by inspecting or filling it"
 requires-python = ">=3.9"
 license ="MIT"

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/python_pdffiller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-pdffiller
-Version: 2.0.2
+Version: 2.0.4
 Summary: Interact with PDF by inspecting or filling it
 Author-email: Jacques Raphanel <jraphanel@sismic.fr>
 License-Expression: MIT

{python_pdffiller-2.0.2 → python_pdffiller-2.0.4}/python_pdffiller.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ docs/source/_static/rtd_theme_overrides.css
 docs/source/_static/terminal_output.css
 docs/source/commands/dump_data_fields.rst
 docs/source/commands/fill_form.rst
+docs/source/commands/sanitize.rst
 pdffiller/__init__.py
 pdffiller/__main__.py
 pdffiller/_version.py
@@ -46,6 +47,7 @@ pdffiller/cli/smart_formatter.py
 pdffiller/cli/commands/__init__.py
 pdffiller/cli/commands/dump_data_fields.py
 pdffiller/cli/commands/fill_form.py
+pdffiller/cli/commands/sanitize.py
 pdffiller/io/__init__.py
 pdffiller/io/colors.py
 pdffiller/io/output.py
@@ -65,9 +67,11 @@ tests/conftest.py
 tests/cli/__init__.py
 tests/cli/test_dump_data_field.py
 tests/cli/test_fill_form.py
+tests/cli/test_sanitize.py
 tests/data/empty.pdf
 tests/data/input.pdf
 tests/unit/__init__.py
 tests/unit/test_form_field.py
 tests/unit/test_formatters.py
+tests/unit/test_sanitize.py
 tests/unit/test_setup.py

python_pdffiller-2.0.4/tests/cli/test_sanitize.py

@@ -0,0 +1,124 @@
+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 command without required arguments"""
+
+    # Test through direct command-line
+    with mock.patch("sys.argv", ["pdffiller", "sanitize"] + argv):
+        assert cli.main() == ERROR_UNEXPECTED
+
+    # Test with direct call to main function
+    assert cli.main(["sanitize"] + argv) == ERROR_UNEXPECTED
+
+
+def test_complete(test_data_dir, output_pdf_path, capsys):
+    """test sanitize command with text output"""
+
+    argv = [
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "sanitize"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        assert output_pdf_path.exists()
+        output_pdf_path.unlink()
+
+    # Test with direct call to main function
+    assert cli.main(["sanitize"] + argv) == SUCCESS
+    assert output_pdf_path.exists()
+
+
+def test_complete_json_output(test_data_dir, output_pdf_path, capsys):
+    """test sanitize command with JSON output"""
+
+    argv = [
+        "-fjson",
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "sanitize"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        out, err = capsys.readouterr()
+        # Output should be valid JSON (or empty if no fields to sanitize)
+        if out.strip():
+            sanitized = json.loads(out)
+            assert isinstance(sanitized, list)
+            for field in sanitized:
+                assert "FieldName" in field
+                assert "FieldType" in field
+                assert "MaxLen" in field
+
+
+def test_complete_with_deep(test_data_dir, output_pdf_path):
+    """test sanitize command with --deep option"""
+
+    argv = [
+        "--deep",
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "input.pdf"),
+    ]
+
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "sanitize"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+        assert output_pdf_path.exists()
+        output_pdf_path.unlink()
+
+    # Test with direct call to main function
+    assert cli.main(["sanitize"] + argv) == SUCCESS
+    assert output_pdf_path.exists()
+
+
+def test_complete_with_invalid_file(test_data_dir, output_pdf_path):
+    """test sanitize command with invalid PDF"""
+
+    argv = [
+        "-o",
+        str(output_pdf_path),
+        str(test_data_dir / "empty.pdf"),
+    ]
+
+    # PdfFillerException is caught and logged, command returns SUCCESS
+    # Test through direct command-line
+    with mock.patch(
+        "sys.argv",
+        ["pdffiller", "sanitize"] + argv,
+    ):
+        assert cli.main() == SUCCESS
+
+    # Test with direct call to main function
+    assert cli.main(["sanitize"] + argv) == SUCCESS

python_pdffiller-2.0.4/tests/unit/test_sanitize.py

@@ -0,0 +1,98 @@
+import pytest
+
+from pdffiller.pdf import Pdf
+
+
+def test_sanitize_removes_maxlen(test_data_dir, output_pdf_path):
+    """Test that sanitize removes MaxLen from text fields without Comb flag"""
+    pdf = Pdf()
+    sanitized = pdf.sanitize(
+        str(test_data_dir / "input.pdf"),
+        str(output_pdf_path),
+    )
+
+    # Verify output file was created
+    assert output_pdf_path.exists()
+
+    # Verify sanitized fields are text fields with a MaxLen value
+    for field in sanitized:
+        assert "FieldName" in field
+        assert "FieldType" in field
+        assert "MaxLen" in field
+        assert field["FieldType"] == "Text"
+        assert isinstance(field["MaxLen"], int)
+        assert field["MaxLen"] > 0
+
+
+def test_sanitize_output_has_no_maxlen(test_data_dir, output_pdf_path):
+    """Test that the sanitized PDF has no MaxLen on non-Comb text fields"""
+    pdf = Pdf()
+    pdf.sanitize(
+        str(test_data_dir / "input.pdf"),
+        str(output_pdf_path),
+    )
+
+    # Re-read the sanitized PDF and check that text fields have no MaxLen
+    sanitized_pdf = Pdf(str(output_pdf_path))
+    for widget in sanitized_pdf.widgets.values():
+        if hasattr(widget, "max_length") and not _has_comb_in_pdf(
+            str(output_pdf_path), widget.name
+        ):
+            assert widget.max_length is None or widget.max_length == 0
+
+
+def test_sanitize_deep_mode(test_data_dir, output_pdf_path):
+    """Test that deep mode also processes fields with Comb flag"""
+    pdf = Pdf()
+    sanitized_normal = pdf.sanitize(
+        str(test_data_dir / "input.pdf"),
+        str(output_pdf_path),
+    )
+
+    # Deep mode should sanitize at least as many fields as normal mode
+    output_pdf_path_deep = output_pdf_path.parent / "deep_output.pdf"
+    pdf2 = Pdf()
+    sanitized_deep = pdf2.sanitize(
+        str(test_data_dir / "input.pdf"),
+        str(output_pdf_path_deep),
+        deep=True,
+    )
+
+    assert len(sanitized_deep) >= len(sanitized_normal)
+
+    if output_pdf_path_deep.exists():
+        output_pdf_path_deep.unlink()
+
+
+def test_sanitize_returns_list(test_data_dir, output_pdf_path):
+    """Test that sanitize returns a list"""
+    pdf = Pdf()
+    result = pdf.sanitize(
+        str(test_data_dir / "input.pdf"),
+        str(output_pdf_path),
+    )
+    assert isinstance(result, list)
+
+
+def test_sanitize_invalid_pdf(test_data_dir, output_pdf_path):
+    """Test that sanitize raises on invalid PDF"""
+    from pdffiller.exceptions import PdfFillerException
+
+    pdf = Pdf()
+    with pytest.raises(PdfFillerException):
+        pdf.sanitize(
+            str(test_data_dir / "empty.pdf"),
+            str(output_pdf_path),
+        )
+
+
+def _has_comb_in_pdf(pdf_path, field_name):
+    """Helper to check if a field has Comb flag set"""
+    import pymupdf
+
+    doc = pymupdf.open(filename=pdf_path)
+    for page in doc:
+        for widget in page.widgets():
+            if widget.field_name == field_name:
+                return bool(widget.field_flags & Pdf.COMB_FLAG)
+    return False