{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Let's mock things!\n",
    "Below you can see `get_wiki_article` function which is a very simple implementation for fetching an article from wikipedia. Your task is to mock it's implementation such that it's going to always return `'Python is cool!'`. However, note that you should be able to check which argument is given to `urlopen` when `get_wiki_article` is called.\n",
    "\n",
    "**Note**: `get_content_of_url` uses [`urrlib`](https://docs.python.org/3/library/urllib.html#module-urllib), which is part of the Standard Library, for creating a HTTP request. Usually it's preferable to use [`requests`](http://docs.python-requests.org/en/master/) library (not part of the Standard Library) for such operations. Actually, `requests` uses `urllib` under the hood so it's good to know what's happening when you start using `requests` - or maybe you have already used it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "from urllib.request import urlopen\n",
    "\n",
    "\n",
    "def get_wiki_article(name):\n",
    "    url = f\"https://en.wikipedia.org/wiki/{name}\"\n",
    "    response = urlopen(url)\n",
    "    content = str(response.read())\n",
    "    return content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your implementation here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's verify it works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "article = \"Python_(programming_language)\"\n",
    "res = get_wiki_article(article)\n",
    "assert \"Guido van Rossum\" not in res, \"Guido is still there!\"\n",
    "assert res == \"Python is cool!\"\n",
    "urlopen.assert_called_with(\n",
    "    \"https://en.wikipedia.org/wiki/Python_(programming_language)\"\n",
    ")\n",
    "\n",
    "print(\"All good!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. The power of `collections` module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Creating a namedtuple\n",
    "Create a namedtuple `Car` which has fields `price`, `mileage`, and `brand`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your implemenation here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "car1 = Car(25000, 2000, \"BMW\")\n",
    "assert car1.price == 25000\n",
    "assert car1.mileage == 2000\n",
    "assert car1.brand == \"BMW\"\n",
    "assert isinstance(car1, tuple)\n",
    "\n",
    "# Note that indexing works also!\n",
    "# This means that if you change a tuple into a namedtuple,\n",
    "# the change will be backwards compatible.\n",
    "assert car1[2] == \"BMW\"\n",
    "\n",
    "print(\"All good!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The power of namedtuples is their simplicity. If `Car` would have been implemented as a class, the implementation would have been notably longer. However, if you would need to be able to e.g. change the `mileage` or `price` during the lifetime of a `Car` instance, consider using `class` because `tuples` are immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 dict of dicts\n",
    "Implement a `name_mapping` function which takes a collection of names as argument. \n",
    "\n",
    "#### The specification for `name_mapping`\n",
    "* you can assume that all the elements in the names collection are strings\n",
    "* if the provided names collection is empty, returns an empty dict\n",
    "* returns a dictionary of dictionaries\n",
    "    * outer dictionary should contain keys `vowel` and `consonant`\n",
    "    * `vowel` and `consonant` keys should have dictionaries of names (keys) and their occurences (values) as values\n",
    "    * names belong to either `vowel` or `consonant` based on their first letter\n",
    "    * vowels are defined by the `VOWELS` constant\n",
    "    * if there are only names starting with a vowel, `consonant` key should not be present in the return value (same applies vice versa)\n",
    "* see the tests below for complete examples \n",
    "\n",
    "Tip: `defaultdict` and `Counter` may be helpful here :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "VOWELS = (\"a\", \"e\", \"i\", \"o\", \"u\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_mapping(names):\n",
    "    # Your implementation here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's verify that it works correctly!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "editable": false
   },
   "outputs": [],
   "source": [
    "names = (\"Alice\", \"John\", \"Lisa\", \"John\", \"Eric\", \"Waldo\", \"annie\", \"Alice\", \"John\")\n",
    "expected = {\n",
    "    \"consonant\": {\"John\": 3, \"Waldo\": 1, \"Lisa\": 1},\n",
    "    \"vowel\": {\"Alice\": 2, \"annie\": 1, \"Eric\": 1},\n",
    "}\n",
    "assert name_mapping(names) == expected\n",
    "print(\"First ok!\")\n",
    "\n",
    "only_consonants = (\"John\", \"Doe\", \"Doe\")\n",
    "expected2 = {\"consonant\": {\"John\": 1, \"Doe\": 2}}\n",
    "assert name_mapping(only_consonants) == expected2\n",
    "print(\"Second ok!\")\n",
    "\n",
    "assert name_mapping([]) == {}\n",
    "\n",
    "print(\"All ok!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}