pdform 0.2.0__tar.gz

pdform-0.2.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.3
+Name: pdform
+Version: 0.2.0
+Summary: A library and command-line tool for working with PDF interactive forms. Uses pikepdf and pdf2htmlex.
+Author: Dominick Johnson
+Author-email: dominick.johnson@tylertech.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: beautifulsoup4 (>=4.13.4,<5.0.0)
+Requires-Dist: click (>=8.2.0,<9.0.0)
+Requires-Dist: pikepdf (>=9.8.0,<10.0.0)
+Requires-Dist: pillow (>=11.2.1,<12.0.0)
+Project-URL: Homepage, https://github.com/dmjohnsson23/pdform-pikpdf
+Description-Content-Type: text/x-rst
+
+======
+PDForm
+======
+
+A library and command-line tool for working with PDF interactive forms. It can:
+
+* Describe the available fields in the form
+* Convert the PDF to an HTML form
+* Populate the PDF form with data
+
+Uses `Pikepdf <https://pikepdf.readthedocs.io/en/latest/index.html>`_.
+
+
+----------------
+Describing Forms
+----------------
+
+The `pdform describe` command can be used to get information about a PDF form, such as the names and types of fields, allowable options, and so forth. Use `pdform describe --help` for command-line options.
+
+.. code-block:: shell
+
+    pdform describe form.pdf
+
+By default, it will show every field in the form, together with all the relevant details about the field. Command-line options exist to filter this view for easier parsing.
+
+.. code-block::
+
+    =========================================================================
+    stream <_io.BufferedReader name='../../pikepdf/tests/resources/form.pdf'>
+    =========================================================================
+
+    Text1
+    -----
+
+    Label:
+            Text1
+
+    Type:
+            TextField
+
+    Required:
+            No
+
+    Read Only:
+            No
+
+    Multiline:
+            No
+
+    Max Length:
+            None
+
+    Default Value:
+
+
+    Current Value:
+
+    ... and so on ...
+
+-------------
+Filling Forms
+-------------
+
+Filling forms is done using the `pdform fill-form` command. Typically, this will be done using JSON-formatted data, such as:
+
+.. code-block:: json
+
+    {
+        "TextField1": "Some Text",
+        "Checkbox1": true,
+        "RadioGroup1": "3",
+        "ChoiceField1": "Option 4",
+        "SignatureField": "/home/myself/signature.png"
+    }
+
+You can then call the command with this JSON:
+
+.. code-block:: shell
+
+    pdform fill-form template.pdf output.pdf data.json
+
+Or pipe this JSON into the command:
+
+.. code-block:: shell
+
+    echo {your json here} | pdform fill-form template.pdf output.pdf -
+
+
+------------------
+Converting to HTML
+------------------
+
+Converting to HTML relies on `pdf2htmlEX <https://pdf2htmlex.github.io/pdf2htmlEX/>`_ to generate the initial HTML. We then use `BeautifulSoup <https://beautiful-soup-4.readthedocs.io/en/latest/>`_ to strip away most of the unnessesary code, and add the form fields.
+
+This function can be activated in one of two ways:
+
+
+1. The `pdform make-html` command. Use `pdform make-html --help` for details.
+2. Directly via Python.
+
+The command-line interface is sufficient for basic usage. It provides a handful of different output formats: plain HTML, Jinja, and PHP.
+
+.. code-block:: shell
+
+    pdform make-html --jinja input.pdf output.jinja
+
+However, it is likely you may wish to customize the rendered HTML. The Python interfaces gives much more flexibility for this.
+
+.. code-block:: python
+
+    from pdform.make_html import FieldRenderer, make_html
+
+    # Define your own field renderer to control the emitted code for form fields
+    class MyFieldRenderer(FieldRenderer):
+        # See the source code for details on how to implement this class
+        ...
+
+    soup = make_html(path, field_renderer_class=MyFieldRenderer)
+    # Use the BeautifulSoup object to perform any post-processing to the generated HTML
+    # (See the BeautifulSoup documentation for how to use it to manipulate the DOM)
+    ...
+    # Output the rendered HTML
+    print(soup.prettify())

pdform-0.2.0/README.rst

