diff --git a/Untitled.ipynb b/Untitled.ipynb
deleted file mode 100644
index c865a362b..000000000
--- a/Untitled.ipynb
+++ /dev/null
@@ -1,244 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "27a9f924-6e0b-4ca5-8bba-a2af2dfbddd8",
-   "metadata": {
-    "editable": true,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "1c942d13-fafc-4c2b-b31f-7b0df5cddfb8",
-   "metadata": {
-    "editable": true,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "hello there\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"hello there\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "abf91581-f1ad-4368-bc1a-6e3f8ca0898e",
-   "metadata": {},
-   "source": [
-    "---CELL BEGIN---\n",
-    "\n",
-    "You can do anything at https://html5zombo.com\n",
-    "\n",
-    "---CELL END---"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "59e3e440-45c1-435d-a612-1e149bd86910",
-   "metadata": {
-    "editable": true,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "hello there\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "print(\"hello there\")\n",
-    "\n",
-    "x = [1, 2, 3, 4, 5]\n",
-    "y = [1, 4, 9, 16, 25]\n",
-    "plt.figure(figsize=(8, 6))\n",
-    "plt.plot(x, y)\n",
-    "plt.gcf().patch.set_alpha(1.0) # change these values to < 1.0 for transparency in different parts of the graph\n",
-    "plt.gca().patch.set_alpha(1.0) # change these values to < 1.0 for transparency in different parts of the graph\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "acd43991-a8d7-4983-b51f-b873b30e968b",
-   "metadata": {
-    "editable": true,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "source": [
-    "img with missing alt tag in markdown\n",
-    "\n",
-    "![](https://i5.walmartimages.com/seo/Tzicr-Modern-Velvet-Home-Office-Chair-Upholstered-Chairs-with-360-Swivel-Armchair-and-Gold-Base-for-Living-Room-Bedroom-Vanity-Study-Beige_6536f77a-49dd-44b0-82e0-3baf61fdae01.7e36947377a7a46b6313b3bd412c092e.jpeg)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c7472a21-64c2-4497-8da9-6346b639da9d",
-   "metadata": {},
-   "source": [
-    "local image in markdown with alt tag   \n",
-    "\n",
-    "![sds](testLocalImage.png)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5a6c5a8d-df6f-4e16-b719-f2c33bd421ff",
-   "metadata": {},
-   "source": [
-    "local transparent image in markdown without alt tag\n",
-    "\n",
-    "![h](testLocalImageTransp.png)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e8a1561d-6a34-4407-8dcd-f88d65bc5649",
-   "metadata": {},
-   "source": [
-    "transparent with alt tag html\n",
-    "\n",
-    "<img alt=\"d\" src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/640px-PNG_transparency_demonstration_1.png\"></img>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "75f7b70b-1a03-4d5a-9a88-14dd4872bb4b",
-   "metadata": {},
-   "source": [
-    "imgs without alt tag html\n",
-    "\n",
-    "![h](testLocalImage.png)\n",
-    "\n",
-    "<img alt=\"\" src=\"https://i5.walmartimages.com/seo/Tzicr-Modern-Velvet-Home-Office-Chair-Upholstered-Chairs-with-360-Swivel-Armchair-and-Gold-Base-for-Living-Room-Bedroom-Vanity-Study-Beige_6536f77a-49dd-44b0-82e0-3baf61fdae01.7e36947377a7a46b6313b3bd412c092e.jpeg\"></img>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "89031092-2561-44b9-9b01-4d69445b2802",
-   "metadata": {},
-   "source": [
-    "### heading 3"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a4923e7d-c548-43e8-9af6-75d1bda27314",
-   "metadata": {},
-   "source": [
-    "#### heading 4"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1282f139-5580-435e-83fa-e0ec1cea1efd",
-   "metadata": {},
-   "source": [
-    "## heading 2\n",
-    "\n",
-    "paragraph\n",
-    "paragraph\n",
-    "paragraph"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "80b58b7d-747e-4275-b5f3-92ddf6ea7e1c",
-   "metadata": {},
-   "source": [
-    "#### heading 4\n",
-    "\n",
-    "another paragraph"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "665980c8-5c82-40b6-8bb0-53308980ff89",
-   "metadata": {},
-   "source": [
-    "### heading 3"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3360305c-ad8e-491c-93b4-8d4abf2afe10",
-   "metadata": {},
-   "source": [
-    "### heading 3"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a9838dde-9edf-4f19-852f-c0926018922f",
-   "metadata": {},
-   "source": [
-    "### heading 3"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Untitled1.ipynb b/Untitled1.ipynb
deleted file mode 100644
index 8c81ae6f0..000000000
--- a/Untitled1.ipynb
+++ /dev/null
@@ -1,33 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "ceaff4ea-b71d-4046-93ec-c4fa3ae49b79",
-   "metadata": {},
-   "source": [
-    "![](testLocalImageTransp.png)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/lab11.ipynb b/lab11.ipynb
deleted file mode 100644
index 2eca02087..000000000
--- a/lab11.ipynb
+++ /dev/null
@@ -1,1255 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 49,
-   "id": "1ea205e9",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "# Initialize Otter\n",
-    "import otter\n",
-    "grader = otter.Notebook(\"lab11.ipynb\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a3b58c9b",
-   "metadata": {},
-   "source": [
-    "# Lab 11: Climate Part 2\n",
-    "\n",
-    "Welcome to Lab 11!\n",
-    "\n",
-    "This Lab will see you complete your analysis from the previous lab by assessing the impact of drought. \n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "da6f4717",
-   "metadata": {},
-   "source": [
-    "**Getting help on lab**: Whenever you feel stuck or need some further clarification, find a GSI or tutor, and they'll be happy to help!\n",
-    "\n",
-    "Here are the policies for getting full credit:\n",
-    "\n",
-    "1. For students enrolled in in-person <span style=\"color: #BC412B\">**Regular Labs**</span>, you will receive lab credit by **attending** lab section and making significant progress on the lab notebook. You **<span style=\"text-decoration: underline\">do not</span>** need to submit this assignment to Gradescope.\n",
-    "\n",
-    "2. For students enrolled in <span style=\"color: #04888B\">**Self-Service Lab**</span>, you will receive lab credit by **completing** the notebook, passing the test cases, and **submitting** it to Gradescope by **11:59pm on the due date**.\n",
-    "\n",
-    "**Submission**: Once you’re finished, run all cells besides the last one, select File > Save Notebook, and then execute the final cell. The result will contain a zip file that you can use to submit on Gradescope.\n",
-    "\n",
-    "Let's begin by setting up the tests and imports by running the cell below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 50,
-   "id": "a7880d74",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Run this cell to set up the notebook, but please don't change it.\n",
-    "from datascience import *\n",
-    "import numpy as np\n",
-    "\n",
-    "%matplotlib inline\n",
-    "import matplotlib.pyplot as plt\n",
-    "plt.style.use('fivethirtyeight')\n",
-    "np.set_printoptions(legacy='1.13')\n",
-    "\n",
-    "import warnings\n",
-    "warnings.simplefilter('ignore')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5fc91aeb",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# Part 2: Drought"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "634457a3",
-   "metadata": {},
-   "source": [
-    "According to the [United States Environmental Protection Agency](https://www.epa.gov/climate-indicators/southwest), \"Large portions of the Southwest have experienced drought conditions since weekly Drought Monitor records began in 2000. For extended periods from 2002 to 2005 and from 2012 to 2020, nearly the entire region was abnormally dry or even drier.\" \n",
-    "\n",
-    "Assessing the impact of drought is challenging with just city-level data because so much of the water that people use is transported from elsewhere, but we'll explore the data we have and see what we can learn.\n",
-    "\n",
-    "Let's first take a look at the precipitation data in the Southwest region. The `southwest.csv` file contains total annual precipitation for 13 cities in the southwestern United States for each year from 1960 to 2021. This dataset is aggregated from the daily data and includes only the Southwest cities from the original dataset that have consistent precipitation records back to 1960."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 51,
-   "id": "d51fa782",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "    <thead>\n",
-       "        <tr>\n",
-       "            <th>City</th> <th>Year</th> <th>Total Precipitation</th>\n",
-       "        </tr>\n",
-       "    </thead>\n",
-       "    <tbody>\n",
-       "        <tr>\n",
-       "            <td>Albuquerque</td> <td>1960</td> <td>8.12               </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>Albuquerque</td> <td>1961</td> <td>8.87               </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>Albuquerque</td> <td>1962</td> <td>5.39               </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>Albuquerque</td> <td>1963</td> <td>7.47               </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>Albuquerque</td> <td>1964</td> <td>7.44               </td>\n",
-       "        </tr>\n",
-       "    </tbody>\n",
-       "</table>\n",
-       "<p>... (788 rows omitted)</p>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "southwest = Table.read_table('southwest.csv')\n",
-    "southwest.show(5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dbed1948",
-   "metadata": {},
-   "source": [
-    "**Question 2.1.** Create a table `totals` that has one row for each year in chronological order. It should contain the following columns:\n",
-    "1. `\"Year\"`: The year (a number)\n",
-    "2. `\"Precipitation\"`: The total precipitation in all 13 southwestern cities that year\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 52,
-   "id": "7c4a3315",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "    <thead>\n",
-       "        <tr>\n",
-       "            <th>Year</th> <th>Precipitation</th>\n",
-       "        </tr>\n",
-       "    </thead>\n",
-       "    <tbody>\n",
-       "        <tr>\n",
-       "            <td>1960</td> <td>149.58       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1961</td> <td>134.82       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1962</td> <td>130.41       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1963</td> <td>132.18       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1964</td> <td>123.41       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1965</td> <td>187.53       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1966</td> <td>120.27       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1967</td> <td>179.02       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1968</td> <td>136.25       </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1969</td> <td>191.72       </td>\n",
-       "        </tr>\n",
-       "    </tbody>\n",
-       "</table>\n",
-       "<p>... (51 rows omitted)</p>"
-      ],
-      "text/plain": [
-       "Year | Precipitation\n",
-       "1960 | 149.58\n",
-       "1961 | 134.82\n",
-       "1962 | 130.41\n",
-       "1963 | 132.18\n",
-       "1964 | 123.41\n",
-       "1965 | 187.53\n",
-       "1966 | 120.27\n",
-       "1967 | 179.02\n",
-       "1968 | 136.25\n",
-       "1969 | 191.72\n",
-       "... (51 rows omitted)"
-      ]
-     },
-     "execution_count": 52,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "totals = southwest.select(\"Year\", \"Total Precipitation\").group(\"Year\", sum).relabeled(\"Total Precipitation sum\", \"Precipitation\")\n",
-    "totals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "id": "2906dae7",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_1</pre></strong> passed! 🌈</p>"
-      ],
-      "text/plain": [
-       "q2_1 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 53,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_1\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0acc6eea",
-   "metadata": {},
-   "source": [
-    "Run the cell below to plot the total precipitation in these cities over time, so that we can try to spot the drought visually. As a reminder, the drought years given by the EPA were  (2002-2005) and (2012-2020)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "0f6791ec",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Just run this cell\n",
-    "totals.plot(\"Year\", \"Precipitation\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "acf26fe5",
-   "metadata": {},
-   "source": [
-    "This plot isn't very revealing. Each year has a different amount of precipitation, and there is quite a bit of variability across years, as if each year's precipitation is a random draw from a distribution of possible outcomes. \n",
-    "\n",
-    "Could it be that these so-called \"drought conditions\" from 2002-2005 and 2012-2020 can be explained by chance? In other words, could it be that the annual precipitation amounts in the Southwest for these drought years are like **random draws from the same underlying distribution** as for other years? Perhaps nothing about the Earth's precipitation patterns has really changed, and the Southwest U.S. just happened to experience a few dry years close together. \n",
-    "\n",
-    "To assess this idea, let's conduct an A/B test in which **each year's total precipitation** is an outcome, and the condition is **whether or not the year is in the EPA's drought period**."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8e18aba6",
-   "metadata": {},
-   "source": [
-    "This `drought_label` function distinguishes between drought years as described in the U.S. EPA statement above (2002-2005 and 2012-2020) and other years. Note that the label \"other\" is perhaps misleading, since there were other droughts before 2000, such as the massive [1988 drought](https://en.wikipedia.org/wiki/1988%E2%80%9390_North_American_drought) that affected much of the U.S. However, if we're interested in whether these modern drought periods (2002-2005 and 2012-2020) are *normal* or *abnormal*, it makes sense to distinguish the years in this way. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "b8c13e9e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def drought_label(n):\n",
-    "    \"\"\"Return the label for an input year n.\"\"\"\n",
-    "    if 2002 <= n <= 2005 or 2012 <= n <= 2020:\n",
-    "        return 'drought'\n",
-    "    else:\n",
-    "        return 'other'"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7ddb1cdf",
-   "metadata": {},
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "**Question 2.2.** Define null and alternative hypotheses for an A/B test that investigates whether drought years are **drier** (have less precipitation) than other years.\n",
-    "\n",
-    "*Note:* Please format your answer using the following structure.\n",
-    "\n",
-    "- *Null hypothesis:* ...\n",
-    "- *Alternative hypothesis:* ...\n",
-    "\n",
-    "\n",
-    "![](\"hello.png\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "02be5cdd",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9a76f37d",
-   "metadata": {},
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "**Question 2.3.** First, define the table `drought`. It should contain one row per year and the following two columns:\n",
-    "- `\"Label\"`: Denotes if a year is part of a `\"drought\"` year or an `\"other\"` year\n",
-    "- `\"Precipitation\"`: The sum of the total precipitation in 13 Southwest cities that year\n",
-    "\n",
-    "Then, construct an overlaid histogram of two observed distributions: the total precipitation in drought years and the total precipitation in other years. \n",
-    "\n",
-    "*Note*: Use the provided `bins` when creating your histogram, and do not re-assign the `southwest` table. Feel free to use as many lines as you need!\n",
-    "\n",
-    "*Hint*: The optional `group` argument in a certain function might be helpful!\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "id": "01298c8b",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "bins = np.arange(85, 215+1, 13)\n",
-    "drought = totals.with_column(\"Label\", totals.apply(drought_label, \"Year\"))\n",
-    "drought\n",
-    "drought.hist(\"Precipitation\", bins = bins, group = \"Label\")\n",
-    "# ..."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "22ecd05e",
-   "metadata": {},
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "Before you continue, inspect the histogram you just created and try to guess the conclusion of the A/B test. Building intuition about the result of hypothesis testing from visualizations is quite useful for data science applications. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d1f76e26",
-   "metadata": {},
-   "source": [
-    "**Question 2.4.** Our next step is to choose a test statistic based on our alternative hypothesis in Question 2.2. Which of the following options are valid choices for the test statistic? Assign `ab_test_stat` to **an array of integers** corresponding to valid choices. Assume averages and totals are taken over the total precipitation sums for each year.\n",
-    "\n",
-    "1. The difference between the **total** precipitation in **drought** years and the **total** precipitation in **other** years.\n",
-    "2. The difference between the **total** precipitation in **others** years and the **total** precipitation in **drought** years.\n",
-    "3. The **absolute** difference between the **total** precipitation in others years and the **total** precipitation in drought years.\n",
-    "1. The difference between the **average** precipitation in **drought** years and the **average** precipitation in **other** years.\n",
-    "2. The difference between the **average** precipitation in **others** years and the **average** precipitation in **drought** years.\n",
-    "3. The **absolute** difference between the **average** precipitation in others years and the **average** precipitation in drought years.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 57,
-   "id": "a46dcde3",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "ab_test_stat = make_array(1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 58,
-   "id": "1734a0aa",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_4</pre></strong> passed! 💯</p>"
-      ],
-      "text/plain": [
-       "q2_4 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 58,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_4\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "11a5a872",
-   "metadata": {},
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "**Question 2.5.** Fellow climate scientists Will and Nicole point out that there are more **other** years than **drought** years, and so measuring the difference between total precipitation will always favor the **other** years. They conclude that all of the options above involving **total** precipitation are invalid test statistic choices. Do you agree with them? Why or why not?\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "843314b0",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "846822aa",
-   "metadata": {},
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "Before going on, check your `drought` table. It should have two columns `Label` and `Precipitation` with 61 rows, 13 of which are for `\"drought\"` years."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "id": "c149a181",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "    <thead>\n",
-       "        <tr>\n",
-       "            <th>Year</th> <th>Precipitation</th> <th>Label</th>\n",
-       "        </tr>\n",
-       "    </thead>\n",
-       "    <tbody>\n",
-       "        <tr>\n",
-       "            <td>1960</td> <td>149.58       </td> <td>other</td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1961</td> <td>134.82       </td> <td>other</td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>1962</td> <td>130.41       </td> <td>other</td>\n",
-       "        </tr>\n",
-       "    </tbody>\n",
-       "</table>\n",
-       "<p>... (58 rows omitted)</p>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "drought.show(3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 60,
-   "id": "eda39f8b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "    <thead>\n",
-       "        <tr>\n",
-       "            <th>Label</th> <th>count</th>\n",
-       "        </tr>\n",
-       "    </thead>\n",
-       "    <tbody>\n",
-       "        <tr>\n",
-       "            <td>drought</td> <td>13   </td>\n",
-       "        </tr>\n",
-       "        <tr>\n",
-       "            <td>other  </td> <td>48   </td>\n",
-       "        </tr>\n",
-       "    </tbody>\n",
-       "</table>"
-      ],
-      "text/plain": [
-       "Label   | count\n",
-       "drought | 13\n",
-       "other   | 48"
-      ]
-     },
-     "execution_count": 60,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "drought.group('Label')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e7e7556d",
-   "metadata": {},
-   "source": [
-    "**Question 2.6.** For our A/B test, we'll use the difference between the average precipitation in drought years and the average precipitation in other years as our test statistic:\n",
-    "\n",
-    "$$\\text{average precipitation in \"drought\" years} - \\text{average precipitation in \"other\" years}$$\n",
-    "\n",
-    "First, complete the function `test_statistic`. It should take in a two-column table `t` with one row per year and two columns:\n",
-    "- `Label`: the label for that year (either `'drought'` or `'other'`)\n",
-    "- `Precipitation`: the total precipitation in the 13 Southwest cities that year. \n",
-    "\n",
-    "Then, use the function you define to assign `observed_statistic` to the observed test statistic.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 61,
-   "id": "7d76952a",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-15.856714743589748"
-      ]
-     },
-     "execution_count": 61,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def test_statistic(t):\n",
-    "    obs = np.average(t.where('Label', are.equal_to('drought')).column('Precipitation')) - np.average(t.where('Label', are.equal_to('other')).column('Precipitation'))\n",
-    "    return obs\n",
-    "\n",
-    "observed_statistic = test_statistic(drought)\n",
-    "observed_statistic"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 62,
-   "id": "05707622",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_6</pre></strong> passed! 🚀</p>"
-      ],
-      "text/plain": [
-       "q2_6 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 62,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_6\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e142edbd",
-   "metadata": {},
-   "source": [
-    "Now that we have defined our hypotheses and test statistic, we are ready to conduct our hypothesis test. We’ll start by defining a function to simulate the test statistic under the null hypothesis, and then call that function 5,000 times to construct an empirical distribution under the null hypothesis."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "40bb3df2",
-   "metadata": {},
-   "source": [
-    "**Question 2.7.** Write a function to simulate the test statistic under the null hypothesis. The `simulate_precipitation_null` function should simulate the null hypothesis once (not 5,000 times) and return the value of the test statistic for that simulated sample.\n",
-    "\n",
-    "*Hint*: Using `t.with_column(...)` with a column name that already exists in a table `t` will replace that column with the newly specified values.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 63,
-   "id": "d5ead0ae",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "9.4788141025641153"
-      ]
-     },
-     "execution_count": 63,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "def simulate_precipitation_null():\n",
-    "    sampled = drought.sample(with_replacement = False).column(\"Label\")\n",
-    "    sampledTable = drought.drop(\"Label\").with_column(\"Label\", sampled)\n",
-    "    stat = test_statistic(sampledTable)\n",
-    "    return stat\n",
-    "\n",
-    "\n",
-    "# Run your function a couple times to make sure that it works\n",
-    "simulate_precipitation_null()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 64,
-   "id": "0d0c3970",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_7</pre></strong> passed! ✨</p>"
-      ],
-      "text/plain": [
-       "q2_7 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 64,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_7\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e975b101",
-   "metadata": {},
-   "source": [
-    "**Question 2.8.** Fill in the blanks below to complete the simulation for the hypothesis test. Your simulation should compute 5,000 values of the test statistic under the null hypothesis and store the result in the array `sampled_stats`.\n",
-    "\n",
-    "*Hint:* You should use the `simulate_precipitation_null` function you wrote in the previous question!\n",
-    "\n",
-    "*Note:* Running this cell may take a few seconds. If it takes more than a minute, try to find a different (faster) way to implement your `simulate_precipitation_null` function.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 65,
-   "id": "ab66f8ab",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x400 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "sampled_stats = make_array()\n",
-    "\n",
-    "repetitions = 5000\n",
-    "for i in np.arange(repetitions):\n",
-    "    sampled_stats = np.append(sampled_stats, simulate_precipitation_null())\n",
-    "\n",
-    "# Do not change these lines\n",
-    "Table().with_column('Difference Between Means', sampled_stats).hist()\n",
-    "plt.scatter(observed_statistic, 0, c=\"r\", s=50);\n",
-    "plt.ylim(-0.01);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 66,
-   "id": "241e0bd5",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_8</pre></strong> passed! ✨</p>"
-      ],
-      "text/plain": [
-       "q2_8 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 66,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_8\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5a70d827",
-   "metadata": {},
-   "source": [
-    "**Question 2.9.** Compute the p-value for this hypothesis test, and assign it to the variable `precipitation_p_val`.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "76ddf1da",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.5"
-      ]
-     },
-     "execution_count": 67,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "precipitation_p_val = 0.5\n",
-    "precipitation_p_val"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "4bf94c97",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<p><strong><pre style='display: inline;'>q2_9</pre></strong> passed! 🙌</p>"
-      ],
-      "text/plain": [
-       "q2_9 results: All test cases passed!"
-      ]
-     },
-     "execution_count": 68,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "grader.check(\"q2_9\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "95088247",
-   "metadata": {},
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "**Question 2.10.** State a conclusion from this test using a p-value cutoff of 5%. What have you learned about the EPA's statement on drought?\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7df7efbd",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2eca4c61",
-   "metadata": {},
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "**Question 2.11.** Does your conclusion from Question 2.10 apply to the entire Southwest region of the U.S.? Why or why not?\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8aaeb116",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "39039658",
-   "metadata": {},
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "## Conclusion"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "73cd05b0",
-   "metadata": {},
-   "source": [
-    "Data science plays a central role in climate change research because massive simulations of the Earth's climate are necessary to assess the implications of climate data recorded from weather stations, satellites, and other sensors. [Berkeley Earth](http://berkeleyearth.org/data/) is a common source of data for these kinds of projects.\n",
-    "\n",
-    "In this project, we found ways to apply our statistical inference technqiues that rely on random sampling even in situations where the data were not generated randomly, but instead by some complicated natural process that appeared random. We made assumptions about randomness and then came to conclusions based on those assumptions. Great care must be taken to choose assumptions that are realistic, so that the resulting conclusions are not misleading. However, making assumptions about data can be productive when doing so allows inference techniques to apply to novel situations."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f9218555",
-   "metadata": {},
-   "source": [
-    "<img src=\"Lily.png\" alt=\"Picture of a dog on a couch\" width=\"350\"/>\n",
-    "\n",
-    "**Congratulations -- Lily says you're done with the lab!**\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "936bb88e",
-   "metadata": {},
-   "source": [
-    "\n",
-    "---\n",
-    "\n",
-    "You're done with lab!\n",
-    "\n",
-    "**Important submission information:** (Self Service Lab Only)\n",
-    "- **Run all the tests** and verify that they all pass\n",
-    "- **Save** from the **File** menu\n",
-    "- **Run the final cell to generate the zip file**\n",
-    "- **Click the link to download the zip file**\n",
-    "- Then, go to [Gradescope](https://www.gradescope.com/courses/546043) and submit the zip file to the corresponding assignment. The name of this assignment is \"Lab XX Autograder\", where XX is the lab number -- 01, 02, 03, etc.\n",
-    "\n",
-    "- If you finish early in Regular Lab, **ask one of the staff members to check you off**.\n",
-    "\n",
-    "**It is your responsibility to make sure your work is saved before running the last cell.**\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "77da1b60",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "## Submission\n",
-    "\n",
-    "Make sure you have run all cells in your notebook in order before running the cell below, so that all images/graphs appear in the output. The cell below will generate a zip file for you to submit. **Please save before exporting!**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "id": "ed4603ff",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running your submission against local test cases...\n",
-      "\n",
-      "\n",
-      "\n",
-      "Your submission received the following results when run against available test cases:\n",
-      "\n",
-      "    q2_1 results: All test cases passed!\n",
-      "\n",
-      "    q2_4 results: All test cases passed!\n",
-      "\n",
-      "    q2_6 results: All test cases passed!\n",
-      "\n",
-      "    q2_7 results: All test cases passed!\n",
-      "\n",
-      "    q2_8 results:\n",
-      "        q2_8 - 1 result:\n",
-      "            ❌ Test case failed\n",
-      "            Trying:\n",
-      "                len(sampled_stats) == 5000\n",
-      "            Expecting:\n",
-      "                True\n",
-      "            **********************************************************************\n",
-      "            Line 1, in q2_8 0\n",
-      "            Failed example:\n",
-      "                len(sampled_stats) == 5000\n",
-      "            Exception raised:\n",
-      "                Traceback (most recent call last):\n",
-      "                  File \"/opt/conda/lib/python3.9/doctest.py\", line 1334, in __run\n",
-      "                    exec(compile(example.source, filename, \"single\",\n",
-      "                  File \"<doctest q2_8 0[0]>\", line 1, in <module>\n",
-      "                    len(sampled_stats) == 5000\n",
-      "                NameError: name 'sampled_stats' is not defined\n",
-      "\n",
-      "        q2_8 - 2 result:\n",
-      "            ❌ Test case failed\n",
-      "            Trying:\n",
-      "                np.std(sampled_stats) > 0\n",
-      "            Expecting:\n",
-      "                True\n",
-      "            **********************************************************************\n",
-      "            Line 1, in q2_8 1\n",
-      "            Failed example:\n",
-      "                np.std(sampled_stats) > 0\n",
-      "            Exception raised:\n",
-      "                Traceback (most recent call last):\n",
-      "                  File \"/opt/conda/lib/python3.9/doctest.py\", line 1334, in __run\n",
-      "                    exec(compile(example.source, filename, \"single\",\n",
-      "                  File \"<doctest q2_8 1[0]>\", line 1, in <module>\n",
-      "                    np.std(sampled_stats) > 0\n",
-      "                NameError: name 'sampled_stats' is not defined\n",
-      "\n",
-      "    q2_9 results:\n",
-      "        q2_9 - 1 result:\n",
-      "            ❌ Test case failed\n",
-      "            Trying:\n",
-      "                type(precipitation_p_val) in set([float, np.float32, np.float64])\n",
-      "            Expecting:\n",
-      "                True\n",
-      "            **********************************************************************\n",
-      "            Line 1, in q2_9 0\n",
-      "            Failed example:\n",
-      "                type(precipitation_p_val) in set([float, np.float32, np.float64])\n",
-      "            Expected:\n",
-      "                True\n",
-      "            Got:\n",
-      "                False\n",
-      "\n",
-      "        q2_9 - 2 result:\n",
-      "            ❌ Test case failed\n",
-      "            Trying:\n",
-      "                0 <= precipitation_p_val <= 1\n",
-      "            Expecting:\n",
-      "                True\n",
-      "            **********************************************************************\n",
-      "            Line 1, in q2_9 1\n",
-      "            Failed example:\n",
-      "                0 <= precipitation_p_val <= 1\n",
-      "            Exception raised:\n",
-      "                Traceback (most recent call last):\n",
-      "                  File \"/opt/conda/lib/python3.9/doctest.py\", line 1334, in __run\n",
-      "                    exec(compile(example.source, filename, \"single\",\n",
-      "                  File \"<doctest q2_9 1[0]>\", line 1, in <module>\n",
-      "                    0 <= precipitation_p_val <= 1\n",
-      "                TypeError: '<=' not supported between instances of 'int' and 'ellipsis'\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "            <p>Your submission has been exported. Click <a href=\"lab11_2023_07_31T15_05_45_914945.zip\" download=\"lab11_2023_07_31T15_05_45_914945.zip\" target=\"_blank\">here</a>\n",
-       "            to download the zip file.</p>\n",
-       "            "
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Save your notebook first, then run this cell to export your submission.\n",
-    "grader.export(pdf=False, run_tests=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "733f7bdd",
-   "metadata": {},
-   "source": [
-    " "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  },
-  "otter": {
-   "OK_FORMAT": true,
-   "tests": {
-    "q2_1": {
-     "name": "q2_1",
-     "points": [
-      0,
-      1
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> totals.num_rows == 61\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> totals.labels == ('Year', 'Precipitation')\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2_4": {
-     "name": "q2_4",
-     "points": [
-      0,
-      0,
-      2
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> type(ab_test_stat) == np.ndarray\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> all([1 <= option <= 6 for option in ab_test_stat])\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> all([type(option) in set([np.int64, np.int32, int]) for option in list(ab_test_stat)])\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2_6": {
-     "name": "q2_6",
-     "points": [
-      1
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> observed_statistic < 0\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2_7": {
-     "name": "q2_7",
-     "points": [
-      1
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> -50 < simulate_precipitation_null() < 50\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2_8": {
-     "name": "q2_8",
-     "points": [
-      0,
-      0
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> len(sampled_stats) == 5000\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> np.std(sampled_stats) > 0\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2_9": {
-     "name": "q2_9",
-     "points": [
-      0,
-      1
-     ],
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> type(precipitation_p_val) in set([float, np.float32, np.float64])\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> 0 <= precipitation_p_val <= 1\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    }
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/lowContrastGraph.ipynb b/lowContrastGraph.ipynb
deleted file mode 100644
index e4ebfee2d..000000000
--- a/lowContrastGraph.ipynb
+++ /dev/null
@@ -1,91 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "1bee8719-9e54-4261-acad-1450e76a9b0d",
-   "metadata": {},
-   "source": [
-    "![hi](graphIssues1.png)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a9dd919b-c788-4898-8f78-bc652ceee089",
-   "metadata": {},
-   "source": [
-    "![hi](graphIssues2.jpeg)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2f18ada6-1ca7-4b2b-9709-2bb79f88eeaf",
-   "metadata": {},
-   "source": [
-    "[hi](graphIssues3.png)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "03f2a4c6-8f8c-4cb3-a6ce-3f8b93adc9c0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import matplotlib.pyplot as plt\n",
-    "# import numpy as np\n",
-    "\n",
-    "# # Data\n",
-    "# x = np.linspace(0, 10, 100)\n",
-    "# y1 = np.sin(x)\n",
-    "# y2 = np.cos(x)\n",
-    "\n",
-    "# # Create plot\n",
-    "# plt.figure(figsize=(8, 6))\n",
-    "\n",
-    "# # Sine curve with poor color contrast and poor transparency\n",
-    "# plt.plot(x, y1, label='Sine', color='lightgrey', alpha=0.2)\n",
-    "\n",
-    "# # Cosine curve with poor color contrast\n",
-    "# plt.plot(x, y2, label='Cosine', color='yellow')\n",
-    "\n",
-    "# # Unstructured header (just a plain text, no structure)\n",
-    "# plt.text(2, 1, 'A Graph', fontsize=20, color='black')\n",
-    "\n",
-    "# # X-axis label\n",
-    "# plt.xlabel('X-axis')\n",
-    "\n",
-    "# # Y-axis label\n",
-    "# plt.ylabel('Y-axis')\n",
-    "\n",
-    "# # No title\n",
-    "\n",
-    "# # No legend added\n",
-    "# # plt.legend()\n",
-    "\n",
-    "# # Display the plot\n",
-    "# plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.12.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/proj4.ipynb b/proj4.ipynb
deleted file mode 100644
index 05189a696..000000000
--- a/proj4.ipynb
+++ /dev/null
@@ -1,2232 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Initialize Otter\n",
-    "import otter\n",
-    "grader = otter.Notebook(\"proj4.ipynb\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "editable": true,
-    "slideshow": {
-     "slide_type": ""
-    },
-    "tags": []
-   },
-   "source": [
-    "# Project 4: Mongo \n",
-    "\n",
-    "## Due Date: Thursday 11/30, 5:00 PM\n",
-    "\n",
-    "In this project, we will be investigating how different database systems handle semi-structured JSON data. In particular, we will be placing emphasis on the use of MongoDB: a database system that stores data in a construct known as documents. These documents are very similar to the JSON objects we've explored in lecture, with a few differences in representation and indexing that we will explore in the following questions. \n",
-    "\n",
-    "In this project, we will be working with the **Yelp Academic Dataset** which contains a dataset of `businesses`, `reviews`, and `users`. Due to the limitations of JupyterHub and the Mongo instances we are working with, `reviews` and `users` are truncated to 7500 reviews and 1000 users. We will be using the full `businesses` dataset, however.\n",
-    "\n",
-    "Throughout the course of this project, you should understand what Mongo can (and cannot) do with regards to its documents as a NoSQL datastore and compare and contrast this to other data representation formats such as the relational model."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Logistics & Scoring Breakdown\n",
-    "\n",
-    "Please read the submission instructions carefully and double check that your submission is not throwing any errors. Please ensure that public tests pass upon submission. It is your responsibility to wait until the autograder finishes running. We will not be accepting regrade requests for submission issues.\n",
-    "\n",
-    "Each coding question has **both public tests and hidden tests**. Roughly 50% of your coding grade will be made up of your score on the public tests released to you, while the remaining 50% will be made up of unreleased hidden tests. **Free-response questions (marked 'm' in the table below) are manually graded.**\n",
-    "\n",
-    "This is an **individual project**. However, you’re welcome to collaborate with any other student in the class as long as it’s within the academic honesty guidelines.\n",
-    "\n",
-    "Question | Points\n",
-    "--- | ---\n",
-    "1a\t| 1\n",
-    "1b  | 1\n",
-    "1c\t| 2\n",
-    "1d\t| 1\n",
-    "1e\t| 2\n",
-    "1f  | 1\n",
-    "2a\t| m: 2\n",
-    "2b\t| 1\n",
-    "2c  | 1\n",
-    "2d  | m: 2\n",
-    "3a\t| m: 1\n",
-    "3b\t| 1\n",
-    "3c\t| 1\n",
-    "3d  | 1\n",
-    "3e  | 1\n",
-    "3f  | 3\n",
-    "4a\t| 1\n",
-    "4b\t| 2\n",
-    "4c\t| 2\n",
-    "4d  | 1\n",
-    "**Total** | 28\n",
-    "\n",
-    "**Grand Total:** 28 points (autograded: 23, manual: 5) "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Loading Up Mongo\n",
-    "We will be using Pymongo, a Python wrapper for MongoDB, for this project. Every student should have access to their own MongoDB instance, running on the localhost of your Datahub server. After running the following cell, for the rest of the project, you can use the Python variables business, review, and user to access the corresponding collection.\n",
-    "\n",
-    "To prevent bracket mismatches while creating your queries, it is recommended to turn on \"Auto Close Brackets\" via Settings in JupyterHub.\n",
-    "Furthermore, since we are using Python dictionaries as our query filter, make sure to wrap all keys and values inside quotes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "import pickle\n",
-    "import pandas as pd\n",
-    "import pymongo\n",
-    "from pymongo import TEXT\n",
-    "import numpy as np\n",
-    "\n",
-    "myclient = pymongo.MongoClient(\"mongodb://localhost\")\n",
-    "mydb = myclient[\"yelp\"]\n",
-    "business = mydb[\"business\"]\n",
-    "review = mydb[\"review\"]\n",
-    "user = mydb[\"user\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Troubleshooting\n",
-    "\n",
-    "**PLEASE READ:** Please avoid printing too much debugging query output—it may crash your Jupyter Hub if your file size becomes too large! It's recommended to use the `limit()` method and delete any debugging query cells if no longer needed as you go through the project.\n",
-    "\n",
-    "You might run into issues on the project where you are certain your code works but the output is incorrect. This may be because your collections have been corrupted. Run the following cell and uncomment the specific collections you would like to drop if you would like to remake your collections from scratch. **Be sure to re-run the Load Datasets cells below if you drop your collections so you aren't working with empty collections!**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# UNCOMMENT AND RUN THIS CELL IF YOU WOULD LIKE TO REMAKE YOUR COLLECTIONS FROM SCRATCH. \n",
-    "# IF YOU DROP ANY COLLECTIONS, RE-RUN THE NEXT TWO CELLS TO LOAD IN THE DATA.\n",
-    "\n",
-    "# review.drop()\n",
-    "# business.drop()\n",
-    "# user.drop()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load Datasets\n",
-    "The following 2 cells will load the JSON datasets into the appropriate Mongo collections. You will only need to run them once unless you drop the collections above. The second cell **may take a couple of minutes to run** if you are running it for the first time or are running it after you dropped the collections."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import zipfile\n",
-    "import os.path\n",
-    "\n",
-    "if not os.path.isfile('data/yelp_academic_dataset_review.json'):\n",
-    "    with zipfile.ZipFile('data/yelp_academic_dataset_review.json.zip', 'r') as zip_ref:\n",
-    "        zip_ref.extractall('data')\n",
-    "\n",
-    "if not os.path.isfile('data/yelp_academic_dataset_user.json'):\n",
-    "    with zipfile.ZipFile('data/yelp_academic_dataset_user.json.zip', 'r') as zip_ref:\n",
-    "        zip_ref.extractall('data')\n",
-    "\n",
-    "if not os.path.isfile('data/yelp_academic_dataset_business.json'):\n",
-    "    with zipfile.ZipFile('data/yelp_academic_dataset_business.json.zip', 'r') as zip_ref:\n",
-    "        zip_ref.extractall('data')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "# THIS CELL MAY TAKE AT MOST 5 MINUTES. BUT HOPEFULLY YOU WILL ONLY NEED TO RUN IT ONCE.\n",
-    "import json\n",
-    "\n",
-    "if business.count_documents({}) == 0:\n",
-    "    print(\"Loading business collection...\")\n",
-    "    with open('data/yelp_academic_dataset_business.json', encoding='utf-8') as f:\n",
-    "        for line in f:\n",
-    "            business.insert_one(json.loads(line))\n",
-    "\n",
-    "if review.count_documents({}) == 0:\n",
-    "    print(\"Loading review collection...\")\n",
-    "    with open('data/yelp_academic_dataset_review.json', encoding='utf-8') as f:\n",
-    "        for line in f:\n",
-    "            review.insert_one(json.loads(line))\n",
-    "            \n",
-    "if user.count_documents({}) == 0:\n",
-    "    print(\"Loading user collection...\")\n",
-    "    with open('data/yelp_academic_dataset_user.json', encoding='utf-8') as f:\n",
-    "        for line in f:\n",
-    "            user.insert_one(json.loads(line))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's take a quick look at our collections. For the command below, replace `user` with `review` or `business` to count the number of documents in each collection."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "user.count_documents({})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now let's inspect our collections. Replace `business` with `review` and `user` to see the first document in each collection."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "business.find_one()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you see a document containing a business named `Oskar Blues Taproom` when you run the command above, it means that our JSON data has successfully been imported into the collection! Now we can get started with exploring Mongo in a bit more detail."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Connect to the grader"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Run the following cell for grading purposes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Just run the following cell, no further action is needed.\n",
-    "from data101_utils import GradingUtil\n",
-    "grading_util = GradingUtil(\"proj4\")\n",
-    "grading_util.prepare_autograder()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell\n",
-    "import pickle\n",
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr style=\"border: 5px solid #003262;\" />\n",
-    "<hr style=\"border: 1px solid #fdb515;\" />\n",
-    "\n",
-    "## Question 1: Basic MQL\n",
-    "\n",
-    "### Question 1a\n",
-    "\n",
-    "In lecture, we discussed how one could find specific attributes from a JSON object using dot (`.`) notation. \n",
-    "\n",
-    "- While you can still use the dot notation in queries, PyMongo represents documents returned from Mongo queries using Python dictionaries, making it convenient to manipulate JSON using a mix of Mongo queries and array indexing. Specifically, given the result of a retrieval `find` query, you can look up the third document by indexing with `[2]`. Note, since we are using Python dictionaries, we will be using 0-based indexing. Then, given this document, you can look up the field `'amount'` by appending `['amount']` etc., adding multiple square brackets as needed to \"walk down\" the JSON tree representation via `collection.find(...)[2]['amount']`. This will return the 'amount' field from the 3rd document returned from the query. This combination of query and indexing will be useful in obtaining the necessary information you need for this question.\n",
-    "  \n",
-    "- In order to get a visual output of the query results, you will need to wrap `collection.find(...)` inside `list()`, e.g. `list(collection.find(...))`. This is because `collection.find(...)` returns a **Cursor** object, which is an iterator. **An important consequence** is that if we set `result = collection.find(...)`, then calling `list(result)` for the first time will get you the expected list of documents in the query result, but calling `list(result)` for a second time will give you an empty list! So wrapping `collection.find(...)` directly inside `list()` would avoid this issue. With that in mind, you may not *always* need to obtain a visual output of the results.\n",
-    "  \n",
-    "- Be aware of the distinction of when you are querying with Mongo versus Python-based array indexing into your Mongo query results (i.e. you are wrapping your query inside `list()` and *then* indexing into that list.)\n",
-    "  \n",
-    "- **As a reminder, since we are using Python dictionaries as our query filter, make sure to wrap all keys and values inside quotes.**\n",
-    "\n",
-    "As a warmup to get you familiarized with PyMongo syntax, find the **Tuesday hours** for the restaurant named **Legal Sea Foods** at **100 Huntington Ave** in **Boston**. Be careful—there are many Legal Sea Foods in Boston!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_1a = ...\n",
-    "result_1a"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_1a\", result_1a);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1a\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "\n",
-    "### Question 1b\n",
-    "Now let's get some practice with aggregation and filtering. Our goal is to write a query that computes the average star rating for all businesses in Colorado with 30 reviews or greater. However, this won't be as easy as setting the state to CO! If we inspect this dataset more closely, we will notice that some cities are not matched up with the right states. As an example, run the query below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "list(business.find({\"state\": \"CA\"}).limit(3))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Notice how cities like Portland and Atlanta, and Orlando are classified as California cities! However, the latitude and longitude is generally correct. The latitude of Colorado is between 37 and 41 **inclusive** and the longitude is between -109 and -102 **inclusive**. Now, use this to **find the average star rating** of all businesses in this range with **30 or more reviews**.\n",
-    "\n",
-    "Recall that in SQL, we would use a GROUP BY with the AVG aggregation function. In Mongo, we use an aggregation pipeline [(documentation here)](https://www.mongodb.com/docs/manual/reference/method/db.collection.aggregate/), comprised of multiple stages (e.g., `$match` followed by `$group`). Each stage transforms the documents in some way. Pipeline stages do not need to produce one output document for every input document. For example, some stages may generate new documents or filter out documents.\n",
-    "\n",
-    "**Hints:**\n",
-    "- As in the previous question, you may find it helpful to use the PyMongo array notation to extract the pertinent information/document once you have composed the right Mongo aggregation query. You are required to wrap `collection.aggregate(...)` inside `list()`, e.g. `list(collection.aggregate(...))` before indexing / visualizing the output. Similar to `collection.find(...)`, `collection.aggregate(...)` also returns a **Cursor** object (which is an iterator).\n",
-    "\n",
-    "- You can set multiple conditions for a given field within the same object, e.g. `{\"$gte\": 0, \"$lte\": 10}`. This is the recommended approach, or else you may need to worry about the ordering between the conditions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_1b = ...\n",
-    "result_1b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_1b\", result_1b);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1b\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 1c\n",
-    "\n",
-    "In this question, we will explore aggregation and grouping further. We will also make use of the `$project` operator which allows us to output documents with certain fields of our choosing. \n",
-    "\n",
-    "For this question, we would like to create an aggregation pipeline to find the town in each state with the highest average number of stars. **We will only consider towns with greater than or equal to 5 reviews in total across all the restaurants in that town so that the average is meaningful.** Your final output should contain exactly two fields:\n",
-    "- `averageStars` which contains the average number of stars for the corresponding town.\n",
-    "- `city_state` which is the name of the town with the highest value of average stars in the state concatenated with a comma followed by the state initials\n",
-    "\n",
-    "\n",
-    "To ensure your output is consistent with the autograder, **sort in descending order by `averageStars` and break ties by sorting second on `city_state` in alphabetical (ascending) order.**\n",
-    "\n",
-    "As a concrete example, imagine that Berkeley and Austin have the highest average stars in California and Texas respectively (and both have more than or equal to 5 total reviews in this *truncated* dataset). If Berkeley and Austin both have an average star rating of 5.0, your final output should be:\n",
-    "\n",
-    "```\n",
-    "{'averageStars': 5.0, 'city_state': 'Austin, TX'}\n",
-    "{'averageStars': 5.0, 'city_state': 'Berkeley, CA'}\n",
-    "```\n",
-    "\n",
-    "**Note:** You will provide a pipeline to `business.aggregate(...)` as your solution. Save your pipeline to `q1c_pipeline`.\n",
-    "\n",
-    "**Hint:** You may find the `concat` operator helpful [(documentation here)](https://docs.mongodb.com/manual/reference/operator/aggregation/concat/)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q1c_pipeline = ...\n",
-    "\n",
-    "result_1c = list(business.aggregate(q1c_pipeline))\n",
-    "result_1c"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_1c\", list(business.aggregate(q1c_pipeline)));"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1c\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 1d\n",
-    "\n",
-    "In class, we've described structured (rectangular) data as well as semi-structured data. We haven't quite covered unstructured data—this is basically free-form text. Often, in semi-structured JSON you may have unstructured text data embedded within, such as the text field in the review collection.\n",
-    "\n",
-    "MongoDB allows us to build a so-called **text index** to retrieve the relevant document based on keywords found in text in a predefined field. This index converts our free-form text into a structure that allows us to easily look up documents by its contents. To leverage this text search capability, we build a text index on the `text` field in the `review` collection. This has been done for you.\n",
-    "\n",
-    "We will then use this text index to do basic sentiment analysis and find all the restaurants we should avoid! Using the text index given, write a query to find all the reviews with \"disgusting\", \"horrible\", \"horrid\", \"gross\", \"bad\", or \"hate\". To use the text index, use the keywords `$text` and `$search` as detailed [here](https://www.mongodb.com/docs/manual/core/text-search-operators/).\n",
-    "\n",
-    "Fill in your query into `result_1d` to count how many reviews contain any of these 6 words.\n",
-    "\n",
-    "**Hint:** In general, you can count the number of documents returned by a `find` query result via `len(list(collection.find(...)))` or more simply `collection.count_documents(...)`. To count the number of documents returned by an `aggregate` query result, the best way is to directly use `len(list(collection.aggregate(...)))`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# We create a text index here\n",
-    "if 'text_text' not in review.index_information():\n",
-    "    review.create_index([('text', TEXT)])\n",
-    "\n",
-    "result_1d = ...\n",
-    "result_1d"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_1d\", result_1d);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1d\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 1e\n",
-    "\n",
-    "Now let's learn Mongo updates, deletions, and creation. Create a new collection called `review_boolean` which is the exact same as `reviews` EXCEPT there is a new field called `to_avoid` which is the string \"true\"  if the review `text` contains the words \"disgusting\", \"horrid\", \"horrible\", \"gross\", \"bad\", or \"hate\" and the string \"false\" if not.  \n",
-    "\n",
-    "This is a tricky task! We have not discussed creation, updates, or insertions in great detail during lecture but luckily, Mongo uses a similar approach to SQL.\n",
-    "\n",
-    "***Insertions***: In order to insert into a document, you may use the functions [review_boolean.insert_one(...)](https://docs.mongodb.com/manual/reference/method/db.collection.insertOne/) or [review_boolean.insert_many(...)](https://docs.mongodb.com/manual/reference/method/db.collection.insertMany/). These functions take in a document or a list of documents and inserts them into the collection. \n",
-    "\n",
-    "***Updates***: In order to update a document, you may use the functions [review_boolean.update_one(...)](https://docs.mongodb.com/manual/reference/method/db.collection.updateOne/) or [review_boolean.update_many(...)](https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/). These functions take in two parameters. The first specifies which documents should be modified. If the first parameter is `{}`, this indicates that all documents should be updated. However, you can put a more specific filter here if you would like. The second parameter specifies what you would like to update your field to (the [$set](https://docs.mongodb.com/manual/reference/operator/update/set/) operator may come in handy here). Recall that in our SQL model, updates are performed as `UPDATE ... SET ... WHERE ...`. In our case, the first ellipsis corresponds to `review_boolean`, the second ellipsis corresponds to the second parameter of `update_*` where `*` can be `one` or `many`, and the third ellipsis corresponds to the first parameter of `update_*`.\n",
-    "\n",
-    "***Creation***: We handle creation of the collection for you. But in Pymongo, creation of a collection is as simple as writing `variable_name = db[collection_name]` where db is the the Pymongo database object variable you have already created.\n",
-    "\n",
-    "Some additional reminders and hints:\n",
-    "- The empty collection `review_boolean` has already been created for you and is stored in the variable of the same name.\n",
-    "- A text index has been created for you. You can use a similar search approach as the last question.\n",
-    "- We want to start by inserting the documents from the `review` collection into the `review_boolean` collection.\n",
-    "- Don't forget that in order to pass the hidden tests, the `to_avoid` field must exist for every document in `review_boolean`! The [$exists](https://www.mongodb.com/docs/manual/reference/operator/query/exists/) operator may be helpful."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "review_boolean = mydb[\"review_boolean\"]\n",
-    "review_boolean.drop()\n",
-    "\n",
-    "# We create a text index here\n",
-    "if 'text_text' not in review_boolean.index_information():\n",
-    "    review_boolean.create_index([('text', TEXT)])\n",
-    "\n",
-    "# YOUR ANSWER BEGINS HERE"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "review_boolean = mydb[\"review_boolean\"]\n",
-    "review_boolean.find_one()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "review_boolean = mydb[\"review_boolean\"]\n",
-    "grading_util.save_results(\"result_1e\", list(review_boolean.find({}, {'_id': 0})));"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1e\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 1f\n",
-    "\n",
-    "Now, you had a change of heart: you decide that it's unfair to label restaurants as `to_avoid` without at least giving them a chance! Remove the `to_avoid` field from the `review_boolean` collection. Calculate the `difference` between the data size of `review_boolean` with the `to_avoid` field and without it. The code for making this calculation is provided but it is up to you to actually remove the field.\n",
-    "\n",
-    "*Deletions*: Deletions in Mongo make use of the `review_boolean.update_one(...)` or `review_boolean.update_many(...)` functionality discussed in Question 1e. However, this time, instead of using the `$set` operator which allows for the creation of new fields, we will use the [$unset](https://docs.mongodb.com/manual/reference/operator/update/unset/) operator which deletes them! Very tidy!\n",
-    "\n",
-    "**Before running the next cell, make sure to re-run your cell for 1e so you don't get a difference of 0!**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "with_avoid = mydb.command(\"collstats\", \"review_boolean\")['size']\n",
-    "\n",
-    "# YOUR ANSWER BEGINS HERE\n",
-    "# END\n",
-    "\n",
-    "without_avoid = mydb.command(\"collstats\", \"review_boolean\")['size']\n",
-    "difference = with_avoid - without_avoid\n",
-    "difference"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_1f\", difference);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q1f\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr style=\"border: 5px solid #003262;\" />\n",
-    "<hr style=\"border: 1px solid #fdb515;\" />\n",
-    "\n",
-    "#### Question 2: JSON and Relational Models\n",
-    "\n",
-    "### Question 2a\n",
-    "\n",
-    "Now we have a good idea of how to do retrieval, aggregation, and updates in Mongo. But we haven't talked about why we\n",
-    "would want to use Mongo to store JSON! In order to explore this, let's take another look at the `business`\n",
-    "collection. We will look at the first two entries."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "list(business.find({}).limit(2))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "What are **two** benefts of storing this data in MongoDB with JSON over a relational database management system such as Postgres?\n",
-    "Please reference specific examples from the `business` collection to back up your claims. \n",
-    "- Format your answer as follows:\n",
-    "  1. Benefit #1, Example #1.\n",
-    "  2. Benefit #2, Example #2.\n",
-    "\n",
-    "**Limit each benefit to 1 sentence and each example to 1 sentence for a total of at most four sentences.**\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 2b\n",
-    "\n",
-    "It seems like MongoDB is getting all the love when it comes to JSON support! However, modern iterations of relational databases\n",
-    "such as Postgres 9.3+ also have [excellent JSON functionality](https://www.postgresql.org/docs/9.3/functions-json.html) as we will soon explore in this task. First, let's set up a\n",
-    "bit of scaffolding. The following cell will import the `yelp_academic_dataset_review.json` data into a table called `reviews` in Postgres yelp database."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "%reload_ext sql\n",
-    "%sql postgresql://jovyan@127.0.0.1:5432/postgres\n",
-    "\n",
-    "!psql -h localhost -c 'DROP DATABASE IF EXISTS yelp'\n",
-    "!psql -h localhost -c 'CREATE DATABASE yelp'\n",
-    "!psql -h localhost -d yelp -c 'DROP TABLE IF EXISTS reviews'\n",
-    "!psql -h localhost -d yelp -c 'CREATE TABLE reviews(data TEXT);'\n",
-    "!cat data/yelp_academic_dataset_review.json | psql -h localhost -d yelp -c \"COPY reviews (data) FROM STDIN;\"\n",
-    "%sql \\l"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now, run the following cell to connect to the Postgres yelp database. There should be no errors after running the following cell."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%sql postgresql://jovyan@127.0.0.1:5432/yelp"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Run the following cell to observe how this new `reviews` table looks. Note that the `data` column is stored as TEXT and not as JSON."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%sql\n",
-    "SELECT * FROM reviews LIMIT 2;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Observe how the reviews table consists of one column named `data`. This column contains all the JSON documents in the \n",
-    "reviews collection *in text format*. Use [Postgres' JSON functions](https://www.postgresql.org/docs/9.3/functions-json.html) to write a query that converts the JSON fields into their own `TEXT` columns (**hint:** one of the operators in Table 9-40 may be useful). To be more concrete, your query should contain 8 columns in this particular order: `review_id`, `user_id`, `business_id`, `stars`, `useful`, `funny`, `cool`, and `text`. Each row should correspond to one JSON document. Some skeleton code (that does the mundane work of converting data to JSON properly) is provided to you—you will only need to fill in the SELECT clause."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "%%sql --save query_2b result_2b <<\n",
-    "...\n",
-    "FROM (SELECT CAST(regexp_replace(data, E'[\\\\n\\\\r]+', '','g') AS JSON) AS values FROM reviews) b\n",
-    "ORDER BY review_id\n",
-    "LIMIT 10;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "query_2b = %sqlcmd snippets query_2b\n",
-    "grading_util.save_results(\"result_2b\", query_2b, result_2b)\n",
-    "result_2b.DataFrame().head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q2b\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 2c\n",
-    "\n",
-    "One important aspect of data engineering that we have not referred to yet are joins. We saw, through the use of indices, selection/projection pushdown, and various physical implementations (as well as orderings), joins could be done quite efficiently in relational SQL based databases. How do joins fare in Mongo where the data stored is inherently semistructured? Let's investigate! For this question, we have provided you access to the tables `business_complete` and `review_complete` which contain the business and review collections in relational form as described in 2b (the columns of the relations\n",
-    "are fields in the JSON document). Each relation has its respective id (`business_id` or `review_id`) column as its primary key."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!psql -h localhost -d yelp -c 'DROP TABLE IF EXISTS business_complete'\n",
-    "!psql -h localhost -d yelp -c 'CREATE TABLE business_complete(business_id TEXT PRIMARY KEY, name TEXT, address TEXT, city TEXT, state TEXT, postal_code TEXT, latitude TEXT,longitude TEXT, stars TEXT, review_count TEXT, is_open TEXT, attributes TEXT, categories TEXT, hours TEXT);'\n",
-    "!psql -h localhost -d yelp -c 'DROP TABLE IF EXISTS review_complete'\n",
-    "!psql -h localhost -d yelp -c 'CREATE TABLE review_complete(review_id TEXT PRIMARY KEY, user_id TEXT, business_id TEXT, stars TEXT, useful TEXT, funny TEXT, cool TEXT,text TEXT);'\n",
-    "!cat data/business.csv | psql -h localhost -d yelp -c \"COPY business_complete (business_id,name,address,city,state,postal_code,latitude,longitude,stars,review_count,is_open,attributes,categories,hours) FROM STDIN CSV HEADER;\"\n",
-    "!cat data/review.csv | psql -h localhost -d yelp -c \"COPY review_complete (review_id, user_id, business_id, stars, useful, funny, cool, text) FROM STDIN CSV HEADER;\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's take a look at how `review_complete` looks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%sql\n",
-    "SELECT * FROM review_complete LIMIT 1;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "At this current moment in time, Mongo only supports left joins (via the lookup aggregation stage). This is what we will compare against SQL.\n",
-    "\n",
-    "Let's start by writing a SQL query that displays all the reviews along with their associated business information. You should perform a **left join** between the `review_complete` table and the `business_complete` table on the `business_id` column, and you may project all columns. Keep a mental note of the **execution time** that you see in the query plan."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_2c_str = ...\n",
-    "!psql -h localhost -d yelp -c \"explain analyze $result_2c_str\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "Now, let's perform the equivalent left join in Mongo between `review` and `business`. **The output array field should be named as `business_info`**. Feel free to refer to the `$lookup` [documentation](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/).\n",
-    "\n",
-    "**Note:** You will provide a single-stage pipeline to `review.aggregate(...)` as your solution. Save your pipeline to `q2c_pipeline`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# We first create an index on business_id in the business collection\n",
-    "business.create_index('business_id', unique=True)\n",
-    "\n",
-    "q2c_pipeline = ...\n",
-    "\n",
-    "result_2c = list(review.aggregate(q2c_pipeline))[:5]\n",
-    "# Uncomment the line below to see your output\n",
-    "# result_2c"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "result_2c = list(review.aggregate(q2c_pipeline))[:5]\n",
-    "grading_util.save_results(\"result_2c\", result_2c);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q2c\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Run the following cell to examine the query plan for the Mongo query that you just wrote. Again, make a mental note of the execution time that you see (you can find the value corresponding to the key `executionTimeMillis`)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mydb.command('explain', {'aggregate': 'review', 'pipeline': q2c_pipeline, 'cursor': {}}, verbosity='executionStats')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 2d\n",
-    "\n",
-    "In the last question, you performed equivalent left joins in both Postgres and Mongo. Now, examine their query plans, paying special attention to `executionTimeMillis`. Which join was faster? What gives that database system you chose an advantage over the other? Keep your response to at most three sentences."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "<hr style=\"border: 5px solid #003262;\" />\n",
-    "<hr style=\"border: 1px solid #fdb515;\" />\n",
-    "\n",
-    "## Question 3: Dataframes / Pandas\n",
-    "\n",
-    "### Question 3a\n",
-    "\n",
-    "So far, we've talked about NoSQL / document databases like Mongo and relational databases like Postgres. Now, we will explore data transformation with a different data model: dataframes. Dataframes are similar to relations with some differences as we will dive into here. To that end, we will use Pandas which is a Python package that allows you to work with dataframes. Pandas is widely adopted by data scientists for data loading, wrangling, cleaning, and analysis. To start, let us export our MongoDB collections into Pandas using a function called `json_normalize`. We need to truncate\n",
-    "`business` before we can use it to meet the memory constraints set by Jupyter. The variable `business_trunc` will contain the reference the truncated business collection."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "business_trunc = mydb[\"business_trunc\"]\n",
-    "count = 0\n",
-    "if business_trunc.count_documents({}) != 1000:\n",
-    "    for document in business.find({}):\n",
-    "        count += 1\n",
-    "        business_trunc.insert_one(document)\n",
-    "        if count == 1000:\n",
-    "            break\n",
-    "\n",
-    "business_cursor = business_trunc.find({})\n",
-    "review_cursor = mydb[\"reviews\"].find({})\n",
-    "user_cursor = mydb[\"users\"].find({})\n",
-    "\n",
-    "# Load the collections into Pandas. \n",
-    "from pandas import json_normalize\n",
-    "user_df = json_normalize(user_cursor)\n",
-    "review_df = json_normalize(review_cursor)\n",
-    "business_df = json_normalize(business_cursor)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For the rest of Question 3, please use the 3 dataframes we just created: `user_df`, `review_df`, and `business_df`. Let's take a look at the first 5 rows of `business_df`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "business_df.head()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- BEGIN QUESTION -->\n",
-    "\n",
-    "What do you notice about how the columns of `business_df` are constructed? How are values that are not found in every document handled in the pandas dataframe? Compare and contrast this dataframe representation with the document representation we saw with Mongo. Keep your response to at most two sentences.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "_Type your answer here, replacing this text._"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "<!-- END QUESTION -->\n",
-    "\n",
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 3b\n",
-    "\n",
-    "In the previous question, we talked about how Mongo and Postgres approach joins. Pandas is also capable of performing joins using the [merge()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html) function! For this task, perform a inner join on `business_df` with itself on `stars`. The final dataframe should be saved to a variable called `result_3b` and should only contain 3 columns in this particular order: the name of the first restaurant, the name of the second restaurant, and the number of the stars. The column names can be arbitrary.\n",
-    "\n",
-    "**Hint:** Check out [this tutorial](https://pandas.pydata.org/docs/getting_started/intro_tutorials/03_subset_data.html) on selecting a subset of the Dataframe. This will be helpful in the rest of Question 3 as well!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_3b = ...\n",
-    "result_3b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "result_3b.columns = ['first', 'second', 'stars']\n",
-    "grading_util.save_results(\"result_3b\", result_3b.sort_values(['first', 'second', 'stars'])[:50]);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3b\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 3c\n",
-    "\n",
-    "Due to the nested representation of the data, there are a lot of missing fields with NaN values in the `business_df` dataframe as you may have noticed in 3a. Construct a dataframe `missing_value_df` with two columns: `column_name` and `percent_missing`. `percent_missing` should be the percentage of NaN values in the corresponding column in `business_df`.\n",
-    "\n",
-    "**Hint:** use Pandas' [isnull()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.isnull.html) function followed by sum()."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "missing_value_df = pd.DataFrame({'column_name': business_df.columns,\n",
-    "                                 ...\n",
-    "missing_value_df.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_3c\", missing_value_df);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3c\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 3d\n",
-    "\n",
-    "Plot a histogram distribution of the percentage of NaN values across all columns (via Pandas [hist()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.hist.html) function). Don't worry about putting titles / making it look nice—we won't be grading the plot."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# PLOT HERE"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "Examine the histogram that you just plotted. How many columns are 90%+ NaN? Input your answer into `result_q3d` as an integer (e.g. if your answer is 6, then `result_q3d = 6`)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_q3d = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3d\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 3e\n",
-    "\n",
-    "Let us now alter `business_df` to exclude the columns with more than 80%+ null values (keep columns with 80% null values or less). This likely means the corresponding attributes are not an important factor for most businesses so we can get rid of them in our `business_df`. Create a new dataframe called `important_attribute_business_df` which only contains these columns.\n",
-    "\n",
-    "**Hint:** check out [this section](https://pandas.pydata.org/docs/getting_started/intro_tutorials/03_subset_data.html#how-do-i-select-specific-rows-and-columns-from-a-dataframe) from the tutorial linked in Q3b."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "important_attribute_business_df = ...\n",
-    "important_attribute_business_df.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_3e\", important_attribute_business_df);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3e\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 3f\n",
-    "\n",
-    "At this point, you have had experience with manipulating data on Mongo, Postgres, and Pandas. In this question, we will provide 3 scenarios and using the lessons you've learned so far, please specify which of the three (Mongo, Postgres, or Pandas) would work best for this specific use case.\n",
-    "\n",
-    "1. You are doing a data journalism piece on college sports. You collect a list of colleges and for each collegiate sport program within that college, you find the budget assigned for that program. You have a choice between the following:\n",
-    "\n",
-    "    A) Representing this data in JSON (e.g. \n",
-    "    ```\n",
-    "    {\n",
-    "        \"UC Berkeley\": {\n",
-    "            \"football\": \"10000000\", \n",
-    "            \"wrestling\": \"344582\", \n",
-    "            ...}\n",
-    "    }\n",
-    "    ```\n",
-    "    ) and importing into Mongo.\n",
-    "    \n",
-    "    B) Representing this data as a schema in Postgres where the columns are the names of the sports.\n",
-    "    \n",
-    "    C) Representing this data as a dataframe in Pandas where the columns are the names of the sports.\n",
-    "\n",
-    "You would like to find the aggregate of budgets across different sports (average, sum, median, mode). What would be the best option for storing this data?\n",
-    "\n",
-    "**NOTE**: Your answer should look like `q3fi_str = ['A']` or `q3fi_str = ['B']` or `q3fi_str = ['C']`.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q3fi_str = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3fi\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "2. You would now like to investigate what effect does budget have on student-athlete scholarships. After doing some research, you find a dataset that contains a list of every single athlete at every single college and their sport and scholarship levels (this is a massive 10GB+ dataset with millions of rows). You find another dataset that contains a list of colleges, their sports programs, and the program budget. This is another massive dataset with hundreds of thousands of rows. You would like to perform an inner join between the two datasets on school and program so you can view each student-athlete's scholarship with their sport's budget. You have a choice between the following:\n",
-    "\n",
-    "    A) Representing each dataset in JSON (e.g. \n",
-    "    ```\n",
-    "    {\"athletes\": [\n",
-    "        {\"Chase Garbers\": {\n",
-    "            \"school\": \"UC Berkeley\", \n",
-    "            \"scholarship\": \"full\", \n",
-    "            \"sport\": \"football\", \n",
-    "            ...\n",
-    "            }\n",
-    "        }, \n",
-    "        ...\n",
-    "    ]}\n",
-    "    ```\n",
-    "    and \n",
-    "    ```\n",
-    "    {\"schools\": [\n",
-    "        {\"UC Berkeley\": {\n",
-    "            \"football\": {\n",
-    "                \"budget\": \"10000000\"\n",
-    "             }, \n",
-    "             ...\n",
-    "             }\n",
-    "        }, \n",
-    "        ...\n",
-    "     ]}\n",
-    "     ```\n",
-    "    ), importing into Mongo, and doing a join there.\n",
-    "    \n",
-    "    B) Representing this data as 2 schemas in Postgres where the columns for the first schema are \n",
-    "    [`student_name`, `school`, `sport`, `scholarship`] and for the second [`school`, `sport`, `budget`].\n",
-    "    \n",
-    "    C) Representing this data as 2 dataframes in Pandas with the same columns as Postgres.\n",
-    "\n",
-    "What would be the best option for storing this data?\n",
-    "\n",
-    "**NOTE**: Your answer should look like `q3fii_str = ['A']` or `q3fii_str = ['B']` or `q3fii_str = ['C']` or `q3fii_str = ['D']`\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q3fii_str = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3fii\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "3. Finally, you are ready to start writing your article! You decide to focus on just the data from UC Berkeley. You have access to a dataset of just UC Berkeley athletes along with their sports and scholarship levels. The scholarship level data was improperly cleaned: some scholarships are recorded as strings \"full\", \"half\", or \"none\" and some are recorded as integer percentages 0-100. You would like to provide this data to your readers in a format that is susceptible to easy visualizations: e.g. graphs that show how many athletes have a full vs. half vs. no scholarship, which sports have the highest percentages of athletes with full scholarships etc. What is the best way to store this data for this purpose?\n",
-    "\n",
-    "    A) Represent the dataset in JSON e.g.\n",
-    "    ```\n",
-    "    {\"athletes\": [\n",
-    "        {\n",
-    "           \"Chase Garbers\": {\n",
-    "             \"scholarship\": \"full\", \n",
-    "             \"sport\": \"football\"\n",
-    "           }\n",
-    "        },\n",
-    "        {\n",
-    "            \"Danielle Vosk\": {\n",
-    "              \"scholarship\": 25,\n",
-    "              \"sport\": \"basketball\"\n",
-    "            }\n",
-    "        },\n",
-    "        ...\n",
-    "        ]\n",
-    "    }\n",
-    "    ```\n",
-    "    B) Represent this data as a schema in Postgres where the columns are [`student_name`, `sport`, `scholarship`]\n",
-    "    \n",
-    "    C) Represent this data as a dataframe in Pandas with the same columns as Postgres.\n",
-    "    \n",
-    "**NOTE**: Your answer should look like `q3fiii_str = ['A']` or `q3fiii_str = ['B']` or `q3fiii_str = ['C']` or `q3fiii_str = ['D']`\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q3fiii_str = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q3fiii\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr style=\"border: 5px solid #003262;\" />\n",
-    "<hr style=\"border: 1px solid #fdb515;\" />\n",
-    "\n",
-    "## Question 4: Messy JSON\n",
-    "\n",
-    "Many of the queries you've seen or written thus far were relatively reliable: aggregating and collecting over fields\n",
-    "that you know exist for sure. But the nature of Mongo documents is that they are inherently flexible and semi-structured. Not every document will share every single field! In this question, we will explore how Mongo handles these use cases using the `business` collection.\n",
-    "\n",
-    "### Question 4a\n",
-    "\n",
-    "Imagine you are in charge of managing your family reunion. You would like to book a private room at a restaurant.\n",
-    "However, you would also like to optimize for chaos. You notice that there is an attribute called `RestaurantsGoodForGroups`. You would like to write a query that returns all restaurants that **do not** have the `RestaurantsGoodForGroups` attribute so that the trajectory of the reunion is determined by fate (**hint:** search up the `$exists` keyword). \n",
-    "\n",
-    "How many restaurants do not have the `RestaurantsGoodForGroups` attribute? You may either enter input this as a function with respect to your query or hardcode in either the String or the numeric version of the answer you computed. Ensure that your output for the autograder is the **number of restaurants that do not have the `RestaurantsGoodForGroups` attribute** stored in `q4a_str` as an integer.\n",
-    "\n",
-    "**Note:** You would like this list to consist solely of restaurants. This means that the business must have `Restaurants` in the `categories` field. You may perform a similar text search as question 1d. **This holds true for the rest of the Question 4 as well!**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# The following text index may be useful!\n",
-    "if 'categories_text' not in business.index_information():\n",
-    "    business.create_index([('categories', TEXT)])\n",
-    "\n",
-    "...\n",
-    "q4a_str = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_4a\", q4a_str)[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q4a\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 4b\n",
-    "\n",
-    "Your relatives inform you that they would like to be at the restaurant when it opens to beat the crowds. Furthermore, after sending\n",
-    "a when2meet, most of your relatives would prefer for the meal to be on a Friday and the start time of the meal to be \n",
-    "between 5-6:59PM (17:00-18:59). Find the number of restaurants that open on Fridays between 17:00-18:59 (you only have to consider the opening time!) and store this in a variable labeled `q4b_str`. As a reminder, in order for a business to be a restaurant, it must have `Restaurant` in its categories. Be aware that `hours` can either be an array or `None`!\n",
-    "\n",
-    "**Hint**: \n",
-    "- Set up an aggregation pipeline using the `$set` and `$match` stage operators. You may also want to use the `$split` operator to parse out the Friday hours as an integer and then use comparison operators to find the restaurants that are open during the specified time. Note that using dot notation for array indexing in aggregation pipelines may not work as expected, so we recommend using `$arrayElemAt` operator.\n",
-    "\n",
-    "- Again as a reminder, you can set multiple conditions for a given field within the same object, e.g. `{\"$gte\": 0, \"$lte\": 10}`. This is the recommended approach, or else you may need to worry about the ordering between the conditions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "...\n",
-    "q4b_str = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_4b\", q4b_str)[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q4b\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 4c\n",
-    "\n",
-    "Some members of your family are vegetarian so you would like to only eat at restaurants with the Vegetarian category. \n",
-    "However, the `categories` are stored as a single string! You would like to make it easy to access Vegetarian as a separate field. Write a query that does the following: for every category in `categories`, add a new document that contains the `ObjectId` for the previous document (labeled `_id`), the name of the business (labeled `name`), and the category (labeled `category`).\n",
-    "\n",
-    "For example, a document \n",
-    "```\n",
-    "{\n",
-    "    \"_id\": ObjectId('606ffb0123cf2e5079dbd91f'), \n",
-    "    \"name\": \"Wendy's\", \n",
-    "     ..., \n",
-    "     categories\" : \"Salad, Vegetarian\"\n",
-    "} \n",
-    "```\n",
-    "would become \n",
-    "```\n",
-    "{\n",
-    "    \"_id\": ObjectId('606ffb0123cf2e5079dbd91f'), \n",
-    "    \"name\": \"Wendy's\",\n",
-    "    “category”: \"Salad\"\n",
-    "}\n",
-    "```\n",
-    "and \n",
-    "```\n",
-    "{\n",
-    "    \"_id\": ObjectId('606ffb0123cf2e5079dbd91f'), \n",
-    "    \"name\": \"Wendy's\",\n",
-    "    “category”: \"Vegetarian\"\n",
-    "}\n",
-    "```\n",
-    "\n",
-    "Finally, to ensure your output is consistent with the autograder, sort in ascending order by `name` and break ties on `category`. Save your pipeline to a variable called `q4c_pipeline`.\n",
-    "\n",
-    "**Hint:** The `$unwind` operator may be helpful here. You can find the documentation [here](https://www.mongodb.com/docs/manual/reference/operator/aggregation/unwind/). Be sure to check what object type `$unwind` operates on and watch out to make sure you don't have any unnecessary space in the `category` field."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true,
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q4c_pipeline = ...\n",
-    "\n",
-    "result_4c = list(business.aggregate(q4c_pipeline))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "result_4c[:5]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "result_4c = list(business.aggregate(q4c_pipeline))[10000:10050]\n",
-    "grading_util.save_results(\"result_4c\", result_4c);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q4c\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<br>\n",
-    "\n",
-    "---\n",
-    "### Question 4d\n",
-    "This change in representation has made it super easy to view all the vegetarian restaurants and count them without the use of an index since we can now simply filter by whether or not 'Vegetarian' is a field in our document! We have provided some code here to count how many vegetarian restaurants are in our dataset. Simply provide the integer count to get a point for this question :)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "q4d_pipeline = q4c_pipeline[:]\n",
-    "q4d_pipeline.append({\"$match\": {\"category\": 'Vegetarian'}})\n",
-    "result_4d = list(business.aggregate(q4d_pipeline))\n",
-    "\n",
-    "veg_count = ..."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Do not delete/edit this cell!\n",
-    "# You must run this cell before running the autograder.\n",
-    "grading_util.save_results(\"result_4d\", veg_count)[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check(\"q4d\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<hr style=\"border: 5px solid #003262;\" />\n",
-    "<hr style=\"border: 1px solid #fdb515;\" />\n",
-    "\n",
-    "## Congratulations! You have finished Project 4.\n",
-    "\n",
-    "Run the following cell to zip and download the results of your queries. You will also need to run the export cell at the end of the notebook.\n",
-    "\n",
-    "**For submission on Gradescope, you will need to submit the `proj4.zip` file generated by the export cell.** Please ensure that your submission includes `proj4.pdf`. \n",
-    "\n",
-    "**Please ensure that public tests pass upon submission.** It is your responsibility to wait until the autograder finishes running. We will not be accepting regrade requests for submission issues.\n",
-    "\n",
-    "**Common submission issues:** You MUST submit the generated zip files (not folders) to the autograder. However, Safari is known to automatically unzip files upon downloading. You can fix this by going into Safari preferences, and deselect the box with the text \"Open safe files after downloading\" under the \"General\" tab."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "grading_util.prepare_submission_and_cleanup()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "---\n",
-    "\n",
-    "To double-check your work, the cell below will rerun all of the autograder tests."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "grader.check_all()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "source": [
-    "## Submission\n",
-    "\n",
-    "Make sure you have run all cells in your notebook in order before running the cell below, so that all images/graphs appear in the output. The cell below will generate a zip file for you to submit. **Please save before exporting!**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "deletable": false,
-    "editable": false
-   },
-   "outputs": [],
-   "source": [
-    "# Save your notebook first, then run this cell to export your submission.\n",
-    "grader.export(files=['results.zip'])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    " "
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "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.11.9"
-  },
-  "otter": {
-   "OK_FORMAT": true,
-   "tests": {
-    "q1a": {
-     "name": "q1a",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> question_1a_str = grading_util.load_results(\"result_1a\")[0]\n>>> \"-\" in question_1a_str and \":\" in question_1a_str\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q1b": {
-     "name": "q1b",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> question_1b_str = grading_util.load_results(\"result_1b\")[0]\n>>> question_1b_str >= 3 and question_1b_str <= 4.5\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q1c": {
-     "name": "q1c",
-     "points": 2,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> cur_test_1c = grading_util.load_results(\"result_1c\")[0]\n>>> len(cur_test_1c) == 31\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q1d": {
-     "name": "q1d",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> question_1d_str = grading_util.load_results(\"result_1d\")[0]\n>>> question_1d_str >= 700 and question_1d_str <= 800\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q1e": {
-     "name": "q1e",
-     "points": 2,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> review_boolean_ans_1e = len(grading_util.load_results(\"result_1e\")[0])\n>>> review_boolean_ans_1e == 7500\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q1f": {
-     "name": "q1f",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> difference = grading_util.load_results(\"result_1f\")[0]\n>>> 0 < difference <= 300000\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2b": {
-     "name": "q2b",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> query_2b, result_2b_df = grading_util.load_results(\"result_2b\")\n>>> result_2b_df.iloc[0, 0] == '000bviMESLXmlIFKDzCEfw'\nTrue",
-         "hidden": false,
-         "locked": false
-        },
-        {
-         "code": ">>> query_2b, result_2b_df = grading_util.load_results(\"result_2b\")\n>>> str(result_2b_df.iloc[8, 3]) == '5.0'\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q2c": {
-     "name": "q2c",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> cur_test_2c = grading_util.load_results(\"result_2c\")[0]\n>>> 'business_info' in list(cur_test_2c[0].keys())\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3b": {
-     "name": "q3b",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> result_3b_df = grading_util.load_results(\"result_3b\")[0]\n>>> result_3b_df.shape == (50, 3)\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3c": {
-     "name": "q3c",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> result_3c_df = grading_util.load_results(\"result_3c\")[0]\n>>> list(result_3c_df.loc[result_3c_df['column_name'] == '_id'][\"percent_missing\"])[0] == 0\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3d": {
-     "name": "q3d",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> result_q3d >= 1 and result_q3d <= 58\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3e": {
-     "name": "q3e",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> result_3e_df = grading_util.load_results(\"result_3e\")[0]\n>>> len(result_3e_df) == 1000 and len(result_3e_df.columns) != 58\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3fi": {
-     "name": "q3fi",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> len(q3fi_str) and ord(q3fi_str[0]) >= 65 and ord(q3fi_str[0]) <= 67\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3fii": {
-     "name": "q3fii",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> len(q3fii_str) and ord(q3fii_str[0]) >= 65 and ord(q3fii_str[0]) <= 67\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q3fiii": {
-     "name": "q3fiii",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> len(q3fiii_str) and ord(q3fiii_str[0]) >= 65 and ord(q3fiii_str[0]) <= 67\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q4a": {
-     "name": "q4a",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> q4a_str = grading_util.load_results(\"result_4a\")[0]\n>>> int(q4a_str) >= 0 and int(q4a_str) <= 10000\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q4b": {
-     "name": "q4b",
-     "points": 2,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> q4b_str = grading_util.load_results(\"result_4b\")[0]\n>>> int(q4b_str) >= 3000 and int(q4b_str) <= 4000\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q4c": {
-     "name": "q4c",
-     "points": 2,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> cur_test_4c = grading_util.load_results(\"result_4c\")[0]\n>>> cur_test_4c[0]['name'] == 'Asian Fusion Bowl' and cur_test_4c[0]['category'] == 'Street Vendors'\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    },
-    "q4d": {
-     "name": "q4d",
-     "points": 1,
-     "suites": [
-      {
-       "cases": [
-        {
-         "code": ">>> veg_count = q4b_str = grading_util.load_results(\"result_4d\")[0]\n>>> veg_count > 0 and veg_count < 2000\nTrue",
-         "hidden": false,
-         "locked": false
-        }
-       ],
-       "scored": true,
-       "setup": "",
-       "teardown": "",
-       "type": "doctest"
-      }
-     ]
-    }
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/DemoAltTags.ipynb b/test_notebooks/DemoAltTags.ipynb
similarity index 100%
rename from DemoAltTags.ipynb
rename to test_notebooks/DemoAltTags.ipynb
diff --git a/DemoHeading.ipynb b/test_notebooks/DemoHeading.ipynb
similarity index 100%
rename from DemoHeading.ipynb
rename to test_notebooks/DemoHeading.ipynb
diff --git a/DemoTextContrast.ipynb b/test_notebooks/DemoTextContrast.ipynb
similarity index 100%
rename from DemoTextContrast.ipynb
rename to test_notebooks/DemoTextContrast.ipynb
diff --git a/DemoTransparency.ipynb b/test_notebooks/DemoTransparency.ipynb
similarity index 100%
rename from DemoTransparency.ipynb
rename to test_notebooks/DemoTransparency.ipynb
diff --git a/test_notebooks/Untitled.ipynb b/test_notebooks/Untitled.ipynb
index 13aa78b02..c865a362b 100644
--- a/test_notebooks/Untitled.ipynb
+++ b/test_notebooks/Untitled.ipynb
@@ -4,7 +4,13 @@
    "cell_type": "code",
    "execution_count": 4,
    "id": "27a9f924-6e0b-4ca5-8bba-a2af2dfbddd8",
-   "metadata": {},
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
@@ -93,14 +99,7 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "6bb9f643-bd59-4fa8-910f-00a3934dfc99",
-   "metadata": {},
-   "source": [
-    "![image](https://images.unsplash.com/photo-1604147706283-d7119b5b822c?q=80&w=1000&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxzZWFyY2h8Mnx8d2hpdGUlMjB0ZXh0dXJlfGVufDB8fDB8fHww)"
-   ]
-  },
-  {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "acd43991-a8d7-4983-b51f-b873b30e968b",
    "metadata": {
@@ -155,7 +154,7 @@
     "\n",
     "![h](testLocalImage.png)\n",
     "\n",
-    "<img alt=\"h\" src=\"https://i5.walmartimages.com/seo/Tzicr-Modern-Velvet-Home-Office-Chair-Upholstered-Chairs-with-360-Swivel-Armchair-and-Gold-Base-for-Living-Room-Bedroom-Vanity-Study-Beige_6536f77a-49dd-44b0-82e0-3baf61fdae01.7e36947377a7a46b6313b3bd412c092e.jpeg\"></img>"
+    "<img alt=\"\" src=\"https://i5.walmartimages.com/seo/Tzicr-Modern-Velvet-Home-Office-Chair-Upholstered-Chairs-with-360-Swivel-Armchair-and-Gold-Base-for-Living-Room-Bedroom-Vanity-Study-Beige_6536f77a-49dd-44b0-82e0-3baf61fdae01.7e36947377a7a46b6313b3bd412c092e.jpeg\"></img>"
    ]
   },
   {
@@ -237,7 +236,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,
diff --git a/test_notebooks/Untitled1.ipynb b/test_notebooks/Untitled1.ipynb
index f3516412d..8c81ae6f0 100644
--- a/test_notebooks/Untitled1.ipynb
+++ b/test_notebooks/Untitled1.ipynb
@@ -25,7 +25,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,
diff --git a/Untitled2.ipynb b/test_notebooks/Untitled2.ipynb
similarity index 100%
rename from Untitled2.ipynb
rename to test_notebooks/Untitled2.ipynb
diff --git a/Untitled3.ipynb b/test_notebooks/Untitled3.ipynb
similarity index 100%
rename from Untitled3.ipynb
rename to test_notebooks/Untitled3.ipynb
diff --git a/test_notebooks/lowContrastGraph.ipynb b/test_notebooks/lowContrastGraph.ipynb
index 23e55bf5e..e4ebfee2d 100644
--- a/test_notebooks/lowContrastGraph.ipynb
+++ b/test_notebooks/lowContrastGraph.ipynb
@@ -29,52 +29,41 @@
    "execution_count": 1,
    "id": "03f2a4c6-8f8c-4cb3-a6ce-3f8b93adc9c0",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x600 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
+    "# import matplotlib.pyplot as plt\n",
+    "# import numpy as np\n",
     "\n",
-    "# Data\n",
-    "x = np.linspace(0, 10, 100)\n",
-    "y1 = np.sin(x)\n",
-    "y2 = np.cos(x)\n",
+    "# # Data\n",
+    "# x = np.linspace(0, 10, 100)\n",
+    "# y1 = np.sin(x)\n",
+    "# y2 = np.cos(x)\n",
     "\n",
-    "# Create plot\n",
-    "plt.figure(figsize=(8, 6))\n",
+    "# # Create plot\n",
+    "# plt.figure(figsize=(8, 6))\n",
     "\n",
-    "# Sine curve with poor color contrast and poor transparency\n",
-    "plt.plot(x, y1, label='Sine', color='lightgrey', alpha=0.2)\n",
+    "# # Sine curve with poor color contrast and poor transparency\n",
+    "# plt.plot(x, y1, label='Sine', color='lightgrey', alpha=0.2)\n",
     "\n",
-    "# Cosine curve with poor color contrast\n",
-    "plt.plot(x, y2, label='Cosine', color='yellow')\n",
+    "# # Cosine curve with poor color contrast\n",
+    "# plt.plot(x, y2, label='Cosine', color='yellow')\n",
     "\n",
-    "# Unstructured header (just a plain text, no structure)\n",
-    "plt.text(2, 1, 'A Graph', fontsize=20, color='grey')\n",
+    "# # Unstructured header (just a plain text, no structure)\n",
+    "# plt.text(2, 1, 'A Graph', fontsize=20, color='black')\n",
     "\n",
-    "# X-axis label\n",
-    "plt.xlabel('X-axis')\n",
+    "# # X-axis label\n",
+    "# plt.xlabel('X-axis')\n",
     "\n",
-    "# Y-axis label\n",
-    "plt.ylabel('Y-axis')\n",
+    "# # Y-axis label\n",
+    "# plt.ylabel('Y-axis')\n",
     "\n",
-    "# No title\n",
+    "# # No title\n",
     "\n",
-    "# No legend added\n",
-    "# plt.legend()\n",
+    "# # No legend added\n",
+    "# # plt.legend()\n",
     "\n",
-    "# Display the plot\n",
-    "plt.show()"
+    "# # Display the plot\n",
+    "# plt.show()"
    ]
   }
  ],
@@ -94,7 +83,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.1"
   }
  },
  "nbformat": 4,
diff --git a/test_notebooks/proj4.ipynb b/test_notebooks/proj4.ipynb
index 7a91a3b56..05189a696 100644
--- a/test_notebooks/proj4.ipynb
+++ b/test_notebooks/proj4.ipynb
@@ -5,7 +5,11 @@
    "execution_count": null,
    "metadata": {
     "deletable": false,
-    "editable": false
+    "editable": false,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
    },
    "outputs": [],
    "source": [
@@ -16,7 +20,13 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
    "source": [
     "# Project 4: Mongo \n",
     "\n",
diff --git a/projA1.ipynb b/test_notebooks/projA1.ipynb
similarity index 100%
rename from projA1.ipynb
rename to test_notebooks/projA1.ipynb