diff --git a/00_python_in_a_nutshell.ipynb b/00_python_in_a_nutshell.ipynb new file mode 100644 index 0000000..e2172dd --- /dev/null +++ b/00_python_in_a_nutshell.ipynb @@ -0,0 +1,1965 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 0: Python in a Nutshell" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python itself is a so-called **general purpose** programming language. That means it does *not* know about any **scientific algorithms** \"out of the box.\"\n", + "\n", + "The purpose of this notebook is to summarize anything that is worthwhile knowing about Python and programming on a \"high level\" and lay the foundation for working with so-called **third-party libraries**, some of which we see in subsequent chapters." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Python as a Calculator" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any computer can always be viewed as some sort of a \"fancy calculator\" and Python is no exception from that. The following code snippet, for example, does exactly what we expect it would, namely *addition*." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 + 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In terms of **syntax** (i.e., \"grammatical rules\"), digits are interpreted as plain numbers (i.e., a so-called **numerical literal**) and the `+` symbol consitutes a so-called **operator** that is built into Python.\n", + "\n", + "Other common operators are `-` for *subtraction*, `*` for *multiplication*, and `**` for *exponentiation*. In terms of arithmetic, Python allows the **chaining** of operations and adheres to conventions from math, namely the [PEMDAS rule ](https://en.wikipedia.org/wiki/Order_of_operations#Mnemonics)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "45" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "87 - 42" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3 * 5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 * 2 ** 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To change the **order of precedence**, parentheses may be used for grouping. Syntactically, they are so-called **delimiters** that mark the beginning and the end of a **(sub-)expression** (i.e., a group of symbols that are **evaluated** together)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(2 * 2) ** 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We must beware that some operators do *not* do what we expect. So, the following code snippet is *not* an example of exponentiation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ^ 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*Division* is also not as straighforward as we may think!\n", + "\n", + "While the `/` operator does *ordinary division*, we must note the subtlety of the `.0` in the result." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "8 / 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whereas both `4` and `4.0` have the *same* **semantic meaning** to us humans, they are two *different* \"things\" for a computer!\n", + "\n", + "Instead of using a single `/`, we may divide with a double `//` just as well." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "8 // 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, then we must be certain that the result is not a number with decimals other than `.0`. As we can guess from the result below, the `//` operator does *integer division* (i.e., \"whole number\" division)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "7 // 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the contrary, the `%` operator implements the so-called *modulo division* (i.e., \"rest\" division). Here, a result of `0` indicates that a number is divisible by another one whereas any result other than `0` shows the opposite." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "7 % 2" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "8 % 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What makes Python such an intuitive and thus beginner-friendly language, is the fact that it is a so-called **[interpreted language ](https://en.wikipedia.org/wiki/Interpreter_%28computing%29)**. In layman's terms, this means that we can go back up and *re-execute* any of the code cells in *any order*: That allows us to built up code *incrementally*. So-called **[compiled languages ](https://en.wikipedia.org/wiki/Compiler)**, on the other hand, would require us to run a program in its entirety even if only one small part has been changed.\n", + "\n", + "Instead of running individual code cells \"by hand\" and taking the result as it is, Python offers us the usage of **variables** to store \"values.\" A variable is created with the single `=` symbol, the so-called **assignment statement**." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "a = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "b = 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After assignment, we can simply ask Python about the values of `a` and `b`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, we can use a variable in place of, for example, a numerical literal within an expression." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a + b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also, we may combine several lines of code into a single code cell, adding as many empty lines as we wish to group the code. Then, all of the lines are executed from top to bottom in linear order whenever we execute the cell as a whole." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 1\n", + "b = 2\n", + "\n", + "a + b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Something that fools many beginners is the fact that the `=` statement is *not* to be confused with the concept of an *equation* from math! An `=` statement is *always* to be interpreted from right to left.\n", + "\n", + "The following code snippet, for example, takes the \"old\" value of `a`, adds the value of `b` to it, and then stores the resulting `3` as the \"new\" value of `a`. After all, a variable is called a variable as its value is indeed variable!" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "a = a + b" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In general, the result of some expression involving variables is often stored in yet another variable for further processing. This is how more realistic programs are built up." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 1\n", + "b = 2\n", + "\n", + "c = a + b\n", + "\n", + "c" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As most real-life projects involve *non-scalar* data, we take a pre-liminary look at how Python models `list`-like data next. Intuitively, a `list` can be thought of as a **container** holding many \"things.\"\n", + "\n", + "The syntax to create a `list` are brackets, `[` and `]`, another example of delimiters, listing the individual **elements** of the `list` in between them, separated by commas.\n", + "\n", + "For example, the next code snippet creates a `list` named `numbers` with the numbers `1`, `2`, `3`, and `4` in it." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [a, b, c, 4]\n", + "\n", + "numbers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whenever we use any kind of delimiter, we may break the lines in between them as we wish and add other so-called **whitespace** characters like spaces to format the way the code looks like. So, the following two code cells do *exactly* the same as the previous one, even the `,` after the `4` in the second cell is ignored." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [\n", + " a, b, c, 4\n", + "]\n", + "\n", + "numbers" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers = [\n", + " a,\n", + " b,\n", + " c,\n", + " 4,\n", + "]\n", + "\n", + "numbers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A nice thing to know is that JupyterLab comes with **tab completion** built in. That means we do not have to type out the name `numbers` as a whole. Try it out by simply typing `num` and then hit the tab key on your keyboard. JupyterLab should complete the variable into `numbers`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A natural operation to do with `list`s is to **access** its elements. That is achieved with another operator that also uses a bracket notation. Each element is associated with an **index**, which is why we say that we \"index into a `list`.\" As with many other programming languages, Python is 0-based, which simply means that whenever we count something, we start to count at `0`.\n", + "\n", + "For example, to obtain the first element in `numbers`, we write the following." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the indexing operation implicitly assumes an **order** among the elements, which is quite intuitive as we specified the numbers in order above.\n", + "\n", + "Another implicit assumption behind `list`s is that the number of elements is *finite*. Because of that, we may use negative indices starting at `-1` to obtain an element in right-to-left order.\n", + "\n", + "So, to obtain the last element in `numbers`, we write the following." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers[-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Expressing Logic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The main point of using `list`s in Python is to write code that does something repeatedly, once for each element in the `list`.\n", + "\n", + "The syntactical construct to achieve that is the `for`-loop, which consists of two parts:\n", + "- a **header** line specifying what is looped over, and\n", + "- a **body** consisting of the block of code that is repeated for each element.\n", + "\n", + "In the example below, `for number in numbers:` constitutes the header. The expression after the `in` references the \"thing\" that is looped over (here: a `list` of `numbers`) and the name between `for` and `in` becomes a variable that is assigned a new value in each **iteration** over of the loop. A best practice is to use a meaingful name, which is why we choose the singular `number`. The `:` at the end is the charactistic symbol of a header line in general and requires the next line (and possibly many more lines) to be **indented**.\n", + "\n", + "The indented line constitues the `for`-loop's body. In the example, we simply take each of the numbers in `numbers`, one at a time, and add it to a `total` that is initialized at `0`. In other words, we calculate the sum of all the elements in `numbers`.\n", + "\n", + "Many beginners struggle with the term \"loop.\" To visualize the looping behavior of this code, we use the online tool [PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B1,%202,%203,%204%5D%0A%0Atotal%20%3D%200%0A%0Afor%20number%20in%20numbers%3A%0A%20%20%20%20total%20%3D%20total%20%2B%20number%0A%0Atotal&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false). That tool is helpful for two reasons:\n", + "1. It allows us to execute code in \"slow motion\" (i.e., by clicking the \"next\" button on the left side, only the next atomic step of the code snippet is executed).\n", + "2. It shows what happens inside the computer's memory on the right-hand side (cf., the \"*Thinking like a Computer*\" section further below)." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total = 0\n", + "\n", + "for number in numbers:\n", + " total = total + number\n", + "\n", + "total" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python is pretty agnostic about how far the `for`-loop's body is indented. So, both of the next code cells are equivalent to the one above. Yet, a popular convention in the Python world is to always indent code with 4 spaces per indentation level." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total = 0\n", + "\n", + "for number in numbers:\n", + " total = total + number\n", + "\n", + "total" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total = 0\n", + "\n", + "for number in numbers:\n", + " total = total + number\n", + "\n", + "total" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Conditional Execution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a variation, let's add up only the even numbers. To achieve that, we exploit the fact that even numbers are all numbers that are divisible by `2` and use the `%` operator from above and a new one, namely the `==` operator for *equality comparison*, to express that idea." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "7 % 2" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "8 % 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whenever *arithmetic* operators like `%` are combined in an expression with *relational* operators like `==`, the arithmetic is done first and the comparison last. So, the next two cells first obtain the rest after dividing `7` and `8` by `2` and then compare that to `0`. The result is a so-called **boolean**, either `True` or `False`, which is a computer's way of saying \"yes\" or \"no.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "7 % 2 == 0" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "8 % 2 == 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use such kind of expressions as the **condition** in an `if` statement that constitutes a second layer within our `for`-loop implementation. An `if` statement itself consists of yet another header line with a body. That body's code is only executed if the condition is `True`.\n", + "\n", + "As an example, the next code snippet loops over all the elements in `numbers` and, for each individual `number`, checks if it is even. Only if that is the case, the `number` is added to the `total`. Otherwise, nothing is done with the `number`. The example also shows how we can add so-called **comments** at the end of a line: Anything that comes after the `#` symbol is disregarded by Python. We use such comments to put little notes to ourselves within the code." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total = 0\n", + "\n", + "for number in numbers:\n", + " if number % 2 == 0: # if the number is even\n", + " total = total + number\n", + "\n", + "total" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`if` statements may have more than one header line: For example, the code in the `else`-clause's body is only executed if the condition in the `if`-clause is `False`. In the code cell below, we calculate the sum of all even numbers and subtract the sum of all odd numbers. The result is `(2 + 4) - (1 + 3)` or `-1 + 2 - 3 + 4` resembling the order of the numbers in the `for`-loop." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total = 0\n", + "\n", + "for number in numbers:\n", + " if number % 2 == 0: # if the number is even\n", + " total = total + number\n", + " else: # if the number is odd\n", + " total = total - number\n", + "\n", + "total" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modularizing Code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One big idea in software engineering is to **modularize** code. The purpose of that is manyfold. Two very important motivations are to\n", + "- make a code segment **re-usable**, and to\n", + "- give a meaningful name to that code segment.\n", + "\n", + "The latter gets more important as the codebase in a project grows so big that we can only look at a tiny fraction of it at one point in time.\n", + "\n", + "The syntactical construct that enables us to achieve that is that of a **function definition**. Just like in math, we can \"define\" a function to be some set of parametrized instructions that provide some (deterministic) **output** given some *concrete* **input**.\n", + "\n", + "A function is defined with the `def` statement: After the `def` part comes the name of the function followed by the **parameter list** within parentheses. The first couple of lines in the function's body should be a so-called **docstring** that describes what the function does in plain English. Then, comes the code that is to be made repeatable. In the example below, we simply copy & pasted the code to calculate the sum of all even numbers in a `list` into the example function `sum_evens()`. Note that we exchanged the variable name `total` with `result` here to illustrate a point further below. In order for the function to provide back the output to \"the outside world,\" we use the `return` statement (Hint: to see its effect simply re-run the couple of code cells below with and without the `return result` line)." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "def sum_evens(numbers):\n", + " \"\"\"Sum up all the even numbers in a list.\n", + "\n", + " Args:\n", + " numbers (list of int's): numbers to be summed up\n", + "\n", + " Returns:\n", + " total (int)\n", + " \"\"\"\n", + " result = 0\n", + "\n", + " for number in numbers:\n", + " if number % 2 == 0: # if the number is even\n", + " result = result + number\n", + "\n", + " return result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After defining a function, we can **call** (i.e., \"execute\") it with the `()` operator. So, just as with the `[]` above, the `()` may have a different meaning in a given context.\n", + "\n", + "Let's execute the function with `numbers` as the input. We see the same `6` below the cell as we do above where we run the code without a function. Without the `return` statement in the function's body, we would not see any output here.\n", + "\n", + "To see what happens in detail, take a look at [PythonTutor ](http://pythontutor.com/visualize.html#code=numbers%20%3D%20%5B1,%202,%203,%204%5D%0A%0Adef%20sum_evens%28numbers%29%3A%0A%20%20%20%20%22%22%22Sum%20up%20all%20the%20even%20numbers%20in%20a%20list.%22%22%22%0A%20%20%20%20result%20%3D%200%0A%0A%20%20%20%20for%20number%20in%20numbers%3A%0A%20%20%20%20%20%20%20%20if%20number%20%25%202%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20result%20%3D%20result%20%2B%20number%0A%0A%20%20%20%20return%20result%0A%0Atotal%20%3D%20sum_evens%28numbers%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) again. You should notice how there are two variables by the name `numbers` in memory. Python manages the memory with a concept called **namespaces** or **scopes**, which are just fancy terms for saying that Python can tell variables from different contexts apart." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum_evens(numbers)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To re-use the *same* instructions with *different* input, we call the function a second time and give it a brand-new `list` of numbers as its input." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum_evens([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note how the variable `result` only exists \"inside\" the `sum_evens()` function. Hence, we see the `NameError` here." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'result' 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\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'result' is not defined" + ] + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The concept of re-usable functions is so important in programming that Python comes with many [built-in functions ](https://docs.python.org/3/library/functions.html). Two popular examples are the [sum() ](https://docs.python.org/3/library/functions.html#sum) and [len() ](https://docs.python.org/3/library/functions.html#len) functions that calculate the sum or the number of elements in a `list` input." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sum(numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(numbers)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another function that comes in handy at times, is the [print() ](https://docs.python.org/3/library/functions.html#print) function that simply \"prints\" out its input to the screen. Below is the popular \"Hello World\" example that is shown in almost any introduction text on any programming language. The double quotes `\"` are yet another delimiter that specifies anything in between them as textual data (cf., the docstring above is just a special case thereof)." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n" + ] + } + ], + "source": [ + "print(\"Hello World\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Single quotes `'` are basically just synonyms for double quotes `\"`." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World\n" + ] + } + ], + "source": [ + "print('Hello World')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The [print() ](https://docs.python.org/3/library/functions.html#print) function is often helpful to **debug** a code snippet (i.e., trying to figure out what it does, step by step)." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The square of 1 is 1\n", + "The square of 2 is 4\n", + "The square of 3 is 9\n", + "The square of 4 is 16\n" + ] + } + ], + "source": [ + "for number in numbers:\n", + " square = number ** 2\n", + " print(\"The square of\", number, \"is\", square)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extending Core Python" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the Python community, we even say that \"Python comes with batteries included,\" meaning that a plain Python installation (like the one you are probably using to execute this notebook) offers all kinds of functionalities for a multitude of application domains. Thus, the name **general purpose** language.\n", + "\n", + "To \"enable\" most of these, however, we need to first **import** them from the so-called [standard library ](https://docs.python.org/3/library/index.html). Let's do a quick example here and look at the [random ](https://docs.python.org/3/library/random.html) module that provides functionalities to simulate and work with random numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "import random" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access a function inside the [random ](https://docs.python.org/3/library/random.html) module, for example, the [random() ](https://docs.python.org/3/library/random.html#random.random) function, we use the `.` operator, formally called the attribute access operator. The [random() ](https://docs.python.org/3/library/random.html#random.random) function simply returns a random decimal number between `0` and `1`." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.38523914298287465" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random.random()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It could be used, for example, to model a fair coin toss by comparing the number it returns to `0.5` with the `<` operator: In 50% of the cases we see `True` and in the other 50% `False`." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random.random() < 0.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A second example would be the [choice() ](https://docs.python.org/3/library/random.html#random.choice) function, which draws a random element from a `list` with replacement. We could use it to model a fair die." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "random.choice([1, 2, 3, 4, 5, 6])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next chapter, we see how we can extend Python even further by installing and importing **third-party packages**." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Thinking like a Computer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An important skill for any data scientist is to learn to \"think\" like a computer does. So far, we have seen that Python is a pretty \"intuitive\" language: Many concepts can already be understood after seeing them once or just a couple of times. Many of the aspects that make other languages harder to learn, are somehow \"magically\" automated by Python in the background, most notably the management of the memory.\n", + "\n", + "This section introduces a couple of more \"advanced\" concepts that presumably are *not* so intuitive to beginners." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \"Simple\" Data Types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At first, let's review the concept of **object-orientation**, which is the paradigm by which Python manages the memory.\n", + "\n", + "Take the following three examples. Whereas `a` and `b` have the same **value** (i.e., **semantic meaning**) to us humans, we see in this section that there are a couple of caveats to look out for." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "a = 42\n", + "b = 42.0\n", + "c = 42.87" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An important idea to understand is that each of the right-hand sides lead to a *new* **object** being created in the computer's memory *first*. An object can be thought of as a \"box\" in memory holding $1$s and $0$s (i.e., physical energy flows inside the computer).\n", + "\n", + "Objects can and do exist without being **referenced** by a variable. Also, an object may even have several variables referencing them, just as a human may have different names in different contexts (e.g., a formal name in the password, a name by which one is known to friends, and maybe a different name by which one is called by one's spouse).\n", + "\n", + "In the example, while both `a` and `b` have the *same* value, they are two *distinct* objects. The `is` operator checks if the objects referenced by two variables are indeed the *same* one, or, in other words, have the same **identity**." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a == b" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a is b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Every object always has some **data type**, which determines how the object behaves and what we can do with it. The types of `a` and `b` are `int` and `float`, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "float" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While it seems cumbersome to analyze numbers at this level of detail, the following code cell shows how `float`ing-point numbers, one gold standard of numbers in all of computer science and engineering, behave couter-intutive. Yet, *nothing* is wrong here." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "0.1 + 0.2 == 0.3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The data type of an object also determines which **methods** we can invoke on it. A method is just a function that is \"attached\" to an object and can be accessed with the `.` operator seen above. A method necessarily needs the objects it is attached to as in input, which is why it is attached to an object to begin with.\n", + "\n", + "For example, `float` objects come with an `.is_integer()` method that tells us if the number has non-`0` decimals." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b.is_integer()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.is_integer()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`int` objects on the contrary have no notion of the concept of decimals, which is why they do *not* have an `.is_integer()` method. That is what the `AttributeError` tells us." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'int' object has no attribute 'is_integer'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'is_integer'" + ] + } + ], + "source": [ + "a.is_integer()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What we could do here, is to take `a` and pass it to the [float() ](https://docs.python.org/3/library/functions.html#float) built-in, a so-called **constructor**, which takes the value of its input and creates a *new* object of the desired `float` type. Yet, we know the answer to `aa.is_integer()` already, even without executing the code cell as `a` has no non-`0` decimals to begin with." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "aa = float(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "aa.is_integer()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create another example `d` to see further examples of methods." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "d = \"Python rocks\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The type of `d` is `str`, which is short for \"**string**\" and is defined in computer science as a sequence of characters." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`str` objects support various methods that \"make sense\" in the context of textual data, for example, the `.lower()` and `.upper()` methods." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'python rocks'" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.lower()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'PYTHON ROCKS'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d.upper()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### \"Complex\" Data Types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The examples in the previous section are considered \"simple\" as they only model *scalar* values (i.e., an individual object per example). However, we have already seen an example of a more \"complex\" object, namely the `list` called `numbers` above." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 4]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "numbers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`list` objects also come with specific methods on them, for example, the `.append()` method that adds another element at the end of a `list`." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "numbers.append(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note how the `.append()` method does not lead to any output below the code cell. That is an indication that `numbers` is \"changed in place.\" The formal term for this property is **mutability**. A good working definition is: Any object whose value can be changed *after* its creation, is a **mutable** objects. Objects *without* this property are called **immutable**.\n", + "\n", + "An example for the latter, is the `tuple` data type. `tuple`s are simply `list`s with the additional property that they cannot be changed. Everything is else is the same as for `list`s. `tuple`s are created with parentheses replacing the brackets." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "more_numbers = (7, 8, 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`more_numbers` does not know about the `.append()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'tuple' object has no attribute 'append'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmore_numbers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'" + ] + } + ], + "source": [ + "more_numbers.append(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Whereas both `list` and `tuple` objects perserve the **order** of their elements, the `set` data type does not. Additionally, any object may only be an element of a `set` at most once. The syntax to create `set`s are curly braces, `{` and `}`. By giving up order, `set` objects offer significantly increased processing speed in various situations." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "other_numbers = {3, 3, 3, 2, 2, 1}" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 2, 3}" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "other_numbers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One last example of a \"complex\" data type is the `dict`ionary type, which models a mapping relationship among the objects it contains. The syntax to create `dict`s also involves curly braces with the additon of using a `:` to specify the mapping relationships.\n", + "\n", + "For example, to map `int`egers to `str`ings modeling the English words corresponding to the numbers, we could write the following. The objects to the left of the `:` take the role of the **keys** while the ones to the right take the role of the **values**." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "to_words = {\n", + " 0: \"zero\",\n", + " 1: \"one\",\n", + " 2: \"two\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The main purpose of `dict`s is to look up the value mapped to by some key. We can use the indexing notion to achieve that." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'zero'" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "to_words[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`dict`s are among the most optimized data type in the Python world and a major building block in codebases solving real-life problems." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A big factor in getting good at any programming language is to learn what data types to use in which situations. There is no \"best\" data type; choosing among a couple of data types always comes down to trade-offs." + ] + } + ], + "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.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/01_scientific_stack.ipynb b/01_scientific_stack.ipynb new file mode 100644 index 0000000..694376b --- /dev/null +++ b/01_scientific_stack.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 1: Python's Scientific Stack" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python itself does not come with any scientific algorithms. However, over time, many third-party libraries emerged that are useful to build machine learning applications. In this context, \"third-party\" means that the libraries are *not* part of Python's standard library.\n", + "\n", + "Among the popular ones are [numpy](https://numpy.org/) (numerical computations, linear algebra), [pandas](https://pandas.pydata.org/) (data processing), [matplotlib](https://matplotlib.org/) (visualisations), and [scikit-learn](https://scikit-learn.org/stable/index.html) (machine learning algorithms).\n", + "\n", + "Before we can import these libraries, we must ensure that they installed on our computers. If you installed Python via the Anaconda Distribution that should already be the case. Otherwise, we can use Python's **package manager** `pip` to install them manually.\n", + "\n", + "`pip` is a so-called command-line interface (CLI), meaning it is a program that is run within a terminal window. JupyterLab allows us to run such a CLI tool from within a notebook by starting a code cell with a single `%` symbol. Here, this does not mean Python's modulo operator but is just an instruction to JupyterLab that the following code is *not* Python." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: numpy in ./.venv/lib/python3.8/site-packages (1.20.3)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pandas in ./.venv/lib/python3.8/site-packages (1.2.4)\n", + "Requirement already satisfied: numpy>=1.16.5 in ./.venv/lib/python3.8/site-packages (from pandas) (1.20.3)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in ./.venv/lib/python3.8/site-packages (from pandas) (2.8.1)\n", + "Requirement already satisfied: pytz>=2017.3 in ./.venv/lib/python3.8/site-packages (from pandas) (2021.1)\n", + "Requirement already satisfied: six>=1.5 in ./.venv/lib/python3.8/site-packages (from python-dateutil>=2.7.3->pandas) (1.16.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install pandas" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: matplotlib in ./.venv/lib/python3.8/site-packages (3.4.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in ./.venv/lib/python3.8/site-packages (from matplotlib) (2.8.1)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in ./.venv/lib/python3.8/site-packages (from matplotlib) (2.4.7)\n", + "Requirement already satisfied: pillow>=6.2.0 in ./.venv/lib/python3.8/site-packages (from matplotlib) (8.2.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in ./.venv/lib/python3.8/site-packages (from matplotlib) (1.3.1)\n", + "Requirement already satisfied: numpy>=1.16 in ./.venv/lib/python3.8/site-packages (from matplotlib) (1.20.3)\n", + "Requirement already satisfied: cycler>=0.10 in ./.venv/lib/python3.8/site-packages (from matplotlib) (0.10.0)\n", + "Requirement already satisfied: six in ./.venv/lib/python3.8/site-packages (from cycler>=0.10->matplotlib) (1.16.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: scikit-learn in ./.venv/lib/python3.8/site-packages (0.24.2)\n", + "Requirement already satisfied: joblib>=0.11 in ./.venv/lib/python3.8/site-packages (from scikit-learn) (1.0.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in ./.venv/lib/python3.8/site-packages (from scikit-learn) (2.1.0)\n", + "Requirement already satisfied: numpy>=1.13.3 in ./.venv/lib/python3.8/site-packages (from scikit-learn) (1.20.3)\n", + "Requirement already satisfied: scipy>=0.19.1 in ./.venv/lib/python3.8/site-packages (from scikit-learn) (1.6.1)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install scikit-learn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we have ensured that the third-party libraries are installed locally, we can simply go ahead with the `import` statement. All the libraries are commonly imported with shorter prefixes for convenient use later on." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's see how the data type provided by these scientific libraries differ from Python's built-in ones.\n", + "\n", + "As an example, we create a `list` object similar to the one from Chapter 0." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vector = [1, 2, 3]\n", + "\n", + "vector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We call the `list` object by the name `vector` as that is what the data mean conceptually. As we remember from our linear algebra courses, vectors should implement scalar-multiplication. So, the following code cell should result in `[3, 6, 9]` as the answer. Surprisingly, the result is a new `list` with all the elements in `vector` repeated three times. That operation is called **concatenation** and is an example of a concept called **operator overloading**. That means that an operator, like `*` in the example, may exhibit a different behavior depending on the data type of its operands." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 3, 1, 2, 3, 1, 2, 3]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "3 * vector" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`numpy`, among others, provides a data type called an **n-dimensional array**. This may sound fancy at first but when used with only 1 or 2 dimensions, it basically represents vectors and matrices as we know them from linear algebra. Additionally, arrays allow for much faster computations as they are implemented in the very efficient [C language](https://en.wikipedia.org/wiki/C_%28programming_language%29) and optimized for numerical operations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To create an array, we use the [array()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html#numpy-array) constructor from the imported `np` module and provide it with a `list` of values." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v1 = np.array([1, 2, 3])\n", + "\n", + "v1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The vector `v1` can now be multiplied with a scalar yielding a result meaningful in the context of linear algebra." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3, 6, 9])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v2 = 3 * v1\n", + "\n", + "v2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To create a matrix, we just use a `list` of (row) `list`s of values." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3],\n", + " [4, 5, 6]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1 = np.array([\n", + " [1, 2, 3],\n", + " [4, 5, 6],\n", + "])\n", + "\n", + "m1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use `numpy`'s `dot()` function to multiply a matrix with a vector to obtain a new vector ..." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([14, 32])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v3 = np.dot(m1, v1)\n", + "\n", + "v3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... or simply transpose it by accessing its `.T` attribute." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 4],\n", + " [2, 5],\n", + " [3, 6]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The rules from maths still apply and it makes a difference if a vector is multiplied from the left or the right by a matrix. The following operation will fail." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)" + ] + } + ], + "source": [ + "np.dot(v1, m1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to retrieve only a **slice** (i.e., subset) of an array's data, we index into it. For example, the first row of the matrix is ..." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1[0, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "... while the second column is:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 5])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1[:, 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To acces the lowest element in the right column, two indices can be used." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1[1, 2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`numpy` also provides various other functions and constants, such as `linspace()` to create an array of equidistant numbers, `sin()` to calculate the sinus values for all numbers in an array, or simple an approximation for `pi`. To further illustrate the concept of **vectorization**, let us calculate the sinus curve over a range of 100 values, going from negative to positive $3\\pi$." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-9.42477796, -9.23437841, -9.04397885, -8.8535793 , -8.66317974,\n", + " -8.47278019, -8.28238063, -8.09198108, -7.90158152, -7.71118197,\n", + " -7.52078241, -7.33038286, -7.1399833 , -6.94958375, -6.75918419,\n", + " -6.56878464, -6.37838508, -6.18798553, -5.99758598, -5.80718642,\n", + " -5.61678687, -5.42638731, -5.23598776, -5.0455882 , -4.85518865,\n", + " -4.66478909, -4.47438954, -4.28398998, -4.09359043, -3.90319087,\n", + " -3.71279132, -3.52239176, -3.33199221, -3.14159265, -2.9511931 ,\n", + " -2.76079354, -2.57039399, -2.37999443, -2.18959488, -1.99919533,\n", + " -1.80879577, -1.61839622, -1.42799666, -1.23759711, -1.04719755,\n", + " -0.856798 , -0.66639844, -0.47599889, -0.28559933, -0.09519978,\n", + " 0.09519978, 0.28559933, 0.47599889, 0.66639844, 0.856798 ,\n", + " 1.04719755, 1.23759711, 1.42799666, 1.61839622, 1.80879577,\n", + " 1.99919533, 2.18959488, 2.37999443, 2.57039399, 2.76079354,\n", + " 2.9511931 , 3.14159265, 3.33199221, 3.52239176, 3.71279132,\n", + " 3.90319087, 4.09359043, 4.28398998, 4.47438954, 4.66478909,\n", + " 4.85518865, 5.0455882 , 5.23598776, 5.42638731, 5.61678687,\n", + " 5.80718642, 5.99758598, 6.18798553, 6.37838508, 6.56878464,\n", + " 6.75918419, 6.94958375, 7.1399833 , 7.33038286, 7.52078241,\n", + " 7.71118197, 7.90158152, 8.09198108, 8.28238063, 8.47278019,\n", + " 8.66317974, 8.8535793 , 9.04397885, 9.23437841, 9.42477796])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x = np.linspace(-3 * np.pi, 3 * np.pi, 100)\n", + "\n", + "x" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-3.67394040e-16, -1.89251244e-01, -3.71662456e-01, -5.40640817e-01,\n", + " -6.90079011e-01, -8.14575952e-01, -9.09631995e-01, -9.71811568e-01,\n", + " -9.98867339e-01, -9.89821442e-01, -9.45000819e-01, -8.66025404e-01,\n", + " -7.55749574e-01, -6.18158986e-01, -4.58226522e-01, -2.81732557e-01,\n", + " -9.50560433e-02, 9.50560433e-02, 2.81732557e-01, 4.58226522e-01,\n", + " 6.18158986e-01, 7.55749574e-01, 8.66025404e-01, 9.45000819e-01,\n", + " 9.89821442e-01, 9.98867339e-01, 9.71811568e-01, 9.09631995e-01,\n", + " 8.14575952e-01, 6.90079011e-01, 5.40640817e-01, 3.71662456e-01,\n", + " 1.89251244e-01, -1.22464680e-16, -1.89251244e-01, -3.71662456e-01,\n", + " -5.40640817e-01, -6.90079011e-01, -8.14575952e-01, -9.09631995e-01,\n", + " -9.71811568e-01, -9.98867339e-01, -9.89821442e-01, -9.45000819e-01,\n", + " -8.66025404e-01, -7.55749574e-01, -6.18158986e-01, -4.58226522e-01,\n", + " -2.81732557e-01, -9.50560433e-02, 9.50560433e-02, 2.81732557e-01,\n", + " 4.58226522e-01, 6.18158986e-01, 7.55749574e-01, 8.66025404e-01,\n", + " 9.45000819e-01, 9.89821442e-01, 9.98867339e-01, 9.71811568e-01,\n", + " 9.09631995e-01, 8.14575952e-01, 6.90079011e-01, 5.40640817e-01,\n", + " 3.71662456e-01, 1.89251244e-01, 1.22464680e-16, -1.89251244e-01,\n", + " -3.71662456e-01, -5.40640817e-01, -6.90079011e-01, -8.14575952e-01,\n", + " -9.09631995e-01, -9.71811568e-01, -9.98867339e-01, -9.89821442e-01,\n", + " -9.45000819e-01, -8.66025404e-01, -7.55749574e-01, -6.18158986e-01,\n", + " -4.58226522e-01, -2.81732557e-01, -9.50560433e-02, 9.50560433e-02,\n", + " 2.81732557e-01, 4.58226522e-01, 6.18158986e-01, 7.55749574e-01,\n", + " 8.66025404e-01, 9.45000819e-01, 9.89821442e-01, 9.98867339e-01,\n", + " 9.71811568e-01, 9.09631995e-01, 8.14575952e-01, 6.90079011e-01,\n", + " 5.40640817e-01, 3.71662456e-01, 1.89251244e-01, 3.67394040e-16])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y = np.sin(x)\n", + "\n", + "y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With `matplotlib`'s [plot()](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot) function we can visualize the sinus curve." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us quickly generate some random data and draw a scatter plot with `numpy`'s `random` module." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(42, 3, 100)\n", + "y = np.random.gamma(7, 1, 100)\n", + "\n", + "plt.scatter(x, y)" + ] + } + ], + "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.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/workshop.ipynb b/02_a_first_example.ipynb similarity index 67% rename from workshop.ipynb rename to 02_a_first_example.ipynb index 16f69e8..5339d00 100644 --- a/workshop.ipynb +++ b/02_a_first_example.ipynb @@ -4,7 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Workshop: Machine Learning for Beginners" + "# Chapter 2: A first Example - Classifying Flowers" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The purpose of this notebook is to look at a first example of a typical data science application, namely **statistical learning**, which is often referred to by its more well-known name **machine learning**. To do so, we look at a very popular example involving the classification of flowers. Albeit simplistic and almost boring in its kind, the example is a rather good one to look at from a beginner's point of view as it does not involve too many decision variables. That makes understanding technicalities and visualizing the data set a lot easier." ] }, { @@ -18,57 +25,68 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "Let's at first review a couple of generic definitions to get started.\n", + "\n", "Machine learning is the process of **extracting knowledge from data** in an automated fashion.\n", "\n", - "The use cases usually are making predictions on new and unseen data or simply understanding a given dataset better by finding patterns.\n", + "Typical use cases regard making predictions on new and unseen data or simply understanding a given dataset better by finding patterns.\n", "\n", - "Central to machine learning is the idea of **automating** the **decision making** from data **without** the user specifying **explicit rules** how these decisions should be made." + "Central to machine learning is the idea of **automating** the **decision making** from data **without** the user specifying **explicit rules** how these decisions should be made.\n", + "\n", + "That is in direct opposition to what we learned in the \"Expressing Logic\" section in Chapter 0, where we learned how to implement decision criterions \"by hand\" with the `if` statement." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Examples" + "#### Example Applications" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Types of Machine Learning" + "### Types of Machine Learning" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "" + "Concete machine learning algorithms are commonly classified into three broad categories that may overlap as well:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- **Supervised** (focus of this workshop): Each entry in the dataset comes with a \"label\". Examples are a list of emails where spam mail is already marked as such or a sample of handwritten digits. The goal is to use the historic data to make predictions.\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- **Supervised** (focus of the example in this notebook): Each entry in the dataset comes with a **label**. Examples are a list of emails where spam mail is already marked as such or a sample of handwritten digits. The goal is to use the historic data to make predictions.\n", "\n", "- **Unsupervised**: There is no desired output associated with a data entry. In a sense, one can think of unsupervised learning as a means of discovering labels from the data itself. A popular example is the clustering of customer data.\n", "\n", - "- **Reinforcement**: Conceptually, this can be seen as \"learning by doing\". Some kind of \"reward function\" tells how good a predicted outcome is. For example, chess computers are typically programmed with this approach." + "- **Reinforcement**: Conceptually, this can be seen as \"learning by doing\". Some kind of **reward function** tells how good a predicted outcome is. A rather recent and extremely popular example for his approach is the Alpha Go machine." ] }, { @@ -82,7 +100,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "" + "Algorithms from the supervised learning category are often broken down further into classification and regression:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" ] }, { @@ -97,32 +122,41 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Case Study: Iris Flower Classification" + "## Example: Iris Flower Classification" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "" + "In the example, we are given measurments regarding the size of various parts of the so-called Iris flower kind. A concrete flower always belongs to one of three distinct special Iris classes. This example application is about classifying a given flower into one of the three classes by only looking at the measurements." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Python for Scientific Computing: A brief Introduction" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Python itself does not come with any scientific algorithms. However, over time, many open source libraries emerged that are useful to build machine learning applications.\n", + "### Importing the Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `sklearn` library provides several sample datasets, among which is also the Iris dataset.\n", "\n", - "Among the popular ones are [numpy](https://numpy.org/) (numerical computations, linear algebra), [pandas](https://pandas.pydata.org/) (data processing), [matplotlib](https://matplotlib.org/) (visualisations), and [scikit-learn](https://scikit-learn.org/stable/index.html) (machine learning algorithms).\n", + "In a tabular visualization, the dataset could be portrayed somewhat like this:\n", "\n", - "First, import the libraries:" + "\n", + "\n", + "However, the data object imported from `sklearn` is organized slightly different. In particular, the so-called **features** are separated from the **labels**." ] }, { @@ -130,561 +164,13 @@ "execution_count": 1, "metadata": {}, "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The following line is needed so that this Jupyter notebook creates the visiualizations in the notebook and not in a new window. This has nothing to do with Python." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Standard Python can do basic arithmetic operations ..." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = 1\n", - "b = 2\n", - "\n", - "c = a + b\n", - "\n", - "c" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... and provides some simple **data structures**, such as a list of values." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 3, 4]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "l = [a, b, c, 4]\n", - "\n", - "l" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Numpy provides a data structure called an **n-dimensional array**. This may sound fancy at first but when used with only 1 or 2 dimensions, it basically represents vectors and matrices. Arrays allow for much faster computations as they are implemented in the very fast [C language](https://en.wikipedia.org/wiki/C_%28programming_language%29)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To create an array, we use the [array()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html#numpy-array) function from the imported `np` module and provide it with a `list` of values." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2, 3])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v1 = np.array([1, 2, 3])\n", - "\n", - "v1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A vector can be multiplied with a scalar." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3, 6, 9])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v2 = v1 * 3\n", - "\n", - "v2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To create a matrix, just use a list of (row) list of values instead." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 2, 3],\n", - " [4, 5, 6]])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m1 = np.array([\n", - " [1, 2, 3],\n", - " [4, 5, 6],\n", - "])\n", - "\n", - "m1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can use numpy to multiply a matrix with a vector to obtain a new vector ..." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([14, 32])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "v3 = np.dot(m1, v1)\n", - "\n", - "v3" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... or simply transpose it." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 4],\n", - " [2, 5],\n", - " [3, 6]])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m1.T" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The rules from maths still apply and it makes a difference if a vector is multiplied from the left or the right by a matrix. The following operation will fail." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mm1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: shapes (3,) and (2,3) not aligned: 3 (dim 0) != 2 (dim 0)" - ] - } - ], - "source": [ - "np.dot(v1, m1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to retrieve only a slice (= subset) of an array's data, we can \"index\" into it. For example, the first row of the matrix is ..." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 2, 3])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m1[0, :]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "... while the second column is:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2, 5])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m1[:, 1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To acces the lowest element in the right column, two indices can be used." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "m1[1, 2]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Numpy also provides various other functions and constants, such as sinus or pi. To further illustrate the concept of **vectorization**, let us calculate the sinus curve over a range of values." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-9.42477796, -9.23437841, -9.04397885, -8.8535793 , -8.66317974,\n", - " -8.47278019, -8.28238063, -8.09198108, -7.90158152, -7.71118197,\n", - " -7.52078241, -7.33038286, -7.1399833 , -6.94958375, -6.75918419,\n", - " -6.56878464, -6.37838508, -6.18798553, -5.99758598, -5.80718642,\n", - " -5.61678687, -5.42638731, -5.23598776, -5.0455882 , -4.85518865,\n", - " -4.66478909, -4.47438954, -4.28398998, -4.09359043, -3.90319087,\n", - " -3.71279132, -3.52239176, -3.33199221, -3.14159265, -2.9511931 ,\n", - " -2.76079354, -2.57039399, -2.37999443, -2.18959488, -1.99919533,\n", - " -1.80879577, -1.61839622, -1.42799666, -1.23759711, -1.04719755,\n", - " -0.856798 , -0.66639844, -0.47599889, -0.28559933, -0.09519978,\n", - " 0.09519978, 0.28559933, 0.47599889, 0.66639844, 0.856798 ,\n", - " 1.04719755, 1.23759711, 1.42799666, 1.61839622, 1.80879577,\n", - " 1.99919533, 2.18959488, 2.37999443, 2.57039399, 2.76079354,\n", - " 2.9511931 , 3.14159265, 3.33199221, 3.52239176, 3.71279132,\n", - " 3.90319087, 4.09359043, 4.28398998, 4.47438954, 4.66478909,\n", - " 4.85518865, 5.0455882 , 5.23598776, 5.42638731, 5.61678687,\n", - " 5.80718642, 5.99758598, 6.18798553, 6.37838508, 6.56878464,\n", - " 6.75918419, 6.94958375, 7.1399833 , 7.33038286, 7.52078241,\n", - " 7.71118197, 7.90158152, 8.09198108, 8.28238063, 8.47278019,\n", - " 8.66317974, 8.8535793 , 9.04397885, 9.23437841, 9.42477796])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x = np.linspace(-3*np.pi, 3*np.pi, 100)\n", - "\n", - "x" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([-3.67394040e-16, -1.89251244e-01, -3.71662456e-01, -5.40640817e-01,\n", - " -6.90079011e-01, -8.14575952e-01, -9.09631995e-01, -9.71811568e-01,\n", - " -9.98867339e-01, -9.89821442e-01, -9.45000819e-01, -8.66025404e-01,\n", - " -7.55749574e-01, -6.18158986e-01, -4.58226522e-01, -2.81732557e-01,\n", - " -9.50560433e-02, 9.50560433e-02, 2.81732557e-01, 4.58226522e-01,\n", - " 6.18158986e-01, 7.55749574e-01, 8.66025404e-01, 9.45000819e-01,\n", - " 9.89821442e-01, 9.98867339e-01, 9.71811568e-01, 9.09631995e-01,\n", - " 8.14575952e-01, 6.90079011e-01, 5.40640817e-01, 3.71662456e-01,\n", - " 1.89251244e-01, -1.22464680e-16, -1.89251244e-01, -3.71662456e-01,\n", - " -5.40640817e-01, -6.90079011e-01, -8.14575952e-01, -9.09631995e-01,\n", - " -9.71811568e-01, -9.98867339e-01, -9.89821442e-01, -9.45000819e-01,\n", - " -8.66025404e-01, -7.55749574e-01, -6.18158986e-01, -4.58226522e-01,\n", - " -2.81732557e-01, -9.50560433e-02, 9.50560433e-02, 2.81732557e-01,\n", - " 4.58226522e-01, 6.18158986e-01, 7.55749574e-01, 8.66025404e-01,\n", - " 9.45000819e-01, 9.89821442e-01, 9.98867339e-01, 9.71811568e-01,\n", - " 9.09631995e-01, 8.14575952e-01, 6.90079011e-01, 5.40640817e-01,\n", - " 3.71662456e-01, 1.89251244e-01, 1.22464680e-16, -1.89251244e-01,\n", - " -3.71662456e-01, -5.40640817e-01, -6.90079011e-01, -8.14575952e-01,\n", - " -9.09631995e-01, -9.71811568e-01, -9.98867339e-01, -9.89821442e-01,\n", - " -9.45000819e-01, -8.66025404e-01, -7.55749574e-01, -6.18158986e-01,\n", - " -4.58226522e-01, -2.81732557e-01, -9.50560433e-02, 9.50560433e-02,\n", - " 2.81732557e-01, 4.58226522e-01, 6.18158986e-01, 7.55749574e-01,\n", - " 8.66025404e-01, 9.45000819e-01, 9.89821442e-01, 9.98867339e-01,\n", - " 9.71811568e-01, 9.09631995e-01, 8.14575952e-01, 6.90079011e-01,\n", - " 5.40640817e-01, 3.71662456e-01, 1.89251244e-01, 3.67394040e-16])" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y = np.sin(x)\n", - "\n", - "y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With matplotlib's [plot()](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot) function we can visualize the sinus curve." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x, y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us quickly generate some random data and draw a scatter plot." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "x = np.random.normal(42, 3, 100)\n", - "y = np.random.gamma(7, 1, 100)\n", - "\n", - "plt.scatter(x, y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Case Study (continued): Importing the Iris data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The sklearn library provides several sample datasets, among which is also the Iris dataset.\n", - "\n", - "As a table, the dataset would look like:\n", - "\n", - "\n", - "However, the data object imported from sklearn is organized slightly different. In particular, the so-called **features** are seperated from the **labels**." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], "source": [ "from sklearn.datasets import load_iris" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -695,12 +181,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Using Python's **dir()** function we can inspect the data object, i.e. find out what **attributes** it has." + "Using Python's `dir()` function we can inspect the data object, i.e. find out what **attributes** it has." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -715,7 +201,7 @@ " 'target_names']" ] }, - "execution_count": 20, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -728,12 +214,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "iris.data provides us with a Numpy array, where the first dimension equals the number of observed flowers (**instances**) and the second dimension lists the various features of a flower." + "`iris.data` provides us with a `numpy.ndarray`, where the first dimension equals the number of observed flowers (i.e., the **instances**) and the second dimension lists the various features of a flower." ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -891,7 +377,7 @@ " [5.9, 3. , 5.1, 1.8]])" ] }, - "execution_count": 21, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -909,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -921,7 +407,7 @@ " 'petal width (cm)']" ] }, - "execution_count": 22, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -939,7 +425,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -954,7 +440,7 @@ " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])" ] }, - "execution_count": 23, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -972,7 +458,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -981,7 +467,7 @@ "array(['setosa', 'versicolor', 'virginica'], dtype='" ] @@ -1027,9 +522,11 @@ "colors = ['blue', 'red', 'green']\n", "\n", "for label, color in zip(range(len(iris.target_names)), colors):\n", - " plt.hist(iris.data[iris.target==label, feature_index], \n", - " label=iris.target_names[label],\n", - " color=color)\n", + " plt.hist(\n", + " iris.data[iris.target==label, feature_index], \n", + " label=iris.target_names[label],\n", + " color=color,\n", + " )\n", "\n", "plt.xlabel(iris.feature_names[feature_index])\n", "plt.legend(loc='upper right')\n", @@ -1045,12 +542,12 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1068,10 +565,12 @@ "colors = ['blue', 'red', 'green']\n", "\n", "for label, color in zip(range(len(iris.target_names)), colors):\n", - " plt.scatter(iris.data[iris.target==label, first_feature_index], \n", - " iris.data[iris.target==label, second_feature_index],\n", - " label=iris.target_names[label],\n", - " c=color)\n", + " plt.scatter(\n", + " iris.data[iris.target==label, first_feature_index], \n", + " iris.data[iris.target==label, second_feature_index],\n", + " label=iris.target_names[label],\n", + " c=color,\n", + " )\n", "\n", "plt.xlabel(iris.feature_names[first_feature_index])\n", "plt.ylabel(iris.feature_names[second_feature_index])\n", @@ -1083,17 +582,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Using the higher level library pandas, one can easily create a so-called **scatterplot matrix**." + "Using the higher level library `pandas`, one can easily create a so-called **scatterplot matrix**." ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1114,18 +622,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Concept of Generalization" + "### Concept of Generalization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The goal of a supervised machine learning model is to make predictions on new (i.e., previously unseen) data.\n", + "The goal of a supervised machine learning model is to make predictions on *new* (i.e., previously unseen) data.\n", "\n", "In a real-world application, we are not interested in marking an already labeled email as spam or not. Instead, we want to make the user's life easier by automatically classifying new incoming mail.\n", "\n", - "In order to get an idea of how good a model generalizes, a best practice is to split the available data into a training and a test set. Only the former is used to train the model. Then predictions are made on the test data and the predictions can be compared with the actual labels.\n", + "In order to get an idea of how good a model **generalizes**, a best practice is to *split* the available data into a **training** and a **test** set. Only the former is used to train the model. Then, predictions are made on the test data and the predictions can be compared with the actual labels.\n", "\n", "Common splits are 75/25 or 60/40." ] @@ -1134,26 +642,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Case Study (continued): Train/Test Split for the Iris data" + "### Train/Test Split for the Iris data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "It is common practice to refer to the feature matrix as X and the vector of labels as y." + "It is common practice to refer to the feature matrix as `X` and the vector of labels as `y`." ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -1169,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -1185,7 +693,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1196,7 +704,7 @@ " 2, 2, 2, 2, 2, 2])" ] }, - "execution_count": 30, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1207,7 +715,16 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1216,7 +733,7 @@ "array([ 0, 0, 50])" ] }, - "execution_count": 31, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1229,12 +746,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "sklearn provides a function that not only randomizes the split but also ensures that the resulting label distribution is proportionate to the overall distribution (called **stratification**)." + "`sklearn` provides a function that not only randomizes the split but also ensures that the resulting label distribution is proportionate to the overall distribution, a concept called **stratification**." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -1243,18 +760,18 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0, 0, 1, 2, 0, 0, 1, 1, 2, 0, 2, 0, 1, 0, 2, 0, 2, 1, 2, 0, 2, 2,\n", - " 2, 1, 2, 0, 2, 1, 1, 1, 1, 1, 0, 0, 2, 1, 2, 1, 0, 0, 1, 2, 1, 0,\n", - " 2])" + "array([1, 0, 2, 2, 1, 0, 1, 1, 1, 0, 0, 2, 2, 0, 0, 2, 0, 1, 0, 0, 2, 2,\n", + " 0, 2, 1, 0, 2, 2, 2, 1, 0, 1, 1, 2, 0, 1, 2, 1, 2, 1, 2, 1, 0, 1,\n", + " 0])" ] }, - "execution_count": 33, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1267,7 +784,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1276,7 +793,7 @@ "array([15, 15, 15])" ] }, - "execution_count": 34, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1289,7 +806,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## A simple Classification Model: k-Nearest Neighbors" + "### A simple Classification Model: k-Nearest Neighbors" ] }, { @@ -1303,26 +820,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "" + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Case Study (continued): Train and Predict the Iris data" + "### Training and Predicting with the Iris data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "sklearn provides a uniform interface for all its classification models. They all have a **fit()** and a **predict()** method that abstract away the actual machine learning algorithm." + "`sklearn` provides a uniform interface for all its classification models. They all have a `.fit()` and a `.predict()` method that abstract away the actual machine learning algorithm." ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1331,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1351,18 +868,18 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0, 0, 1, 2, 0, 0, 1, 1, 2, 0, 2, 0, 1, 0, 2, 0, 2, 1, 2, 0, 2, 2,\n", - " 2, 1, 2, 0, 2, 1, 1, 1, 1, 1, 0, 0, 2, 1, 2, 1, 0, 0, 1, 2, 1, 0,\n", - " 2])" + "array([1, 0, 2, 2, 1, 0, 1, 1, 1, 0, 0, 2, 1, 0, 0, 2, 0, 2, 0, 0, 2, 2,\n", + " 0, 2, 1, 0, 2, 1, 2, 1, 0, 1, 1, 2, 0, 1, 2, 1, 2, 1, 2, 1, 0, 1,\n", + " 0])" ] }, - "execution_count": 37, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1380,18 +897,18 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0, 0, 1, 2, 0, 0, 1, 1, 2, 0, 2, 0, 1, 0, 2, 0, 2, 1, 2, 0, 2, 2,\n", - " 2, 1, 2, 0, 2, 1, 1, 1, 1, 1, 0, 0, 2, 1, 2, 1, 0, 0, 1, 2, 1, 0,\n", - " 2])" + "array([1, 0, 2, 2, 1, 0, 1, 1, 1, 0, 0, 2, 2, 0, 0, 2, 0, 1, 0, 0, 2, 2,\n", + " 0, 2, 1, 0, 2, 2, 2, 1, 0, 1, 1, 2, 0, 1, 2, 1, 2, 1, 2, 1, 0, 1,\n", + " 0])" ] }, - "execution_count": 38, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1404,21 +921,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Numpy can show us the indices where the predictions are wrong." + "`numpy` shows us the indices where the predictions are wrong." ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(array([], dtype=int64),)" + "(array([12, 17, 27]),)" ] }, - "execution_count": 39, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1436,16 +953,16 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "1.0" + "0.9333333333333333" ] }, - "execution_count": 40, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1458,12 +975,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It is important to mention that we can also \"predict\" the training set. Surprisingly, the model does not get the training set 100% correct." + "It is important to mention that we can also \"predict\" the training set. Somehow surprisingly, the model does not get the training set 100% correct." ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -1472,7 +989,7 @@ "0.9523809523809523" ] }, - "execution_count": 41, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1492,12 +1009,12 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1519,11 +1036,19 @@ "\n", "for n, color in enumerate(colors):\n", " idx = np.where(y_test == n)[0]\n", - " plt.scatter(X_test[idx, first_feature_index], X_test[idx, second_feature_index], color=color,\n", - " label=iris.target_names[n])\n", + " plt.scatter(\n", + " X_test[idx, first_feature_index],\n", + " X_test[idx, second_feature_index],\n", + " color=color,\n", + " label=iris.target_names[n],\n", + " )\n", "\n", - "plt.scatter(X_test[incorrect_idx, first_feature_index], X_test[incorrect_idx, second_feature_index],\n", - " color=\"darkred\", label='misclassified')\n", + "plt.scatter(\n", + " X_test[incorrect_idx, first_feature_index],\n", + " X_test[incorrect_idx, second_feature_index],\n", + " color=\"darkred\",\n", + " label='misclassified',\n", + ")\n", "\n", "plt.xlabel('sepal width [cm]')\n", "plt.ylabel('petal length [cm]')\n", @@ -1536,48 +1061,48 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In practice, the number of neighbors is to chosen before the model is trained. Therefore, it is possible to \"optimize\" it. This process is referred to as **hyper-parameter** tuning. For the Iris dataset this does not make much of a difference." + "In practice, the number of neighbors must be chosen before the model is trained. Therefore, it is possible to \"optimize\" it. This process is referred to as **hyper-parameter tuning**. For the Iris dataset this does not make much of a difference." ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1 1.0\n", - "2 0.9555555555555556\n", - "3 1.0\n", - "4 0.9777777777777777\n", - "5 1.0\n", - "6 1.0\n", - "7 1.0\n", - "8 0.9777777777777777\n", - "9 0.9777777777777777\n", - "10 0.9777777777777777\n", - "11 0.9777777777777777\n", - "12 0.9777777777777777\n", - "13 1.0\n", - "14 0.9777777777777777\n", - "15 0.9555555555555556\n", - "16 0.9777777777777777\n", - "17 0.9555555555555556\n", - "18 0.9777777777777777\n", - "19 0.9777777777777777\n", - "20 0.9777777777777777\n", - "21 0.9555555555555556\n", - "22 0.9777777777777777\n", - "23 0.9555555555555556\n", - "24 0.9777777777777777\n", - "25 0.9555555555555556\n", - "26 0.9777777777777777\n", - "27 0.9555555555555556\n", - "28 0.9777777777777777\n", - "29 0.9777777777777777\n", - "30 0.9777777777777777\n" + "1 0.9555555555555556\n", + "2 0.9333333333333333\n", + "3 0.9333333333333333\n", + "4 0.9333333333333333\n", + "5 0.9333333333333333\n", + "6 0.9333333333333333\n", + "7 0.9111111111111111\n", + "8 0.9111111111111111\n", + "9 0.9111111111111111\n", + "10 0.9333333333333333\n", + "11 0.9555555555555556\n", + "12 0.9555555555555556\n", + "13 0.9333333333333333\n", + "14 0.9111111111111111\n", + "15 0.9333333333333333\n", + "16 0.9111111111111111\n", + "17 0.9333333333333333\n", + "18 0.9111111111111111\n", + "19 0.9333333333333333\n", + "20 0.9333333333333333\n", + "21 0.9333333333333333\n", + "22 0.9333333333333333\n", + "23 0.9111111111111111\n", + "24 0.9555555555555556\n", + "25 0.9111111111111111\n", + "26 0.9333333333333333\n", + "27 0.9111111111111111\n", + "28 0.9333333333333333\n", + "29 0.9555555555555556\n", + "30 0.9111111111111111\n" ] } ], @@ -1594,21 +1119,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## WHU's Python Course in the BSc program" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- free [online book](https://github.com/webartifex/intro-to-python) by the author of this workshop" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Literature on Machine Learning" + "### Further Resources on Machine Learning" ] }, { @@ -1624,7 +1135,7 @@ "source": [ "- [Python Machine Learning](https://www.amazon.de/Python-Machine-Learning-scikit-learn-TensorFlow/dp/1787125939/ref=sr_1_1?__mk_de_DE=%C3%85M%C3%85%C5%BD%C3%95%C3%91&keywords=python+machine+learning&qid=1575545025&sr=8-1) by Sebastian Raschka\n", "\n", - "" + "" ] }, { @@ -1633,7 +1144,7 @@ "source": [ "- [An Introduction to Statistical Learning](http://faculty.marshall.usc.edu/gareth-james/ISL/)\n", "\n", - "" + "" ] } ], @@ -1653,7 +1164,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.9" }, "toc": { "base_numbering": 1, diff --git a/LICENSE.txt b/LICENSE.txt index 0ec444a..e7802f3 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2018-2020 Alexander Hess [alexander@webartifex.biz] +Copyright (c) 2018-2021 Alexander Hess [alexander@webartifex.biz] Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index 1264a22..fdd6a87 100644 --- a/README.md +++ b/README.md @@ -1,50 +1,64 @@ -# Workshop: Machine Learning for Beginners +# An Introduction to Data Science -This repository contains the code for the workshop "Machine Learning for -Beginners" as presented in various occasions at -[WHU - Otto Beisheim School of Management](https://www.whu.edu), such as the -[Campus for Supply Chain Management](https://www.campus-for-supply-chain-management-cscm.de/), -[IdeaLab](https://www.idealab.io)'s [IdeaHack](http://www.ideahack.io), or -within many [executive education](https://ee.whu.edu/) programs. +This project is an introductory workshop + in **[Data Science ](https://en.wikipedia.org/wiki/Data_science)** + in the programming language **[Python ](https://www.python.org/)**. +To learn about Python and programming in detail, + this [introductory course ](https://github.com/webartifex/intro-to-python) is recommended. -## Prerequisites +### Table of Contents -To be suitable for *total beginners*, there are *no* prerequisites. -If you are interested to learn more after this workshop, check out the -full-semester course **[Introduction to Python & Programming](https://github.com/webartifex/intro-to-python)**. +- *Chapter 0*: [Python in a Nutshell](00_python_in_a_nutshell.ipynb) +- *Chapter 1*: [Python's Scientific Stack](01_scientific_stack.ipynb) +- *Chapter 2*: [A first Example: Classifying Flowers](02_a_first_example.ipynb) +- *Chapter 3*: [Case Study: House Prices in Ames, Iowa ](https://github.com/webartifex/ames-housing) -## Installation +### Objective -To follow this workshop on your own computer, a working installation of -**Python 3.7** or higher is required. +The **main goal** is to **show** students + how **Python** can be used to solve typical **data science** tasks. -A popular and beginner friendly way is to install the [Anaconda Distribution](https://www.anaconda.com/distribution/) -that not only ships Python but comes pre-packaged with a lot of third-party -libraries from the so-called "scientific stack". -Just go to the [download](https://www.anaconda.com/distribution/#download-section) -section and install the latest version (i.e., *2020-02* with Python 3.7 at the -time of this writing) for your operating system. -Then, among others, you will find an entry "Jupyter Notebook" in your start -menu. -Click on it and a new tab in your web browser will open where you can switch -between folders as you could in your computer's default file browser. +### Prerequisites -To download the course's materials as a ZIP file, click on the green "Clone or -download" button on the top right on this website. -Then, unpack the ZIP file into a folder of your choosing (ideally somewhere -within your personal user folder so that the files show up right away). +To be suitable for *beginners*, there are *no* formal prerequisites. +It is only expected that the student has: +- a *solid* understanding of the **English** language and +- knowledge of **basic mathematics** from high school. + + +### Getting started & Installation + +To follow this workshop, an installation of **Python 3.8** or higher is expected. + +A popular and beginner friendly way is + to install the [Anaconda Distribution](https://www.anaconda.com/products/individual) + that not only ships Python itself + but also comes pre-packaged with a lot of third-party libraries + including [Python's scientific stack](https://scipy.org/about.html). + +Detailed instructions can be found [here ](https://github.com/webartifex/intro-to-python#installation). + + +## Contributing + +Feedback **is highly encouraged** and will be incorporated. +Open an issue in the [issues tracker ](https://github.com/webartifex/intro-to-data-science/issues) + or initiate a [pull request ](https://help.github.com/en/articles/about-pull-requests) + if you are familiar with the concept. +Simple issues that *anyone* can **help fix** are, for example, + **spelling mistakes** or **broken links**. +If you feel that some topic is missing entirely, you may also mention that. +The materials here are considered a **permanent work-in-progress**. ## About the Author -Alexander Hess is a PhD student at the Chair of Logistics Management at the -[WHU - Otto Beisheim School of Management](https://www.whu.edu) where he -conducts research on urban delivery platforms and teaches an introductory -course on Python (cf., [Fall Term 2019](https://vlv.whu.edu/campus/all/event.asp?objgguid=0xE57C2715B01B441AAFD3E79AA05CACCF&from=vvz&gguid=0x6A2B0ED5B2B949E69957A2099E7DE2F1&mode=own&tguid=0x3980A9BBC3BF4A638E977F2DC163F44B&lang=en), -[Spring Term 2020](https://vlv.whu.edu/campus/all/event.asp?objgguid=0x3354F4C108FF4E959CDD692A325D9AFE&from=vvz&gguid=0x262E29795DD742CFBDE72B12B69CEFD6&mode=own&lang=en&tguid=0x2E4A7D1FF3C34AD08FF07685461781C9)). - -Connect him on [LinkedIn](https://www.linkedin.com/in/webartifex). +Alexander Hess is a PhD student + at the Chair of Logistics Management at [WHU - Otto Beisheim School of Management](https://www.whu.edu) + where he conducts research on urban delivery platforms + and teaches coding courses based on Python in the BSc and MBA programs. +Connect with him on [LinkedIn](https://www.linkedin.com/in/webartifex). diff --git a/poetry.lock b/poetry.lock index f014c8d..5d0e1e9 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,66 +1,93 @@ [[package]] +name = "anyio" +version = "3.1.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" category = "main" -description = "Disable App Nap on OS X 10.9" -marker = "sys_platform == \"darwin\" or platform_system == \"Darwin\"" -name = "appnope" optional = false -python-versions = "*" -version = "0.1.0" +python-versions = ">=3.6.2" + +[package.dependencies] +idna = ">=2.8" +sniffio = ">=1.1" + +[package.extras] +doc = ["sphinx-rtd-theme", "sphinx-autodoc-typehints (>=1.2.0)"] +test = ["coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "pytest (>=6.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (<0.15)", "mock (>=4)", "uvloop (>=0.15)"] +trio = ["trio (>=0.16)"] [[package]] +name = "appnope" +version = "0.1.2" +description = "Disable App Nap on macOS >= 10.9" category = "main" -description = "The secure Argon2 password hashing algorithm." -name = "argon2-cffi" optional = false python-versions = "*" + +[[package]] +name = "argon2-cffi" version = "20.1.0" +description = "The secure Argon2 password hashing algorithm." +category = "main" +optional = false +python-versions = "*" [package.dependencies] cffi = ">=1.0.0" six = "*" [package.extras] -dev = ["coverage (>=5.0.2)", "hypothesis", "pytest", "sphinx", "wheel", "pre-commit"] +dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pytest", "sphinx", "wheel", "pre-commit"] docs = ["sphinx"] -tests = ["coverage (>=5.0.2)", "hypothesis", "pytest"] +tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pytest"] [[package]] -category = "main" -description = "Async generators and context managers for Python 3.5+" name = "async-generator" +version = "1.10" +description = "Async generators and context managers for Python 3.5+" +category = "main" optional = false python-versions = ">=3.5" -version = "1.10" [[package]] -category = "main" -description = "Classes Without Boilerplate" name = "attrs" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "20.2.0" - -[package.extras] -dev = ["coverage (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "zope.interface", "sphinx", "sphinx-rtd-theme", "pre-commit"] -docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"] -tests = ["coverage (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "zope.interface"] -tests_no_zope = ["coverage (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six"] - -[[package]] +version = "21.2.0" +description = "Classes Without Boilerplate" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" + +[package.extras] +dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit"] +docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"] +tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface"] +tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins"] + +[[package]] +name = "babel" +version = "2.9.1" +description = "Internationalization utilities" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + +[package.dependencies] +pytz = ">=2015.7" + +[[package]] +name = "backcall" +version = "0.2.0" +description = "Specifications for callback functions passed in to an API" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "bleach" +version = "3.3.0" +description = "An easy safelist-based HTML-sanitizing tool." category = "main" -description = "Specifications for callback functions passed in to an API" -name = "backcall" -optional = false -python-versions = "*" -version = "0.2.0" - -[[package]] -category = "main" -description = "An easy safelist-based HTML-sanitizing tool." -name = "bleach" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "3.2.0" [package.dependencies] packaging = "*" @@ -68,141 +95,108 @@ six = ">=1.9.0" webencodings = "*" [[package]] -category = "main" -description = "Python package for providing Mozilla's CA Bundle." -name = "certifi" -optional = false -python-versions = "*" -version = "2020.6.20" - -[[package]] -category = "main" -description = "Foreign Function Interface for Python calling C code." name = "cffi" +version = "1.14.5" +description = "Foreign Function Interface for Python calling C code." +category = "main" optional = false python-versions = "*" -version = "1.14.3" [package.dependencies] pycparser = "*" [[package]] -category = "main" -description = "Universal encoding detector for Python 2 and 3" -name = "chardet" -optional = false -python-versions = "*" -version = "3.0.4" - -[[package]] -category = "main" -description = "Cross-platform colored terminal text." -marker = "sys_platform == \"win32\"" name = "colorama" +version = "0.4.4" +description = "Cross-platform colored terminal text." +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "0.4.3" [[package]] -category = "main" -description = "Composable style cycles" name = "cycler" +version = "0.10.0" +description = "Composable style cycles" +category = "main" optional = false python-versions = "*" -version = "0.10.0" [package.dependencies] six = "*" [[package]] -category = "main" -description = "Decorators for Humans" name = "decorator" -optional = false -python-versions = ">=2.6, !=3.0.*, !=3.1.*" -version = "4.4.2" - -[[package]] +version = "5.0.9" +description = "Decorators for Humans" +category = "main" +optional = false +python-versions = ">=3.5" + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" + +[[package]] +name = "entrypoints" +version = "0.3" +description = "Discover and load entry points from installed packages." +category = "main" +optional = false +python-versions = ">=2.7" + +[[package]] +name = "idna" +version = "3.1" +description = "Internationalized Domain Names in Applications (IDNA)" +category = "main" +optional = false +python-versions = ">=3.4" + +[[package]] +name = "ipykernel" +version = "5.5.5" +description = "IPython Kernel for Jupyter" category = "main" -description = "XML bomb protection for Python stdlib modules" -name = "defusedxml" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "0.6.0" - -[[package]] -category = "main" -description = "Discover and load entry points from installed packages." -name = "entrypoints" -optional = false -python-versions = ">=2.7" -version = "0.3" - -[[package]] -category = "main" -description = "Internationalized Domain Names in Applications (IDNA)" -name = "idna" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "2.10" - -[[package]] -category = "main" -description = "Read metadata from Python packages" -marker = "python_version < \"3.8\"" -name = "importlib-metadata" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" -version = "1.7.0" - -[package.dependencies] -zipp = ">=0.5" - -[package.extras] -docs = ["sphinx", "rst.linker"] -testing = ["packaging", "pep517", "importlib-resources (>=1.3)"] - -[[package]] -category = "main" -description = "IPython Kernel for Jupyter" -name = "ipykernel" optional = false python-versions = ">=3.5" -version = "5.3.4" [package.dependencies] -appnope = "*" +appnope = {version = "*", markers = "platform_system == \"Darwin\""} ipython = ">=5.0.0" jupyter-client = "*" tornado = ">=4.2" traitlets = ">=4.1.0" [package.extras] -test = ["pytest (!=5.3.4)", "pytest-cov", "flaky", "nose"] +test = ["pytest (!=5.3.4)", "pytest-cov", "flaky", "nose", "jedi (<=0.17.2)"] [[package]] -category = "main" -description = "IPython: Productive Interactive Computing" name = "ipython" +version = "7.23.1" +description = "IPython: Productive Interactive Computing" +category = "main" optional = false python-versions = ">=3.7" -version = "7.18.1" [package.dependencies] -appnope = "*" +appnope = {version = "*", markers = "sys_platform == \"darwin\""} backcall = "*" -colorama = "*" +colorama = {version = "*", markers = "sys_platform == \"win32\""} decorator = "*" -jedi = ">=0.10" -pexpect = ">4.3" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} pickleshare = "*" prompt-toolkit = ">=2.0.0,<3.0.0 || >3.0.0,<3.0.1 || >3.0.1,<3.1.0" pygments = "*" -setuptools = ">=18.5" traitlets = ">=4.2" [package.extras] -all = ["Sphinx (>=1.3)", "ipykernel", "ipyparallel", "ipywidgets", "nbconvert", "nbformat", "nose (>=0.10.1)", "notebook", "numpy (>=1.14)", "pygments", "qtconsole", "requests", "testpath"] +all = ["Sphinx (>=1.3)", "ipykernel", "ipyparallel", "ipywidgets", "nbconvert", "nbformat", "nose (>=0.10.1)", "notebook", "numpy (>=1.16)", "pygments", "qtconsole", "requests", "testpath"] doc = ["Sphinx (>=1.3)"] kernel = ["ipykernel"] nbconvert = ["nbconvert"] @@ -210,211 +204,266 @@ nbformat = ["nbformat"] notebook = ["notebook", "ipywidgets"] parallel = ["ipyparallel"] qtconsole = ["qtconsole"] -test = ["nose (>=0.10.1)", "requests", "testpath", "pygments", "nbformat", "ipykernel", "numpy (>=1.14)"] +test = ["nose (>=0.10.1)", "requests", "testpath", "pygments", "nbformat", "ipykernel", "numpy (>=1.16)"] [[package]] -category = "main" -description = "Vestigial utilities from IPython" name = "ipython-genutils" +version = "0.2.0" +description = "Vestigial utilities from IPython" +category = "main" optional = false python-versions = "*" -version = "0.2.0" [[package]] -category = "main" -description = "An autocompletion tool for Python that can be used for text editors." name = "jedi" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "0.17.2" - -[package.dependencies] -parso = ">=0.7.0,<0.8.0" - -[package.extras] -qa = ["flake8 (3.7.9)"] -testing = ["Django (<3.1)", "colorama", "docopt", "pytest (>=3.9.0,<5.0.0)"] - -[[package]] +version = "0.18.0" +description = "An autocompletion tool for Python that can be used for text editors." category = "main" -description = "A very fast and expressive template engine." -name = "jinja2" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "2.11.2" - -[package.dependencies] -MarkupSafe = ">=0.23" - -[package.extras] -i18n = ["Babel (>=0.8)"] - -[[package]] -category = "main" -description = "Lightweight pipelining: using Python functions as pipeline jobs." -name = "joblib" optional = false python-versions = ">=3.6" -version = "0.16.0" + +[package.dependencies] +parso = ">=0.8.0,<0.9.0" + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["Django (<3.1)", "colorama", "docopt", "pytest (<6.0.0)"] [[package]] +name = "jinja2" +version = "3.0.1" +description = "A very fast and expressive template engine." category = "main" -description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = ">=3.6" + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "joblib" +version = "1.0.1" +description = "Lightweight pipelining with Python functions" +category = "main" +optional = false +python-versions = ">=3.6" + +[[package]] name = "json5" +version = "0.9.5" +description = "A Python implementation of the JSON5 data format." +category = "main" optional = false python-versions = "*" -version = "0.9.5" [package.extras] dev = ["hypothesis"] [[package]] -category = "main" -description = "An implementation of JSON Schema validation for Python" name = "jsonschema" +version = "3.2.0" +description = "An implementation of JSON Schema validation for Python" +category = "main" optional = false python-versions = "*" -version = "3.2.0" [package.dependencies] attrs = ">=17.4.0" pyrsistent = ">=0.14.0" -setuptools = "*" six = ">=1.11.0" -[package.dependencies.importlib-metadata] -python = "<3.8" -version = "*" - [package.extras] format = ["idna", "jsonpointer (>1.13)", "rfc3987", "strict-rfc3339", "webcolors"] format_nongpl = ["idna", "jsonpointer (>1.13)", "webcolors", "rfc3986-validator (>0.1.0)", "rfc3339-validator"] [[package]] -category = "main" -description = "Jupyter protocol implementation and client libraries" name = "jupyter-client" +version = "6.2.0" +description = "Jupyter protocol implementation and client libraries" +category = "main" optional = false -python-versions = ">=3.5" -version = "6.1.7" +python-versions = ">=3.6.1" [package.dependencies] jupyter-core = ">=4.6.0" +nest-asyncio = ">=1.5" python-dateutil = ">=2.1" pyzmq = ">=13" tornado = ">=4.1" traitlets = "*" [package.extras] -test = ["ipykernel", "ipython", "mock", "pytest", "pytest-asyncio", "async-generator", "pytest-timeout"] +doc = ["sphinx (>=1.3.6)", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] +test = ["async-generator", "ipykernel", "ipython", "mock", "pytest-asyncio", "pytest-timeout", "pytest", "mypy", "pre-commit", "jedi (<0.18)"] [[package]] -category = "main" -description = "Jupyter core package. A base package on which Jupyter projects rely." name = "jupyter-core" +version = "4.7.1" +description = "Jupyter core package. A base package on which Jupyter projects rely." +category = "main" optional = false -python-versions = "!=3.0,!=3.1,!=3.2,!=3.3,!=3.4,>=2.7" -version = "4.6.3" +python-versions = ">=3.6" [package.dependencies] -pywin32 = ">=1.0" +pywin32 = {version = ">=1.0", markers = "sys_platform == \"win32\""} traitlets = "*" [[package]] +name = "jupyter-server" +version = "1.8.0" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." category = "main" -description = "The JupyterLab notebook server extension." -name = "jupyterlab" optional = false -python-versions = ">=3.5" -version = "2.2.8" +python-versions = ">=3.6" [package.dependencies] -jinja2 = ">=2.10" -jupyterlab-server = ">=1.1.5,<2.0" -notebook = ">=4.3.1" -tornado = "<6.0.0 || >6.0.0,<6.0.1 || >6.0.1,<6.0.2 || >6.0.2" +anyio = ">=3.1.0,<4" +argon2-cffi = "*" +ipython-genutils = "*" +jinja2 = "*" +jupyter-client = ">=6.1.1" +jupyter-core = ">=4.6.0" +nbconvert = "*" +nbformat = "*" +prometheus-client = "*" +pyzmq = ">=17" +Send2Trash = "*" +terminado = ">=0.8.3" +tornado = ">=6.1.0" +traitlets = ">=4.2.1" +websocket-client = "*" [package.extras] -docs = ["jsx-lexer", "recommonmark", "sphinx", "sphinx-rtd-theme", "sphinx-copybutton"] -test = ["pytest", "pytest-check-links", "requests", "wheel", "virtualenv"] +test = ["coverage", "pytest", "pytest-cov", "pytest-mock", "requests", "pytest-tornasync", "pytest-console-scripts", "ipykernel"] [[package]] +name = "jupyterlab" +version = "3.0.16" +description = "JupyterLab computational environment" category = "main" -description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +ipython = "*" +jinja2 = ">=2.1" +jupyter-core = "*" +jupyter-server = ">=1.4,<2.0" +jupyterlab-server = ">=2.3,<3.0" +nbclassic = ">=0.2,<1.0" +packaging = "*" +tornado = ">=6.1.0" + +[package.extras] +test = ["coverage", "pytest (>=6.0)", "pytest-cov", "pytest-console-scripts", "pytest-check-links (>=0.5)", "jupyterlab-server[test] (>=2.2,<3.0)", "requests", "requests-cache", "virtualenv", "check-manifest"] + +[[package]] name = "jupyterlab-pygments" +version = "0.1.2" +description = "Pygments theme using JupyterLab CSS variables" +category = "main" optional = false python-versions = "*" -version = "0.1.1" [package.dependencies] pygments = ">=2.4.1,<3" [[package]] -category = "main" -description = "JupyterLab Server" name = "jupyterlab-server" +version = "2.5.2" +description = "A set of server components for JupyterLab and JupyterLab like applications ." +category = "main" optional = false -python-versions = ">=3.5" -version = "1.2.0" +python-versions = ">=3.6" [package.dependencies] +babel = "*" jinja2 = ">=2.10" json5 = "*" jsonschema = ">=3.0.1" -notebook = ">=4.2.0" +jupyter-server = ">=1.4,<2.0" +packaging = "*" requests = "*" [package.extras] -test = ["pytest", "requests"] +test = ["codecov", "ipykernel", "pytest (>=5.3.2)", "pytest-cov", "jupyter-server", "openapi-core (>=0.13.8,<0.14.0)", "pytest-console-scripts", "strict-rfc3339", "ruamel.yaml", "wheel"] [[package]] -category = "main" -description = "A fast implementation of the Cassowary constraint solver" name = "kiwisolver" +version = "1.3.1" +description = "A fast implementation of the Cassowary constraint solver" +category = "main" optional = false python-versions = ">=3.6" -version = "1.2.0" [[package]] -category = "main" -description = "Safely add untrusted strings to HTML/XML markup." name = "markupsafe" -optional = false -python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*" -version = "1.1.1" - -[[package]] +version = "2.0.1" +description = "Safely add untrusted strings to HTML/XML markup." category = "main" -description = "Python plotting package" -name = "matplotlib" optional = false python-versions = ">=3.6" -version = "3.3.2" + +[[package]] +name = "matplotlib" +version = "3.4.2" +description = "Python plotting package" +category = "main" +optional = false +python-versions = ">=3.7" [package.dependencies] -certifi = ">=2020.06.20" cycler = ">=0.10" kiwisolver = ">=1.0.1" -numpy = ">=1.15" +numpy = ">=1.16" pillow = ">=6.2.0" -pyparsing = ">=2.0.3,<2.0.4 || >2.0.4,<2.1.2 || >2.1.2,<2.1.6 || >2.1.6" -python-dateutil = ">=2.1" +pyparsing = ">=2.2.1" +python-dateutil = ">=2.7" [[package]] +name = "matplotlib-inline" +version = "0.1.2" +description = "Inline Matplotlib backend for Jupyter" category = "main" -description = "The fastest markdown parser in pure Python" +optional = false +python-versions = ">=3.5" + +[package.dependencies] +traitlets = "*" + +[[package]] name = "mistune" +version = "0.8.4" +description = "The fastest markdown parser in pure Python" +category = "main" optional = false python-versions = "*" -version = "0.8.4" [[package]] +name = "nbclassic" +version = "0.3.1" +description = "Jupyter Notebook as a Jupyter Server Extension." category = "main" -description = "A client library for executing notebooks. Formally nbconvert's ExecutePreprocessor." -name = "nbclient" optional = false python-versions = ">=3.6" -version = "0.5.0" + +[package.dependencies] +jupyter-server = ">=1.8,<2.0" +notebook = "<7" + +[package.extras] +test = ["pytest", "pytest-tornasync", "pytest-console-scripts"] + +[[package]] +name = "nbclient" +version = "0.5.3" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +category = "main" +optional = false +python-versions = ">=3.6.1" [package.dependencies] async-generator = "*" @@ -429,12 +478,12 @@ sphinx = ["Sphinx (>=1.7)", "sphinx-book-theme", "mock", "moto", "myst-parser"] test = ["codecov", "coverage", "ipython", "ipykernel", "ipywidgets", "pytest (>=4.1)", "pytest-cov (>=2.6.1)", "check-manifest", "flake8", "mypy", "tox", "bumpversion", "xmltodict", "pip (>=18.1)", "wheel (>=0.31.0)", "setuptools (>=38.6.0)", "twine (>=1.11.0)", "black"] [[package]] -category = "main" -description = "Converting Jupyter Notebooks" name = "nbconvert" +version = "6.0.7" +description = "Converting Jupyter Notebooks" +category = "main" optional = false python-versions = ">=3.6" -version = "6.0.3" [package.dependencies] bleach = "*" @@ -452,19 +501,19 @@ testpath = "*" traitlets = ">=4.2" [package.extras] -all = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pyppeteer (0.2.2)", "tornado (>=4.0)", "sphinx (>=1.5.1)", "sphinx-rtd-theme", "nbsphinx (>=0.2.12)", "ipython"] +all = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pyppeteer (==0.2.2)", "tornado (>=4.0)", "sphinx (>=1.5.1)", "sphinx-rtd-theme", "nbsphinx (>=0.2.12)", "ipython"] docs = ["sphinx (>=1.5.1)", "sphinx-rtd-theme", "nbsphinx (>=0.2.12)", "ipython"] serve = ["tornado (>=4.0)"] -test = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pyppeteer (0.2.2)"] -webpdf = ["pyppeteer (0.2.2)"] +test = ["pytest", "pytest-cov", "pytest-dependency", "ipykernel", "ipywidgets (>=7)", "pyppeteer (==0.2.2)"] +webpdf = ["pyppeteer (==0.2.2)"] [[package]] -category = "main" -description = "The Jupyter Notebook format" name = "nbformat" +version = "5.1.3" +description = "The Jupyter Notebook format" +category = "main" optional = false python-versions = ">=3.5" -version = "5.0.7" [package.dependencies] ipython-genutils = "*" @@ -473,26 +522,26 @@ jupyter-core = "*" traitlets = ">=4.1" [package.extras] -test = ["pytest", "pytest-cov", "testpath"] +fast = ["fastjsonschema"] +test = ["check-manifest", "fastjsonschema", "testpath", "pytest", "pytest-cov"] [[package]] -category = "main" -description = "Patch asyncio to allow nested event loops" name = "nest-asyncio" +version = "1.5.1" +description = "Patch asyncio to allow nested event loops" +category = "main" optional = false python-versions = ">=3.5" -version = "1.4.0" [[package]] -category = "main" -description = "A web-based notebook environment for interactive computing" name = "notebook" +version = "6.4.0" +description = "A web-based notebook environment for interactive computing" +category = "main" optional = false -python-versions = ">=3.5" -version = "6.1.4" +python-versions = ">=3.6" [package.dependencies] -Send2Trash = "*" argon2-cffi = "*" ipykernel = "*" ipython-genutils = "*" @@ -503,230 +552,234 @@ nbconvert = "*" nbformat = "*" prometheus-client = "*" pyzmq = ">=17" +Send2Trash = ">=1.5.0" terminado = ">=0.8.3" -tornado = ">=5.0" +tornado = ">=6.1" traitlets = ">=4.2.1" [package.extras] -docs = ["sphinx", "nbsphinx", "sphinxcontrib-github-alt"] -test = ["nose", "coverage", "requests", "nose-warnings-filters", "nbval", "nose-exclude", "selenium", "pytest", "pytest-cov", "requests-unixsocket"] +docs = ["sphinx", "nbsphinx", "sphinxcontrib-github-alt", "sphinx-rtd-theme", "myst-parser"] +json-logging = ["json-logging"] +test = ["pytest", "coverage", "requests", "nbval", "selenium", "pytest-cov", "requests-unixsocket"] [[package]] -category = "main" -description = "NumPy is the fundamental package for array computing with Python." name = "numpy" +version = "1.20.3" +description = "NumPy is the fundamental package for array computing with Python." +category = "main" optional = false -python-versions = ">=3.6" -version = "1.19.2" +python-versions = ">=3.7" [[package]] -category = "main" -description = "Core utilities for Python packages" name = "packaging" +version = "20.9" +description = "Core utilities for Python packages" +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "20.4" [package.dependencies] pyparsing = ">=2.0.2" -six = "*" [[package]] -category = "main" -description = "Powerful data structures for data analysis, time series, and statistics" name = "pandas" +version = "1.2.4" +description = "Powerful data structures for data analysis, time series, and statistics" +category = "main" optional = false -python-versions = ">=3.6.1" -version = "1.1.2" +python-versions = ">=3.7.1" [package.dependencies] -numpy = ">=1.15.4" +numpy = ">=1.16.5" python-dateutil = ">=2.7.3" -pytz = ">=2017.2" +pytz = ">=2017.3" [package.extras] -test = ["pytest (>=4.0.2)", "pytest-xdist", "hypothesis (>=3.58)"] +test = ["pytest (>=5.0.1)", "pytest-xdist", "hypothesis (>=3.58)"] [[package]] -category = "main" -description = "Utilities for writing pandoc filters in python" name = "pandocfilters" -optional = false -python-versions = "*" -version = "1.4.2" - -[[package]] +version = "1.4.3" +description = "Utilities for writing pandoc filters in python" category = "main" -description = "A Python Parser" -name = "parso" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "0.7.1" - -[package.extras] -testing = ["docopt", "pytest (>=3.0.7)"] [[package]] +name = "parso" +version = "0.8.2" +description = "A Python Parser" category = "main" -description = "Pexpect allows easy control of interactive console applications." -marker = "sys_platform != \"win32\"" +optional = false +python-versions = ">=3.6" + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["docopt", "pytest (<6.0.0)"] + +[[package]] name = "pexpect" +version = "4.8.0" +description = "Pexpect allows easy control of interactive console applications." +category = "main" optional = false python-versions = "*" -version = "4.8.0" [package.dependencies] ptyprocess = ">=0.5" [[package]] -category = "main" -description = "Tiny 'shelve'-like database with concurrency support" name = "pickleshare" -optional = false -python-versions = "*" version = "0.7.5" - -[[package]] +description = "Tiny 'shelve'-like database with concurrency support" category = "main" -description = "Python Imaging Library (Fork)" -name = "pillow" -optional = false -python-versions = ">=3.5" -version = "7.2.0" - -[[package]] -category = "main" -description = "Python client for the Prometheus monitoring system." -name = "prometheus-client" optional = false python-versions = "*" -version = "0.8.0" + +[[package]] +name = "pillow" +version = "8.2.0" +description = "Python Imaging Library (Fork)" +category = "main" +optional = false +python-versions = ">=3.6" + +[[package]] +name = "prometheus-client" +version = "0.10.1" +description = "Python client for the Prometheus monitoring system." +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [package.extras] twisted = ["twisted"] [[package]] -category = "main" -description = "Library for building powerful interactive command lines in Python" name = "prompt-toolkit" +version = "3.0.18" +description = "Library for building powerful interactive command lines in Python" +category = "main" optional = false python-versions = ">=3.6.1" -version = "3.0.7" [package.dependencies] wcwidth = "*" [[package]] -category = "main" -description = "Run a subprocess in a pseudo terminal" -marker = "sys_platform != \"win32\" or os_name != \"nt\"" name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +category = "main" optional = false python-versions = "*" -version = "0.6.0" [[package]] +name = "py" +version = "1.10.0" +description = "library with cross-python path, ini-parsing, io, code, log facilities" category = "main" -description = "C parser in Python" -name = "pycparser" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "2.20" [[package]] +name = "pycparser" +version = "2.20" +description = "C parser in Python" category = "main" -description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" + +[[package]] name = "pygments" +version = "2.9.0" +description = "Pygments is a syntax highlighting package written in Python." +category = "main" optional = false python-versions = ">=3.5" -version = "2.7.0" [[package]] -category = "main" -description = "Python parsing module" name = "pyparsing" +version = "2.4.7" +description = "Python parsing module" +category = "main" optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" -version = "2.4.7" [[package]] -category = "main" -description = "Persistent/Functional/Immutable data structures" name = "pyrsistent" +version = "0.17.3" +description = "Persistent/Functional/Immutable data structures" +category = "main" optional = false python-versions = ">=3.5" -version = "0.17.3" [[package]] -category = "main" -description = "Extensions to the standard Python datetime module" name = "python-dateutil" +version = "2.8.1" +description = "Extensions to the standard Python datetime module" +category = "main" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" -version = "2.8.1" [package.dependencies] six = ">=1.5" [[package]] -category = "main" -description = "World timezone definitions, modern and historical" name = "pytz" +version = "2021.1" +description = "World timezone definitions, modern and historical" +category = "main" optional = false python-versions = "*" -version = "2020.1" [[package]] -category = "main" -description = "Python for Window Extensions" -marker = "sys_platform == \"win32\"" name = "pywin32" +version = "300" +description = "Python for Window Extensions" +category = "main" optional = false python-versions = "*" -version = "228" [[package]] -category = "main" -description = "Python bindings for the winpty library" -marker = "os_name == \"nt\"" name = "pywinpty" -optional = false -python-versions = "*" -version = "0.5.7" - -[[package]] +version = "1.1.1" +description = "Pseudo terminal support for Windows from Python." +category = "main" +optional = false +python-versions = ">=3.6" + +[[package]] +name = "pyzmq" +version = "22.0.3" +description = "Python bindings for 0MQ" +category = "main" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} +py = {version = "*", markers = "implementation_name == \"pypy\""} + +[[package]] +name = "requests" +version = "2.15.1" +description = "Python HTTP for Humans." +category = "main" +optional = false +python-versions = "*" + +[package.extras] +security = ["cryptography (>=1.3.4)", "idna (>=2.0.0)", "pyOpenSSL (>=0.14)"] +socks = ["PySocks (>=1.5.6,!=1.5.7)", "win-inet-pton"] + +[[package]] +name = "scikit-learn" +version = "0.24.2" +description = "A set of python modules for machine learning and data mining" category = "main" -description = "Python bindings for 0MQ" -name = "pyzmq" -optional = false -python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*" -version = "19.0.2" - -[[package]] -category = "main" -description = "Python HTTP for Humans." -name = "requests" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -version = "2.24.0" - -[package.dependencies] -certifi = ">=2017.4.17" -chardet = ">=3.0.2,<4" -idna = ">=2.5,<3" -urllib3 = ">=1.21.1,<1.25.0 || >1.25.0,<1.25.1 || >1.25.1,<1.26" - -[package.extras] -security = ["pyOpenSSL (>=0.14)", "cryptography (>=1.3.4)"] -socks = ["PySocks (>=1.5.6,<1.5.7 || >1.5.7)", "win-inet-pton"] - -[[package]] -category = "main" -description = "A set of python modules for machine learning and data mining" -name = "scikit-learn" optional = false python-versions = ">=3.6" -version = "0.23.2" [package.dependencies] joblib = ">=0.11" @@ -735,82 +788,96 @@ scipy = ">=0.19.1" threadpoolctl = ">=2.0.0" [package.extras] -alldeps = ["numpy (>=1.13.3)", "scipy (>=0.19.1)"] +benchmark = ["matplotlib (>=2.1.1)", "pandas (>=0.25.0)", "memory-profiler (>=0.57.0)"] +docs = ["matplotlib (>=2.1.1)", "scikit-image (>=0.13)", "pandas (>=0.25.0)", "seaborn (>=0.9.0)", "memory-profiler (>=0.57.0)", "sphinx (>=3.2.0)", "sphinx-gallery (>=0.7.0)", "numpydoc (>=1.0.0)", "Pillow (>=7.1.2)", "sphinx-prompt (>=1.3.0)"] +examples = ["matplotlib (>=2.1.1)", "scikit-image (>=0.13)", "pandas (>=0.25.0)", "seaborn (>=0.9.0)"] +tests = ["matplotlib (>=2.1.1)", "scikit-image (>=0.13)", "pandas (>=0.25.0)", "pytest (>=5.0.1)", "pytest-cov (>=2.9.0)", "flake8 (>=3.8.2)", "mypy (>=0.770)", "pyamg (>=4.0.0)"] [[package]] -category = "main" -description = "SciPy: Scientific Library for Python" name = "scipy" -optional = false -python-versions = ">=3.6" -version = "1.5.2" - -[package.dependencies] -numpy = ">=1.14.5" - -[[package]] +version = "1.6.1" +description = "SciPy: Scientific Library for Python" +category = "main" +optional = false +python-versions = ">=3.7" + +[package.dependencies] +numpy = ">=1.16.5" + +[[package]] +name = "send2trash" +version = "1.5.0" +description = "Send file to trash natively under Mac OS X, Windows and Linux." +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +category = "main" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" + +[[package]] +name = "sniffio" +version = "1.2.0" +description = "Sniff out which async library your code is running under" +category = "main" +optional = false +python-versions = ">=3.5" + +[[package]] +name = "terminado" +version = "0.10.0" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +category = "main" +optional = false +python-versions = ">=3.6" + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=4" + +[package.extras] +test = ["pytest"] + +[[package]] +name = "testpath" +version = "0.5.0" +description = "Test utilities for code working with files and commands" +category = "main" +optional = false +python-versions = ">= 3.5" + +[package.extras] +test = ["pytest", "pathlib2"] + +[[package]] +name = "threadpoolctl" +version = "2.1.0" +description = "threadpoolctl" +category = "main" +optional = false +python-versions = ">=3.5" + +[[package]] +name = "tornado" +version = "6.1" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +category = "main" +optional = false +python-versions = ">= 3.5" + +[[package]] +name = "traitlets" +version = "5.0.5" +description = "Traitlets Python configuration system" category = "main" -description = "Send file to trash natively under Mac OS X, Windows and Linux." -name = "send2trash" -optional = false -python-versions = "*" -version = "1.5.0" - -[[package]] -category = "main" -description = "Python 2 and 3 compatibility utilities" -name = "six" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" -version = "1.15.0" - -[[package]] -category = "main" -description = "Terminals served to xterm.js using Tornado websockets" -name = "terminado" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -version = "0.8.3" - -[package.dependencies] -ptyprocess = "*" -pywinpty = ">=0.5" -tornado = ">=4" - -[[package]] -category = "main" -description = "Test utilities for code working with files and commands" -name = "testpath" -optional = false -python-versions = "*" -version = "0.4.4" - -[package.extras] -test = ["pathlib2"] - -[[package]] -category = "main" -description = "threadpoolctl" -name = "threadpoolctl" -optional = false -python-versions = ">=3.5" -version = "2.1.0" - -[[package]] -category = "main" -description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." -name = "tornado" -optional = false -python-versions = ">= 3.5" -version = "6.0.4" - -[[package]] -category = "main" -description = "Traitlets Python configuration system" -name = "traitlets" optional = false python-versions = ">=3.7" -version = "5.0.4" [package.dependencies] ipython-genutils = "*" @@ -819,56 +886,42 @@ ipython-genutils = "*" test = ["pytest"] [[package]] -category = "main" -description = "HTTP library with thread-safe connection pooling, file post, and more." -name = "urllib3" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4" -version = "1.25.10" - -[package.extras] -brotli = ["brotlipy (>=0.6.0)"] -secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "pyOpenSSL (>=0.14)", "ipaddress"] -socks = ["PySocks (>=1.5.6,<1.5.7 || >1.5.7,<2.0)"] - -[[package]] -category = "main" -description = "Measures the displayed width of unicode strings in a terminal" name = "wcwidth" -optional = false -python-versions = "*" version = "0.2.5" - -[[package]] +description = "Measures the displayed width of unicode strings in a terminal" category = "main" -description = "Character encoding aliases for legacy web content" -name = "webencodings" optional = false python-versions = "*" -version = "0.5.1" [[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +category = "main" +optional = false +python-versions = "*" + +[[package]] +name = "websocket-client" +version = "1.0.1" +description = "WebSocket client for Python with low level API options" category = "main" -description = "Backport of pathlib-compatible object wrapper for zip files" -marker = "python_version < \"3.8\"" -name = "zipp" optional = false python-versions = ">=3.6" -version = "3.1.0" - -[package.extras] -docs = ["sphinx", "jaraco.packaging (>=3.2)", "rst.linker (>=1.9)"] -testing = ["jaraco.itertools", "func-timeout"] [metadata] -content-hash = "7e24cd65e092682db86f62c26adeff3da77639fdc814d54f2319f259cc2e1aa2" -lock-version = "1.0" -python-versions = "^3.7" +lock-version = "1.1" +python-versions = "^3.8" +content-hash = "f684f47b6832846bcfe88bf58eb673f20582f94c1c2b7ff3a2d366106f5cc96c" [metadata.files] +anyio = [ + {file = "anyio-3.1.0-py3-none-any.whl", hash = "sha256:5e335cef65fbd1a422bbfbb4722e8e9a9fadbd8c06d5afe9cd614d12023f6e5a"}, + {file = "anyio-3.1.0.tar.gz", hash = "sha256:43e20711a9d003d858d694c12356dc44ab82c03ccc5290313c3392fa349dad0e"}, +] appnope = [ - {file = "appnope-0.1.0-py2.py3-none-any.whl", hash = "sha256:5b26757dc6f79a3b7dc9fab95359328d5747fcb2409d331ea66d0272b90ab2a0"}, - {file = "appnope-0.1.0.tar.gz", hash = "sha256:8b995ffe925347a2138d7ac0fe77155e4311a0ea6d6da4f5128fe4b3cbe5ed71"}, + {file = "appnope-0.1.2-py2.py3-none-any.whl", hash = "sha256:93aa393e9d6c54c5cd570ccadd8edad61ea0c4b9ea7a01409020c9aa019eb442"}, + {file = "appnope-0.1.2.tar.gz", hash = "sha256:dd83cd4b5b460958838f6eb3000c660b1f9caf2a5b1de4264e941512f603258a"}, ] argon2-cffi = [ {file = "argon2-cffi-20.1.0.tar.gz", hash = "sha256:d8029b2d3e4b4cea770e9e5a0104dd8fa185c1724a0f01528ae4826a6d25f97d"}, @@ -887,120 +940,131 @@ argon2-cffi = [ {file = "argon2_cffi-20.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:6678bb047373f52bcff02db8afab0d2a77d83bde61cfecea7c5c62e2335cb203"}, {file = "argon2_cffi-20.1.0-cp38-cp38-win32.whl", hash = "sha256:77e909cc756ef81d6abb60524d259d959bab384832f0c651ed7dcb6e5ccdbb78"}, {file = "argon2_cffi-20.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:9dfd5197852530294ecb5795c97a823839258dfd5eb9420233c7cfedec2058f2"}, + {file = "argon2_cffi-20.1.0-cp39-cp39-win32.whl", hash = "sha256:e2db6e85c057c16d0bd3b4d2b04f270a7467c147381e8fd73cbbe5bc719832be"}, + {file = "argon2_cffi-20.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:8a84934bd818e14a17943de8099d41160da4a336bcc699bb4c394bbb9b94bd32"}, + {file = "argon2_cffi-20.1.0-pp36-pypy36_pp73-macosx_10_7_x86_64.whl", hash = "sha256:b94042e5dcaa5d08cf104a54bfae614be502c6f44c9c89ad1535b2ebdaacbd4c"}, + {file = "argon2_cffi-20.1.0-pp36-pypy36_pp73-win32.whl", hash = "sha256:8282b84ceb46b5b75c3a882b28856b8cd7e647ac71995e71b6705ec06fc232c3"}, + {file = "argon2_cffi-20.1.0-pp37-pypy37_pp73-macosx_10_7_x86_64.whl", hash = "sha256:3aa804c0e52f208973845e8b10c70d8957c9e5a666f702793256242e9167c4e0"}, + {file = "argon2_cffi-20.1.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:36320372133a003374ef4275fbfce78b7ab581440dfca9f9471be3dd9a522428"}, ] async-generator = [ {file = "async_generator-1.10-py3-none-any.whl", hash = "sha256:01c7bf666359b4967d2cda0000cc2e4af16a0ae098cbffcb8472fb9e8ad6585b"}, {file = "async_generator-1.10.tar.gz", hash = "sha256:6ebb3d106c12920aaae42ccb6f787ef5eefdcdd166ea3d628fa8476abe712144"}, ] attrs = [ - {file = "attrs-20.2.0-py2.py3-none-any.whl", hash = "sha256:fce7fc47dfc976152e82d53ff92fa0407700c21acd20886a13777a0d20e655dc"}, - {file = "attrs-20.2.0.tar.gz", hash = "sha256:26b54ddbbb9ee1d34d5d3668dd37d6cf74990ab23c828c2888dccdceee395594"}, + {file = "attrs-21.2.0-py2.py3-none-any.whl", hash = "sha256:149e90d6d8ac20db7a955ad60cf0e6881a3f20d37096140088356da6c716b0b1"}, + {file = "attrs-21.2.0.tar.gz", hash = "sha256:ef6aaac3ca6cd92904cdd0d83f629a15f18053ec84e6432106f7a4d04ae4f5fb"}, +] +babel = [ + {file = "Babel-2.9.1-py2.py3-none-any.whl", hash = "sha256:ab49e12b91d937cd11f0b67cb259a57ab4ad2b59ac7a3b41d6c06c0ac5b0def9"}, + {file = "Babel-2.9.1.tar.gz", hash = "sha256:bc0c176f9f6a994582230df350aa6e05ba2ebe4b3ac317eab29d9be5d2768da0"}, ] backcall = [ {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, ] bleach = [ - {file = "bleach-3.2.0-py2.py3-none-any.whl", hash = "sha256:769483204d247465c0b001ead257fb86bba6944bce6fe1b6759c812cceb54e3d"}, - {file = "bleach-3.2.0.tar.gz", hash = "sha256:f9e0205cc57b558c21bdfc11034f9d96b14c4052c25be60885d94f4277c792e0"}, -] -certifi = [ - {file = "certifi-2020.6.20-py2.py3-none-any.whl", hash = "sha256:8fc0819f1f30ba15bdb34cceffb9ef04d99f420f68eb75d901e9560b8749fc41"}, - {file = "certifi-2020.6.20.tar.gz", hash = "sha256:5930595817496dd21bb8dc35dad090f1c2cd0adfaf21204bf6732ca5d8ee34d3"}, + {file = "bleach-3.3.0-py2.py3-none-any.whl", hash = "sha256:6123ddc1052673e52bab52cdc955bcb57a015264a1c57d37bea2f6b817af0125"}, + {file = "bleach-3.3.0.tar.gz", hash = "sha256:98b3170739e5e83dd9dc19633f074727ad848cbedb6026708c8ac2d3b697a433"}, ] cffi = [ - {file = "cffi-1.14.3-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:485d029815771b9fe4fa7e1c304352fe57df6939afe835dfd0182c7c13d5e92e"}, - {file = "cffi-1.14.3-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:3cb3e1b9ec43256c4e0f8d2837267a70b0e1ca8c4f456685508ae6106b1f504c"}, - {file = "cffi-1.14.3-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:f0620511387790860b249b9241c2f13c3a80e21a73e0b861a2df24e9d6f56730"}, - {file = "cffi-1.14.3-cp27-cp27m-win32.whl", hash = "sha256:005f2bfe11b6745d726dbb07ace4d53f057de66e336ff92d61b8c7e9c8f4777d"}, - {file = "cffi-1.14.3-cp27-cp27m-win_amd64.whl", hash = "sha256:2f9674623ca39c9ebe38afa3da402e9326c245f0f5ceff0623dccdac15023e05"}, - {file = "cffi-1.14.3-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:09e96138280241bd355cd585148dec04dbbedb4f46128f340d696eaafc82dd7b"}, - {file = "cffi-1.14.3-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:3363e77a6176afb8823b6e06db78c46dbc4c7813b00a41300a4873b6ba63b171"}, - {file = "cffi-1.14.3-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:52bf29af05344c95136df71716bb60508bbd217691697b4307dcae681612db9f"}, - {file = "cffi-1.14.3-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:0ef488305fdce2580c8b2708f22d7785ae222d9825d3094ab073e22e93dfe51f"}, - {file = "cffi-1.14.3-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:0b1ad452cc824665ddc682400b62c9e4f5b64736a2ba99110712fdee5f2505c4"}, - {file = "cffi-1.14.3-cp35-cp35m-win32.whl", hash = "sha256:85ba797e1de5b48aa5a8427b6ba62cf69607c18c5d4eb747604b7302f1ec382d"}, - {file = "cffi-1.14.3-cp35-cp35m-win_amd64.whl", hash = "sha256:e66399cf0fc07de4dce4f588fc25bfe84a6d1285cc544e67987d22663393926d"}, - {file = "cffi-1.14.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:c687778dda01832555e0af205375d649fa47afeaeeb50a201711f9a9573323b8"}, - {file = "cffi-1.14.3-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:15f351bed09897fbda218e4db5a3d5c06328862f6198d4fb385f3e14e19decb3"}, - {file = "cffi-1.14.3-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:4d7c26bfc1ea9f92084a1d75e11999e97b62d63128bcc90c3624d07813c52808"}, - {file = "cffi-1.14.3-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:23e5d2040367322824605bc29ae8ee9175200b92cb5483ac7d466927a9b3d537"}, - {file = "cffi-1.14.3-cp36-cp36m-win32.whl", hash = "sha256:a624fae282e81ad2e4871bdb767e2c914d0539708c0f078b5b355258293c98b0"}, - {file = "cffi-1.14.3-cp36-cp36m-win_amd64.whl", hash = "sha256:de31b5164d44ef4943db155b3e8e17929707cac1e5bd2f363e67a56e3af4af6e"}, - {file = "cffi-1.14.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:03d3d238cc6c636a01cf55b9b2e1b6531a7f2f4103fabb5a744231582e68ecc7"}, - {file = "cffi-1.14.3-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:f92cdecb618e5fa4658aeb97d5eb3d2f47aa94ac6477c6daf0f306c5a3b9e6b1"}, - {file = "cffi-1.14.3-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:22399ff4870fb4c7ef19fff6eeb20a8bbf15571913c181c78cb361024d574579"}, - {file = "cffi-1.14.3-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:f4eae045e6ab2bb54ca279733fe4eb85f1effda392666308250714e01907f394"}, - {file = "cffi-1.14.3-cp37-cp37m-win32.whl", hash = "sha256:b0358e6fefc74a16f745afa366acc89f979040e0cbc4eec55ab26ad1f6a9bfbc"}, - {file = "cffi-1.14.3-cp37-cp37m-win_amd64.whl", hash = "sha256:6642f15ad963b5092d65aed022d033c77763515fdc07095208f15d3563003869"}, - {file = "cffi-1.14.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c2a33558fdbee3df370399fe1712d72464ce39c66436270f3664c03f94971aff"}, - {file = "cffi-1.14.3-cp38-cp38-manylinux1_i686.whl", hash = "sha256:2791f68edc5749024b4722500e86303a10d342527e1e3bcac47f35fbd25b764e"}, - {file = "cffi-1.14.3-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:529c4ed2e10437c205f38f3691a68be66c39197d01062618c55f74294a4a4828"}, - {file = "cffi-1.14.3-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8f0f1e499e4000c4c347a124fa6a27d37608ced4fe9f7d45070563b7c4c370c9"}, - {file = "cffi-1.14.3-cp38-cp38-win32.whl", hash = "sha256:3b8eaf915ddc0709779889c472e553f0d3e8b7bdf62dab764c8921b09bf94522"}, - {file = "cffi-1.14.3-cp38-cp38-win_amd64.whl", hash = "sha256:bbd2f4dfee1079f76943767fce837ade3087b578aeb9f69aec7857d5bf25db15"}, - {file = "cffi-1.14.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5d9a7dc7cf8b1101af2602fe238911bcc1ac36d239e0a577831f5dac993856e9"}, - {file = "cffi-1.14.3-cp39-cp39-manylinux1_i686.whl", hash = "sha256:cc75f58cdaf043fe6a7a6c04b3b5a0e694c6a9e24050967747251fb80d7bce0d"}, - {file = "cffi-1.14.3-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:bf39a9e19ce7298f1bd6a9758fa99707e9e5b1ebe5e90f2c3913a47bc548747c"}, - {file = "cffi-1.14.3-cp39-cp39-win32.whl", hash = "sha256:d80998ed59176e8cba74028762fbd9b9153b9afc71ea118e63bbf5d4d0f9552b"}, - {file = "cffi-1.14.3-cp39-cp39-win_amd64.whl", hash = "sha256:c150eaa3dadbb2b5339675b88d4573c1be3cb6f2c33a6c83387e10cc0bf05bd3"}, - {file = "cffi-1.14.3.tar.gz", hash = "sha256:f92f789e4f9241cd262ad7a555ca2c648a98178a953af117ef7fad46aa1d5591"}, -] -chardet = [ - {file = "chardet-3.0.4-py2.py3-none-any.whl", hash = "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"}, - {file = "chardet-3.0.4.tar.gz", hash = "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae"}, + {file = "cffi-1.14.5-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:bb89f306e5da99f4d922728ddcd6f7fcebb3241fc40edebcb7284d7514741991"}, + {file = "cffi-1.14.5-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:34eff4b97f3d982fb93e2831e6750127d1355a923ebaeeb565407b3d2f8d41a1"}, + {file = "cffi-1.14.5-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:99cd03ae7988a93dd00bcd9d0b75e1f6c426063d6f03d2f90b89e29b25b82dfa"}, + {file = "cffi-1.14.5-cp27-cp27m-win32.whl", hash = "sha256:65fa59693c62cf06e45ddbb822165394a288edce9e276647f0046e1ec26920f3"}, + {file = "cffi-1.14.5-cp27-cp27m-win_amd64.whl", hash = "sha256:51182f8927c5af975fece87b1b369f722c570fe169f9880764b1ee3bca8347b5"}, + {file = "cffi-1.14.5-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:43e0b9d9e2c9e5d152946b9c5fe062c151614b262fda2e7b201204de0b99e482"}, + {file = "cffi-1.14.5-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:cbde590d4faaa07c72bf979734738f328d239913ba3e043b1e98fe9a39f8b2b6"}, + {file = "cffi-1.14.5-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:5de7970188bb46b7bf9858eb6890aad302577a5f6f75091fd7cdd3ef13ef3045"}, + {file = "cffi-1.14.5-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:a465da611f6fa124963b91bf432d960a555563efe4ed1cc403ba5077b15370aa"}, + {file = "cffi-1.14.5-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:d42b11d692e11b6634f7613ad8df5d6d5f8875f5d48939520d351007b3c13406"}, + {file = "cffi-1.14.5-cp35-cp35m-win32.whl", hash = "sha256:72d8d3ef52c208ee1c7b2e341f7d71c6fd3157138abf1a95166e6165dd5d4369"}, + {file = "cffi-1.14.5-cp35-cp35m-win_amd64.whl", hash = "sha256:29314480e958fd8aab22e4a58b355b629c59bf5f2ac2492b61e3dc06d8c7a315"}, + {file = "cffi-1.14.5-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:3d3dd4c9e559eb172ecf00a2a7517e97d1e96de2a5e610bd9b68cea3925b4892"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:48e1c69bbacfc3d932221851b39d49e81567a4d4aac3b21258d9c24578280058"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:69e395c24fc60aad6bb4fa7e583698ea6cc684648e1ffb7fe85e3c1ca131a7d5"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:9e93e79c2551ff263400e1e4be085a1210e12073a31c2011dbbda14bda0c6132"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:24ec4ff2c5c0c8f9c6b87d5bb53555bf267e1e6f70e52e5a9740d32861d36b6f"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c3f39fa737542161d8b0d680df2ec249334cd70a8f420f71c9304bd83c3cbed"}, + {file = "cffi-1.14.5-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:681d07b0d1e3c462dd15585ef5e33cb021321588bebd910124ef4f4fb71aef55"}, + {file = "cffi-1.14.5-cp36-cp36m-win32.whl", hash = "sha256:58e3f59d583d413809d60779492342801d6e82fefb89c86a38e040c16883be53"}, + {file = "cffi-1.14.5-cp36-cp36m-win_amd64.whl", hash = "sha256:005a36f41773e148deac64b08f233873a4d0c18b053d37da83f6af4d9087b813"}, + {file = "cffi-1.14.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:2894f2df484ff56d717bead0a5c2abb6b9d2bf26d6960c4604d5c48bbc30ee73"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:0857f0ae312d855239a55c81ef453ee8fd24136eaba8e87a2eceba644c0d4c06"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:cd2868886d547469123fadc46eac7ea5253ea7fcb139f12e1dfc2bbd406427d1"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:35f27e6eb43380fa080dccf676dece30bef72e4a67617ffda586641cd4508d49"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06d7cd1abac2ffd92e65c0609661866709b4b2d82dd15f611e602b9b188b0b69"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f861a89e0043afec2a51fd177a567005847973be86f709bbb044d7f42fc4e05"}, + {file = "cffi-1.14.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc5a8e069b9ebfa22e26d0e6b97d6f9781302fe7f4f2b8776c3e1daea35f1adc"}, + {file = "cffi-1.14.5-cp37-cp37m-win32.whl", hash = "sha256:9ff227395193126d82e60319a673a037d5de84633f11279e336f9c0f189ecc62"}, + {file = "cffi-1.14.5-cp37-cp37m-win_amd64.whl", hash = "sha256:9cf8022fb8d07a97c178b02327b284521c7708d7c71a9c9c355c178ac4bbd3d4"}, + {file = "cffi-1.14.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8b198cec6c72df5289c05b05b8b0969819783f9418e0409865dac47288d2a053"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux1_i686.whl", hash = "sha256:ad17025d226ee5beec591b52800c11680fca3df50b8b29fe51d882576e039ee0"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:6c97d7350133666fbb5cf4abdc1178c812cb205dc6f41d174a7b0f18fb93337e"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8ae6299f6c68de06f136f1f9e69458eae58f1dacf10af5c17353eae03aa0d827"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:04c468b622ed31d408fea2346bec5bbffba2cc44226302a0de1ade9f5ea3d373"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:06db6321b7a68b2bd6df96d08a5adadc1fa0e8f419226e25b2a5fbf6ccc7350f"}, + {file = "cffi-1.14.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:293e7ea41280cb28c6fcaaa0b1aa1f533b8ce060b9e701d78511e1e6c4a1de76"}, + {file = "cffi-1.14.5-cp38-cp38-win32.whl", hash = "sha256:b85eb46a81787c50650f2392b9b4ef23e1f126313b9e0e9013b35c15e4288e2e"}, + {file = "cffi-1.14.5-cp38-cp38-win_amd64.whl", hash = "sha256:1f436816fc868b098b0d63b8920de7d208c90a67212546d02f84fe78a9c26396"}, + {file = "cffi-1.14.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1071534bbbf8cbb31b498d5d9db0f274f2f7a865adca4ae429e147ba40f73dea"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux1_i686.whl", hash = "sha256:9de2e279153a443c656f2defd67769e6d1e4163952b3c622dcea5b08a6405322"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:6e4714cc64f474e4d6e37cfff31a814b509a35cb17de4fb1999907575684479c"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:158d0d15119b4b7ff6b926536763dc0714313aa59e320ddf787502c70c4d4bee"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1bf1ac1984eaa7675ca8d5745a8cb87ef7abecb5592178406e55858d411eadc0"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:df5052c5d867c1ea0b311fb7c3cd28b19df469c056f7fdcfe88c7473aa63e333"}, + {file = "cffi-1.14.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24a570cd11895b60829e941f2613a4f79df1a27344cbbb82164ef2e0116f09c7"}, + {file = "cffi-1.14.5-cp39-cp39-win32.whl", hash = "sha256:afb29c1ba2e5a3736f1c301d9d0abe3ec8b86957d04ddfa9d7a6a42b9367e396"}, + {file = "cffi-1.14.5-cp39-cp39-win_amd64.whl", hash = "sha256:f2d45f97ab6bb54753eab54fffe75aaf3de4ff2341c9daee1987ee1837636f1d"}, + {file = "cffi-1.14.5.tar.gz", hash = "sha256:fd78e5fee591709f32ef6edb9a015b4aa1a5022598e36227500c8f4e02328d9c"}, ] colorama = [ - {file = "colorama-0.4.3-py2.py3-none-any.whl", hash = "sha256:7d73d2a99753107a36ac6b455ee49046802e59d9d076ef8e47b61499fa29afff"}, - {file = "colorama-0.4.3.tar.gz", hash = "sha256:e96da0d330793e2cb9485e9ddfd918d456036c7149416295932478192f4436a1"}, + {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"}, + {file = "colorama-0.4.4.tar.gz", hash = "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b"}, ] cycler = [ {file = "cycler-0.10.0-py2.py3-none-any.whl", hash = "sha256:1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d"}, {file = "cycler-0.10.0.tar.gz", hash = "sha256:cd7b2d1018258d7247a71425e9f26463dfb444d411c39569972f4ce586b0c9d8"}, ] decorator = [ - {file = "decorator-4.4.2-py2.py3-none-any.whl", hash = "sha256:41fa54c2a0cc4ba648be4fd43cff00aedf5b9465c9bf18d64325bc225f08f760"}, - {file = "decorator-4.4.2.tar.gz", hash = "sha256:e3a62f0520172440ca0dcc823749319382e377f37f140a0b99ef45fecb84bfe7"}, + {file = "decorator-5.0.9-py3-none-any.whl", hash = "sha256:6e5c199c16f7a9f0e3a61a4a54b3d27e7dad0dbdde92b944426cb20914376323"}, + {file = "decorator-5.0.9.tar.gz", hash = "sha256:72ecfba4320a893c53f9706bebb2d55c270c1e51a28789361aa93e4a21319ed5"}, ] defusedxml = [ - {file = "defusedxml-0.6.0-py2.py3-none-any.whl", hash = "sha256:6687150770438374ab581bb7a1b327a847dd9c5749e396102de3fad4e8a3ef93"}, - {file = "defusedxml-0.6.0.tar.gz", hash = "sha256:f684034d135af4c6cbb949b8a4d2ed61634515257a67299e5f940fbaa34377f5"}, + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, ] entrypoints = [ {file = "entrypoints-0.3-py2.py3-none-any.whl", hash = "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19"}, {file = "entrypoints-0.3.tar.gz", hash = "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"}, ] idna = [ - {file = "idna-2.10-py2.py3-none-any.whl", hash = "sha256:b97d804b1e9b523befed77c48dacec60e6dcb0b5391d57af6a65a312a90648c0"}, - {file = "idna-2.10.tar.gz", hash = "sha256:b307872f855b18632ce0c21c5e45be78c0ea7ae4c15c828c20788b26921eb3f6"}, -] -importlib-metadata = [ - {file = "importlib_metadata-1.7.0-py2.py3-none-any.whl", hash = "sha256:dc15b2969b4ce36305c51eebe62d418ac7791e9a157911d58bfb1f9ccd8e2070"}, - {file = "importlib_metadata-1.7.0.tar.gz", hash = "sha256:90bb658cdbbf6d1735b6341ce708fc7024a3e14e99ffdc5783edea9f9b077f83"}, + {file = "idna-3.1-py3-none-any.whl", hash = "sha256:5205d03e7bcbb919cc9c19885f9920d622ca52448306f2377daede5cf3faac16"}, + {file = "idna-3.1.tar.gz", hash = "sha256:c5b02147e01ea9920e6b0a3f1f7bb833612d507592c837a6c49552768f4054e1"}, ] ipykernel = [ - {file = "ipykernel-5.3.4-py3-none-any.whl", hash = "sha256:d6fbba26dba3cebd411382bc484f7bc2caa98427ae0ddb4ab37fe8bfeb5c7dd3"}, - {file = "ipykernel-5.3.4.tar.gz", hash = "sha256:9b2652af1607986a1b231c62302d070bc0534f564c393a5d9d130db9abbbe89d"}, + {file = "ipykernel-5.5.5-py3-none-any.whl", hash = "sha256:29eee66548ee7c2edb7941de60c0ccf0a7a8dd957341db0a49c5e8e6a0fcb712"}, + {file = "ipykernel-5.5.5.tar.gz", hash = "sha256:e976751336b51082a89fc2099fb7f96ef20f535837c398df6eab1283c2070884"}, ] ipython = [ - {file = "ipython-7.18.1-py3-none-any.whl", hash = "sha256:2e22c1f74477b5106a6fb301c342ab8c64bb75d702e350f05a649e8cb40a0fb8"}, - {file = "ipython-7.18.1.tar.gz", hash = "sha256:a331e78086001931de9424940699691ad49dfb457cea31f5471eae7b78222d5e"}, + {file = "ipython-7.23.1-py3-none-any.whl", hash = "sha256:f78c6a3972dde1cc9e4041cbf4de583546314ba52d3c97208e5b6b2221a9cb7d"}, + {file = "ipython-7.23.1.tar.gz", hash = "sha256:714810a5c74f512b69d5f3b944c86e592cee0a5fb9c728e582f074610f6cf038"}, ] ipython-genutils = [ {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"}, {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"}, ] jedi = [ - {file = "jedi-0.17.2-py2.py3-none-any.whl", hash = "sha256:98cc583fa0f2f8304968199b01b6b4b94f469a1f4a74c1560506ca2a211378b5"}, - {file = "jedi-0.17.2.tar.gz", hash = "sha256:86ed7d9b750603e4ba582ea8edc678657fb4007894a12bcf6f4bb97892f31d20"}, + {file = "jedi-0.18.0-py2.py3-none-any.whl", hash = "sha256:18456d83f65f400ab0c2d3319e48520420ef43b23a086fdc05dff34132f0fb93"}, + {file = "jedi-0.18.0.tar.gz", hash = "sha256:92550a404bad8afed881a137ec9a461fed49eca661414be45059329614ed0707"}, ] jinja2 = [ - {file = "Jinja2-2.11.2-py2.py3-none-any.whl", hash = "sha256:f0a4641d3cf955324a89c04f3d94663aa4d638abe8f733ecd3582848e1c37035"}, - {file = "Jinja2-2.11.2.tar.gz", hash = "sha256:89aab215427ef59c34ad58735269eb58b1a5808103067f7bb9d5836c651b3bb0"}, + {file = "Jinja2-3.0.1-py3-none-any.whl", hash = "sha256:1f06f2da51e7b56b8f238affdd6b4e2c61e39598a378cc49345bc1bd42a978a4"}, + {file = "Jinja2-3.0.1.tar.gz", hash = "sha256:703f484b47a6af502e743c9122595cc812b0271f661722403114f71a79d0f5a4"}, ] joblib = [ - {file = "joblib-0.16.0-py3-none-any.whl", hash = "sha256:d348c5d4ae31496b2aa060d6d9b787864dd204f9480baaa52d18850cb43e9f49"}, - {file = "joblib-0.16.0.tar.gz", hash = "sha256:8f52bf24c64b608bf0b2563e0e47d6fcf516abc8cfafe10cfd98ad66d94f92d6"}, + {file = "joblib-1.0.1-py3-none-any.whl", hash = "sha256:feeb1ec69c4d45129954f1b7034954241eedfd6ba39b5e9e4b6883be3332d5e5"}, + {file = "joblib-1.0.1.tar.gz", hash = "sha256:9c17567692206d2f3fb9ecf5e991084254fe631665c450b443761c4186a613f7"}, ] json5 = [ {file = "json5-0.9.5-py2.py3-none-any.whl", hash = "sha256:af1a1b9a2850c7f62c23fde18be4749b3599fd302f494eebf957e2ada6b9e42c"}, @@ -1011,181 +1075,206 @@ jsonschema = [ {file = "jsonschema-3.2.0.tar.gz", hash = "sha256:c8a85b28d377cc7737e46e2d9f2b4f44ee3c0e1deac6bf46ddefc7187d30797a"}, ] jupyter-client = [ - {file = "jupyter_client-6.1.7-py3-none-any.whl", hash = "sha256:c958d24d6eacb975c1acebb68ac9077da61b5f5c040f22f6849928ad7393b950"}, - {file = "jupyter_client-6.1.7.tar.gz", hash = "sha256:49e390b36fe4b4226724704ea28d9fb903f1a3601b6882ce3105221cd09377a1"}, + {file = "jupyter_client-6.2.0-py3-none-any.whl", hash = "sha256:9715152067e3f7ea3b56f341c9a0f9715c8c7cc316ee0eb13c3c84f5ca0065f5"}, + {file = "jupyter_client-6.2.0.tar.gz", hash = "sha256:e2ab61d79fbf8b56734a4c2499f19830fbd7f6fefb3e87868ef0545cb3c17eb9"}, ] jupyter-core = [ - {file = "jupyter_core-4.6.3-py2.py3-none-any.whl", hash = "sha256:a4ee613c060fe5697d913416fc9d553599c05e4492d58fac1192c9a6844abb21"}, - {file = "jupyter_core-4.6.3.tar.gz", hash = "sha256:394fd5dd787e7c8861741880bdf8a00ce39f95de5d18e579c74b882522219e7e"}, + {file = "jupyter_core-4.7.1-py3-none-any.whl", hash = "sha256:8c6c0cac5c1b563622ad49321d5ec47017bd18b94facb381c6973a0486395f8e"}, + {file = "jupyter_core-4.7.1.tar.gz", hash = "sha256:79025cb3225efcd36847d0840f3fc672c0abd7afd0de83ba8a1d3837619122b4"}, +] +jupyter-server = [ + {file = "jupyter_server-1.8.0-py3-none-any.whl", hash = "sha256:81547b97f346647fb600b9bbfd020075603dbefe25f639d3d4dc2b7c7a6013cf"}, + {file = "jupyter_server-1.8.0.tar.gz", hash = "sha256:8f0c75e0a577536125ad62a442ebb7cf02746f1a69d907e8a273c6225d281237"}, ] jupyterlab = [ - {file = "jupyterlab-2.2.8-py3-none-any.whl", hash = "sha256:95d0509557881cfa8a5fcdf225f2fca46faf1bc52fc56a28e0b72fcc594c90ab"}, - {file = "jupyterlab-2.2.8.tar.gz", hash = "sha256:c8377bee30504919c1e79949f9fe35443ab7f5c4be622c95307e8108410c8b8c"}, + {file = "jupyterlab-3.0.16-py3-none-any.whl", hash = "sha256:88f6e7580c15cf731d96495fda362e786753e18d1e3e7e735915862efb602a92"}, + {file = "jupyterlab-3.0.16.tar.gz", hash = "sha256:7ad4fbe1f6d38255869410fd151a8b15692a663ca97c0a8146b3f5c40e275c23"}, ] jupyterlab-pygments = [ - {file = "jupyterlab_pygments-0.1.1-py2.py3-none-any.whl", hash = "sha256:c9535e5999f29bff90bd0fa423717dcaf247b71fad505d66b17d3217e9021fc5"}, - {file = "jupyterlab_pygments-0.1.1.tar.gz", hash = "sha256:19a0ccde7daddec638363cd3d60b63a4f6544c9181d65253317b2fb492a797b9"}, + {file = "jupyterlab_pygments-0.1.2-py2.py3-none-any.whl", hash = "sha256:abfb880fd1561987efaefcb2d2ac75145d2a5d0139b1876d5be806e32f630008"}, + {file = "jupyterlab_pygments-0.1.2.tar.gz", hash = "sha256:cfcda0873626150932f438eccf0f8bf22bfa92345b814890ab360d666b254146"}, ] jupyterlab-server = [ - {file = "jupyterlab_server-1.2.0-py3-none-any.whl", hash = "sha256:55d256077bf13e5bc9e8fbd5aac51bef82f6315111cec6b712b9a5ededbba924"}, - {file = "jupyterlab_server-1.2.0.tar.gz", hash = "sha256:5431d9dde96659364b7cc877693d5d21e7b80cea7ae3959ecc2b87518e5f5d8c"}, + {file = "jupyterlab_server-2.5.2-py3-none-any.whl", hash = "sha256:7c7209e00910aff1ad8a7b8fd5826536561c6bafba9608ed5d1b04e1b9819efd"}, + {file = "jupyterlab_server-2.5.2.tar.gz", hash = "sha256:43bc96fa49196e3ace214693e0955eb73fe11d37ac1577d45b177a0588c0a1d6"}, ] kiwisolver = [ - {file = "kiwisolver-1.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:443c2320520eda0a5b930b2725b26f6175ca4453c61f739fef7a5847bd262f74"}, - {file = "kiwisolver-1.2.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:efcf3397ae1e3c3a4a0a0636542bcad5adad3b1dd3e8e629d0b6e201347176c8"}, - {file = "kiwisolver-1.2.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:fccefc0d36a38c57b7bd233a9b485e2f1eb71903ca7ad7adacad6c28a56d62d2"}, - {file = "kiwisolver-1.2.0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:be046da49fbc3aa9491cc7296db7e8d27bcf0c3d5d1a40259c10471b014e4e0c"}, - {file = "kiwisolver-1.2.0-cp36-none-win32.whl", hash = "sha256:60a78858580761fe611d22127868f3dc9f98871e6fdf0a15cc4203ed9ba6179b"}, - {file = "kiwisolver-1.2.0-cp36-none-win_amd64.whl", hash = "sha256:556da0a5f60f6486ec4969abbc1dd83cf9b5c2deadc8288508e55c0f5f87d29c"}, - {file = "kiwisolver-1.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7cc095a4661bdd8a5742aaf7c10ea9fac142d76ff1770a0f84394038126d8fc7"}, - {file = "kiwisolver-1.2.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:c955791d80e464da3b471ab41eb65cf5a40c15ce9b001fdc5bbc241170de58ec"}, - {file = "kiwisolver-1.2.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:603162139684ee56bcd57acc74035fceed7dd8d732f38c0959c8bd157f913fec"}, - {file = "kiwisolver-1.2.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:63f55f490b958b6299e4e5bdac66ac988c3d11b7fafa522800359075d4fa56d1"}, - {file = "kiwisolver-1.2.0-cp37-none-win32.whl", hash = "sha256:03662cbd3e6729f341a97dd2690b271e51a67a68322affab12a5b011344b973c"}, - {file = "kiwisolver-1.2.0-cp37-none-win_amd64.whl", hash = "sha256:4eadb361baf3069f278b055e3bb53fa189cea2fd02cb2c353b7a99ebb4477ef1"}, - {file = "kiwisolver-1.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c31bc3c8e903d60a1ea31a754c72559398d91b5929fcb329b1c3a3d3f6e72113"}, - {file = "kiwisolver-1.2.0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:d52b989dc23cdaa92582ceb4af8d5bcc94d74b2c3e64cd6785558ec6a879793e"}, - {file = "kiwisolver-1.2.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:e586b28354d7b6584d8973656a7954b1c69c93f708c0c07b77884f91640b7657"}, - {file = "kiwisolver-1.2.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:38d05c9ecb24eee1246391820ed7137ac42a50209c203c908154782fced90e44"}, - {file = "kiwisolver-1.2.0-cp38-none-win32.whl", hash = "sha256:d069ef4b20b1e6b19f790d00097a5d5d2c50871b66d10075dab78938dc2ee2cf"}, - {file = "kiwisolver-1.2.0-cp38-none-win_amd64.whl", hash = "sha256:18d749f3e56c0480dccd1714230da0f328e6e4accf188dd4e6884bdd06bf02dd"}, - {file = "kiwisolver-1.2.0.tar.gz", hash = "sha256:247800260cd38160c362d211dcaf4ed0f7816afb5efe56544748b21d6ad6d17f"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:fd34fbbfbc40628200730bc1febe30631347103fc8d3d4fa012c21ab9c11eca9"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:d3155d828dec1d43283bd24d3d3e0d9c7c350cdfcc0bd06c0ad1209c1bbc36d0"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:5a7a7dbff17e66fac9142ae2ecafb719393aaee6a3768c9de2fd425c63b53e21"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:f8d6f8db88049a699817fd9178782867bf22283e3813064302ac59f61d95be05"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-manylinux2014_ppc64le.whl", hash = "sha256:5f6ccd3dd0b9739edcf407514016108e2280769c73a85b9e59aa390046dbf08b"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-win32.whl", hash = "sha256:225e2e18f271e0ed8157d7f4518ffbf99b9450fca398d561eb5c4a87d0986dd9"}, + {file = "kiwisolver-1.3.1-cp36-cp36m-win_amd64.whl", hash = "sha256:cf8b574c7b9aa060c62116d4181f3a1a4e821b2ec5cbfe3775809474113748d4"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:232c9e11fd7ac3a470d65cd67e4359eee155ec57e822e5220322d7b2ac84fbf0"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:b38694dcdac990a743aa654037ff1188c7a9801ac3ccc548d3341014bc5ca278"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:ca3820eb7f7faf7f0aa88de0e54681bddcb46e485beb844fcecbcd1c8bd01689"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:c8fd0f1ae9d92b42854b2979024d7597685ce4ada367172ed7c09edf2cef9cb8"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-manylinux2014_ppc64le.whl", hash = "sha256:1e1bc12fb773a7b2ffdeb8380609f4f8064777877b2225dec3da711b421fda31"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-win32.whl", hash = "sha256:72c99e39d005b793fb7d3d4e660aed6b6281b502e8c1eaf8ee8346023c8e03bc"}, + {file = "kiwisolver-1.3.1-cp37-cp37m-win_amd64.whl", hash = "sha256:8be8d84b7d4f2ba4ffff3665bcd0211318aa632395a1a41553250484a871d454"}, + {file = "kiwisolver-1.3.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:31dfd2ac56edc0ff9ac295193eeaea1c0c923c0355bf948fbd99ed6018010b72"}, + {file = "kiwisolver-1.3.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:563c649cfdef27d081c84e72a03b48ea9408c16657500c312575ae9d9f7bc1c3"}, + {file = "kiwisolver-1.3.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:78751b33595f7f9511952e7e60ce858c6d64db2e062afb325985ddbd34b5c131"}, + {file = "kiwisolver-1.3.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:a357fd4f15ee49b4a98b44ec23a34a95f1e00292a139d6015c11f55774ef10de"}, + {file = "kiwisolver-1.3.1-cp38-cp38-manylinux2014_ppc64le.whl", hash = "sha256:5989db3b3b34b76c09253deeaf7fbc2707616f130e166996606c284395da3f18"}, + {file = "kiwisolver-1.3.1-cp38-cp38-win32.whl", hash = "sha256:c08e95114951dc2090c4a630c2385bef681cacf12636fb0241accdc6b303fd81"}, + {file = "kiwisolver-1.3.1-cp38-cp38-win_amd64.whl", hash = "sha256:44a62e24d9b01ba94ae7a4a6c3fb215dc4af1dde817e7498d901e229aaf50e4e"}, + {file = "kiwisolver-1.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:50af681a36b2a1dee1d3c169ade9fdc59207d3c31e522519181e12f1b3ba7000"}, + {file = "kiwisolver-1.3.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:a53d27d0c2a0ebd07e395e56a1fbdf75ffedc4a05943daf472af163413ce9598"}, + {file = "kiwisolver-1.3.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:834ee27348c4aefc20b479335fd422a2c69db55f7d9ab61721ac8cd83eb78882"}, + {file = "kiwisolver-1.3.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5c3e6455341008a054cccee8c5d24481bcfe1acdbc9add30aa95798e95c65621"}, + {file = "kiwisolver-1.3.1-cp39-cp39-manylinux2014_ppc64le.whl", hash = "sha256:acef3d59d47dd85ecf909c359d0fd2c81ed33bdff70216d3956b463e12c38a54"}, + {file = "kiwisolver-1.3.1-cp39-cp39-win32.whl", hash = "sha256:c5518d51a0735b1e6cee1fdce66359f8d2b59c3ca85dc2b0813a8aa86818a030"}, + {file = "kiwisolver-1.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:b9edd0110a77fc321ab090aaa1cfcaba1d8499850a12848b81be2222eab648f6"}, + {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0cd53f403202159b44528498de18f9285b04482bab2a6fc3f5dd8dbb9352e30d"}, + {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:33449715e0101e4d34f64990352bce4095c8bf13bed1b390773fc0a7295967b3"}, + {file = "kiwisolver-1.3.1-pp36-pypy36_pp73-win32.whl", hash = "sha256:401a2e9afa8588589775fe34fc22d918ae839aaaf0c0e96441c0fdbce6d8ebe6"}, + {file = "kiwisolver-1.3.1.tar.gz", hash = "sha256:950a199911a8d94683a6b10321f9345d5a3a8433ec58b217ace979e18f16e248"}, ] markupsafe = [ - {file = "MarkupSafe-1.1.1-cp27-cp27m-macosx_10_6_intel.whl", hash = "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161"}, - {file = "MarkupSafe-1.1.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7"}, - {file = "MarkupSafe-1.1.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183"}, - {file = "MarkupSafe-1.1.1-cp27-cp27m-win32.whl", hash = "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b"}, - {file = "MarkupSafe-1.1.1-cp27-cp27m-win_amd64.whl", hash = "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e"}, - {file = "MarkupSafe-1.1.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f"}, - {file = "MarkupSafe-1.1.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1"}, - {file = "MarkupSafe-1.1.1-cp34-cp34m-macosx_10_6_intel.whl", hash = "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5"}, - {file = "MarkupSafe-1.1.1-cp34-cp34m-manylinux1_i686.whl", hash = "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1"}, - {file = "MarkupSafe-1.1.1-cp34-cp34m-manylinux1_x86_64.whl", hash = "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735"}, - {file = "MarkupSafe-1.1.1-cp34-cp34m-win32.whl", hash = "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21"}, - {file = "MarkupSafe-1.1.1-cp34-cp34m-win_amd64.whl", hash = "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235"}, - {file = "MarkupSafe-1.1.1-cp35-cp35m-macosx_10_6_intel.whl", hash = "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b"}, - {file = "MarkupSafe-1.1.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f"}, - {file = "MarkupSafe-1.1.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905"}, - {file = "MarkupSafe-1.1.1-cp35-cp35m-win32.whl", hash = "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1"}, - {file = "MarkupSafe-1.1.1-cp35-cp35m-win_amd64.whl", hash = "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d"}, - {file = "MarkupSafe-1.1.1-cp36-cp36m-macosx_10_6_intel.whl", hash = "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff"}, - {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473"}, - {file = "MarkupSafe-1.1.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e"}, - {file = "MarkupSafe-1.1.1-cp36-cp36m-win32.whl", hash = "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66"}, - {file = "MarkupSafe-1.1.1-cp36-cp36m-win_amd64.whl", hash = "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5"}, - {file = "MarkupSafe-1.1.1-cp37-cp37m-macosx_10_6_intel.whl", hash = "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d"}, - {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e"}, - {file = "MarkupSafe-1.1.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6"}, - {file = "MarkupSafe-1.1.1-cp37-cp37m-win32.whl", hash = "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2"}, - {file = "MarkupSafe-1.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c"}, - {file = "MarkupSafe-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6788b695d50a51edb699cb55e35487e430fa21f1ed838122d722e0ff0ac5ba15"}, - {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:cdb132fc825c38e1aeec2c8aa9338310d29d337bebbd7baa06889d09a60a1fa2"}, - {file = "MarkupSafe-1.1.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:13d3144e1e340870b25e7b10b98d779608c02016d5184cfb9927a9f10c689f42"}, - {file = "MarkupSafe-1.1.1-cp38-cp38-win32.whl", hash = "sha256:596510de112c685489095da617b5bcbbac7dd6384aeebeda4df6025d0256a81b"}, - {file = "MarkupSafe-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:e8313f01ba26fbbe36c7be1966a7b7424942f670f38e666995b88d012765b9be"}, - {file = "MarkupSafe-1.1.1.tar.gz", hash = "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:f9081981fe268bd86831e5c75f7de206ef275defcb82bc70740ae6dc507aee51"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:0955295dd5eec6cb6cc2fe1698f4c6d84af2e92de33fbcac4111913cd100a6ff"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:0446679737af14f45767963a1a9ef7620189912317d095f2d9ffa183a4d25d2b"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:f826e31d18b516f653fe296d967d700fddad5901ae07c622bb3705955e1faa94"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:fa130dd50c57d53368c9d59395cb5526eda596d3ffe36666cd81a44d56e48872"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:905fec760bd2fa1388bb5b489ee8ee5f7291d692638ea5f67982d968366bef9f"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-win32.whl", hash = "sha256:6c4ca60fa24e85fe25b912b01e62cb969d69a23a5d5867682dd3e80b5b02581d"}, + {file = "MarkupSafe-2.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:b2f4bf27480f5e5e8ce285a8c8fd176c0b03e93dcc6646477d4630e83440c6a9"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0717a7390a68be14b8c793ba258e075c6f4ca819f15edfc2a3a027c823718567"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:6557b31b5e2c9ddf0de32a691f2312a32f77cd7681d8af66c2692efdbef84c18"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:49e3ceeabbfb9d66c3aef5af3a60cc43b85c33df25ce03d0031a608b0a8b2e3f"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:d7f9850398e85aba693bb640262d3611788b1f29a79f0c93c565694658f4071f"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:6a7fae0dd14cf60ad5ff42baa2e95727c3d81ded453457771d02b7d2b3f9c0c2"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:b7f2d075102dc8c794cbde1947378051c4e5180d52d276987b8d28a3bd58c17d"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-win32.whl", hash = "sha256:a30e67a65b53ea0a5e62fe23682cfe22712e01f453b95233b25502f7c61cb415"}, + {file = "MarkupSafe-2.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:611d1ad9a4288cf3e3c16014564df047fe08410e628f89805e475368bd304914"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:be98f628055368795d818ebf93da628541e10b75b41c559fdf36d104c5787066"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:1d609f577dc6e1aa17d746f8bd3c31aa4d258f4070d61b2aa5c4166c1539de35"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:7d91275b0245b1da4d4cfa07e0faedd5b0812efc15b702576d103293e252af1b"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:01a9b8ea66f1658938f65b93a85ebe8bc016e6769611be228d797c9d998dd298"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:47ab1e7b91c098ab893b828deafa1203de86d0bc6ab587b160f78fe6c4011f75"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:97383d78eb34da7e1fa37dd273c20ad4320929af65d156e35a5e2d89566d9dfb"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-win32.whl", hash = "sha256:023cb26ec21ece8dc3907c0e8320058b2e0cb3c55cf9564da612bc325bed5e64"}, + {file = "MarkupSafe-2.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:984d76483eb32f1bcb536dc27e4ad56bba4baa70be32fa87152832cdd9db0833"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:2ef54abee730b502252bcdf31b10dacb0a416229b72c18b19e24a4509f273d26"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3c112550557578c26af18a1ccc9e090bfe03832ae994343cfdacd287db6a6ae7"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:53edb4da6925ad13c07b6d26c2a852bd81e364f95301c66e930ab2aef5b5ddd8"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:f5653a225f31e113b152e56f154ccbe59eeb1c7487b39b9d9f9cdb58e6c79dc5"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:4efca8f86c54b22348a5467704e3fec767b2db12fc39c6d963168ab1d3fc9135"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:ab3ef638ace319fa26553db0624c4699e31a28bb2a835c5faca8f8acf6a5a902"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:f8ba0e8349a38d3001fae7eadded3f6606f0da5d748ee53cc1dab1d6527b9509"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-win32.whl", hash = "sha256:10f82115e21dc0dfec9ab5c0223652f7197feb168c940f3ef61563fc2d6beb74"}, + {file = "MarkupSafe-2.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:693ce3f9e70a6cf7d2fb9e6c9d8b204b6b39897a2c4a1aa65728d5ac97dcc1d8"}, + {file = "MarkupSafe-2.0.1.tar.gz", hash = "sha256:594c67807fb16238b30c44bdf74f36c02cdf22d1c8cda91ef8a0ed8dabf5620a"}, ] matplotlib = [ - {file = "matplotlib-3.3.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:27f9de4784ae6fb97679556c5542cf36c0751dccb4d6407f7c62517fa2078868"}, - {file = "matplotlib-3.3.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:06866c138d81a593b535d037b2727bec9b0818cadfe6a81f6ec5715b8dd38a89"}, - {file = "matplotlib-3.3.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:5ccecb5f78b51b885f0028b646786889f49c54883e554fca41a2a05998063f23"}, - {file = "matplotlib-3.3.2-cp36-cp36m-win32.whl", hash = "sha256:69cf76d673682140f46c6cb5e073332c1f1b2853c748dc1cb04f7d00023567f7"}, - {file = "matplotlib-3.3.2-cp36-cp36m-win_amd64.whl", hash = "sha256:371518c769d84af8ec9b7dcb871ac44f7a67ef126dd3a15c88c25458e6b6d205"}, - {file = "matplotlib-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:793e061054662aa27acaff9201cdd510a698541c6e8659eeceb31d66c16facc6"}, - {file = "matplotlib-3.3.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:16b241c3d17be786966495229714de37de04472da472277869b8d5b456a8df00"}, - {file = "matplotlib-3.3.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:3fb0409754b26f48045bacd6818e44e38ca9338089f8ba689e2f9344ff2847c7"}, - {file = "matplotlib-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:548cfe81476dbac44db96e9c0b074b6fb333b4d1f12b1ae68dbed47e45166384"}, - {file = "matplotlib-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:f0268613073df055bcc6a490de733012f2cf4fe191c1adb74e41cec8add1a165"}, - {file = "matplotlib-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:57be9e21073fc367237b03ecac0d9e4b8ddbe38e86ec4a316857d8d93ac9286c"}, - {file = "matplotlib-3.3.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:be2f0ec62e0939a9dcfd3638c140c5a74fc929ee3fd1f31408ab8633db6e1523"}, - {file = "matplotlib-3.3.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:c5d0c2ae3e3ed4e9f46b7c03b40d443601012ffe8eb8dfbb2bd6b2d00509f797"}, - {file = "matplotlib-3.3.2-cp38-cp38-win32.whl", hash = "sha256:a522de31e07ed7d6f954cda3fbd5ca4b8edbfc592a821a7b00291be6f843292e"}, - {file = "matplotlib-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:8bc1d3284dee001f41ec98f59675f4d723683e1cc082830b440b5f081d8e0ade"}, - {file = "matplotlib-3.3.2-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:799c421bc245a0749c1515b6dea6dc02db0a8c1f42446a0f03b3b82a60a900dc"}, - {file = "matplotlib-3.3.2-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:2f5eefc17dc2a71318d5a3496313be5c351c0731e8c4c6182c9ac3782cfc4076"}, - {file = "matplotlib-3.3.2.tar.gz", hash = "sha256:3d2edbf59367f03cd9daf42939ca06383a7d7803e3993eb5ff1bee8e8a3fbb6b"}, + {file = "matplotlib-3.4.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c541ee5a3287efe066bbe358320853cf4916bc14c00c38f8f3d8d75275a405a9"}, + {file = "matplotlib-3.4.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:3a5c18dbd2c7c366da26a4ad1462fe3e03a577b39e3b503bbcf482b9cdac093c"}, + {file = "matplotlib-3.4.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:a9d8cb5329df13e0cdaa14b3b43f47b5e593ec637f13f14db75bb16e46178b05"}, + {file = "matplotlib-3.4.2-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:7ad19f3fb6145b9eb41c08e7cbb9f8e10b91291396bee21e9ce761bb78df63ec"}, + {file = "matplotlib-3.4.2-cp37-cp37m-win32.whl", hash = "sha256:7a58f3d8fe8fac3be522c79d921c9b86e090a59637cb88e3bc51298d7a2c862a"}, + {file = "matplotlib-3.4.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6382bc6e2d7e481bcd977eb131c31dee96e0fb4f9177d15ec6fb976d3b9ace1a"}, + {file = "matplotlib-3.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6a6a44f27aabe720ec4fd485061e8a35784c2b9ffa6363ad546316dfc9cea04e"}, + {file = "matplotlib-3.4.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:1c1779f7ab7d8bdb7d4c605e6ffaa0614b3e80f1e3c8ccf7b9269a22dbc5986b"}, + {file = "matplotlib-3.4.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:5826f56055b9b1c80fef82e326097e34dc4af8c7249226b7dd63095a686177d1"}, + {file = "matplotlib-3.4.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:0bea5ec5c28d49020e5d7923c2725b837e60bc8be99d3164af410eb4b4c827da"}, + {file = "matplotlib-3.4.2-cp38-cp38-win32.whl", hash = "sha256:6475d0209024a77f869163ec3657c47fed35d9b6ed8bccba8aa0f0099fbbdaa8"}, + {file = "matplotlib-3.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:21b31057bbc5e75b08e70a43cefc4c0b2c2f1b1a850f4a0f7af044eb4163086c"}, + {file = "matplotlib-3.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b26535b9de85326e6958cdef720ecd10bcf74a3f4371bf9a7e5b2e659c17e153"}, + {file = "matplotlib-3.4.2-cp39-cp39-manylinux1_i686.whl", hash = "sha256:32fa638cc10886885d1ca3d409d4473d6a22f7ceecd11322150961a70fab66dd"}, + {file = "matplotlib-3.4.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:956c8849b134b4a343598305a3ca1bdd3094f01f5efc8afccdebeffe6b315247"}, + {file = "matplotlib-3.4.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:85f191bb03cb1a7b04b5c2cca4792bef94df06ef473bc49e2818105671766fee"}, + {file = "matplotlib-3.4.2-cp39-cp39-win32.whl", hash = "sha256:b1d5a2cedf5de05567c441b3a8c2651fbde56df08b82640e7f06c8cd91e201f6"}, + {file = "matplotlib-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:df815378a754a7edd4559f8c51fc7064f779a74013644a7f5ac7a0c31f875866"}, + {file = "matplotlib-3.4.2.tar.gz", hash = "sha256:d8d994cefdff9aaba45166eb3de4f5211adb4accac85cbf97137e98f26ea0219"}, +] +matplotlib-inline = [ + {file = "matplotlib-inline-0.1.2.tar.gz", hash = "sha256:f41d5ff73c9f5385775d5c0bc13b424535c8402fe70ea8210f93e11f3683993e"}, + {file = "matplotlib_inline-0.1.2-py3-none-any.whl", hash = "sha256:5cf1176f554abb4fa98cb362aa2b55c500147e4bdbb07e3fda359143e1da0811"}, ] mistune = [ {file = "mistune-0.8.4-py2.py3-none-any.whl", hash = "sha256:88a1051873018da288eee8538d476dffe1262495144b33ecb586c4ab266bb8d4"}, {file = "mistune-0.8.4.tar.gz", hash = "sha256:59a3429db53c50b5c6bcc8a07f8848cb00d7dc8bdb431a4ab41920d201d4756e"}, ] +nbclassic = [ + {file = "nbclassic-0.3.1-py3-none-any.whl", hash = "sha256:a7437c90a0bffcce172a4540cc53e140ea5987280c87c31a0cfa6e5d315eb907"}, + {file = "nbclassic-0.3.1.tar.gz", hash = "sha256:f920f8d09849bea7950e1017ff3bd101763a8d68f565a51ce053572e65aa7947"}, +] nbclient = [ - {file = "nbclient-0.5.0-py3-none-any.whl", hash = "sha256:8a6e27ff581cee50895f44c41936ce02369674e85e2ad58643d8d4a6c36771b0"}, - {file = "nbclient-0.5.0.tar.gz", hash = "sha256:8ad52d27ba144fca1402db014857e53c5a864a2f407be66ca9d74c3a56d6591d"}, + {file = "nbclient-0.5.3-py3-none-any.whl", hash = "sha256:e79437364a2376892b3f46bedbf9b444e5396cfb1bc366a472c37b48e9551500"}, + {file = "nbclient-0.5.3.tar.gz", hash = "sha256:db17271330c68c8c88d46d72349e24c147bb6f34ec82d8481a8f025c4d26589c"}, ] nbconvert = [ - {file = "nbconvert-6.0.3-py3-none-any.whl", hash = "sha256:06c64fd45d4b6424e88eb3bf7e5eb205a0fc8a4c0a69666f0b9a2262c76f59e1"}, - {file = "nbconvert-6.0.3.tar.gz", hash = "sha256:d8490f40368a1324521f8e740a0e341dc40bcd6e6926da64fa64b3a8801f16a3"}, + {file = "nbconvert-6.0.7-py3-none-any.whl", hash = "sha256:39e9f977920b203baea0be67eea59f7b37a761caa542abe80f5897ce3cf6311d"}, + {file = "nbconvert-6.0.7.tar.gz", hash = "sha256:cbbc13a86dfbd4d1b5dee106539de0795b4db156c894c2c5dc382062bbc29002"}, ] nbformat = [ - {file = "nbformat-5.0.7-py3-none-any.whl", hash = "sha256:ea55c9b817855e2dfcd3f66d74857342612a60b1f09653440f4a5845e6e3523f"}, - {file = "nbformat-5.0.7.tar.gz", hash = "sha256:54d4d6354835a936bad7e8182dcd003ca3dc0cedfee5a306090e04854343b340"}, + {file = "nbformat-5.1.3-py3-none-any.whl", hash = "sha256:eb8447edd7127d043361bc17f2f5a807626bc8e878c7709a1c647abda28a9171"}, + {file = "nbformat-5.1.3.tar.gz", hash = "sha256:b516788ad70771c6250977c1374fcca6edebe6126fd2adb5a69aa5c2356fd1c8"}, ] nest-asyncio = [ - {file = "nest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:ea51120725212ef02e5870dd77fc67ba7343fc945e3b9a7ff93384436e043b6a"}, - {file = "nest_asyncio-1.4.0.tar.gz", hash = "sha256:5773054bbc14579b000236f85bc01ecced7ffd045ec8ca4a9809371ec65a59c8"}, + {file = "nest_asyncio-1.5.1-py3-none-any.whl", hash = "sha256:76d6e972265063fe92a90b9cc4fb82616e07d586b346ed9d2c89a4187acea39c"}, + {file = "nest_asyncio-1.5.1.tar.gz", hash = "sha256:afc5a1c515210a23c461932765691ad39e8eba6551c055ac8d5546e69250d0aa"}, ] notebook = [ - {file = "notebook-6.1.4-py3-none-any.whl", hash = "sha256:07b6e8b8a61aa2f780fe9a97430470485bc71262bc5cae8521f1441b910d2c88"}, - {file = "notebook-6.1.4.tar.gz", hash = "sha256:687d01f963ea20360c0b904ee7a37c3d8cda553858c8d6e33fd0afd13e89de32"}, + {file = "notebook-6.4.0-py3-none-any.whl", hash = "sha256:f7f0a71a999c7967d9418272ae4c3378a220bd28330fbfb49860e46cf8a5838a"}, + {file = "notebook-6.4.0.tar.gz", hash = "sha256:9c4625e2a2aa49d6eae4ce20cbc3d8976db19267e32d2a304880e0c10bf8aef9"}, ] numpy = [ - {file = "numpy-1.19.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:b594f76771bc7fc8a044c5ba303427ee67c17a09b36e1fa32bde82f5c419d17a"}, - {file = "numpy-1.19.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:e6ddbdc5113628f15de7e4911c02aed74a4ccff531842c583e5032f6e5a179bd"}, - {file = "numpy-1.19.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:3733640466733441295b0d6d3dcbf8e1ffa7e897d4d82903169529fd3386919a"}, - {file = "numpy-1.19.2-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:4339741994c775396e1a274dba3609c69ab0f16056c1077f18979bec2a2c2e6e"}, - {file = "numpy-1.19.2-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:7c6646314291d8f5ea900a7ea9c4261f834b5b62159ba2abe3836f4fa6705526"}, - {file = "numpy-1.19.2-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:7118f0a9f2f617f921ec7d278d981244ba83c85eea197be7c5a4f84af80a9c3c"}, - {file = "numpy-1.19.2-cp36-cp36m-win32.whl", hash = "sha256:9a3001248b9231ed73894c773142658bab914645261275f675d86c290c37f66d"}, - {file = "numpy-1.19.2-cp36-cp36m-win_amd64.whl", hash = "sha256:967c92435f0b3ba37a4257c48b8715b76741410467e2bdb1097e8391fccfae15"}, - {file = "numpy-1.19.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:d526fa58ae4aead839161535d59ea9565863bb0b0bdb3cc63214613fb16aced4"}, - {file = "numpy-1.19.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:eb25c381d168daf351147713f49c626030dcff7a393d5caa62515d415a6071d8"}, - {file = "numpy-1.19.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:62139af94728d22350a571b7c82795b9d59be77fc162414ada6c8b6a10ef5d02"}, - {file = "numpy-1.19.2-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:0c66da1d202c52051625e55a249da35b31f65a81cb56e4c69af0dfb8fb0125bf"}, - {file = "numpy-1.19.2-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:2117536e968abb7357d34d754e3733b0d7113d4c9f1d921f21a3d96dec5ff716"}, - {file = "numpy-1.19.2-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:54045b198aebf41bf6bf4088012777c1d11703bf74461d70cd350c0af2182e45"}, - {file = "numpy-1.19.2-cp37-cp37m-win32.whl", hash = "sha256:aba1d5daf1144b956bc87ffb87966791f5e9f3e1f6fab3d7f581db1f5b598f7a"}, - {file = "numpy-1.19.2-cp37-cp37m-win_amd64.whl", hash = "sha256:addaa551b298052c16885fc70408d3848d4e2e7352de4e7a1e13e691abc734c1"}, - {file = "numpy-1.19.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:58d66a6b3b55178a1f8a5fe98df26ace76260a70de694d99577ddeab7eaa9a9d"}, - {file = "numpy-1.19.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:59f3d687faea7a4f7f93bd9665e5b102f32f3fa28514f15b126f099b7997203d"}, - {file = "numpy-1.19.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:cebd4f4e64cfe87f2039e4725781f6326a61f095bc77b3716502bed812b385a9"}, - {file = "numpy-1.19.2-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:c35a01777f81e7333bcf276b605f39c872e28295441c265cd0c860f4b40148c1"}, - {file = "numpy-1.19.2-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:d7ac33585e1f09e7345aa902c281bd777fdb792432d27fca857f39b70e5dd31c"}, - {file = "numpy-1.19.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:04c7d4ebc5ff93d9822075ddb1751ff392a4375e5885299445fcebf877f179d5"}, - {file = "numpy-1.19.2-cp38-cp38-win32.whl", hash = "sha256:51ee93e1fac3fe08ef54ff1c7f329db64d8a9c5557e6c8e908be9497ac76374b"}, - {file = "numpy-1.19.2-cp38-cp38-win_amd64.whl", hash = "sha256:1669ec8e42f169ff715a904c9b2105b6640f3f2a4c4c2cb4920ae8b2785dac65"}, - {file = "numpy-1.19.2-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:0bfd85053d1e9f60234f28f63d4a5147ada7f432943c113a11afcf3e65d9d4c8"}, - {file = "numpy-1.19.2.zip", hash = "sha256:0d310730e1e793527065ad7dde736197b705d0e4c9999775f212b03c44a8484c"}, + {file = "numpy-1.20.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:70eb5808127284c4e5c9e836208e09d685a7978b6a216db85960b1a112eeace8"}, + {file = "numpy-1.20.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6ca2b85a5997dabc38301a22ee43c82adcb53ff660b89ee88dded6b33687e1d8"}, + {file = "numpy-1.20.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c5bf0e132acf7557fc9bb8ded8b53bbbbea8892f3c9a1738205878ca9434206a"}, + {file = "numpy-1.20.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:db250fd3e90117e0312b611574cd1b3f78bec046783195075cbd7ba9c3d73f16"}, + {file = "numpy-1.20.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:637d827248f447e63585ca3f4a7d2dfaa882e094df6cfa177cc9cf9cd6cdf6d2"}, + {file = "numpy-1.20.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:8b7bb4b9280da3b2856cb1fc425932f46fba609819ee1c62256f61799e6a51d2"}, + {file = "numpy-1.20.3-cp37-cp37m-win32.whl", hash = "sha256:67d44acb72c31a97a3d5d33d103ab06d8ac20770e1c5ad81bdb3f0c086a56cf6"}, + {file = "numpy-1.20.3-cp37-cp37m-win_amd64.whl", hash = "sha256:43909c8bb289c382170e0282158a38cf306a8ad2ff6dfadc447e90f9961bef43"}, + {file = "numpy-1.20.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f1452578d0516283c87608a5a5548b0cdde15b99650efdfd85182102ef7a7c17"}, + {file = "numpy-1.20.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:6e51534e78d14b4a009a062641f465cfaba4fdcb046c3ac0b1f61dd97c861b1b"}, + {file = "numpy-1.20.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e515c9a93aebe27166ec9593411c58494fa98e5fcc219e47260d9ab8a1cc7f9f"}, + {file = "numpy-1.20.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1c09247ccea742525bdb5f4b5ceeacb34f95731647fe55774aa36557dbb5fa4"}, + {file = "numpy-1.20.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:66fbc6fed94a13b9801fb70b96ff30605ab0a123e775a5e7a26938b717c5d71a"}, + {file = "numpy-1.20.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ea9cff01e75a956dbee133fa8e5b68f2f92175233de2f88de3a682dd94deda65"}, + {file = "numpy-1.20.3-cp38-cp38-win32.whl", hash = "sha256:f39a995e47cb8649673cfa0579fbdd1cdd33ea497d1728a6cb194d6252268e48"}, + {file = "numpy-1.20.3-cp38-cp38-win_amd64.whl", hash = "sha256:1676b0a292dd3c99e49305a16d7a9f42a4ab60ec522eac0d3dd20cdf362ac010"}, + {file = "numpy-1.20.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:830b044f4e64a76ba71448fce6e604c0fc47a0e54d8f6467be23749ac2cbd2fb"}, + {file = "numpy-1.20.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:55b745fca0a5ab738647d0e4db099bd0a23279c32b31a783ad2ccea729e632df"}, + {file = "numpy-1.20.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5d050e1e4bc9ddb8656d7b4f414557720ddcca23a5b88dd7cff65e847864c400"}, + {file = "numpy-1.20.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9c65473ebc342715cb2d7926ff1e202c26376c0dcaaee85a1fd4b8d8c1d3b2f"}, + {file = "numpy-1.20.3-cp39-cp39-win32.whl", hash = "sha256:16f221035e8bd19b9dc9a57159e38d2dd060b48e93e1d843c49cb370b0f415fd"}, + {file = "numpy-1.20.3-cp39-cp39-win_amd64.whl", hash = "sha256:6690080810f77485667bfbff4f69d717c3be25e5b11bb2073e76bb3f578d99b4"}, + {file = "numpy-1.20.3-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4e465afc3b96dbc80cf4a5273e5e2b1e3451286361b4af70ce1adb2984d392f9"}, + {file = "numpy-1.20.3.zip", hash = "sha256:e55185e51b18d788e49fe8305fd73ef4470596b33fc2c1ceb304566b99c71a69"}, ] packaging = [ - {file = "packaging-20.4-py2.py3-none-any.whl", hash = "sha256:998416ba6962ae7fbd6596850b80e17859a5753ba17c32284f67bfff33784181"}, - {file = "packaging-20.4.tar.gz", hash = "sha256:4357f74f47b9c12db93624a82154e9b120fa8293699949152b22065d556079f8"}, + {file = "packaging-20.9-py2.py3-none-any.whl", hash = "sha256:67714da7f7bc052e064859c05c595155bd1ee9f69f76557e21f051443c20947a"}, + {file = "packaging-20.9.tar.gz", hash = "sha256:5b327ac1320dc863dca72f4514ecc086f31186744b84a230374cc1fd776feae5"}, ] pandas = [ - {file = "pandas-1.1.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:eb0ac2fd04428f18b547716f70c699a7cc9c65a6947ed8c7e688d96eb91e3db8"}, - {file = "pandas-1.1.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:02ec9f5f0b7df7227931a884569ef0b6d32d76789c84bcac1a719dafd1f912e8"}, - {file = "pandas-1.1.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:1edf6c254d2d138188e9987159978ee70e23362fe9197f3f100844a197f7e1e4"}, - {file = "pandas-1.1.2-cp36-cp36m-win32.whl", hash = "sha256:b821f239514a9ce46dd1cd6c9298a03ed58d0235d414ea264aacc1b14916bbe4"}, - {file = "pandas-1.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:ab6ea0f3116f408a8a59cd50158bfd19d2a024f4e221f14ab1bcd2da4f0c6fdf"}, - {file = "pandas-1.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:474fa53e3b2f3a543cbca81f7457bd1f44e7eb1be7171067636307e21b624e9c"}, - {file = "pandas-1.1.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:9e135ce9929cd0f0ba24f0545936af17ba935f844d4c3a2b979354a73c9440e0"}, - {file = "pandas-1.1.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:188cdfbf8399bc144fa95040536b5ce3429d2eda6c9c8b238c987af7df9f128c"}, - {file = "pandas-1.1.2-cp37-cp37m-win32.whl", hash = "sha256:08783a33989a6747317766b75be30a594a9764b9f145bb4bcc06e337930d9807"}, - {file = "pandas-1.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:f7008ec22b92d771b145150978d930a28fab8da3a10131b01bbf39574acdad0b"}, - {file = "pandas-1.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:59df9f0276aa4854d8bff28c5e5aeb74d9c6bb4d9f55d272b7124a7df40e47d0"}, - {file = "pandas-1.1.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:eeb64c5b3d4f2ea072ca8afdeb2b946cd681a863382ca79734f1b520b8d2fa26"}, - {file = "pandas-1.1.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:c9235b37489168ed6b173551c816b50aa89f03c24a8549a8b4d47d8dc79bfb1e"}, - {file = "pandas-1.1.2-cp38-cp38-win32.whl", hash = "sha256:0936991228241db937e87f82ec552a33888dd04a2e0d5a2fa3c689f92fab09e0"}, - {file = "pandas-1.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:026d764d0b86ee53183aa4c0b90774b6146123eeada4e24946d7d24290777be1"}, - {file = "pandas-1.1.2.tar.gz", hash = "sha256:b64ffd87a2cfd31b40acd4b92cb72ea9a52a48165aec4c140e78fd69c45d1444"}, + {file = "pandas-1.2.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c601c6fdebc729df4438ec1f62275d6136a0dd14d332fc0e8ce3f7d2aadb4dd6"}, + {file = "pandas-1.2.4-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:8d4c74177c26aadcfb4fd1de6c1c43c2bf822b3e0fc7a9b409eeaf84b3e92aaa"}, + {file = "pandas-1.2.4-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:b730add5267f873b3383c18cac4df2527ac4f0f0eed1c6cf37fcb437e25cf558"}, + {file = "pandas-1.2.4-cp37-cp37m-win32.whl", hash = "sha256:2cb7e8f4f152f27dc93f30b5c7a98f6c748601ea65da359af734dd0cf3fa733f"}, + {file = "pandas-1.2.4-cp37-cp37m-win_amd64.whl", hash = "sha256:2111c25e69fa9365ba80bbf4f959400054b2771ac5d041ed19415a8b488dc70a"}, + {file = "pandas-1.2.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:167693a80abc8eb28051fbd184c1b7afd13ce2c727a5af47b048f1ea3afefff4"}, + {file = "pandas-1.2.4-cp38-cp38-manylinux1_i686.whl", hash = "sha256:612add929bf3ba9d27b436cc8853f5acc337242d6b584203f207e364bb46cb12"}, + {file = "pandas-1.2.4-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:971e2a414fce20cc5331fe791153513d076814d30a60cd7348466943e6e909e4"}, + {file = "pandas-1.2.4-cp38-cp38-win32.whl", hash = "sha256:68d7baa80c74aaacbed597265ca2308f017859123231542ff8a5266d489e1858"}, + {file = "pandas-1.2.4-cp38-cp38-win_amd64.whl", hash = "sha256:bd659c11a4578af740782288cac141a322057a2e36920016e0fc7b25c5a4b686"}, + {file = "pandas-1.2.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9db70ffa8b280bb4de83f9739d514cd0735825e79eef3a61d312420b9f16b758"}, + {file = "pandas-1.2.4-cp39-cp39-manylinux1_i686.whl", hash = "sha256:298f0553fd3ba8e002c4070a723a59cdb28eda579f3e243bc2ee397773f5398b"}, + {file = "pandas-1.2.4-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:52d2472acbb8a56819a87aafdb8b5b6d2b3386e15c95bde56b281882529a7ded"}, + {file = "pandas-1.2.4-cp39-cp39-win32.whl", hash = "sha256:d0877407359811f7b853b548a614aacd7dea83b0c0c84620a9a643f180060950"}, + {file = "pandas-1.2.4-cp39-cp39-win_amd64.whl", hash = "sha256:2b063d41803b6a19703b845609c0b700913593de067b552a8b24dd8eeb8c9895"}, + {file = "pandas-1.2.4.tar.gz", hash = "sha256:649ecab692fade3cbfcf967ff936496b0cfba0af00a55dfaacd82bdda5cb2279"}, ] pandocfilters = [ - {file = "pandocfilters-1.4.2.tar.gz", hash = "sha256:b3dd70e169bb5449e6bc6ff96aea89c5eea8c5f6ab5e207fc2f521a2cf4a0da9"}, + {file = "pandocfilters-1.4.3.tar.gz", hash = "sha256:bc63fbb50534b4b1f8ebe1860889289e8af94a23bff7445259592df25a3906eb"}, ] parso = [ - {file = "parso-0.7.1-py2.py3-none-any.whl", hash = "sha256:97218d9159b2520ff45eb78028ba8b50d2bc61dcc062a9682666f2dc4bd331ea"}, - {file = "parso-0.7.1.tar.gz", hash = "sha256:caba44724b994a8a5e086460bb212abc5a8bc46951bf4a9a1210745953622eb9"}, + {file = "parso-0.8.2-py2.py3-none-any.whl", hash = "sha256:a8c4922db71e4fdb90e0d0bc6e50f9b273d3397925e5e60a717e719201778d22"}, + {file = "parso-0.8.2.tar.gz", hash = "sha256:12b83492c6239ce32ff5eed6d3639d6a536170723c6f3f1506869f1ace413398"}, ] pexpect = [ {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"}, @@ -1196,54 +1285,63 @@ pickleshare = [ {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, ] pillow = [ - {file = "Pillow-7.2.0-cp35-cp35m-macosx_10_10_intel.whl", hash = "sha256:1ca594126d3c4def54babee699c055a913efb01e106c309fa6b04405d474d5ae"}, - {file = "Pillow-7.2.0-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:c92302a33138409e8f1ad16731568c55c9053eee71bb05b6b744067e1b62380f"}, - {file = "Pillow-7.2.0-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:8dad18b69f710bf3a001d2bf3afab7c432785d94fcf819c16b5207b1cfd17d38"}, - {file = "Pillow-7.2.0-cp35-cp35m-manylinux2014_aarch64.whl", hash = "sha256:431b15cffbf949e89df2f7b48528be18b78bfa5177cb3036284a5508159492b5"}, - {file = "Pillow-7.2.0-cp35-cp35m-win32.whl", hash = "sha256:09d7f9e64289cb40c2c8d7ad674b2ed6105f55dc3b09aa8e4918e20a0311e7ad"}, - {file = "Pillow-7.2.0-cp35-cp35m-win_amd64.whl", hash = "sha256:0295442429645fa16d05bd567ef5cff178482439c9aad0411d3f0ce9b88b3a6f"}, - {file = "Pillow-7.2.0-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:ec29604081f10f16a7aea809ad42e27764188fc258b02259a03a8ff7ded3808d"}, - {file = "Pillow-7.2.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:612cfda94e9c8346f239bf1a4b082fdd5c8143cf82d685ba2dba76e7adeeb233"}, - {file = "Pillow-7.2.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:0a80dd307a5d8440b0a08bd7b81617e04d870e40a3e46a32d9c246e54705e86f"}, - {file = "Pillow-7.2.0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:06aba4169e78c439d528fdeb34762c3b61a70813527a2c57f0540541e9f433a8"}, - {file = "Pillow-7.2.0-cp36-cp36m-win32.whl", hash = "sha256:f7e30c27477dffc3e85c2463b3e649f751789e0f6c8456099eea7ddd53be4a8a"}, - {file = "Pillow-7.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:ffe538682dc19cc542ae7c3e504fdf54ca7f86fb8a135e59dd6bc8627eae6cce"}, - {file = "Pillow-7.2.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:94cf49723928eb6070a892cb39d6c156f7b5a2db4e8971cb958f7b6b104fb4c4"}, - {file = "Pillow-7.2.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:6edb5446f44d901e8683ffb25ebdfc26988ee813da3bf91e12252b57ac163727"}, - {file = "Pillow-7.2.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:52125833b070791fcb5710fabc640fc1df07d087fc0c0f02d3661f76c23c5b8b"}, - {file = "Pillow-7.2.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:9ad7f865eebde135d526bb3163d0b23ffff365cf87e767c649550964ad72785d"}, - {file = "Pillow-7.2.0-cp37-cp37m-win32.whl", hash = "sha256:c79f9c5fb846285f943aafeafda3358992d64f0ef58566e23484132ecd8d7d63"}, - {file = "Pillow-7.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d350f0f2c2421e65fbc62690f26b59b0bcda1b614beb318c81e38647e0f673a1"}, - {file = "Pillow-7.2.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:6d7741e65835716ceea0fd13a7d0192961212fd59e741a46bbed7a473c634ed6"}, - {file = "Pillow-7.2.0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:edf31f1150778abd4322444c393ab9c7bd2af271dd4dafb4208fb613b1f3cdc9"}, - {file = "Pillow-7.2.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:d08b23fdb388c0715990cbc06866db554e1822c4bdcf6d4166cf30ac82df8c41"}, - {file = "Pillow-7.2.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:5e51ee2b8114def244384eda1c82b10e307ad9778dac5c83fb0943775a653cd8"}, - {file = "Pillow-7.2.0-cp38-cp38-win32.whl", hash = "sha256:725aa6cfc66ce2857d585f06e9519a1cc0ef6d13f186ff3447ab6dff0a09bc7f"}, - {file = "Pillow-7.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:a060cf8aa332052df2158e5a119303965be92c3da6f2d93b6878f0ebca80b2f6"}, - {file = "Pillow-7.2.0-pp36-pypy36_pp73-macosx_10_10_x86_64.whl", hash = "sha256:9c87ef410a58dd54b92424ffd7e28fd2ec65d2f7fc02b76f5e9b2067e355ebf6"}, - {file = "Pillow-7.2.0-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:e901964262a56d9ea3c2693df68bc9860b8bdda2b04768821e4c44ae797de117"}, - {file = "Pillow-7.2.0-pp36-pypy36_pp73-win32.whl", hash = "sha256:25930fadde8019f374400f7986e8404c8b781ce519da27792cbe46eabec00c4d"}, - {file = "Pillow-7.2.0.tar.gz", hash = "sha256:97f9e7953a77d5a70f49b9a48da7776dc51e9b738151b22dacf101641594a626"}, + {file = "Pillow-8.2.0-cp36-cp36m-macosx_10_10_x86_64.whl", hash = "sha256:dc38f57d8f20f06dd7c3161c59ca2c86893632623f33a42d592f097b00f720a9"}, + {file = "Pillow-8.2.0-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:a013cbe25d20c2e0c4e85a9daf438f85121a4d0344ddc76e33fd7e3965d9af4b"}, + {file = "Pillow-8.2.0-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:8bb1e155a74e1bfbacd84555ea62fa21c58e0b4e7e6b20e4447b8d07990ac78b"}, + {file = "Pillow-8.2.0-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:c5236606e8570542ed424849f7852a0ff0bce2c4c8d0ba05cc202a5a9c97dee9"}, + {file = "Pillow-8.2.0-cp36-cp36m-win32.whl", hash = "sha256:12e5e7471f9b637762453da74e390e56cc43e486a88289995c1f4c1dc0bfe727"}, + {file = "Pillow-8.2.0-cp36-cp36m-win_amd64.whl", hash = "sha256:5afe6b237a0b81bd54b53f835a153770802f164c5570bab5e005aad693dab87f"}, + {file = "Pillow-8.2.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:cb7a09e173903541fa888ba010c345893cd9fc1b5891aaf060f6ca77b6a3722d"}, + {file = "Pillow-8.2.0-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:0d19d70ee7c2ba97631bae1e7d4725cdb2ecf238178096e8c82ee481e189168a"}, + {file = "Pillow-8.2.0-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:083781abd261bdabf090ad07bb69f8f5599943ddb539d64497ed021b2a67e5a9"}, + {file = "Pillow-8.2.0-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:c6b39294464b03457f9064e98c124e09008b35a62e3189d3513e5148611c9388"}, + {file = "Pillow-8.2.0-cp37-cp37m-win32.whl", hash = "sha256:01425106e4e8cee195a411f729cff2a7d61813b0b11737c12bd5991f5f14bcd5"}, + {file = "Pillow-8.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:3b570f84a6161cf8865c4e08adf629441f56e32f180f7aa4ccbd2e0a5a02cba2"}, + {file = "Pillow-8.2.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:031a6c88c77d08aab84fecc05c3cde8414cd6f8406f4d2b16fed1e97634cc8a4"}, + {file = "Pillow-8.2.0-cp38-cp38-manylinux1_i686.whl", hash = "sha256:66cc56579fd91f517290ab02c51e3a80f581aba45fd924fcdee01fa06e635812"}, + {file = "Pillow-8.2.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:6c32cc3145928c4305d142ebec682419a6c0a8ce9e33db900027ddca1ec39178"}, + {file = "Pillow-8.2.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:624b977355cde8b065f6d51b98497d6cd5fbdd4f36405f7a8790e3376125e2bb"}, + {file = "Pillow-8.2.0-cp38-cp38-win32.whl", hash = "sha256:5cbf3e3b1014dddc45496e8cf38b9f099c95a326275885199f427825c6522232"}, + {file = "Pillow-8.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:463822e2f0d81459e113372a168f2ff59723e78528f91f0bd25680ac185cf797"}, + {file = "Pillow-8.2.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:95d5ef984eff897850f3a83883363da64aae1000e79cb3c321915468e8c6add5"}, + {file = "Pillow-8.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b91c36492a4bbb1ee855b7d16fe51379e5f96b85692dc8210831fbb24c43e484"}, + {file = "Pillow-8.2.0-cp39-cp39-manylinux1_i686.whl", hash = "sha256:d68cb92c408261f806b15923834203f024110a2e2872ecb0bd2a110f89d3c602"}, + {file = "Pillow-8.2.0-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:f217c3954ce5fd88303fc0c317af55d5e0204106d86dea17eb8205700d47dec2"}, + {file = "Pillow-8.2.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5b70110acb39f3aff6b74cf09bb4169b167e2660dabc304c1e25b6555fa781ef"}, + {file = "Pillow-8.2.0-cp39-cp39-win32.whl", hash = "sha256:a7d5e9fad90eff8f6f6106d3b98b553a88b6f976e51fce287192a5d2d5363713"}, + {file = "Pillow-8.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:238c197fc275b475e87c1453b05b467d2d02c2915fdfdd4af126145ff2e4610c"}, + {file = "Pillow-8.2.0-pp36-pypy36_pp73-macosx_10_10_x86_64.whl", hash = "sha256:0e04d61f0064b545b989126197930807c86bcbd4534d39168f4aa5fda39bb8f9"}, + {file = "Pillow-8.2.0-pp36-pypy36_pp73-manylinux2010_i686.whl", hash = "sha256:63728564c1410d99e6d1ae8e3b810fe012bc440952168af0a2877e8ff5ab96b9"}, + {file = "Pillow-8.2.0-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:c03c07ed32c5324939b19e36ae5f75c660c81461e312a41aea30acdd46f93a7c"}, + {file = "Pillow-8.2.0-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:4d98abdd6b1e3bf1a1cbb14c3895226816e666749ac040c4e2554231068c639b"}, + {file = "Pillow-8.2.0-pp37-pypy37_pp73-manylinux2010_i686.whl", hash = "sha256:aac00e4bc94d1b7813fe882c28990c1bc2f9d0e1aa765a5f2b516e8a6a16a9e4"}, + {file = "Pillow-8.2.0-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:22fd0f42ad15dfdde6c581347eaa4adb9a6fc4b865f90b23378aa7914895e120"}, + {file = "Pillow-8.2.0-pp37-pypy37_pp73-win32.whl", hash = "sha256:e98eca29a05913e82177b3ba3d198b1728e164869c613d76d0de4bde6768a50e"}, + {file = "Pillow-8.2.0.tar.gz", hash = "sha256:a787ab10d7bb5494e5f76536ac460741788f1fbce851068d73a87ca7c35fc3e1"}, ] prometheus-client = [ - {file = "prometheus_client-0.8.0-py2.py3-none-any.whl", hash = "sha256:983c7ac4b47478720db338f1491ef67a100b474e3bc7dafcbaefb7d0b8f9b01c"}, - {file = "prometheus_client-0.8.0.tar.gz", hash = "sha256:c6e6b706833a6bd1fd51711299edee907857be10ece535126a158f911ee80915"}, + {file = "prometheus_client-0.10.1-py2.py3-none-any.whl", hash = "sha256:030e4f9df5f53db2292eec37c6255957eb76168c6f974e4176c711cf91ed34aa"}, + {file = "prometheus_client-0.10.1.tar.gz", hash = "sha256:b6c5a9643e3545bcbfd9451766cbaa5d9c67e7303c7bc32c750b6fa70ecb107d"}, ] prompt-toolkit = [ - {file = "prompt_toolkit-3.0.7-py3-none-any.whl", hash = "sha256:83074ee28ad4ba6af190593d4d4c607ff525272a504eb159199b6dd9f950c950"}, - {file = "prompt_toolkit-3.0.7.tar.gz", hash = "sha256:822f4605f28f7d2ba6b0b09a31e25e140871e96364d1d377667b547bb3bf4489"}, + {file = "prompt_toolkit-3.0.18-py3-none-any.whl", hash = "sha256:bf00f22079f5fadc949f42ae8ff7f05702826a97059ffcc6281036ad40ac6f04"}, + {file = "prompt_toolkit-3.0.18.tar.gz", hash = "sha256:e1b4f11b9336a28fa11810bc623c357420f69dfdb6d2dac41ca2c21a55c033bc"}, ] ptyprocess = [ - {file = "ptyprocess-0.6.0-py2.py3-none-any.whl", hash = "sha256:d7cc528d76e76342423ca640335bd3633420dc1366f258cb31d05e865ef5ca1f"}, - {file = "ptyprocess-0.6.0.tar.gz", hash = "sha256:923f299cc5ad920c68f2bc0bc98b75b9f838b93b599941a6b63ddbc2476394c0"}, + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] +py = [ + {file = "py-1.10.0-py2.py3-none-any.whl", hash = "sha256:3b80836aa6d1feeaa108e046da6423ab8f6ceda6468545ae8d02d9d58d18818a"}, + {file = "py-1.10.0.tar.gz", hash = "sha256:21b81bda15b66ef5e1a777a21c4dcd9c20ad3efd0b3f817e7a809035269e1bd3"}, ] pycparser = [ {file = "pycparser-2.20-py2.py3-none-any.whl", hash = "sha256:7582ad22678f0fcd81102833f60ef8d0e57288b6b5fb00323d101be910e35705"}, {file = "pycparser-2.20.tar.gz", hash = "sha256:2d475327684562c3a96cc71adf7dc8c4f0565175cf86b6d7a404ff4c771f15f0"}, ] pygments = [ - {file = "Pygments-2.7.0-py3-none-any.whl", hash = "sha256:2df50d16b45b977217e02cba6c8422aaddb859f3d0570a88e09b00eafae89c6e"}, - {file = "Pygments-2.7.0.tar.gz", hash = "sha256:2594e8fdb06fef91552f86f4fd3a244d148ab24b66042036e64f29a291515048"}, + {file = "Pygments-2.9.0-py3-none-any.whl", hash = "sha256:d66e804411278594d764fc69ec36ec13d9ae9147193a1740cd34d272ca383b8e"}, + {file = "Pygments-2.9.0.tar.gz", hash = "sha256:a18f47b506a429f6f4b9df81bb02beab9ca21d0a5fee38ed15aef65f0545519f"}, ] pyparsing = [ {file = "pyparsing-2.4.7-py2.py3-none-any.whl", hash = "sha256:ef9d7589ef3c200abe66653d3f1ab1033c3c419ae9b9bdb1240a85b024efc88b"}, @@ -1257,143 +1355,192 @@ python-dateutil = [ {file = "python_dateutil-2.8.1-py2.py3-none-any.whl", hash = "sha256:75bb3f31ea686f1197762692a9ee6a7550b59fc6ca3a1f4b5d7e32fb98e2da2a"}, ] pytz = [ - {file = "pytz-2020.1-py2.py3-none-any.whl", hash = "sha256:a494d53b6d39c3c6e44c3bec237336e14305e4f29bbf800b599253057fbb79ed"}, - {file = "pytz-2020.1.tar.gz", hash = "sha256:c35965d010ce31b23eeb663ed3cc8c906275d6be1a34393a1d73a41febf4a048"}, + {file = "pytz-2021.1-py2.py3-none-any.whl", hash = "sha256:eb10ce3e7736052ed3623d49975ce333bcd712c7bb19a58b9e2089d4057d0798"}, + {file = "pytz-2021.1.tar.gz", hash = "sha256:83a4a90894bf38e243cf052c8b58f381bfe9a7a483f6a9cab140bc7f702ac4da"}, ] pywin32 = [ - {file = "pywin32-228-cp27-cp27m-win32.whl", hash = "sha256:37dc9935f6a383cc744315ae0c2882ba1768d9b06700a70f35dc1ce73cd4ba9c"}, - {file = "pywin32-228-cp27-cp27m-win_amd64.whl", hash = "sha256:11cb6610efc2f078c9e6d8f5d0f957620c333f4b23466931a247fb945ed35e89"}, - {file = "pywin32-228-cp35-cp35m-win32.whl", hash = "sha256:1f45db18af5d36195447b2cffacd182fe2d296849ba0aecdab24d3852fbf3f80"}, - {file = "pywin32-228-cp35-cp35m-win_amd64.whl", hash = "sha256:6e38c44097a834a4707c1b63efa9c2435f5a42afabff634a17f563bc478dfcc8"}, - {file = "pywin32-228-cp36-cp36m-win32.whl", hash = "sha256:ec16d44b49b5f34e99eb97cf270806fdc560dff6f84d281eb2fcb89a014a56a9"}, - {file = "pywin32-228-cp36-cp36m-win_amd64.whl", hash = "sha256:a60d795c6590a5b6baeacd16c583d91cce8038f959bd80c53bd9a68f40130f2d"}, - {file = "pywin32-228-cp37-cp37m-win32.whl", hash = "sha256:af40887b6fc200eafe4d7742c48417529a8702dcc1a60bf89eee152d1d11209f"}, - {file = "pywin32-228-cp37-cp37m-win_amd64.whl", hash = "sha256:00eaf43dbd05ba6a9b0080c77e161e0b7a601f9a3f660727a952e40140537de7"}, - {file = "pywin32-228-cp38-cp38-win32.whl", hash = "sha256:fa6ba028909cfc64ce9e24bcf22f588b14871980d9787f1e2002c99af8f1850c"}, - {file = "pywin32-228-cp38-cp38-win_amd64.whl", hash = "sha256:9b3466083f8271e1a5eb0329f4e0d61925d46b40b195a33413e0905dccb285e8"}, - {file = "pywin32-228-cp39-cp39-win32.whl", hash = "sha256:ed74b72d8059a6606f64842e7917aeee99159ebd6b8d6261c518d002837be298"}, - {file = "pywin32-228-cp39-cp39-win_amd64.whl", hash = "sha256:8319bafdcd90b7202c50d6014efdfe4fde9311b3ff15fd6f893a45c0868de203"}, + {file = "pywin32-300-cp35-cp35m-win32.whl", hash = "sha256:1c204a81daed2089e55d11eefa4826c05e604d27fe2be40b6bf8db7b6a39da63"}, + {file = "pywin32-300-cp35-cp35m-win_amd64.whl", hash = "sha256:350c5644775736351b77ba68da09a39c760d75d2467ecec37bd3c36a94fbed64"}, + {file = "pywin32-300-cp36-cp36m-win32.whl", hash = "sha256:a3b4c48c852d4107e8a8ec980b76c94ce596ea66d60f7a697582ea9dce7e0db7"}, + {file = "pywin32-300-cp36-cp36m-win_amd64.whl", hash = "sha256:27a30b887afbf05a9cbb05e3ffd43104a9b71ce292f64a635389dbad0ed1cd85"}, + {file = "pywin32-300-cp37-cp37m-win32.whl", hash = "sha256:d7e8c7efc221f10d6400c19c32a031add1c4a58733298c09216f57b4fde110dc"}, + {file = "pywin32-300-cp37-cp37m-win_amd64.whl", hash = "sha256:8151e4d7a19262d6694162d6da85d99a16f8b908949797fd99c83a0bfaf5807d"}, + {file = "pywin32-300-cp38-cp38-win32.whl", hash = "sha256:fbb3b1b0fbd0b4fc2a3d1d81fe0783e30062c1abed1d17c32b7879d55858cfae"}, + {file = "pywin32-300-cp38-cp38-win_amd64.whl", hash = "sha256:60a8fa361091b2eea27f15718f8eb7f9297e8d51b54dbc4f55f3d238093d5190"}, + {file = "pywin32-300-cp39-cp39-win32.whl", hash = "sha256:638b68eea5cfc8def537e43e9554747f8dee786b090e47ead94bfdafdb0f2f50"}, + {file = "pywin32-300-cp39-cp39-win_amd64.whl", hash = "sha256:b1609ce9bd5c411b81f941b246d683d6508992093203d4eb7f278f4ed1085c3f"}, ] pywinpty = [ - {file = "pywinpty-0.5.7-cp27-cp27m-win32.whl", hash = "sha256:b358cb552c0f6baf790de375fab96524a0498c9df83489b8c23f7f08795e966b"}, - {file = "pywinpty-0.5.7-cp27-cp27m-win_amd64.whl", hash = "sha256:1e525a4de05e72016a7af27836d512db67d06a015aeaf2fa0180f8e6a039b3c2"}, - {file = "pywinpty-0.5.7-cp35-cp35m-win32.whl", hash = "sha256:2740eeeb59297593a0d3f762269b01d0285c1b829d6827445fcd348fb47f7e70"}, - {file = "pywinpty-0.5.7-cp35-cp35m-win_amd64.whl", hash = "sha256:33df97f79843b2b8b8bc5c7aaf54adec08cc1bae94ee99dfb1a93c7a67704d95"}, - {file = "pywinpty-0.5.7-cp36-cp36m-win32.whl", hash = "sha256:e854211df55d107f0edfda8a80b39dfc87015bef52a8fe6594eb379240d81df2"}, - {file = "pywinpty-0.5.7-cp36-cp36m-win_amd64.whl", hash = "sha256:dbd838de92de1d4ebf0dce9d4d5e4fc38d0b7b1de837947a18b57a882f219139"}, - {file = "pywinpty-0.5.7-cp37-cp37m-win32.whl", hash = "sha256:5fb2c6c6819491b216f78acc2c521b9df21e0f53b9a399d58a5c151a3c4e2a2d"}, - {file = "pywinpty-0.5.7-cp37-cp37m-win_amd64.whl", hash = "sha256:dd22c8efacf600730abe4a46c1388355ce0d4ab75dc79b15d23a7bd87bf05b48"}, - {file = "pywinpty-0.5.7-cp38-cp38-win_amd64.whl", hash = "sha256:8fc5019ff3efb4f13708bd3b5ad327589c1a554cb516d792527361525a7cb78c"}, - {file = "pywinpty-0.5.7.tar.gz", hash = "sha256:2d7e9c881638a72ffdca3f5417dd1563b60f603e1b43e5895674c2a1b01f95a0"}, + {file = "pywinpty-1.1.1-cp36-none-win_amd64.whl", hash = "sha256:fa2a0af28eaaacc59227c6edbc0f1525704d68b2dfa3e5b47ae21c5aa25d6d78"}, + {file = "pywinpty-1.1.1-cp37-none-win_amd64.whl", hash = "sha256:0fe3f538860c6b06e6fbe63da0ee5dab5194746b0df1be7ed65b4fce5da21d21"}, + {file = "pywinpty-1.1.1-cp38-none-win_amd64.whl", hash = "sha256:12c89765b3102d2eea3d39d191d1b0baea68fb5e3bd094c67b2575b3c9ebfa12"}, + {file = "pywinpty-1.1.1-cp39-none-win_amd64.whl", hash = "sha256:50bce6f7d9857ffe9694847af7e8bf989b198d0ebc2bf30e26d54c4622cb5c50"}, + {file = "pywinpty-1.1.1.tar.gz", hash = "sha256:4a3ffa2444daf15c5f65a76b5b2864447cc915564e41e2876816b9e4fe849070"}, ] pyzmq = [ - {file = "pyzmq-19.0.2-cp27-cp27m-macosx_10_9_intel.whl", hash = "sha256:59f1e54627483dcf61c663941d94c4af9bf4163aec334171686cdaee67974fe5"}, - {file = "pyzmq-19.0.2-cp27-cp27m-win32.whl", hash = "sha256:c36ffe1e5aa35a1af6a96640d723d0d211c5f48841735c2aa8d034204e87eb87"}, - {file = "pyzmq-19.0.2-cp27-cp27m-win_amd64.whl", hash = "sha256:0a422fc290d03958899743db091f8154958410fc76ce7ee0ceb66150f72c2c97"}, - {file = "pyzmq-19.0.2-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:c20dd60b9428f532bc59f2ef6d3b1029a28fc790d408af82f871a7db03e722ff"}, - {file = "pyzmq-19.0.2-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:d46fb17f5693244de83e434648b3dbb4f4b0fec88415d6cbab1c1452b6f2ae17"}, - {file = "pyzmq-19.0.2-cp35-cp35m-macosx_10_9_intel.whl", hash = "sha256:f1a25a61495b6f7bb986accc5b597a3541d9bd3ef0016f50be16dbb32025b302"}, - {file = "pyzmq-19.0.2-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:ab0d01148d13854de716786ca73701012e07dff4dfbbd68c4e06d8888743526e"}, - {file = "pyzmq-19.0.2-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:720d2b6083498a9281eaee3f2927486e9fe02cd16d13a844f2e95217f243efea"}, - {file = "pyzmq-19.0.2-cp35-cp35m-win32.whl", hash = "sha256:29d51279060d0a70f551663bc592418bcad7f4be4eea7b324f6dd81de05cb4c1"}, - {file = "pyzmq-19.0.2-cp35-cp35m-win_amd64.whl", hash = "sha256:5120c64646e75f6db20cc16b9a94203926ead5d633de9feba4f137004241221d"}, - {file = "pyzmq-19.0.2-cp36-cp36m-macosx_10_9_intel.whl", hash = "sha256:8a6ada5a3f719bf46a04ba38595073df8d6b067316c011180102ba2a1925f5b5"}, - {file = "pyzmq-19.0.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:fa411b1d8f371d3a49d31b0789eb6da2537dadbb2aef74a43aa99a78195c3f76"}, - {file = "pyzmq-19.0.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:00dca814469436455399660247d74045172955459c0bd49b54a540ce4d652185"}, - {file = "pyzmq-19.0.2-cp36-cp36m-win32.whl", hash = "sha256:046b92e860914e39612e84fa760fc3f16054d268c11e0e25dcb011fb1bc6a075"}, - {file = "pyzmq-19.0.2-cp36-cp36m-win_amd64.whl", hash = "sha256:99cc0e339a731c6a34109e5c4072aaa06d8e32c0b93dc2c2d90345dd45fa196c"}, - {file = "pyzmq-19.0.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e36f12f503511d72d9bdfae11cadbadca22ff632ff67c1b5459f69756a029c19"}, - {file = "pyzmq-19.0.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:c40fbb2b9933369e994b837ee72193d6a4c35dfb9a7c573257ef7ff28961272c"}, - {file = "pyzmq-19.0.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:5d9fc809aa8d636e757e4ced2302569d6e60e9b9c26114a83f0d9d6519c40493"}, - {file = "pyzmq-19.0.2-cp37-cp37m-win32.whl", hash = "sha256:3fa6debf4bf9412e59353defad1f8035a1e68b66095a94ead8f7a61ae90b2675"}, - {file = "pyzmq-19.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:73483a2caaa0264ac717af33d6fb3f143d8379e60a422730ee8d010526ce1913"}, - {file = "pyzmq-19.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:36ab114021c0cab1a423fe6689355e8f813979f2c750968833b318c1fa10a0fd"}, - {file = "pyzmq-19.0.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:8b66b94fe6243d2d1d89bca336b2424399aac57932858b9a30309803ffc28112"}, - {file = "pyzmq-19.0.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:654d3e06a4edc566b416c10293064732516cf8871a4522e0a2ba00cc2a2e600c"}, - {file = "pyzmq-19.0.2-cp38-cp38-win32.whl", hash = "sha256:276ad604bffd70992a386a84bea34883e696a6b22e7378053e5d3227321d9702"}, - {file = "pyzmq-19.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:09d24a80ccb8cbda1af6ed8eb26b005b6743e58e9290566d2a6841f4e31fa8e0"}, - {file = "pyzmq-19.0.2-pp27-pypy_73-macosx_10_9_x86_64.whl", hash = "sha256:c1a31cd42905b405530e92bdb70a8a56f048c8a371728b8acf9d746ecd4482c0"}, - {file = "pyzmq-19.0.2-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a7e7f930039ee0c4c26e4dfee015f20bd6919cd8b97c9cd7afbde2923a5167b6"}, - {file = "pyzmq-19.0.2.tar.gz", hash = "sha256:296540a065c8c21b26d63e3cea2d1d57902373b16e4256afe46422691903a438"}, + {file = "pyzmq-22.0.3-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:c0cde362075ee8f3d2b0353b283e203c2200243b5a15d5c5c03b78112a17e7d4"}, + {file = "pyzmq-22.0.3-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:ff1ea14075bbddd6f29bf6beb8a46d0db779bcec6b9820909584081ec119f8fd"}, + {file = "pyzmq-22.0.3-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:26380487eae4034d6c2a3fb8d0f2dff6dd0d9dd711894e8d25aa2d1938950a33"}, + {file = "pyzmq-22.0.3-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:3e29f9cf85a40d521d048b55c63f59d6c772ac1c4bf51cdfc23b62a62e377c33"}, + {file = "pyzmq-22.0.3-cp36-cp36m-win32.whl", hash = "sha256:4f34a173f813b38b83f058e267e30465ed64b22cd0cf6bad21148d3fa718f9bb"}, + {file = "pyzmq-22.0.3-cp36-cp36m-win_amd64.whl", hash = "sha256:30df70f81fe210506aa354d7fd486a39b87d9f7f24c3d3f4f698ec5d96b8c084"}, + {file = "pyzmq-22.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7026f0353977431fc884abd4ac28268894bd1a780ba84bb266d470b0ec26d2ed"}, + {file = "pyzmq-22.0.3-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:6d4163704201fff0f3ab0cd5d7a0ea1514ecfffd3926d62ec7e740a04d2012c7"}, + {file = "pyzmq-22.0.3-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:763c175294d861869f18eb42901d500eda7d3fa4565f160b3b2fd2678ea0ebab"}, + {file = "pyzmq-22.0.3-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:61e4bb6cd60caf1abcd796c3f48395e22c5b486eeca6f3a8797975c57d94b03e"}, + {file = "pyzmq-22.0.3-cp37-cp37m-win32.whl", hash = "sha256:b25e5d339550a850f7e919fe8cb4c8eabe4c917613db48dab3df19bfb9a28969"}, + {file = "pyzmq-22.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:3ef50d74469b03725d781a2a03c57537d86847ccde587130fe35caafea8f75c6"}, + {file = "pyzmq-22.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:60e63577b85055e4cc43892fecd877b86695ee3ef12d5d10a3c5d6e77a7cc1a3"}, + {file = "pyzmq-22.0.3-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:f5831eff6b125992ec65d973f5151c48003b6754030094723ac4c6e80a97c8c4"}, + {file = "pyzmq-22.0.3-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:9221783dacb419604d5345d0e097bddef4459a9a95322de6c306bf1d9896559f"}, + {file = "pyzmq-22.0.3-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:b62ea18c0458a65ccd5be90f276f7a5a3f26a6dea0066d948ce2fa896051420f"}, + {file = "pyzmq-22.0.3-cp38-cp38-win32.whl", hash = "sha256:81e7df0da456206201e226491aa1fc449da85328bf33bbeec2c03bb3a9f18324"}, + {file = "pyzmq-22.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:f52070871a0fd90a99130babf21f8af192304ec1e995bec2a9533efc21ea4452"}, + {file = "pyzmq-22.0.3-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:c5e29fe4678f97ce429f076a2a049a3d0b2660ada8f2c621e5dc9939426056dd"}, + {file = "pyzmq-22.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d18ddc6741b51f3985978f2fda57ddcdae359662d7a6b395bc8ff2292fca14bd"}, + {file = "pyzmq-22.0.3-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:4231943514812dfb74f44eadcf85e8dd8cf302b4d0bce450ce1357cac88dbfdc"}, + {file = "pyzmq-22.0.3-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:23a74de4b43c05c3044aeba0d1f3970def8f916151a712a3ac1e5cd9c0bc2902"}, + {file = "pyzmq-22.0.3-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:532af3e6dddea62d9c49062ece5add998c9823c2419da943cf95589f56737de0"}, + {file = "pyzmq-22.0.3-cp39-cp39-win32.whl", hash = "sha256:33acd2b9790818b9d00526135acf12790649d8d34b2b04d64558b469c9d86820"}, + {file = "pyzmq-22.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:a558c5bc89d56d7253187dccc4e81b5bb0eac5ae9511eb4951910a1245d04622"}, + {file = "pyzmq-22.0.3-pp36-pypy36_pp73-macosx_10_9_x86_64.whl", hash = "sha256:581787c62eaa0e0db6c5413cedc393ebbadac6ddfd22e1cf9a60da23c4f1a4b2"}, + {file = "pyzmq-22.0.3-pp36-pypy36_pp73-manylinux2010_x86_64.whl", hash = "sha256:38e3dca75d81bec4f2defa14b0a65b74545812bb519a8e89c8df96bbf4639356"}, + {file = "pyzmq-22.0.3-pp36-pypy36_pp73-win32.whl", hash = "sha256:2f971431aaebe0a8b54ac018e041c2f0b949a43745444e4dadcc80d0f0ef8457"}, + {file = "pyzmq-22.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:da7d4d4c778c86b60949d17531e60c54ed3726878de8a7f8a6d6e7f8cc8c3205"}, + {file = "pyzmq-22.0.3-pp37-pypy37_pp73-manylinux2010_x86_64.whl", hash = "sha256:13465c1ff969cab328bc92f7015ce3843f6e35f8871ad79d236e4fbc85dbe4cb"}, + {file = "pyzmq-22.0.3-pp37-pypy37_pp73-win32.whl", hash = "sha256:279cc9b51db48bec2db146f38e336049ac5a59e5f12fb3a8ad864e238c1c62e3"}, + {file = "pyzmq-22.0.3.tar.gz", hash = "sha256:f7f63ce127980d40f3e6a5fdb87abf17ce1a7c2bd8bf2c7560e1bbce8ab1f92d"}, ] requests = [ - {file = "requests-2.24.0-py2.py3-none-any.whl", hash = "sha256:fe75cc94a9443b9246fc7049224f75604b113c36acb93f87b80ed42c44cbb898"}, - {file = "requests-2.24.0.tar.gz", hash = "sha256:b3559a131db72c33ee969480840fff4bb6dd111de7dd27c8ee1f820f4f00231b"}, + {file = "requests-2.15.1-py2.py3-none-any.whl", hash = "sha256:ff753b2196cd18b1bbeddc9dcd5c864056599f7a7d9a4fb5677e723efa2b7fb9"}, + {file = "requests-2.15.1.tar.gz", hash = "sha256:e5659b9315a0610505e050bb7190bf6fa2ccee1ac295f2b760ef9d8a03ebbb2e"}, ] scikit-learn = [ - {file = "scikit-learn-0.23.2.tar.gz", hash = "sha256:20766f515e6cd6f954554387dfae705d93c7b544ec0e6c6a5d8e006f6f7ef480"}, - {file = "scikit_learn-0.23.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:98508723f44c61896a4e15894b2016762a55555fbf09365a0bb1870ecbd442de"}, - {file = "scikit_learn-0.23.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:a64817b050efd50f9abcfd311870073e500ae11b299683a519fbb52d85e08d25"}, - {file = "scikit_learn-0.23.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:daf276c465c38ef736a79bd79fc80a249f746bcbcae50c40945428f7ece074f8"}, - {file = "scikit_learn-0.23.2-cp36-cp36m-win32.whl", hash = "sha256:cb3e76380312e1f86abd20340ab1d5b3cc46a26f6593d3c33c9ea3e4c7134028"}, - {file = "scikit_learn-0.23.2-cp36-cp36m-win_amd64.whl", hash = "sha256:0a127cc70990d4c15b1019680bfedc7fec6c23d14d3719fdf9b64b22d37cdeca"}, - {file = "scikit_learn-0.23.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:2aa95c2f17d2f80534156215c87bee72b6aa314a7f8b8fe92a2d71f47280570d"}, - {file = "scikit_learn-0.23.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:6c28a1d00aae7c3c9568f61aafeaad813f0f01c729bee4fd9479e2132b215c1d"}, - {file = "scikit_learn-0.23.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:da8e7c302003dd765d92a5616678e591f347460ac7b53e53d667be7dfe6d1b10"}, - {file = "scikit_learn-0.23.2-cp37-cp37m-win32.whl", hash = "sha256:d9a1ce5f099f29c7c33181cc4386660e0ba891b21a60dc036bf369e3a3ee3aec"}, - {file = "scikit_learn-0.23.2-cp37-cp37m-win_amd64.whl", hash = "sha256:914ac2b45a058d3f1338d7736200f7f3b094857758895f8667be8a81ff443b5b"}, - {file = "scikit_learn-0.23.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7671bbeddd7f4f9a6968f3b5442dac5f22bf1ba06709ef888cc9132ad354a9ab"}, - {file = "scikit_learn-0.23.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:d0dcaa54263307075cb93d0bee3ceb02821093b1b3d25f66021987d305d01dce"}, - {file = "scikit_learn-0.23.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:5ce7a8021c9defc2b75620571b350acc4a7d9763c25b7593621ef50f3bd019a2"}, - {file = "scikit_learn-0.23.2-cp38-cp38-win32.whl", hash = "sha256:0d39748e7c9669ba648acf40fb3ce96b8a07b240db6888563a7cb76e05e0d9cc"}, - {file = "scikit_learn-0.23.2-cp38-cp38-win_amd64.whl", hash = "sha256:1b8a391de95f6285a2f9adffb7db0892718950954b7149a70c783dc848f104ea"}, + {file = "scikit-learn-0.24.2.tar.gz", hash = "sha256:d14701a12417930392cd3898e9646cf5670c190b933625ebe7511b1f7d7b8736"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-macosx_10_13_x86_64.whl", hash = "sha256:d5bf9c863ba4717b3917b5227463ee06860fc43931dc9026747de416c0a10fee"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:5beaeb091071625e83f5905192d8aecde65ba2f26f8b6719845bbf586f7a04a1"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:06ffdcaaf81e2a3b1b50c3ac6842cfb13df2d8b737d61f64643ed61da7389cde"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:fec42690a2eb646b384eafb021c425fab48991587edb412d4db77acc358b27ce"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:5ff3e4e4cf7592d36541edec434e09fb8ab9ba6b47608c4ffe30c9038d301897"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:3cbd734e1aefc7c5080e6b6973fe062f97c26a1cdf1a991037ca196ce1c8f427"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-win32.whl", hash = "sha256:f74429a07fedb36a03c159332b914e6de757176064f9fed94b5f79ebac07d913"}, + {file = "scikit_learn-0.24.2-cp36-cp36m-win_amd64.whl", hash = "sha256:dd968a174aa82f3341a615a033fa6a8169e9320cbb46130686562db132d7f1f0"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-macosx_10_13_x86_64.whl", hash = "sha256:49ec0b1361da328da9bb7f1a162836028e72556356adeb53342f8fae6b450d47"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:f18c3ed484eeeaa43a0d45dc2efb4d00fc6542ccdcfa2c45d7b635096a2ae534"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:cdf24c1b9bbeb4936456b42ac5bd32c60bb194a344951acb6bfb0cddee5439a4"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:d177fe1ff47cc235942d628d41ee5b1c6930d8f009f1a451c39b5411e8d0d4cf"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:f3ec00f023d84526381ad0c0f2cff982852d035c921bbf8ceb994f4886c00c64"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:ae19ac105cf7ce8c205a46166992fdec88081d6e783ab6e38ecfbe45729f3c39"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-win32.whl", hash = "sha256:f0ed4483c258fb23150e31b91ea7d25ff8495dba108aea0b0d4206a777705350"}, + {file = "scikit_learn-0.24.2-cp37-cp37m-win_amd64.whl", hash = "sha256:39b7e3b71bcb1fe46397185d6c1a5db1c441e71c23c91a31e7ad8cc3f7305f9a"}, + {file = "scikit_learn-0.24.2-cp38-cp38-macosx_10_13_x86_64.whl", hash = "sha256:90a297330f608adeb4d2e9786c6fda395d3150739deb3d42a86d9a4c2d15bc1d"}, + {file = "scikit_learn-0.24.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:f1d2108e770907540b5248977e4cff9ffaf0f73d0d13445ee938df06ca7579c6"}, + {file = "scikit_learn-0.24.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:1eec963fe9ffc827442c2e9333227c4d49749a44e592f305398c1db5c1563393"}, + {file = "scikit_learn-0.24.2-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:2db429090b98045d71218a9ba913cc9b3fe78e0ba0b6b647d8748bc6d5a44080"}, + {file = "scikit_learn-0.24.2-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:62214d2954377fcf3f31ec867dd4e436df80121e7a32947a0b3244f58f45e455"}, + {file = "scikit_learn-0.24.2-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8fac72b9688176922f9f54fda1ba5f7ffd28cbeb9aad282760186e8ceba9139a"}, + {file = "scikit_learn-0.24.2-cp38-cp38-win32.whl", hash = "sha256:ae426e3a52842c6b6d77d00f906b6031c8c2cfdfabd6af7511bb4bc9a68d720e"}, + {file = "scikit_learn-0.24.2-cp38-cp38-win_amd64.whl", hash = "sha256:038f4e9d6ef10e1f3fe82addc3a14735c299866eb10f2c77c090410904828312"}, + {file = "scikit_learn-0.24.2-cp39-cp39-macosx_10_13_x86_64.whl", hash = "sha256:48f273836e19901ba2beecd919f7b352f09310ce67c762f6e53bc6b81cacf1f0"}, + {file = "scikit_learn-0.24.2-cp39-cp39-manylinux1_i686.whl", hash = "sha256:a2a47449093dcf70babc930beba2ca0423cb7df2fa5fd76be5260703d67fa574"}, + {file = "scikit_learn-0.24.2-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:0e71ce9c7cbc20f6f8b860107ce15114da26e8675238b4b82b7e7cd37ca0c087"}, + {file = "scikit_learn-0.24.2-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:2754c85b2287333f9719db7f23fb7e357f436deed512db3417a02bf6f2830aa5"}, + {file = "scikit_learn-0.24.2-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:7be1b88c23cfac46e06404582215a917017cd2edaa2e4d40abe6aaff5458f24b"}, + {file = "scikit_learn-0.24.2-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:4e6198675a6f9d333774671bd536668680eea78e2e81c0b19e57224f58d17f37"}, + {file = "scikit_learn-0.24.2-cp39-cp39-win32.whl", hash = "sha256:cbdb0b3db99dd1d5f69d31b4234367d55475add31df4d84a3bd690ef017b55e2"}, + {file = "scikit_learn-0.24.2-cp39-cp39-win_amd64.whl", hash = "sha256:40556bea1ef26ef54bc678d00cf138a63069144a0b5f3a436eecd8f3468b903e"}, ] scipy = [ - {file = "scipy-1.5.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:cca9fce15109a36a0a9f9cfc64f870f1c140cb235ddf27fe0328e6afb44dfed0"}, - {file = "scipy-1.5.2-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:1c7564a4810c1cd77fcdee7fa726d7d39d4e2695ad252d7c86c3ea9d85b7fb8f"}, - {file = "scipy-1.5.2-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:07e52b316b40a4f001667d1ad4eb5f2318738de34597bd91537851365b6c61f1"}, - {file = "scipy-1.5.2-cp36-cp36m-win32.whl", hash = "sha256:d56b10d8ed72ec1be76bf10508446df60954f08a41c2d40778bc29a3a9ad9bce"}, - {file = "scipy-1.5.2-cp36-cp36m-win_amd64.whl", hash = "sha256:8e28e74b97fc8d6aa0454989db3b5d36fc27e69cef39a7ee5eaf8174ca1123cb"}, - {file = "scipy-1.5.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6e86c873fe1335d88b7a4bfa09d021f27a9e753758fd75f3f92d714aa4093768"}, - {file = "scipy-1.5.2-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:a0afbb967fd2c98efad5f4c24439a640d39463282040a88e8e928db647d8ac3d"}, - {file = "scipy-1.5.2-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:eecf40fa87eeda53e8e11d265ff2254729d04000cd40bae648e76ff268885d66"}, - {file = "scipy-1.5.2-cp37-cp37m-win32.whl", hash = "sha256:315aa2165aca31375f4e26c230188db192ed901761390be908c9b21d8b07df62"}, - {file = "scipy-1.5.2-cp37-cp37m-win_amd64.whl", hash = "sha256:ec5fe57e46828d034775b00cd625c4a7b5c7d2e354c3b258d820c6c72212a6ec"}, - {file = "scipy-1.5.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:fc98f3eac993b9bfdd392e675dfe19850cc8c7246a8fd2b42443e506344be7d9"}, - {file = "scipy-1.5.2-cp38-cp38-manylinux1_i686.whl", hash = "sha256:a785409c0fa51764766840185a34f96a0a93527a0ff0230484d33a8ed085c8f8"}, - {file = "scipy-1.5.2-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:0a0e9a4e58a4734c2eba917f834b25b7e3b6dc333901ce7784fd31aefbd37b2f"}, - {file = "scipy-1.5.2-cp38-cp38-win32.whl", hash = "sha256:dac09281a0eacd59974e24525a3bc90fa39b4e95177e638a31b14db60d3fa806"}, - {file = "scipy-1.5.2-cp38-cp38-win_amd64.whl", hash = "sha256:92eb04041d371fea828858e4fff182453c25ae3eaa8782d9b6c32b25857d23bc"}, - {file = "scipy-1.5.2.tar.gz", hash = "sha256:066c513d90eb3fd7567a9e150828d39111ebd88d3e924cdfc9f8ce19ab6f90c9"}, + {file = "scipy-1.6.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a15a1f3fc0abff33e792d6049161b7795909b40b97c6cc2934ed54384017ab76"}, + {file = "scipy-1.6.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:e79570979ccdc3d165456dd62041d9556fb9733b86b4b6d818af7a0afc15f092"}, + {file = "scipy-1.6.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:a423533c55fec61456dedee7b6ee7dce0bb6bfa395424ea374d25afa262be261"}, + {file = "scipy-1.6.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:33d6b7df40d197bdd3049d64e8e680227151673465e5d85723b3b8f6b15a6ced"}, + {file = "scipy-1.6.1-cp37-cp37m-win32.whl", hash = "sha256:6725e3fbb47da428794f243864f2297462e9ee448297c93ed1dcbc44335feb78"}, + {file = "scipy-1.6.1-cp37-cp37m-win_amd64.whl", hash = "sha256:5fa9c6530b1661f1370bcd332a1e62ca7881785cc0f80c0d559b636567fab63c"}, + {file = "scipy-1.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bd50daf727f7c195e26f27467c85ce653d41df4358a25b32434a50d8870fc519"}, + {file = "scipy-1.6.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:f46dd15335e8a320b0fb4685f58b7471702234cba8bb3442b69a3e1dc329c345"}, + {file = "scipy-1.6.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:0e5b0ccf63155d90da576edd2768b66fb276446c371b73841e3503be1d63fb5d"}, + {file = "scipy-1.6.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:2481efbb3740977e3c831edfd0bd9867be26387cacf24eb5e366a6a374d3d00d"}, + {file = "scipy-1.6.1-cp38-cp38-win32.whl", hash = "sha256:68cb4c424112cd4be886b4d979c5497fba190714085f46b8ae67a5e4416c32b4"}, + {file = "scipy-1.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:5f331eeed0297232d2e6eea51b54e8278ed8bb10b099f69c44e2558c090d06bf"}, + {file = "scipy-1.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0c8a51d33556bf70367452d4d601d1742c0e806cd0194785914daf19775f0e67"}, + {file = "scipy-1.6.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:83bf7c16245c15bc58ee76c5418e46ea1811edcc2e2b03041b804e46084ab627"}, + {file = "scipy-1.6.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:794e768cc5f779736593046c9714e0f3a5940bc6dcc1dba885ad64cbfb28e9f0"}, + {file = "scipy-1.6.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:5da5471aed911fe7e52b86bf9ea32fb55ae93e2f0fac66c32e58897cfb02fa07"}, + {file = "scipy-1.6.1-cp39-cp39-win32.whl", hash = "sha256:8e403a337749ed40af60e537cc4d4c03febddcc56cd26e774c9b1b600a70d3e4"}, + {file = "scipy-1.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:a5193a098ae9f29af283dcf0041f762601faf2e595c0db1da929875b7570353f"}, + {file = "scipy-1.6.1.tar.gz", hash = "sha256:c4fceb864890b6168e79b0e714c585dbe2fd4222768ee90bc1aa0f8218691b11"}, ] send2trash = [ {file = "Send2Trash-1.5.0-py3-none-any.whl", hash = "sha256:f1691922577b6fa12821234aeb57599d887c4900b9ca537948d2dac34aea888b"}, {file = "Send2Trash-1.5.0.tar.gz", hash = "sha256:60001cc07d707fe247c94f74ca6ac0d3255aabcb930529690897ca2a39db28b2"}, ] six = [ - {file = "six-1.15.0-py2.py3-none-any.whl", hash = "sha256:8b74bedcbbbaca38ff6d7491d76f2b06b3592611af620f8426e82dddb04a5ced"}, - {file = "six-1.15.0.tar.gz", hash = "sha256:30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259"}, + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] +sniffio = [ + {file = "sniffio-1.2.0-py3-none-any.whl", hash = "sha256:471b71698eac1c2112a40ce2752bb2f4a4814c22a54a3eed3676bc0f5ca9f663"}, + {file = "sniffio-1.2.0.tar.gz", hash = "sha256:c4666eecec1d3f50960c6bdf61ab7bc350648da6c126e3cf6898d8cd4ddcd3de"}, ] terminado = [ - {file = "terminado-0.8.3-py2.py3-none-any.whl", hash = "sha256:a43dcb3e353bc680dd0783b1d9c3fc28d529f190bc54ba9a229f72fe6e7a54d7"}, - {file = "terminado-0.8.3.tar.gz", hash = "sha256:4804a774f802306a7d9af7322193c5390f1da0abb429e082a10ef1d46e6fb2c2"}, + {file = "terminado-0.10.0-py3-none-any.whl", hash = "sha256:048ce7b271ad1f94c48130844af1de163e54913b919f8c268c89b36a6d468d7c"}, + {file = "terminado-0.10.0.tar.gz", hash = "sha256:46fd07c9dc7db7321922270d544a1f18eaa7a02fd6cd4438314f27a687cabbea"}, ] testpath = [ - {file = "testpath-0.4.4-py2.py3-none-any.whl", hash = "sha256:bfcf9411ef4bf3db7579063e0546938b1edda3d69f4e1fb8756991f5951f85d4"}, - {file = "testpath-0.4.4.tar.gz", hash = "sha256:60e0a3261c149755f4399a1fff7d37523179a70fdc3abdf78de9fc2604aeec7e"}, + {file = "testpath-0.5.0-py3-none-any.whl", hash = "sha256:8044f9a0bab6567fc644a3593164e872543bb44225b0e24846e2c89237937589"}, + {file = "testpath-0.5.0.tar.gz", hash = "sha256:1acf7a0bcd3004ae8357409fc33751e16d37ccc650921da1094a86581ad1e417"}, ] threadpoolctl = [ {file = "threadpoolctl-2.1.0-py3-none-any.whl", hash = "sha256:38b74ca20ff3bb42caca8b00055111d74159ee95c4370882bbff2b93d24da725"}, {file = "threadpoolctl-2.1.0.tar.gz", hash = "sha256:ddc57c96a38beb63db45d6c159b5ab07b6bced12c45a1f07b2b92f272aebfa6b"}, ] tornado = [ - {file = "tornado-6.0.4-cp35-cp35m-win32.whl", hash = "sha256:5217e601700f24e966ddab689f90b7ea4bd91ff3357c3600fa1045e26d68e55d"}, - {file = "tornado-6.0.4-cp35-cp35m-win_amd64.whl", hash = "sha256:c98232a3ac391f5faea6821b53db8db461157baa788f5d6222a193e9456e1740"}, - {file = "tornado-6.0.4-cp36-cp36m-win32.whl", hash = "sha256:5f6a07e62e799be5d2330e68d808c8ac41d4a259b9cea61da4101b83cb5dc673"}, - {file = "tornado-6.0.4-cp36-cp36m-win_amd64.whl", hash = "sha256:c952975c8ba74f546ae6de2e226ab3cc3cc11ae47baf607459a6728585bb542a"}, - {file = "tornado-6.0.4-cp37-cp37m-win32.whl", hash = "sha256:2c027eb2a393d964b22b5c154d1a23a5f8727db6fda837118a776b29e2b8ebc6"}, - {file = "tornado-6.0.4-cp37-cp37m-win_amd64.whl", hash = "sha256:5618f72e947533832cbc3dec54e1dffc1747a5cb17d1fd91577ed14fa0dc081b"}, - {file = "tornado-6.0.4-cp38-cp38-win32.whl", hash = "sha256:22aed82c2ea340c3771e3babc5ef220272f6fd06b5108a53b4976d0d722bcd52"}, - {file = "tornado-6.0.4-cp38-cp38-win_amd64.whl", hash = "sha256:c58d56003daf1b616336781b26d184023ea4af13ae143d9dda65e31e534940b9"}, - {file = "tornado-6.0.4.tar.gz", hash = "sha256:0fe2d45ba43b00a41cd73f8be321a44936dc1aba233dee979f17a042b83eb6dc"}, + {file = "tornado-6.1-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:d371e811d6b156d82aa5f9a4e08b58debf97c302a35714f6f45e35139c332e32"}, + {file = "tornado-6.1-cp35-cp35m-manylinux1_i686.whl", hash = "sha256:0d321a39c36e5f2c4ff12b4ed58d41390460f798422c4504e09eb5678e09998c"}, + {file = "tornado-6.1-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:9de9e5188a782be6b1ce866e8a51bc76a0fbaa0e16613823fc38e4fc2556ad05"}, + {file = "tornado-6.1-cp35-cp35m-manylinux2010_i686.whl", hash = "sha256:61b32d06ae8a036a6607805e6720ef00a3c98207038444ba7fd3d169cd998910"}, + {file = "tornado-6.1-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:3e63498f680547ed24d2c71e6497f24bca791aca2fe116dbc2bd0ac7f191691b"}, + {file = "tornado-6.1-cp35-cp35m-manylinux2014_aarch64.whl", hash = "sha256:6c77c9937962577a6a76917845d06af6ab9197702a42e1346d8ae2e76b5e3675"}, + {file = "tornado-6.1-cp35-cp35m-win32.whl", hash = "sha256:6286efab1ed6e74b7028327365cf7346b1d777d63ab30e21a0f4d5b275fc17d5"}, + {file = "tornado-6.1-cp35-cp35m-win_amd64.whl", hash = "sha256:fa2ba70284fa42c2a5ecb35e322e68823288a4251f9ba9cc77be04ae15eada68"}, + {file = "tornado-6.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:0a00ff4561e2929a2c37ce706cb8233b7907e0cdc22eab98888aca5dd3775feb"}, + {file = "tornado-6.1-cp36-cp36m-manylinux1_i686.whl", hash = "sha256:748290bf9112b581c525e6e6d3820621ff020ed95af6f17fedef416b27ed564c"}, + {file = "tornado-6.1-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:e385b637ac3acaae8022e7e47dfa7b83d3620e432e3ecb9a3f7f58f150e50921"}, + {file = "tornado-6.1-cp36-cp36m-manylinux2010_i686.whl", hash = "sha256:25ad220258349a12ae87ede08a7b04aca51237721f63b1808d39bdb4b2164558"}, + {file = "tornado-6.1-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:65d98939f1a2e74b58839f8c4dab3b6b3c1ce84972ae712be02845e65391ac7c"}, + {file = "tornado-6.1-cp36-cp36m-manylinux2014_aarch64.whl", hash = "sha256:e519d64089b0876c7b467274468709dadf11e41d65f63bba207e04217f47c085"}, + {file = "tornado-6.1-cp36-cp36m-win32.whl", hash = "sha256:b87936fd2c317b6ee08a5741ea06b9d11a6074ef4cc42e031bc6403f82a32575"}, + {file = "tornado-6.1-cp36-cp36m-win_amd64.whl", hash = "sha256:cc0ee35043162abbf717b7df924597ade8e5395e7b66d18270116f8745ceb795"}, + {file = "tornado-6.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7250a3fa399f08ec9cb3f7b1b987955d17e044f1ade821b32e5f435130250d7f"}, + {file = "tornado-6.1-cp37-cp37m-manylinux1_i686.whl", hash = "sha256:ed3ad863b1b40cd1d4bd21e7498329ccaece75db5a5bf58cd3c9f130843e7102"}, + {file = "tornado-6.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:dcef026f608f678c118779cd6591c8af6e9b4155c44e0d1bc0c87c036fb8c8c4"}, + {file = "tornado-6.1-cp37-cp37m-manylinux2010_i686.whl", hash = "sha256:70dec29e8ac485dbf57481baee40781c63e381bebea080991893cd297742b8fd"}, + {file = "tornado-6.1-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:d3f7594930c423fd9f5d1a76bee85a2c36fd8b4b16921cae7e965f22575e9c01"}, + {file = "tornado-6.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:3447475585bae2e77ecb832fc0300c3695516a47d46cefa0528181a34c5b9d3d"}, + {file = "tornado-6.1-cp37-cp37m-win32.whl", hash = "sha256:e7229e60ac41a1202444497ddde70a48d33909e484f96eb0da9baf8dc68541df"}, + {file = "tornado-6.1-cp37-cp37m-win_amd64.whl", hash = "sha256:cb5ec8eead331e3bb4ce8066cf06d2dfef1bfb1b2a73082dfe8a161301b76e37"}, + {file = "tornado-6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:20241b3cb4f425e971cb0a8e4ffc9b0a861530ae3c52f2b0434e6c1b57e9fd95"}, + {file = "tornado-6.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:c77da1263aa361938476f04c4b6c8916001b90b2c2fdd92d8d535e1af48fba5a"}, + {file = "tornado-6.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:fba85b6cd9c39be262fcd23865652920832b61583de2a2ca907dbd8e8a8c81e5"}, + {file = "tornado-6.1-cp38-cp38-manylinux2010_i686.whl", hash = "sha256:1e8225a1070cd8eec59a996c43229fe8f95689cb16e552d130b9793cb570a288"}, + {file = "tornado-6.1-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:d14d30e7f46a0476efb0deb5b61343b1526f73ebb5ed84f23dc794bdb88f9d9f"}, + {file = "tornado-6.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8f959b26f2634a091bb42241c3ed8d3cedb506e7c27b8dd5c7b9f745318ddbb6"}, + {file = "tornado-6.1-cp38-cp38-win32.whl", hash = "sha256:34ca2dac9e4d7afb0bed4677512e36a52f09caa6fded70b4e3e1c89dbd92c326"}, + {file = "tornado-6.1-cp38-cp38-win_amd64.whl", hash = "sha256:6196a5c39286cc37c024cd78834fb9345e464525d8991c21e908cc046d1cc02c"}, + {file = "tornado-6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f0ba29bafd8e7e22920567ce0d232c26d4d47c8b5cf4ed7b562b5db39fa199c5"}, + {file = "tornado-6.1-cp39-cp39-manylinux1_i686.whl", hash = "sha256:33892118b165401f291070100d6d09359ca74addda679b60390b09f8ef325ffe"}, + {file = "tornado-6.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:7da13da6f985aab7f6f28debab00c67ff9cbacd588e8477034c0652ac141feea"}, + {file = "tornado-6.1-cp39-cp39-manylinux2010_i686.whl", hash = "sha256:e0791ac58d91ac58f694d8d2957884df8e4e2f6687cdf367ef7eb7497f79eaa2"}, + {file = "tornado-6.1-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:66324e4e1beede9ac79e60f88de548da58b1f8ab4b2f1354d8375774f997e6c0"}, + {file = "tornado-6.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:a48900ecea1cbb71b8c71c620dee15b62f85f7c14189bdeee54966fbd9a0c5bd"}, + {file = "tornado-6.1-cp39-cp39-win32.whl", hash = "sha256:d3d20ea5782ba63ed13bc2b8c291a053c8d807a8fa927d941bd718468f7b950c"}, + {file = "tornado-6.1-cp39-cp39-win_amd64.whl", hash = "sha256:548430be2740e327b3fe0201abe471f314741efcb0067ec4f2d7dcfb4825f3e4"}, + {file = "tornado-6.1.tar.gz", hash = "sha256:33c6e81d7bd55b468d2e793517c909b139960b6c790a60b7991b9b6b76fb9791"}, ] traitlets = [ - {file = "traitlets-5.0.4-py3-none-any.whl", hash = "sha256:9664ec0c526e48e7b47b7d14cd6b252efa03e0129011de0a9c1d70315d4309c3"}, - {file = "traitlets-5.0.4.tar.gz", hash = "sha256:86c9351f94f95de9db8a04ad8e892da299a088a64fd283f9f6f18770ae5eae1b"}, -] -urllib3 = [ - {file = "urllib3-1.25.10-py2.py3-none-any.whl", hash = "sha256:e7983572181f5e1522d9c98453462384ee92a0be7fac5f1413a1e35c56cc0461"}, - {file = "urllib3-1.25.10.tar.gz", hash = "sha256:91056c15fa70756691db97756772bb1eb9678fa585d9184f24534b100dc60f4a"}, + {file = "traitlets-5.0.5-py3-none-any.whl", hash = "sha256:69ff3f9d5351f31a7ad80443c2674b7099df13cc41fc5fa6e2f6d3b0330b0426"}, + {file = "traitlets-5.0.5.tar.gz", hash = "sha256:178f4ce988f69189f7e523337a3e11d91c786ded9360174a3d9ca83e79bc5396"}, ] wcwidth = [ {file = "wcwidth-0.2.5-py2.py3-none-any.whl", hash = "sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784"}, @@ -1403,7 +1550,7 @@ webencodings = [ {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, ] -zipp = [ - {file = "zipp-3.1.0-py3-none-any.whl", hash = "sha256:aa36550ff0c0b7ef7fa639055d797116ee891440eac1a56f378e2d3179e0320b"}, - {file = "zipp-3.1.0.tar.gz", hash = "sha256:c599e4d75c98f6798c509911d08a22e6c021d074469042177c8c86fb92eefd96"}, +websocket-client = [ + {file = "websocket-client-1.0.1.tar.gz", hash = "sha256:3e2bf58191d4619b161389a95bdce84ce9e0b24eb8107e7e590db682c2d0ca81"}, + {file = "websocket_client-1.0.1-py2.py3-none-any.whl", hash = "sha256:abf306dc6351dcef07f4d40453037e51cc5d9da2ef60d0fc5d0fe3bcda255372"}, ] diff --git a/pyproject.toml b/pyproject.toml index 55e5a0c..e8042f3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,20 +1,36 @@ [build-system] -requires = ["poetry>=0.12"] -build-backend = "poetry.masonry.api" +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" [tool.poetry] -name = "workshop-machine-learning-for-beginners" +name = "intro-to-data-science" version = "0.1.0" -authors = ["Alexander Hess "] -description = "An introductory workshop on machine learning" +authors = [ + "Alexander Hess ", +] +description = "An intro to data science for absolute beginners" +keywords = [ + "python", + "data-science", + "machine-learning", + "matplotlib", + "numpy", + "seaborn", + "sklearn", +] license = "MIT" -[tool.poetry.dependencies] -python = "^3.7" +readme = "README.md" +homepage = "https://github.com/webartifex/intro-to-data-science" +repository = "https://github.com/webartifex/intro-to-data-science" -jupyterlab = "^2.2.8" -matplotlib = "^3.3.2" -numpy = "^1.19.2" -pandas = "^1.1.2" -scikit-learn = "^0.23.2" +[tool.poetry.dependencies] +python = "^3.8" +jupyterlab = "^3.0.16" +matplotlib = "^3.4.2" +numpy = "^1.20.3" +pandas = "^1.2.4" +scikit-learn = "^0.24.2" + +[tool.poetry.dev-dependencies] diff --git a/raw/python_general.png b/raw/python_general.png deleted file mode 100644 index 6c9d929..0000000 Binary files a/raw/python_general.png and /dev/null differ diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 90a97c6..0000000 --- a/requirements.txt +++ /dev/null @@ -1,56 +0,0 @@ -attrs==19.3.0 -backcall==0.1.0 -bleach==3.1.0 -cycler==0.10.0 -decorator==4.4.1 -defusedxml==0.6.0 -entrypoints==0.3 -importlib-metadata==1.2.0 -ipykernel==5.1.3 -ipython==7.10.1 -ipython-genutils==0.2.0 -ipywidgets==7.5.1 -jedi==0.15.1 -Jinja2==2.10.3 -joblib==0.14.0 -jsonschema==3.2.0 -jupyter==1.0.0 -jupyter-client==5.3.4 -jupyter-console==6.0.0 -jupyter-core==4.6.1 -kiwisolver==1.1.0 -MarkupSafe==1.1.1 -matplotlib==3.1.2 -mistune==0.8.4 -more-itertools==8.0.0 -nbconvert==5.6.1 -nbformat==4.4.0 -notebook==6.0.2 -numpy==1.17.4 -pandas==0.25.3 -pandocfilters==1.4.2 -parso==0.5.1 -pexpect==4.7.0 -pickleshare==0.7.5 -prometheus-client==0.7.1 -prompt-toolkit==2.0.10 -ptyprocess==0.6.0 -Pygments==2.5.2 -pyparsing==2.4.5 -pyrsistent==0.15.6 -python-dateutil==2.8.1 -pytz==2019.3 -pyzmq==18.1.1 -qtconsole==4.6.0 -scikit-learn==0.22 -scipy==1.3.3 -Send2Trash==1.5.0 -six==1.13.0 -terminado==0.8.3 -testpath==0.4.4 -tornado==6.0.3 -traitlets==4.3.3 -wcwidth==0.1.7 -webencodings==0.5.1 -widgetsnbextension==3.5.1 -zipp==0.6.0 diff --git a/raw/3_types_of_machine_learning.png b/static/3_types_of_machine_learning.png similarity index 100% rename from raw/3_types_of_machine_learning.png rename to static/3_types_of_machine_learning.png diff --git a/raw/classification_vs_regression.png b/static/classification_vs_regression.png similarity index 100% rename from raw/classification_vs_regression.png rename to static/classification_vs_regression.png diff --git a/raw/examples.png b/static/examples.png similarity index 100% rename from raw/examples.png rename to static/examples.png diff --git a/raw/generalization.png b/static/generalization.png similarity index 100% rename from raw/generalization.png rename to static/generalization.png diff --git a/raw/iris.png b/static/iris.png similarity index 100% rename from raw/iris.png rename to static/iris.png diff --git a/raw/iris_data.png b/static/iris_data.png similarity index 100% rename from raw/iris_data.png rename to static/iris_data.png diff --git a/raw/knn.png b/static/knn.png similarity index 100% rename from raw/knn.png rename to static/knn.png diff --git a/static/link/README.md b/static/link/README.md new file mode 100644 index 0000000..f5c9136 --- /dev/null +++ b/static/link/README.md @@ -0,0 +1,2 @@ +This folder contains small images +that are used to enhance the links in the notebooks and markdown files. diff --git a/static/link/to_gh.png b/static/link/to_gh.png new file mode 100644 index 0000000..01f1a8a Binary files /dev/null and b/static/link/to_gh.png differ diff --git a/static/link/to_py.png b/static/link/to_py.png new file mode 100644 index 0000000..53c6045 Binary files /dev/null and b/static/link/to_py.png differ diff --git a/static/link/to_wiki.png b/static/link/to_wiki.png new file mode 100644 index 0000000..39ccb8c Binary files /dev/null and b/static/link/to_wiki.png differ diff --git a/raw/python_ml.png b/static/python_ml_book.png similarity index 100% rename from raw/python_ml.png rename to static/python_ml_book.png diff --git a/raw/r.png b/static/r_ml_book.png similarity index 100% rename from raw/r.png rename to static/r_ml_book.png diff --git a/raw/spam.png b/static/spam.png similarity index 100% rename from raw/spam.png rename to static/spam.png diff --git a/raw/what_is_machine_learning.png b/static/what_is_machine_learning.png similarity index 100% rename from raw/what_is_machine_learning.png rename to static/what_is_machine_learning.png