@@ -0,0 +1,123 @@
+======
+PDForm
+======
+
+A library and command-line tool for working with PDF interactive forms. It can:
+
+* Describe the available fields in the form
+* Convert the PDF to an HTML form
+* Populate the PDF form with data
+
+Uses `Pikepdf <https://pikepdf.readthedocs.io/en/latest/index.html>`_.
+
+
+----------------
+Describing Forms
+----------------
+
+The `pdform describe` command can be used to get information about a PDF form, such as the names and types of fields, allowable options, and so forth. Use `pdform describe --help` for command-line options.
+
+.. code-block:: shell
+
+    pdform describe form.pdf
+
+By default, it will show every field in the form, together with all the relevant details about the field. Command-line options exist to filter this view for easier parsing.
+
+.. code-block::
+
+    =========================================================================
+    stream <_io.BufferedReader name='../../pikepdf/tests/resources/form.pdf'>
+    =========================================================================
+
+    Text1
+    -----
+
+    Label:
+            Text1
+
+    Type:
+            TextField
+
+    Required:
+            No
+
+    Read Only:
+            No
+
+    Multiline:
+            No
+
+    Max Length:
+            None
+
+    Default Value:
+
+
+    Current Value:
+
+    ... and so on ...
+
+-------------
+Filling Forms
+-------------
+
+Filling forms is done using the `pdform fill-form` command. Typically, this will be done using JSON-formatted data, such as:
+
+.. code-block:: json
+
+    {
+        "TextField1": "Some Text",
+        "Checkbox1": true,
+        "RadioGroup1": "3",
+        "ChoiceField1": "Option 4",
+        "SignatureField": "/home/myself/signature.png"
+    }
+
+You can then call the command with this JSON:
+
+.. code-block:: shell
+
+    pdform fill-form template.pdf output.pdf data.json
+
+Or pipe this JSON into the command:
+
+.. code-block:: shell
+
+    echo {your json here} | pdform fill-form template.pdf output.pdf -
+
+
+------------------
+Converting to HTML
+------------------
+
+Converting to HTML relies on `pdf2htmlEX <https://pdf2htmlex.github.io/pdf2htmlEX/>`_ to generate the initial HTML. We then use `BeautifulSoup <https://beautiful-soup-4.readthedocs.io/en/latest/>`_ to strip away most of the unnessesary code, and add the form fields.
+
+This function can be activated in one of two ways:
+
+
+1. The `pdform make-html` command. Use `pdform make-html --help` for details.
+2. Directly via Python.
+
+The command-line interface is sufficient for basic usage. It provides a handful of different output formats: plain HTML, Jinja, and PHP.
+
+.. code-block:: shell
+
+    pdform make-html --jinja input.pdf output.jinja
+
+However, it is likely you may wish to customize the rendered HTML. The Python interfaces gives much more flexibility for this.
+
+.. code-block:: python
+
+    from pdform.make_html import FieldRenderer, make_html
+
+    # Define your own field renderer to control the emitted code for form fields
+    class MyFieldRenderer(FieldRenderer):
+        # See the source code for details on how to implement this class
+        ...
+
+    soup = make_html(path, field_renderer_class=MyFieldRenderer)
+    # Use the BeautifulSoup object to perform any post-processing to the generated HTML
+    # (See the BeautifulSoup documentation for how to use it to manipulate the DOM)
+    ...
+    # Output the rendered HTML
+    print(soup.prettify())

pdform-0.2.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "pdform"
+version = "0.2.0"
+description = "A library and command-line tool for working with PDF interactive forms. Uses pikepdf and pdf2htmlex."
+authors = [
+    {name = "Dominick Johnson",email = "dominick.johnson@tylertech.com"}
+]
+readme = "README.rst"
+requires-python = ">=3.11"
+dependencies = [
+    "pikepdf (>=9.8.0,<10.0.0)",
+    "click (>=8.2.0,<9.0.0)",
+    "pillow (>=11.2.1,<12.0.0)",
+    "beautifulsoup4 (>=4.13.4,<5.0.0)"
+]
+
+[tool.poetry]
+packages = [{include = "pdform", from = "src"}]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+pdform = 'pdform.cli:cli'
+
+[project.urls]
+Homepage = "https://github.com/dmjohnsson23/pdform-pikpdf"

pdform-0.2.0/src/pdform/__main__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+cli()

pdform-0.2.0/src/pdform/cli.py

@@ -0,0 +1,12 @@
+import click
+from .make_html.cli import cli as make_html
+from .describe import describe
+from .fill_form import cli as fill_form
+
+@click.group()
+def cli():
+    pass
+
+cli.add_command(make_html)
+cli.add_command(describe)
+cli.add_command(fill_form)

pdform-0.2.0/src/pdform/describe.py

