Notebooks/10_Decorators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python  \n",
    "\n",
    "### [Decorators](https://realpython.com/primer-on-python-decorators/)\n",
    "\n",
    "Decorators are functions that modify other functions’ behaviors without changing their core operations. As indicated by the name, decorators only decorate other functions.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions\n",
    "\n",
    "Before you can understand decorators, you must first understand how functions work. For our purposes, a function returns a value based on the given arguments. Here is a very simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_one(number):\n",
    "    return number + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_one(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### First-Class Objects\n",
    "\n",
    "In Python, functions are first-class objects. This means that functions can be passed around and used as arguments, just like any other object (string, int, float, list, and so on). Consider the following three functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_hello(name):\n",
    "    return f\"Hello {name}\"\n",
    "\n",
    "def be_awesome(name):\n",
    "    return f\"Yo {name}, together we are the awesomest!\"\n",
    "\n",
    "def greet_bob(greeter_func):\n",
    "    return greeter_func(\"Bob\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Bob'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet_bob(say_hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Yo Bob, together we are the awesomest!'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet_bob(be_awesome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inner Functions\n",
    "\n",
    "It’s possible to define functions inside other functions. Such functions are called inner functions. Here’s an example of a function with two inner functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parent():\n",
    "    print(\"Printing from the parent() function\")\n",
    "\n",
    "    def first_child():\n",
    "        print(\"Printing from the first_child() function\")\n",
    "\n",
    "    def second_child():\n",
    "        print(\"Printing from the second_child() function\")\n",
    "\n",
    "    second_child()\n",
    "    first_child()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing from the parent() function\n",
      "Printing from the second_child() function\n",
      "Printing from the first_child() function\n"
     ]
    }
   ],
   "source": [
    "parent()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Returning Functions From Functions\n",
    "\n",
    "Python also allows you to use functions as return values. The following example returns one of the inner functions from the outer parent() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parent(num):\n",
    "    def first_child():\n",
    "        return \"Hi, I am Emma\"\n",
    "\n",
    "    def second_child():\n",
    "        return \"Call me Liam\"\n",
    "\n",
    "    if num == 1:\n",
    "        return first_child\n",
    "    else:\n",
    "        return second_child"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function parent.<locals>.first_child at 0x7fd4a01f4bf8>\n",
      "<function parent.<locals>.second_child at 0x7fd4a01f4d08>\n"
     ]
    }
   ],
   "source": [
    "first = parent(1)\n",
    "second = parent(2)\n",
    "\n",
    "print(first)\n",
    "print(second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi, I am Emma'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Call me Liam'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simple Decorators\n",
    "\n",
    "Now that you’ve seen that functions are just like any other object in Python, you’re ready to move on and see the magical beast that is the Python decorator. Let’s start with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "def say_whee():\n",
    "    print(\"Whee!\")\n",
    "\n",
    "say_whee = my_decorator(say_whee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Something is happening before the function is called.\n",
      "Whee!\n",
      "Something is happening after the function is called.\n"
     ]
    }
   ],
   "source": [
    "say_whee()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Explanation  \n",
    "\n",
    "To understand what’s going on here, look back at the previous examples. We are literally just applying everything you have learned so far.\n",
    "\n",
    "The so-called decoration happens at the following line:\n",
    "\n",
    "say_whee = my_decorator(say_whee)\n",
    "\n",
    "In effect, the name say_whee now points to the wrapper() inner function. Remember that you return wrapper as a function when you call my_decorator(say_whee):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.my_decorator.<locals>.wrapper()>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_whee"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, wrapper() has a reference to the original say_whee() as func, and calls that function between the two calls to print().\n",
    "\n",
    "Put simply: decorators wrap a function, modifying its behavior.\n",
    "\n",
    "Before moving on, let’s have a look at a second example. Because wrapper() is a regular Python function, the way a decorator modifies a function can change dynamically. So as not to disturb your neighbors, the following example will only run the decorated code during the day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "def not_during_the_night(func):\n",
    "    def wrapper():\n",
    "        if 7 <= datetime.now().hour < 22:\n",
    "            func()\n",
    "        else:\n",
    "            pass  # Hush, the neighbors are asleep\n",
    "    return wrapper\n",
    "\n",
    "def say_whee():\n",
    "    print(\"Whee!\")\n",
    "\n",
    "say_whee = not_during_the_night(say_whee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Whee!\n"
     ]
    }
   ],
   "source": [
    "say_whee()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows you to use decorators in a simpler way with the @ symbol, sometimes called the “pie” syntax. The following example does the exact same thing as the first decorator example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_decorator(func):\n",
    "    def wrapper():\n",
    "        print(\"Something is happening before the function is called.\")\n",
    "        func()\n",
    "        print(\"Something is happening after the function is called.\")\n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "def say_whee():\n",
    "    print(\"Whee!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, @my_decorator is just an easier way of saying say_whee = my_decorator(say_whee). It’s how you apply a decorator to a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Whee!\n",
      "Whee!\n"
     ]
    }
   ],
   "source": [
    "#Create a file called decorators.py with the following content:\n",
    "\n",
    "def do_twice(func):\n",
    "    def wrapper_do_twice():\n",
    "        func()\n",
    "        func()\n",
    "    return wrapper_do_twice\n",
    "\n",
    "#from decorators import do_twice\n",
    "\n",
    "@do_twice\n",
    "def say_whee():\n",
    "    print(\"Whee!\")\n",
    "\n",
    "say_whee()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decorating Functions With Arguments\n",
    "\n",
    "Say that you have a function that accepts some arguments. Can you still decorate it? Let’s try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "@do_twice\n",
    "def greet(name):\n",
    "    print(f\"Hello {name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "wrapper_do_twice() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-eea630159444>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgreet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"World\"\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m#error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: wrapper_do_twice() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "greet(\"World\")  #error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem is that the inner function wrapper_do_twice() does not take any arguments, but name=\"World\" was passed to it. You could fix this by letting wrapper_do_twice() accept one argument, but then it would not work for the say_whee() function you created earlier.\n",
    "\n",
    "The solution is to use *args and **kwargs in the inner wrapper function. Then it will accept an arbitrary number of positional and keyword arguments. Rewrite decorators.py as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_twice(func):\n",
    "    def wrapper_do_twice(*args, **kwargs):\n",
    "        func(*args, **kwargs)\n",
    "        func(*args, **kwargs)\n",
    "    return wrapper_do_twice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "@do_twice\n",
    "def greet(name):\n",
    "    print(f\"Hello {name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The wrapper_do_twice() inner function now accepts any number of arguments and passes them on to the function it decorates. Now both your say_whee() and greet() examples works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Whee!\n",
      "Whee!\n"
     ]
    }
   ],
   "source": [
    "say_whee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "greet(\"World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning Values From Decorated Functions\n",
    "\n",
    "What happens to the return value of decorated functions? Well, that’s up to the decorator to decide. Let’s say you decorate a simple function as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "@do_twice\n",
    "def return_greeting(name):\n",
    "    print(\"Creating greeting\")\n",
    "    return f\"Hi {name}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating greeting\n",
      "Creating greeting\n"
     ]
    }
   ],
   "source": [
    "hi_adam = return_greeting(\"Adam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(hi_adam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oops, your decorator ate the return value from the function.\n",
    "\n",
    "Because the do_twice_wrapper() doesn’t explicitly return a value, the call return_greeting(\"Adam\") ended up returning None.\n",
    "\n",
    "To fix this, you need to make sure the wrapper function returns the return value of the decorated function. Change your decorator to:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_twice(func):\n",
    "    def wrapper_do_twice(*args, **kwargs):\n",
    "        func(*args, **kwargs)\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper_do_twice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "@do_twice\n",
    "def return_greeting(name):\n",
    "    print(\"Creating greeting\")\n",
    "    return f\"Hi {name}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating greeting\n",
      "Creating greeting\n",
      "Hi Adam\n"
     ]
    }
   ],
   "source": [
    "print(return_greeting(\"Adam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Who Are You, Really?\n",
    "\n",
    "A great convenience when working with Python, especially in the interactive shell, is its powerful introspection ability. Introspection is the ability of an object to know about its own attributes at runtime. For instance, a function knows its own name and documentation:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function print>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'print'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The introspection works for functions you define yourself as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.do_twice.<locals>.wrapper_do_twice()>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_whee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'wrapper_do_twice'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_whee.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, after being decorated, say_whee() has gotten very confused about its identity. It now reports being the wrapper_do_twice() inner function inside the do_twice() decorator. Although technically true, this is not very useful information.\n",
    "\n",
    "To fix this, decorators should use the @functools.wraps decorator, which will preserve information about the original function. Update your decorator again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "def do_twice(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper_do_twice(*args, **kwargs):\n",
    "        func(*args, **kwargs)\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper_do_twice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "@do_twice\n",
    "def say_whee():\n",
    "    print(\"Whee!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.say_whee()>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_whee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'say_whee'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say_whee.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function say_whee in module __main__:\n",
      "\n",
      "say_whee()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(say_whee)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The decorator template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "def decorator(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper_decorator(*args, **kwargs):\n",
    "        # Do something before\n",
    "        value = func(*args, **kwargs)\n",
    "        # Do something after\n",
    "        return value\n",
    "    return wrapper_decorator\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decorators with [Arguments](https://medium.com/better-programming/python-decorators-5-advanced-features-to-know-17dd9be7517b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from functools import wraps\n",
    "\n",
    "def logging_time(unit):\n",
    "    \"\"\"Decorator that logs time\"\"\"\n",
    "    def logger(func):\n",
    "        @wraps(func)\n",
    "        def inner_logger(*args, **kwargs):\n",
    "            \"\"\"Function that logs time\"\"\"\n",
    "            start = time.time()\n",
    "            func(*args, **kwargs)\n",
    "            scaling = 1000 if unit == \"ms\" else 1\n",
    "            print(f\"Calling {func.__name__}: {(time.time() - start) * scaling:.5f} {unit}\")\n",
    "        return inner_logger\n",
    "    return logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling calculate_sum_ms: 1.65248 ms\n",
      "Calling calculate_sum_s: 0.00175 s\n"
     ]
    }
   ],
   "source": [
    "@logging_time(\"ms\")\n",
    "def calculate_sum_ms(n):\n",
    "    \"\"\"Calculate sum of 0 to n-1\"\"\"\n",
    "    return sum(range(n))\n",
    "\n",
    "@logging_time(\"s\")\n",
    "def calculate_sum_s(n):\n",
    "    \"\"\"Calculate sum of 0 to n-1\"\"\"\n",
    "    return sum(range(n))\n",
    "\n",
    "calculate_sum_ms(100000)\n",
    "calculate_sum_s(100000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def repeat(func):\n",
    "    \"\"\"Decorator that repeats function call twice\"\"\"\n",
    "    def repeater(*args, **kwargs):\n",
    "        func(*args, **kwargs)\n",
    "        func(*args, **kwargs)\n",
    "    return repeater"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "@logging_time(\"ms\")\n",
    "@repeat\n",
    "def say_hi(whom):\n",
    "    print(f\"Hi, {whom}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "@repeat\n",
    "@logging_time(\"ms\")\n",
    "def say_hello(whom):\n",
    "    print(f\"Hello, {whom}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, John!\n",
      "Hi, John!\n",
      "Calling repeater: 0.14925 ms\n"
     ]
    }
   ],
   "source": [
    "say_hi(\"John\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Aaron!\n",
      "Calling say_hello: 0.07200 ms\n",
      "Hello, Aaron!\n",
      "Calling say_hello: 0.02909 ms\n"
     ]
    }
   ],
   "source": [
    "say_hello(\"Aaron\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class-Based decorators "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Repeat:\n",
    "    def __init__(self, n):\n",
    "        self.n = n\n",
    "\n",
    "    def __call__(self, func):\n",
    "        def repeater(*args, **kwargs):\n",
    "            for _ in range(self.n):\n",
    "                func(*args, **kwargs)\n",
    "        return repeater"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Repeat(n=2)\n",
    "def morning_greet(person):\n",
    "    print(f\"Good Morning, {person}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "@Repeat(n=3)\n",
    "def afternoon_greet(person):\n",
    "    print(f\"Good Afternoon, {person}!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good Morning, Jason!\n",
      "Good Morning, Jason!\n"
     ]
    }
   ],
   "source": [
    "morning_greet(\"Jason\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good Afternoon, Kelly!\n",
      "Good Afternoon, Kelly!\n",
      "Good Afternoon, Kelly!\n"
     ]
    }
   ],
   "source": [
    "afternoon_greet(\"Kelly\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Timing Functions\n",
    "\n",
    "Let’s start by creating a @timer decorator. It will measure the time a function takes to execute and print the duration to the console. Here’s the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timer(func):\n",
    "    \"\"\"Print the runtime of the decorated function\"\"\"\n",
    "    @functools.wraps(func)\n",
    "    def wrapper_timer(*args, **kwargs):\n",
    "        start_time = time.perf_counter()    # 1\n",
    "        value = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()      # 2\n",
    "        run_time = end_time - start_time    # 3\n",
    "        print(f\"Finished {func.__name__!r} in {run_time:.4f} secs\")\n",
    "        return value\n",
    "    return wrapper_timer\n",
    "\n",
    "@timer\n",
    "def waste_some_time(num_times):\n",
    "    for _ in range(num_times):\n",
    "        sum([i**2 for i in range(10000)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished 'waste_some_time' in 0.0026 secs\n"
     ]
    }
   ],
   "source": [
    "waste_some_time(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished 'waste_some_time' in 0.2757 secs\n"
     ]
    }
   ],
   "source": [
    "waste_some_time(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slowing Down Code\n",
    "\n",
    "This next example might not seem very useful. Why would you want to slow down your Python code? Probably the most common use case is that you want to rate-limit a function that continuously checks whether a resource—like a web page—has changed. The @slow_down decorator will sleep one second before it calls the decorated function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slow_down(func):\n",
    "    \"\"\"Sleep 1 second before calling the function\"\"\"\n",
    "    @functools.wraps(func)\n",
    "    def wrapper_slow_down(*args, **kwargs):\n",
    "        time.sleep(1)\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper_slow_down\n",
    "\n",
    "@slow_down\n",
    "def countdown(from_number):\n",
    "    if from_number < 1:\n",
    "        print(\"Liftoff!\")\n",
    "    else:\n",
    "        print(from_number)\n",
    "        countdown(from_number - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "Liftoff!\n"
     ]
    }
   ],
   "source": [
    "countdown(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Topics  \n",
    "\n",
    "<ul>\n",
    "<li><a href=\"#decorating-classes\">Decorators on classes</a></li>\n",
    "<li><a href=\"#nesting-decorators\">Several decorators on one function</a></li>\n",
    "<li><a href=\"#decorators-with-arguments\">Decorators with arguments</a></li>\n",
    "<li><a href=\"#both-please-but-never-mind-the-bread\">Decorators that can optionally take arguments</a></li>\n",
    "<li><a href=\"#stateful-decorators\">Stateful decorators</a></li>\n",
    "<li><a href=\"#classes-as-decorators\">Classes as decorators</a></li>\n",
    "</ul>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}