Loop Mapping for Dynamic Attribute Tables

pip install geopandas>=0.14 jinja2>=3.1 weasyprint>=60 pandas>=2.1

import geopandas as gpd
import pandas as pd
from pathlib import Path


def extract_attributes(
    source_path: Path,
    required_fields: list[str],
    chunk_size: int | None = None,
) -> list[dict]:
    """Read a spatial file and return normalized attribute records for templating."""
    gdf = gpd.read_file(source_path, columns=required_fields)

    # Drop geometry — the template cannot serialize shapely objects
    df = pd.DataFrame(gdf[required_fields])

    # Normalize keys: lowercase, strip whitespace, replace spaces with underscores
    df.columns = [c.strip().lower().replace(" ", "_") for c in df.columns]

    # Coerce ambiguous object columns to numeric where possible
    for col in df.select_dtypes(include=["object"]).columns:
        df[col] = pd.to_numeric(df[col], errors="coerce").fillna(df[col])

    # Remove rows that are entirely empty (null geometry artefacts)
    df = df.dropna(how="all")

    if chunk_size:
        # Return a list of page-sized sublists for chunked rendering
        return [
            df.iloc[i : i + chunk_size].to_dict(orient="records")
            for i in range(0, len(df), chunk_size)
        ]

    return df.to_dict(orient="records")

{# table_template.html #}
<table class="attribute-table">
  <thead>
    <tr>
      {% for col in headers %}
        <th scope="col">{{ col | replace("_", " ") | title }}</th>
      {% endfor %}
    </tr>
  </thead>
  <tbody>
    {% for row in records %}
      <tr class="{{ 'row-even' if loop.index is even else 'row-odd' }}"
          data-row="{{ loop.index }}">
        {% for col in headers %}
          <td>{{ row[col] | default("—", true) | round(4) if row[col] is number
               else row[col] | default("—", true) }}</td>
        {% endfor %}
      </tr>
    {% else %}
      <tr>
        <td colspan="{{ headers | length }}" class="no-records">
          No records returned for this query.
        </td>
      </tr>
    {% endfor %}
  </tbody>
</table>

import jinja2
from pathlib import Path


def build_environment(template_dir: Path) -> jinja2.Environment:
    """Create a reusable Jinja2 Environment with strict undefined handling."""
    return jinja2.Environment(
        loader=jinja2.FileSystemLoader(template_dir),
        autoescape=jinja2.select_autoescape(["html"]),
        undefined=jinja2.StrictUndefined,  # Fail fast on missing keys
        keep_trailing_newline=True,
    )


def render_attribute_table(
    env: jinja2.Environment,
    template_name: str,
    headers: list[str],
    records: list[dict],
) -> str:
    """Render one page of attribute records to an HTML string."""
    template = env.get_template(template_name)
    return template.render(headers=headers, records=records)

import logging
from pathlib import Path
from weasyprint import HTML


def export_to_pdf(
    html_string: str,
    output_path: Path,
    expected_row_count: int,
    css_path: Path | None = None,
) -> None:
    """Render an HTML string to PDF and assert the output is non-empty."""
    logger = logging.getLogger(__name__)
    logger.info("Rendering PDF: %s", output_path)

    stylesheets = []
    if css_path and css_path.exists():
        from weasyprint import CSS
        stylesheets.append(CSS(filename=str(css_path)))

    HTML(string=html_string).write_pdf(output_path, stylesheets=stylesheets)

    if not output_path.exists() or output_path.stat().st_size < 1024:
        raise RuntimeError(
            f"PDF generation failed or produced a suspiciously small file at {output_path}"
        )

    logger.info("Exported %d rows → %s (%.1f KB)",
                expected_row_count, output_path, output_path.stat().st_size / 1024)

#!/usr/bin/env python3
"""
render_attribute_table.py — generate a paginated PDF attribute table from
a GeoPackage or GeoJSON layer using Jinja2 for-loop mapping.

Usage:
    python render_attribute_table.py \
        --source data/parcels.gpkg \
        --fields parcel_id,area_ha,zone_code,owner_name \
        --template templates/table_template.html \
        --output reports/parcels_table.pdf \
        --chunk 500
"""

import argparse
import logging
import sys
from pathlib import Path

import geopandas as gpd
import jinja2
import pandas as pd
from weasyprint import CSS, HTML

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    stream=sys.stderr,
)
logger = logging.getLogger(__name__)