@@ -0,0 +1,124 @@
+import click
+from pikepdf import Pdf
+from pikepdf.form import Form, TextField, CheckboxField, RadioButtonGroup, ChoiceField, SignatureField
+import re
+
+@click.command
+@click.argument('path', type=click.File('rb'))
+@click.option('--text', 'filter_types', help='Show text fields. (If no type filters are provided, all will be implied true)', multiple=True, flag_value='text')
+@click.option('--checkbox', 'filter_types', help='Show checkbox fields. (If no type filters are provided, all will be implied true)', multiple=True, flag_value='checkbox')
+@click.option('--radio', 'filter_types', help='Show radio fields. (If no type filters are provided, all will be implied true)', multiple=True, flag_value='radio')
+@click.option('--choice', 'filter_types', help='Show choice fields. (If no type filters are provided, all will be implied true)', multiple=True, flag_value='choice')
+@click.option('--signature', 'filter_types', help='Show signature fields. (If no type filters are provided, all will be implied true)', multiple=True, flag_value='signature')
+@click.option('--name', '-n', 'filter_name', help='Show only fields with a name containing the given string. Use slashes to build a regex.', multiple=True, type=click.STRING)
+@click.option('--label', '-l', 'filter_label', help='Show only fields with a label containing the given string. Use slashes to build a regex.',multiple=True, type=click.STRING)
+@click.option('--names-only/--full-info', 'names_only', help='Determines if detailed information should be shown, or only field names.', default=False)
+def describe(path, filter_types, filter_name, filter_label, names_only):
+    """
+    Describe the fields in a form
+    """
+    something_shown = False
+    with Pdf.open(path) as pdf:
+        form = Form(pdf)
+
+        with pdf.open_metadata() as meta:
+            title = meta.get('dc:title', pdf.filename)
+            click.secho('=' * len(title), reverse=True)
+            click.secho(title, reverse=True)
+            click.secho('=' * len(title), reverse=True)
+            click.echo()
+
+        if not form.exists:
+            click.secho("No interactive form exists in this document.", fg='yellow')
+            return
+
+
+        for name, field in form.items():
+            if filter_types:
+                if isinstance(field, TextField) and 'text' not in filter_types:
+                    continue
+                if isinstance(field, CheckboxField) and 'checkbox' not in filter_types:
+                    continue
+                if isinstance(field, RadioButtonGroup) and 'radio' not in filter_types:
+                    continue
+                if isinstance(field, ChoiceField) and 'choice' not in filter_types:
+                    continue
+                if isinstance(field, SignatureField) and 'signature' not in filter_types:
+                    continue
+            
+            if filter_name and not filter_match(filter_name, name):
+                continue
+            if filter_label and not filter_match(filter_label, field.alternate_name):
+                continue
+
+            something_shown = True
+
+            if names_only:
+                click.echo(name)
+                continue
+
+            click.secho(name, reverse=True, fg='cyan')
+            click.secho('-' * len(name), reverse=True, fg='cyan')
+            click.echo()
+            click.secho('Label:', fg='cyan')
+            click.echo("\t"+field.alternate_name)
+            click.echo()
+            click.secho('Type:', fg='cyan')
+            click.echo("\t"+type(field).__name__)
+            click.echo()
+            click.secho('Required:', fg='cyan')
+            click.echo("\t"+('Yes' if field.is_required else 'No'))
+            click.echo()
+            click.secho('Read Only:', fg='cyan')
+            click.echo("\t"+('Yes' if field.is_read_only else 'No'))
+            click.echo()
+
+            if isinstance(field, TextField):
+                click.secho('Multiline:', fg='cyan')
+                click.echo("\t"+('Yes' if field.is_multiline else 'No'))
+                click.echo()
+                click.secho('Max Length:', fg='cyan')
+                click.echo("\t"+str(field.max_length))
+                click.echo()
+            elif isinstance(field, CheckboxField):
+                click.secho('"On" Value:', fg='cyan')
+                click.echo("\t"+str(field.on_value))
+                click.echo()
+            elif isinstance(field, RadioButtonGroup):
+                click.secho('Can Toggle Off:', fg='cyan')
+                click.echo("\t"+('Yes' if field.can_toggle_off else 'No'))
+                click.echo()
+                click.secho('Possible Values:', fg='cyan')
+                for option in field.options:
+                    click.echo("\t* "+str(option.on_value))
+                click.echo()
+            elif isinstance(field, ChoiceField):
+                click.secho('Possible Values:', fg='cyan')
+                for option in field.options:
+                    click.echo("\t* "+str(option.display_value))
+                click.echo()
+            
+            click.secho('Default Value:', fg='cyan')
+            click.echo("\t"+str(field.default_value))
+            click.echo()
+            click.secho('Current Value:', fg='cyan')
+            click.echo("\t"+str(field.value))
+            click.echo()
+    
+    if not something_shown:
+        click.secho("No fields match the given criteria.", fg='yellow')
+            
+
+def filter_match(filters, match_against):
+    matched = False
+    for fl in filters:
+        if fl.startswith('/') and fl.endswith('/'):
+            if re.search(fl[1:-2], match_against):
+                matched = True
+        elif fl.lower() in match_against.lower():
+            matched = True
+    return matched
+
+
+if __name__ == '__main__':
+    describe()

pdform-0.2.0/src/pdform/fill_form.py

