mypy_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Type annotations in Python: The mypy static type-checker\n",
    "\n",
    "The triggering situation for diving into type annotations and static type-checking was the following one:\n",
    " - an unclear/messy code,\n",
    " - inconvenient to read again after a break/difficult to remember subtle details,\n",
    " - unannotated/partially annotated code.\n",
    " \n",
    " The most common recommendation to tackle that kind of issues is to write DocStrings (in extenso documentation). But that \n",
    " solution is dissatisfying:\n",
    " - DocStrings are tedious to write and not so flexible, especially for early code versions \n",
    " which are are prone too (extensive) refactorization,\n",
    " - DocStrings are not very visual/readable, they have too much verbosity! That applies \n",
    " in particular as soon as many variables/parameters are used.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## What are type annotations?\n",
    "Python is a __dynamically-typed__ language. This means that the Python interpreter does type checking only as code runs,\n",
    "and that the type of a variable is allowed to change over its lifetime.\n",
    "Nevertheless, Python >= 3.0 allows type annotations (__standardized syntax__ for writing them described in __PEP 3107__):\n",
    "- __Function annotations__ are written directly in the code, but they are __optional__.\n",
    "They are __treated as comments__ at running time,\n",
    "- Function annotations are __purely arbitrary__: the user associates Python expressions with parts of the code,\n",
    "but __might not comply with the Python dynamically-set types__ at running time.\n",
    "Pseudo-grammar for annotating a function and its parameters: _identifier [: expression] [= expression]_\n",
    "\n",
    "Usually, information about annotations is accessible with the _annotations()_ method.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "arg is a required parameter for foo() with value:  bar\narg has type:  <class 'str'>\nkwarg is an optional parameter for foo() with value:  None\nkwarg has type:  <class 'NoneType'>\n\nAnnotations for the foo() function:\n {'arg': <class 'object'>, 'kwarg': <class 'object'>, 'return': None}\n"
     ],
     "output_type": "stream"
    }
   ],
   "source": [
    "def foo(arg: object, kwarg: object = None) -> None:\n",
    "    print('arg is a required parameter for foo() with value: ', arg)\n",
    "    print('arg has type: ', type(arg))\n",
    "    print('kwarg is an optional parameter for foo() with value: ', kwarg)\n",
    "    print('kwarg has type: ', type(kwarg))\n",
    "    \n",
    "foo('bar')\n",
    "print('\\nAnnotations for the foo() function:\\n', foo.__annotations__)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As from Python 3.5, the _typing_ library provides extended types for annotating the Python code.\n",
    "Annotations can be used for functions as well as for classes and objects. _typing_'s usage, when supported by \n",
    "the IDE, enables refined hinting functionality. As previously mentioned, the typing package does not introduce \n",
    "static typing of variables, but assigns arbitrary expressions. Those expressions re evaluated by the IDE \n",
    "in respect to the internal consistency of the package rules, which might not comply with the Python interpreter."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## What is static type-checking?\n",
    "Static type-checking is a Python-independant eparate process for assessing consistency of annotations, \n",
    "based on the provided _built-ins_ or _typing_ types given.\n",
    "One of the most mature project for applying static type-checking is the ___mypy___ project.\n",
    "MyPy acts same way as linter, it simply checks your program for type errors by looking at type annotations.\n",
    "So you pass your program to _mypy_ and you get error saying that you are passing invalid type to your function call.\n",
    "This enables early debugging, among others. For further comparison based on users' experiences, please have a look at: \n",
    "https://www.reddit.com/r/Python/comments/6i5dwo/mypy_good_or_bad/"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## How to get mypy?\n",
    "Mypy can be installed via the regular _pip_ way. Note that a configuaration file is recommended \n",
    "(at your code's root for example) in order to easily customize your imports and checking options.\n",
    "See teh official documentation: https://mypy.readthedocs.io/en/latest/"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Example of configuration file: mypy.ini"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# commands for running mypy on a regular Python file:\n",
    "\n",
    "# cd path/to/project\n",
    "# mypy mytuples.py\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "0"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 1
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "def my_tuple0(a: int, b: int, c:int) -> tuple:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple0(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple0.__annotations__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Equivalent to running _$ mypy mytuples.py_\n",
    "Returns error code 0 i.e. no type errors checked in the piece of code.\n",
    "NB: The code has not been read/interpreted/compiled with Python!\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "A tuple of int:  (4, 7, -5)\nType annotations of my_tuple function: \n {'a': <class 'int'>, 'b': <class 'int'>, 'c': <class 'int'>, 'return': <class 'tuple'>}\n"
     ],
     "output_type": "stream"
    }
   ],
   "source": [
    "def my_tuple0(a: int, b: int, c:int) -> tuple:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple0(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple0.__annotations__)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "For running the piece of code with Python, remove the _%%mypy_ magic function. \n",
    "Equivalent to running _$ python mytuples.py_ instead of _$ mypy mytuples.py_\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "\nType checking report:\n\n<string>:5: error: Incompatible return value type (got \"Tuple[int, ...]\", expected \"Tuple[int]\")\n\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 5
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import Tuple\n",
    "\n",
    "def my_tuple1(a: int, b: int, c:int) -> Tuple[int]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple1(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple1.__annotations__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Outputs error code 1 i.e. the mypy checking found potential type error(s).\n",
    "\n",
    "The are several ways to suppress that error:\n",
    "- comply with the suggestion returned by _mypy_,\n",
    "- use a local silencer, \n",
    "- modify the local options in the _mypy.ini_ configuration file. \n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "A tuple of int:  (4, 7, -5)\nType annotations of my_tuple function: \n {'a': <class 'int'>, 'b': <class 'int'>, 'c': <class 'int'>, 'return': typing.Tuple[int]}\n<class 'tuple'>\n"
     ],
     "output_type": "stream"
    }
   ],
   "source": [
    "from typing import Tuple\n",
    "\n",
    "def my_tuple1(a: int, b: int, c:int) -> Tuple[int]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple1(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple1.__annotations__)\n",
    "print(type(t47_5))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note here that even tagged with an error by _mypy_, the piece of code is Python-functional!\n",
    "Python assigns dynamically the 'tuple' built-in type to the output.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "0"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 7
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import Tuple, no_type_check\n",
    "\n",
    "@no_type_check\n",
    "def my_tuple1(a: int, b: int, c:int) -> Tuple[int]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple1(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple1.__annotations__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Here is how to locally silent the previous error by using a function decorator.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "0"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 10
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import Tuple\n",
    "\n",
    "def my_tuple2(a: int, b: int, c:int) -> Tuple[int, ...]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple2(4, 7, -5)\n",
    "print('A tuple of int: ', t47_5)\n",
    "print('Type annotations of my_tuple function: \\n', my_tuple2.__annotations__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Here is how to silent the previous error by following _mypy_ hints.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "How to get an idea about the types that will be inferred by _mypy_ when writing a function or a class?\n",
    "\n",
    "_mypy_ can understand two expressions for that purpose:\n",
    "* _reveal_type(obj)_,\n",
    "* _reveal_locals()_\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "\nType checking report:\n\n<string>:4: error: Function is missing a type annotation\n<string>:16: error: Revealed type is 'Any'\n<string>:17: error: Revealed type is 'builtins.tuple[builtins.int]'\n\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 11
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import Tuple\n",
    "\n",
    "def my_tuple3(a, b, c):\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "def my_tuple4(a:int, b:int, c:int) -> Tuple[int, ...]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple3(4, 7, -5)\n",
    "t47_8 = my_tuple4(4, 7, -8)\n",
    "\n",
    "# reveal_type(my_tuple3)  # underlined as error in Pycharm IDE!\n",
    "# reveal_type(my_tuple4)  # unresolved reference reveal_type\n",
    "\n",
    "reveal_type(t47_5)\n",
    "reveal_type(t47_8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'reveal_type' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-db685fb41788>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;31m# reveal_type(my_tuple4)  # unresolved reference reveal_type\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mreveal_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt47_5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0mreveal_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mt47_8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'reveal_type' is not defined"
     ]
    }
   ],
   "source": [
    "# Run Python now:\n",
    "from typing import Tuple\n",
    "\n",
    "def my_tuple3(a, b, c):\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "def my_tuple4(a:int, b:int, c:int) -> Tuple[int, ...]:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple3(4, 7, -5)\n",
    "t47_8 = my_tuple4(4, 7, -8)\n",
    "\n",
    "# reveal_type(my_tuple3)  # underlined as error in Pycharm IDE!\n",
    "# reveal_type(my_tuple4)  # unresolved reference reveal_type\n",
    "\n",
    "reveal_type(t47_5)\n",
    "reveal_type(t47_8)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "_reveal_type_ and _reveal_locals_ are only understood by mypy and don’t exist in Python.\n",
    "If you try to run your program, you’ll have to remove any reveal_type and reveal_locals calls\n",
    "before you can run your code.\n",
    "Both are always available and you don’t need to import them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Type checking report:\n",
      "\n",
      "<string>:7: error: Incompatible return value type (got \"Tuple[int, ...]\", expected \"mytupletype\")\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import NewType, Tuple\n",
    "\n",
    "# Here is an example on how to refine type annotation with typing\n",
    "mytupletype = NewType('mytupletype', Tuple[float, float, bool])\n",
    "\n",
    "def my_tuple4(a:int, b:int, c:int) -> mytupletype:\n",
    "    return tuple((a, b, c))\n",
    "\n",
    "t47_5 = my_tuple4(4, 7, -5)\n",
    "t47_0 = my_tuple4(4, 7, 0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "t47_5 outputs an error because -5 cannot be interpreted as a boolean, whereas\n",
    "t47_0 do not return any error.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import Any, TypeVar\n",
    "\n",
    "def definition_domain0(x: Any) -> None: \n",
    "    if type(x) == str:\n",
    "        print('x is defined by an alphabet')\n",
    "    elif type(x) == bool:\n",
    "        print('x tells the truth')\n",
    "    elif type(x) == int:\n",
    "        print('x is defined on |N')\n",
    "    elif type(x) == float:\n",
    "        print('x is defined on |R')\n",
    "    else:\n",
    "        print('What are you x?')\n",
    "        \n",
    "def definition_domain1(x: Any) -> Any: \n",
    "    if type(x) == str:\n",
    "        print('x is defined by an alphabet')\n",
    "    elif type(x) == bool:\n",
    "        print('x tells the truth')\n",
    "    elif type(x) == int:\n",
    "        print('x is defined on |N')\n",
    "    elif type(x) == float:\n",
    "        print('x is defined on |R')\n",
    "    else:\n",
    "        print('What are you x?')\n",
    "    return x\n",
    "\n",
    "x_int = 8\n",
    "x_bool = True\n",
    "x_float = -3.07\n",
    "x_str = 'å'\n",
    "x_func = lambda  x: str(x)\n",
    "\n",
    "\n",
    "y0 = definition_domain0(x_int)  # notified in Pycharm IDE\n",
    "\n",
    "y11 = definition_domain1(x_int)\n",
    "y12 = definition_domain1(x_str)\n",
    "y13 = definition_domain1(x_func)\n",
    "\n",
    "reveal_locals()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%mypy\n",
    "from typing import Any, TypeVar, Union\n",
    "       \n",
    "Choosable = TypeVar('Choosable', str, bool, int, float)  # user-defined type\n",
    "        \n",
    "def definition_domain2(x: Choosable) -> Choosable: \n",
    "    if type(x) == str:\n",
    "        print('x is defined by an alphabet')\n",
    "    elif type(x) == bool:\n",
    "        print('x tells the truth')\n",
    "    elif type(x) == int:\n",
    "        print('x is defined on |N')\n",
    "    elif type(x) == float:\n",
    "        print('x is defined on |R')\n",
    "    else:\n",
    "        pass\n",
    "    return x\n",
    "\n",
    "def definition_domain3(x: Union[str, bool, int, float]) -> Union[str, bool, int, float]: \n",
    "    if type(x) == str:\n",
    "        print('x is defined by an alphabet')\n",
    "    elif type(x) == bool:\n",
    "        print('x tells the truth')\n",
    "    elif type(x) == int:\n",
    "        print('x is defined on |N')\n",
    "    elif type(x) == float:\n",
    "        print('x is defined on |R')\n",
    "    else:\n",
    "        pass\n",
    "    return x\n",
    "\n",
    "x_int = 8\n",
    "x_bool = True\n",
    "x_float = -3.07\n",
    "x_str = 'å'\n",
    "x_func = lambda  x: str(x)\n",
    "\n",
    "y21 = definition_domain2(x_int)\n",
    "y22 = definition_domain2(x_str)\n",
    "y23 = definition_domain2(x_func)\n",
    "\n",
    "y31 = definition_domain3(x_int)\n",
    "y32 = definition_domain3(x_str)\n",
    "y33 = definition_domain3(x_func)\n",
    "\n",
    "reveal_locals()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%%mypy\n",
    "\n",
    "class Shadok(object):\n",
    "    def __init__(self, name: str) -> None:\n",
    "        self.name = name\n",
    "\n",
    "    def assign_task(self, state: str) -> None:\n",
    "        self.__setattr__('state', state)\n",
    "        print('Shadok {} is now {}'.format(repr(self.name), self.__getattribute__('state')))\n",
    "        \n",
    "s1 = Shadok('shadok1')\n",
    "print(s1.__dict__)\n",
    "print(s1.__annotations__) \n",
    "print('\\n')\n",
    "\n",
    "s1.assign_task('pumping')\n",
    "print(s1.__dict__)\n",
    "print(s1.__annotations__)\n",
    "print(Shadok.__init__.__annotations__)\n",
    "print('\\n')\n",
    "\n",
    "reveal_type(s1)\n",
    "reveal_type(s1.__class__)\n",
    "reveal_type(s1.name)\n",
    "reveal_type(s1.state)  # 'Shadok' has no attribute state\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "MyPy is able to infer the types of class attributes, but the result is not so relevant\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class Shadok(object):\n",
    "    def __init__(self, name: str) -> None:\n",
    "        self.name = name\n",
    "\n",
    "    def assign_task(self, state: str) -> None:\n",
    "        self.__setattr__('state', state)\n",
    "        print('Shadok {} is now {}'.format(repr(self.name), self.__getattribute__('state')))\n",
    "        \n",
    "s1 = Shadok('shadok1')\n",
    "print('s1.__dict__: ', s1.__dict__)\n",
    "# print(s1.__annotations__)  # s1 has no annotations! s1 is an instance\n",
    "# print(Shadock.__annotations__)  # Shadock has no annotations! Shadok is a class\n",
    "print('Shadok.__init__.__annotations__: ', Shadok.__init__.__annotations__)\n",
    "print('Shadok.assign_task.__annotations__: ', Shadok.assign_task.__annotations__)\n",
    "print('\\n')\n",
    "\n",
    "s1.assign_task('pumping')\n",
    "print('s1.__dict__: ', s1.__dict__) # 'Shadok' has an attribute state!\n",
    "# print('s1.name.__annotations__: ', s1.name.__annotations__) # AttributeError: 'str' object has no annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Only the functions are here annotated, not the instances\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create your own customized types\n",
    "For instance for my research projects, using genetic data encoded as genotypes:\n",
    "\n",
    "Genotypes formats, with R = reference allele = 0 and A = alternate allele = 1:\n",
    "\n",
    "| Genotype | GenotypeTrue (phased or unphased) | GenotypeLikelihoods (likelihoods of (RR, {RA,AR}, AA) |\n",
    "| :-: | :------------: | :-: |\n",
    "RR | 0\\|0 -> (0, 0, 1) or 0/0 -> (0, 0, 0) | (1, 0, 0) |\n",
    "RA | 0\\|1 -> (0, 1, 1) or 0/1 -> (0, 1, 0) | (0, 1, 0)\n",
    "AR | 1\\|0 -> (1, 0, 1) or 1/0 -> (1, 0, 0) | (0, 1, 0)\n",
    "AA | 1\\|1 -> (1, 1, 1) or 1/1 -> (1, 1, 0) | (0, 0, 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import NewType, List\n",
    "\n",
    "GL = NewType('GenotypeLikelihoods', Tuple[float, float, float]) \n",
    "GT = NewType('GenotypeTrue', Tuple[int, int, bool])\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": false,
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "\nType checking report:\n\n<string>:4: error: Argument 2 to NewType(...) must be subclassable (got \"Any\")\n<string>:4: error: Name 'Tuple' is not defined\n<string>:5: error: Argument 2 to NewType(...) must be subclassable (got \"Any\")\n<string>:5: error: Name 'Tuple' is not defined\n\n"
     ],
     "output_type": "stream"
    },
    {
     "data": {
      "text/plain": "1"
     },
     "metadata": {},
     "output_type": "execute_result",
     "execution_count": 7
    }
   ],
   "source": [
    "%%mypy\n",
    "\n",
    "from typing import NewType, List\n",
    "\n",
    "GLtype = NewType('GLtype', Tuple[float, float, float])\n",
    "GTtype = NewType('GTtype', Tuple[int, int, bool])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "text": [
      "/home/camille/PycharmProjects\nNone\n"
     ],
     "output_type": "stream"
    }
   ],
   "source": [
    "# %%mypy\n",
    "\n",
    "# Customize the str type for typing files paths:\n",
    "from pathlib import Path\n",
    "from os import PathLike\n",
    "from typing import NewType, Union\n",
    "\n",
    "FilePath = NewType('FilePath', Union[Path, PathLike])\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n",
     "is_executing": false
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "References/further information:\n",
    "\n",
    "- https://docs.python.org/3/reference/compound_stmts.html#function\n",
    "- https://docs.python.org/3/glossary.html#term-function-annotation\n",
    "- https://www.python.org/dev/peps/pep-3107/\n",
    "- https://docs.python.org/3/library/typing.html\n",
    "- https://mypy.readthedocs.io/en/latest/index.html\n",
    "- https://realpython.com/python-type-checking\n",
    "- https://switowski.com/python/ipython/2019/02/15/creating-magic-functions-part3.html\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PyCharm (PhDCircus)",
   "language": "python",
   "name": "pycharm-eba737b5"
  },
  "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.5"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}