Preventing duplicate server writes during PyScript network retries

Answer – The Core Pattern

The most reliable way to avoid duplicate server writes when retrying POST requests in PyScript is to generate a unique idempotency key once per logical operation, store it in a local variable, and include that exact key in every retry attempt. The backend must be configured to store the key and return the original response when the same key is received again.

1. Generate the key before the first attempt – e.g., import uuid; key = str(uuid.uuid4()) or js.crypto.randomUUID() via the FFI.
2. Persist the key in a local variable that lives outside the retry loop.
3. Send the key in a header (conventionally Idempotency-Key) or as a JSON field in the request body.
4. Implement retry logic that only triggers on network errors, rejected promises, or 5xx/429 status codes, with a bounded number of attempts and exponential backoff with jitter.
5. Never regenerate the key inside the retry loop; reuse the same key value for every attempt.
6. Let the server dedupe: it should store the key (e.g., a unique constraint in a database) and return the original result for repeated keys instead of performing the write again.

Because pyfetch is just a thin wrapper around the browser’s fetch, the same HTTP semantics apply. An abort or timeout on the client side does not guarantee that the server stopped processing; the write may still be committed.

Example PyScript Snippet

import asyncio
import uuid
from pyodide.http import pyfetch

async def post_with_retry(url, payload, max_attempts=5):
    idempotency_key = str(uuid.uuid4())
    headers = {
        "Content-Type": "application/json",
        "Idempotency-Key": idempotency_key
    }
    backoff = 1.0
    for attempt in range(1, max_attempts + 1):
        try:
            response = await pyfetch(url, method="POST", headers=headers, data=payload)
            if response.status < 500:
                return await response.json()
        except Exception as e:
            # Network‑level failure
            pass
        if attempt == max_attempts:
            raise RuntimeError(f"Failed after {max_attempts} attempts")
        await asyncio.sleep(backoff + (0.1 * attempt))
        backoff *= 2

Likely Explanation for Duplicates

Duplicate writes typically occur when the idempotency key is regenerated inside the retry loop or omitted entirely, making each retry look like a new operation to the backend.

Confirmed Facts

• PyScript does not provide built‑in idempotency handling; pyfetch delegates to the browser’s fetch.
• Server‑side storage of the key (unique constraint or cache) is required to guarantee at‑most‑once semantics.
• Retry only on transient conditions (network errors, 5xx, 429); do not retry on 4xx errors.
• Using a header like Idempotency-Key is the most common convention.

Missing Diagnostic Detail

Does your backend currently support idempotency key handling (e.g., a unique constraint on the key column or a cache that returns the original response)? If not, the client‑side pattern alone will not prevent duplicate writes.