@@ -0,0 +1,116 @@
+from io import BytesIO
+from pikepdf import Name, Pdf, Page, Rectangle
+from pikepdf.form import Form, TextField, CheckboxField, RadioButtonGroup, ChoiceField, SignatureField, ExtendedAppearanceStreamGenerator
+from PIL import Image
+import click
+
+
+@click.command('fill-form', help='Populate the template with the provided data')
+@click.argument('template', type=click.File(), required=True)
+@click.argument('output', type=click.File('w'), required=True)
+@click.argument('data-file', type=click.File(), default='-')
+@click.option('--data-format', help='The format of the data file.', type=click.Choice(('json',)), default='json')
+@click.option('--set', '-s', 'cli_data', nargs=2, multiple=True, help='Set a field value in the form. Using this option causes the data file to be ignored.')
+def cli(template, output, data_file, data_format, cli_data):
+    if cli_data:
+        data = dict(cli_data)
+    else:
+        data = parse_data(data_format, data_file)
+    with Pdf.open(template) as pdf:
+        fill_form(pdf, data)
+        pdf.save(output)
+
+
+def parse_data(format, file):
+    if format == 'json':
+        from json import load
+        return load(file)
+
+
+def img_to_pdf(img) -> Pdf:
+    """
+    Convert an image to a PDF.
+
+    The input image may be:
+
+    * An open file-like object
+    * A path
+    * A base64 data URL
+    """
+    if isinstance(img, str) and img.startswith('data:'):
+        # embedded base64
+        from base64 import b64decode
+        _, path = path.split(',', 2)
+        path = BytesIO(b64decode(path))
+    # Open image and convert to RGB (Greyscale images cause issues)
+    img = Image.open(img).convert('RGB')
+    # Convert the image to a PDF
+    pdf_img = BytesIO()
+    img.save(pdf_img, 'pdf')
+    pdf_img.seek(0)
+    return Pdf.open(pdf_img)
+
+
+def stamp(img, page:Page, rect:Rectangle):
+    """
+    Stamp an image on the page, fitting it in the box of the given rect.
+
+    :param img: The image to stamp. Can be a file path, open file object, or base64 data URL.
+    :param page: The page to stamp the image on.
+    :param rect: The box in which to place the image. The image will be scaled to fit.
+    """
+    with img_to_pdf(img) as stamp_pdf:
+        page.add_overlay(stamp_pdf.pages[0], rect)
+
+
+def fill_form(pdf:Pdf, data:dict):
+    """
+    Fill the form fields of the given PDF with the data provided.
+
+    :param pdf: The PDF to populate with data
+    :param data: The data to populate the form with. The keys of this dictionary should match
+        the field's fully-qualified name. The values should be as follows:
+
+        * For text fields, provide the value to set
+        * For checkboxes, provide a boolean
+        * For radio buttons, provide the value in the button's AP.N dictionary
+        * For signature fields, provide the path to an image which will be stamped in its place
+          (real cryptographic signatures are not supported)
+    """
+    # Populate form
+    form = Form(pdf, ExtendedAppearanceStreamGenerator)
+    for key, field in form.items():
+        if key and key in data and data[key] is not None:
+            value = data[key]
+            if isinstance(field, (TextField, ChoiceField)):
+                field.value = value
+            elif isinstance(field, CheckboxField):
+                if value is True:
+                    field.checked = True
+                elif value is None or value is False:
+                    field.checked = False
+                else:
+                    field.value = to_name(value)
+            elif isinstance(field, RadioButtonGroup):
+                field.value = to_name(value)
+            elif isinstance(field, SignatureField):
+                if isinstance(value, str):
+                    img = value
+                    expand = None
+                else:
+                    img = value['img']
+                    expand = value.get('expand_rect')
+                with img_to_pdf(img) as stamp_pdf:
+                    field.stamp_overlay(stamp_pdf.pages[0], expand_rect=expand)
+    if '.stamps' in data:
+        # Custom stamps not associated with fields
+        for stamp_data in data['.stamps']:
+            if not stamp_data['img']:
+                continue
+            stamp(stamp_data['img'], pdf.pages[stamp_data['page']-1], Rectangle(*stamp_data['rect']))
+
+
+def to_name(value: str):
+    if not value.startswith('/'):
+        value = f"/{value}"
+    return Name(value)

pdform-0.2.0/src/pdform/make_html/__init__.py

@@ -0,0 +1,3 @@
+from .field_renderer import FieldRenderer, JinjaFieldRenderer, PHPFieldRenderer
+from .make_html import make_html
+from .process_form import add_form_fields

pdform-0.2.0/src/pdform/make_html/cli.py

@@ -0,0 +1,26 @@
+import click
+from .make_html import make_html
+from .field_renderer import FieldRenderer, PHPFieldRenderer, JinjaFieldRenderer
+
+
+@click.command('make-html', help='Convert a PDF form into an HTML form')
+@click.argument('path', type=click.Path(True, dir_okay=False))
+@click.argument('output', type=click.File('w'))
+@click.option('--pdf2html', help='Override the path used to call Pdf2HmlEX', default='pdf2htmlex')
+@click.option('--zoom', help='The size at which to render the PDF into HTML', type=click.FloatRange(0, None, True), default=1)
+@click.option('--sort-widgets/--original-widget-sorting', help='Attempt to re-sort widgets based on their location on the page.', default=False)
+@click.option('--rename-fields/--original-fields-naming', help='Rename fields, removing special characters.', default=False)
+@click.option('--from-page', help='Start rendering at this page', type=click.IntRange(1), default=1)
+@click.option('--to-page', help='Stop rendering after this page', type=click.IntRange(1))
+@click.option('--html', 'field_renderer_class', help='Render the page as plain HTML', flag_value='html', default=True)
+@click.option('--php', 'field_renderer_class', help='Render the page as PHP code', flag_value='php')
+@click.option('--jinja', 'field_renderer_class', help='Render the page as a Jinja template', flag_value='jinja')
+def cli(path, output, *, field_renderer_class, **kwargs):
+    kwargs['field_renderer_class'] = {
+        'html':FieldRenderer,
+        'php':PHPFieldRenderer,
+        'jinja':JinjaFieldRenderer,
+    }[field_renderer_class]
+    soup = make_html(path, **kwargs)
+    output.write(str(soup))
+    return output

