import asyncio

async def greet(name):
    await asyncio.sleep(0)                # yield control to the loop once
    return f"hi {name}"

coro = greet("asha")
print(type(coro).__name__)                # coroutine  ← nothing has run yet
print(asyncio.run(coro))                  # hi asha    ← run() starts a loop, runs it, closes it

import asyncio

async def job(name, delay, log):
    log.append(f"start {name}")
    await asyncio.sleep(delay)
    log.append(f"end {name}")

async def sequential():
    log = []
    await job("a", 0.02, log)             # waits for a to finish…
    await job("b", 0.01, log)             # …before b even starts
    return log

async def concurrent():
    log = []
    t1 = asyncio.create_task(job("a", 0.02, log))   # both scheduled now
    t2 = asyncio.create_task(job("b", 0.01, log))
    await t1
    await t2
    return log

print(asyncio.run(sequential()))   # ['start a', 'end a', 'start b', 'end b']
print(asyncio.run(concurrent()))   # ['start a', 'start b', 'end b', 'end a']

import asyncio

async def fetch(i):
    await asyncio.sleep(0.01 * (3 - i))   # later items finish first…
    if i == 1:
        raise ValueError(f"item {i} failed")
    return i * 10

async def main():
    results = await asyncio.gather(*(fetch(i) for i in range(3)), return_exceptions=True)
    print(results)                        # [0, ValueError('item 1 failed'), 20]  ← …but order = input order
    try:
        await asyncio.gather(fetch(0), fetch(1))
    except ValueError as e:
        print("first error:", e)          # first error: item 1 failed

asyncio.run(main())

import asyncio

async def worker(n):
    await asyncio.sleep(0.01)
    if n == 2:
        raise KeyError(n)
    return n

async def main():
    async with asyncio.TaskGroup() as tg:
        tasks = [tg.create_task(worker(n)) for n in range(2)]
    print([t.result() for t in tasks])    # [0, 1]  ← all done when the block exits

    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(worker(2))
            slow = tg.create_task(asyncio.sleep(10))
    except* KeyError as eg:
        print(type(eg).__name__, len(eg.exceptions))   # ExceptionGroup 1
    print(slow.cancelled())               # True  ← the sibling was cancelled

asyncio.run(main())

import asyncio

async def main():
    try:
        async with asyncio.timeout(0.01):          # 3.11+
            await asyncio.sleep(1)
    except TimeoutError:
        print("timeout block")                     # timeout block

    try:
        await asyncio.wait_for(asyncio.sleep(1), timeout=0.01)
    except TimeoutError:
        print("wait_for")                          # wait_for

asyncio.run(main())

import asyncio

async def worker(log):
    try:
        await asyncio.sleep(1)
    except asyncio.CancelledError:
        log.append("cleaning up")
        raise                             # always re-raise CancelledError

async def main():
    log = []
    t = asyncio.create_task(worker(log))
    await asyncio.sleep(0)                # let it start
    t.cancel()                            # throws CancelledError into it at its await
    try:
        await t
    except asyncio.CancelledError:
        log.append("cancelled")
    print(log, t.cancelled())             # ['cleaning up', 'cancelled'] True

asyncio.run(main())

import asyncio

async def consumer(q, out):
    while True:
        item = await q.get()
        out.append(item * item)
        q.task_done()

async def main():
    q = asyncio.Queue(maxsize=2)          # put() waits when full
    out = []
    workers = [asyncio.create_task(consumer(q, out)) for _ in range(2)]
    for i in range(5):                    # the producer
        await q.put(i)
    await q.join()                        # every item processed
    for w in workers:
        w.cancel()
    await asyncio.gather(*workers, return_exceptions=True)
    print(sorted(out))                    # [0, 1, 4, 9, 16]

asyncio.run(main())

import asyncio

async def main():
    sem = asyncio.Semaphore(3)            # at most 3 "requests" in flight
    active = peak = 0

    async def fetch(i):
        nonlocal active, peak
        async with sem:
            active += 1
            peak = max(peak, active)
            await asyncio.sleep(0.01)
            active -= 1
            return i

    results = await asyncio.gather(*(fetch(i) for i in range(10)))
    print(results == list(range(10)), peak)   # True 3

asyncio.run(main())

import asyncio, time

def blocking_io(x):
    time.sleep(0.01)                      # a blocking library call
    return x * 2

async def main():
    results = await asyncio.gather(
        asyncio.to_thread(blocking_io, 1),   # runs in the default thread pool
        asyncio.to_thread(blocking_io, 2),
    )
    print(results)                        # [2, 4]

asyncio.run(main())

import asyncio
from contextlib import asynccontextmanager

async def ticker(n):                      # async generator
    for i in range(n):
        await asyncio.sleep(0)
        yield i

log = []

@asynccontextmanager
async def connection(name):               # async with → __aenter__ / __aexit__
    log.append(f"open {name}")
    try:
        yield name.upper()
    finally:
        log.append(f"close {name}")

async def main():
    squares = [i * i async for i in ticker(4)]   # async comprehension
    print(squares)                        # [0, 1, 4, 9]
    async with connection("db") as conn:
        log.append(f"using {conn}")
    print(log)                            # ['open db', 'using DB', 'close db']

asyncio.run(main())

import asyncio

async def save():
    return "saved"

async def main():
    result = save()                       # forgot await → just a coroutine object
    print(type(result).__name__)          # coroutine
    result.close()                        # (silences "coroutine was never awaited")
    print(await save())                   # saved

asyncio.run(main())