python-2/python2.5.notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# python 2.5\n",
    "- enum (finish from previous session)\n",
    "- pytest\n",
    "- typehints\n",
    "- mypy\n",
    "- let's download (python2.5.semaphore.py)[python2.5.semaphore.py]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# enum\n",
    "Quickly review from last session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<enum 'Colors'>\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(Colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Colors.red == Colors.green"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<Colors.red: 'red'>,\n",
       " <Colors.orange: 'orange'>,\n",
       " <Colors.green: 'green'>,\n",
       " <Colors.orangegreen: 'orangegreen'>]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(Colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Colors.red in Colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### (exercise)\n",
    "create `FlowerColors` and try yourself: `FlowerColors.red == Colors.red`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class FlowerColors(Enum):\n",
    "    red = 'red'\n",
    "\n",
    "FlowerColors.red == Colors.red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### auto values in Enums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<AnotherColors.red: 1>,\n",
       " <AnotherColors.orange: 2>,\n",
       " <AnotherColors.green: 3>,\n",
       " <AnotherColors.orangegreen: 4>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class AnotherColors(Enum):\n",
    "    red = auto()\n",
    "    orange = auto()\n",
    "    green = auto()\n",
    "    orangegreen = auto()\n",
    "\n",
    "list(AnotherColors)  # vs. list(Colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# typehints\n",
    "- `Map`: To annotate arguments it is preferred to use an abstract collection type such as Mapping.\n",
    "- `List`: To annotate arguments it is preferred to use an abstract collection type such as Sequence or Iterable.\n",
    "- note for generics https://docs.python.org/3/library/typing.html#generic-concrete-collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is output of 16 lines\n",
      "...m\n",
      "...i\n",
      "...c\n",
      "...k\n",
      "...a\n",
      "... \n",
      "...m\n",
      "...a\n",
      "...s\n",
      "...a\n",
      "... \n",
      "...m\n",
      "...i\n",
      "...r\n",
      "...e\n",
      "...k\n",
      "This is output of 3 lines\n",
      "...micka\n",
      "...masa\n",
      "...mirek\n"
     ]
    }
   ],
   "source": [
    "# %load python2.5.mypy.py\n",
    "from typing import List, Dict\n",
    "# def indent(size, content: List[str]):\n",
    "\n",
    "def indent(size, content):\n",
    "    print(f'This is output of {len(content)} lines')\n",
    "    for line in content:\n",
    "        print(size * '.' + line)\n",
    "\n",
    "\n",
    "indent(3, 'micka masa mirek')\n",
    "indent(3, 'micka masa mirek'.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "age\n",
      "2.5\n"
     ]
    }
   ],
   "source": [
    "#def indent_dict(content: List[Dict[str, int]]):\n",
    "def indent_dict(content):\n",
    "    for item in content:\n",
    "        for key, value in item.items():\n",
    "            print(key)\n",
    "            c = value / 2\n",
    "            print(c)\n",
    "\n",
    "\n",
    "dict_content = [\n",
    "    {'age': 5},\n",
    "    # vs {'age': '5'},  # notice str instead of int\n",
    "]\n",
    "\n",
    "indent_dict(dict_content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# mypy - static analysis types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting mypy\n",
      "  Downloading mypy-0.812-cp38-cp38-win_amd64.whl (7.8 MB)\n",
      "Collecting typed-ast<1.5.0,>=1.4.0\n",
      "  Downloading typed_ast-1.4.2-cp38-cp38-win_amd64.whl (158 kB)\n",
      "Collecting mypy-extensions<0.5.0,>=0.4.3\n",
      "  Using cached mypy_extensions-0.4.3-py2.py3-none-any.whl (4.5 kB)\n",
      "Collecting typing-extensions>=3.7.4\n",
      "  Using cached typing_extensions-3.7.4.3-py3-none-any.whl (22 kB)\n",
      "Installing collected packages: typed-ast, mypy-extensions, typing-extensions, mypy\n",
      "Successfully installed mypy-0.812 mypy-extensions-0.4.3 typed-ast-1.4.2 typing-extensions-3.7.4.3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: You are using pip version 20.2; however, version 21.0.1 is available.\n",
      "You should consider upgrading via the 'c:\\prace\\venv\\scripts\\python.exe -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "!pip install mypy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Success: no issues found in 1 source file\n"
     ]
    }
   ],
   "source": [
    "!mypy python2.4.mypy.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python2.4.mypy.py:4: error: Function is missing a type annotation\n",
      "python2.4.mypy.py:10: error: Call to untyped function \"indent\" in typed context\n",
      "python2.4.mypy.py:11: error: Call to untyped function \"indent\" in typed context\n",
      "python2.4.mypy.py:14: error: Function is missing a return type annotation\n",
      "Found 4 errors in 1 file (checked 1 source file)\n"
     ]
    }
   ],
   "source": [
    "!mypy --strict python2.4.mypy.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# test driven development (TDD)\n",
    "- write tests ahead of actual code\n",
    "- https://en.wikipedia.org/wiki/Test-driven_development#Test-driven_development_cycle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# how to test - case study\n",
    "\n",
    "Let's extend previous example from Street light to Traffic semaphore.\n",
    "\n",
    "Requirements:\n",
    "1. defined state after creation is `red`\n",
    "1. `change_status()` to move to another state\n",
    "1. `get_status()` to return current state\n",
    "1. `set_status(Colors.*)` to set current state by passing color from enum `Colors`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# semaphore.py\n",
    "from enum import Enum #, auto\n",
    "\n",
    "class Colors(Enum):\n",
    "    red = 'red'\n",
    "    orange = 'orange'\n",
    "    green = 'green'\n",
    "    orangered = 'orangered'\n",
    "\n",
    "\n",
    "class Semaphore:\n",
    "    sequence = [\n",
    "        Colors.red,\n",
    "        Colors.orangered,\n",
    "        Colors.green,\n",
    "        Colors.orange\n",
    "    ]\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.current_index = 0\n",
    "\n",
    "    def change_state(self):\n",
    "        self.current_index += 1\n",
    "    \n",
    "    def get_status(self):\n",
    "        return self.sequence[self.current_index]\n",
    "    \n",
    "    def set_status(self, status):\n",
    "        index = self.sequence.index(status)\n",
    "        self.current_index = index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Colors.red\n",
      "Colors.orangered\n",
      "Colors.green\n"
     ]
    }
   ],
   "source": [
    "sem = Semaphore()\n",
    "\n",
    "print(sem.get_status())\n",
    "\n",
    "sem.change_state()\n",
    "print(sem.get_status())\n",
    "\n",
    "sem.set_status(Colors.green)\n",
    "print(sem.get_status())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = sem.get_status()\n",
    "print('Status is ' + status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why we need test-runner?\n",
    "\n",
    "Naive test suite:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ok - init status is red\n",
      "fail - next status si NOT orangered\n"
     ]
    }
   ],
   "source": [
    "sem = Semaphore()\n",
    "\n",
    "status = sem.get_status()\n",
    "if status == Colors.red:\n",
    "    print('ok - init status is red')\n",
    "else:\n",
    "    print('fail - init statu si NOT red')\n",
    "\n",
    "\n",
    "sem.change_state()\n",
    "#status = sem.get_status()\n",
    "status = sem.change_state()\n",
    "if status == Colors.orangered:\n",
    "    print('ok - next status is orangered')\n",
    "else:\n",
    "    print('fail - next status si NOT orangered')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* condition no.0: tests has to exists\n",
    "* test each public method isn't ideal, better to test class behaviour as whole\n",
    "* writing tests are like experimenting in science, with difference you know correct result in advance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "recommendations with examples \\\n",
    "`>>>` [python2.5.testing.notes.ipynb](python2.5.testing.notes.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## mock\n",
    "\n",
    "- `MagicMock` is subclass `Mock` with default implementation of *magic methods* (not covered by this training yet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from unittest.mock import MagicMock\n",
    "\n",
    "m = MagicMock()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['assert_any_call',\n",
       " 'assert_called',\n",
       " 'assert_called_once',\n",
       " 'assert_called_once_with',\n",
       " 'assert_called_with',\n",
       " 'assert_has_calls',\n",
       " 'assert_not_called',\n",
       " 'attach_mock',\n",
       " 'call_args',\n",
       " 'call_args_list',\n",
       " 'call_count',\n",
       " 'called',\n",
       " 'configure_mock',\n",
       " 'method_calls',\n",
       " 'mock_add_spec',\n",
       " 'mock_calls',\n",
       " 'reset_mock',\n",
       " 'return_value',\n",
       " 'side_effect']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.return_value = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "value = m(a='aaa')\n",
    "print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, 1)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.called, m.call_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "call(a='aaa')"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.call_args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Colors.green: 'green'>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def iterate_to_green(sem):\n",
    "    sem.change_state()\n",
    "    sem.change_state()\n",
    "\n",
    "semaphore = Semaphore()\n",
    "iterate_to_green(semaphore)\n",
    "\n",
    "semaphore.get_status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[call.change_state(), call.change_state()]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "mock_sem = MagicMock()\n",
    "\n",
    "iterate_to_green(mock_sem)\n",
    "\n",
    "# mock_sem.change_state was not defined yet and still works\n",
    "print(mock_sem.method_calls)\n",
    "print(mock_sem.change_state.call_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### spy (with Mock/MagicMock)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "[call.change_state(), call.change_state()]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "semaphore = Semaphore()\n",
    "mock = MagicMock(wraps=semaphore)\n",
    "\n",
    "print(mock.change_state.call_count)\n",
    "\n",
    "iterate_to_green(mock)\n",
    "\n",
    "print(mock.method_calls)\n",
    "print(mock.change_state.call_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# pytest\n",
    "- `pytest` is **test runner**\n",
    "- test case as function\n",
    "- tests discovery\n",
    "- junit export\n",
    "- fixtures\n",
    "- better than builtin `unittests`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pytest in c:\\prace\\venv\\lib\\site-packages (5.4.3)\n",
      "Requirement already satisfied: pytest-mock in c:\\prace\\venv\\lib\\site-packages (3.2.0)\n",
      "Requirement already satisfied: packaging in c:\\prace\\venv\\lib\\site-packages (from pytest) (20.4)\n",
      "Requirement already satisfied: more-itertools>=4.0.0 in c:\\prace\\venv\\lib\\site-packages (from pytest) (8.4.0)\n",
      "Requirement already satisfied: wcwidth in c:\\prace\\venv\\lib\\site-packages (from pytest) (0.2.5)\n",
      "Requirement already satisfied: colorama; sys_platform == \"win32\" in c:\\prace\\venv\\lib\\site-packages (from pytest) (0.4.3)\n",
      "Requirement already satisfied: py>=1.5.0 in c:\\prace\\venv\\lib\\site-packages (from pytest) (1.9.0)\n",
      "Requirement already satisfied: atomicwrites>=1.0; sys_platform == \"win32\" in c:\\prace\\venv\\lib\\site-packages (from pytest) (1.4.0)\n",
      "Requirement already satisfied: attrs>=17.4.0 in c:\\prace\\venv\\lib\\site-packages (from pytest) (19.3.0)\n",
      "Requirement already satisfied: pluggy<1.0,>=0.12 in c:\\prace\\venv\\lib\\site-packages (from pytest) (0.13.1)\n",
      "Requirement already satisfied: six in c:\\prace\\venv\\lib\\site-packages (from packaging->pytest) (1.15.0)\n",
      "Requirement already satisfied: pyparsing>=2.0.2 in c:\\prace\\venv\\lib\\site-packages (from packaging->pytest) (2.4.7)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: You are using pip version 20.2; however, version 21.0.1 is available.\n",
      "You should consider upgrading via the 'c:\\prace\\venv\\scripts\\python.exe -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "!pip install pytest pytest-mock"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** figure out serveral tests (`def test_...(self): ...`)\\\n",
    "*type single `X` per each test case (as comment in Barevné lístečky)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 7 test cases so far...\n",
    "def test_initial_state_is_red(): ...\n",
    "def test_next_state_after_red(): ...\n",
    "def test_next_state_after_orangered(): ...\n",
    "def test_next_state_after_green(): ...\n",
    "def test_next_state_after_orange(): ...\n",
    "def test_full_cycle(): ...\n",
    "def test_set_invalid_color(): ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    "* `initial_state_is_red` is great\n",
    "* `next_state_after_red` is ok, better is to contain `_is_orangered`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* stdout is captured by default (`-s` to display anyway)\n",
    "* show verbose output (`-v`) with percents\n",
    "* `--lf` (`--last-failed`)\n",
    "* `--setup-plan` ("
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_initial_state_is_red():\n",
    "    sem = Semaphore()\n",
    "    assert sem.get_status() == Colors.red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* PyCharm integration\n",
    "    * **Run pytest in \\<filename\\>** from right click in editor\n",
    "    * execute single test case\n",
    "    * auto re-run tests after change (💗), also with minimized panel\n",
    "    * by default passed tests are hidden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fixtures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "from pytest import fixture\n",
    "\n",
    "@fixture\n",
    "def semaphore():\n",
    "    return Semaphore()\n",
    "\n",
    "@fixture\n",
    "def red_semaphore(semaphore):\n",
    "    semaphore.set_state(Colors.red)\n",
    "    return semaphore\n",
    "\n",
    "\n",
    "def test_red_sem(red_semaphore):\n",
    "    assert red_semaphore == Colors.red\n",
    "\n",
    "\n",
    "def test_change_from_red(red_semaphore):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## spy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test_spy.py\n",
    "class Clock:\n",
    "    def tick(self):\n",
    "        print('tick.')\n",
    "\n",
    "\n",
    "def test_one(mocker):\n",
    "    clock = Clock()\n",
    "    spy = mocker.spy(clock, 'tick')\n",
    "\n",
    "    # spy, not mocker\n",
    "    print(spy.call_count)\n",
    "\n",
    "    clock.tick()\n",
    "    clock.tick()\n",
    "\n",
    "    print(spy.call_count)\n",
    "    # print(dir(spy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### expecting exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytest import raises\n",
    "\n",
    "def test_exception():\n",
    "    with raises(Exception):\n",
    "        raise KeyError('this was not expected')\n",
    "        #raise Exception('this was not expected')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# own exception\n",
    "- https://docs.python.org/3/library/exceptions.html#exception-hierarchy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TrafficLightException(Exception):\n",
    "    ...\n",
    "\n",
    "    \n",
    "class TrafficLight:\n",
    "    ...\n",
    "    \n",
    "    def set_color(self, newcolor):\n",
    "        if new_color not in Color:\n",
    "            raise TrafficLightException"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<🐍>python code</🐍>\n",
      "Passed function looks like this: <function decorate_print at 0x00000168CC5FB820>\n"
     ]
    }
   ],
   "source": [
    "def decorate_print(msg):\n",
    "    print('<🐍>', end='')\n",
    "    print(msg, end='')\n",
    "    print('</🐍>')\n",
    "\n",
    "decorate_print('python code')\n",
    "\n",
    "def describe_function(fn):\n",
    "    print('Passed function looks like this:', fn)\n",
    "\n",
    "describe_function(decorate_print)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}