pdform-0.2.0/src/pdform/make_html/field_renderer.py

@@ -0,0 +1,225 @@
+from html import escape
+from pikepdf.form import _FieldWrapper
+
+class FieldRenderer:
+    """
+    Used to render HTML inputs in the output HTML. Subclass to output the inputs in various different template formats (e.g. Jinja, PHP, etc...).
+    """
+    _renderer_type = None
+    type: str
+    name: str
+    label: str
+    style: dict
+    field: _FieldWrapper
+
+    def __init__(self, field):
+        self.field = field
+
+    @classmethod
+    def set_render_type(cls, renderer):
+        if not issubclass(renderer, cls):
+            raise TypeError('Renderer type must be a subclass of FieldRenderer')
+        cls._renderer_type = renderer
+    
+    @classmethod
+    def make(cls, type, field):
+        renderer = (cls._renderer_type or cls)(field)
+        renderer.type = type
+        return renderer
+    
+    def __str__(self):
+        return self.render()
+
+    def render(self):
+        if self.type == 'button':
+            return self.render_button()
+        if self.type == 'checkbox':
+            return self.render_checkbox()
+        if self.type == 'file':
+            return self.render_file()
+        if self.type == 'password':
+            return self.render_password()
+        if self.type == 'radio':
+            return self.render_radio()
+        if self.type == 'select':
+            return self.render_select()
+        if self.type == 'signature':
+            return self.render_signature()
+        if self.type == 'text':
+            return self.render_text()
+        if self.type == 'textarea':
+            return self.render_textarea()
+        raise ValueError(f'Unknown input type: {self.type}')
+
+    def render_style_attr_value(self):
+        if self.style is None:
+            return None
+        return escape(';'.join([f"{key}:{value}" for key,value in self.style.items()]))
+    
+    def render_template_value_variable(self):
+        """If this renderer is for a template type, returns the variable name that should contain the value of this field."""
+        return ''
+
+    def render_button(self):
+        """Render a push button using the properties of this renderer"""
+        return f""""""
+
+    def render_checkbox(self):
+        """Render a checkbox using the properties of this renderer"""
+        return f"""<input type='checkbox' {self.render_basic_attrs()} {self.render_value_checked_if()}/>"""
+
+    def render_file(self):
+        """Render a file input using the properties of this renderer"""
+        return f""""""
+
+    def render_password(self):
+        """Render a password input using the properties of this renderer"""
+        return f"""<input type='password' {self.render_basic_attrs()} {self.render_value_attr()}/>"""
+
+    def render_radio(self):
+        """Render a radio button using the properties of this renderer"""
+        return f"""<input type='radio' {self.render_basic_attrs()} {self.render_value_checked_if()}/>"""
+
+    def render_select(self):
+        """Render a select element using the properties of this renderer"""
+        return f"""<select {self.render_basic_attrs()}>
+        {''.join(f"<option>{opt.display_value}</option>" for opt in self.field.options)}
+        </select>"""
+
+    def render_signature(self):
+        """Render a signature field using the properties of this renderer"""
+        return f"""<input type='file' data-real-type='signature' {self.render_basic_attrs()}/>"""
+
+    def render_text(self):
+        """Render a text field using the properties of this renderer"""
+        return f"""<input type='text' {self.render_basic_attrs()} {self.render_value_attr()}/>"""
+
+    def render_textarea(self):
+        """Render a multiline text field using the properties of this renderer"""
+        return f"""<textarea {self.render_basic_attrs()}>{self.render_value_content()}</textarea>"""
+
+    def render_basic_attrs(self):
+        """Render the basic attributes (name and style) to apply to the field, regardless of type."""
+        return f"""name='{escape(self.name)}' aria-label='{escape(self.label)}' style='{self.render_style_attr_value()}'"""
+    
+    def render_value_attr(self):
+        """Render the value attribute of a field, or template code to generate such"""
+        return ''
+    
+    def render_value_content(self):
+        """Render the raw value of a field (e.g. for use in a textarea), or template code to generate such"""
+        return ''
+    
+    def render_value_checked_if(self):
+        """Render the 'checked' attribute for checkboxes or radio buttons, or template code to generate such"""
+        return ''
+
+    def render_html_escape(self, value:str):
+        """Given a string, which should be a statement in the target template language, and add the 
+        code necessary to escape the results for safe inclusion in HTML source."""
+        return value
+    
+    def render_echo_statement(self, stmt:str):
+        """Given a string, which should be a statement in the target template language, render the 
+        necessary syntax to output the result of the statement into the rendered HTML."""
+        return ''
+    
+    def render_echo_statement_if(self, condition:str, stmt:str, *, html_escape=True):
+        """Given two strings, which should be statements in the target template language, render the 
+        necessary syntax to output the result of the second statement into the rendered HTML, 
+        conditional on the value of the first."""
+        return ''
+    
+    def render_if(self, condition:str, html:str):
+        """Given two strings, the first of which should be a statement in the target template 
+        language, and the second of which is raw HTML or template code, render the necessary syntax 
+        to output the raw value conditional on the statement."""
+        return html
+
+
+
+class PHPFieldRenderer(FieldRenderer):
+    """
+    Render the HTML as PHP source code.
+    """
+    def render_echo_statement(self, stmt:str):
+        return f"<?={stmt}?>"
+    
+    def render_echo_statement_if(self, condition:str, stmt:str, *, html_escape=True):
+        if html_escape:
+            stmt = self.render_html_escape(stmt)
+        return self.render_echo_statement(
+            f"{condition} ? '' : {stmt}"
+        )
+    
+    def render_if(self, condition:str, html:str):
+        return f"<?php if ({condition}):?>{html}<?endif;?>"
+
+    def render_template_value_variable(self):
+        return f"""$fd['{self.name}']"""
+    
+    def render_value_attr(self):
+        return self.render_echo_statement_if(
+            f"empty({self.render_template_value_variable()})",
+            f"""'value="'.{self.render_html_escape(self.render_template_value_variable())}.'"'""",
+            html_escape=False
+        )
+    
+    def render_value_content(self):
+        return self.render_echo_statement_if(
+            f"empty({self.render_template_value_variable()})",
+            self.render_template_value_variable()
+        )
+    
+    def render_value_checked_if(self):
+        return self.render_echo_statement_if(
+            f"empty({self.render_template_value_variable()})",
+            f"'checked'",
+            html_escape=False
+        )
+
+    def render_html_escape(self, value:str):
+        return f"htmlspecialchars({value})"
+
+
+class JinjaFieldRenderer(FieldRenderer):
+    """
+    Render the HTML as a Jinja template. This does not use advanced Jinja features, so templates 
+    produced may work in other template engines with a similar syntax, requiring little or no 
+    modification.
+    """
+    def render_echo_statement(self, stmt:str):
+        return f"{{{{{stmt}}}}}"
+    
+    def render_echo_statement_if(self, condition:str, stmt:str, *, html_escape=True):
+        if html_escape:
+            stmt = self.render_html_escape(stmt)
+        return self.render_if(condition, self.render_echo_statement(stmt))
+    
+    def render_if(self, condition:str, html:str):
+        return f"""{{% if {condition} %}}{html}{{% endif %}}"""
+    
+    def render_template_value_variable(self):
+        return f"""fd['{self.name}']"""
+    
+    def render_value_attr(self):
+        value = self.render_echo_statement(self.render_html_escape(self.render_template_value_variable()))
+        return self.render_if(
+            self.render_template_value_variable(),
+            f"value='{value}'"
+        )
+    
+    def render_value_content(self):
+        return self.render_echo_statement_if(
+            self.render_template_value_variable(),
+            self.render_template_value_variable()
+        )
+    
+    def render_value_checked_if(self):
+        return self.render_if(
+            self.render_template_value_variable(),
+            'checked'
+        )
+
+    def render_html_escape(self, value:str):
+        return f"{value} | e"

