19-Documentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Course Announcements**\n",
    "\n",
    "Due Dates:\n",
    "- **CL8** due tonight\n",
    "- **A5** due Monday\n",
    "\n",
    "Notes:\n",
    "- Scientific Computing Lecture on Canvas issue:\n",
    "    - Have reuploaded lecture on Media Gallery (will be out of order)\n",
    "- No Lecture/OH on Monday (Memorial Day Holiday)\n",
    "- Folder for module/scripts practice: CL7_student_examples\n",
    "- A4 Grades/Feedback Posted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "**Q&A**\n",
    "\n",
    "Q: I am curious about how to make a Pytest through DataHub, since the example from lecture was done on a terminal from the computer, and not through Datahub.  \n",
    "A: The process would be the same, but you would create the .py file on datahub and use the terminal on datahub.\n",
    "\n",
    "Q: Could you please say again how to install Linters on datahub? Or is that available on Anaconda by default?  \n",
    "A: On datahub: `pip install --user pylint`. It is available from Anaconda by default.\n",
    "\n",
    "Q: Are we required to explain the code style we utilize in every big cell that has our code?  \n",
    "A: No. Please don't. This would make your card very hard to read. You want to use good code style, but you shoudl not explain it.\n",
    "\n",
    "Q: Does pylint just check your code style?  \n",
    "A: It checks code style and for execution errors (programmatic errors).\n",
    "\n",
    "Q: are there any examples of where \"bad\" coding style is better than the standard PEP?  \n",
    "A: Sure, there are execeptions to every rule. We'll discuss list comprehensions next week. Sometimes brevity in code is preferred, making it slightly less readable. There are tradeoffs in all these decisions.\n",
    "\n",
    "Q: Are there other types of PEPs? PEP8 makes it seem like there are 7 others haha, or was it just a number they chose and went with it?\n",
    "A: There are hundreds of PEPs. They focus on all aspects of Python code, not just style. https://www.python.org/dev/peps/\n",
    "\n",
    "Q: How to run code and go through a terminal correctly? I only get how to use a juypter notebook.  \n",
    "A: Take a look back at the command line lecture. This is also something we can help with in office hours.\n",
    "\n",
    "Q: Will we get points taken off on the final project if we forget to include PEP8?  \n",
    "A: You will need to consider code style in your final project. We will look at your code style overall and grade that; however, if you make a \"mistake\" here or there, you will not lose points.\n",
    "\n",
    "Q: How can we make sure our names are descriptive enough?  \n",
    "A: Just make sure they make *some* reference/indication to the information stored in the variable (and they aren't just single letter variable names).\n",
    "\n",
    "Q: I am curious about if people can have their own individual code style or if everyone should/has to use the standard PEP8 rules.  \n",
    "A: Yes! People absolutely have their own code style. In fact, if you're contributing to someone else's project, you should try to match their code style when possible. PEP8 lays the groundwork, but people develop their own styles from there.\n",
    "\n",
    "Q: Are spaces not required between comments and lines of code?   \n",
    "A: Nope! \n",
    "\n",
    "Q: The most confusing part of lecture was the line length coding style section because I don't know how I would be able to know if I was under 79 characters in a line without actually counting each character.   \n",
    "A: There are tools to help with this *but* we won't be checking your code for exactly 79 characters. Just try to avoid super long lines of code!\n",
    "\n",
    "Q: Why do we need/what are docstrings?  \n",
    "A: We're discussing that today!\n",
    "\n",
    "Q: This lecture was very straightforward. I am slightly confused as to why this is being introduced so late in the quarter though.  \n",
    "A: I agree - I go back and forth on this as to whether it's best to introduce style up front before you know the syntax or to let you get experience with the syntax and then focus on style...\n",
    "\n",
    "Q: For the string quotes, why it is not recommended to use a backward slash?  \n",
    "A: Makes your code slightly less readable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Documentation\n",
    "\n",
    "- readability\n",
    "- comments\n",
    "- documentation\n",
    "- versioning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Readability (API)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\"Code is more often read than written\" - Guido van Rossum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "So: code should be written to be readable by humans."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Note: one of those humans is future you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Writing Readable Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "So how do we write good code for humans?\n",
    "\n",
    "- Use good structure\n",
    "- Use good naming\n",
    "- Use code comments and include documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Good Structure\n",
    "\n",
    "If you design your program using separate functions for each task, avoid copying + pasting (functions and loops instead), and consider structure beforehand, you'll be set up for success"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Good Naming\n",
    "\n",
    "Clear names are for humans. The computer doesn't care, but you and others reading your code do."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Code comments & Documentation\n",
    "\n",
    "Helpful comments and documentation take your code to the next level. The final piece in the trifecta of readable code! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Good code has good documentation - but code documentation should _not_ be used to try and fix unclear names, or bad structure. \n",
    "\n",
    "Rather, comments should add any additional context and information that helps explain what the code is, how it works, and why it works that way. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "These will all be components of your final project grade."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #1\n",
    "\n",
    "What does the following code do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def ff(jj):\n",
    "    oo = list(); jj = list(jj) \n",
    "    for ii in jj: oo.append(str(ord(ii)))\n",
    "    return '+'.join(oo)\n",
    "ff('Hello World.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) Returns unicode code points, as a list\n",
    "- B) Encodes a string as a cypher, returning a string of alphabetical characters\n",
    "- C) Returns unicode code points, as a string\n",
    "- D) Encodes inputs alphabetical characters, returned as a list\n",
    "- E) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Improvement Considerations:\n",
    "- Structural considerations: indentations & spacing\n",
    "- Improved naming: functions & variables\n",
    "- Add Comments within code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'72+101+108+108+111+32+87+111+114+108+100+46'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def return_unicode(input_list):\n",
    "    string = list()\n",
    "    input_list = list(input_list)\n",
    "      \n",
    "    for character in input_list: \n",
    "        string.append(str(ord(character)))\n",
    "        \n",
    "    output_string = '+'.join(string)\n",
    "    return output_string\n",
    "\n",
    "return_unicode('Hello World.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) Returns unicode code points, as a list\n",
    "- B) Encodes a string as a cypher, returning a string of alphabetical characters\n",
    "- C) Returns unicode code points, as a string\n",
    "- D) Encodes inputs alphabetical characters, returned as a list\n",
    "- E) This code will fail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Improvement Considerations:\n",
    "- Structural considerations: indentations & spacing\n",
    "- Improved naming: functions & variables\n",
    "- Add Comments within code\n",
    "- **Proper Documentation!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's fix this code!\n",
    "def convert_to_unicode(input_string):\n",
    "    \"\"\"Converts an input string into a string containing the unicode code points.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    input_string : string\n",
    "        String to convert to code points\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    output_string : string\n",
    "        String containing the code points for the input string.\n",
    "    \"\"\" \n",
    "    \n",
    "    output = list()\n",
    "    # Converting a string to a list, to split up the characters of the string\n",
    "    input_list = list(input_string)\n",
    "    \n",
    "    for character in input_list:   \n",
    "        temp = ord(character)\n",
    "        output.append(temp)\n",
    "\n",
    "    output_string = '+'.join(output)\n",
    "        \n",
    "    return output_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Code documentation is text that accompanies and/or is embedded within a software project, that explains what the code is and how to use it. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Stuff written for humans in human language to help the humans."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Comments vs. Documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Comments are string literals written directly in the code, typically directed at developers - people reading and potentially writing the code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Documentation are descriptions and guides written for code users. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inline Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Code comments should use `#`, and be written at the same indentation level of the code it describes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "How to use comments:\n",
    "- Generally:\n",
    "    - focus on the *how* and *why*, over literal 'what is the code'\n",
    "    - explain any context needed to understand the task at hand\n",
    "    - give a broad overview of what approach you are taking to perform the task\n",
    "    - if you're using any unusual approaches, explain what they are, and why you're using them\n",
    "- Comments need to be maintained - make sure to keep them up to date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Bad Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# This is a loop that iterates over elements in a list\n",
    "for element in list_of_elements:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Good Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Because of X, we will use approach Y to do Z\n",
    "for element in list_of_elements:\n",
    "    # comment for code block\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Docstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Docstrings</b> are in-code text that describe modules, classes and functions. They describe the operation of the code.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Numpy style docs\n",
    "[Numpy style docs](https://numpydoc.readthedocs.io/en/latest/format.html) are a particular specification for docstrings. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example Docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def add(num1, num2):\n",
    "    \"\"\"Add two numbers together. \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    num1 : int or float\n",
    "        The first number, to be added. \n",
    "    num2 : int or float\n",
    "        The second number, to be added.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    answer : int or float\n",
    "        The result of the addition. \n",
    "    \"\"\"\n",
    "    \n",
    "    answer = num1 + num2\n",
    "    \n",
    "    return answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Docstrings\n",
    "\n",
    "- multi-line string that describes what's going on\n",
    "- starts and ends with triple quotes `\"\"\"`\n",
    "- one sentence overview at the top - the task/goal of function\n",
    "- **Parameters** : description of function arguments, keywords & respective types\n",
    "- **Returns** : explanation of returned values and their types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Docstrings** are available to you *outside* of the source code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Docstrings are available through the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "add?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function add in module __main__:\n",
      "\n",
      "add(num1, num2)\n",
      "    Add two numbers together. \n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    num1 : int or float\n",
      "        The first number, to be added. \n",
      "    num2 : int or float\n",
      "        The second number, to be added.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    answer : int or float\n",
      "        The result of the addition.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# The `help` function prints out the `docstring` \n",
    "# of an object (module, function, class)\n",
    "help(add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `__doc__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Add two numbers together. \n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    num1 : int or float\n",
      "        The first number, to be added. \n",
      "    num2 : int or float\n",
      "        The second number, to be added.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    answer : int or float\n",
      "        The result of the addition. \n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# Docstrings get stored as the `__doc__` attribute\n",
    "# can also be accessed from there\n",
    "print(add.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #2\n",
    "\n",
    "What should be included in a docstring?\n",
    "\n",
    "1) Input arguments and their types  \n",
    "2) A brief overview sentence about the code  \n",
    "3) A copy of the `def` line  \n",
    "4) Returned variables and their types  \n",
    "5) A step by step description of the procedure used in the code  \n",
    "\n",
    "- A) 1, 4 \n",
    "- B) 2, 3, 5\n",
    "- C) 3, 5 \n",
    "- D) 1, 2, 4 \n",
    "- E) 1, 2, 3, 4, 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Projects & Documentation\n",
    "\n",
    "**Do *all* of my functions need `numpy` documentation?**\n",
    "\n",
    "1. Your original code definitely needs `numpy` docstrings (required)\n",
    "2. It's best if all your main functions have docstrings (optional)\n",
    "    - If you include functions from an assignment, go ahead document them\n",
    "    - If you write a teeny tiny function to accomplish a super small task, no need to document"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Documentation for a Software Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Documentation Files:\n",
    "- A `README` is a file that provides an overview of the project to potential users and developers\n",
    "- A `LICENSE` file specifies the license under which the code is available (the terms of use)\n",
    "- An `API Reference` is a collection of the docstrings, listing public interfaces, parameters and return values\n",
    "- Tutorials and/or Examples show examples and tutorials for using the codebase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Documentation Sites"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Documentation sites are a host of a package's documentation, for code users. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Example: Function Documentation\n",
    "`numpy.array` :\n",
    "https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Example: Package Documentation\n",
    "**scikit learn** (`sklearn`) : https://scikit-learn.org/stable/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Software Versioning\n",
    "\n",
    "When you make changes to the software you've released into the world, you have to change the version of that software to let people know changes have occurred."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Versioning Schemes\n",
    "\n",
    "The rules, if you're new to this can be [dizzying](https://www.python.org/dev/peps/pep-0440/#version-scheme), so we'll [simplify](https://www.python.org/dev/peps/pep-0396/) for now:\n",
    "\n",
    "- `<MAJOR>.<MINOR>`\n",
    "    - i.e. 1.3\n",
    "    \n",
    "- `<MAJOR>.<MINOR>.<MAINTENANCE>`\n",
    "    - i.e. 1.3.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- `<MAJOR>` - increase by 1 w/ incompatible API changes\n",
    "- `<MINOR>` - increase by 1 w/ added functionality in a backwards-compatible manner\n",
    "- `<MAINTENANCE>` - (aka patch) inrease by 1 w/  backwards-compatible bug fixes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.2.4'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# see version information\n",
    "import pandas as pd\n",
    "pd.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python package development... when `<MAJOR>` == 0, suggests a package in development"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: lisc\r\n",
      "Version: 0.1.2.dev0\r\n",
      "Summary: Literature Scanner\r\n",
      "Home-page: https://github.com/lisc-tools/lisc\r\n",
      "Author: Thomas Donoghue\r\n",
      "Author-email: tdonoghue.research@gmail.com\r\n",
      "License: Apache License, 2.0\r\n",
      "Location: /Users/shannonellis/.local/lib/python3.7/site-packages\r\n",
      "Requires: numpy, lxml, requests, beautifulsoup4, nltk\r\n",
      "Required-by: \r\n"
     ]
    }
   ],
   "source": [
    "# see version information\n",
    "!pip show lisc"
   ]
  }
 ],
 "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
}