Async Programming Fundamentals

import asyncio

async def task1():
    await asyncio.sleep(1)
    print("task1 done")

async def task2():
    await asyncio.sleep(1)
    print("task2 done")

async def task3():
    await asyncio.sleep(1)
    print("task3 done")

async def main():
    print("Event loop started")
    # Tasks scheduled here run concurrently
    await asyncio.gather(
        task1(),
        task2(),
        task3()
    )
    print("Event loop finishing")

asyncio.run(main())

import asyncio

async def main():
    # Ask for the loop from inside a coroutine, where one is running
    loop = asyncio.get_running_loop()
    print(type(loop).__name__)

asyncio.run(main())

import asyncio

# Define a coroutine with 'async def'
async def fetch_data():
    print("Fetching data...")
    await asyncio.sleep(2)  # Simulate I/O operation
    print("Data fetched!")
    return {"data": "Hello, Async World!"}

# Run the coroutine
async def main():
    result = await fetch_data()
    print(result)

# Execute
asyncio.run(main())

import asyncio

async def fetch_page(url):
    print(f"Fetching {url}")
    await asyncio.sleep(2)  # Simulate network request
    return f"Content from {url}"

async def main():
    # gather runs all coroutines concurrently
    results = await asyncio.gather(
        fetch_page("https://example.com/page1"),
        fetch_page("https://example.com/page2"),
        fetch_page("https://example.com/page3")
    )

    for result in results:
        print(result)

asyncio.run(main())

# All three pages fetched in parallel
# Total time: ~2 seconds instead of 6!

import asyncio

async def background_task(name):
    print(f"{name} started in background")
    await asyncio.sleep(3)
    print(f"{name} completed")
    return f"{name} result"

async def main():
    # create_task SCHEDULES the coroutine, it does not run it yet. main()
    # keeps going until it reaches an await, which is the only point where
    # the event loop can switch to the new tasks.
    task1 = asyncio.create_task(background_task("Task 1"))
    task2 = asyncio.create_task(background_task("Task 2"))

    # Do other work while tasks run
    print("Doing other work...")
    await asyncio.sleep(1)
    print("Still doing work...")

    # Wait for tasks to complete
    result1 = await task1
    result2 = await task2

    print(f"Results: {result1}, {result2}")

asyncio.run(main())

# Note the order below: "Doing other work..." prints before either task
# starts, because main() had not awaited anything yet.

import asyncio

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

async def main():
    tasks = [
        asyncio.create_task(task("Fast", 1)),
        asyncio.create_task(task("Medium", 2)),
        asyncio.create_task(task("Slow", 3))
    ]

    # Wait for first task to complete
    done, pending = await asyncio.wait(
        tasks,
        return_when=asyncio.FIRST_COMPLETED
    )

    print(f"First task completed: {done.pop().result()}")
    print(f"Still running: {len(pending)} tasks")

    # Wait for all remaining
    done, pending = await asyncio.wait(pending)

    # asyncio.wait returns a set, which has no meaningful order. Sort the
    # results so the output is the same on every run.
    for result in sorted(t.result() for t in done):
        print(result)

asyncio.run(main())

import asyncio
import aiohttp  # Async HTTP library
import time

async def fetch_json(session, url):
    """Fetch JSON from a URL"""
    async with session.get(url) as response:
        return await response.json()

async def fetch_user_data(user_id):
    """Fetch user profile, posts, and comments concurrently"""
    base_url = "https://jsonplaceholder.typicode.com"

    async with aiohttp.ClientSession() as session:
        # Run all three requests concurrently
        user, posts, comments = await asyncio.gather(
            fetch_json(session, f"{base_url}/users/{user_id}"),
            fetch_json(session, f"{base_url}/posts?userId={user_id}"),
            fetch_json(session, f"{base_url}/comments?postId=1")
        )

        return {
            "user": user,
            "post_count": len(posts),
            "comment_count": len(comments)
        }

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

    # Fetch data for multiple users concurrently
    results = await asyncio.gather(
        fetch_user_data(1),
        fetch_user_data(2),
        fetch_user_data(3)
    )

    # This one talks to a live API, so your own timing will differ
    elapsed = time.time() - start

    for i, result in enumerate(results, 1):
        print(f"User {i}: {result['post_count']} posts, "
              f"{result['comment_count']} comments")

    print(f"\nTotal time: {elapsed:.2f}s for 9 requests")

# Run
asyncio.run(main())