pdform-0.2.0/src/pdform/make_html/make_html.py

@@ -0,0 +1,112 @@
+import os
+from subprocess import run
+from .template_soup import TemplateSoup
+from bs4 import Tag, BeautifulSoup
+import tempfile
+from .process_form import add_form_fields
+from pathlib import Path
+from pikepdf import Pdf
+from pikepdf.form import Form
+import re
+from base64 import urlsafe_b64decode
+from io import StringIO
+
+
+def make_html(path:str|Path, *, pdf2html:str='pdf2htmlex', zoom:int|float=1, from_page:int|None=None, to_page:int|None=None, **process_form_args):
+    output_path = tempfile.mktemp()
+    
+    pdf2html_options = [
+        '--zoom', str(zoom), 
+        '--no-drm', '1',
+        '--printing', '0',
+        '--bg-format', 'svg',
+    ]
+    if from_page is not None:
+        pdf2html_options.append('--first-page')
+        pdf2html_options.append(str(from_page))
+    if to_page is not None:
+        pdf2html_options.append('--last-page')
+        pdf2html_options.append(str(to_page))
+
+    # Run pdf2htmlex to get the initial base HTML
+    result = run([
+        pdf2html,
+        *pdf2html_options,
+        path,
+        os.path.relpath(output_path)
+    ])
+    result.check_returncode()
+
+    with open(output_path, 'r') as file:
+        soup = TemplateSoup(file, 'lxml')
+
+    # Remove all the extra stuff we don't need
+    for script in soup.find_all('script'):
+        script.decompose()
+    for el in soup.find_all(id='sidebar'):
+        el.decompose()
+    for el in soup.find_all(class_='loading-indicator'):
+        el.decompose()
+    for el in soup.find_all(class_='pi'):
+        el.decompose()
+    for el in soup.find_all('img'):
+        unwrap_svg_img(el)
+    for el in soup.find_all('style'):
+        if '* Fancy styles for pdf2htmlEX' in el.string:
+            el.decompose()
+        elif '* Base CSS for pdf2htmlEX' in el.string:
+            # This one also has a lot of junk we don't need, but some stuff we do.
+            css = el.string
+            # All the UI-related stuff right after the header
+            css = re.sub('(?<=\*/).*?(?=\.pf\{)', '', css)
+            # Selection, page info (.pi), css drawings (.d), text input (.it), radio input (.ir) 
+            css = re.sub('::(-moz-)?selection\{background:rgba\(127,255,255,0\.4\)\}.*', '', css)
+            el.string = css
+    # Copy any new styles we've created
+    sio = StringIO()
+    for style, css_class in svg_path_styles.items():
+        sio.write('.')
+        sio.write(css_class)
+        sio.write('{')
+        sio.write(style)
+        sio.write('}\n')
+    sio.seek(0)
+    new_styles = soup.new_tag('style')
+    new_styles.string = sio.read()
+    soup.head.append(new_styles)
+    
+    # Add our own stuff direct from the PDF
+    with Pdf.open(path) as pdf:
+        form = Form(pdf)
+        add_form_fields(soup, pdf, form,
+            zoom=zoom, 
+            start_page=from_page,
+            **process_form_args
+        )
+
+    return soup
+
+
+path_style_counter = 0
+svg_path_styles = {}
+def unwrap_svg_img(img_el:Tag):
+    global path_style_counter, svg_path_styles
+    data_url = img_el['src']
+    if not data_url.startswith('data:image/svg+xml;base64,'):
+        return
+    data_url = data_url[26:]
+    svg = BeautifulSoup(urlsafe_b64decode(data_url), 'xml').svg
+    del svg['xmlns']
+    del svg['xmlns:xlink']
+    svg['class'] = img_el['class']
+    for path in svg.find_all('path'):
+        style = path['style']
+        if style in svg_path_styles:
+            css_class = svg_path_styles[style]
+        else:
+            css_class = f"svp{path_style_counter}"
+            path_style_counter += 1
+            svg_path_styles[style] = css_class
+        del path['style']
+        path['class'] = css_class
+    img_el.replace_with(svg)

