courses/E375004/asyncio/asyncio.ipynb

{
 "cells": [
  {
   "attachments": {
    "3d3fc3cd-cd5b-4db7-9fe3-31bab484fdf4.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "a8fba407-53e5-4095-bffb-a5e0a00f531b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Asyncio\n",
    "\n",
    "Asyncio is a Python library that provides support for asynchronous programming. It allows you to write concurrent code that performs non-blocking I/O operations, making it well-suited for applications that need to handle many connections or I/O-bound tasks efficiently. \n",
    "\n",
    "## Concurrent vs. Parallel - Ways tasks are executed.\n",
    "\n",
    "**Concurrency** refers to the ability of a system to execute multiple tasks or processes in overlapping time periods, enabling efficient resource utilization and responsiveness, even on a single processing unit.\n",
    "\n",
    "**Parallelism** is a specific kind of concurrency where tasks are really executed simultaneously. In computer science, parallelism can only be achieved in multicore environments.\n",
    "\n",
    "![1 dDJO9Ski233CLRadWdbqvQ.png](attachment:3d3fc3cd-cd5b-4db7-9fe3-31bab484fdf4.png)\n",
    "\n",
    "## Synchronous vs. Asynchronous - Programming models.\n",
    "\n",
    "In **Synchronous**, you write code as steps that are executed in order, from top to bottom. In an **Asynchronous** programming model, you write code as tasks, which are then executed concurrently. Executing concurrently means that all the tasks are likely executed at the same time.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7f804d23-f016-4bc6-90f2-9a412b060f8a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One\n",
      "Two\n",
      "One\n",
      "Two\n",
      "One\n",
      "Two\n",
      "Task executed in 3.00 seconds.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def count():\n",
    "    print(\"One\")\n",
    "    time.sleep(1)\n",
    "    print(\"Two\")\n",
    "\n",
    "def main():\n",
    "    for _ in range(3):\n",
    "        count()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    s = time.perf_counter()\n",
    "    main()\n",
    "    elapsed = time.perf_counter() - s\n",
    "    print(f\"Task executed in {elapsed:0.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dd4f38aa-86bc-43f5-8def-94b152e17f2f",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "One\n",
      "One\n",
      "One\n",
      "Two\n",
      "Two\n",
      "Two\n",
      "Task executed in 1.01 seconds.\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "import time\n",
    "\n",
    "async def count():\n",
    "    print(\"One\")\n",
    "    await asyncio.sleep(1)\n",
    "    print(\"Two\")\n",
    "\n",
    "async def main():\n",
    "    await asyncio.gather(count(), count(), count())\n",
    "\n",
    "if __name__ == \"__main__\":    \n",
    "    s = time.perf_counter()\n",
    "    asyncio.run(main())  # if running inside jupyter use `await main()` instead\n",
    "    elapsed = time.perf_counter() - s\n",
    "    print(f\"Task executed in {elapsed:0.2f} seconds.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bbbe38-8703-465e-abfc-edf3077d17c7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Basic concepts\n",
    "\n",
    "1. **`async def`**: This keyword is used to define a coroutine function, which can be awaited asynchronously. For example:\n",
    "   ```python\n",
    "   async def my_coroutine():\n",
    "       # asynchronous code here\n",
    "   ```\n",
    "   \n",
    "2. **`await`**: This keyword is used inside coroutine functions to await the result of another coroutine or a Future object. It suspends the execution of the coroutine until the awaited coroutine or Future completes. For example:\n",
    "   ```python\n",
    "   async def my_coroutine():\n",
    "       result = await some_async_function()\n",
    "   ```\n",
    "   \n",
    "3. **`asyncio.sleep()`**: This function suspends the execution of the current coroutine for a specified amount of time (in seconds) without blocking the event loop. It is often used to simulate asynchronous delays. For example:\n",
    "   ```python\n",
    "   async def my_coroutine():\n",
    "       await asyncio.sleep(1)\n",
    "       print(\"One second has passed.\")\n",
    "   ```\n",
    "   \n",
    "5. **`asyncio.run()`**: This function is used to run the top-level entry point coroutine in an asyncio application. It creates an event loop, runs the coroutine until it completes, and then closes the event loop. For example:\n",
    "   ```python\n",
    "   asyncio.run(main_coroutine())\n",
    "   ```\n",
    "   \n",
    "8. **`asyncio.gather()`**: This function is used to concurrently run multiple coroutines and wait for all of them to complete. It returns a list of results in the same order as the coroutines passed to it. For example:\n",
    "   ```python\n",
    "   results = await asyncio.gather(coroutine1(), coroutine2(), coroutine3())\n",
    "   ```\n",
    "     \n",
    "4. **`async with`**: This syntax allows you to use asynchronous context managers, which are like regular context managers but support asynchronous operations. For example:\n",
    "   ```python\n",
    "   async with async_open('file.txt') as file:\n",
    "       data = await file.read()\n",
    "   ```\n",
    "\n",
    "9. **`async for`**: This construct is used to asynchronously iterate over an asynchronous iterable. It is often used to iterate over the results of asynchronous generators or asynchronous iterators. For example:\n",
    "```python\n",
    "async def async_generator():\n",
    "    for i in range(5):\n",
    "        yield i\n",
    "\n",
    "async def my_coroutine():\n",
    "    async for item in async_generator():\n",
    "        print(item)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cf24cb8a-0eb5-4dd7-ad93-646ba507b333",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "async def g():\n",
    "    # Pause here and come back to g() when f() is ready\n",
    "    r = await f()\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2e0c1a6-9a77-456e-a670-b0a87f510cab",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Concurent random number search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1d3efba1-cc8c-4e9a-bd17-9a0e8fb8e506",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001B[32mInitiated makerandom(0).\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[91mInitiated makerandom(1).\u001B[0m\n",
      "\u001B[91mmakerandom(1) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[34mInitiated makerandom(2).\u001B[0m\n",
      "\u001B[34mmakerandom(2) == 0 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[91mmakerandom(1) == 7 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[34mmakerandom(2) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 8 too low; retrying.\u001B[0m\n",
      "\u001B[91m---> Finished: makerandom(1) == 10\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 7 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 8 too low; retrying.\u001B[0m\n",
      "\u001B[34mmakerandom(2) == 4 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 7 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 1 too low; retrying.\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 6 too low; retrying.\u001B[0m\n",
      "\u001B[34m---> Finished: makerandom(2) == 9\u001B[0m\n",
      "\u001B[32mmakerandom(0) == 3 too low; retrying.\u001B[0m\n",
      "\u001B[32m---> Finished: makerandom(0) == 9\u001B[0m\n",
      "r1: 9, r2: 10, r3: 9\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "import random\n",
    "\n",
    "# ANSI colors\n",
    "c = (\n",
    "    \"\\033[32m\",  # Green\n",
    "    \"\\033[91m\",  # Red\n",
    "    \"\\033[34m\",  # Blue\n",
    ")\n",
    "\n",
    "def color_print(text, color_idx):\n",
    "    print(c[color_idx] + text + \"\\033[0m\")\n",
    "\n",
    "async def makerandom(idx: int, threshold: int = 6) -> int:\n",
    "    color_print(f\"Initiated makerandom({idx}).\", idx)\n",
    "    i = random.randint(0, 10)\n",
    "    while i <= threshold:\n",
    "        color_print(f\"makerandom({idx}) == {i} too low; retrying.\", idx)\n",
    "        await asyncio.sleep(idx + 1)\n",
    "        i = random.randint(0, 10)\n",
    "    color_print(f\"---> Finished: makerandom({idx}) == {i}\", idx)\n",
    "    return i\n",
    "\n",
    "async def main():\n",
    "    res = await asyncio.gather(*(makerandom(i, 8) for i in range(3)))\n",
    "    return res\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    random.seed(444)\n",
    "    r1, r2, r3 = asyncio.run(main())  # if running inside jupyter use `await main()` instead\n",
    "    print(f\"r1: {r1}, r2: {r2}, r3: {r3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be5a2996-eb2e-4b9e-aca2-c4509e39591b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Asyncio Tasks and TaskGroup\n",
    "\n",
    "New in `python3.11` \n",
    "\n",
    "An asyncio task represents the execution of a coroutine in the event loop. It is a higher-level abstraction built on top of coroutines.\n",
    "\n",
    "An asyncio task group is a context manager provided by the asyncio module for managing multiple concurrent tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "08551998-e72d-4d00-ada6-91b3fca01ea8",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coroutine 1 started\n",
      "Coroutine 2 started\n",
      "Coroutine 2 finished\n",
      "Coroutine 1 finished\n",
      "Result: Result from coroutine 1\n",
      "Result: Result from coroutine 2\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "\n",
    "# Define some asynchronous coroutine functions\n",
    "async def coroutine1():\n",
    "    print(\"Coroutine 1 started\")\n",
    "    await asyncio.sleep(2)\n",
    "    print(\"Coroutine 1 finished\")\n",
    "    return \"Result from coroutine 1\"\n",
    "\n",
    "async def coroutine2():\n",
    "    print(\"Coroutine 2 started\")\n",
    "    await asyncio.sleep(1)\n",
    "    print(\"Coroutine 2 finished\")\n",
    "    return \"Result from coroutine 2\"\n",
    "\n",
    "async def main():\n",
    "    # Create tasks from the coroutines\n",
    "    task1 = asyncio.create_task(coroutine1())\n",
    "    task2 = asyncio.create_task(coroutine2())\n",
    "\n",
    "    # Wait for all tasks to complete\n",
    "    results = await asyncio.gather(task1, task2)\n",
    "\n",
    "    # Print the results\n",
    "    for result in results:\n",
    "        print(\"Result:\", result)\n",
    "\n",
    "# Run the main coroutine\n",
    "asyncio.run(main())  # if running inside jupyter use `await main()` instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "82061935-9823-4e8b-8407-cb7b4b14da70",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coroutine 1 started\n",
      "Coroutine 2 started\n",
      "Coroutine 2 finished\n",
      "Coroutine 1 finished\n",
      "Result: Result from coroutine 1\n",
      "Result: Result from coroutine 2\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "\n",
    "# Define some asynchronous coroutine functions\n",
    "async def coroutine1():\n",
    "    print(\"Coroutine 1 started\")\n",
    "    await asyncio.sleep(2)\n",
    "    print(\"Coroutine 1 finished\")\n",
    "    return \"Result from coroutine 1\"\n",
    "\n",
    "async def coroutine2():\n",
    "    print(\"Coroutine 2 started\")\n",
    "    await asyncio.sleep(1)\n",
    "    print(\"Coroutine 2 finished\")\n",
    "    return \"Result from coroutine 2\"\n",
    "\n",
    "async def main():\n",
    "    async with asyncio.TaskGroup() as tg:\n",
    "        # Schedule coroutines to run concurrently within the task group\n",
    "        task1 = tg.create_task(coroutine1())\n",
    "        task2 = tg.create_task(coroutine2())\n",
    "\n",
    "    # Access results obtained from the task group\n",
    "    results = [await task1, await task2]\n",
    "\n",
    "    # Print the results\n",
    "    for result in results:\n",
    "        print(\"Result:\", result)\n",
    "\n",
    "# Run the main coroutine\n",
    "asyncio.run(main())  # if running inside jupyter use `await main()` instead"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0679e9d7-5ac8-46b1-a390-dcba6f505a84",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Synchronous and asynchronous images downloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c71307a6-a6dd-45e7-ae56-c6c59018ef65",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading photo-759\n",
      "photo-759 was downloaded...\n",
      "Downloading photo-719\n",
      "photo-719 was downloaded...\n",
      "Downloading photo-97c\n",
      "photo-97c was downloaded...\n",
      "Downloading photo-d79\n",
      "photo-d79 was downloaded...\n",
      "Downloading photo-235\n",
      "photo-235 was downloaded...\n",
      "Downloading photo-4b6\n",
      "photo-4b6 was downloaded...\n",
      "Downloading photo-267\n",
      "photo-267 was downloaded...\n",
      "Downloading photo-c03\n",
      "photo-c03 was downloaded...\n",
      "Downloading photo-097\n",
      "photo-097 was downloaded...\n",
      "Downloading photo-c0e\n",
      "photo-c0e was downloaded...\n",
      "Downloading photo-cde\n",
      "photo-cde was downloaded...\n",
      "Downloading photo-b99\n",
      "photo-b99 was downloaded...\n",
      "Downloading photo-a84\n",
      "photo-a84 was downloaded...\n",
      "Downloading photo-70e\n",
      "photo-70e was downloaded...\n",
      "Downloading photo-f0c\n",
      "photo-f0c was downloaded...\n",
      "Finished in 15.556760787963867 seconds\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "import time\n",
    "\n",
    "# image urls for download\n",
    "img_urls = [\n",
    "    'https://images.unsplash.com/photo-1516117172878-fd2c41f4a759',\n",
    "    'https://images.unsplash.com/photo-1532009324734-20a7a5813719',\n",
    "    'https://images.unsplash.com/photo-1524429656589-6633a470097c',\n",
    "    'https://images.unsplash.com/photo-1530224264768-7ff8c1789d79',\n",
    "    'https://images.unsplash.com/photo-1564135624576-c5c88640f235',\n",
    "    'https://images.unsplash.com/photo-1541698444083-023c97d3f4b6',\n",
    "    'https://images.unsplash.com/photo-1522364723953-452d3431c267',\n",
    "    'https://images.unsplash.com/photo-1513938709626-033611b8cc03',\n",
    "    'https://images.unsplash.com/photo-1507143550189-fed454f93097',\n",
    "    'https://images.unsplash.com/photo-1493976040374-85c8e12f0c0e',\n",
    "    'https://images.unsplash.com/photo-1504198453319-5ce911bafcde',\n",
    "    'https://images.unsplash.com/photo-1530122037265-a5f1f91d3b99',\n",
    "    'https://images.unsplash.com/photo-1516972810927-80185027ca84',\n",
    "    'https://images.unsplash.com/photo-1550439062-609e1531270e',\n",
    "    'https://images.unsplash.com/photo-1549692520-acc6669e2f0c'\n",
    "]\n",
    "\n",
    "start_measure = time.time()\n",
    "\n",
    "# Function for downloading\n",
    "def download_image(img_url):\n",
    "    img_name = f\"photo-{img_url[-3:]}\"\n",
    "    print(f'Downloading {img_name}')\n",
    "    img_bytes = requests.get(img_url).content\n",
    "    with open(f\"images/{img_name}.jpg\", 'wb') as img_file:\n",
    "        img_file.write(img_bytes)\n",
    "        print(f'{img_name} was downloaded...')\n",
    "\n",
    "def main():\n",
    "    # Download images\n",
    "    for url in img_urls:\n",
    "        download_image(url)\n",
    "    \n",
    "    stop_measure = time.time()\n",
    "    \n",
    "    print('Finished in {} seconds'.format(stop_measure-start_measure))\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "06490372-d2cc-4e4a-bdd5-f359a2f7d519",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading photo-759\n",
      "Downloading photo-719\n",
      "Downloading photo-97c\n",
      "Downloading photo-d79\n",
      "Downloading photo-235\n",
      "Downloading photo-4b6\n",
      "Downloading photo-267\n",
      "Downloading photo-c03\n",
      "Downloading photo-097\n",
      "Downloading photo-c0e\n",
      "Downloading photo-cde\n",
      "Downloading photo-b99\n",
      "Downloading photo-a84\n",
      "Downloading photo-70e\n",
      "Downloading photo-f0c\n",
      "photo-c03 was downloaded...\n",
      "photo-097 was downloaded...\n",
      "photo-759 was downloaded...\n",
      "photo-719 was downloaded...\n",
      "photo-97c was downloaded...\n",
      "photo-a84 was downloaded...\n",
      "photo-d79 was downloaded...\n",
      "photo-267 was downloaded...\n",
      "photo-70e was downloaded...\n",
      "photo-4b6 was downloaded...\n",
      "photo-f0c was downloaded...\n",
      "photo-b99 was downloaded...\n",
      "photo-235 was downloaded...\n",
      "photo-cde was downloaded...\n",
      "photo-c0e was downloaded...\n",
      "Finished in 5.209580421447754 seconds\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "from aiohttp import ClientSession\n",
    "\n",
    "# image urls for download\n",
    "img_urls = [\n",
    "    'https://images.unsplash.com/photo-1516117172878-fd2c41f4a759',\n",
    "    'https://images.unsplash.com/photo-1532009324734-20a7a5813719',\n",
    "    'https://images.unsplash.com/photo-1524429656589-6633a470097c',\n",
    "    'https://images.unsplash.com/photo-1530224264768-7ff8c1789d79',\n",
    "    'https://images.unsplash.com/photo-1564135624576-c5c88640f235',\n",
    "    'https://images.unsplash.com/photo-1541698444083-023c97d3f4b6',\n",
    "    'https://images.unsplash.com/photo-1522364723953-452d3431c267',\n",
    "    'https://images.unsplash.com/photo-1513938709626-033611b8cc03',\n",
    "    'https://images.unsplash.com/photo-1507143550189-fed454f93097',\n",
    "    'https://images.unsplash.com/photo-1493976040374-85c8e12f0c0e',\n",
    "    'https://images.unsplash.com/photo-1504198453319-5ce911bafcde',\n",
    "    'https://images.unsplash.com/photo-1530122037265-a5f1f91d3b99',\n",
    "    'https://images.unsplash.com/photo-1516972810927-80185027ca84',\n",
    "    'https://images.unsplash.com/photo-1550439062-609e1531270e',\n",
    "    'https://images.unsplash.com/photo-1549692520-acc6669e2f0c'\n",
    "]\n",
    "\n",
    "start_measure = time.time()\n",
    "\n",
    "async def get_image_data(url):\n",
    "    async with ClientSession() as session:\n",
    "        async with session.get(url) as response:\n",
    "            response = await response.read()\n",
    "            return response\n",
    "\n",
    "# Function for downloading\n",
    "async def download_image(img_url):\n",
    "    img_name = f\"photo-{img_url[-3:]}\"\n",
    "    print(f'Downloading {img_name}')\n",
    "    img_bytes = await get_image_data(img_url)\n",
    "    with open(f\"images/{img_name}.jpg\", 'wb') as img_file:\n",
    "        img_file.write(img_bytes)\n",
    "        print(f'{img_name} was downloaded...')\n",
    "        \n",
    "async def main():\n",
    "\n",
    "    tasks = []  # prepare a list for future threads\n",
    "\n",
    "    for url in img_urls:\n",
    "        task = asyncio.create_task(download_image(url))\n",
    "        tasks.append(task)\n",
    "\n",
    "    await asyncio.gather(*tasks)\n",
    "\n",
    "    stop_measure = time.time()\n",
    "\n",
    "    print('Finished in {} seconds'.format(stop_measure - start_measure))\n",
    "    \n",
    "asyncio.run(main())  # if running inside jupyter use `await main()` instead"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "175125e2-53a0-4ed4-9373-4c17a742104a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## References\n",
    "\n",
    "https://docs.python.org/3.12/library/asyncio.html\n",
    "\n",
    "https://realpython.com/async-io-python/#where-does-async-io-fit-in\n",
    "\n",
    "https://stackoverflow.com/questions/4844637/what-is-the-difference-between-concurrency-parallelism-and-asynchronous-methods"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}