Decorator Taxonomy A-E PyTenn Slides.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from sys import getsizeof\n",
    "from datetime import datetime\n",
    "import sys, inspect, dis, asyncio\n",
    "from functools import wraps\n",
    "from unittest.mock import MagicMock\n",
    "import random\n",
    "\n",
    "jsonify= MagicMock()\n",
    "hybrid_property= MagicMock()\n",
    "pytest = MagicMock()\n",
    "Flask = MagicMock()\n",
    "cython = MagicMock()\n",
    "click = MagicMock()\n",
    "profilehooks = MagicMock()\n",
    "jit = MagicMock()\n",
    "numba = MagicMock()\n",
    "\n",
    "# file touch\n",
    "with open('hello_world.txt', 'a') as f:\n",
    "    pass\n",
    "\n",
    "def null_it(func):\n",
    "    \"\"\"Replace with no-op\"\"\"\n",
    "    def null(*args,**kwargs): pass\n",
    "    return null\n",
    "\n",
    "prepare = lambda:None\n",
    "cleanup = lambda:None\n",
    "expose = lambda x: lambda x: None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Taxonomy of Decorators: A-E\n",
    "\n",
    "Andy Fundinger, Senior Engineer\n",
    "\n",
    "PyTennessee 2019,\n",
    "February 10,\n",
    "Nashville, TN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction \n",
    "* Who I am\n",
    "* What is Bloomberg?\n",
    "* What is this talk?\n",
    "  - We use decorators, but when we go to talk about them, it's hard to get them into categories \n",
    "  - With a common terminology, we can discuss more easily\n",
    "* Who is this talk for?  \n",
    "  - Intermediate developers who can write decorators, but maybe aren't sure when and why\n",
    "  - Architects who may need to work across teams to implement and manage their design"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Decorator Syntax and Implementation \n",
    "\n",
    "Any decorator can be replaced with code in the decorated functions.  However, decorators allow this code to be reused and factored out of the functions.\n",
    "- Decorators without the @ sign\n",
    "- Function Decorators\n",
    "- Class Decorators\n",
    "- Decorators with arguments\n",
    "- Decorators written as classes\n",
    "\n",
    "Decorators generally insert a section of code of arbitrary complexity in a single line.  Debuggers generally skip over this code--for better or worse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic Syntax\n",
    "### Decorators without the @ sign\n",
    "\n",
    "The oldest decorators in Python are @staticmethod and @classmethod.  Dating back to Python 2.2, we used those like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Util(object):\n",
    "    def wibble():\n",
    "        print(\"Wobble\")\n",
    "    wibble = staticmethod(wibble)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The @ sign\n",
    "\n",
    "The @ sign was added in 2.4 as a syntactic sugar for this pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Util(object):\n",
    "    @staticmethod\n",
    "    def wibble():\n",
    "        print(\"Wobble\")\n",
    "    @null_it\n",
    "    def disabled():\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can write our own decorators as long as we accept a function and  return a replacement function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def null_it(func):\n",
    "    \"\"\"Replace with no-op\"\"\"\n",
    "    def null(*args,**kwargs): pass\n",
    "    return null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nonsense\n"
     ]
    }
   ],
   "source": [
    "class Printer(object):\n",
    "    @null_it\n",
    "    def printOut(self, stuff):\n",
    "        sys.stdout.write(stuff)\n",
    "    def print_out(self, stuff):\n",
    "        print(stuff)\n",
    "              \n",
    "Printer().print_out('Nonsense')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "Printer().printOut('something')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Class Decorators\n",
    "\n",
    "In Python 2.6, we can decorate classes too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@null_it\n",
    "class DeadClass:\n",
    "    pass\n",
    "\n",
    "DeadClass() is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### More advanced declarations\n",
    "\n",
    "#### @wraps - impersonate the orginal function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "HelloHello\n"
     ]
    }
   ],
   "source": [
    "from functools import wraps\n",
    "\n",
    "def double_arg1(func):\n",
    "    #@wraps(func)\n",
    "    def wrapper(arg_one,*args, **kwargs):\n",
    "        return func(arg_one*2, *args, **kwargs)\n",
    "    wrapper.__wrapped__ = func\n",
    "    wrapper.__module__ = func.__module__\n",
    "    wrapper.__doc__ = func.__doc__\n",
    "        \n",
    "    return wrapper \n",
    "\n",
    "@double_arg1\n",
    "def print_x(x):\n",
    "    print(x)\n",
    "    \n",
    "print_x(1)\n",
    "print_x('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.double_arg1.<locals>.wrapper>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print_x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Decorators with arguments \n",
    "\n",
    "Decorators with arguments aren't actually doing anything all that special.  They simply call the function with the arguments and __that__ function returns the actual decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Hello Hello Hello \n"
     ]
    }
   ],
   "source": [
    "def mult_arg(mult):\n",
    "    def deco(func):\n",
    "        def wrapper(arg_one):\n",
    "            return func(arg_one * mult)\n",
    "        return wrapper\n",
    "    return deco\n",
    "\n",
    "@mult_arg(3)\n",
    "def print_x(x):\n",
    "    print(x)\n",
    "    \n",
    "print_x(1)\n",
    "print_x('Hello ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Notice, this is two closures, one for the argument (mult) and one for the function (func).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Decorators written as classes\n",
    "\n",
    "Normally we write decorators that are closures, but there's no particular benefit to this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 30) {}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "class trace_it:\n",
    "    def __init__(self, func):\n",
    "        self.func = func\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        print(args, kwargs)\n",
    "        return self.func(*args, **kwargs)\n",
    "        \n",
    "@trace_it\n",
    "def rand(min_val, max_val):\n",
    "    return random.randint(min_val, max_val)\n",
    "rand(10,30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A - Argument Changing Decorators \n",
    "\n",
    "* add or remove an argument when the function is called\n",
    "* change the value or type of an argument at call time \n",
    "\n",
    "### Problems \n",
    "\n",
    "* calling the apparent signature does not actually work\n",
    "* calling a function for a test requires injecting data to drive the decorator properly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example:  [click.option()](https://click.palletsprojects.com/en/5.x/options/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "@click.command()\n",
    "@click.option('--n', default=1)\n",
    "def dots(n):\n",
    "    print('.' * n)\n",
    "               \n",
    "if __name__ == '__main__':\n",
    "    dots()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- adding the func name in the call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "self_aware: here\n"
     ]
    }
   ],
   "source": [
    "def fn_with_name(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        func(func.__name__,*args,**kwargs)\n",
    "    return wrapper\n",
    "        \n",
    "@fn_with_name\n",
    "def self_aware(name, oth):\n",
    "    print(f'{name}: {oth}')\n",
    "    \n",
    "self_aware('here')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Return Value Decorators\n",
    "* run the function \"normally\"\n",
    "* alter the output\n",
    "\n",
    "#### Example: [TurboGears @expose('json')](https://turbogears.readthedocs.io/en/latest/cookbook/jsonp.html#json-and-jsonp-rendering)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "@expose('json')\n",
    "def jp(self, **kwargs):\n",
    "    return dict(hello='World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- wrapping results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'process_1': ('stuff',), 'process_2': 'Constant Value'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def composable_result(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        return {func.__name__:func(*args,**kwargs)}\n",
    "    return wrapper\n",
    "        \n",
    "@composable_result\n",
    "def process_1(oth):\n",
    "    return (oth,)\n",
    "\n",
    "@composable_result\n",
    "def process_2():\n",
    "    return 'Constant Value'\n",
    "    \n",
    "results = {}\n",
    "results.update(process_1('stuff'))\n",
    "results.update(process_2())\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## B - Binding Decorators\n",
    "\n",
    "* implement the Descriptor Protocol to change how functions behave\n",
    "* the standard library includes @staticmethod, @classmethod, and @property\n",
    "\n",
    "### Problems\n",
    "\n",
    "* creates an alternative to instance methods and attributes\n",
    "* new language patterns arguably better fitting other languages \n",
    "* time shifts otherwise normal exceptions or introduces new ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example: SQLAlchemy Hybrid Properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Interval(object):\n",
    "    # ...\n",
    "    \n",
    "    @hybrid_property\n",
    "    def radius(self):\n",
    "        return abs(self.length) / 2\n",
    "\n",
    "    @radius.expression\n",
    "    def radius(cls):\n",
    "        return func.abs(cls.length) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\>>> i1.radius\n",
    "\n",
    "2\n",
    "\n",
    "\\>>> print Session().query(Interval).filter(Interval.radius > 5)\n",
    "\n",
    "SELECT interval.id AS interval_id, interval.start AS interval_start,\n",
    "    interval.\"end\" AS interval_end\n",
    "FROM interval\n",
    "WHERE abs(interval.\"end\" - interval.start) / :abs_1 > :param_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- instance method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class instance_method:\n",
    "    def __init__(self, func):\n",
    "        self.func = func\n",
    "    def __get__(self, inst, cls):\n",
    "        if inst is None:\n",
    "            raise TypeError(f'{self.func.__name__} is only valid on instances.')\n",
    "        return self.func.__get__(inst, cls)\n",
    "    \n",
    "class GoodClass:\n",
    "    @instance_method\n",
    "    def simple_method(self):\n",
    "        print('simple_method')\n",
    "    def normal_method(self):\n",
    "        print('normal_method')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normal_method\n",
      "simple_method\n"
     ]
    }
   ],
   "source": [
    "GoodClass().normal_method()\n",
    "GoodClass().simple_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "normal_method() missing 1 required positional argument: 'self'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-63f2a7128816>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGoodClass\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal_method\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[0;31mTypeError\u001b[0m: normal_method() missing 1 required positional argument: 'self'"
     ]
    }
   ],
   "source": [
    "GoodClass.normal_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "simple_method is only valid on instances.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-065d630c3609>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGoodClass\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimple_method\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[0;32m<ipython-input-17-53c5e8f52716>\u001b[0m in \u001b[0;36m__get__\u001b[0;34m(self, inst, cls)\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__get__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\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[0minst\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\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[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'{self.func.__name__} is only valid on instances.'\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;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__get__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\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;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: simple_method is only valid on instances."
     ]
    }
   ],
   "source": [
    "GoodClass.simple_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.GoodClass.normal_method>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GoodClass.normal_method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "simple_method is only valid on instances.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-5ffb98a5765b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGoodClass\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimple_method\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-17-53c5e8f52716>\u001b[0m in \u001b[0;36m__get__\u001b[0;34m(self, inst, cls)\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__get__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\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[0minst\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\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[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'{self.func.__name__} is only valid on instances.'\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;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__get__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\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;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: simple_method is only valid on instances."
     ]
    }
   ],
   "source": [
    "GoodClass.simple_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## C - Control Flow Decorators\n",
    "\n",
    "* change whether a function will be called and how many times\n",
    "\n",
    "### Problems\n",
    "\n",
    "* a predictable control flow now has a hidden conditional\n",
    "* a single invocation might now lead to 0, 1, or many executions of the function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example: Retry Decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Awesome sauce!\n"
     ]
    }
   ],
   "source": [
    "from retrying import retry\n",
    "\n",
    "@retry\n",
    "def do_something_unreliable():\n",
    "    if random.randint(0, 10) > 1:\n",
    "        raise IOError(\"Broken sauce, everything is hosed!!!111one\")\n",
    "    else:\n",
    "        return \"Awesome sauce!\"\n",
    "\n",
    "print(do_something_unreliable())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- infinite retry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid negative number -3\n",
      "Invalid negative number -13\n",
      "Invalid negative number -64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def infinite_retry(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        while True:\n",
    "            try:\n",
    "                return func(*args, **kwargs)\n",
    "            except RuntimeError as e:\n",
    "                print(e)\n",
    "    return wrapper\n",
    "\n",
    "@infinite_retry\n",
    "def random_fail(max_value):\n",
    "    ret = random.randint(-100, max_value)\n",
    "    if ret<0:\n",
    "        raise RuntimeError(\"Invalid negative number {ret}\".format(ret=ret))\n",
    "    return ret\n",
    "\n",
    "random_fail(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## D - Descriptive Decorators\n",
    "\n",
    "* add the decorated object to some sort of collection\n",
    "* this collection will serve some other purpose such as:\n",
    "  - documentation\n",
    "  - dispatching\n",
    "  - plugins\n",
    "\n",
    "### Problems \n",
    "\n",
    "* it's unclear how dispatching will be done as a result of registration\n",
    "* similarly it's hard to see where the registration is maintained"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example pytest.marks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "@pytest.mark.webtest\n",
    "def test_send_http():\n",
    "    pass # perform some webtest test for your app\n",
    "def test_something_quick():\n",
    "    pass\n",
    "def test_another():\n",
    "    pass\n",
    "class TestClass(object):\n",
    "    def test_method(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[afundinger decorator-taxonomy]$ pytest -m webtest\n",
    "\n",
    "\n",
    "collected 4 items\n",
    "\n",
    "\n",
    "test_example.py . \n",
    "\n",
    "[100%]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example:  flask.app.route"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "app = Flask(__name__)\n",
    "\n",
    "@app.route('/')\n",
    "def hello_world():\n",
    "    return 'Hello, World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- qa list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "to_qa=[]\n",
    "def qa(func):\n",
    "    to_qa.append(func.__name__)\n",
    "    return func\n",
    "\n",
    "@qa\n",
    "def new_code(): pass\n",
    "\n",
    "@qa\n",
    "def refactored_code(): pass\n",
    "\n",
    "def well_trusted_code(): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['new_code', 'refactored_code']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "to_qa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "new_code()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## E - Execution Decorators \n",
    "\n",
    "* reads the method/class code\n",
    "* may reinterpret the source code to basically not be python\n",
    "\n",
    "### Problems\n",
    "* many\n",
    "* and more\n",
    "\n",
    "This truly means that the code you wrote is changed--by the decorator--to some other code that is then executed.  It might:\n",
    "* be analyzed for dependencies\n",
    "* have objects in the ast swapped out, injected or removed\n",
    "* be recompiled with different rules "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example: numba"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "@numba.jit\n",
    "def f(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example implementation -- code replacer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def replacer(old, new):\n",
    "    def deco(func):\n",
    "        source = inspect.getsource(func.__code__)\n",
    "        lines = source.split('\\n')\n",
    "        new_source = lines[1]+'\\n'+('\\n'.join(lines[2:]).replace(old, new))\n",
    "        exec(new_source,globals())\n",
    "        return globals()[func.__name__]\n",
    "    return deco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample: 10\n"
     ]
    }
   ],
   "source": [
    "def sample(a, b):\n",
    "    x = a + b\n",
    "    y = x * 2\n",
    "    print('Sample: ' + str(y))\n",
    "sample(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample: 26\n"
     ]
    }
   ],
   "source": [
    "@replacer('b','b*3')\n",
    "def sample(a, b):\n",
    "    x = a + b\n",
    "    y = x * 2\n",
    "    print('Sample: ' + str(y))\n",
    "sample(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sa*3mple: 14\n"
     ]
    }
   ],
   "source": [
    "@replacer('a','a*3')\n",
    "def sample(a, b):\n",
    "    x = a + b\n",
    "    y = x * 2\n",
    "    print('Sample: ' + str(y))\n",
    "sample(1,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Other tools available for execution decorators\n",
    "\n",
    "* bytecode manipulation\n",
    "* ast manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "Our Taxonomy\n",
    "* Argument changing\n",
    "  - @pytest.mark.parametrize\n",
    "  - @flask.templated\n",
    "  - @django.views.decorators.gzip.gzip_page\n",
    "* Binding\n",
    "  - @variants.primary\n",
    "  - @pyramid.decorator.reify\n",
    "* Control flow\n",
    "  - @functools.lru_cache\n",
    "  - @django.views.decorators.http.require_http_methods\n",
    "  - @twisted.internet.defer.inlineCallbacks\n",
    "* Descriptive\n",
    "  - @numpy.testing.decorators.setastest\n",
    "* Execution\n",
    "  - @cython.locals\n",
    "* ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## W - Wrapping Decorators \n",
    "\n",
    "* just runs some code around a function call \n",
    "* doesn't affect our function at all\n",
    "* arguably best replaced with context managers\n",
    "\n",
    "### Problems\n",
    "\n",
    "* does so little that it is unlikely to actually remain in this category\n",
    "* forces code to be designed to have function boundaries at potentially unnatural locations just to allow the decorator to be used"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Example:  [profilehooks.timecall()](https://pypi.org/project/profilehooks/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@profilehooks.timecall       \n",
    "def my_function(args, etc):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "## Feedback Please\n",
    "* Pacing \n",
    "  - Syntax vs Examples\n",
    "  - Examples themselves\n",
    "* choice of examples\n",
    "  - Real world examples\n",
    "  - Example implementations\n",
    "  - Execution decorator example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "## Bytecode manipulation scratch work "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "sample.__code__.co_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "dis.dis(sample.__code__.co_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "source = inspect.getsource(sample.__code__)\n",
    "source"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "def sample(a, b):\n",
    "    x = a + b\n",
    "    y = x * 2\n",
    "    print('Sample: ' + str(y))\n",
    "sample(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "source = inspect.getsource(sample.__code__)\n",
    "source"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "lines = source.split('\\n')\n",
    "new_source = lines[0]+'\\n'+('\\n'.join(lines[1:]).replace('b','b*3'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "new_source"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "glb = globals()\n",
    "exec(new_source,glb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "glb['sample'](1,4), sample(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "outputs": [],
   "source": [
    "dis.dis(sample)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}