pdform-0.2.0/src/pdform/make_html/process_form.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+from .template_soup import TemplateSoup
+from pikepdf import Pdf, Annotation
+from pikepdf.form import Form, TextField, CheckboxField, RadioButtonGroup, ChoiceField, SignatureField
+from .field_renderer import FieldRenderer
+from typing import Type
+from functools import cmp_to_key
+
+
+def add_form_fields(soup: TemplateSoup, pdf:Pdf, form: Form, zoom: int|float = 1, rename_fields = {}, field_labels = {}, sort_widgets=False, start_page:int=1, field_renderer_class:Type[FieldRenderer]=FieldRenderer):
+    """
+    :param rename_fields: A mapping of PDF field names to desired HTML field names.
+    :param field_labels: A mapping of PDF field names to human-readable labels.
+    :param sort_widgets: Attempt to sort widgets according to their visual placement on the page. 
+        This can be useful for PDF forms where the tab order is illogical, though some manual 
+        refinement may still be needed afterward for a truly logical tab order.
+    """
+
+    html_form = soup.find(id='page-container').wrap(soup.new_tag('form'))
+    html_pages = html_form.find_all(class_='pf')
+    rendered_fields = {}
+    i = 0
+    for page_no, pdf_page in enumerate(pdf.pages, 1):
+        if page_no < start_page: continue
+        widgets = form.get_widget_annotations_for_page(pdf_page)
+        if not widgets: continue
+        html_page = html_pages[page_no-start_page]
+        fieldset = soup.new_tag('div', attrs={'class':'form-inputs'})
+        if callable(sort_widgets):
+            widgets = sort_widgets(widgets)
+        elif sort_widgets is True:
+            widgets = sorted(widgets, key=cmp_to_key(_cmp_widgets))
+        for widget in widgets:
+            widget: Annotation
+            field = form.get_field_for_annotation(widget)
+            i += 1
+            if field.is_radio_button:
+                field = RadioButtonGroup(form, field)
+                input = field_renderer_class.make('radio', field)
+            elif field.is_checkbox:
+                field = CheckboxField(form, field)
+                input = field_renderer_class.make('checkbox', field)
+            elif field.is_pushbutton:
+                input = field_renderer_class.make('button', field)
+            elif field.is_text:
+                field = TextField(form, field)
+                if field.is_multiline:
+                    input = field_renderer_class.make('textarea', field)
+                elif field.is_password:
+                    input = field_renderer_class.make('password', field)
+                elif field.is_password:
+                    input = field_renderer_class.make('file', field)
+                else:
+                    input = field_renderer_class.make('text', field)
+            elif field.is_choice:
+                field = ChoiceField(form, field)
+                input = field_renderer_class.make('select', field)
+            elif field.field_type == "/Sig":
+                field = SignatureField(form, field)
+                input = field_renderer_class.make('signature', field)
+            else:
+                continue
+            name = field.fully_qualified_name
+            if callable(rename_fields):
+                input.name = rename_fields(name, field)
+            elif isinstance(rename_fields, dict) and name in rename_fields:
+                input.name = rename_fields[name]
+            elif rename_fields is True:
+                input.name = _auto_rename(name)
+            else:
+                input.name = name
+            if name in field_labels:
+                input.label = field_labels[name]
+            else:
+                input.label = field.alternate_name
+            # The PDF format considers the bottom-left corner to be the origin, so we use that to place
+            scale = zoom
+            input.style = {
+                'position': 'absolute',
+                'left': f'{widget.rect.llx*scale}px',
+                'bottom': f'{widget.rect.lly*scale}px',
+                'width': f'{widget.rect.width*scale}px',
+                'height': f'{widget.rect.height*scale}px',
+            }
+            fieldset.append(soup.make_placeholder(value=input))
+        html_page.append(fieldset)
+    style = soup.new_tag('style')
+    style.append("""
+        .form-inputs{
+            bottom: 0;
+            left: 0;
+            position: absolute;
+        }
+        .form-inputs input,
+        .form-inputs textarea,
+        .form-inputs select{
+            border: none;
+            background: rgba(0,0,0,.05);
+            resize: none;
+            appearance: none;
+            margin: 0
+        }
+        .form-inputs input:hover,
+        .form-inputs textarea:hover,
+        .form-inputs select:hover{
+            box-shadow: inset 0 0 5px 5px rgba(0, 0, 0, .1);
+        }
+        .form-inputs input:checked::after{
+            display: block;
+            content: '\\2714';
+            width: 100%;
+            height: 100%;
+            text-align: center;
+        }
+    """)
+    soup.find('head').append(style)
+    return rendered_fields
+
+
+_rename_re = None
+def _auto_rename(name:str):
+    global _rename_re
+    if _rename_re is None:
+        import re
+        _rename_re = re.compile('[^A-Za-z0-9]+')
+    name = _rename_re.sub('_', name).strip('_')
+    if name[0].isdigit():
+        return f"_{name}"
+    return name
+
+
+def _cmp_widgets(wig1: Annotation, wig2: Annotation):
+    rect1 = wig1.rect
+    rect2 = wig2.rect
+    w1_then_w2 = -1
+    w2_then_w1 = 1
+    if rect1.lly >= rect2.ury:
+        # Bottom of wig1 above top of wig2; wig2 is after wig1
+        return w1_then_w2
+    if rect1.ury <= rect2.lly:
+        # Top of wig1 below bottom of wig2; wig2 is before wig1
+        return w2_then_w1
+    # The two are in line, or at leaest overlapping in the y direction; compare x values
+    if rect1.urx <= rect2.llx:
+        # Right of wig1 before left of wig2; wig2 is after wig1
+        return w1_then_w2
+    if rect1.llx >= rect2.urx:
+        # Left of wig1 after right of wig2; wig2 is before wig1
+        return w2_then_w1
+    # Rectangles overlap in both x and y directions, let's just compare top-left corner
+    if rect1.ury > rect2.ury:
+        # rect1 higher than rect2; wig2 is after wig1
+        return w1_then_w2
+    if rect1.ury < rect2.ury:
+        # rect1 lower than rect2; wig2 is before wig1
+        return w2_then_w1
+    if rect1.llx > rect2.llx:
+        # rect1 further than rect2; wig2 is before wig1
+        return w2_then_w1
+    if rect1.llx < rect2.llx:
+        # rect2 further than rect1; wig2 is after wig1
+        return w1_then_w2
+    # Okay, we give up, they share the same upper-left
+    return 0