def extract_attributes(
    source_path: Path,
    required_fields: list[str],
) -> list[dict]:
    gdf = gpd.read_file(source_path, columns=required_fields)
    df = pd.DataFrame(gdf[required_fields])
    df.columns = [c.strip().lower().replace(" ", "_") for c in df.columns]
    for col in df.select_dtypes(include=["object"]).columns:
        df[col] = pd.to_numeric(df[col], errors="coerce").fillna(df[col])
    return df.dropna(how="all").to_dict(orient="records")


def build_environment(template_dir: Path) -> jinja2.Environment:
    return jinja2.Environment(
        loader=jinja2.FileSystemLoader(template_dir),
        autoescape=jinja2.select_autoescape(["html"]),
        undefined=jinja2.StrictUndefined,
        keep_trailing_newline=True,
    )


def render_pages(
    env: jinja2.Environment,
    template_name: str,
    headers: list[str],
    records: list[dict],
    chunk_size: int,
) -> str:
    """Render all record chunks into a single HTML document."""
    template = env.get_template(template_name)
    chunks = [
        records[i : i + chunk_size] for i in range(0, len(records), chunk_size)
    ]
    pages = [template.render(headers=headers, records=chunk) for chunk in chunks]
    # Wrap in a minimal HTML shell for WeasyPrint
    body = '\n<div class="page-break"></div>\n'.join(pages)
    return f"<!DOCTYPE html><html lang='en'><body>{body}</body></html>"


def export_to_pdf(html_string: str, output_path: Path, expected_rows: int) -> None:
    HTML(string=html_string).write_pdf(output_path)
    if not output_path.exists() or output_path.stat().st_size < 1024:
        raise RuntimeError(f"PDF export failed at {output_path}")
    logger.info("Exported %d rows → %s (%.1f KB)",
                expected_rows, output_path, output_path.stat().st_size / 1024)


def main() -> None:
    parser = argparse.ArgumentParser(description="Render attribute table PDF from spatial data")
    parser.add_argument("--source", required=True, type=Path)
    parser.add_argument("--fields", required=True, help="Comma-separated field names")
    parser.add_argument("--template", required=True, type=Path)
    parser.add_argument("--output", required=True, type=Path)
    parser.add_argument("--chunk", type=int, default=500, help="Rows per page")
    args = parser.parse_args()

    fields = [f.strip() for f in args.fields.split(",")]
    headers = [f.strip().lower().replace(" ", "_") for f in fields]

    logger.info("Reading %s, fields: %s", args.source, fields)
    records = extract_attributes(args.source, fields)
    logger.info("Extracted %d records", len(records))

    env = build_environment(args.template.parent)
    html = render_pages(env, args.template.name, headers, records, args.chunk)

    args.output.parent.mkdir(parents=True, exist_ok=True)
    export_to_pdf(html, args.output, len(records))


if __name__ == "__main__":
    main()

# Preserve rows with null geometry — only drop geometry column, not the row
gdf["geometry_valid"] = gdf.geometry.notna() & gdf.geometry.is_valid
df = pd.DataFrame(gdf[required_fields + ["geometry_valid"]])

import csv

def export_csv(records: list[dict], headers: list[str], output_path: Path) -> None:
    with output_path.open("w", newline="", encoding="utf-8") as fh:
        writer = csv.DictWriter(fh, fieldnames=headers, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(records)

RUN apt-get update && apt-get install -y \
    libpango-1.0-0 \
    libcairo2 \
    libgdk-pixbuf2.0-0 \
    libffi-dev \
    && rm -rf /var/lib/apt/lists/*