GPT-OSS 120B × async-fetch

```python
#!/usr/bin/env python3
"""Utility to fetch many URLs concurrently with timeout, retries and
structured results.

The public entry point is :func:`fetch_all`.  It returns a list of dictionaries
containing the original URL, the HTTP status code (or ``None`` on error),
the response body as text (or ``None`` on error) and an error message (or
``None`` on success).

Typical usage::

    >>> import asyncio
    >>> from fetch_all import fetch_all
    >>> urls = ["https://example.com", "https://httpbin.org/status/500"]
    >>> results = asyncio.run(fetch_all(urls))
    >>> for r in results:
    ...     print(r)
"""

from __future__ import annotations

import asyncio
from typing import Any, Awaitable, Callable, Dict, List, Optional

import aiohttp

# --------------------------------------------------------------------------- #
# Helper
# --------------------------------------------------------------------------- #
async def _fetch_one(
    session: aiohttp.ClientSession,
    url: str,
    *,
    timeout: float,
    retries: int,
) -> Dict[str, Any]:
    """
    Fetch a single URL with per‑request timeout and retry logic.

    Parameters
    ----------
    session:
        An open :class:`aiohttp.ClientSession` that will be reused for all
        requests.
    url:
        The URL to request.
    timeout:
        Per‑request timeout in seconds.
    retries:
        Number of retry attempts *after* the first try (i.e. ``retries=0``
        means “try once, never retry”).

    Returns
    -------
    dict
        ``{
            "url": <original url>,
            "status": <int|None>,
            "body": <str|None>,
            "error": <str|None>,
        }``
    """
    backoff = 0.5  # seconds, will be doubled after each failure
    attempt = 0

    while True:
        attempt += 1
        try:
            async with session.get(url, timeout=timeout) as resp:
                # Treat 5xx as transient errors that should be retried
                if 500 <= resp.status < 600:
                    raise aiohttp.ClientResponseError(
                        request_info=resp.request_info,
                        history=resp.history,
                        status=resp.status,
                        message=f"Server error {resp.status}",
                        headers=resp.headers,
                    )
                body = await resp.text()
                return {
                    "url": url,
                    "status": resp.status,
                    "body": body,
                    "error": None,
                }

        except (aiohttp.ClientError, asyncio.TimeoutError) as exc:
            # Store the error message; we'll retry if we have attempts left.
            err_msg = str(exc)

            if attempt > retries + 1:  # +1 because the first attempt is 0‑retry
                return {
                    "url": url,
                    "status": None,
                    "body": None,
                    "error": err_msg,
                }

            # wait before the next attempt (exponential back‑off)
            await asyncio.sleep(backoff)
            backoff *= 2  # exponential increase
            continue


# --------------------------------------------------------------------------- #
# Public API
# --------------------------------------------------------------------------- #
async def fetch_all(
    urls: List[str],
    *,
    timeout: float = 5.0,
    retries: int = 2,
) -> List[Dict[str, Any]]:
    """
    Fetch *all* URLs concurrently.

    Parameters
    ----------
    urls:
        List of URL strings to request.
    timeout:
        Per‑request timeout (seconds).  The total runtime can be longer because
        the calls are parallel.
    retries:
        Number of retry attempts after the first failed try.  Retries are
        performed on network errors, timeouts and HTTP 5xx responses using an
        exponential back‑off (0.5 s, 1 s, 2 s, …).

    Returns
    -------
    list[dict]
        A list where each element corresponds to an input URL and contains the
        keys ``url``, ``status``, ``body`` and ``error`` as described in the
        module docstring.
    """
    # Create a single session that will be shared among all concurrent fetches.
    async with aiohttp.ClientSession() as session:
        tasks: List[Awaitable[Dict[str, Any]]] = [
            _fetch_one(session, url, timeout=timeout, retries=retries) for url in urls
        ]
        # ``asyncio.gather`` runs them concurrently and returns results in the
        # same order as *tasks*.
        results = await asyncio.gather(*tasks, return_exceptions=False)
        return results


# --------------------------------------------------------------------------- #
# Demo when executed directly
# --------------------------------------------------------------------------- #
if __name__ == "__main__":
    import json

    async def _demo() -> None:
        demo_urls = [
            "https://example.com",                     # normal 200
            "https://httpbin.org/status/502",          # 5xx → will be retried
            "https://httpbin.org/delay/10",            # will timeout (default 5 s)
        ]
        print(f"Fetching {len(demo_urls)} URLs concurrently …\n")
        results = await fetch_all(demo_urls, timeout=5.0, retries=2)

        # pretty‑print the result dictionaries
        for r in results:
            print(json.dumps(r, indent=2, ensure_ascii=False))
            print("-" * 60)

    asyncio.run(_demo())
```