pdform-0.2.0/src/pdform/make_html/template_soup.py

@@ -0,0 +1,51 @@
+from bs4 import BeautifulSoup
+from bs4.element import PreformattedString
+from string import Template
+from secrets import token_hex
+
+class TemplateSoup(BeautifulSoup):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.template = {}
+        self._substitutions = {}
+
+    def __str__(self):
+        return Template(super().__str__()).safe_substitute(self._substitutions)
+    
+    def prettify(self, *args, **kwargs):
+        return Template(super().prettify(*args, **kwargs)).safe_substitute(self._substitutions)
+    
+    def make_placeholder(self, name:str|None = None, value=None)->'Placeholder':
+        if name is None:
+            name = substitution_name = 'p'+token_hex(16)
+        else:
+            substitution_name = name+token_hex(8)
+        pl = Placeholder(substitution_name)
+        if value is not None:
+            pl.substitution_value = value
+        self.template[name] = pl
+        self._substitutions[substitution_name] = pl.substitution_string_proxy
+        return pl
+
+
+class Placeholder(PreformattedString):
+    PREFIX: str = "${"
+    SUFFIX: str = "}"
+
+    substitution_value = None
+    
+    @property
+    def substitution_string(self):
+        return str(self.substitution_value)
+    
+    @property
+    def substitution_string_proxy(self):
+        return _SubstitutionStringProxy(self)
+
+
+class _SubstitutionStringProxy:
+    def __init__(self, placeholder:Placeholder):
+        self.placeholder = placeholder
+    
+    def __str__(self):
+        return self.placeholder.substitution_string