import asyncio, inspect

async def my_coro():
    await asyncio.sleep(0.1)
    return "done"

async def inspect_lifecycle():
    coro = my_coro()
    print(coro.cr_frame)              # frame object (not None = not yet started)
    print(inspect.getcoroutinestate(coro))  # CORO_CREATED

    task = asyncio.create_task(coro)
    await asyncio.sleep(0)            # let it start
    print(inspect.getcoroutinestate(coro))  # CORO_SUSPENDED (at sleep)

    result = await task
    print(inspect.getcoroutinestate(coro))  # CORO_CLOSED
    print(result)                    # "done"

asyncio.run(inspect_lifecycle())

import asyncio

async def work(name: str, delay: float):
    await asyncio.sleep(delay)
    return f"{name} done"

async def main():

    # ── gather() ─────────────────────────────────────────
    # Runs all, waits for ALL to finish, returns list in order.
    # If one raises, by default it cancels others.
    results = await asyncio.gather(
        work("A", 0.1),
        work("B", 0.3),
        work("C", 0.2),
        return_exceptions=True   # exceptions become values, not raised
    )
    print(results)  # ['A done', 'B done', 'C done'] ← in input order

    # ── wait() ───────────────────────────────────────────
    # More control: separate done from not-done sets.
    tasks = {asyncio.create_task(work(n, d)) for n, d in [("X",.1),("Y",.5)]}
    done, pending = await asyncio.wait(tasks, timeout=0.2)
    print(f"done: {len(done)}, pending: {len(pending)}")
    for t in pending:
        t.cancel()   # cancel tasks that didn't finish in time

    # ── as_completed() ───────────────────────────────────
    # Yields results as they finish (fastest first).
    # Great for: "show first result immediately, load rest after"
    coros = [work("fast", 0.1), work("slow", 0.5), work("mid", 0.3)]
    async for fut in asyncio.as_completed(coros):  # Python 3.13+ async for
        result = await fut
        print(f"Got: {result}")  # fast → mid → slow

asyncio.run(main())

import asyncio

# ── Manual cancellation ──────────────────────────────────
async def long_running():
    try:
        print("working...")
        await asyncio.sleep(10)    # long operation
        print("done")
    except asyncio.CancelledError:
        print("cleanup: releasing resources")
        raise                        # ALWAYS re-raise CancelledError!

async def cancel_demo():
    task = asyncio.create_task(long_running())
    await asyncio.sleep(0.5)     # let it start
    task.cancel()                  # inject CancelledError
    try:
        await task
    except asyncio.CancelledError:
        print("task was cancelled")

# ── Timeout with wait_for (works in all Python 3.7+) ─────
async def timeout_demo():
    try:
        result = await asyncio.wait_for(
            long_running(),
            timeout=2.0             # raise TimeoutError after 2s
        )
    except asyncio.TimeoutError:
        print("Request timed out after 2s")

# ── asyncio.timeout context manager (Python 3.11+) ───────
async def timeout_context():
    try:
        async with asyncio.timeout(2.0):
            await asyncio.sleep(10)  # will be cancelled
    except TimeoutError:
        print("timed out!")

# ── FastAPI timeout pattern ───────────────────────────────
# @app.get("/data")
# async def get_data():
#     try:
#         result = await asyncio.wait_for(slow_service(), timeout=5.0)
#         return result
#     except asyncio.TimeoutError:
#         raise HTTPException(504, "Gateway Timeout")

asyncio.run(cancel_demo())

import asyncio
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from functools import partial
import hashlib, time

# ── Synchronous CPU-heavy function ──
def hash_password(password: str) -> str:
    # bcrypt is CPU-intensive — takes ~100ms
    return hashlib.pbkdf2_hmac('sha256', password.encode(), b'salt', 100_000).hex()

def heavy_compute(n: int) -> int:
    return sum(i*i for i in range(n))

async def main():
    loop = asyncio.get_event_loop()

    # ── ThreadPoolExecutor ──────────────────────────────
    # Good for: blocking I/O (sync DB drivers), light CPU work
    # GIL is still held, but I/O ops release it
    with ThreadPoolExecutor(max_workers=4) as pool:
        hashed = await loop.run_in_executor(
            pool,
            hash_password,
            "mysecretpassword"
        )
        print(f"Hash: {hashed[:20]}...")

    # ── ProcessPoolExecutor ─────────────────────────────
    # Good for: heavy CPU (ML inference, image processing)
    # Spawns separate processes → bypasses GIL
    with ProcessPoolExecutor(max_workers=2) as pool:
        result = await loop.run_in_executor(
            pool,
            heavy_compute,
            10_000_000
        )
        print(f"Sum: {result}")

    # ── asyncio.to_thread (Python 3.9+, simpler syntax) ─
    hashed = await asyncio.to_thread(hash_password, "mypassword")
    print(f"to_thread hash: {hashed[:20]}...")

asyncio.run(main())

# ── FastAPI patterns ────────────────────────────────────
#
# Pattern 1: auto thread pool with plain def
# @app.post("/login")
# def login(data: LoginSchema):          ← FastAPI runs in thread pool
#     hashed = hash_password(data.password)  ← safe: not blocking event loop
#     ...
#
# Pattern 2: explicit offload in async def
# @app.post("/process-image")
# async def process_image(file: UploadFile):
#     data = await file.read()
#     result = await asyncio.to_thread(resize_image, data, (800, 600))
#     return {"size": len(result)}