20-CodeProjects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Course Announcements**\n",
    "\n",
    "Due Dates:\n",
    "- A5 due Monday (5/31)\n",
    "- Final Project/Exam (Fri 6/11 at 11:59 PM)\n",
    "    - Exam: will have >= 48h to complete\n",
    "    \n",
    "Notes:\n",
    "- Please fill out your CAPEs (+1% if >=85% response rate)\n",
    "- No lecture/OH on Monday (Memorial Day)\n",
    "- No OH for staff during Finals Week (Prof Ellis will have some; details TBD)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Q&A**\n",
    "\n",
    "Q: what does a `list(input_string)` do?  \n",
    "A: This \"typecasts\" `input_string` (a string) to be a list. Typecasting specifies the type the variable should be. Here it's converting/typecasting a string to a list. To see an example of what this means, try `list('hello')`. \n",
    "\n",
    "Q: What's the difference between documentation and pseudocode?  \n",
    "A: Psuedocode is for you as you're trying to plan/think through your code. It isn't meant for or to be read by others. Docstrings are for users of your code to know how to use your code. Comments in your code are for people who may be reading your code and want to understand your thinking. Sometimes pseudocode comments can be helpful comments, but other times, it's best to delete your pseudocode if it doesn't guide a reader's understanding.\n",
    "\n",
    "Q: What resources can we use to make sure we follow good documentation and code style?  \n",
    "A: [PEP8](https://www.python.org/dev/peps/pep-0008/) for code style; [numpy docstrings documentation](https://numpydoc.readthedocs.io/en/latest/format.html) for docstrings\n",
    "\n",
    "Q: Are numpy docstring the only type of docstrings? if not, why would we choose numpy docstring style over the others?  \n",
    "A: Nope - there are others. We choose this style b/c 1) it's popular and used by many and 2) it integrates well with a lot of documentation tools. Feel free to google sphinx to see what I mean! \n",
    "\n",
    "Q: Do we need to write an explanation for each line of code that we write?  \n",
    "A: No. You should avoid this. This would make your code *less* readable.\n",
    "\n",
    "Q: Why is documentation an important thing to incorporate in your code?  \n",
    "A: It's the best way to communicate to others how to use your code. If, during CL8 or A5 you've googled how to use a function/method from `pandas`/`numpy`, you've benefitted from someone writing documentation!\n",
    "\n",
    "Q: \"When I ran `!pip show lisc` in my datahub, it said that \"\"WARNING: Package(s) not found: lisc\"\"\n",
    "Why is this happened? (this is the last line of code in today's notebook)\"  \n",
    "A: You would have to install this first:  `pip install --user lisc` first.\n",
    "\n",
    "Q: When are major updates needed? Why isn't it always minor?  \n",
    "A: B/c sometimes you re-think your approach and update/change your code base. A major change is then needed. Feel free to look up differences between Python 2 and Python 3 - so many changes...for the better!\n",
    "\n",
    "Q: If there are multiple docstrings in a notebook, how are they specified and accessed through the '__doc__'  attribute?  \n",
    "A: The attribute is attached to the object, so what comes before `__doc__` will specify which docstring you want to pull up.\n",
    "\n",
    "Q: How to read the documentation of some packages, they still can be really confusing at times and I usually prefer looking at examples/tutorials rather than reading the documentation.  \n",
    "A: That's OK! Examples/tutorials are a great place to start. I'd suggest doing the example/tutorial first and then look back at the documentation. Reading documentation is a skill, but a handy/helpful one, so I encourage you to look at the documentation after the example, once you have a sense of what it's doing to practice/hone this skill.\n",
    "\n",
    "Q: Are docstrings automatically stored in `__doc__` through the double quotation marks?  \n",
    "A: Yup!\n",
    "\n",
    "Q: Where to put docstrings. I have a class with methods for my final project. I know I'd put a docstring under the class but do I have to put one for each of my methods as well?  \n",
    "A: Yup - ideally each method would have one. Now, if your methods only included `print()` statements, you could omit the docstrings there, but if they're carrying out operations, best to document. We'll be looking to see you have at least 3 docstrings in your project."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Code Projects\n",
    "\n",
    "- modular design\n",
    "- minimal viable product\n",
    "- test-driven development\n",
    "- rapid prototyping\n",
    "- project organization\n",
    "- refactoring\n",
    "- code review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Project Check-In\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Modular Design"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Modular design, like modular programming, is the approach of designing and building things as independent modules. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Minimal Viable Product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "A 'minimal viable product' is a product that contains the minimum amount of implemented features to use the code product - no more, no less.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Test-Driven Development"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Writing the tests as soon as you have a plan & before you've written the code.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Rapid Prototyping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Rapid prototyping is an approach for developing things in which you work on minimal prototypes and iterate on them quickly. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "#### Some examples\n",
    "\n",
    "- Chatbot: start and end a chat\n",
    "- Data Analysis: read a dataset in, make a basic plot\n",
    "- Car Inventory: object with method that adds a car to the Inventory\n",
    "- Artificial Agents: simple bot moves around randomly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Project Organization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- **Notebooks**: good for interactive development\n",
    "    - For when seeing the inputs and outputs of code running needs to be seen start to finish\n",
    "    - file ends in `.ipynb`\n",
    "- **Modules**: for storing mature Python code, that you can import\n",
    "    - you don't *use* the functions in there, just define them\n",
    "    - file ends in `.py`\n",
    "- **Scripts**: a Python file for executing a particular task\n",
    "    - this takes an input and does something start to finish\n",
    "    - file ends in `.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Project Workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Typical project workflow:\n",
    "\n",
    "- Develop plan and write tests\n",
    "- Develop code interactively in a Jupyter notebook/text editor\n",
    "- As functions & classes become mature, move them to Python files that you then `import`\n",
    "    - As you do so, go back through them to check for code style, add documentation, and run your code tests\n",
    "- At the end of a project, (maybe) write a standalone script that runs the project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Project Notes\n",
    "\n",
    "1. Design and write tests\n",
    "2. Write some code\n",
    "2. Test to make sure it works\n",
    "3. Check code style (naming, spacing, etc.)\n",
    "4. Add documentation\n",
    "5. Move to module (if necessary)\n",
    "6. Run all tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Project Design\n",
    "\n",
    "- Idea: atbash encryption: return the capitalized, reverse alphabetical letter for each character in the input string\n",
    "\n",
    "- Design:\n",
    "    - `atbash_encrypt()` : take input string and return atbash encrypted string\n",
    "        - inputs: `input_string` \n",
    "        - returns: `atbash_string`\n",
    "    - `atbash_decrypt()` : take encrypted string and decrypt using atbash\n",
    "        - inputs: `atbash_string`\n",
    "        - returns: `decrypted_string`\n",
    "    - `atbash_wrapper()` : does either of the above, as specified with input parameter\n",
    "        - inputs: `input_string`, `method` (either 'encrypt' or 'decrypt', default: 'encrypt')\n",
    "        - returns `output_string`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Adding Unit Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def test_atbash_encrypt():\n",
    "    assert callable(atbash_encrypt)\n",
    "    assert isinstance(atbash_encrypt('hello'), str)\n",
    "    assert atbash_encrypt('HELLO') == 'SVOOL'\n",
    "    assert atbash_encrypt('hello') == 'SVOOL'\n",
    "    \n",
    "def test_atbash_decrypt():\n",
    "    assert callable(atbash_decrypt)\n",
    "    assert isinstance(atbash_decrypt('hello'), str)\n",
    "    assert atbash_decrypt('SVOOL') == 'HELLO'\n",
    "    assert atbash_decrypt('svool') == 'HELLO'\n",
    "\n",
    "def test_atbash_wrapper():\n",
    "    assert callable(atbash_wrapper)\n",
    "    assert isinstance(atbash_wrapper('hello', method='encrypt'), str)\n",
    "    assert atbash_wrapper('hello', method='encrypt') == 'SVOOL'\n",
    "    assert atbash_wrapper('HELLO', method='encrypt') == 'SVOOL'\n",
    "    assert atbash_wrapper('SVOOL', method='decrypt') == 'HELLO'\n",
    "    assert atbash_wrapper('svool', method='decrypt') == 'HELLO'\n",
    "    assert atbash_wrapper('svool', method='blargh') == \"method should be either 'decrypt' or 'encrypt'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "...move to test file\n",
    "\n",
    "...will uncomment as I write the code/functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Writing Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "#### `atbash_encrypt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hello'.find('e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def atbash_encrypt(input_string):\n",
    "    alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "    reverse_alpha = 'ZYXWVUTSRQPONMLKJIHGFEDCBA'\n",
    "\n",
    "    atbash_string = ''\n",
    "\n",
    "    for char in input_string:\n",
    "        char = char.upper()\n",
    "        if char in alpha:\n",
    "            position = alpha.find(char)\n",
    "            atbash_string += reverse_alpha[position]\n",
    "        else:\n",
    "            atbash_string = None\n",
    "            break\n",
    "        \n",
    "    return atbash_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# smoke test\n",
    "atbash_encrypt('!!!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Moving to a module...\n",
    "\n",
    "- consider imports at the top"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Note on `imports`: If you want to be able to use modules (imports) within a module/script, be sure to import it at the top. This applies to test files as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atbash as ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SVOOL'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ab.atbash_encrypt('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.7.7, pytest-6.1.2, py-1.9.0, pluggy-0.13.1\n",
      "rootdir: /Users/shannonellis/Desktop/Teaching/COGS18/LectureNotes-Sp21-Bardolph\n",
      "collected 1 item                                                               \u001b[0m\n",
      "\n",
      "test_atbash.py \u001b[32m.\u001b[0m\u001b[32m                                                         [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m============================== \u001b[32m\u001b[1m1 passed\u001b[0m\u001b[32m in 0.03s\u001b[0m\u001b[32m ===============================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pytest test_atbash.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### `atbash_decrypt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# reminder: consider code style! \n",
    "def atbash_decrypt(atbash_string):    \n",
    "    ALPHA='ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "    REVERSEALPHA='ZYXWVUTSRQPONMLKJIHGFEDCBA'\n",
    "    atbash_string=atbash_string.upper()\n",
    "    decrypted_string=''\n",
    "    for l in atbash_string:\n",
    "        if l in REVERSEALPHA:\n",
    "            letterindex=REVERSEALPHA.find(l)\n",
    "            decrypted_string=decrypted_string+ALPHA [letterindex]\n",
    "        else: decrypted_string=decrypted_string+l\n",
    "    return decrypted_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# smoke test\n",
    "atbash_decrypt('SVOOL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\r\n",
      "platform darwin -- Python 3.7.7, pytest-6.1.2, py-1.9.0, pluggy-0.13.1\r\n",
      "rootdir: /Users/shannonellis/Desktop/Teaching/COGS18/LectureNotes-Sp21-Bardolph\r\n",
      "\u001b[1mcollecting ... \u001b[0m\u001b[1m\r",
      "collected 2 items                                                              \u001b[0m\r\n",
      "\r\n",
      "test_atbash.py \u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m                                                        [100%]\u001b[0m\r\n",
      "\r\n",
      "\u001b[32m============================== \u001b[32m\u001b[1m2 passed\u001b[0m\u001b[32m in 0.02s\u001b[0m\u001b[32m ===============================\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "!pytest test_atbash.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### `atbash_wrapper`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def atbash_wrapper(input_string, method='encrypt'):\n",
    "    \n",
    "    if method == 'encrypt':\n",
    "        output_string = atbash_encrypt(input_string)\n",
    "    elif method == 'decrypt':\n",
    "        output_string = atbash_decrypt(input_string)\n",
    "    else:\n",
    "        output_string = \"method should be either 'decrypt' or 'encrypt'\"\n",
    "    \n",
    "    return output_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"method should be either 'decrypt' or 'encrypt'\""
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# smoke test\n",
    "atbash_wrapper('svool', method='aslfsdklj')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "************* Module atbash\n",
      "atbash.py:44:0: C0305: Trailing newlines (trailing-newlines)\n",
      "atbash.py:1:0: C0114: Missing module docstring (missing-module-docstring)\n",
      "atbash.py:1:0: C0116: Missing function or method docstring (missing-function-docstring)\n",
      "atbash.py:18:0: C0116: Missing function or method docstring (missing-function-docstring)\n",
      "atbash.py:34:0: C0116: Missing function or method docstring (missing-function-docstring)\n",
      "\n",
      "------------------------------------------------------------------\n",
      "Your code has been rated at 8.33/10 (previous run: 8.70/10, -0.36)\n",
      "\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pylint atbash.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m============================= test session starts ==============================\u001b[0m\n",
      "platform darwin -- Python 3.7.7, pytest-6.1.2, py-1.9.0, pluggy-0.13.1\n",
      "rootdir: /Users/shannonellis/Desktop/Teaching/COGS18/LectureNotes-Sp21-Bardolph\n",
      "collected 3 items                                                              \u001b[0m\n",
      "\n",
      "test_atbash.py \u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\u001b[32m                                                       [100%]\u001b[0m\n",
      "\n",
      "\u001b[32m============================== \u001b[32m\u001b[1m3 passed\u001b[0m\u001b[32m in 0.04s\u001b[0m\u001b[32m ===============================\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pytest test_atbash.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Documentation\n",
    "\n",
    "- Code in final project/exam requires:\n",
    "    - numpy-style docstrings\n",
    "    - code comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Putting it all together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from atbash import atbash_wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SVOOL'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# carry out atbash encryption by default\n",
    "atbash_wrapper('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# carry out atbash decryption\n",
    "atbash_wrapper('svool', method='decrypt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"method should be either 'decrypt' or 'encrypt'\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# gives appropriate response if incorrect method provided\n",
    "atbash_wrapper('hello', method='blargh')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**atbash improvements**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import atbash as ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SVOOL'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ab.atbash_encrypt('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SVOOL'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ab.atbash_decrypt('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Refactoring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Refactoring is the process of restructuring existing computer code, without changing its external behaviour. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Think of this as restructuring and final edits on your essay. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Nesting Functions** - If you have a whole bunch of functions, if statements, and for/while loops together within a single function, you probably want (need?) to refactor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Clean functions accomplish a **single task**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**DRY**: Don't Repeat Yourself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Refactoring Example: Chatbot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import random \n",
    "\n",
    "def have_a_chat():\n",
    "    \"\"\"Main function to run our chatbot.\"\"\"\n",
    "    \n",
    "    chat = True\n",
    "\n",
    "    while chat:\n",
    "\n",
    "        # Get a message from the user\n",
    "        msg = input('INPUT :\\t')\n",
    "        out_msg = None\n",
    "        \n",
    "        # Check if the input is a question\n",
    "        input_string = msg\n",
    "        if '?' in input_string:\n",
    "            question = True\n",
    "        else:\n",
    "            question = False\n",
    "\n",
    "        # Check for an end msg \n",
    "        if 'quit' in input_string:\n",
    "            out_msg = 'Bye!'\n",
    "            chat = False\n",
    "            \n",
    "        # If we don't have an output yet, but the input was a question, \n",
    "        # return msg related to it being a question\n",
    "        if not out_msg and question:\n",
    "            out_msg = \"I'm too shy to answer questions. What do you want to talk about?\"\n",
    "\n",
    "        # Catch-all to say something if msg not caught & processed so far\n",
    "        if not out_msg:\n",
    "            out_msg = random.choice(['Good.', 'Okay', 'Huh?', 'Yeah!', 'Thanks!'])\n",
    "\n",
    "        print('OUTPUT:', out_msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT :\thi\n",
      "OUTPUT: Huh?\n",
      "INPUT :\thow are you?\n",
      "OUTPUT: I'm too shy to answer questions. What do you want to talk about?\n",
      "INPUT :\tschool\n",
      "OUTPUT: Good.\n",
      "INPUT :\tok\n",
      "OUTPUT: Good.\n",
      "INPUT :\tquit\n",
      "OUTPUT: Bye!\n"
     ]
    }
   ],
   "source": [
    "have_a_chat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Refactored Example: Chatbot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What this function does:\n",
    "\n",
    "1. takes an input\n",
    "2. checks if input is a question\n",
    "3. checks if input is supposed to end the chat\n",
    "4. return appropriate response if question, end chat, or other\n",
    "\n",
    "That's four different things! Functions should do a single thing..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def get_input():\n",
    "    \"\"\"ask user for an input message\"\"\"\n",
    "    \n",
    "    msg = input('INPUT :\\t')\n",
    "    out_msg = None\n",
    "    \n",
    "    return msg, out_msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def is_question(input_string):\n",
    "    \"\"\"determine if input from user is a question\"\"\"\n",
    "    \n",
    "    if '?' in input_string:\n",
    "        output = True\n",
    "    else:\n",
    "        output = False\n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def end_chat(input_list):\n",
    "    \"\"\"identify if user says 'quit' in input and end chat\"\"\"\n",
    "    \n",
    "    if 'quit' in input_list:\n",
    "        output = 'Bye'\n",
    "        chat = False\n",
    "    else:\n",
    "        output = None\n",
    "        chat = True\n",
    "        \n",
    "    return output, chat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def return_message(out_msg, question):\n",
    "    \"\"\"generic responses for the chatbot to return\"\"\"\n",
    "        \n",
    "    # If we don't have an output yet, but the input was a question, \n",
    "    # return msg related to it being a question\n",
    "    if not out_msg and question:\n",
    "        out_msg = \"I'm too shy to answer questions. What do you want to talk about?\"\n",
    "\n",
    "    # Catch-all to say something if msg not caught & processed so far\n",
    "    if not out_msg:\n",
    "        out_msg = random.choice(['Good.', 'Okay', 'Huh?', 'Yeah!', 'Thanks!'])\n",
    "        \n",
    "    return out_msg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def have_a_chat():\n",
    "    \"\"\"Main function to run our chatbot.\"\"\"\n",
    "    \n",
    "    chat = True\n",
    "\n",
    "    while chat:\n",
    "\n",
    "        # Get input message from the user\n",
    "        msg, out_msg = get_input()\n",
    "        \n",
    "        # Check if the input is a question\n",
    "        question = is_question(msg)\n",
    "         \n",
    "        # Check for an end msg \n",
    "        out_msg, chat = end_chat(msg)\n",
    "       \n",
    "        # specify what to return\n",
    "        out_msg = return_message(out_msg = out_msg, question = question)\n",
    "        \n",
    "        print('OUTPUT:', out_msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT :\thi\n",
      "OUTPUT: Thanks!\n",
      "INPUT :\thow are you?\n",
      "OUTPUT: I'm too shy to answer questions. What do you want to talk about?\n",
      "INPUT :\tschool\n",
      "OUTPUT: Good.\n",
      "INPUT :\tquit\n",
      "OUTPUT: Bye\n"
     ]
    }
   ],
   "source": [
    "have_a_chat()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Code reviews is a process for systematically reviewing someone else's code. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This is what you'll have the chance to do in coding lab next week!"
   ]
  }
 ],
 "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.7.7"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}