TaskGroup, Timeouts und Abbruch

import asyncio
from collections.abc import Callable, Coroutine
from typing import Any


async def fetch_all(names: list[str], fetch: Callable[[str], Coroutine[Any, Any, str]]) -> dict[str, str]:
    """Fetch every name in a TaskGroup; map each name to its text, in the order of names.

    If a fetch fails, the others are cancelled and an ExceptionGroup is raised.
    """
    # gather leaves the other fetches running when one fails.
    # Create one task per name in an asyncio.TaskGroup instead.
    texts = await asyncio.gather(*(fetch(name) for name in names))
    return dict(zip(names, texts))

import asyncio

from main import fetch_all


def test_results():
    """Jeder Name wird auf seinen Text abgebildet, in der Reihenfolge von names"""

    async def fake_fetch(name):
        await asyncio.sleep(0.02 if name == "slow" else 0)
        return name.upper()

    got = asyncio.run(fetch_all(["slow", "fast"], fake_fetch))
    assert list(got.items()) == [("slow", "SLOW"), ("fast", "FAST")], f"fetch_all lieferte {got!r}"


def test_failure_is_a_group():
    """Ein scheiternder Abruf kommt als ExceptionGroup mit seinem ValueError heraus"""

    async def fake_fetch(name):
        await asyncio.sleep(0)
        if name == "bad":
            raise ValueError("bad page")
        return name

    try:
        asyncio.run(fetch_all(["ok", "bad"], fake_fetch))
        error = None
    except Exception as caught:
        error = caught
    assert isinstance(error, ExceptionGroup), f"fetch_all löste {error!r} aus, keine ExceptionGroup"
    assert [str(e) for e in error.exceptions] == ["bad page"], f"die Gruppe enthält {error.exceptions!r}"


def test_others_cancelled():
    """Scheitert ein Abruf, wird der langsame abgebrochen, bevor fetch_all auslöst"""
    cancelled = []

    async def fake_fetch(name):
        if name == "bad":
            await asyncio.sleep(0)
            raise ValueError("bad page")
        try:
            await asyncio.sleep(1)
        except asyncio.CancelledError:
            cancelled.append(name)
            raise
        return name

    async def run():
        try:
            await fetch_all(["slow", "bad"], fake_fetch)
        except Exception:
            pass
        return list(cancelled)

    seen = asyncio.run(run())
    assert seen == ["slow"], f"abgebrochen, als fetch_all auslöste: {seen!r}; nutzen Sie eine TaskGroup"

import asyncio
from collections.abc import Awaitable, Callable


async def fetch_one(fetch: Callable[[str], Awaitable[str]], name: str, limit: float) -> str:
    """Return fetch(name), or "timeout" if it takes longer than limit seconds."""
    async with asyncio.timeout(limit):
        try:
            return await fetch(name)
        except TimeoutError:  # never true here: inside the block the fetch sees CancelledError
            return "timeout"


async def fetch_each(names: list[str], fetch: Callable[[str], Awaitable[str]], limit: float) -> list[str]:
    """Fetch every name in a TaskGroup, each with its own time limit; results in the order of names."""
    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(fetch_one(fetch, name, limit)) for name in names]
    return [task.result() for task in tasks]

import asyncio

from main import fetch_each

DELAYS = {"home": 0, "blog": 0.01, "archive": 1}


async def fake_fetch(name):
    await asyncio.sleep(DELAYS[name])
    return name.upper()


def test_all_in_time():
    """Seiten, die rechtzeitig ankommen, liefern ihren Text"""
    got = asyncio.run(fetch_each(["home", "blog"], fake_fetch, 0.5))
    assert got == ["HOME", "BLOG"], f"fetch_each lieferte {got!r}"


def test_slow_page_times_out():
    """Eine Seite, die länger als die Frist braucht, ergibt "timeout", und die anderen kommen trotzdem an"""
    try:
        got = asyncio.run(fetch_each(["home", "archive", "blog"], fake_fetch, 0.05))
    except Exception as error:
        got = error
    assert got == ["HOME", "timeout", "BLOG"], f"fetch_each ergab {got!r}: wo wird der TimeoutError ausgelöst?"

import asyncio
from collections.abc import Awaitable, Callable


async def fetch_limited(names: list[str], fetch: Callable[[str], Awaitable[str]], limit: int) -> list[str]:
    """Fetch every name in a TaskGroup, at most limit at a time; results in the order of names."""
    # TODO: every fetch starts at once. Create one asyncio.Semaphore(limit)
    # here and hold it in fetch_one around the await.

    async def fetch_one(name: str) -> str:
        return await fetch(name)

    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(fetch_one(name)) for name in names]
    return [task.result() for task in tasks]


async def demo_fetch(name: str) -> str:
    print("start", name)
    await asyncio.sleep(0.1)
    print("end", name)
    return name.upper()


if __name__ == "__main__":
    print(asyncio.run(fetch_limited(["home", "about", "blog", "shop"], demo_fetch, 2)))

import asyncio

from main import fetch_limited


def counting_fetch():
    """A fake fetch that records how many calls are waiting at the same time."""
    state = {"running": 0, "peak": 0}

    async def fetch(name):
        state["running"] += 1
        state["peak"] = max(state["peak"], state["running"])
        await asyncio.sleep(0.01)
        state["running"] -= 1
        return name.upper()

    return fetch, state


def test_results_in_order():
    """Jeder Name liefert seinen Text, in der Reihenfolge von names"""
    fetch, _ = counting_fetch()
    got = asyncio.run(fetch_limited(["home", "about", "blog"], fetch, 2))
    assert got == ["HOME", "ABOUT", "BLOG"], f"fetch_limited lieferte {got!r}"


def test_limit_is_kept():
    """Mit limit 2 laufen nie mehr als 2 Abrufe gleichzeitig"""
    fetch, state = counting_fetch()
    asyncio.run(fetch_limited(["a", "b", "c", "d", "e"], fetch, 2))
    assert state["peak"] == 2, f"{state['peak']} Abrufe liefen gleichzeitig, erwartet waren höchstens 2: halten Sie eine gemeinsame Semaphore um jeden Abruf"


def test_limit_is_used():
    """Mit limit 3 laufen wirklich drei Abrufe gleichzeitig"""
    fetch, state = counting_fetch()
    asyncio.run(fetch_limited(["a", "b", "c", "d", "e"], fetch, 3))
    assert state["peak"] == 3, f"{state['peak']} Abrufe liefen gleichzeitig, erwartet waren 3: legen Sie die Semaphore einmal an, nicht in jedem Abruf"