Lesson_10_object_oriented_programming_sklearn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# https://github.com/laike9m/pdir2/wiki/User-Configuration\n",
    "!export PDIR2_CONFIG_FILE=\"~/.pdir2config\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting /home/enrico/.pdir2config\n"
     ]
    }
   ],
   "source": [
    "%%file ~/.pdir2config\n",
    "[global]\n",
    "category-color = magenta\n",
    "attribute-color = bright blue\n",
    "comma-color = bright blue\n",
    "doc-color = bright black\n",
    "#uniform-color = bright black"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Object Oriented Programming in Python\n",
    "\n",
    "How to develop libraries and program with human API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## code categorization\n",
    "\n",
    "#### prompt\n",
    "\n",
    "In a prompt one writes commands, they executes and they are forgotten.\n",
    "This is the most common case for bash, but can be done in python as well once one is sufficiently well versed in it using smart shells like **IPython**\n",
    "\n",
    "#### scripts\n",
    "\n",
    "A script can be seen as a way of repeating a series of commands.\n",
    "It has a very well defined scope and does not need configurations, option managements, and so on.\n",
    "They are mostly run just once to perform a specific job and that's it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### libraries\n",
    "\n",
    "A library is an organized collection of functions, routines and objects that are designed to be used by someone else than the original writer.\n",
    "This is where good programming practice start to matter seriously.\n",
    "Library need an API (Application Programming Interface) that defines what and how is possible to do with the library.\n",
    "\n",
    "Library design is one of the main reasons for object oriented programming: it allows to design consistent and well structured interfaces that helps the user obtaining what they wants and guide them down the right path avoiding bad practices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### programs\n",
    "\n",
    "A program is a higher level interaction: the user does not need to write code, aside some configuration files in case.\n",
    "It performs a specific goal, and might be run very often or even continuously by the user.\n",
    "\n",
    "they are often classified based on their interface (even if this is often just different possibilities of interacting with the same underlying commands):\n",
    "* **GUI** - graphical user interface\n",
    "* **CLI** - command line interface\n",
    "* **TUI** - text-based user interface\n",
    "* **WUI** - web-based user interface (not a real term)\n",
    "\n",
    "there are more exotic ones, such are Voice User Interface (Siri), Tangible User Interface (joysticks and buttons) and so on, but they go out of the scope of this discussion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### frameworks\n",
    "\n",
    "a framework is basically a program (or a set of libraries that can be compiled as such) that can be configured by writing code, typically in the form of classes.\n",
    "\n",
    "Basically they are the opposite of a library.\n",
    "Your program call the library, while a framework calls the code you wrote.\n",
    "\n",
    "A very well known framework in python is Django, a web content management systems, where the user need to write the code for database connection and display, and runs calling the user code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Objects anatomy\n",
    "\n",
    "before discussing how to use objects to write libraries and APIs, we have to discuss what an object is and how it does work internally.\n",
    "\n",
    "This is contrary to how we usually approach topics, but the fact is that in python one does not really needs to write objects if they are not trying to write a nice library, and to use them effectively to do so one needs to have a basic understaing on what is possible with them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Objects are usually used to represent two things:\n",
    "\n",
    "#### Ontologies\n",
    "Where the important information is given by the type of the object (for example, exceptions)\n",
    "\n",
    "#### Interfaces\n",
    "the object represent an interface for the user to interact with *something*, and it doesn't really matter what the object **is**, but only only how the object **respond** to messages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In Python, the concept of OOP follows some basic principles:\n",
    "* **Inheritance**: Creating a new class from an older one, reusing and extending its methods and attributes\n",
    "* **Encapsulation**: Hiding the internal machinery of a class from other objects: one does not need to know **how** a class does what it does, but only how to talk with it (its API, the methods that it exposes)\n",
    "* **Polymorphism**: using common operation in different ways for different data input."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "OOP in python is quite different from OOP in languages like C++ or Java.\n",
    "\n",
    "On the surface they look similar, and all the traditional OOP patterns and construct can be applied in Python.\n",
    "\n",
    "Once you get confident with the python approach to OOP it will become clear that they are radically different about what is the relationship between classes and instances, and how that affect what is the best approach to solve problems.\n",
    "\n",
    "To make it more explicit:\n",
    "* **traditional OOP** is more concerned about **ontologies**, with interface management as a side effect.\n",
    "* **Python's OOP** is more concerned with **interfaces**, with ontologies as a side effect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### sidenote: pdir2\n",
    "\n",
    "For this lesson we will use a library called **pdir**, that replace the traditional `dir` function with one that allows more control on what gets shown.\n",
    "\n",
    "This will allow us to discuss in more detail what is going on under the hood of an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import pdir as dir"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### sidenote: docstring\n",
    "\n",
    "For space constraint, I will skip writing docstring for all the classes, methods and functions that we will discuss in this lesson.\n",
    "\n",
    "This is of course completely against good practices, but it was necessary to keep the discussion short.\n",
    "\n",
    "Always write docstrings in real code!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creating a new class\n",
    "\n",
    "When we want to do object oriented programming, we usually start by creating a new class.\n",
    "\n",
    "This is done using the `class` reverved keyword, in a similar fashion to how we can define a function using `def`.\n",
    "\n",
    "```python\n",
    "class MyclassName:\n",
    "    <classbody>\n",
    "```\n",
    "\n",
    "Once we have our class, we can **instantiate** this class in a specific object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In their simplest interpretation, **classes** represent the platonic idea of how an object should behave, while **instances** are the actual objects that we can interact with.\n",
    "\n",
    "For example, a class could be the concept of `Dog`, describing how a dog would move, bark and so on.\n",
    "\n",
    "Then we can instantiate this class in a specific dog, for example `spotty`, by calling the name of the class as if it was a function.\n",
    "\n",
    "```python\n",
    "spotty = Dog()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "the minimal class is one that does nothing and have nothing to show for it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Empty:\n",
    "    \"\"\"this class does not do anything.\n",
    "    \n",
    "    it's just a stub for explainations, and this is its docstring\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "some_object = Empty()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Once we instantiate, we can determine that this object belong to that class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Empty"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(some_object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(some_object, Empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Empty in module __main__ object:\n",
      "\n",
      "class Empty(builtins.object)\n",
      " |  this class does not do anything.\n",
      " |  \n",
      " |  it's just a stub for explainations, and this is its docstring\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(some_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## object attributes\n",
    "\n",
    "That was a quite boring class and object, but it's our starting point.\n",
    "\n",
    "Once we have an instance of an object, we can store and retrieve **attributes** in that object.\n",
    "\n",
    "These represents the data that are stored inside the object.\n",
    "Having them inside the object allows us to keep them all together and give them some form of identity.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "by default, an object does not have any attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(some_object).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "or better, there are already a lot, but they are the underlying machinery that make class work, and we will see what (some) of these mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mspecial attribute:\u001b[0m\n",
       "    \u001b[0;34m__class__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__dict__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__doc__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__module__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__weakref__\u001b[0m\n",
       "\u001b[0;35mabstract class:\u001b[0m\n",
       "    \u001b[0;34m__subclasshook__\u001b[0m\n",
       "\u001b[0;35mobject customization:\u001b[0m\n",
       "    \u001b[0;34m__format__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__hash__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__init__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__new__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__repr__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__sizeof__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__str__\u001b[0m\n",
       "\u001b[0;35mrich comparison:\u001b[0m\n",
       "    \u001b[0;34m__eq__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__ge__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__gt__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__le__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__lt__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__ne__\u001b[0m\n",
       "\u001b[0;35mattribute access:\u001b[0m\n",
       "    \u001b[0;34m__delattr__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__dir__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__getattribute__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__setattr__\u001b[0m\n",
       "\u001b[0;35mclass customization:\u001b[0m\n",
       "    \u001b[0;34m__init_subclass__\u001b[0m\n",
       "\u001b[0;35mpickle:\u001b[0m\n",
       "    \u001b[0;34m__reduce__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__reduce_ex__\u001b[0m"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(some_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### setting and retrieving attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Empty:\n",
    "    pass\n",
    "\n",
    "namespace_0 = Empty()\n",
    "namespace_1 = Empty()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.a = 2\n",
    "namespace_0.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Empty' object has no attribute 'a'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-134-e8dada81b736>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnamespace_1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Empty' object has no attribute 'a'"
     ]
    }
   ],
   "source": [
    "namespace_1.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mproperty:\u001b[0m\n",
       "    \u001b[0;34ma\u001b[0m"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(namespace_0).public.properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "the public attributes are stored internally as a dictionary, that we can poke and probe.\n",
    "\n",
    "it is literally a normal dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 2}"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_1.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### hasattr, getattr, setattr, delattr\n",
    "\n",
    "attribute management is normally done using the form `object.attribute`, but can be also done programmatically using 4 different functions.\n",
    "They all treat the attribute name as a string\n",
    "\n",
    "* `getattr`: retrieve the chosen attribute (given as a string)\n",
    "* `setattr`: set the given attribute\n",
    "* `delattr`: delete an attribute\n",
    "* `hasattr`: check if the object has the given attribute (employ `getattr`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(namespace_0, 'a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(namespace_1, 'a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setattr(namespace_1, 'a', 4)\n",
    "getattr(namespace_1, 'a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`getattr` also support a `default` parameter, that is returned if the object does not have the given attribute (instead of raising an `AttributeError`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'default_value'"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(namespace_1, 'b', 'default_value')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### the `__class__` attribute\n",
    "\n",
    "one of the special attributes of an instance is the `__class__` attribute: this stores a reference to the class that the instance belongs to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Empty"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## class attributes and *MRO*\n",
    "\n",
    "At this point the *class* has been pretty much useless, all the work has been done by the *instances*\n",
    "\n",
    "The advantage of a class is the ability to store **shared attributes** across all instances.\n",
    "\n",
    "This ensure that all the instances have access to the same information, and this basically is what establish their behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Something:\n",
    "    b = 3\n",
    "\n",
    "namespace_0 = Something()\n",
    "namespace_1 = Something()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "if we check the object `__dict__`, it is empty, but we can access the attribute anyway!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "How does the attribute `b` gets shown to the instance?\n",
    "\n",
    "This is done using the so-called Method Resolution Order (MRO).\n",
    "\n",
    "When we ask for an attribute to an instance the following happen\n",
    "1. if it does have it, it returns it\n",
    "2. if it does not, it goes and ask to its class if it does have it.\n",
    "3. if the class has it (or can obtain it), that is what gets returned\n",
    "4. if the class does not have it, it tries dynamic generation (we'll see that later)\n",
    "5. if that fails, it raises `AttributeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[__main__.Something, object]"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Something.mro()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This means that we can set an attribute on an *instance*, and this will shadow the same attribute derived from the *class*.\n",
    "\n",
    "We will see this behavior again when we will discuss class *inheritance*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mproperty:\u001b[0m\n",
       "    \u001b[0;34mb\u001b[0m"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(Something).public"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.b = 5\n",
    "namespace_0.b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_1.b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del namespace_0.b\n",
    "namespace_0.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A useful information that you can store in your class is it's **version**.\n",
    "\n",
    "A canonical way to represent changes in your code is to use [semantic versioning](www.semver.org).\n",
    "\n",
    "One can use the same process to check for the class version of an item.\n",
    "For libraries that create and destroy objects inside a single process it might not be relevant, but if you want to store objects long term, keeping track of the version of the class might be useful!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "the common use is to use a `__version__` attribute of the class, and fill it with a tuple with the `(major, minor, fix)` values, where all of those numbers are stored as integers\n",
    "\n",
    "```python\n",
    "class MyClass:\n",
    "    __version__ = (0, 1, 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## methods\n",
    "\n",
    "Methods are functions that are defined inside the class body.\n",
    "\n",
    "They are (almost) the same as any other attribute.\n",
    "\n",
    "the common trait of all the methods is that the first argument, usually called `self`, is used to refer to the instance calling the method, allowing to access its attribute from inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Something:\n",
    "    a = 2\n",
    "    def multiply(self, b=2):\n",
    "        return self.a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Something.multiply of <__main__.Something object at 0x7fbf46e70ba8>>"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0 = Something()\n",
    "\n",
    "namespace_0.multiply"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "note that I don't need to specify the instance as the parameter `self`.\n",
    "\n",
    "This is because there is a bit of magic when method are recalled as attributes: they are **bound** to the instance.\n",
    "\n",
    "This means that we do not need to specify the instance, but it will get automatically provided to the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace_0.multiply(b=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If we want we can access the **unbound** method directly to the class: in this case we have to explicitely provide the instance on which the function is supposed to apply."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Something.multiply(namespace_0, b=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Note**: we are not bound to apply this function to an instance of the same class, but only to instances that behave similarly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Empty:\n",
    "    a = 3\n",
    "\n",
    "weird = Empty()\n",
    "\n",
    "Something.multiply(weird, b=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions can be added as methods to a class in any moment.\n",
    "\n",
    "This is often referred as **monkey patching**, and is a powerful yet dangerous technique.\n",
    "\n",
    "One can do it for their won script (maybe to allow a library to act on a class it is not designed for), and that is perfectly ok as long as you know what you're doing.\n",
    "\n",
    "There are libraries that works by patching other libraries to extend their capabilities: there are several that do this on *pandas* object, to extend them with new functionalities.\n",
    "\n",
    "Doing that in libraries that will be used by other libraries is not a good practice, as it can lead to undescribed behaviors by third party users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def triple_function(self):\n",
    "    return self.a*3\n",
    "\n",
    "Something.triple = triple_function\n",
    "\n",
    "namespace_0 = Something()\n",
    "namespace_0.triple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "One could technically patch a single instance with a method, but it's not usually a good useful practice.\n",
    "\n",
    "to do this we need to explicitly bound the instance to the method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from types import MethodType\n",
    "\n",
    "def external_function(self):\n",
    "    return self.a*2\n",
    "\n",
    "namespace = Something()\n",
    "namespace.func = MethodType(external_function, namespace)\n",
    "namespace.func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## init method\n",
    "\n",
    "The next step that we might take is to allow the class to \"personalize\" the instantiation process.\n",
    "\n",
    "this is done using the **magic method** `__init__`.\n",
    "\n",
    "`__init__` gets automatically called after the instance is created, and is tipically used to assign values to some instance attributes based on some arguments given to the function creating it.\n",
    "\n",
    "aside of this automatica call, it is a completely normal method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Something:\n",
    "    def __init__(self, a):\n",
    "        self.a = a\n",
    "\n",
    "namespace = Something(a=3)\n",
    "namespace.a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In the recent versions of python (3.7 natively, 3.6 with backporting), there is a simplified version to define instantiation methods, using the **dataclass** decorator.\n",
    "\n",
    "It takes variable annotations and automatically generates the corresponding `__init__` method, dramatically reducing boilerplat code\n",
    "\n",
    "this is a simplified version of a more general library, called **attrs**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120.0\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class InventoryItem:\n",
    "    name: str\n",
    "    unit_price: float\n",
    "    quantity_on_hand: int = 0\n",
    "\n",
    "    def total_cost(self) -> float:\n",
    "        return self.unit_price * self.quantity_on_hand\n",
    "\n",
    "item = InventoryItem('hammers', 10.0, 12)\n",
    "print(item.total_cost())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "That code will generate the following constructor under the hood:\n",
    "\n",
    "```python\n",
    "def __init__(self, name: str, unit_price: float, quantity_on_hand: int=0):\n",
    "    self.name = name\n",
    "    self.unit_price = unit_price\n",
    "    self.quantity_on_hand = quantity_on_hand\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "we would have repeated each variable name 3 times without dataclasses!\n",
    "\n",
    "that's a good reduction in boilerplate!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## magic methods\n",
    "\n",
    "python relies heavily on magical operators, methods that get called when we try to perform some operation on an object.\n",
    "All these functions are characterized by the presence of the **dunder names**: `__magic_func__`\n",
    "\n",
    "the `__init__` method is one of these magic methods.\n",
    "\n",
    "Any kind of matematical operator is linked to a special method, and so are several special functions such as `len`\n",
    "\n",
    "these methods are the python equivalent of **operator overloading** and are what allows more advanced forms of **polymorphism**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "for example, the addition operator `+` is linked to the magic method `__add__`, so if we want our class to be able to perform addition, they need to implement it.\n",
    "```python\n",
    "my_object + something\n",
    "```\n",
    "becomes:\n",
    "\n",
    "```python\n",
    "my_object.__add__(something)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "@dataclass\n",
    "class Something:\n",
    "    a: int\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        return self.__class__(self.a+other)\n",
    "\n",
    "namespace_0 = Something(a=3)\n",
    "print(namespace_0.a)\n",
    "\n",
    "namespace_1 = namespace_0 + 2\n",
    "print(namespace_1.a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Note that if we write in the other order, and the other object does not know how to handle the sum, it will crash with a `TypeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'Something'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-193-6ca245b48fe2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnamespace_2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnamespace_0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'Something'"
     ]
    }
   ],
   "source": [
    "namespace_2 = 2 + namespace_0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The solution is to add a second magic method, `__radd__`, that is called if the first term does not know how to handle the given class.\n",
    "\n",
    "to signal that it does not know how to handle the sum, the first addendum should return `NotImplemented` (a singleton) instead of an actual result\n",
    "\n",
    "if the adding operation is symmetrical for the object (it doesn't have to be!) one cas avoid reimplementing the `__radd__` by simply saying:\n",
    "\n",
    "```python\n",
    "__radd__ = __add__\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@dataclass\n",
    "class Something:\n",
    "    a: int\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        if not isinstance(other, int):\n",
    "            return NotImplemented\n",
    "        return self.__class__(self.a+other)\n",
    "    \n",
    "    __radd__ = __add__\n",
    "\n",
    "namespace_0 = Something(a=3)\n",
    "namespace_2 = 2 + namespace_0\n",
    "namespace_2.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'Something' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-240-52e8ac33a07f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnamespace_2\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"a\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'Something' and 'str'"
     ]
    }
   ],
   "source": [
    "namespace_2 + \"a\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The dot operator\n",
    "\n",
    "when we try to obtain something out of an we (almost) always use the **dot** operator: `<class>.<attribute>`\n",
    "\n",
    "this is a request to the object to try and give us the object with the name we asked for.\n",
    "\n",
    "There is no actual need for that attribute to actually exist, we could even obtain them on the fly.\n",
    "\n",
    "Even when we try to obtain a method, we are asking for a function, and then we call it.\n",
    "\n",
    "This is what makes possible to create very clever API with python, but also why it's so slow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "When we execute code such as:\n",
    "\n",
    "    a = [1, 2]\n",
    "    a.append(3)\n",
    "    \n",
    "python has to do the following:\n",
    "\n",
    "* ask `a` if it does have the `append` attribute (no)\n",
    "* ask the class of `a` (the `list` class) if it does have it\n",
    "    * if it doesn't, ask the same to the superclasses\n",
    "\n",
    "once the attribute have been obtained, we try to perform the call of the function.\n",
    "Calling a function is **exactly the same** as calling the `__call__` method.\n",
    "So we have to start all over: does `append` have a `__call__` method?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This is true for all **operators** as well, for example addition (`+` operator).\n",
    "\n",
    "when we run code such as:\n",
    "\n",
    "    a = np.array([1, 2])\n",
    "    b = 1 + a\n",
    "    \n",
    "python has to go and:\n",
    "\n",
    "* ask the object `1` if it does have a `__add__` method (and its class and so on, you know the drill)\n",
    "* it does have it, but when it tries to apply it to an array it fails with `NotImplementedError`\n",
    "* python then goes the the object `a` and ask if it does have `__radd__` the right side add ()and its class and so on\n",
    "* now the array knows how to perform the sum, so it execute it and returns a result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "I can leverage this property using the **descriptors**, or the syntactic sugar `@property` decorator.\n",
    "\n",
    "A descriptor hides behing a normal attribute access the following operations:\n",
    "* how to obtain the attribute\n",
    "* how to set the attribute\n",
    "* how to delete the attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Something:\n",
    "    @property\n",
    "    def myattr(self):\n",
    "        return 1\n",
    "\n",
    "namespace = Something()\n",
    "namespace.myattr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The basic definition of a property does not include informations on how to set the attribute, so if ones tries to modify it, it crashes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-206-41b7a728e224>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmyattr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "namespace.myattr = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To allow this behavior I have to explicitely define the setting function using the decorator `@<propertyname>.setter` on a function with the same name as the initial property\n",
    "\n",
    "this allows us to also do attribute checking and modification on setting on the fly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Enrico'"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Something:\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "    \n",
    "    @name.setter\n",
    "    def name(self, value):\n",
    "        self._name = value.title()\n",
    "        \n",
    "\n",
    "namespace = Something()\n",
    "namespace.name = \"eNRICO\"\n",
    "namespace.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mdescriptor:\u001b[0m\n",
       "    \u001b[0;34mname\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30m@property with getter, setter\u001b[0m"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(namespace).own.public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### note - privates attributes part 1 of 3\n",
    "\n",
    "In python there is no such thing as a private attribute.\n",
    "The sentence that is commonly used in the community is:\n",
    "\n",
    "> we're all consenting adults\n",
    "\n",
    "But, on the other end, for some attributes is common to require for the user to not modify the directly (like the `_name` attribute in the previous cose).\n",
    "\n",
    "By the default the attributes and methods staring with a single underscore represents methods that the users of the class should not use.\n",
    "They are not guarantee to be a stable interface and one risks breaking things using them.\n",
    "\n",
    "> if you expose an attribute, expect the users to change it, plan accordingly!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### note - privates attributes part 2 of 3\n",
    "\n",
    "One wat of creating a more explicit private attribute (not really, bot more explicitely saying *\"don't use me\"*)\n",
    "is to use `getattr` and `settattr` with strings that are invalid identifiers and thus cannot be retrieved by the dot operator.\n",
    "\n",
    "This is a bit exotic and I don't suggest using it, but if you're curious there is some indication on how to do it in the notebook that underpin this slides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### note - privates attributes part 3 of 3\n",
    "\n",
    "A common mistake is to think that attributes with the name starting with double underscore (but not ending in them) are a way to make attributes private.\n",
    "\n",
    "That is a completely different feature, called **name mangling**, and is used to solve some nasty inheritance problems, not as private attributes.\n",
    "\n",
    "One might actually make a mess in the inheritance chain by using them without understanding them, so refrain unless you know what you're doing!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Properties can be used also to control the behavior of the attribute, such as the types and values that it can accept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Something:\n",
    "    @property\n",
    "    def name(self):\n",
    "        if not hasattr(self, \"_name\"):\n",
    "            raise ValueError(\"the `name` attribute has not been set\")\n",
    "        return self._name\n",
    "    \n",
    "    @name.setter\n",
    "    def name(self, value):\n",
    "        if not isinstance(value, str):\n",
    "            raise TypeError(\"name need to be a string, a value of <{}> was provided\".format(repr(value)))\n",
    "        self._name = value.title()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "the `name` attribute has not been set",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-213-36921b093d67>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnamespace\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSomething\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-212-e3b8550f5f83>\u001b[0m in \u001b[0;36mname\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"_name\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"the `name` attribute has not been set\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: the `name` attribute has not been set"
     ]
    }
   ],
   "source": [
    "namespace = Something()\n",
    "namespace.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "name need to be a string, a value of <[1, 2]> was provided",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-215-2fb97a563220>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-212-e3b8550f5f83>\u001b[0m in \u001b[0;36mname\u001b[0;34m(self, value)\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"name need to be a string, a value of <{}> was provided\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrepr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: name need to be a string, a value of <[1, 2]> was provided"
     ]
    }
   ],
   "source": [
    "namespace.name = [1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Enrico'"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namespace.name = \"eNRICO\"\n",
    "namespace.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "What happends when the dot operator fails to find the requested attribute in the instance and class?\n",
    "\n",
    "it falls back to a magic method, of course: `__getattr__`.\n",
    "\n",
    "If that is not defined, it gives up and fails, but if we implement it we can return dynamically attributes we never defined in the class or the instance!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"'b' has been requested\""
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Something:\n",
    "    def __getattr__(self, name):\n",
    "        return \"{} has been requested\".format(repr(name))\n",
    "\n",
    "namespace = Something()\n",
    "namespace.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance\n",
    "\n",
    "inheritance is a way of constructing classes on the basis of other classes.\n",
    "\n",
    "This can be used for both goals of object oriented programming:\n",
    "\n",
    "* defining an ontology (type A is also type B)\n",
    "* interface extension\n",
    "* interface validation\n",
    "\n",
    "the last one has been reduced from python 3.4+ with the introduction of the abstract base classes subclass hook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The syntax to inherit from other classes is the following:\n",
    "\n",
    "```python\n",
    "class ClassName(SuperClass_0, SuperClass_1):\n",
    "    <class_body>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ontology definition - Exceptions\n",
    "\n",
    "This is very common in Exception management: when one is writing their own library, sometimes is more convenient to define specialized exceptions that can be caught in a more focused way.\n",
    "This can be specialized versions (and should usually be) of the most common one, such as `ValueError`, `TypeError`, `IndexError`, etc...\n",
    "\n",
    "This allows the user to distinguish between exceptions that are expected (the one raised from the library) and the one that are not (other exceptions that might be caused by some other code).\n",
    "\n",
    "It might also be a way to limit the things a user has to worry about in error management, by catching and reraising possible exceptions as different ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ZeroError(ValueError): pass\n",
    "class NegativeError(ValueError): pass\n",
    "\n",
    "def myfunction(a):\n",
    "    if a<0:\n",
    "        raise NegativeError(\"the value should not be negative\")\n",
    "    if a==0:\n",
    "        raise ZeroError(\"the value should not be zero\")\n",
    "        \n",
    "    return a*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If I use a ValueError I can catch both kind of errors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    myfunction(0)\n",
    "except ValueError:\n",
    "    pass\n",
    "\n",
    "try:\n",
    "    myfunction(-1)\n",
    "except ValueError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "And I can selectively catch only the kind of error I'm interested in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    myfunction(0)\n",
    "except ZeroError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "NegativeError",
     "evalue": "the value should not be negative",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNegativeError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-380-07678d184437>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mmyfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mZeroError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-377-674f95bb9925>\u001b[0m in \u001b[0;36mmyfunction\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmyfunction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNegativeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"the value should not be negative\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mZeroError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"the value should not be zero\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNegativeError\u001b[0m: the value should not be negative"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    myfunction(-1)\n",
    "except ZeroError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### the use of multiple inheritance in the ontology\n",
    "\n",
    "A similar approach is to employ multiple inheritance to represent an error that can fit in various category.\n",
    "\n",
    "If you have a dynamical dictionary that generate results on the fly, one error might be at the same time and `IndexError` (because it is a nonsensical index) and a `ValueError` (because if you look at it as a function, the user just passed a wrong value).\n",
    "\n",
    "It makes sense for the user to be able to catch them in both ways, so one can use the **principle of least surprise** and raise an exception that can be caught both ways.\n",
    "\n",
    "From a formal point of view this is not an ontology anymore, but *practicaly beats purity*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ValueOrIndexError(ValueError, IndexError): pass\n",
    "import string\n",
    "\n",
    "class MyDict(dict):\n",
    "    def __getitem__(self, char):\n",
    "        if char not in string.ascii_letters:\n",
    "            raise ValueOrIndexError(f\"'{char}' is not a valid character!\")\n",
    "        else:\n",
    "            return ord(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = MyDict()\n",
    "temp['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "ValueOrIndexError",
     "evalue": "'2' is not a valid character!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueOrIndexError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-407-c40d2261fa0f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtemp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-399-1cfb1db28486>\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, char)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mchar\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mstring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mascii_letters\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueOrIndexError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"'{char}' is not a valid character!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mord\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchar\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueOrIndexError\u001b[0m: '2' is not a valid character!"
     ]
    }
   ],
   "source": [
    "temp['2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    temp['2']\n",
    "except ValueError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    temp['2']\n",
    "except IndexError:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Traditional inheritance - methods\n",
    "\n",
    "\n",
    "a child class can:\n",
    "* **add** - add a new method that didn't exist before, with no interaction with the other methods of the superclass aside of leveraging them\n",
    "* **override** replace entirely the old method\n",
    "* **extend** add new behavior to the method while also calling the old one to keep the old behavior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "an example, taken from Raymond Hettinger's lectures:\n",
    " ```python\n",
    "@dataclass\n",
    "class Animal:\n",
    "    name: str\n",
    "        \n",
    "    def walk(self):\n",
    "        print(f\"{self.name} is walking\")\n",
    "```\n",
    "\n",
    "es: dog add bark, snake override walk with a slithering behavior, cat extend walk with tail wiggles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### adding\n",
    "```python\n",
    "class Dog(Animal):\n",
    "    def bark(self):\n",
    "        print(f\"{self.name} is barking!\")\n",
    "```\n",
    "\n",
    "Dog adds a completely new method to the superclass Animal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### overriding\n",
    "```python\n",
    "class Snake(Animal):\n",
    "    def walk(self):\n",
    "        print(f\"{self.name} is slithering!\")\n",
    "```\n",
    "\n",
    "Snake completely override the superclass original method, and the new one have no relationship with the old one aside of the intended use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### extending\n",
    "```python\n",
    "class Cat(Animal):\n",
    "    def walk(self):\n",
    "        super().walk()\n",
    "        print(f\"{self.name} is wagging is tail!\")\n",
    "```\n",
    "\n",
    "Cat is extending the old function by adding new behavior on top of it.\n",
    "\n",
    "the `super` function is a special function that allows to reference the method implemented by the superclass instead of the current one, and is commonly used during inheritance, especially while overrriding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### interface extension\n",
    "\n",
    "A common use of inheritance is to use an class that defines more methods given some basic ones.\n",
    "\n",
    "for example, the \"collections\" module provides a \"MutableMapping\" abstract base\n",
    "class to help create various methods from a base set of methods:\n",
    "* `__getitem__`\n",
    "* `__setitem__`\n",
    "* `__delitem__`\n",
    "* `keys`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mfunction:\u001b[0m\n",
       "    \u001b[0;34mclear\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.clear() -> None.  Remove all items from D.\u001b[0m\n",
       "    \u001b[0;34mget\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\u001b[0m\n",
       "    \u001b[0;34mitems\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.items() -> a set-like object providing a view on D's items\u001b[0m\n",
       "    \u001b[0;34mkeys\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.keys() -> a set-like object providing a view on D's keys\u001b[0m\n",
       "    \u001b[0;34mpop\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.pop(k[,d]) -> v, remove specified key and return the corresponding value.\u001b[0m\n",
       "    \u001b[0;34mpopitem\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.popitem() -> (k, v), remove and return some (key, value) pair\u001b[0m\n",
       "    \u001b[0;34msetdefault\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\u001b[0m\n",
       "    \u001b[0;34mupdate\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.\u001b[0m\n",
       "    \u001b[0;34mvalues\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mD.values() -> an object providing a view on D's values\u001b[0m"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import collections\n",
    "collections.Mapping\n",
    "\n",
    "class Empty(collections.MutableMapping):\n",
    "    def __getitem__(): pass\n",
    "    def __setitem__(): pass\n",
    "    def __delitem__(): pass \n",
    "    def keys(): pass\n",
    "\n",
    "dir(Empty).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "It can also replace some of the methods of the parent class, for example a more performing one when some assumptions are valid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Interface validation\n",
    "\n",
    "in this case when can define a class checking for an interface and makes it so that all the classes following that inteface will be positive when checked for subclassing or being an instance of that interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# this is only available in python 3.4+\n",
    "import abc\n",
    "class PippoInterface(abc.ABC):\n",
    "    @classmethod\n",
    "    def __subclasshook__(cls, subclass):\n",
    "        # I define a instance or subclass as having a method called \"pippo\"\n",
    "        return hasattr(subclass, \"pippo\") and callable(getattr(subclass, \"pippo\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Myclass_1:\n",
    "    def pippo(self):\n",
    "        pass\n",
    "    \n",
    "assert issubclass(Myclass_1, PippoInterface)\n",
    "assert isinstance(Myclass_1(), PippoInterface)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Myclass_2:\n",
    "    def pluto(self):\n",
    "        pass\n",
    "    \n",
    "assert not issubclass(Myclass_2, PippoInterface)\n",
    "assert not isinstance(Myclass_2(), PippoInterface)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Myclass_3:\n",
    "    pippo = 1\n",
    "\n",
    "assert not issubclass(Myclass_3, PippoInterface)\n",
    "assert not isinstance(Myclass_3(), PippoInterface)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Composition Over Inheritance\n",
    "\n",
    "Often inheritance is used to specify some very corner case of the class.\n",
    "\n",
    "In many cases this can be replace with composition.\n",
    "Composition is a way to replace the framework approach: instead of subclassing a class to specialize it's behavior, one can set an attribute as a completely different object to configure its behavior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's consider a very simple class that print a message.\n",
    "\n",
    "This class prints to the terminal, but we might implement a subclass that replace the print with something else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:hello everybody!\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello everybody!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class BasicPrinter:\n",
    "    def printer(self, message):\n",
    "        print(message)\n",
    "        \n",
    "    def say_hello(self, name):\n",
    "        s = f\"hello {name}!\\n\"\n",
    "        self.printer(s)\n",
    "        \n",
    "class LoggingPrinter(BasicPrinter):\n",
    "    def printer(self, message):\n",
    "        import logging\n",
    "        logging.warning(message)\n",
    "        \n",
    "BasicPrinter().say_hello(\"everybody\")\n",
    "LoggingPrinter().say_hello(\"everybody\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "this approach works, and it's quite common in more structured languages, but you can see that it still feels somewhat *verbose*.\n",
    "\n",
    "If we have several behaviors, we would need a different subclass for each behaviors.\n",
    "\n",
    "If we have several kind of behaviors, we might need to write a class for each of the combination in the cartesian product of the options!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "composition present a better option, by allowing to simply replace a component to change the behavior, no subclassing needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello everybody!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "@dataclass\n",
    "class Printer:\n",
    "    printer: callable = print\n",
    "        \n",
    "    def say_hello(self, name):\n",
    "        s = f\"hello {name}!\\n\"\n",
    "        self.printer(s)\n",
    "        \n",
    "myprinter = Printer()\n",
    "myprinter.say_hello(\"everybody\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello everybody!\n",
      "hello nobody!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from io import StringIO\n",
    "s = StringIO()\n",
    "\n",
    "myprinter.printer = s.write\n",
    "myprinter.say_hello(\"everybody\")\n",
    "myprinter.say_hello(\"nobody\")\n",
    "\n",
    "print(s.getvalue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### framework logic\n",
    "\n",
    "This is a another very common pattern that can be replaced by composition.\n",
    "\n",
    "The parent class controls the behavior, the child class implement the actual methods needed for actual acting (the basic idea for the abstract classes). \n",
    "\n",
    "An animal could delegate how to sense food and how to move from one place to another, but control how the decision to move is made after the food is sensed.\n",
    "\n",
    "-----\n",
    "\n",
    "On the other end, it's a very common pattern in Python: all the magic methods are nothing more than framewok logic to perform various operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How to use objects to make a library\n",
    "\n",
    "rule number 1:\n",
    "> don't start writing the code to implement the features:\n",
    ">\n",
    "> write how the features should look like in real code and implement them!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Let's say that we want to implement a class to represent and manage some kind of object.\n",
    "\n",
    "to do this, the best starting point is to try and write the code that we would like to have with that class, and then proceed to implement it.\n",
    "\n",
    "This has two advantages:\n",
    "* it guides us on which are the most important feature first\n",
    "* it paved the road for testing in a very easy way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A simple use case - fitting using seaborn distplot\n",
    "\n",
    "the `distplot` method of seaborn allows to plot a density plot of some data and allow to plot a density estimation using either a Kernel Density Estimator or a distribution object.\n",
    "\n",
    "This object can be passed as the `fit` parameter to the function, and it expected to implement:\n",
    "* **fit** method, that takes the array of data and should return a tuple of parameters of the distribution\n",
    "* **pdf** that takes the same tuple of parameters and position on which to estimate the distribution pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import random as rn\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "\n",
    "data = rn.randn(1000)*2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fbf1eb493c8>"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(data, kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fbf1e8e8ba8>"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class NormalFit:\n",
    "    def fit(self, data):\n",
    "        return np.mean(data), np.std(data)\n",
    "    \n",
    "    def pdf(self, x, *fit_args):\n",
    "        μ, σ = fit_args\n",
    "        C_i = np.sqrt(2*np.pi*σ**2)\n",
    "        logbase =  -(x-μ)**2 / (2*σ**2) \n",
    "        return np.exp(logbase)/C_i\n",
    "    \n",
    "sns.distplot(data, fit=NormalFit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The object interface is designed to be used with scipy.stats distributions in general, so one doesn't need to write a class for **most** distributions, but it does allow to use fixed parameters, or to use bayesian priors, etc..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fbf1ea2ed68>"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XlcVfed//HX997LZd8EZBNUVNwXlKhojPuSaJpEs7dJmulMxk7SSZvpkvy6TZeZptNkmrZJJknTNE1ia9QsmqhxiRrjgpFFUUAQEZFdZN+53O/vD0hKDegFgXPhfp6PBw/g3nMObw749vC953yP0lojhBDCdZiMDiCEEGJgSfELIYSLkeIXQggXI8UvhBAuRopfCCFcjBS/EEK4GCl+IYRwMVL8QgjhYqT4hRDCxViMDtCV4OBgPWrUKKNjCCHEoJGcnFyutQ5xZFmnLP5Ro0aRlJRkdAwhhBg0lFIXHF1WhnqEEMLFSPELIYSLkeIXQggXI8UvhBAuRopfCCFcjBS/EEK4GCl+IYRwMVL8QgjhYqT4hRDCxTjllbtC9Ke/Hst3aLn750T3cxIhjCFH/EII4WKk+IUQwsVI8QshhIuR4hdCCBcjxS+EEC5Gil8IIVyMFL8QQrgYKX4hhHAxUvxCCOFi5MpdMSTl5uayc+dOsrKyqK+vZ9iwYcTHx7N06VKjowlhOCl+MaQUFBTwy1/+kk8++QSTyUR0dDR+fn7k5uby4Ycf8qtf/YqZS77Cgq/cj7unl9FxhTCEFL8YMrZv386PfvQjTCYTjz/+OHfeeSfBwcEAaK05e/Ysr732Glu3bSE79Sh3PvZjho8YZWxoIQwgY/xiSHj11Vf57ne/y+TJk9m+fTvr16//ovQBlFLExsby9NNP88D3f01TQz1//uV3uHg23cDUQhjDoeJXSq1SSmUppXKUUk928fxXlVJpHW9HlFLTHV1XiOv11ltv8eyzz3LLLbfw2muvERYWdtXlR02czjd++nt8/AP467M/pDD3zAAlFcI5XLP4lVJm4AXgZmAScJ9SatIVi50HFmqtpwG/AF7pwbpC9NrevXv5r//6L5YtW8avf/1rrFarQ+v5Bw3nwSefwcvXn02/+xnVl8v6OakQzsORI/7ZQI7WOldr3QJsBG7rvIDW+ojWurLj00RghKPrCtFbeXl5PPXUU0ydOpVnnnkGi6VnL1n5BgZxz7d/RktzE5v/8HPabK39lFQI5+JI8UcCFzt9XtDxWHe+Aezs5bpCOKSlpYUnnngCi8XCc889h7u7e6+2MzxyFLf9y/cozjvL/nf/0scphXBOjhS/6uIx3eWCSi2mvfh/0It1H1FKJSmlki5duuRALOHKXnnlFTIzM/nlL39JRETEdW1rwqx5xC28maM7t3Ah61QfJRTCeTlS/AVAVKfPRwBFVy6klJoGvArcprW+3JN1AbTWr2it47XW8SEhIY5kFy4qKyuLl19+mVtvvbXPLshacf96AoJD2f7n57C1tvTJNoVwVo4U/3FgnFJqtFLKCtwLbOu8gFIqGngXeEBrnd2TdYXoCa01v/jFL/Dx8eGpp57qs+1a3T1Y9bVHuVxSwNGdW/psu0I4o2sWv9baBjwG7AIygU1a63Sl1Hql1PqOxX4CBAEvKqVOKKWSrrZuP3wfwkXs2LGD5ORkvvOd7xAYGNin2x43fTYT4xdw6IO/UVMhw41i6FJadznkbqj4+HidlJRkdAzhZJqbm7n55psJDAxk06ZNmM3mXm3nr8fyu32u6lIJLz71z0yZu4iNf/x9b6MKMeCUUsla63hHlpUrd8WgsXHjRoqLi/ne977X69K/loCQMG5Y9hVOHt7LmTNyYZcYmmSuHmGYqx15d3b/nGjq6+t5+eWXSUhIYO7cuf2a68Y195L6yUc8//zzPP/88/36tYQwghS/GBQ2bNhAZWUl3/72t697W1prMotryK9o5FJtExqYERXAxHA/3MwmPH38mLNyLR+//yYZGRlMmiQXm4uhRYZ6hNNraGjg9ddfZ8GCBUybNu26tpVWUMXLB3N561g+h8+Vc7m+heLqJjYev8jTO8+QWVwDwJzlt+Pr68uLL77YF9+CEE5FjviF09u8eTOVlZWsX7/+2gt3Q2vNiwfO8czuLLytFtbNHMGMqADMJoVda3Iv1bMrvYQNxy5w16wopkcF8MADD/Diiy+Sm5tLTExMH35HQhhLjviFU2uz2Xj99deJj49n5syZvdpGa5udJ985xW92ZfGV6RE8sTyWWSMDMZvaLyw3KcXY4T78842jGRnkzaakiyRfqOT+++/HarXyxhtv9OW3JIThpPiFU8tKOUJJSQkPP/xwr9avbWrln14/zttJF/nWkrE8d88MPNy6PiPI3c3M1+eNIibEm60nCqlss7JmzRq2bt1KZWVll+sIMRhJ8Qun9tne94mKimLhwoU9XreoqpG7XjrK0XOX+Z910/iPFeNRqqvpo/7OzWzi7vgorBYTT2w6yVcfeJCmpiY2b97c229BCKcjxS+cVnHeWS5mp3P//ff3+Lz9lPxK7njxMIWVjfz54Ru4+4aoa6/UwdfDjdtmRJJWUM2eAhPz5s1jw4YNtLTIHD5iaJDiF07r+N6tuLl7sHbtWofX0VrzlyN53PPyUawWE5u/mcCCcT2f9G9qpD+3zYjgD/vOsvy2uykrK+Ojjz7q8XaEcEZS/MIp1ddUcTrxANPnL8fPz8+hdbJLa3n49eP8dFs6C8aF8OFjC5gQ5ti6XfnJmkm4W0zsrxrGmDFj+Mtf/oIzTnEiRE9J8QunlHJgB222VuKXfeWqy7XY7BzIKuOJt0+w6rmDJF+o5EerJ/Lqg/H4e7ldV4YgH3f+5aYYdmWUsfCWtWRkZJCRkXFd2xTCGch5/MLp2O1tpBzYTszkmYRERP/Dc2U1TZwsqCatoIqTBdWk5ldS22TD22rmoXmj+Pcl4wj0duy+u4745wUxvHn0AsfbRuHh4cHmzZuZPHlyn21fCCNI8Qunk3s6hZqKcpbf137BVl2zjb8dy+eNxDwuVjQCYDYpxg33Yc20cJZNDGX+2OBuT9O8Hj7uFh5bMpaffZDB4oSFbN++ne9///t4eXn1+dcSYqBI8Qunc/LQbjx9/IidMYeUC5U8vTOTmiYbCTFBfH3eaKaP8GdyhD+e1v6ZofNK98+J5tVPz1PmFkdd3S52797N7bffPiBfW4j+IMUvnEpjXQ1ZKUeZtXg1h3Kr2J1RypzRw3jqlonMiAowJJO7xcw3bhzNzz9oYHRkNFu2bJHiF4OaFL9wKqcT99Nma6U2bCafZJQyIyqA1dPCySiqIaOo5qrr3j8n+qrP91TnaaOVAk+rheYR8SQfe5ffv3+Y4PCofvm6QvQ3OatHOJUTn+4mIGI0KTVezBk9jDtnjcBiMv7X1N1iZm5MEMUBU1AmEycO7jI6khC9Zvy/KCE6lFw4R8mFHKpC44gM8GTNtAhM15hiYSAljAnC7OWPz6jppB3eQ5vNZnQkIXpFil84jROf7gKThdaIOO6cNeKL2TOdhY+7hZkjA6kImUF9TRXnM1KNjiREr0jxC6fQZrNx8sg+bGGTWT5jNKF+HkZH6lJCTBC2kPFYPLw4fXS/0XGE6BUpfuEUctNTaGmoxWvsbOaPDTY6TrdC/TyICfPHHjGdMymHaWluMjqSED0mxS+cwtEDe9BunixeeJNTjet3JSEmiMbw6bQ2N5Gdmmh0HCF6TE7nFIZraWok/9QxzNFxzBrd85k0P9f59Mv+NCHMD58R47F7B3L66D54/MEB+bpC9BU54heGO3zoU7StmbgblzrdC7pdMZsUc2OCaQqfzrlTSXJ3LjHoSPELwyUd+hg8/Fi6IMHoKA6LHzUMomZit7exa5ec0y8GFyl+YaiSy5U05p8mfPJc3N2ubxrlgeTjbmHypIlo31C2ffCB0XGE6BEpfmGo/R9/jLLbmL9khdFRemzemGBskXGkpqRQUlJidBwhHCbFLwxj15pzKQcx+wYzYdIUo+P02IhAT4InzAZg9+7dBqcRwnFS/MIwGXlF2EvPEhN3I8rJT+HsilKK+XGTsPuFs2XrdqPjCOEwKX5hmMMHD6C0nRsXLTU6Sq9NG+GP28g4zmacoqyszOg4QjhEil8YorqhlZKMz7D6hRA5epzRcXrNzWxi9c2rAM07H+wwOo4QDpHiF4Z4/3gOquwssbPmDcphns7W3zoPu28oW97/0OgoQjhEil8Y4u1tH6F0GzfMX2x0lOs2OtibyCkJFOVkUFoqwz3C+UnxiwFXWd/CuZTDWH2HERkz3ug4feKBO28FNC9ueM/oKEJckxS/GHDbknJRZVmMi5uHcoK7a/WFr62ci/IP4yO5ilcMAkPjX50YVN7+YBfKbmPW/EVGR+kzbmYTM+beRHX+GU7nFhodR4irkuIXA+pyXTM5qUfw9Asketxko+P0qX+9/w4Umt+/tdXoKEJclUPFr5RapZTKUkrlKKWe7OL5CUqpo0qpZqXUd694Lk8pdUopdUIpldRXwcXg9EHqBUylmSxctGTIDPN87qYbpuPuF8yRTw/Q2mY3Oo4Q3brmvzyllBl4AbgZmATcp5SadMViFcC/A890s5nFWusZWuv46wkrBr93du5HtbWy7tZVRkfpc0opEhYsxFaUyYcpeUbHEaJbjhxyzQZytNa5WusWYCNwW+cFtNZlWuvjQGs/ZBRDRHVDK1mpibi5ezJ79myj4/SLB9etQdltvLrlI6OjCNEtR4o/ErjY6fOCjsccpYHdSqlkpdQjPQknhpY9GcWYijOYOScBq9VqdJx+ccMN8bh7+ZCdeoTz5fVGxxGiS47cerGryyp1D77GfK11kVJqOLBHKXVGa33wS1+k/T+FRwCio6N7sHkxWLyzNxHVXMMdtwy+KZgdZbFYWLRoER/t2ceGo+f50a1/n3XU0VtD3j9Hfv9F/3LkiL8AiOr0+QigyNEvoLUu6nhfBrxH+9BRV8u9orWO11rHh4T0/r6rwjk1tNhIPXYIZTKxcOFCo+P0q9WrVqBaG9j00Sc0tbYZHUeIL3Gk+I8D45RSo5VSVuBeYJsjG1dKeSulfD//GFgBnO5tWDF4Hcy+hC46TeykaQQEBBgdp1/Nnz8fN6uVxryTfHRabtAinM81i19rbQMeA3YBmcAmrXW6Umq9Umo9gFIqTClVADwB/EgpVaCU8gNCgUNKqZPAZ8B2rbW86uWC3jt0GlNNMbfevNzoKP3Oy8uL+fPmYy1L563EPKPjCPEljozxo7XeAey44rGXOn1cQvsQ0JVqgOnXE1AMfi02O4cOHgBg6ZIlxoYZIMuWLeXAgf0kp6WTVTKN8WG+RkcS4gtD6woa4ZQOnyunteAUoZHRjBo1yug4A2Lx4sWYTCaspRn89dgFo+MI8Q+k+EW/23b8HObyc9y8YpnRUQbMsGHDiIuLw7/yDO+mFNLYIi/yCuchxS/6VWubnb37PwFtZ/mywXuLxd5YunQptSUXqKssY8epYqPjCPEFKX7Rr47lVtCUfwpvP3+mT3etl3uWdLyeMbzmLBuPO3YOvxADwaEXd4Xore0nL2IpzWTpLSsxm81Gx+kX3V+YpQgZMYrWknSO581h/thghvt6DGg2IboiR/yi37TZNR99chRaG1m21DXO5rlS7Iy5VF88g6m1geS8SqPjCAFI8Yt+lJRXQd35k1jc3Jg3b57RcQwxPi4BbbcT1XyBlPxKbHaZrlkYT4pf9Jsdp4oxl6QzZ85cvL29jY5jiIjRsfj4D8P9Uib1LW1kFtcaHUkIGeMX/eOtxAu8eyAZVX8Z/zFxDk9QNtQok4lxM+aQ8dkn+MauJTW/kqmR/kbHEi5OjvhFvyioaKDxQhoA42bMMTiNsWLj5tLc2EAMJWSX1lLbJLetEMaS4hf94nRRDebSdMJGjsMvMNjoOIYaPSkOi9Udt7JM7BpOXqwyOpJwcVL8os9prTl17iKminzGz0wwOo7h3KzuxEyeSUH6cSIDPEjJr0LrntzSQoi+JcUv+typwmrq8k4Bmti4uUbHcQrj4xKovlxGrHstJTVNFFc3GR1JuDApftHndp4uwVySju+wEEKjYoyO4xTGTp8NSmEqScdsUqTkyzn9wjhS/KJPaa35ICUPy6VsJsQloFRXd+50PT7+gYwYM5HzaceYEOZLWkE1bXYZ7hHGkOIXfSolv5Ki7FPotlYZ5rlCbNxcivPOMs63jbpmm9yMXRhGil/0qa0nirCWZmD18GTkhGlGx3EqsXEdL3QXp+NuMXGyQM7uEcaQ4hd9prXNzgcnC3EvP8PYaTdgtrgZHcmpBIdHMSw0gnMnjzEp3I/0ompsbTKFgxh4UvyizxzKKaeqMJeWuipiZ8hpnFdSShE7Yy7nM04wMcSdplY72aV1RscSLkiKX/SZramFeJWfwWw2M3ZavNFxnFJsXAJttlZUaRZeVrMM9whDSPGLPtHQYmN3Rik+l88wa9YsPH38jI7klKLGTcbT25eck4lMifTnTEkNzTa5LaMYWFL8ok98dLqExsoyakrzWbx4sdFxnJbJbGbs9NmcPfkZU8J8aG3TMtwjBpwUv+gTW5ILCKrNAf5+y0HRtdi4BBrrarBU5+NtNXO6sNroSMLFSPGL61ZQ2cDR3MsEVGYzZswYoqOjjY7k1MZMmYXZ4kZOaiKTIvzIKq2lVc7uEQNIil9ct/dSCtEtjZScOy1H+w5w9/Ri1IRpZKUeZVK4Hy02OzllMtwjBo4Uv7guWmveSSlgAoW0tbXJ+L6DYmcmUFFaSEBbJR5uJtKLaoyOJFyIFL+4LskXKsm73IBfZRbDhg1j2jS5WtcRsTPap7M4d/IYE8P8yCyukbl7xICR4hfXZUtyAZ4WOH8qiUWLFmE2m42ONCj4DQshbORYslMTmRzhT2NrG7nlMtwjBoYUv+i1xpY2tqcVM8e3irq6Whnm6aHYuAQu5mQQ6WXDzazIkOEeMUCk+EWv7c4oobbZhm9FFlarlXnz5hkdaVCJjZsLWnP+1HHGDvclq6RW7swlBoQUv+i1LckFRAZ4cCblKAkJCXh5eRkdaVAJix6D37AQslMTmRjmS1VjK6U1zUbHEi7AYnQAMbj89Vg+ANWNrRw6W87soGbSCgqYvmzdF88JxyiliI2by8lPd7Ps61YAzpTIcI/of3LEL3olNb8SDXiUZQAwbsYcYwMNUrFxCbS2NHM5N53IAE/OlNQaHUm4ACl+0WNaa1LyqxgV5M3F9ONEjpmIb0CQ0bEGpZHjp2L18CL7RCITwny5WNFARX2L0bHEECfFL3qssKqR8rpmJvq3UXw+m/FxMvd+b1ncrIyZOovs1ETGD/dBAweyyoyOJYY4KX7RY6n5VVhMCnNp+zBP7Ewp/usRG5dAXXUFuuoivh4WPs6U4hf9S4pf9EibXZNWUMWEcD/Opx1jWGgkweFRRsca1MZNuwFlMpFzIpHxob4czL5Ei00mbRP9R4pf9MjZslrqW9qYEuJGXuZJxs+ch1LK6FiDmqePH9GxU8hOTWRCmB+1zTaS8iqMjiWGMCl+0SOp+VV4Wc1Qkom9zcZ4GebpE7FxCZQVnCdY1WG1mPj4jAz3iP7jUPErpVYppbKUUjlKqSe7eH6CUuqoUqpZKfXdnqwrBo/aplYyi2uYNsKfnBPH8PL1J3LMBKNjDQmxce2Ttp0/dYx5Y4LYJ8Uv+tE1i18pZQZeAG4GJgH3KaUmXbFYBfDvwDO9WFcMEjtPl2Cza6aG+5CT9hmxcQmYTDIpW18YNjyC4IhoslMTWTphOOfL6zl3SSZtE/3DkSP+2UCO1jpXa90CbARu67yA1rpMa30caO3pumLweD+1kCBvK22lZ2lubJDTOPtYbFwCF7LSiI/wAGCfnN0j+okjxR8JXOz0eUHHY45weF2l1CNKqSSlVNKlS5cc3LwYKMXVjRzNvcyMqADOpibiZnVn9OQ4o2MNKePj5qLtdnJPJzMhzJePz5QaHUkMUY4Uf1enbDg6haDD62qtX9Fax2ut40NCQhzcvBgo76cWoTVMH+FP9omjxEyZhZvV3ehYQ0pkzAS8/QLYt28fSyYM53heJdWNV/4RLcT1c6T4C4DOJ2qPAIoc3P71rCuchNaa91ILmBkdQOvli9RUlDN+pkzB3NeUycS4GXM5ePAgC8cG0mbXfJItf/2KvudI8R8HximlRiulrMC9wDYHt3896wonkVFcQ3ZpHXfMHMGZ5CMoZWLc9NlGxxqSYuPmUldXR2tpDoFebuyXs3tEP7hm8WutbcBjwC4gE9iktU5XSq1XSq0HUEqFKaUKgCeAHymlCpRSft2t21/fjOgf76cW4mZWrJkazpnkQ0SPn4KXr7/RsYakmElxuLu788mBAywaP5wDWWVyL17R5xyaj19rvQPYccVjL3X6uIT2YRyH1hWDh92u+TCtmIWxIVwuzqe8KJ/4JbcaHWvIcnP3YN68eezbt4/HV3+d91ILOXGxklkjhxkdTQwhcuWuuKrUi5UUVzexelo4u3fvBqWYMGu+0bGGtCVLllBUVEQ4FZhNSi7mEn1Oil9c1YdpxVgtJpZNDGX37t1EjZ2Eb6DMvd+fFi9ejMlk4vCBj4kfGSizdYo+J8UvumW3a3ac6hjmKSkkKyuLifE3Gh1ryAsKCmL27Nns2rWLJRNCOFNSS2FVo9GxxBAixS+6lZJfSWlNM2umhbNnzx4AJkjxD4iVK1eSl5dHjLX9Hrxydo/oS1L8olufD/MsnRjKrl27mDZtGv5Bw42O5RKWL1+OyWQi47NPiR7mJeP8ok9J8YsufT7Ms3h8CNXlpaSnp7NixQqjY7mMoKAgbrjhBnbt2sXi8SEczimnsaXN6FhiiHDodE4x9P31WP4/fH6+vJ6y2mYCvKw8/ce3AWgaPgVPI8K5qJUrV/Lzn/+cB7zqabbZOZpbzpIJoUbHEkOAHPGLLp0qrMZiUkwI8yUz6RBhI8cSODzc6Fgu5fPhnpKMRLysZhnuEX1Gil98iV1r0gurGR/mS3NNBYXnMuVsHgMEBwcTHx/Px3v2cOPYYPZllqG1XMUrrp8Uv/iSvMv11DbbmBrpz5nkwwBMvGGBwalc04oVKzh37hxTfRsoqm4iq7TW6EhiCJDiF19yqqAaN7NifJgvmcc/JWTEKILCupyRQ/SzFStWoJSiITcFQC7mEn1Cil/8A7vWpBfVMD7Ul5a6KvLPpjNxlgzzGCUkJIRZs2bx6f69TI30l3F+0Sek+MU/yCuvp67ZxtQRAWR8dhC0ZtKchUbHcmmrVq3i3LlzzPBvIjW/kst1zUZHEoOcFL/4B2mFHcM8ob6kJx4gNHoMIRHRRsdyacuXL0cphanwJHYtwz3i+knxiy+02dvP5pkQ5kddRQmFuWeYMneR0bFc3vDhw5k1axZJh/YRGeDBR+klRkcSg5wUv/hCbnkd9S1tTI30Jz3xAACT5ywyNJNot3r1anJzc5kT2Mihs+XUNsm9eEXvSfGLL5wqqMZqMREb6sPpxP1ExU6WuXmcxMqVK7FYLJCfQkubnf1Zci9e0XtS/AIAm91OelENk8L9qCy+QHlRPlPmLjY6lugQGBjIggULSD70McHebuw6LcM9ovek+AUA58rqaGxtH+Y5nXgAZTIxMV4u2nIma9asoaysjDjPy+zPKqOpVSZtE70jxS8ASCuoxsPNxNgQb9ITDxAzeSbefgFGxxKdLF68GC8vL/SFJBpa2jiYLcM9ondkdk5Bs62NjOIaJkf4U5ybSfXlUhatfdDoWC7ryplSOxsbN4+kwwfwXLWI7aeKWTE5bACTiaFCjvgFB7PLabbZmTbCn7RDe3Bz95AbqjupKQlLaG5sILo5j93ppTS02IyOJAYhKX7Bh2lFeFnNRPu7kXH8IBPjF2D1kJn3ndHoiTPw9gtE5yfT2NrGXrmYS/SCFL+La2ptY29GKZMj/Mg5cZTmxgam37jM6FiiGyazmSkJiynMTGa41ca2E4VGRxKDkBS/i9t/pqzjoq0ATh7ag39QKCPHTzM6lriK6TeuwN5mY3xLNp9kX6KqocXoSGKQkeJ3cR+mFRPsYyXY3Mj59FSmzV+KMsmvhTMLjRpN+OhYLp06SKvNzk45p1/0kPwLd2H1zTY+PlPKzVPCSU/ch9Z2ps2XYZ7BYMaNK7iQm0OUqYL3U2W4R/SMFL8L25NRSlOrnVumhpF2eC9R4yYzLDTS6FjCAZPnLsJqtRJekcax8xXkX24wOpIYRKT4Xdg7KQVEBnjiWVtAeVG+HO0PIp7evixbtoy8E59isreyKemi0ZHEICLF76JKqps4nFPOupmRbN68GTd3D5mJc5BZu3YttTU1TFEX2ZJcgK3NbnQkMUhI8buo91ILsWtYGRvAjh07mDJ3Me6eXkbHEj0wd+5cwsPDMV84TklNEwfPyhQOwjFS/C5Ia807KQXEjwzkxOG9NDU1MWvxaqNjiR4ym82sXbuWrLQkhuka3j4uwz3CMVL8LiitoJqcsjrWzoxk06ZNTJ48mfBR44yOJXrhrrvuwmQyEVObxseZZVyqlfvximuT4ndB76QUYLWYGMklsrOzufvuu42OJHopNDSUxYsXczHlALbWVt4+3v0Eb0J8TorfxTS02HgvtZCbp4Sxfeu7eHl5sXq1DPMMZvfeey811VVMsufyZuIFWuVFXnENUvwu5sOTxdQ22bhjyjB27tzJrbfeire3t9GxxHVISEggOjoalXuE0ppmPpIrecU1yHz8LmbDsQvEhvqQ+9nHNDU1cc899xgdSfRS53n7x89bxZ6NrxAw+hK/2ZVFbdPfp2u+f060EfGEE5MjfhdyqqCakwXV3Bc/gg0bNhAfH8/EiRONjiX6wPQbl2NxsxJcmkR+RQMFlXIlr+ieQ8WvlFqllMpSSuUopZ7s4nmllPp9x/NpSqmZnZ7LU0qdUkqdUEol9WV40TN//ewCHm4mAquzKSoq4sEH5S5bQ4Wnjx+T5yykLP0w1rYmjpy7bHQk4cSuWfxKKTPwAnAzMAm4Tyk16YrFbgbGdbw9AvzfFc8v1lrP0FrHX39k0RvVja1sPVHEV6ZHsGXjBiIjI1myZInRsUQfmr3iDlqcRB2kAAATUUlEQVSbmxhRdYK0giqZrll0y5Ej/tlAjtY6V2vdAmwEbrtimduAN3S7RCBAKRXex1nFddj4WT4NLW3MD2oiOTmZr33ta5jNZqNjiT4UFj2G0ZPjqDm1D+w2DuWUGx1JOClHij8S6HxJYEHHY44uo4HdSqlkpdQj3X0RpdQjSqkkpVTSpUty6XlfarHZ+fPhPOaNCeLIR+2ncK5bt87oWKIfzF25jvrqCkY1ZHM8r4KGZrknr/gyR4pfdfGY7sEy87XWM2kfDnpUKXVTV19Ea/2K1jpeax0fEhLiQCzhqO2niiipaeLuyf7s3LmTtWvX4uvra3Qs0Q/GTI0nJHIkzRn7aLXZOXpexvrFlzlyOmcBENXp8xFAkaPLaK0/f1+mlHqP9qGjg70NLHpmQ+IFnt+fQ4ivO1s3b8Bma8N/6pJ/OBVQDB1KKeauXMcHr/0vI9sKOXrOQn2zDW93OXNb/J0jR/zHgXFKqdFKKStwL7DtimW2AQ92nN0zF6jWWhcrpbyVUr4ASilvYAVwug/zi2s4d6me4uomZke4k7x/O5Pm3CQ3WxnipiQsxtsvEEvOARpa2njj6AWjIwknc83i11rbgMeAXUAmsElrna6UWq+UWt+x2A4gF8gB/gj8W8fjocAhpdRJ4DNgu9b6oz7+HsRV7M8qw9fdQvOZT2htbuLGNfcZHUn0M4ubldkrbqco6wSjTJd5+eA5aptajY4lnIhDf/9prXfQXu6dH3up08caeLSL9XKB6deZUfTS0XOXOV9ez8rYAD57cSuxcQkMHzHK6FhiANyw9FaO7tyMNXsvVWPv4c+H8/j3pTIDq2gnV+4OYc/tzcbXw4Lp/BGa6utYcKsc7bsKd09v5q5cx8X048wNbOSPn+ZS3ShH/aKdFP8QdeRcOcfOV3DjaH+O736PmMkziYgZb3QsMYBuWHYbHl4+uJ/dS22TjT99mmt0JOEkpPiHIK01v92TTaifO6bcI9TXVHLjV+43OpYYYB5e3sxecQefHf6Em4Y389rhPCrr5WpeIcU/JO3JKOV4XiX/MjeCozveZsyUWYwcP9XoWMIAc5bfjo+PD5asvdS32HhFjvoFUvxDTmubnad3nmFMiDe1abtprKth8Z0PGx1LGMTD24eHHnqIowf3c9OwBl4/nEd5ndye0dVJ8Q8xf/ssn9zyeh6bF8qbb7zBpNkL5X66Lu7hhx8mODiYuqR3aW618dKBc0ZHEgaT4h9CappaeW7vWRJigji9dwutra0sXveQ0bGEwby9vXnsscfISDtBgmcJbyReoLCq0ehYwkBS/EPIb/dkU9nQwjfifNm0aRPr1q2Tq3QFAOvWrSMmJoayI1vA3sazu7KMjiQMJBN4DFJXzrVTXN3I64fzmD16GL9/9jeYLG6EJ1w5e7ZwRZ//rsTf+iCbfvefxIw7xXupiogATyICPAG5PaOrkSP+IcCuNVtPFOFlNTPGdoGzJ49x021fxTcgyOhowonEzpjLyPHTKDv2Ph40sfN0Me0X3QtXI8U/BKTmV5Jf0cDy8UEcePsVgiOimb38DqNjCSejlGLFV9fT1FBHRP7HnLtUT1ZprdGxhAGk+Ae52qZWdpwqYWSQF42n91B5qZhVX3sUs0VG8cSXhUWPYc6KOyhK3U9gYyHb04qx2e1GxxIDTIp/kNt2sojWNjvLoiwc2f42k2bfxOhJM4yOJZzYwtsfwG9YCO5p73C5tpEjOXKzFlcjxT+InS6sJr2ohiXjgzmy6QVMZgvL7+327pZCAGD18GTV1/6N6pJ8wsuOsT+rjLLaJqNjiQEkxT9I1Tfb2HayiIgADzwvHiMv8yQr7vtX/IbJbSvFtY2fOY/YuATqUj7EVlXK0zvOGB1JDCAp/kFIa817qYU0traxLMrM/s1/Yuy0G5hx00qjo4lB5JYHv4WbuweB6Zt4NzmfIznlRkcSA0SKfxDanFxARnENyyeEkPj285gtbqx++Nso1dU974Xomm9gEKu//jj1JecJzj/AD98/TVNrm9GxxACQ4h9k8i838LNt6YwO9oasj7l4Np2VX/0mfoHBRkcTg9DE+BuZvmAFDad2cSHrNC/uzzE6khgAUvyDSIvNzrf+loLJpJjjXc7B995kSsISps5banQ0MYitvP+bREZEEHB6E/+35xQZRTVGRxL9TIp/EPnVzkxOFlTzw8UR7PnzMwRHRLH664/LEI+4Lu6eXjzzzDPY6qtwT97Adzam0GyTIZ+hTIp/kPjodAl/PpzHg3Mi2frSf2NrbeHOx36M1d3D6GhiCJg+fTo//vGPaSs+w7n9b/O7vWeNjiT6kRT/IJBTVsf3Np9kaqQfLZ9t4sSJE9z6T08QHB5ldDQxhNx1113ce++9uOUc4JUNW0jKqzA6kugnUvxOrrqxlUfeSMJqMZHQdJyt77/Ho48+yqTZNxkdTQxBTz31FNPj4nBL3cQ3n9tChdyjd0iS4ndibXbNtzemkl/RwD3Bhbz52h9Zt24djz76qNHRxBBltVp58fnnCQ8Pp3bf//HIH7Zht8sMnkONzOTlpLTW/OLDDPZnXeJrI6p444VnWLBgAT/96U/lxVzR5668v8Nd3/kvXv7Z45ze+D884OHB6oRpgMzbP1TIEb+TeuVgLq8fyWOZTxHvv/Qrpk6dym9/+1vc3NyMjiZcgH/QcB5+8tdYlCbpjf8mMU3u2DWUSPE7ofdTC/nVzjPM0jkc/dtzxMXF8eqrr+Lt7W10NOFCQiKieeD7v8Jsb2H3Cz/kxKl0oyOJPiLF72Q+TCviibdTGVuVTOYHLzN79mxefvllKX1hiKiYWB588hmUycQHv/8hH+47bHQk0QeUM956LT4+XiclJRkdY8DtPFXMo299RsCZD2jMPkxsXAJrv/kUblZ3o6MJF3f+wkXe+s1T0FjFd5/6Md/46l1GRxJXUEola63jHVlWjvidxKakizz2+qf4fPYnGrMPM3/Nvdz9rZ9I6QunMHpkFA889QymoGie+eVPePLHP6O1tdXoWKKXpPgNprXmhf05PPnC23gdeBZ7eR63/+sPWHLnwyiT/HiE8xgVGcbmv76JZfwitm7ZyF33P0BhYaHRsUQvSLMYqKm1jSf+epznfvMr3BP/xOjIML7x0z8wNWGJ0dGE6NKkyEC2vfoMfgsf5syZM9yy5lY2btyIMw4Zi+5J8Rskr7yOFf/xe3Y8+ziW80d46KGH2Lx5E6FRo42OJsRVjQ725qNnv834B35Bo+8Ifvazn/HQ1x/m7FmZ32ewkOIfYHa75jcb93Lz2vu4tOcVokODefPNN3nyySdxd5fxfDE4BHpb2fTELTz0g6dpmX4nSSfSuO322/npT39KebncycvZyZW7A+j9j4/w38/+jtrzaZg9vPm3//gBj3z9a1gs8mMQg4+7xcwPV09iYezjPPFWPJVJH7J5yzts++AD7rn7bh566CHCw8ONjim6IKdz9rOWlhY2vPsBf/jjGzQWZYPVi3HzV3Pbnffi6e1jdDwheqS7KRvqm228eCCHP+44hsrcjbnwBCalWLNmDffccw8zZsyQqUb6WU9O55Ti7wd2u53jycm8vmkrh/btxtZQi/YOIjp+GXesuwt/P1+jIwrRLyrqWziUc4kTZ3JpyzqAW/5xtK2ZyOiR3HPnOlasWMHIkSO/WP7KOYK6I3MEXZsUvwGqqqrY98lhPtizn9TPjtBcW4k2WbBETmHlrXcwbkocfl4yhi9cw6opYWxJvsi2pPNkHv8Uc/5xzBXnAQgIj2b6DfO5cf486n2i8PX2vOb2pPivrc+LXym1CvgdYAZe1Vo/fcXzquP5W4AG4Ota6xRH1u2Ksxd/S0sLqacy+CQxmd2HjlN+8RzNlwsBjbZ4wPBxhE+ew+x5NzE5OgSLWV5DF66lc1FfrGjgcE45B1KySD32KVU5KajyXBQabbKggkbiMXwUfuGjCYmKITwymmE+7gR4WQn0smK1mKT4HdCnxa+UMgPZwHKgADgO3Ke1zui0zC3At2gv/jnA77TWcxxZtytGF7/WmqqqKnIvFpGZe5Gs3AucP59HUUE+FaVFNFeVgba3L2v1gsBo/CLHMXLiDKZNm8bIEB8scvGVcGFXK+rWNjsZF0r5+NNEdu77lMt5mTSWF4DdBoA2u6F9Q7F7B6O9grD6hxA5YgQjwkOJiQpnbEQwI4O8iRrmRbi/hxxYdehJ8TtyOslsIEdrndux8Y3AbUDn8r4NeEO3/y+SqJQKUEqFA6McWLdP1dbWUlxcTFNzCw2NjTQ2NtHQ2EhTUwv1jQ3U1jdS29BIfX0j1TU1VFZXU1NdTW1tLQ11tTTV19JcV/3FL+HntNkN5ROCd1AEkZPnMH7CRObMmk6pzYsgH3d54UoIB7mZTUyPCWd6zB2ETZgFQJvNRnlxPkV5ZynIPUtpYT7Vl4ppKEpDazsFSe1HjomANlnQ7j7g7gPuvnh5++Dp5YWXlxfe3t74+frg6+ODl5cXVg9P3NzcsLi54eZmAZMZTG5kFNejTeb2N2XCrhVaQxugtaJNgwYih3nRphVWswkPqwUPqwVPNwseVjOeVgseFhOeVjMebmbcLeb2jy0mPNzaH/N0M+PhZsLdzYzZpDArhVJgUgqzSWFSGNIdjhR/JHCx0+cFtB/VX2uZSAfX7TPT/nMXjWePYkl526HltckCbl5oqye4eeLm6Y17aCgRE4MJCRnOiIhQRkdFMHnMKKaOjWJYFwXv6ItTQojumS0WQqNiCI2KIW7Byi8eb7PZqK4oY2aQnfLyci5dKudCUSmFJWWUXSqnoqKCxsoKaksaqWppRNv6dv6gq92FQKNAKUDBl7r7KmXeZdEr7Dd8leDYWRx5ammPc/aUI8XfVcorx4e6W8aRdds3oNQjwCMdnzYrpU47kM3ZBAOD8eqVwZobBm/2IZ37qwMQpBece5+np3EWUP/vS884mnvktRdp50jxFwBRnT4fARQ5uIzVgXUB0Fq/ArwCoJRKcnSsyplI7oE3WLNL7oE3WLP3R25HXhU5DoxTSo1WSlmBe4FtVyyzDXhQtZsLVGutix1cVwghxAC65hG/1tqmlHoM2EX7KZmvaa3TlVLrO55/CdhB+xk9ObSfzvnw1dbtl+9ECCGEQxyaJEZrvYP2cu/82EudPtbAo46u64BXeri8s5DcA2+wZpfcA2+wZu/z3E555a4QQoj+I1c+CCGEi3GK4ldK/adSqlApdaLj7ZZullullMpSSuUopZ4c6Jxd5PmNUuqMUipNKfWeUiqgm+XylFKnOr43wy5Jvtb+63hx/vcdz6cppWYakfOKTFFKqf1KqUylVLpS6vEullmklKru9PvzEyOyduVaP3sn3efjO+3LE0qpGqXUt69Yxin2uVLqNaVUWefTv5VSw5RSe5RSZzveB3azrqF90k32gekUrbXhb8B/At+9xjJm4BwQQ/tpoieBSQbnXgFYOj7+NfDrbpbLA4INznrN/Uf7C/Q7ab/+Yi5wzAl+N8KBmR0f+9I+BciVuRcBHxqdtTc/e2fc51383pQAI51xnwM3ATOB050e+x/gyY6Pn+zq36Uz9Ek32QekU5ziiN9BX0wdobVuAT6f/sEwWuvdWuvP53ZIpP06BWflyP77YuoNrXUi8PnUG4bRWhfrjgn/tNa1QCbtV4QPFU63z6+wFDintb5gdJCuaK0PAhVXPHwb8JeOj/8C3N7Fqob3SVfZB6pTnKn4H+v48+a1bv40625aCGfxT7QfuXVFA7uVUskdVygbwZH959T7WCk1CogDjnXxdIJS6qRSaqdSavKABru6a/3snXqf037tzd+6ec5Z93mobr+OiI73w7tYxtn3O/RjpwzYPf+UUnuBsC6e+iHwf8AvaP9mfgE8S/s3/Q+b6GLdfj8l6Wq5tdZbO5b5IWADNnSzmfla6yKl1HBgj1LqTMf/9gPpeqbeMJxSygd4B/i21rrmiqdTaB+KqOt4feh9YNxAZ+zGtX72zrzPrcBXgKe6eNqZ97kjnHa/Q/93yoAVv9Z6mSPLKaX+CHzYxVOOTB3R566VWyn1ELAGWKo7Bt+62EZRx/sypdR7tP+ZOdDFfz1TbxhKKeVGe+lv0Fq/e+Xznf8j0FrvUEq9qJQK1lobPi+LAz97p9znHW4GUrTWpVc+4cz7HChVSoVrrYs7hs3KuljGaff7QHSKUwz1XDGmeQfQ1QRtTjf9g2q/ycwPgK9orRu6WcZbKeX7+ce0v3hjxAR01zP1hmGUUgr4E5Cptf7fbpYJ61gOpdRs2n+vLw9cyq45+LN3un3eyX10M8zjrPu8wzbgoY6PHwK2drGM0/UJDGCnDOSr2Fd5dftN4BSQRvvOD+94PALY0Wm5W2g/q+Mc7UMtRufOoX2c8ETH20tX5qb9rIGTHW/pRubuav8B64H1HR8r4IWO508B8U6wj2+k/U/wtE77+ZYrcj/WsW9P0v6C2Dyjc1/tZ+/s+7wjlxftRe7f6TGn2+e0/8dUDLTSfhT/DSAI+Bg42/F+WMeyTtUn3WQfkE6RK3eFEMLFOMVQjxBCiIEjxS+EEC5Gil8IIVyMFL8QQrgYKX4hhHAxUvxCCOFipPiFEMLFSPELIYSL+f91m4nrts9ZCAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as st\n",
    "sns.distplot(data, fit=st.norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Scikit-learn (sklearn) use case\n",
    "\n",
    "scikit learn is the main machine learning library in python.\n",
    "For our current discussion, we can say that sklearn is based on two pillars:\n",
    "\n",
    "* Classifiers, Regressors and Transformers\n",
    "* pipelines and unions\n",
    "\n",
    "Sklearn emploies a very simple interface api for the first group, and leverage the second group to hierarchically create the whole analysis pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This allowed anyone to write classes compatible with all the other sklearn compatible classes, driving an explosion of methods and libraries that all work together nicely.\n",
    "\n",
    "These good API choices basically singlehandedly put python in the machine learning community attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The basic idea of `Classifiers`, `Regressors` and `Transformers`, is that all of them implement a compatible interface:\n",
    "\n",
    "* **Transformers** implements a method `fit` and a method `transform`\n",
    "* **Regressors** and **Classifiers** implement the methods `fit` and `predict`\n",
    "\n",
    "the idea is that with the `fit` function this object \"learns\" from the data, then they apply to (ideally) new data to predict the expected value or to transform them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* **fit(X, y)** should take:\n",
    "    * an array-like **X** (rows for the obsersations, columns for the features)\n",
    "    * an array-like **y** (rows for the observations, potentially multiple column values)\n",
    "    * **returns**: the predictor itself\n",
    "* **predict(X)** should take:\n",
    "    * an array-like **X** (rows for the obsersations, columns for the features)\n",
    "    * **returns**: an array-like (rows for the observations, potentially multiple column values)\n",
    "* **transform(X)** should take:\n",
    "    * an array-like **X** (rows for the obsersations, columns for the features)\n",
    "    * **returns**: an array-like (rows for the observations, potentially multiple column values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Any class that implements these features can inherit from `BaseEstimator` and then from `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin` or `sklearn.base.TransformerMixin` to have their interface completed.\n",
    "\n",
    "due to the requirements for this extension, I **strongly** suggest to create the classes using the `dataclass` decorator.\n",
    "It is also a good idea to just store the `__init__` parameters without modyfing them.\n",
    "If you have to perform some processing and transformations, it's usually better to do them inside the `fit` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import List\n",
    "\n",
    "@dataclass\n",
    "class ColumnSelector(BaseEstimator, TransformerMixin):\n",
    "    columns: List[str]\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X):\n",
    "        return X[self.columns]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'columns': ['a', 'e']}\n"
     ]
    }
   ],
   "source": [
    "cs = ColumnSelector(columns=[\"a\", \"e\"])\n",
    "print(cs.get_params())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>e</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.606346</td>\n",
       "      <td>-0.300311</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.020452</td>\n",
       "      <td>-0.678270</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.406233</td>\n",
       "      <td>0.581932</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-2.292684</td>\n",
       "      <td>0.420558</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.959172</td>\n",
       "      <td>1.054905</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         e\n",
       "0 -1.606346 -0.300311\n",
       "1  0.020452 -0.678270\n",
       "2  1.406233  0.581932\n",
       "3 -2.292684  0.420558\n",
       "4  0.959172  1.054905"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame(rn.randn(5, 5), columns=list(\"abcde\"))\n",
    "cs.fit_transform(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "The real magic bits are **pipelines** and **unions**.\n",
    "\n",
    "* **unions** take a series of transformers and combined all of their output in a single transformed dataset. **it behaves like a transformer itself**\n",
    "* **pipelines** take a list of transformers (and optionally a classifier/regressor at the end) and pipe the data from one to the other. **it behaves like a transformer or estimator itself**\n",
    "\n",
    "the fact that both unions and pipelines expose the same interface as the objects that they are wrapping means that they can be used inside other unions and pipelines, creating a full data-flow structure that behaves correctly (for example about data leaking)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The exercise\n",
    "\n",
    "Our goal might be to implement a groupby standardizer.\n",
    "\n",
    "a standardizer subtract the average of one or more columns, and divide the data by their standard deviation.\n",
    "\n",
    "The standard standardizer does use the whole data average, but we might want to do this operation separatedly on different groups, for example by country.\n",
    "\n",
    "Assuming that all the groupby categories are present in the traning data, try to implement it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# end of the general programming module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Extra material\n",
    "\n",
    "this is not part of the lesson material, but it is interesting to have here as a reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## metaprogramming: metaclasses\n",
    "\n",
    "classes are objects too.\n",
    "\n",
    "by default they are of type `type` (which is a class but also an object).\n",
    "`type` provide an initialization for the class in the same way as the class provide the init to the instance (using the `__new__` method)\n",
    "\n",
    "One can instantiate a subclass of `type` that provide a different initialization process, and using to generate the new class.\n",
    "To do this, this new type subclass should be indicated as the class `metaclass` alongside its superclasses.\n",
    "This allow to personalize the generation of classes.\n",
    "It is not commonly used in normal programming, but can be very useful for:\n",
    "* frameworks\n",
    "* attribute sharing without inheritance from other classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# type is an object that have type type, which is an object that have type type, etc...\n",
    "class Empty_base:\n",
    "    pass\n",
    "\n",
    "class Empty(Empty_base):\n",
    "    pass\n",
    "\n",
    "assert issubclass(Empty, Empty_base)\n",
    "assert isinstance(Empty, object)\n",
    "\n",
    "assert type(Empty()) is Empty\n",
    "assert type(Empty) is type\n",
    "\n",
    "assert type(type) is type\n",
    "assert type(object) is type\n",
    "assert isinstance(type, object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 355,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dynamical class generation\n",
    "Foo = type('SomeClass', (Empty, ), {'x':100})\n",
    "assert Foo.__name__ == 'SomeClass'\n",
    "\n",
    "someobject = Foo()\n",
    "assert isinstance(someobject, Foo)\n",
    "assert type(Foo) is type\n",
    "\n",
    "someobject.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 362,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# we can subclass type and use it to generate classes, and so the new class type in going to be a subclass of type\n",
    "class Meta(type):\n",
    "    def __new__(cls, name, bases, dct):\n",
    "        x = super().__new__(cls, name, bases, dct)\n",
    "        x.attr = 100\n",
    "        \n",
    "        def obscure(self):\n",
    "            return self.attr\n",
    "        x.obscure = obscure\n",
    "        \n",
    "        return x\n",
    "    \n",
    "Foo = Meta('SomeClass', (Empty, ), {})\n",
    "assert Foo.__name__ == 'SomeClass'\n",
    "\n",
    "someobject = Foo()\n",
    "assert isinstance(someobject, Foo)\n",
    "assert type(Foo) is Meta\n",
    "\n",
    "assert someobject.obscure() == someobject.attr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "class Foo(metaclass=Meta):\n",
    "    pass\n",
    "\n",
    "someobject = Foo()\n",
    "assert isinstance(someobject, Foo)\n",
    "assert type(Foo) is Meta\n",
    "\n",
    "assert someobject.obscure() == someobject.attr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Improving your library API design and management\n",
    "\n",
    "One of the problems when writing a library is that the requirements and structure of your functions API will change over time.\n",
    "\n",
    "Improving and changing your API is a non trivial process, as probably there are users relying on your code!\n",
    "\n",
    "The best thing is to get it right from the beginning.\n",
    "While this is clearly utopical, in general it is a good idea to follow the old advice of \n",
    "> measure twice, cut once\n",
    "\n",
    "Luckly python provide us with a great number of tools (such as properties, dynamical attributes, magic methods, etc...) that makes it easy to have a post-hoc patch that is transparent to the user but allows you to improve one step at the time.\n",
    "\n",
    "Here I collect some suggestions that you might find helpful, both for the good design and on how to improve the design over time.\n",
    "\n",
    "a good discussion can be found in this article: [API evolution the right way](https://emptysqua.re/blog/api-evolution-the-right-way/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### deprecation warning\n",
    "\n",
    "once you define a function that use certain parameters, or with certain defaults, and you realize that you need to change them, don't do it straight away!\n",
    "You will break you users' code, and they will not be thrilled.\n",
    "\n",
    "the usual solution is to take an intermediate step (usually one release or two of the library before the change will actually happens) to warn your users about the changes in the API.\n",
    "This is done using the `DeprecationWarning` exception, or a warning logging when the function is called, or raising a warning message from the `warnings` module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## using function parameters using the `enum` module\n",
    "\n",
    "a common issue with some APIs, especially old ones in python, is the use of modal parameters using strings.\n",
    "\n",
    "A **modal parameter** is a parameter that changes the behavior of the function in one of few selected modes.\n",
    "A common example could be the `histtype` parameter in the `hist` function of matplotlib.\n",
    "This parameter takes a string to define the kind of histogram that one wants to do.\n",
    "\n",
    "I've been using this funcion for almost ten years, and I still can't remember if the names are hyphenated, which are available and which not, and so on.\n",
    "And if one inputs the wrong string, the error message is not helpful enough.\n",
    "\n",
    "This is a limit in the API: it has a low **discoverability**, meaning that a new user will have a bad time understanding how to use it, or even that it is possible at all.\n",
    "This is common with graphical functions, that might need to pass parameters to few other functions on the way, and their signature ends up being an unsightly mess.\n",
    "\n",
    "A better solution is to leverage the **enum** standard library module (introduced in python 3.4) and dynamical attribute assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "let's consider a function that evolves a dynamical system such as the one we implemented in the first few lessons for cellular automata.\n",
    "\n",
    "This function has a modal argument, namely the behavior of the system at the boundaries.\n",
    "This could be:\n",
    "* **reflective**\n",
    "* **circular**\n",
    "* **fixed alive**\n",
    "* **fixed dead**\n",
    "\n",
    "the first version would be using a string as a parameter, such as:\n",
    "\n",
    "```python\n",
    "def evolve(initial_state, rule, boundary='fixed dead'):\n",
    "    # do something with those info\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "the problem is that a string is the wrong abstraction: we don't want **any** kind of strings, but only a limited sets of them, but we are still allowing the user to put any value in.\n",
    "This means that we also have to worry about error management, and be very careful to keep the documentation in line with the values we accept.\n",
    "\n",
    "a better solution would be to use an enum class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import enum\n",
    "\n",
    "class BoundaryType(enum.Enum):\n",
    "    REFLECTIVE = \"reflective\"\n",
    "    CIRCULAR = \"circular\"\n",
    "    FIXED_DEAD = 'fixed dead'\n",
    "    FIXED_ALIVE = 'fixed alive'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "and would write the function as:\n",
    "    \n",
    "```python\n",
    "def evolve(initial_state, rule, boundary=BoundaryType.FIXED_DEAD):\n",
    "    # function body\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Having this enum gives us several advantages:\n",
    "* it is still compatible with the old definition (the value is identical to the old ones), allowing for a smoother transition\n",
    "* the user can see in their code what is available, and can leverage their editor's autocompletion capabilities\n",
    "* there is less risk of mistakes in the code by passing the wrong string\n",
    "\n",
    "the only disadvantage is that is is slightly more verbose, but this is often worth the improvement in code correctness\n",
    "\n",
    "this approach has two disadvantages:\n",
    "* the code is a little bit more verbose\n",
    "* the user is required to import more stuff from the module, littering the namespace and the import section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "We can improve discoverability even further by leveraging functions attributes.\n",
    "\n",
    "Being functions just another object, we can set any kind of attribute.\n",
    "In our case we can include the values that the arguments should have in the function attributes, making sure that the function carry with it everything it needs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mproperty:\u001b[0m\n",
       "    \u001b[0;34mx\u001b[0m"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fun():\n",
    "    pass\n",
    "\n",
    "fun.x = 3\n",
    "dir(fun).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "there are three approaches for this implementation:\n",
    "1. storing all the enums in a single namespace\n",
    "2. storing each enum in an attribute with the same name of the enum\n",
    "3. storing each enum in an attribute with the same name of the parameter of the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "#### storing all the enums in a single namespace\n",
    "\n",
    "This option is useful if only one parameter use the enum, or several parameters do, but sharing the same enum values.\n",
    "\n",
    "for example, a graphic class for a square might take for each side if the line should be absent, thin or bold.\n",
    "given that four parameters share the same values and there are no other parameters (for now!), it might make sense to store all the enum values in the function bare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 436,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mproperty:\u001b[0m\n",
       "    \u001b[0;34mBOLD\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34mNO_LINE\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34mTHIN\u001b[0m"
      ]
     },
     "execution_count": 436,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class LineStyle(enum.Enum):\n",
    "    NO_LINE = 'noline'\n",
    "    THIN = 'thin'\n",
    "    BOLD = 'bold'\n",
    "    \n",
    "def draw_square(top=LineStyle.THIN, bottom=LineStyle.THIN, left=LineStyle.THIN, right=LineStyle.THIN):\n",
    "    pass\n",
    "\n",
    "for style in LineStyle:\n",
    "    setattr(draw_square, style.name, style)\n",
    "\n",
    "dir(draw_square).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "And this function could then be called with:\n",
    "\n",
    "```python\n",
    "draw_square(bottom=draw_square.BOLD)\n",
    "```\n",
    "\n",
    "this approach can be useful when one of the parameters (tipically the first or second) have a predominant role in the behavior of the function, changing it drastically rather than fine-tuning it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "#### each enum in an attribute with the same name of the enum\n",
    "\n",
    "This is a little more verbose, but helps the user understand what the enumerator is referring about, and have the advantage of using the same expression that would appear in the function signature.\n",
    "\n",
    "this means, on the other end, that we increase the verboseness of our code further"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 437,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mclass:\u001b[0m\n",
       "    \u001b[0;34mLineStyle\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mAn enumeration.\u001b[0m"
      ]
     },
     "execution_count": 437,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class LineStyle(enum.Enum):\n",
    "    NO_LINE = 'noline'\n",
    "    THIN = 'thin'\n",
    "    BOLD = 'bold'\n",
    "    \n",
    "def draw_square(top=LineStyle.THIN, bottom=LineStyle.THIN, left=LineStyle.THIN, right=LineStyle.THIN):\n",
    "    pass\n",
    "\n",
    "draw_square.LineStyle = LineStyle\n",
    "\n",
    "dir(draw_square).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "An now the call would be in this (verbose but clear):\n",
    "```python\n",
    "draw_square(bottom=draw_square.LineStyle.BOLD)\n",
    "```\n",
    "\n",
    "there is nothing stopping the user to use two lines instead of one, and redefine the values locally\n",
    "\n",
    "```python\n",
    "bold = draw_square.LineStyle.BOLD\n",
    "draw_square(bottom=bold)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "#### each enum in an attribute with the same name of the parameter\n",
    "\n",
    "if the function has several parameters (or we want to be safe for future extensions), one solution would be to set as name of the attribute not the name of the enum class, but of the attribute.\n",
    "This would obfuscate a little bit the connection between the function signature and the value passed, but as you will see, this is quite clear to read anyway.\n",
    "\n",
    "let's assume that we want to put some other parameter, for example the shape of the corners of our square..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mclass:\u001b[0m\n",
       "    \u001b[0;34mcorners\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30mAn enumeration.\u001b[0m"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class CornerStyle(enum.Enum):\n",
    "    POINTY = 'pointy'\n",
    "    SQUARED = 'squared'\n",
    "    CURVED = 'curved'\n",
    "    \n",
    "def draw_square(corners=CornerStyle.SQUARED):\n",
    "    pass\n",
    "\n",
    "draw_square.corners = LineStyle\n",
    "\n",
    "dir(draw_square).public"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "and the call to the function would be something like:\n",
    "\n",
    "```python\n",
    "draw_square(corners=draw_square.corners.CURVED)\n",
    "```\n",
    "\n",
    "again, it is verbose, but can be shortened as shown before.\n",
    "It also have the advantage of showing explicitely the connection between the parameter and the values that it can take.\n",
    "\n",
    "Of course there can be a mixture of all the approaches, depending on the function at hand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Black Magic section\n",
    "\n",
    "this is not lecture topic, but some weird (somewhat useful) tricks that you might want to check out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## class registration with ABCMeta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "class PippoInterface(metaclass=abc.ABCMeta):\n",
    "    pass\n",
    "        \n",
    "@PippoInterface.register\n",
    "class Myclass:\n",
    "    def pippo(self):\n",
    "        pass\n",
    "\n",
    "obj = Myclass()\n",
    "assert issubclass(Myclass, PippoInterface)\n",
    "assert isinstance(obj, PippoInterface)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Classes bodies are code blocks\n",
    "\n",
    "Classes bodies are code blocks that get executed when the class is defined.\n",
    "\n",
    "This means that ny construct that one might want to employ is legitimate, including exotic ones such as conditional declaration.\n",
    "\n",
    "Albeit not very useful in global space classes, it is useful in some situations such as second order classes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm executing but not doing anything, with a value of 4\n"
     ]
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Temp:\n",
    "    a = 4\n",
    "    print(f\"I'm executing but not doing anything, with a value of {a}\")\n",
    "    del a\n",
    "dir(Temp).public"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:setting 'a' to 3\n"
     ]
    }
   ],
   "source": [
    "debug_mode = True\n",
    "import logging\n",
    "\n",
    "class Conditional:\n",
    "    if not debug_mode:\n",
    "        def __init__(self, a):\n",
    "            self.a = a\n",
    "    else:\n",
    "        def __init__(self, a):\n",
    "            self.a = a\n",
    "            logging.warning(\"setting 'a' to {}\".format(a))\n",
    "            \n",
    "myobj = Conditional(a=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "note that changing the value of `debug_mode` mode does not change the behavior of the class.\n",
    "\n",
    "The definition itself was conditional, now the behavior is determined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:setting 'a' to 3\n"
     ]
    }
   ],
   "source": [
    "debug_mode = False\n",
    "myobj = Conditional(a=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "note that there is a limitation: it is not possible to reference the class itself inside its definition.\n",
    "\n",
    "This is because the class name is bound to the namaspace only after the definition code has been run, and it does not exists beforehand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Uniform Calling Syntax\n",
    "\n",
    "Python does not normally support it, but nothing stops you from implementing it for some specific classes.\n",
    "\n",
    "You probably shouldn't, but hey, who's going to stop you?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import partial\n",
    "class DarkMagic:\n",
    "    def __getattr__(self, name):\n",
    "        func = eval(name) # dynamical resolution of the function name\n",
    "        if not callable(func):\n",
    "            raise TypeError(\"the requested dynamic attribute with name <{}> is not a function\".format(name))\n",
    "        return partial(func, self)\n",
    "    \n",
    "def hideous_function(self, b):\n",
    "    return self.a*b*2\n",
    "\n",
    "dark_beast = DarkMagic()\n",
    "dark_beast.a = 3\n",
    "dark_beast.hideous_function(b=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## secret attributes with unproper names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\u001b[0;35mproperty:\u001b[0m\n",
       "    \u001b[0;34m_secret 'a'\u001b[0m\n",
       "\u001b[0;35mspecial attribute:\u001b[0m\n",
       "    \u001b[0;34m__dict__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__doc__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__module__\u001b[0m\u001b[1;34m, \u001b[0m\u001b[0;34m__weakref__\u001b[0m\n",
       "\u001b[0;35mobject customization:\u001b[0m\n",
       "    \u001b[0;34m__init__\u001b[0m\n",
       "\u001b[0;35mdescriptor:\u001b[0m\n",
       "    \u001b[0;34ma\u001b[0m\u001b[0;34m: \u001b[0m\u001b[1;30m@property with getter\u001b[0m"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if you know what you're doing, you can do some weird ass stuff\n",
    "# like attributes with names that are not legitimate attribute names \n",
    "# and can't therefore be accessed with the dot operator\n",
    "class HiddenMagic:\n",
    "    def __init__(self, a):\n",
    "        setattr(self, \"_secret 'a'\", a)\n",
    "        \n",
    "    @property\n",
    "    def a(self):\n",
    "        return getattr(self, \"_secret 'a'\")\n",
    "        \n",
    "crazy_obj = HiddenMagic(3)\n",
    "print(crazy_obj.a)\n",
    "dir(crazy_obj).own"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## transparent wrapping objects relying attributes exploiting unproper names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2\n",
      "<__main__.Empty object at 0x7fbf54091860>\n"
     ]
    }
   ],
   "source": [
    "class Wrapper:\n",
    "    @classmethod\n",
    "    def unwrap(cls, obj):\n",
    "        return getattr(obj, \"_ other _ \")\n",
    "    \n",
    "    def __init__(self, other):\n",
    "        self.__dict__[\"_ other _ \"] = other\n",
    "        \n",
    "    def __getattr__(self, name):\n",
    "        other = getattr(self, \"_ other _ \")\n",
    "        return getattr(other, name)\n",
    "    \n",
    "    def __setattr__(self, name, value):\n",
    "        other = getattr(self, \"_ other _ \")\n",
    "        return setattr(other, name, value)\n",
    "    \n",
    "class Empty:\n",
    "    pass\n",
    "\n",
    "tipo = Empty()\n",
    "wrapped = Wrapper(tipo)\n",
    "wrapped.a = 2\n",
    "print(wrapped.a, tipo.a)\n",
    "print(Wrapper.unwrap(wrapped))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Dynamical class change of an instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm fabulous\""
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Worm:\n",
    "    def mutate(self):\n",
    "        self.__class__ = Butterfly\n",
    "        \n",
    "class Butterfly:\n",
    "    def describe(self):\n",
    "        return \"I'm fabulous\"\n",
    "\n",
    "beast = Worm()\n",
    "beast.mutate()\n",
    "beast.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Attributes with access logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "RWcounts(reads=2, writes=1)\n"
     ]
    }
   ],
   "source": [
    "# implements a count access for an attribute...this is terrible practices!\n",
    "# this can be done, but one might be better off using a Descriptor\n",
    "from collections import namedtuple\n",
    "rw_counts = namedtuple(\"RWcounts\", [\"reads\", \"writes\"])\n",
    "\n",
    "class AnotherWeirdo:\n",
    "    def __init__(self):\n",
    "        self._a = 0\n",
    "        self._a_readings = 0\n",
    "        self._a_writings = 0\n",
    "    \n",
    "    @property\n",
    "    def a(self):\n",
    "        self._a_readings += 1\n",
    "        return self._a\n",
    "    \n",
    "    @a.setter\n",
    "    def a(self, value):\n",
    "        self._a_writings += 1\n",
    "        self._a = value\n",
    "        \n",
    "    def get_access_stats(self):\n",
    "        return rw_counts(self._a_readings, self._a_writings)\n",
    "        \n",
    "weirdo = AnotherWeirdo()\n",
    "weirdo.a = 3\n",
    "print(weirdo.a)\n",
    "print(weirdo.a)\n",
    "print(weirdo.get_access_stats())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Calling interfaces (such as `pandas.Series.str`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e']\n",
      "['A', 'b', 'c', 'd', 'e']\n"
     ]
    }
   ],
   "source": [
    "# a map-calling interface similar to that of pandas' Series.str\n",
    "class MapInterface:\n",
    "    def __init__(self, target):\n",
    "        setattr(self, \"_ target _\", target)\n",
    "        \n",
    "    def __getattr__(self, function):\n",
    "        setattr(self, \"_ target function_\", function)\n",
    "        return self\n",
    "    \n",
    "    def __call__(self, *args, **kwargs):\n",
    "        target = getattr(self, \"_ target _\")\n",
    "        funcname = getattr(self, \"_ target function_\")\n",
    "        results = []\n",
    "        for item in target:\n",
    "            function = getattr(item, funcname)\n",
    "            result = function(*args, **kwargs)\n",
    "            results.append(result)\n",
    "        return MyList(results)\n",
    "            \n",
    "class MyList(list):\n",
    "    @property\n",
    "    def str(self):\n",
    "        return MapInterface(self)\n",
    "        \n",
    "mylist = MyList('abcde')\n",
    "print(mylist)\n",
    "print(mylist.str.replace('a', 'A'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## dynamical attribute resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "class MyEvilList(list):\n",
    "    def __getattr__(self, name):\n",
    "        base, cls = name.split('_')\n",
    "        assert base == 'getas'\n",
    "        cls = eval(cls)\n",
    "        return cls(iter(self))\n",
    "    \n",
    "a = MyEvilList([1, 2, 3])\n",
    "print(a.getas_tuple)\n",
    "print(a.getas_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## A sklearn class to perform column selection from a dataframe including columns operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'columns': ['a', 'e', 'abs(a)*exp(e)']}\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>a</th>\n",
       "      <th>e</th>\n",
       "      <th>abs(a)*exp(e)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.987063</td>\n",
       "      <td>0.307840</td>\n",
       "      <td>1.342883</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.817038</td>\n",
       "      <td>-1.034727</td>\n",
       "      <td>0.290312</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.143144</td>\n",
       "      <td>0.078301</td>\n",
       "      <td>0.154803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.307495</td>\n",
       "      <td>1.301436</td>\n",
       "      <td>8.479050</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.218387</td>\n",
       "      <td>-0.722837</td>\n",
       "      <td>0.105999</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          a         e  abs(a)*exp(e)\n",
       "0  0.987063  0.307840       1.342883\n",
       "1  0.817038 -1.034727       0.290312\n",
       "2  0.143144  0.078301       0.154803\n",
       "3  2.307495  1.301436       8.479050\n",
       "4 -0.218387 -0.722837       0.105999"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a class as the one used in the example, but that can parse generic formulas in the dataframe space using eval\n",
    "from dataclasses import dataclass\n",
    "from typing import List\n",
    "import pandas as pd\n",
    "\n",
    "@dataclass\n",
    "class ColumnSelector(BaseEstimator, TransformerMixin):\n",
    "    columns: List[str]\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        return self\n",
    "\n",
    "    def transform(self, X: pd.DataFrame):\n",
    "        new_series = {col: X.eval(col) for col in self.columns}\n",
    "        return pd.DataFrame(new_series)\n",
    "\n",
    "\n",
    "df = pd.DataFrame(rn.randn(100, 5), columns=list(\"abcde\"))\n",
    "            \n",
    "cs = ColumnSelector(columns=[\"a\", \"e\", \"abs(a)*exp(e)\"])\n",
    "print(cs.get_params())\n",
    "cs.fit_transform(df).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## write once attributes\n",
    "\n",
    "this class behave like a namespace where the variables can be instantiated with a value and never changed again (can change them internally, but their identity doesn't change)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "tried to rewrite an attribute!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-413-c9ed41df8539>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m4\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[0mnamespace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-413-c9ed41df8539>\u001b[0m in \u001b[0;36m__setattr__\u001b[0;34m(self, name, value)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"tried to rewrite an attribute!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m         \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: tried to rewrite an attribute!"
     ]
    }
   ],
   "source": [
    "class NameSpace:\n",
    "    def __init__(self, **kwargs):\n",
    "        for name, value in kwargs.items():\n",
    "            self.__setattr__(name, value)\n",
    "            \n",
    "    def __setattr__(self, name, value):\n",
    "        if hasattr(self, name):\n",
    "            raise AttributeError(\"tried to rewrite an attribute!\")\n",
    "        super().__setattr__(name, value)\n",
    "        \n",
    "namespace = NameSpace(a=4)\n",
    "namespace.b = 4\n",
    "assert namespace.a == 4 == namespace.b\n",
    "namespace.a = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## notes on subclassing\n",
    "* when you write a class try to make it eay to subclass! for example refer to `self.__class__` and `self.__class__.__name__` instead of specifically using the class and its name\n",
    "* the instance of `self` might not be the class you are writing right now, but one of its derived ones! keep things generic unless you need it!\n",
    "* this is true also for `super()`. it does not refer to the ancestor of the class you're writing, but to the ancestor of the object you're having as self, that might include some completely different classes.\n",
    "* subclassing is delegating work, so its the instance that have the complete control on what gets executed\n",
    "* try to focus all the violations of Liskov substitution principle in one (or very few methods) so that by overriding those you can have a fully functioning class that follow the principle as possible as it can\n",
    "* the open-closed principle: open to extension, closed to modification. when you subclass you should not break the unsedlying assumptions of the base class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Fluent Interface\n",
    "\n",
    "Fluent interfaces are a variant of object oriented interfaces where methods that act on the object without creating a new one returns the object itself rather than nothing.\n",
    "\n",
    "This allows to chain the methods in a semi-pipeline form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "class FluentNumber:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "        \n",
    "    def add(self, value):\n",
    "        self.value += value\n",
    "        return self\n",
    "    \n",
    "    def multiply(self, value):\n",
    "        self.value *= value\n",
    "        return self\n",
    "    \n",
    "number2 = FluentNumber(2)\n",
    "result = number2.add(3).multiply(2)\n",
    "print(result.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}