asyncio - main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:90% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:90% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A practical guide to speed up your application\n",
    "# with Asyncio\n",
    "\n",
    "By Niels Denissen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Niels Denissen\n",
    "\n",
    "<center><img src=\"https://media.licdn.com/media/AAEAAQAAAAAAAAd8AAAAJDAyODhlNzFlLWYwYTktNDAxNC1iYjBkLWFhNTdlMWZhNmQzNg.jpg\" style=\"width: 350px;\" alt=\"Drawing\"></center>\n",
    "\n",
    "<table style=\"width:60%;border:0px;\">\n",
    "  <tr style=\"border:0px;\">\n",
    "    <td style=\"border:0px;\"><img src=\"./img/wbaa.png\" style=\"width:350px\"></td>\n",
    "    <td style=\"border:0px;\">Data Engineer / Scientist</td>\n",
    "  </tr>\n",
    "  <tr style=\"border:0px;\">\n",
    "    <td style=\"border:0px;\"><img src=\"./img/uu.png\" style=\"width:250px\"></td>\n",
    "    <td style=\"border:0px;\">Msc. Artificial Intelligence</td>\n",
    "  </tr>\n",
    "  <tr border=\"0\" style=\"border:0px;\">\n",
    "    <td style=\"border:0px;\"><img src=\"./img/tue.svg\" style=\"width:200px\"></td>\n",
    "    <td style=\"border:0px;\">Bsc. Computer Science</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# At the end of this session, you will...\n",
    "* Understand the fundamentals of async programming\n",
    "* Know when it will speed up your program\n",
    "* Be able to change your sync code to async code\n",
    "* (if we go really fast...) know how to circumvent typical pitfalls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide01.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide02.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide03.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide04.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide05.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img width=90% src=\"./img/Slides/Slide06.jpg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why would you want this?\n",
    "\n",
    "In general for applications that rely heavily on I/O."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<center><img src=\"./img/results_bar.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How does it work?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide07.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide08.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide09.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide10.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide11.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"./img/Slides/Slide12.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Key things to remember:\n",
    "\n",
    "1. **Program async tasks**: i.e, when to give control back to loop\n",
    "2. **Create an event loop**: it controls stuff for you\n",
    "3. **Assign tasks to event loop**: tell  loop which tasks it has to run\n",
    "4. **Run event loop**: specifying when it should stop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's look at some code\n",
    "Starting with a regular synchronous example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def pydataTalk(sleep_time):\n",
    "    print(\"Welcome\")\n",
    "    time.sleep(sleep_time)\n",
    "    print(\"?\")\n",
    "    time.sleep(sleep_time)\n",
    "    print(\"Profit $\")\n",
    "    return \"Knowledge\"\n",
    "\n",
    "pydataTalk(sleep_time=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Speaker note:** See this as a process (me) doing something with data (saying words). This sleep in between my slides represents a database query waiting for the database to return the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Now what does this look like asynchronous?\n",
    "* **```async```** in front of function you want to run asynchronously\n",
    "* **```await```** inside function to give back control to loop\n",
    "\n",
    "Let's rewrite the function ```pydataTalk``` to it's async equivalent together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Rewrite this function to it's async equivalent\n",
    "import time\n",
    "\n",
    "# 1. Program async tasks: i.e, when to give control back to loop\n",
    "def pydataTalk(sleep_time):\n",
    "    print(\"Welcome\")\n",
    "    time.sleep(sleep_time)\n",
    "    print(\"?\")\n",
    "    time.sleep(sleep_time)\n",
    "    print(\"Profit $\")\n",
    "    return \"Knowledge\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# What happens if we call? ...\n",
    "pydataTalk(sleep_time=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# 2. Create an event loop: it controls stuff for you\n",
    "\n",
    "# 3. Assign tasks to event loop: tell loop which tasks it has to run\n",
    "\n",
    "# 4. Run event loop: specifying when it should stop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Back-up solution\n",
    "\n",
    "# 1. Program async tasks: i.e, when to give control back to loop\n",
    "import asyncio\n",
    "\n",
    "async def pydataTalk(sleep_time):\n",
    "    print(\"Welcome\")\n",
    "    await asyncio.sleep(sleep_time)\n",
    "    print(\"?\")\n",
    "    await asyncio.sleep(sleep_time)\n",
    "    print(\"Profit $\")\n",
    "    return \"Knowledge\"\n",
    "\n",
    "\n",
    "# 2. Create an event loop: it controls stuff for you\n",
    "loop = asyncio.get_event_loop()\n",
    "\n",
    "# 3. Assign tasks to event loop: tell loop which tasks it has to run\n",
    "taskA = loop.create_task(pydataTalk(sleep_time=0.5))\n",
    "\n",
    "# 4. Run event loop: specifying when it should stop\n",
    "loop.run_until_complete(taskA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Let's add another async task\n",
    "What will happen here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "async def drinkWater(sleep_time):\n",
    "    print(\"1st sip\")\n",
    "    await asyncio.sleep(sleep_time)\n",
    "    print(\"2nd sip\")\n",
    "    return \"Bathroom break\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "talk = pydataTalk(sleep_time=1)\n",
    "drink = drinkWater(sleep_time=1)\n",
    "task_talk = loop.create_task(talk)\n",
    "task_drink = loop.create_task(drink)\n",
    "loop.run_until_complete(task_drink)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "loop.run_until_complete(task_talk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Proper way of executing multiple tasks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "talk = pydataTalk(sleep_time=1)\n",
    "drink = drinkWater(sleep_time=1)\n",
    "task_talk = loop.create_task(talk)\n",
    "task_drink = loop.create_task(drink)\n",
    "loop.run_until_complete(asyncio.gather(task_talk, task_drink))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Key things to remember (with code):\n",
    "\n",
    "1) **Program async tasks**: i.e, when to give control back to loop  \n",
    "- **```async```** in front of function (```async def functionA():```)\n",
    "- **```await```** to give back control to loop\n",
    "\n",
    "2) **Create an event loop**: it controls stuff for you\n",
    "- ```loop = asyncio.get_event_loop()```\n",
    "\n",
    "3) **Assign tasks to event loop**: tell loop which tasks it has to run\n",
    "- ```taskA = loop.create_task(functionA)```\n",
    "\n",
    "4) **Run event loop**: specifying when it should stop\n",
    "- ```loop.run_until_complete(taskA)```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# On to a more realistic example!\n",
    "\n",
    "Suppose we want to scrape marktplaats (eBay) pages and write the results to a database.\n",
    "\n",
    "**Prerequisite:** Make sure to start postgres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "def get_page_soup(url, session):\n",
    "    \"\"\"\n",
    "    Try get the given url and return souped version.\n",
    "    If an error occured, return None.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        #Get HTML page\n",
    "        response = session.get(url)\n",
    "            \n",
    "        # Parse the page using beautiful soup\n",
    "        return BeautifulSoup(response.text, \"html.parser\")\n",
    "    except:\n",
    "        print(\"Couldn't find url: {}\".format(url))\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def gen_data(pages=list(range(1,200))):\n",
    "    \"\"\"\n",
    "    Data generator: reads pages from marktplaats and yields descriptions given with products\n",
    "    \"\"\"\n",
    "    \n",
    "    # Specification of base url\n",
    "    base_url = \"http://www.marktplaats.nl/z/motoren.html?categoryId=678&currentPage=\"\n",
    "    \n",
    "    # Use same session throughout the lifetime of the generator\n",
    "    with requests.Session() as session:\n",
    "        for page in pages:\n",
    "            soup = get_page_soup(base_url + str(page), session)\n",
    "            if soup is None: continue\n",
    "\n",
    "            # Run through all articles\n",
    "            for article in soup.find_all('article'):\n",
    "                try:\n",
    "                    # Extract url of article and get souped version\n",
    "                    article_url = article.attrs['data-url']\n",
    "                    article_soup = get_page_soup(article_url, session)\n",
    "                    if article_soup is None: continue\n",
    "\n",
    "                    # Run through all descriptions\n",
    "                    for a in article_soup.find_all('div', {'id': 'vip-ad-description'}):\n",
    "                        if a.text is not None: yield str(a.text)\n",
    "                except KeyError:\n",
    "                    # Couldn't find the url of this article, pass it\n",
    "                    pass\n",
    "        \n",
    "data_generator = gen_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "next(data_generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "nbpresent": {
     "id": "15a2c93d-7e56-433e-bca5-41641fce882b"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Synchronous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import psycopg2\n",
    "\n",
    "class Sync:\n",
    "    # DSN for postgres\n",
    "    postgres_dsn = \"dbname='postgres' user='postgres' password='pydata' host='localhost'\"\n",
    "\n",
    "    def _write(self, page, conn):\n",
    "        \"\"\"\n",
    "        Private funtion to write all descriptions from marktplaats page to database\n",
    "        \"\"\"\n",
    "        description_counter = 0\n",
    "        with conn.cursor() as cursor:\n",
    "            for data_entry in gen_data(pages=[page]):\n",
    "                cursor.execute(\"\"\"INSERT INTO pydata(text) VALUES (%s)\"\"\", [data_entry])\n",
    "                description_counter += 1\n",
    "        \n",
    "        return description_counter\n",
    "            \n",
    "    def write_single(self, page):\n",
    "        \"\"\"\n",
    "        Write single page\n",
    "        \"\"\"\n",
    "        with psycopg2.connect(dsn=self.postgres_dsn) as conn:\n",
    "            return self._write(page,conn)\n",
    "    \n",
    "    def write_everything(self, n_pages=8):\n",
    "        \"\"\"\n",
    "        Write specified number of pages\n",
    "        \"\"\"\n",
    "        description_counters = []\n",
    "        with psycopg2.connect(dsn=self.postgres_dsn) as conn:\n",
    "            for page in range(1, n_pages+1):\n",
    "                description_counters.append(self._write(page, conn))\n",
    "        \n",
    "        return sum(description_counters)\n",
    "\n",
    "    def read(self):\n",
    "        \"\"\"\n",
    "        Read all from postgres\n",
    "        \"\"\"\n",
    "        with psycopg2.connect(dsn=self.postgres_dsn) as conn:\n",
    "            with conn.cursor() as cursor:\n",
    "                cursor.execute(\"SELECT text FROM pydata;\")\n",
    "                return cursor.fetchall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multi-threaded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from multiprocessing import Pool\n",
    "\n",
    "class Threads:\n",
    "    def write_everything(self, n_pages=8, no_threads=8):\n",
    "        \"\"\"\n",
    "        Start thread pool with specified number of threads, start synchronous client in each\n",
    "        \"\"\"\n",
    "        p = Pool(processes=no_threads)\n",
    "        description_counters = p.map(Sync().write_single, range(1,n_pages+1))\n",
    "        p.close()\n",
    "        p.terminate()\n",
    "        \n",
    "        # Return the sum of each result (number of articles done)\n",
    "        return sum(description_counters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "nbpresent": {
     "id": "fd679c88-2ef8-480b-8365-fed8e6480154"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Asynchronous\n",
    "\n",
    "For the asynchronous part we'll have to rewrite our generator. This needs to be asynchronous as well (supported since  3.6: https://www.python.org/dev/peps/pep-0525/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "import aiohttp\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "async def get_page_soup_async(url, session, sem):\n",
    "    \"\"\"\n",
    "    Try get the given url and return souped version.\n",
    "    If an error occured, return None.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        # Get HTML page using semaphore to limit the open connections at a time\n",
    "        async with sem:\n",
    "            async with session.get(url) as resp:\n",
    "                response = await resp.text()\n",
    "            \n",
    "        # Parse the page using beautiful soup\n",
    "        return BeautifulSoup(response, \"html.parser\")\n",
    "    except:\n",
    "        print(\"Couldn't find url: {}\".format(url))\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "async def gen_data_async(pages=list(range(1,200))):\n",
    "    \"\"\"\n",
    "    Data generator: reads pages from marktplaats and yields descriptions given with products\n",
    "    \"\"\"\n",
    "    # Specification of base url\n",
    "    base_url = \"http://www.marktplaats.nl/z/motoren.html?categoryId=678&currentPage=\"\n",
    "    \n",
    "    # Use same session throughout the lifetime of the generator\n",
    "    async with aiohttp.ClientSession() as session:\n",
    "        # create instance of Semaphore to limit amount of open http connections\n",
    "        sem = asyncio.Semaphore(1000)\n",
    "    \n",
    "        for page in pages:\n",
    "            response_soup = await get_page_soup_async(base_url + str(page), session, sem)\n",
    "            if response_soup is None: continue\n",
    "            \n",
    "            # Run through all articles\n",
    "            for article in response_soup.find_all('article'):\n",
    "                try:\n",
    "                    # Extract url of article and get souped version\n",
    "                    article_url = article.attrs['data-url']\n",
    "                    article_soup = await get_page_soup_async(article_url, session, sem)\n",
    "                    if article_soup is None: continue\n",
    "\n",
    "                    # Run through all descriptions\n",
    "                    for a in article_soup.find_all('div', {'id': 'vip-ad-description'}):\n",
    "                        if a.text is not None: yield str(a.text)\n",
    "                except KeyError:\n",
    "                    # Couldn't find the url of this article, pass it\n",
    "                    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "import asyncpg\n",
    "\n",
    "class Async:\n",
    "    async def _write(self, page):\n",
    "        \"\"\"\n",
    "        Write descriptions of page to database\n",
    "        \"\"\"\n",
    "        description_counter = 0\n",
    "        async with self.conn_pool_async.acquire() as conn_async:\n",
    "            async with conn_async.transaction():\n",
    "                async for data_entry in gen_data_async(pages=[page]):\n",
    "                    await conn_async.execute(\"\"\"INSERT INTO pydata(text) VALUES ($1)\"\"\", data_entry)\n",
    "                    description_counter += 1\n",
    "                    \n",
    "        return description_counter\n",
    "\n",
    "    def write_everything(self, n_pages=8):\n",
    "        \"\"\"\n",
    "        Write multiple pages asynchronously to the database\n",
    "        \"\"\"\n",
    "        # Create new loop and tell asyncio to use it\n",
    "        self.loop = asyncio.new_event_loop()\n",
    "        asyncio.set_event_loop(self.loop)\n",
    "        \n",
    "        # Create the connection pool\n",
    "        self.conn_pool_async = self.loop.run_until_complete(\n",
    "            asyncpg.create_pool(min_size=1, max_size=100, host='localhost', port=5432,\n",
    "                                user='postgres', password='pydata', database='postgres'))\n",
    "        \n",
    "        # Create a task per page and run until all of them complete\n",
    "        tasks = [self.loop.create_task(self._write(p)) for p in range(1, n_pages+1)]\n",
    "        description_counters = self.loop.run_until_complete(asyncio.gather(*tasks))\n",
    "        \n",
    "        # Close the loop\n",
    "        self.loop.close()\n",
    "        \n",
    "        return sum(description_counters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Speed comparison\n",
    "\n",
    "First we define some functions to time the different implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def time_sync(n_pages):\n",
    "    start_time = time.time()\n",
    "    n_written = Sync().write_everything(n_pages=n_pages)\n",
    "    runtime = time.time() - start_time\n",
    "    return (n_written, runtime)\n",
    "\n",
    "def time_threads(n_pages, n_threads):\n",
    "    start_time = time.time()\n",
    "    n_written = Threads().write_everything(n_pages=n_pages, no_threads=n_threads)\n",
    "    runtime = time.time() - start_time\n",
    "    return (n_written, runtime)\n",
    "\n",
    "def time_async(n_pages):\n",
    "    start_time = time.time()\n",
    "    n_written = Async().write_everything(n_pages=n_pages)\n",
    "    runtime = time.time() - start_time\n",
    "    return (n_written, runtime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Now we'll run each implementation for various number of pages and a various number of threads for multithreading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "result_list = []\n",
    "\n",
    "# Run through range of pages\n",
    "for n_pages in [1,2,4,8,16,32,64,128]:\n",
    "    print(\"Processing n_pages={}\".format(n_pages))\n",
    "    \n",
    "    print(\"\\t Async\")\n",
    "    n_written, runtime = time_async(n_pages)\n",
    "    result_list.append([\"async\", n_written, 1, runtime])\n",
    "    \n",
    "    print(\"\\t Sync\")\n",
    "    n_written, runtime = time_sync(n_pages)\n",
    "    result_list.append([\"sync\", n_written, 1, runtime])\n",
    "    \n",
    "    for n_threads in [2,4,8]:\n",
    "        print(\"\\t Threads: {}\".format(n_threads))\n",
    "        n_written, runtime = time_threads(n_pages, n_threads)\n",
    "        result_list.append([\"threaded\", n_written, n_threads, runtime])\n",
    "        \n",
    "# Write all to a pandas Dataframe\n",
    "results_df = pd.DataFrame(result_list, columns=[\"type\", \"n_written\",\"n_threads\",\"time\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "pickle.dump(results_df, open(\"data/results_df.p\",\"wb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "results_df_aggr = results_df.groupby([\"type\",\"n_threads\"]).sum()\n",
    "results_df_aggr['sec_article'] = results_df_aggr.time / results_df_aggr.n_written"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1,1, figsize=(15,5))\n",
    "\n",
    "# Plot bar chart of articles done per second\n",
    "ax.bar(left=[i+0.8 for i in range(len(results_df_aggr.sec_article))], \n",
    "       height=results_df_aggr.sec_article, \n",
    "       width=0.9,\n",
    "       color=['green','blue','orange','red','black'])\n",
    "\n",
    "ax.set_xticks([i+0.8 for i in range(len(results_df_aggr.sec_article))])\n",
    "ax.set_xticklabels([\"Aysnc\",\"Sync - 1 Thread\",\"Sync - 2 Threads\",\"Sync - 4 Threads\",\"Sync - 8 Threads\"])\n",
    "plt.legend(loc='best')\n",
    "plt.ylabel(\"Time per article (s)\")\n",
    "plt.savefig('results_bar.png',dpi=100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"./img/results_bar.png\"></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# Define plot and colors to use later on\n",
    "fig, ax = plt.subplots(1,1, figsize=(15,5))\n",
    "colors = {8:\"black\", 4:\"red\", 2:\"orange\", \"sync\": \"blue\", \"async\": \"green\"}\n",
    "\n",
    "# Plot sync\n",
    "results_sync = results_df[results_df.type == \"sync\"]\n",
    "ax.plot(results_sync.n_written, results_sync.time, '-', color=colors['sync'], label='sync')\n",
    "\n",
    "# Plot threads\n",
    "for tu in results_df.n_threads[results_df.n_threads > 1].unique():\n",
    "    results_threads = results_df[(results_df.type == \"threaded\") & (results_df.n_threads == tu)]\n",
    "    ax.plot(results_threads.n_written, results_threads.time, '-', color=colors[tu], label=str(tu)+' threads')\n",
    "    \n",
    "# Plot async\n",
    "results_async = results_df[results_df.type == \"async\"]\n",
    "ax.plot(results_async.n_written, results_async.time, '-', color=colors['async'], label='async')\n",
    "\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel(\"Articles written (#)\")\n",
    "plt.ylabel(\"Time (s)\")\n",
    "plt.savefig('results_line.png',dpi=100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center><img src=\"./img/results_line.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The solution to our Marktplaats problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Restart the database and gather all results anew here:\n",
    "Async().write_everything(n_pages=150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "from stop_words import get_stop_words\n",
    "\n",
    "regex = re.compile('[^a-zA-Z0-9]')\n",
    "stop_words = get_stop_words('dutch')\n",
    "\n",
    "words = [regex.sub('', word.lower()) for item in Sync().read() for word in item[0].split(' ')]\n",
    "words = [word for word in words if len(word) > 0 and word not in stop_words]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "%matplotlib inline\n",
    "\n",
    "count_words_sorted = pd.Series(Counter(words)).sort_values(ascending=True)\n",
    "\n",
    "high_counts = count_words_sorted[count_words_sorted.values > 1000]\n",
    "\n",
    "fig, ax = plt.subplots(1,1, figsize=(15,5))\n",
    "ax.barh(bottom=[i+0.8 for i in range(len(high_counts))], width=high_counts.values, height=0.9)\n",
    "ax.set_yticks([i+0.8 for i in range(len(high_counts))])\n",
    "ax.set_yticklabels(high_counts.index)\n",
    "\n",
    "plt.xlabel(\"Occurences in articles (#)\")\n",
    "plt.savefig('results_marktplaats.png',dpi=100)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<center><img src=\"./img/results_marktplaats.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Learnings from practice\n",
    "\n",
    "Here I'll list some things I've encountered in practice and make some suggestions on how you could solve this:\n",
    "- Exception handling\n",
    "- Passing data between tasks\n",
    "- Control your tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exception handling\n",
    "\n",
    "Handling exceptions raised in tasks of a loop can be very confusing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "async def pleaseExceptMe(sleep_time):\n",
    "    print(\"\\t Wait for it ...\")\n",
    "    await asyncio.sleep(sleep_time)\n",
    "    print(\"\\t Incoming!\")\n",
    "    raise Exception(\"You shall not PASS!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "loop = asyncio.get_event_loop()\n",
    "\n",
    "# Create except task and run it\n",
    "task_except = loop.create_task(pleaseExceptMe(sleep_time=2))\n",
    "loop.run_until_complete(task_except)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What if we want to run something indefinitely (like our server example)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "async def pydataTalk(sleep_time):\n",
    "    while True:\n",
    "        print(\"Welcome\")\n",
    "        await asyncio.sleep(sleep_time)\n",
    "        print(\"?\")\n",
    "        await asyncio.sleep(sleep_time)\n",
    "        print(\"Profit $\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We need a stopper to stop the loop after a specified amount of time. Otherwise it runs forever."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "async def stopper(loop_object, sleep_time):\n",
    "    await asyncio.sleep(sleep_time)\n",
    "    loop_object.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So what would happen now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Create new loop and tell asyncio to use it\n",
    "loop = asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "\n",
    "# Create tasks and run indefinitely\n",
    "task_talk = loop.create_task(pydataTalk(sleep_time=1))\n",
    "task_except = loop.create_task(pleaseExceptMe(sleep_time=2))\n",
    "task_stopper = loop.create_task(stopper(loop, sleep_time=4))\n",
    "loop.run_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Normally when you run a loop until a task completes with `run_until_complete` the result of the future is evaluated after execution. This evaluation could also mean throwing an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "task_except.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Whenever you run the loop forever (`run_forever()`), the result of the future isn't necessarily evaluated and thus exceptions might not be noticed.\n",
    "\n",
    "One way to circumvent this is to set the exception handler for the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def _exception_handler(loop_object, context):\n",
    "    loop_object.stop()\n",
    "    print(\"Exception: {0}\".format(context['exception']))\n",
    "    print(\"Entire context exception: {0}\".format(context))\n",
    "    \n",
    "# Set the exception handler\n",
    "loop.set_exception_handler(_exception_handler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "loop.create_task(pleaseExceptMe(sleep_time=1))\n",
    "loop.run_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Some very weird stuff happens if you catch the returned task..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "task_except = loop.create_task(pleaseExceptMe(sleep_time=1))\n",
    "task_stopper = loop.create_task(stopper(loop, sleep_time=5))\n",
    "loop.run_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The exception handler is never called, this apparantly is due to the fact that in the first case, upon garbage collecting the finished exceptMe task, the exception handler gets called (http://bugs.python.org/issue28274)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Passing data between tasks\n",
    "\n",
    "Use Queues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "async def adder(queue):\n",
    "    \"\"\" Add data to queue \"\"\"\n",
    "    for i in range(6):\n",
    "        await queue.put(i)\n",
    "        await asyncio.sleep(0.01)\n",
    "        \n",
    "async def reader(name, queue):\n",
    "    \"\"\" Read data from the queue \"\"\"\n",
    "    while True:\n",
    "        read = await queue.get()\n",
    "        print(\"Read by {0}: {1}\".format(name, read))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Create new loop and tell asyncio to use it\n",
    "loop = asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "\n",
    "# Add tasks and run until complete\n",
    "queue = asyncio.Queue()\n",
    "task_read1 = loop.create_task(reader(\"no.1\", queue))\n",
    "task_read2 = loop.create_task(reader(\"no.2\", queue))\n",
    "task_add = loop.create_task(adder(queue))\n",
    "loop.run_until_complete(task_add)\n",
    "loop.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control your tasks\n",
    "\n",
    "We saw already that `asyncio.gather` could combine tasks and wait for them to all finish. Using `asyncio.wait` you can have a bit more control over the tasks you dispatch to the loop. For example you can issue a timeout for tasks in the loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "async def sleeper(t):\n",
    "    await asyncio.sleep(t)\n",
    "    return \"slept\"\n",
    "\n",
    "# Create new loop and tell asyncio to use it\n",
    "loop = asyncio.new_event_loop()\n",
    "asyncio.set_event_loop(loop)\n",
    "\n",
    "task = loop.create_task(sleeper(2))\n",
    "loop.run_until_complete(asyncio.wait([task], timeout=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "task.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Or if you have multiple tasks and only want to wait for the first one to finish:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "task1 = loop.create_task(sleeper(2))\n",
    "task2 = loop.create_task(sleeper(4))\n",
    "loop.run_until_complete(\n",
    "    asyncio.wait([task1,task2], return_when=asyncio.FIRST_COMPLETED))\n",
    "print('task1: ' + str(task1.result()))\n",
    "print('task2: ' + str(task2.result()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Or finally, if you want to stop as soon as an exception in one of the tasks occurs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "async def sleeper_except(t):\n",
    "    await asyncio.sleep(t)\n",
    "    raise Exception('hello')\n",
    "    return \"slept\"\n",
    "\n",
    "task1 = loop.create_task(sleeper_except(1))\n",
    "task2 = loop.create_task(sleeper(4))\n",
    "loop.run_until_complete(\n",
    "    asyncio.wait([task1,task2], return_when=asyncio.FIRST_EXCEPTION))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "task1.result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "task2.result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# GitHub\n",
    "\n",
    "The presentation is available on GitHub: https://github.com/nielsdenissen/pydata-asyncio\n",
    "\n",
    "# References\n",
    "\n",
    "- In-depth blog post on asyncio: https://snarky.ca/how-the-heck-does-async-await-work-in-python-3-5/\n",
    "- Async file reading: https://github.com/Tinche/aiofiles\n",
    "- Using semaphores to limit open connections aiohttp: https://pawelmhm.github.io/asyncio/python/aiohttp/2016/04/22/asyncio-aiohttp.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Asyncio under the hood\n",
    "\n",
    "This post explains the concept very well: https://snarky.ca/how-the-heck-does-async-await-work-in-python-3-5/.\n",
    "All code below is copy pasted from there.\n",
    "\n",
    "Essentially a coroutine (task that runs in an eventloop) is very similar to a generator. Let's first look at a simple generator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def lazy_range(up_to):  \n",
    "    \"\"\"Generator to return the sequence of integers from 0 to up_to, exclusive.\"\"\"\n",
    "    index = 0\n",
    "    while index < up_to:\n",
    "        yield index\n",
    "        index += 1\n",
    "        \n",
    "generator = lazy_range(2)\n",
    "print(next(generator))\n",
    "print(next(generator))\n",
    "print(next(generator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But you can also send data to a generator since python 2.5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def jumping_range(up_to):  \n",
    "    \"\"\"Generator for the sequence of integers from 0 to up_to, exclusive.\n",
    "\n",
    "    Sending a value into the generator will shift the sequence by that amount.\n",
    "    \"\"\"\n",
    "    index = 0\n",
    "    while index < up_to:\n",
    "        jump = yield index\n",
    "        if jump is None:\n",
    "            jump = 1\n",
    "        index += jump"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "generator = jumping_range(10)\n",
    "print(next(generator))\n",
    "generator.send(5)\n",
    "print(next(generator))\n",
    "print(next(generator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`yield from` can be used to chain generators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bottom():  \n",
    "    # Returning the yield lets the value that goes up the call stack to come right back\n",
    "    # down.\n",
    "    return (yield 42)\n",
    "\n",
    "def middle():  \n",
    "    return (yield from bottom())\n",
    "\n",
    "def top():  \n",
    "    return (yield from middle())\n",
    "\n",
    "# Get the generator.\n",
    "gen = top()  \n",
    "value = next(gen)  \n",
    "print(value)  # Prints '42'.  \n",
    "try:  \n",
    "    value = gen.send(value * 2)\n",
    "except StopIteration as exc:  \n",
    "    value = exc.value\n",
    "print(value)  # Prints '84'. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Put bluntly this is the concept that python uses to implement asynchronous programming. Programs yield from (await) Future objects. These future objects will at a certain point in time return a value. That only happens though, when the future is done (e.g. data is received from a database). Before that the future will yield wait times that the loop will have to wait before checking again if the future is done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import datetime  \n",
    "import heapq  \n",
    "import types  \n",
    "import time\n",
    "\n",
    "\n",
    "class Task:\n",
    "\n",
    "    \"\"\"Represent how long a coroutine should wait before starting again.\n",
    "\n",
    "    Comparison operators are implemented for use by heapq. Two-item\n",
    "    tuples unfortunately don't work because when the datetime.datetime\n",
    "    instances are equal, comparison falls to the coroutine and they don't\n",
    "    implement comparison methods, triggering an exception.\n",
    "\n",
    "    Think of this as being like asyncio.Task/curio.Task.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, wait_until, coro):\n",
    "        self.coro = coro\n",
    "        self.waiting_until = wait_until\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.waiting_until == other.waiting_until\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        return self.waiting_until < other.waiting_until\n",
    "\n",
    "\n",
    "class SleepingLoop:\n",
    "\n",
    "    \"\"\"An event loop focused on delaying execution of coroutines.\n",
    "\n",
    "    Think of this as being like asyncio.BaseEventLoop/curio.Kernel.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, *coros):\n",
    "        self._new = coros\n",
    "        self._waiting = []\n",
    "\n",
    "    def run_until_complete(self):\n",
    "        # Start all the coroutines.\n",
    "        for coro in self._new:\n",
    "            wait_for = coro.send(None)\n",
    "            heapq.heappush(self._waiting, Task(wait_for, coro))\n",
    "        # Keep running until there is no more work to do.\n",
    "        while self._waiting:\n",
    "            now = datetime.datetime.now()\n",
    "            # Get the coroutine with the soonest resumption time.\n",
    "            task = heapq.heappop(self._waiting)\n",
    "            if now < task.waiting_until:\n",
    "                # We're ahead of schedule; wait until it's time to resume.\n",
    "                delta = task.waiting_until - now\n",
    "                time.sleep(delta.total_seconds())\n",
    "                now = datetime.datetime.now()\n",
    "            try:\n",
    "                # It's time to resume the coroutine.\n",
    "                wait_until = task.coro.send(now)\n",
    "                heapq.heappush(self._waiting, Task(wait_until, task.coro))\n",
    "            except StopIteration:\n",
    "                # The coroutine is done.\n",
    "                pass\n",
    "\n",
    "\n",
    "@types.coroutine\n",
    "def sleep(seconds):  \n",
    "    \"\"\"Pause a coroutine for the specified number of seconds.\n",
    "\n",
    "    Think of this as being like asyncio.sleep()/curio.sleep().\n",
    "    \"\"\"\n",
    "    now = datetime.datetime.now()\n",
    "    wait_until = now + datetime.timedelta(seconds=seconds)\n",
    "    # Make all coroutines on the call stack pause; the need to use `yield`\n",
    "    # necessitates this be generator-based and not an async-based coroutine.\n",
    "    actual = yield wait_until\n",
    "    # Resume the execution stack, sending back how long we actually waited.\n",
    "    return actual - now\n",
    "\n",
    "\n",
    "async def countdown(label, length, *, delay=0):  \n",
    "    \"\"\"Countdown a launch for `length` seconds, waiting `delay` seconds.\n",
    "\n",
    "    This is what a user would typically write.\n",
    "    \"\"\"\n",
    "    print(label, 'waiting', delay, 'seconds before starting countdown')\n",
    "    delta = await sleep(delay)\n",
    "    print(label, 'starting after waiting', delta)\n",
    "    while length:\n",
    "        print(label, 'T-minus', length)\n",
    "        waited = await sleep(1)\n",
    "        length -= 1\n",
    "    print(label, 'lift-off!')\n",
    "\n",
    "\n",
    "def main():  \n",
    "    \"\"\"Start the event loop, counting down 3 separate launches.\n",
    "\n",
    "    This is what a user would typically write.\n",
    "    \"\"\"\n",
    "    loop = SleepingLoop(countdown('A', 5), countdown('B', 3, delay=2),\n",
    "                        countdown('C', 4, delay=1))\n",
    "    start = datetime.datetime.now()\n",
    "    loop.run_until_complete()\n",
    "    print('Total elapsed time is', datetime.datetime.now() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Implementing your own awaitable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "import types\n",
    "import datetime\n",
    "\n",
    "@types.coroutine\n",
    "def sleep(seconds):  \n",
    "    \"\"\" One way to create an awaitable, adding coroutine type. \n",
    "    Sleep amount of seconds \"\"\"\n",
    "    \n",
    "    now = datetime.datetime.now()\n",
    "    wait_until = now + datetime.timedelta(seconds=seconds)\n",
    "    \n",
    "    # Yield until time has passed\n",
    "    while datetime.datetime.now() < wait_until:\n",
    "        print(\"waiting\")\n",
    "        yield\n",
    "    \n",
    "    return \"Slept \" + str(datetime.datetime.now() - now)\n",
    "\n",
    "\n",
    "async def test_sleep(name):\n",
    "    \"\"\" await sleep method \"\"\"\n",
    "    return await sleep(0.002)\n",
    "\n",
    "    \n",
    "def test(name):\n",
    "    \"\"\" A simple generator can be made a coroutine by the create_task function \"\"\"\n",
    "    for i in range(3):\n",
    "        print(str(name) + \"; i: \" + str(i))\n",
    "        yield\n",
    "\n",
    "    return name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "loop = asyncio.get_event_loop()\n",
    "task1 = loop.create_task(test_await(\"task1\"))\n",
    "task2 = loop.create_task(test(\"task2\"))\n",
    "loop.run_until_complete(asyncio.gather(task1,task2))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "pydata",
   "language": "python",
   "name": "pydata"
  },
  "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.6.0"
  },
  "nbpresent": {
   "slides": {
    "055eee60-165b-4575-a8dc-1cbe2f5a0ed7": {
     "id": "055eee60-165b-4575-a8dc-1cbe2f5a0ed7",
     "prev": "b21c8b08-dab8-4b4e-bc01-0916a817861b",
     "regions": {
      "0afc619b-15a3-4aca-8166-153e0dd22a54": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "fd679c88-2ef8-480b-8365-fed8e6480154",
        "part": "whole"
       },
       "id": "0afc619b-15a3-4aca-8166-153e0dd22a54"
      },
      "355e8ba5-0537-4fcf-b2d6-a10254daef13": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "82f66c14-78bd-496c-8e1f-d743dcce8e56",
        "part": "whole"
       },
       "id": "355e8ba5-0537-4fcf-b2d6-a10254daef13"
      },
      "8e320679-f03b-4882-bd7a-3114d8032b81": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "dd47b59c-1d1f-44be-a32b-92c137f6f652",
        "part": "whole"
       },
       "id": "8e320679-f03b-4882-bd7a-3114d8032b81"
      },
      "d276e97a-fa3a-488d-a4ab-726f0df9424e": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "2c7efeb1-340e-432b-902d-9d6c668e2891",
        "part": "whole"
       },
       "id": "d276e97a-fa3a-488d-a4ab-726f0df9424e"
      }
     }
    },
    "404cc914-3e0f-4e30-93e2-11abff6438ac": {
     "id": "404cc914-3e0f-4e30-93e2-11abff6438ac",
     "prev": "52b0376a-bee2-4720-b4d6-be68c9ac424c",
     "regions": {
      "d8ba7cc8-280b-424f-a643-37991e0c78d3": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "4ffb6b8e-0ff5-449c-9b07-2711e94c3bbf",
        "part": "whole"
       },
       "id": "d8ba7cc8-280b-424f-a643-37991e0c78d3"
      }
     }
    },
    "52b0376a-bee2-4720-b4d6-be68c9ac424c": {
     "id": "52b0376a-bee2-4720-b4d6-be68c9ac424c",
     "layout": "grid",
     "prev": null,
     "regions": {
      "27e3b8be-0198-48e9-9832-7ace34515c6c": {
       "attrs": {
        "height": 0.3333333333333333,
        "pad": 0.01,
        "width": 0.3333333333333333,
        "x": 0.5833333333333334,
        "y": 0.3333333333333333
       },
       "content": {
        "cell": "4ffb6b8e-0ff5-449c-9b07-2711e94c3bbf",
        "part": "source"
       },
       "id": "27e3b8be-0198-48e9-9832-7ace34515c6c"
      },
      "459cf186-3afa-4c0f-a7bf-ff3eb4b68b6d": {
       "attrs": {
        "height": 0.4166666666666667,
        "pad": 0.01,
        "width": 0.3333333333333333,
        "x": 0.08333333333333333,
        "y": 0.5833333333333334
       },
       "content": {
        "cell": "09dae240-d4b3-4a44-8473-3a86b82f4fb9",
        "part": "outputs"
       },
       "id": "459cf186-3afa-4c0f-a7bf-ff3eb4b68b6d"
      },
      "536211f6-9855-485e-b0c7-d951456d0717": {
       "attrs": {
        "height": 0.3333333333333333,
        "pad": 0.01,
        "width": 0.3333333333333333,
        "x": 0.08252557889068386,
        "y": 0.3333333333333333
       },
       "content": {
        "cell": "b4cae9dd-3acc-42f4-9b0d-7055782d41bb",
        "part": "source"
       },
       "id": "536211f6-9855-485e-b0c7-d951456d0717"
      },
      "a21e2fed-4c51-4f53-be49-6e258031c1b2": {
       "attrs": {
        "height": 0.4166666666666667,
        "pad": 0.01,
        "width": 0.3333333333333333,
        "x": 0.5833333333333334,
        "y": 0.5833333333333334
       },
       "content": {
        "cell": "4ffb6b8e-0ff5-449c-9b07-2711e94c3bbf",
        "part": "outputs"
       },
       "id": "a21e2fed-4c51-4f53-be49-6e258031c1b2"
      },
      "dad473b1-339d-49c1-9e8a-993273db345b": {
       "attrs": {
        "height": 0.16666666666666666,
        "pad": 0.01,
        "width": 0.8333333333333334,
        "x": 0.08333333333333333,
        "y": 0
       },
       "content": {
        "cell": "15a2c93d-7e56-433e-bca5-41641fce882b",
        "part": "source"
       },
       "id": "dad473b1-339d-49c1-9e8a-993273db345b"
      }
     }
    },
    "63813c25-d228-437f-bf7f-639d6e3c5da7": {
     "id": "63813c25-d228-437f-bf7f-639d6e3c5da7",
     "prev": "f573b26d-58f6-4509-85fc-66a7e3693c9d",
     "regions": {
      "35ca4045-cd99-49d5-ba09-70864ac7d133": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "ec35d138-7314-432e-89bd-61893bac5145",
        "part": "whole"
       },
       "id": "35ca4045-cd99-49d5-ba09-70864ac7d133"
      }
     }
    },
    "a4057fde-9a11-43b0-bd56-4feaa1dfaca3": {
     "id": "a4057fde-9a11-43b0-bd56-4feaa1dfaca3",
     "prev": "055eee60-165b-4575-a8dc-1cbe2f5a0ed7",
     "regions": {
      "1baa595a-f747-45a6-a27d-582a7a337417": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "4a2bd98b-624d-4428-8f7e-4bc01e93cac7",
        "part": "whole"
       },
       "id": "1baa595a-f747-45a6-a27d-582a7a337417"
      },
      "ffcd6f52-5283-419a-8d49-968e2ac271d9": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "2421f844-a3a6-49ef-813f-d94d1b6a529e",
        "part": "whole"
       },
       "id": "ffcd6f52-5283-419a-8d49-968e2ac271d9"
      }
     }
    },
    "b21c8b08-dab8-4b4e-bc01-0916a817861b": {
     "id": "b21c8b08-dab8-4b4e-bc01-0916a817861b",
     "prev": "404cc914-3e0f-4e30-93e2-11abff6438ac",
     "regions": {
      "885451f5-c8ac-4f09-9ac9-15aa51471b65": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "09dae240-d4b3-4a44-8473-3a86b82f4fb9",
        "part": "whole"
       },
       "id": "885451f5-c8ac-4f09-9ac9-15aa51471b65"
      }
     }
    },
    "f573b26d-58f6-4509-85fc-66a7e3693c9d": {
     "id": "f573b26d-58f6-4509-85fc-66a7e3693c9d",
     "prev": "a4057fde-9a11-43b0-bd56-4feaa1dfaca3",
     "regions": {
      "10777a1d-dadc-444b-b1cf-549aa2f9e2aa": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "6a22e939-be78-45fe-8dfe-ebc37896958c",
        "part": "whole"
       },
       "id": "10777a1d-dadc-444b-b1cf-549aa2f9e2aa"
      },
      "7c6941db-5f82-49c8-bdd9-c96e036bbd61": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "53c9835d-fa3d-416b-82fc-1dd0dc2fbb98",
        "part": "whole"
       },
       "id": "7c6941db-5f82-49c8-bdd9-c96e036bbd61"
      },
      "d93b7078-e596-4e3c-a23a-3e1487879cd4": {
       "attrs": {
        "height": 0.4,
        "width": 0.8,
        "x": 0.1,
        "y": 0.5
       },
       "content": {
        "cell": "6f54a0fd-f68e-40bc-9f01-6f0190c5c2a3",
        "part": "whole"
       },
       "id": "d93b7078-e596-4e3c-a23a-3e1487879cd4"
      }
     }
    }
   },
   "themes": {
    "default": "4d6afbe7-540b-4fc5-8649-3cacd7b9d1e5",
    "theme": {
     "20234a90-f10f-46aa-9aa2-06d8cbaec54b": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "20234a90-f10f-46aa-9aa2-06d8cbaec54b",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         247,
         243,
         222
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         51,
         51,
         51
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         139,
         116,
         61
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         51,
         51,
         51
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "32cb50b8-8d1e-46af-b0fd-46d6f63be529": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "32cb50b8-8d1e-46af-b0fd-46d6f63be529",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         253,
         246,
         227
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         88,
         110,
         117
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         38,
         139,
         210
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         101,
         123,
         131
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "38c924d2-86f0-4502-8f62-fc169084d433": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "38c924d2-86f0-4502-8f62-fc169084d433",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         256,
         256,
         256
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         66,
         175,
         250
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         256,
         256,
         256
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 5.25
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 4
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3.5
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       },
       "p": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Source Sans Pro",
       "font-size": 6
      }
     },
     "4405cc19-2fa1-4edd-a53b-43934d5b368b": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "4405cc19-2fa1-4edd-a53b-43934d5b368b",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         256,
         256,
         256
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         0,
         0,
         0
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         0,
         0,
         139
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         0,
         0,
         0
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "News Cycle",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "News Cycle",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "News Cycle",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "News Cycle",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "News Cycle"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "News Cycle"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "News Cycle"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "4d6afbe7-540b-4fc5-8649-3cacd7b9d1e5": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "4d6afbe7-540b-4fc5-8649-3cacd7b9d1e5",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         253,
         246,
         227
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         88,
         110,
         117
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         38,
         139,
         210
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         101,
         123,
         131
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "4f69ba16-f8ae-4f92-ad55-2456b0b1e47e": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "4f69ba16-f8ae-4f92-ad55-2456b0b1e47e",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         17,
         17,
         17
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         238,
         238
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         231,
         173,
         82
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         238,
         238,
         238
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Montserrat",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Montserrat",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Montserrat",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Montserrat",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Montserrat"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Montserrat"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Montserrat"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Open Sans",
        "font-size": 4
       },
       "p": {
        "color": "mainColor",
        "font-family": "Open Sans",
        "font-size": 4
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Open Sans",
       "font-size": 4
      }
     },
     "591a7109-54d6-4db3-ad77-fd06344bb2fa": {
      "id": "591a7109-54d6-4db3-ad77-fd06344bb2fa",
      "palette": {
       "19cc588f-0593-49c9-9f4b-e4d7cc113b1c": {
        "id": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "rgb": [
         252,
         252,
         252
        ]
       },
       "31af15d2-7e15-44c5-ab5e-e04b16a89eff": {
        "id": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "rgb": [
         68,
         68,
         68
        ]
       },
       "50f92c45-a630-455b-aec3-788680ec7410": {
        "id": "50f92c45-a630-455b-aec3-788680ec7410",
        "rgb": [
         155,
         177,
         192
        ]
       },
       "c5cc3653-2ee1-402a-aba2-7caae1da4f6c": {
        "id": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "rgb": [
         43,
         126,
         184
        ]
       },
       "efa7f048-9acb-414c-8b04-a26811511a21": {
        "id": "efa7f048-9acb-414c-8b04-a26811511a21",
        "rgb": [
         25.118061674008803,
         73.60176211453744,
         107.4819383259912
        ]
       }
      },
      "rules": {
       "blockquote": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410"
       },
       "code": {
        "font-family": "Anonymous Pro"
       },
       "h1": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 8
       },
       "h2": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 6
       },
       "h3": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-family": "Lato",
        "font-size": 5.5
       },
       "h4": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 5
       },
       "h5": {
        "font-family": "Lato"
       },
       "h6": {
        "font-family": "Lato"
       },
       "h7": {
        "font-family": "Lato"
       },
       "pre": {
        "font-family": "Anonymous Pro",
        "font-size": 4
       }
      },
      "text-base": {
       "font-family": "Merriweather",
       "font-size": 4
      }
     },
     "65bfe04c-3268-43e0-8eb2-826b873a9421": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "65bfe04c-3268-43e0-8eb2-826b873a9421",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         247,
         251,
         252
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         51,
         51,
         51
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         59,
         117,
         158
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         51,
         51,
         51
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Quicksand",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Quicksand",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Quicksand",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Quicksand",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Quicksand"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Quicksand"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Quicksand"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Open Sans",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Open Sans",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Open Sans",
       "font-size": 5
      }
     },
     "7193039e-33df-48a9-b60b-c96cb0ab94cd": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "7193039e-33df-48a9-b60b-c96cb0ab94cd",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         238,
         238
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         170,
         34,
         51
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         238,
         238,
         238
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Ubuntu",
       "font-size": 5
      }
     },
     "860d9e1d-b00e-48fe-bc8c-0dc45be1f347": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "860d9e1d-b00e-48fe-bc8c-0dc45be1f347",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         43,
         43,
         43
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         238,
         238
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         19,
         218,
         236
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         238,
         238,
         238
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "92f27e02-8a54-4ee2-9658-93732476152d": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "92f27e02-8a54-4ee2-9658-93732476152d",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         0,
         43,
         54
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         232,
         213
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         38,
         139,
         210
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         147,
         161,
         161
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "9d82a808-cad4-4ce5-b5bf-398e28da359f": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "9d82a808-cad4-4ce5-b5bf-398e28da359f",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         238,
         238
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         170,
         34,
         51
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         238,
         238,
         238
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Ubuntu",
       "font-size": 5
      }
     },
     "ae991b9c-acd2-4815-bb3b-42aa4844dc53": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "ae991b9c-acd2-4815-bb3b-42aa4844dc53",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         256,
         256,
         256
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         66,
         175,
         250
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         256,
         256,
         256
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 5.25
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 4
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3.5
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       },
       "p": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Source Sans Pro",
       "font-size": 6
      }
     },
     "b30814d5-6ce1-4852-80f8-c26d1dca3a59": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "b30814d5-6ce1-4852-80f8-c26d1dca3a59",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         253,
         246,
         227
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         88,
         110,
         117
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         38,
         139,
         210
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         101,
         123,
         131
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "baaa043c-1fe7-46cb-b02b-2ed3e3dd8c67": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "baaa043c-1fe7-46cb-b02b-2ed3e3dd8c67",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         238,
         238,
         238
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         170,
         34,
         51
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         238,
         238,
         238
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Ubuntu",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Ubuntu"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Ubuntu",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Ubuntu",
       "font-size": 5
      }
     },
     "bae5e3ff-9bf9-4e63-b8c0-a839e9244161": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "bae5e3ff-9bf9-4e63-b8c0-a839e9244161",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         256,
         256,
         256
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         34,
         34,
         34
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         42,
         118,
         221
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         34,
         34,
         34
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 5.25
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 4
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3.5
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Source Sans Pro",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Source Sans Pro"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       },
       "p": {
        "color": "mainColor",
        "font-family": "Source Sans Pro",
        "font-size": 6
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Source Sans Pro",
       "font-size": 6
      }
     },
     "cc08ae87-2829-4539-b133-c60a48cd9edf": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "cc08ae87-2829-4539-b133-c60a48cd9edf",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         240,
         241,
         235
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         56,
         61,
         61
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         81,
         72,
         61
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         0,
         0,
         0
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "EB Garamond",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "EB Garamond",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "EB Garamond",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "EB Garamond",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "EB Garamond"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "EB Garamond"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "EB Garamond"
       },
       "li": {
        "color": "mainColor",
        "font-family": "EB Garamond",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "EB Garamond",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "EB Garamond",
       "font-size": 5
      }
     },
     "d000cc97-3978-44c6-90dc-06c97e3153f0": {
      "id": "d000cc97-3978-44c6-90dc-06c97e3153f0",
      "palette": {
       "19cc588f-0593-49c9-9f4b-e4d7cc113b1c": {
        "id": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "rgb": [
         252,
         252,
         252
        ]
       },
       "31af15d2-7e15-44c5-ab5e-e04b16a89eff": {
        "id": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "rgb": [
         68,
         68,
         68
        ]
       },
       "50f92c45-a630-455b-aec3-788680ec7410": {
        "id": "50f92c45-a630-455b-aec3-788680ec7410",
        "rgb": [
         155,
         177,
         192
        ]
       },
       "c5cc3653-2ee1-402a-aba2-7caae1da4f6c": {
        "id": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "rgb": [
         43,
         126,
         184
        ]
       },
       "efa7f048-9acb-414c-8b04-a26811511a21": {
        "id": "efa7f048-9acb-414c-8b04-a26811511a21",
        "rgb": [
         25.118061674008803,
         73.60176211453744,
         107.4819383259912
        ]
       }
      },
      "rules": {
       "blockquote": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410"
       },
       "code": {
        "font-family": "Anonymous Pro"
       },
       "h1": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 8
       },
       "h2": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 6
       },
       "h3": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-family": "Lato",
        "font-size": 5.5
       },
       "h4": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 5
       },
       "h5": {
        "font-family": "Lato"
       },
       "h6": {
        "font-family": "Lato"
       },
       "h7": {
        "font-family": "Lato"
       },
       "pre": {
        "font-family": "Anonymous Pro",
        "font-size": 4
       }
      },
      "text-base": {
       "font-family": "Merriweather",
       "font-size": 4
      }
     },
     "e2748042-0571-41e9-84da-25f06b395501": {
      "backgrounds": {
       "backgroundColor": {
        "background-color": "backgroundColor",
        "id": "backgroundColor"
       }
      },
      "id": "e2748042-0571-41e9-84da-25f06b395501",
      "palette": {
       "backgroundColor": {
        "id": "backgroundColor",
        "rgb": [
         247,
         243,
         222
        ]
       },
       "headingColor": {
        "id": "headingColor",
        "rgb": [
         51,
         51,
         51
        ]
       },
       "linkColor": {
        "id": "linkColor",
        "rgb": [
         139,
         116,
         61
        ]
       },
       "mainColor": {
        "id": "mainColor",
        "rgb": [
         51,
         51,
         51
        ]
       }
      },
      "rules": {
       "a": {
        "color": "linkColor"
       },
       "h1": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 7
       },
       "h2": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 5
       },
       "h3": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3.75
       },
       "h4": {
        "color": "headingColor",
        "font-family": "Oswald",
        "font-size": 3
       },
       "h5": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h6": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "h7": {
        "color": "headingColor",
        "font-family": "Oswald"
       },
       "li": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       },
       "p": {
        "color": "mainColor",
        "font-family": "Lato",
        "font-size": 5
       }
      },
      "text-base": {
       "color": "mainColor",
       "font-family": "Lato",
       "font-size": 5
      }
     },
     "ea4ce857-aaad-4718-a159-718a1373bc44": {
      "backgrounds": {
       "dc7afa04-bf90-40b1-82a5-726e3cff5267": {
        "background-color": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "id": "dc7afa04-bf90-40b1-82a5-726e3cff5267"
       }
      },
      "id": "ea4ce857-aaad-4718-a159-718a1373bc44",
      "palette": {
       "19cc588f-0593-49c9-9f4b-e4d7cc113b1c": {
        "id": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "rgb": [
         252,
         252,
         252
        ]
       },
       "31af15d2-7e15-44c5-ab5e-e04b16a89eff": {
        "id": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "rgb": [
         68,
         68,
         68
        ]
       },
       "50f92c45-a630-455b-aec3-788680ec7410": {
        "id": "50f92c45-a630-455b-aec3-788680ec7410",
        "rgb": [
         197,
         226,
         245
        ]
       },
       "c5cc3653-2ee1-402a-aba2-7caae1da4f6c": {
        "id": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "rgb": [
         43,
         126,
         184
        ]
       },
       "efa7f048-9acb-414c-8b04-a26811511a21": {
        "id": "efa7f048-9acb-414c-8b04-a26811511a21",
        "rgb": [
         25.118061674008803,
         73.60176211453744,
         107.4819383259912
        ]
       }
      },
      "rules": {
       "a": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c"
       },
       "blockquote": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-size": 3
       },
       "code": {
        "font-family": "Anonymous Pro"
       },
       "h1": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "font-family": "Merriweather",
        "font-size": 8
       },
       "h2": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "font-family": "Merriweather",
        "font-size": 6
       },
       "h3": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-family": "Lato",
        "font-size": 5.5
       },
       "h4": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 5
       },
       "h5": {
        "font-family": "Lato"
       },
       "h6": {
        "font-family": "Lato"
       },
       "h7": {
        "font-family": "Lato"
       },
       "li": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-size": 3.25
       },
       "pre": {
        "font-family": "Anonymous Pro",
        "font-size": 4
       }
      },
      "text-base": {
       "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
       "font-family": "Lato",
       "font-size": 4
      }
     },
     "ebafa9d8-438c-493e-a023-4b2291072091": {
      "backgrounds": {
       "dc7afa04-bf90-40b1-82a5-726e3cff5267": {
        "background-color": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "id": "dc7afa04-bf90-40b1-82a5-726e3cff5267"
       }
      },
      "id": "ebafa9d8-438c-493e-a023-4b2291072091",
      "palette": {
       "19cc588f-0593-49c9-9f4b-e4d7cc113b1c": {
        "id": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "rgb": [
         252,
         252,
         252
        ]
       },
       "31af15d2-7e15-44c5-ab5e-e04b16a89eff": {
        "id": "31af15d2-7e15-44c5-ab5e-e04b16a89eff",
        "rgb": [
         68,
         68,
         68
        ]
       },
       "50f92c45-a630-455b-aec3-788680ec7410": {
        "id": "50f92c45-a630-455b-aec3-788680ec7410",
        "rgb": [
         197,
         226,
         245
        ]
       },
       "c5cc3653-2ee1-402a-aba2-7caae1da4f6c": {
        "id": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "rgb": [
         43,
         126,
         184
        ]
       },
       "efa7f048-9acb-414c-8b04-a26811511a21": {
        "id": "efa7f048-9acb-414c-8b04-a26811511a21",
        "rgb": [
         25.118061674008803,
         73.60176211453744,
         107.4819383259912
        ]
       }
      },
      "rules": {
       "a": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c"
       },
       "blockquote": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-size": 3
       },
       "code": {
        "font-family": "Anonymous Pro"
       },
       "h1": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "font-family": "Merriweather",
        "font-size": 8
       },
       "h2": {
        "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
        "font-family": "Merriweather",
        "font-size": 6
       },
       "h3": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-family": "Lato",
        "font-size": 5.5
       },
       "h4": {
        "color": "c5cc3653-2ee1-402a-aba2-7caae1da4f6c",
        "font-family": "Lato",
        "font-size": 5
       },
       "h5": {
        "font-family": "Lato"
       },
       "h6": {
        "font-family": "Lato"
       },
       "h7": {
        "font-family": "Lato"
       },
       "li": {
        "color": "50f92c45-a630-455b-aec3-788680ec7410",
        "font-size": 3.25
       },
       "pre": {
        "font-family": "Anonymous Pro",
        "font-size": 4
       }
      },
      "text-base": {
       "color": "19cc588f-0593-49c9-9f4b-e4d7cc113b1c",
       "font-family": "Lato",
       "font-size": 4
      }
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}