import asyncio
import time

async def fetch(name: str, delay: float) -> str:
    """Simulate an I/O-bound operation (network request, DB query)."""
    print(f"  {name}: starting")
    await asyncio.sleep(delay)        # suspend here; event loop runs others
    print(f"  {name}: done after {delay}s")
    return f"{name} result"

async def main():
    start = time.perf_counter()

    # Sequential: total time = sum of delays = 6s
    # result_a = await fetch("A", 2)
    # result_b = await fetch("B", 1)
    # result_c = await fetch("C", 3)

    # Concurrent: total time ≈ max delay = 3s
    results = await asyncio.gather(
        fetch("A", 2),
        fetch("B", 1),
        fetch("C", 3),
    )
    elapsed = time.perf_counter() - start
    print(f"Results: {results}")
    print(f"Total time: {elapsed:.2f}s")   # ~3.0s, not 6.0s

asyncio.run(main())

import asyncio

# ── Pattern 1: asyncio.gather — wait for all, return all results ──────────────
async def batch_fetch(urls: list[str]) -> list[str]:
    """Fetch all URLs concurrently, return all results in order."""
    async def fetch_one(url):
        await asyncio.sleep(0.1)   # simulate HTTP request
        return f"content of {url}"

    return await asyncio.gather(*[fetch_one(u) for u in urls])

# ── Pattern 2: create_task — background task, fire and continue ──────────────
async def pipeline():
    # Start background work immediately
    bg_task = asyncio.create_task(long_background_job())

    # Do other work while background runs
    result = await fast_operation()

    # Now wait for the background task
    bg_result = await bg_task
    return result, bg_result

# ── Pattern 3: gather with error handling ─────────────────────────────────────
async def robust_gather(coroutines):
    """Return results or exceptions — never raises on individual failure."""
    results = await asyncio.gather(*coroutines, return_exceptions=True)
    successes = [r for r in results if not isinstance(r, Exception)]
    failures  = [r for r in results if isinstance(r, Exception)]
    return successes, failures

# ── Pattern 4: TaskGroup (Python 3.11+) — structured concurrency ─────────────
async def structured():
    async with asyncio.TaskGroup() as tg:
        task_a = tg.create_task(fetch("A", 1))
        task_b = tg.create_task(fetch("B", 2))
    # Both tasks complete before this line; any exception is propagated
    print(task_a.result(), task_b.result())

# ── Pattern 5: timeout ────────────────────────────────────────────────────────
async def with_timeout():
    try:
        result = await asyncio.wait_for(fetch("slow", 10), timeout=2.0)
    except asyncio.TimeoutError:
        result = None   # fallback if operation takes too long
    return result

import asyncio
from contextlib import asynccontextmanager
from typing import AsyncIterator

# ── Async context manager ─────────────────────────────────────────────────────
@asynccontextmanager
async def managed_connection(host: str):
    """Acquire a connection, yield it, release on exit."""
    print(f"Connecting to {host}...")
    conn = await create_connection(host)   # async setup
    try:
        yield conn
    finally:
        await conn.close()                 # async cleanup

async def query_data():
    async with managed_connection("db.example.com") as conn:
        return await conn.execute("SELECT * FROM orders")

# ── Async generator / async iterator ─────────────────────────────────────────
async def stream_records(batch_size: int = 100) -> AsyncIterator[list[dict]]:
    """Stream database records in batches without loading all into memory."""
    offset = 0
    while True:
        batch = await fetch_from_db(offset=offset, limit=batch_size)
        if not batch:
            return                          # StopAsyncIteration
        yield batch
        offset += batch_size

async def process_all():
    total = 0
    async for batch in stream_records(batch_size=50):
        for record in batch:
            total += record.get("amount", 0)
    return total

# ── Real-world pattern: parallel API calls with aiohttp (pseudocode) ─────────
# import aiohttp
# async def fetch_all(urls):
#     async with aiohttp.ClientSession() as session:     # one session, reused
#         async def get(url):
#             async with session.get(url) as resp:
#                 return await resp.json()
#         return await asyncio.gather(*[get(u) for u in urls])