Generate a Brazilian invoice PDF in Python

payload = {
    "tipo": "fatura",                    # or "recibo"
    "numero": "0001/2026",
    "data": "2026-08-07",                # ISO in, DD/MM/YYYY printed
    "vencimento": "2026-08-22",
    "emitente": {
        "nome": "Atlas Solucoes Digitais LTDA",
        "documento": "11.222.333/0001-81",   # CNPJ - check digits are verified
        "endereco": "Av. Paulista, 1000 - Sao Paulo/SP",
    },
    "destinatario": {
        "nome": "Comercio Silva & Filhos ME",
        "documento": "22.333.444/0001-81",
    },
    "itens": [
        {"descricao": "Consultoria de implementacao", "quantidade": 20, "valor_unitario": 250},
        {"descricao": "Licenca mensal", "quantidade": 1, "valor_unitario": 349.90},
    ],
    "desconto": 100,
    "forma_pagamento": "PIX",
    "observacoes": "Pagamento em ate 10 dias.",
}

import os
import requests

HOST = "brazilian-invoice-receipt-pdf-api-cpf-cnpj.p.rapidapi.com"
URL = f"https://{HOST}/invoice"


class InvoiceError(RuntimeError):
    def __init__(self, status, code, message):
        super().__init__(f"[{status}] {code}: {message}")
        self.status, self.code, self.message = status, code, message


def generate_invoice(payload: dict, timeout: float = 15.0) -> bytes:
    response = requests.post(
        URL,
        json=payload,                       # sets Content-Type and encodes UTF-8
        headers={
            "X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],
            "X-RapidAPI-Host": HOST,
        },
        timeout=timeout,                    # ALWAYS pass this; requests has no default
    )

    if response.status_code != 200:
        try:
            detail = response.json()
        except ValueError:
            detail = {"error": "http_error", "message": response.text[:300]}
        raise InvoiceError(response.status_code, detail.get("error"), detail.get("message"))

    # .content = raw bytes.  .text = decoded str, which WILL corrupt the PDF.
    return response.content


if __name__ == "__main__":
    pdf = generate_invoice(payload)
    with open("fatura.pdf", "wb") as fh:      # "wb", not "w"
        fh.write(pdf)
    print(f"wrote fatura.pdf ({len(pdf)} bytes)")

try:
    pdf = generate_invoice(payload)
except InvoiceError as err:
    if err.code == "invalid_params":
        # Split it back into a list for a form-level error display.
        for problem in err.message.split("; "):
            print("field error:", problem)
    elif err.status == 429:
        print("monthly quota exhausted - stop the batch, do not retry")
    else:
        raise

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry


def build_session() -> requests.Session:
    session = requests.Session()
    retry = Retry(
        total=3,
        backoff_factor=0.5,                       # 0.5s, 1s, 2s
        status_forcelist=[500, 502, 503, 504],    # NOT 400 - that is your payload
        allowed_methods=["POST"],                 # urllib3 excludes POST by default
        raise_on_status=False,
    )
    session.mount("https://", HTTPAdapter(max_retries=retry, pool_maxsize=10))
    session.headers.update({
        "X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"],
        "X-RapidAPI-Host": HOST,
    })
    return session

import asyncio
import httpx

async def generate_many(payloads: list[dict], concurrency: int = 8) -> list[bytes]:
    limits = httpx.Limits(max_connections=concurrency)
    gate = asyncio.Semaphore(concurrency)

    async with httpx.AsyncClient(
        base_url=f"https://{HOST}",
        headers={"X-RapidAPI-Key": os.environ["RAPIDAPI_KEY"], "X-RapidAPI-Host": HOST},
        timeout=httpx.Timeout(15.0, connect=5.0),
        limits=limits,
    ) as client:

        async def one(body: dict) -> bytes:
            async with gate:
                r = await client.post("/invoice", json=body)
                if r.status_code != 200:
                    raise InvoiceError(r.status_code, *_detail(r))
                return r.content        # httpx uses .content for bytes too

        return await asyncio.gather(*(one(p) for p in payloads))


def _detail(r):
    try:
        d = r.json()
        return d.get("error"), d.get("message")
    except ValueError:
        return "http_error", r.text[:300]

# --- Django ---
from django.http import HttpResponse, JsonResponse

def invoice_pdf(request, order_id):
    order = Order.objects.select_related("customer").get(pk=order_id)
    try:
        pdf = generate_invoice(build_payload(order))
    except InvoiceError as err:
        return JsonResponse({"detail": err.message}, status=502)

    response = HttpResponse(pdf, content_type="application/pdf")
    # inline = open in the browser viewer; attachment = force a download
    response["Content-Disposition"] = f'inline; filename="fatura-{order.number}.pdf"'
    return response


# --- FastAPI ---
from fastapi import FastAPI, HTTPException
from fastapi.responses import Response

app = FastAPI()

@app.get("/orders/{order_id}/invoice.pdf")
async def invoice(order_id: int):
    order = await get_order(order_id)
    try:
        pdf = await generate_invoice_async(build_payload(order))
    except InvoiceError as err:
        raise HTTPException(status_code=502, detail=err.message)

    return Response(
        content=pdf,
        media_type="application/pdf",
        headers={"Content-Disposition": f'inline; filename="fatura-{order.number}.pdf"'},
    )

from decimal import Decimal, ROUND_HALF_UP

def money(value: Decimal) -> float:
    """Decimal -> float with exactly 2 decimal places, rounded the way finance expects."""
    return float(value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

itens = [
    {"descricao": line.title, "quantidade": line.qty, "valor_unitario": money(line.unit_price)}
    for line in order.lines
]

import re

def _digits(value: str) -> str:
    return re.sub(r"\D", "", value or "")


def _check_digit(nums: list[int], weights: list[int]) -> int:
    total = sum(n * w for n, w in zip(nums, weights))
    rest = total % 11
    return 0 if rest < 2 else 11 - rest       # the rule everyone gets wrong


def is_valid_cpf(value: str) -> bool:
    d = _digits(value)
    if len(d) != 11 or d == d[0] * 11:        # 111.111.111-11 is arithmetically valid
        return False
    n = [int(c) for c in d]
    return (_check_digit(n[:9], list(range(10, 1, -1))) == n[9]
            and _check_digit(n[:10], list(range(11, 1, -1))) == n[10])


def is_valid_cnpj(value: str) -> bool:
    d = _digits(value)
    if len(d) != 14 or d == d[0] * 14:
        return False
    n = [int(c) for c in d]
    w1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
    w2 = [6] + w1
    return _check_digit(n[:12], w1) == n[12] and _check_digit(n[:13], w2) == n[13]


def is_valid_tax_id(value: str) -> bool:
    return is_valid_cpf(value) if len(_digits(value)) == 11 else is_valid_cnpj(value)