simplicio-prompt 0.1.0

package/adopters.md

@@ -0,0 +1,24 @@
+# Adopters
+
+Projects vendoring the yool/tuple/HAMT spec.
+
+| Project | Repo | Status | Vendored Version |
+|---|---|---|---|
+| SendSprint | https://github.com/wesleysimplicio/SendSprint | planning | v0.2 |
+| llm-project-mapper | https://github.com/wesleysimplicio/llm-project-mapper | planning | v0.2 |
+
+## How to vendor
+
+1. Copy `YOOL_TUPLE_HAMT.md` into your repo as `docs/YOOL_TUPLE_HAMT.md`.
+2. Pin the spec version in your repo's README (e.g., `Spec: simplicio-prompt v0.2`).
+3. Implement guardrails per §11 (CPU throttle + disk GC). MANDATORY.
+4. Add your project to the table above via PR.
+
+## Update protocol
+
+When the spec changes upstream:
+
+1. Diff your vendored copy against the new canonical version.
+2. Bump your project's vendored-version pin.
+3. Run your own integration tests before merging.
+4. Update the Vendored Version column here.

package/benchmarks/generate_prompt_benchmark_pdf.py

@@ -0,0 +1,355 @@
+"""Generate the prompt benchmark PDF report.
+
+Run with the bundled Codex Python when available:
+
+    python benchmarks/generate_prompt_benchmark_pdf.py
+
+The script uses ReportLab if installed. It intentionally keeps the benchmark
+figures in source control so the PDF can be regenerated exactly.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+
+from reportlab.graphics.shapes import Drawing, Rect, String
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib.units import cm
+from reportlab.platypus import (
+    Paragraph,
+    SimpleDocTemplate,
+    Spacer,
+    Table,
+    TableStyle,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from benchmarks.prompt_vs_normal import token_model  # noqa: E402
+
+OUT = ROOT / "benchmarks" / "prompt_vs_normal_benchmark.pdf"
+
+PROMPT = """Use o repo canonico https://github.com/wesleysimplicio/simplicio-prompt.
+Leia antes de editar: YOOL_TUPLE_HAMT.md, kernel/yool_tuple_kernel.py,
+guardrails/cpu_throttle.py, guardrails/disk_gc.py, examples/python/receipts.py
+e scripts/build_hamt.py.
+
+Ao receber "Implement X": decomponha em grafo Hilbert-indexed, crie tuple raiz,
+use batch_spawn(depth, branching, compression_threshold) para 1.000.000+
+subagents sem enumerar, execute work ativo com spawn_agent, roteie por out/in/rd,
+route_packet e scan_index, aplique hookwall, compress_token e prune_idle, e use
+LaneWorkerPool respeitando YOOL_TUPLE_* env vars.
+
+Execute:
+python kernel/yool_tuple_kernel.py
+
+Responda SEMPRE exatamente neste formato (sem variações):
+[Tuple Space Snapshot]
+[Active Agents/Subagents]
+[Total Agents/Subagents]
+[Próximo Yool a executar]
+[Resultado parcial]"""
+
+
+def p(text: str, style: ParagraphStyle) -> Paragraph:
+    return Paragraph(text.replace("\n", "<br/>"), style)
+
+
+def main() -> int:
+    styles = getSampleStyleSheet()
+    title = styles["Title"]
+    h2 = styles["Heading2"]
+    body = styles["BodyText"]
+    body.leading = 13
+    small = ParagraphStyle("small", parent=body, fontSize=8.5, leading=10.5)
+    code = ParagraphStyle(
+        "code",
+        parent=small,
+        fontName="Courier",
+        backColor=colors.HexColor("#F4F6F8"),
+        borderColor=colors.HexColor("#D7DEE8"),
+        borderWidth=0.5,
+        borderPadding=6,
+        leading=9.5,
+    )
+
+    doc = SimpleDocTemplate(
+        str(OUT),
+        pagesize=A4,
+        rightMargin=1.5 * cm,
+        leftMargin=1.5 * cm,
+        topMargin=1.4 * cm,
+        bottomMargin=1.4 * cm,
+        title="Yool Prompt Benchmark",
+        author="wesleysimplicio/simplicio-prompt",
+    )
+
+    story = [
+        Paragraph("Yool Prompt vs Normal Instruction Benchmark", title),
+        p(
+            "Repository: wesleysimplicio/simplicio-prompt<br/>Run date: 2026-05-21",
+            body,
+        ),
+        Spacer(1, 0.25 * cm),
+        Paragraph("Executive Summary", h2),
+        p(
+            "The Yool prompt is faster because it turns a generic instruction into an "
+            "execution protocol: lazy batch_spawn for scale, tuple-space routing, "
+            "LaneWorkerPool fan-out, receipts, hookwall checks, and explicit runtime "
+            "guardrails. The benchmark measured local runtime mechanics, not hosted LLM "
+            "provider behavior.",
+            body,
+        ),
+    ]
+
+    story.extend(
+        [
+            Spacer(1, 0.2 * cm),
+            _bar_chart(
+                "Speedup (x)",
+                [
+                    ("Scale 131k vs 1M", 1397.0, colors.HexColor("#2B6CB0")),
+                    ("Scale 262k vs 1M", 5902.0, colors.HexColor("#2B6CB0")),
+                    ("Active 256 tasks", 6.37, colors.HexColor("#38A169")),
+                    ("Active 512 tasks", 9.31, colors.HexColor("#38A169")),
+                ],
+                max_value=5902.0,
+            ),
+        ]
+    )
+
+    scale_table = Table(
+        [
+            ["Profile", "Represented agents", "Wall time", "Peak memory"],
+            ["Normal instruction, flat list", "131,072", "217.11 ms", "28,749.88 KiB"],
+            ["Yool prompt, lazy batch_spawn", "1,048,576", "0.16 ms", "6.32 KiB"],
+            ["Observed gain", "8x more agents", "1,397x faster", "4,547x less memory"],
+        ],
+        colWidths=[6.1 * cm, 3.8 * cm, 3.1 * cm, 4.1 * cm],
+    )
+    scale_table.setStyle(_table_style())
+    story.extend(
+        [Spacer(1, 0.2 * cm), Paragraph("Scale Representation", h2), scale_table]
+    )
+
+    larger_scale_table = Table(
+        [
+            ["Profile", "Represented agents", "Wall time", "Peak memory"],
+            ["Normal instruction, flat list", "262,144", "431.45 ms", "57,542.32 KiB"],
+            ["Yool prompt, lazy batch_spawn", "1,048,576", "0.07 ms", "6.39 KiB"],
+            ["Observed gain", "4x more agents", "5,902x faster", "9,000x less memory"],
+        ],
+        colWidths=[6.1 * cm, 3.8 * cm, 3.1 * cm, 4.1 * cm],
+    )
+    larger_scale_table.setStyle(_table_style())
+    story.extend([Spacer(1, 0.25 * cm), larger_scale_table])
+
+    story.extend(
+        [
+            Spacer(1, 0.25 * cm),
+            _bar_chart(
+                "Peak memory reduction for scale representation (x)",
+                [
+                    ("131k flat vs 1M lazy", 4547.0, colors.HexColor("#805AD5")),
+                    ("262k flat vs 1M lazy", 9000.0, colors.HexColor("#805AD5")),
+                ],
+                max_value=9000.0,
+            ),
+        ]
+    )
+
+    exec_table = Table(
+        [
+            ["Profile", "Tasks", "Wall time", "Throughput", "Peak memory"],
+            ["Normal sequential", "256", "603.98 ms", "423.9 tasks/s", "17.33 KiB"],
+            ["Yool lane fan-out", "256", "94.87 ms", "2,698.3 tasks/s", "879.82 KiB"],
+            [
+                "Observed gain",
+                "same",
+                "6.37x faster",
+                "6.37x higher",
+                "higher active overhead",
+            ],
+        ],
+        colWidths=[5.0 * cm, 2.0 * cm, 3.0 * cm, 3.6 * cm, 3.7 * cm],
+    )
+    exec_table.setStyle(_table_style())
+    story.extend([Spacer(1, 0.35 * cm), Paragraph("Active Execution", h2), exec_table])
+
+    exec_big_table = Table(
+        [
+            ["Profile", "Tasks", "Wall time", "Throughput", "Peak memory"],
+            ["Normal sequential", "512", "1,212.88 ms", "422.1 tasks/s", "33.55 KiB"],
+            [
+                "Yool lane fan-out",
+                "512",
+                "130.28 ms",
+                "3,929.9 tasks/s",
+                "1,739.41 KiB",
+            ],
+            [
+                "Observed gain",
+                "same",
+                "9.31x faster",
+                "9.31x higher",
+                "higher active overhead",
+            ],
+        ],
+        colWidths=[5.0 * cm, 2.0 * cm, 3.0 * cm, 3.6 * cm, 3.7 * cm],
+    )
+    exec_big_table.setStyle(_table_style())
+    story.extend([Spacer(1, 0.25 * cm), exec_big_table])
+
+    token_rows = token_model()
+    token_table_data = [
+        ["Scenario", "Normal tokens", "Yool tokens", "Savings", "Savings %"]
+    ]
+    token_chart_rows = []
+    for item in token_rows:
+        token_table_data.append(
+            [
+                item.scenario,
+                f"{item.normal_tokens:,}",
+                f"{item.yool_tokens:,}",
+                f"{item.savings_tokens:,}",
+                f"{item.savings_pct:.2f}%",
+            ]
+        )
+        if item.savings_pct > 0:
+            token_chart_rows.append(
+                (
+                    item.scenario.replace("_", " "),
+                    item.savings_pct,
+                    colors.HexColor("#DD6B20"),
+                )
+            )
+    token_table = Table(
+        token_table_data,
+        colWidths=[5.2 * cm, 3.0 * cm, 3.0 * cm, 3.0 * cm, 2.4 * cm],
+    )
+    token_table.setStyle(_table_style())
+    story.extend(
+        [
+            Spacer(1, 0.35 * cm),
+            Paragraph("Token Usage and Estimated Savings", h2),
+            p(
+                "Token numbers are deterministic local estimates using ceil(UTF-8 bytes / 4). "
+                "They are not provider billing measurements. The model compares repeated "
+                "chat-context orchestration against one prompt plus compact tuple envelopes.",
+                body,
+            ),
+            token_table,
+            Spacer(1, 0.2 * cm),
+            _bar_chart(
+                "Estimated token savings (%)", token_chart_rows, max_value=100.0
+            ),
+            p(
+                "One-off bootstrap is intentionally more expensive with the Yool prompt, "
+                "because it carries the execution protocol. Savings appear when work fans out: "
+                "the protocol is paid once and subtasks travel as compact tuple envelopes.",
+                body,
+            ),
+        ]
+    )
+
+    story.extend(
+        [
+            Spacer(1, 0.35 * cm),
+            Paragraph("Gains Beyond Speed", h2),
+            p(
+                "Scalability: million-agent trees without flat lists.<br/>"
+                "Auditability: tuple state plus receipts.<br/>"
+                "Recovery: pending work can be replayed from tuple state.<br/>"
+                "Failure isolation: lanes separate planning, build, test, review, and runtime work.<br/>"
+                "Guardrails: CPU, queue, compression, hookwall, and disk GC are named controls.<br/>"
+                "Portability: the same prompt points Claude, Codex, Hermes, and scripts at the same files.",
+                body,
+            ),
+            Paragraph("Tradeoffs", h2),
+            p(
+                "For small active workloads, the Yool prompt uses more memory because it "
+                "creates tuple envelopes and worker fan-out structures. It pays off when work "
+                "is I/O-bound, uses subprocesses, browser automation, APIs, hosted LLM calls, "
+                "or large-scale planning/execution.",
+                body,
+            ),
+            Paragraph("Prompt Used", h2),
+            p(PROMPT, code),
+            Paragraph("Reproduce", h2),
+            p(
+                "python benchmarks/prompt_vs_normal.py --json<br/>"
+                "python benchmarks/prompt_vs_normal.py --tasks 512 --scale-agents 262144 --sleep-ms 2 --json<br/>"
+                "python benchmarks/generate_prompt_benchmark_pdf.py",
+                code,
+            ),
+        ]
+    )
+
+    doc.build(story)
+    print(OUT)
+    return 0
+
+
+def _table_style() -> TableStyle:
+    return TableStyle(
+        [
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#172033")),
+            ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+            ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+            ("FONTSIZE", (0, 0), (-1, -1), 8.5),
+            ("GRID", (0, 0), (-1, -1), 0.35, colors.HexColor("#CAD3DF")),
+            ("BACKGROUND", (0, 1), (-1, -1), colors.HexColor("#F9FBFD")),
+            ("BACKGROUND", (0, -1), (-1, -1), colors.HexColor("#EAF5EF")),
+            ("FONTNAME", (0, -1), (-1, -1), "Helvetica-Bold"),
+            ("VALIGN", (0, 0), (-1, -1), "TOP"),
+            ("LEFTPADDING", (0, 0), (-1, -1), 5),
+            ("RIGHTPADDING", (0, 0), (-1, -1), 5),
+            ("TOPPADDING", (0, 0), (-1, -1), 5),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 5),
+        ]
+    )
+
+
+def _bar_chart(
+    title: str, rows: list[tuple[str, float, colors.Color]], max_value: float
+) -> Drawing:
+    width = 17 * cm
+    row_h = 0.55 * cm
+    height = 1.0 * cm + row_h * len(rows)
+    drawing = Drawing(width, height)
+    drawing.add(
+        String(0, height - 0.35 * cm, title, fontName="Helvetica-Bold", fontSize=10)
+    )
+    label_w = 5.4 * cm
+    bar_w = 9.0 * cm
+    x = label_w
+    y = height - 0.85 * cm
+    for label, value, color in rows:
+        y -= row_h
+        drawing.add(String(0, y + 0.12 * cm, label[:34], fontSize=7.5))
+        drawing.add(
+            Rect(
+                x,
+                y,
+                bar_w,
+                0.25 * cm,
+                fillColor=colors.HexColor("#E8EDF3"),
+                strokeColor=None,
+            )
+        )
+        filled = (
+            0 if max_value <= 0 else max(0.0, min(bar_w, bar_w * value / max_value))
+        )
+        drawing.add(Rect(x, y, filled, 0.25 * cm, fillColor=color, strokeColor=None))
+        drawing.add(
+            String(x + bar_w + 0.25 * cm, y + 0.08 * cm, f"{value:,.2f}", fontSize=7.5)
+        )
+    return drawing
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/benchmarks/generate_v2_benchmark_pdf.py

@@ -0,0 +1,302 @@
+"""Generate the V2 safe-speed benchmark PDF."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from reportlab.graphics.shapes import Drawing, Rect, String
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib.units import cm
+from reportlab.platypus import (
+    Paragraph,
+    SimpleDocTemplate,
+    Spacer,
+    Table,
+    TableStyle,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+IN_JSON = ROOT / "benchmarks" / "v2_safe_speed_results.json"
+OUT = ROOT / "benchmarks" / "v2_safe_speed_benchmark.pdf"
+
+
+def main() -> int:
+    payload = json.loads(IN_JSON.read_text(encoding="utf-8"))
+    results = payload["results"]
+    comparisons = payload["comparisons"]
+
+    styles = getSampleStyleSheet()
+    title = styles["Title"]
+    h2 = styles["Heading2"]
+    body = styles["BodyText"]
+    body.leading = 13
+    small = ParagraphStyle("small", parent=body, fontSize=8.2, leading=10)
+
+    doc = SimpleDocTemplate(
+        str(OUT),
+        pagesize=A4,
+        rightMargin=1.4 * cm,
+        leftMargin=1.4 * cm,
+        topMargin=1.3 * cm,
+        bottomMargin=1.3 * cm,
+        title="Yool Safe-Speed Benchmark V2",
+        author="wesleysimplicio/simplicio-prompt",
+    )
+
+    story = [
+        Paragraph("Yool Safe-Speed Benchmark V2", title),
+        _p(
+            "Comparacao entre instrucao normal, V1 high-throughput e V2 safe-speed.<br/>"
+            f"Run date: {payload['run_date']}<br/>"
+            f"Python: {payload['environment']['python']}",
+            body,
+        ),
+        Spacer(1, 0.2 * cm),
+        Paragraph("Executive Summary", h2),
+        _p(
+            "A V2 mantem o ganho estrutural da V1 para escala massiva e adiciona "
+            "controles seguros de velocidade: cache por input/receipt, LaneWorkerPool "
+            "adaptativo, backoff com jitter, circuit breaker por provedor, batching, "
+            "compressao de contexto, roteamento local e speculative execution apenas "
+            "para tarefas idempotentes.",
+            body,
+        ),
+        Spacer(1, 0.2 * cm),
+        _bar_chart(
+            "Speed gains (x)",
+            _comparison_rows(
+                comparisons,
+                [
+                    "scale_representation",
+                    "active_execution",
+                    "cache_dedupe",
+                    "small_task_batching",
+                ],
+                metric="wall_ms",
+            ),
+        ),
+        Spacer(1, 0.2 * cm),
+        _bar_chart(
+            "Provider/token reduction (x)",
+            _comparison_rows(
+                comparisons,
+                [
+                    "cache_dedupe",
+                    "small_task_batching",
+                    "provider_failure_control",
+                    "context_compression",
+                ],
+                metrics={"provider_calls", "tokens"},
+            ),
+        ),
+    ]
+
+    for scenario, heading in [
+        ("scale_representation", "Scale Representation"),
+        ("active_execution", "Active Execution"),
+        ("cache_dedupe", "Cache Dedupe"),
+        ("small_task_batching", "Small Task Batching"),
+        ("provider_failure_control", "Provider Failure Control"),
+        ("context_compression", "Context Compression"),
+    ]:
+        story.extend(
+            [
+                Spacer(1, 0.25 * cm),
+                Paragraph(heading, h2),
+                _result_table(
+                    [item for item in results if item["scenario"] == scenario]
+                ),
+            ]
+        )
+
+    story.extend(
+        [
+            Spacer(1, 0.25 * cm),
+            Paragraph("Gains Table", h2),
+            _comparison_table(comparisons),
+            Spacer(1, 0.25 * cm),
+            Paragraph("Interpretation", h2),
+            _p(
+                "V1 ja resolve escala com lazy batch_spawn. V2 melhora a velocidade "
+                "real de entrega ao reduzir chamadas repetidas e overhead de orquestracao. "
+                "O circuit breaker e o backoff sao importantes porque velocidade sem "
+                "controle aumenta risco de rate limit ou bloqueio por provedor. A V2 "
+                "acelera evitando trabalho, nao forçando chamadas infinitas.",
+                body,
+            ),
+            Paragraph("Limitations", h2),
+            _p(
+                "Os numeros medem mecanica local. Provedores reais podem variar por "
+                "rate limit, latencia, tamanho de contexto e politica de cache. Para "
+                "trabalho CPU-bound puro em Python, subprocessos ou extensoes nativas "
+                "ainda sao melhores que threads por causa do GIL.",
+                small,
+            ),
+        ]
+    )
+
+    doc.build(story)
+    print(OUT)
+    return 0
+
+
+def _p(text: str, style: ParagraphStyle) -> Paragraph:
+    return Paragraph(text.replace("\n", "<br/>"), style)
+
+
+def _result_table(rows: list[dict]) -> Table:
+    table_data = [
+        [
+            "Profile",
+            "Tasks",
+            "Wall ms",
+            "Throughput/s",
+            "Calls",
+            "Cache",
+            "Blocked",
+            "Tokens",
+        ]
+    ]
+    for row in rows:
+        table_data.append(
+            [
+                row["profile"],
+                f"{row['tasks']:,}",
+                f"{row['wall_ms']:.2f}",
+                f"{row['throughput_tasks_s']:.1f}",
+                f"{row['provider_calls']:,}",
+                f"{row['cache_hits']:,}",
+                f"{row['blocked_calls']:,}",
+                f"{row['tokens']:,}",
+            ]
+        )
+    table = Table(
+        table_data,
+        colWidths=[
+            4.2 * cm,
+            2.1 * cm,
+            2.0 * cm,
+            2.3 * cm,
+            1.8 * cm,
+            1.8 * cm,
+            1.8 * cm,
+            1.8 * cm,
+        ],
+    )
+    table.setStyle(_table_style())
+    return table
+
+
+def _comparison_table(comparisons: list[dict]) -> Table:
+    table_data = [["Scenario", "Baseline", "Improved", "Metric", "Ratio", "Gain"]]
+    for item in comparisons:
+        ratio = "n/a" if item["ratio"] is None else f"{item['ratio']:.2f}x"
+        table_data.append(
+            [
+                item["scenario"],
+                item["baseline"],
+                item["improved"],
+                item["metric"],
+                ratio,
+                f"{item['percent']:.2f}%",
+            ]
+        )
+    table = Table(
+        table_data,
+        colWidths=[3.4 * cm, 3.5 * cm, 3.5 * cm, 2.4 * cm, 1.8 * cm, 2.0 * cm],
+    )
+    table.setStyle(_table_style())
+    return table
+
+
+def _comparison_rows(
+    comparisons: list[dict],
+    scenarios: list[str],
+    *,
+    metric: str | None = None,
+    metrics: set[str] | None = None,
+) -> list[tuple[str, float, colors.Color]]:
+    rows = []
+    palette = [
+        colors.HexColor("#2B6CB0"),
+        colors.HexColor("#38A169"),
+        colors.HexColor("#DD6B20"),
+        colors.HexColor("#805AD5"),
+    ]
+    for item in comparisons:
+        if item["scenario"] not in scenarios:
+            continue
+        if metric is not None and item["metric"] != metric:
+            continue
+        if metrics is not None and item["metric"] not in metrics:
+            continue
+        if item["ratio"] is None:
+            continue
+        label = f"{item['scenario']} {item['metric']}"[:38]
+        rows.append((label, float(item["ratio"]), palette[len(rows) % len(palette)]))
+    return rows
+
+
+def _bar_chart(title: str, rows: list[tuple[str, float, colors.Color]]) -> Drawing:
+    width = 17 * cm
+    row_h = 0.55 * cm
+    height = 1.0 * cm + row_h * max(1, len(rows))
+    drawing = Drawing(width, height)
+    drawing.add(
+        String(0, height - 0.35 * cm, title, fontName="Helvetica-Bold", fontSize=10)
+    )
+    if not rows:
+        drawing.add(String(0, height - 0.85 * cm, "No comparable rows", fontSize=8))
+        return drawing
+    max_value = max(value for _label, value, _color in rows)
+    label_w = 6.0 * cm
+    bar_w = 8.6 * cm
+    y = height - 0.85 * cm
+    for label, value, color in rows:
+        y -= row_h
+        drawing.add(String(0, y + 0.12 * cm, label, fontSize=7.2))
+        drawing.add(
+            Rect(
+                label_w,
+                y,
+                bar_w,
+                0.25 * cm,
+                fillColor=colors.HexColor("#E8EDF3"),
+                strokeColor=None,
+            )
+        )
+        filled = 0 if max_value <= 0 else min(bar_w, bar_w * value / max_value)
+        drawing.add(
+            Rect(label_w, y, filled, 0.25 * cm, fillColor=color, strokeColor=None)
+        )
+        drawing.add(
+            String(
+                label_w + bar_w + 0.2 * cm, y + 0.08 * cm, f"{value:.2f}x", fontSize=7.2
+            )
+        )
+    return drawing
+
+
+def _table_style() -> TableStyle:
+    return TableStyle(
+        [
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#172033")),
+            ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+            ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+            ("FONTSIZE", (0, 0), (-1, -1), 7.5),
+            ("GRID", (0, 0), (-1, -1), 0.35, colors.HexColor("#CAD3DF")),
+            ("BACKGROUND", (0, 1), (-1, -1), colors.HexColor("#F9FBFD")),
+            ("VALIGN", (0, 0), (-1, -1), "TOP"),
+            ("LEFTPADDING", (0, 0), (-1, -1), 4),
+            ("RIGHTPADDING", (0, 0), (-1, -1), 4),
+            ("TOPPADDING", (0, 0), (-1, -1), 4),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 4),
+        ]
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())