From 27fb61268415b8e73eff300c99de1489ba3a8edc Mon Sep 17 00:00:00 2001 From: Bluesy1 <68259537+Bluesy1@users.noreply.github.com> Date: Tue, 31 Oct 2023 18:49:29 -0700 Subject: [PATCH 1/3] Add first draft of converted snorm.R file Also adds examples in a jupyter notebook Refs: https://irene.vrbik.ok.ubc.ca/blog/2021-11-04-shading-under-the-normal-curve/ --- .../shaded_normal_density_curve.ipynb | 429 ++++++++++++++++++ src/problem_bank_helpers/__init__.py | 1 + src/problem_bank_helpers/stats.py | 208 +++++++++ 3 files changed, 638 insertions(+) create mode 100644 notebook_features/shaded_normal_density_curve.ipynb create mode 100644 src/problem_bank_helpers/stats.py diff --git a/notebook_features/shaded_normal_density_curve.ipynb b/notebook_features/shaded_normal_density_curve.ipynb new file mode 100644 index 0000000..396b3cc --- /dev/null +++ b/notebook_features/shaded_normal_density_curve.ipynb @@ -0,0 +1,429 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A demonstration of the `shaded_normal_density` function." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.figure import Figure\n", + "from scipy import stats\n", + "\n", + "\n", + "def shaded_normal_density(\n", + " q: float | tuple[float, float],\n", + " /,\n", + " mean: float = 0,\n", + " sd: float = 1,\n", + " rsd: float = 4,\n", + " lower_tail: bool = True,\n", + " add_prob: bool = True,\n", + " add_q: bool = True,\n", + " add_legend: bool = False,\n", + " figsize: tuple[float, float] | None = (8, 6),\n", + " color: str = \"xkcd:sky blue\",\n", + " x_label: str = \"x\",\n", + " y_label: str = \"f(x; μ,σ)\",\n", + " legend_text: str | None = None,\n", + " **kwargs,\n", + ") -> Figure:\n", + " \"\"\"\n", + " Generate a normal distribution plot with optional listed probability calculation.\n", + "\n", + " Parameters\n", + " ----------\n", + " q : float or tuple of 2 floats\n", + " If a float, the upper or lower bound of the shaded area. If a tuple of floats, the lower and upper bounds of the shaded area.\n", + " mean : float, default: 0\n", + " The mean of the normal distribution.\n", + " sd : float, default: 1\n", + " The standard deviation of the normal distribution.\n", + " rsd : float, default: 4\n", + " The number of standard deviations to plot on either side of the mean=.\n", + " lower_tail : bool, default: True\n", + " Whether the shaded area should represent the lower tail probability P(X <= x) (True) or the upper tail probability P(X > x) (False).\n", + " add_prob : bool, default: True\n", + " Whether to show the probability of the shaded area will be displayed on the plot.\n", + " add_q : bool, default: True\n", + " Whether the value(s) of `q` should be displayed on the x-axis of the plot.\n", + " add_legend : bool, default: False\n", + " Whether a legend with the mean and standard deviation values will be displayed on the plot.\n", + " figsize : tuple of 2 floats or None, default: (8, 6)\n", + " The size of the plot in inches. If None, the default matplotlib figure size will be used as this is passed to `matplotlib.pyplot.figure`.\n", + " color : color, default: 'xkcd:sky blue'\n", + " The color of the shaded area as a valid _.\n", + " x_label : str, default: 'x'\n", + " The label for the x-axis.\n", + " y_label : str, default: 'f(x; μ,σ)'\n", + " The label for the y-axis.\n", + " legend_text : str or None, optional\n", + " The text to display in the legend if add_legend is set to true. By default (None), the legend will display the mean and standard deviation values.\n", + " **kwargs\n", + " Additional keyword arguments to pass to `matplotlib.pyplot.figure`.\n", + "\n", + " Returns\n", + " -------\n", + " matplotlib.figure.Figure\n", + " The generated matplotlib Figure object.\n", + "\n", + " Raises\n", + " ------\n", + " TypeError\n", + " If the input parameters are not of the expected type.\n", + " ValueError\n", + " If the input values are out of the expected range.\n", + "\n", + " References\n", + " ----------\n", + " Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `_.\n", + "\n", + " The R function by Dr. Irene Vrbick was adapted from `here `_.\n", + " \"\"\"\n", + " if not isinstance(mean, (float, int)):\n", + " raise TypeError(f\"mean must be a number, not a {mean.__class__.__name__!r}\")\n", + " if not isinstance(sd, (float, int)):\n", + " raise TypeError(f\"sd must be a number, not a {sd.__class__.__name__!r}\")\n", + " if not isinstance(rsd, (float, int)):\n", + " raise TypeError(f\"rsd must be a number, not a {rsd.__class__.__name__!r}\")\n", + " if (\n", + " isinstance(q, tuple)\n", + " and len(q) == 2\n", + " and isinstance(q[0], (float, int))\n", + " and isinstance(q[1], (float, int))\n", + " ):\n", + " q_lower, q_upper = sorted(q)\n", + " xx = np.linspace(mean - rsd * sd, mean + rsd * sd, 200)\n", + " yy = stats.norm.pdf(xx, mean, sd)\n", + " fig = plt.figure(figsize=figsize, **kwargs)\n", + " ax = fig.gca()\n", + " ax.plot(xx, yy)\n", + " ax.set_xlabel(x_label)\n", + " ax.set_ylabel(y_label)\n", + " x = np.linspace(q_lower, q_upper, 200)\n", + " y = stats.norm.pdf(x, mean, sd)\n", + " # fmt: off\n", + " filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one\n", + " np.concatenate([[q_lower], x, [q_upper]]),\n", + " np.concatenate([[0], y, [0]]),\n", + " color,\n", + " )\n", + " # fmt: on\n", + " if add_prob:\n", + " height = max(y) / 4\n", + " rv = stats.norm(mean, sd)\n", + " prob: float = rv.cdf(q_upper) - rv.cdf(q_lower)\n", + " ax.text((sum(q) / 2), height, f\"{prob:.3f}\", ha=\"center\")\n", + " if add_q:\n", + " ax.set_xticks(\n", + " [q_lower, q_upper],\n", + " labels=[\n", + " str(round(q_lower, 4)),\n", + " str(round(q_upper, 4)),\n", + " ],\n", + " minor=True,\n", + " color=color,\n", + " y=-0.05,\n", + " )\n", + " if q_lower in ax.get_xticks():\n", + " ax.get_xticklabels()[\n", + " np.where(ax.get_xticks() == q_lower)[0][0]\n", + " ].set_color(color)\n", + " if q_upper in ax.get_xticks():\n", + " ax.get_xticklabels()[\n", + " np.where(ax.get_xticks() == q_upper)[0][0]\n", + " ].set_color(color)\n", + "\n", + " elif isinstance(q, (float, int)):\n", + " if not isinstance(lower_tail, bool):\n", + " raise TypeError(\n", + " f\"lower_tail must be a bool, not a {lower_tail.__class__.__name__!r}\"\n", + " )\n", + "\n", + " xx = np.linspace(mean - rsd * sd, mean + rsd * sd, 200)\n", + " yy = stats.norm.pdf(xx, mean, sd)\n", + " fig = plt.figure(figsize=figsize, **kwargs)\n", + " ax = fig.gca()\n", + " ax.plot(xx, yy)\n", + " ax.set_xlabel(x_label)\n", + " ax.set_ylabel(y_label)\n", + "\n", + " if lower_tail is True:\n", + " x = np.linspace(xx[0], q, 100)\n", + " y = stats.norm.pdf(x, mean, sd)\n", + " # fmt: off\n", + " filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one\n", + " np.concatenate([[xx[0]], x, [q]]),\n", + " np.concatenate([[0], y, [0]]),\n", + " color,\n", + " )\n", + " # fmt: on\n", + " if add_prob:\n", + " height: float = stats.norm.pdf(q, mean, sd) / 4 # type: ignore\n", + " prob: float = stats.norm.cdf(q, mean, sd) # type: ignore\n", + " ax.text((q - 0.5 * sd), height, f\"{prob:.3f}\", ha=\"center\")\n", + " else:\n", + " x = np.linspace(q, xx[-1], 100)\n", + " y = stats.norm.pdf(x, mean, sd)\n", + " # fmt: off\n", + " filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one\n", + " np.concatenate([[q], x, [xx[-1]]]),\n", + " np.concatenate([[0], y, [0]]),\n", + " color,\n", + " )\n", + " # fmt: on\n", + " if add_prob:\n", + " height: float = stats.norm.pdf(q, mean, sd) / 4 # type: ignore\n", + " prob: float = stats.norm.sf(q, mean, sd) # type: ignore\n", + " ax.text((q + 0.5 * sd), height, f\"{prob:.3f}\", ha=\"center\")\n", + "\n", + " if add_q:\n", + " if q in ax.get_xticks():\n", + " ax.get_xticklabels()[np.where(ax.get_xticks() == q)[0][0]].set_color(\n", + " color\n", + " )\n", + " else:\n", + " ax.set_xticks(\n", + " [q],\n", + " labels=[\n", + " str(round(q, 4)),\n", + " ],\n", + " minor=True,\n", + " color=color,\n", + " y=-0.05,\n", + " )\n", + "\n", + " else:\n", + " error_base = \"q must be a tuple of two numbers, or a single number\"\n", + " if isinstance(q, tuple):\n", + " if len(q) != 2:\n", + " raise ValueError(f\"{error_base}, not a {len(q)}-tuple\")\n", + " raise TypeError(\n", + " f\"{error_base}, not a 2-tuple containing a {q[0].__class__.__name__!r} and a {q[1].__class__.__name__!r}\"\n", + " )\n", + " else:\n", + " raise TypeError(f\"{error_base}, not a {q.__class__.__name__!r}\")\n", + "\n", + " if add_legend:\n", + " ax.set_title(legend_text or f\"μ = {mean}, σ = {sd}\")\n", + "\n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lower tail probabilities \n", + "\n", + "#### $P(Z\\leq z)$\n", + "\n", + "Shading the region $P(Z\\leq z)$ where $Z∼N(0,1)$ is the standard normal $N(0,1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAIiCAYAAAAq1htwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABysElEQVR4nO3deXhU1eE+8PfOnnWyTxYSkrCFyBLWAKKiBoNaK1Zb9GsLphYr1VZ/aW1Lq6DVNmqtxYWKS903bK1YLaIYCYiELWGHAAFC1smemWSyTDJzf39MMhhJIPuZ5f08zzwhkzs374ySvJw59xxJlmUZREREREQeSiE6ABERERHRcGLhJSIiIiKPxsJLRERERB6NhZeIiIiIPBoLLxERERF5NBZeIiIiIvJoLLxERERE5NFYeImIiIjIo6lEB3BFdrsd5eXlCAgIgCRJouMQERER0XfIsozGxkZER0dDobjwGC4Lbw/Ky8sRGxsrOgYRERERXURJSQlGjRp1wWNYeHsQEBAAwPECBgYGCk5DRERERN9lNpsRGxvr7G0XwsLbg65pDIGBgSy8RERERC6sL9NPedEaEREREXk0Fl4iIiIi8mgsvERERETk0Vh4iYiIiMijsfASERERkUdj4SUiIiIij8bCS0REREQejYWXiIiIiDwaCy8REREReTQWXiIiIiLyaCy8REREROTRWHiJiIiIyKO5ROFdu3Yt4uPjodPpkJqait27d/fpce+//z4kScLixYu73S/LMlatWoWoqCj4+PggLS0NJ0+eHIbkREREROTqhBfe9evXIzMzE6tXr0Z+fj6mTp2K9PR0VFVVXfBxRUVF+M1vfoPLLrvsvK89+eSTePbZZ7Fu3Trs2rULfn5+SE9PR2tr63A9DSIiIiJyUcIL79NPP43ly5cjIyMDycnJWLduHXx9ffHqq6/2+hibzYbbb78djzzyCBITE7t9TZZlrFmzBg8++CBuvPFGTJkyBW+++SbKy8uxYcOGYX42RERERORqhBZeq9WKvLw8pKWlOe9TKBRIS0tDbm5ur4/705/+hIiICNx5553nfe3MmTMwGo3dzqnX65GamnrBcxIRERGRZ1KJ/OY1NTWw2WwwGAzd7jcYDCgoKOjxMdu3b8c///lP7N+/v8evG41G5zm+e86ur31XW1sb2tranJ+bzea+PgUiIpfWYbPjdI0F1g47AECtVCAx3A9qpfA3+IiIRozQwttfjY2N+MlPfoKXX34ZYWFhQ3berKwsPPLII0N2PiIikeotVqzfW4JvCmuQf7YeFqut29d91EpMiwvCvDGhWDIrDuEBWkFJiYhGhtDCGxYWBqVSicrKym73V1ZWIjIy8rzjT506haKiItxwww3O++x2x6iFSqXC8ePHnY+rrKxEVFRUt3OmpKT0mGPlypXIzMx0fm42mxEbGzvg50VEJEKVuRUvf30a7+wqRvO3Sq6/VoUAnePHfVNbBxpbO7DjVC12nKrFc18V4rbZcVh+eSJignxERSciGlZCC69Go8GMGTOQnZ3tXFrMbrcjOzsb995773nHJyUl4dChQ93ue/DBB9HY2IhnnnkGsbGxUKvViIyMRHZ2trPgms1m7Nq1CytWrOgxh1arhVbLEQ4ick+yLOPfeaV4+L9HnKO5yVGB+NHMUZidEIoJkQFQKiQAgN0uo7C6CbvO1OHfe0twoNSE13cU4b3dxXjw+on48ZzRkCRJ5NMhIhpywqc0ZGZmYtmyZZg5cyZmz56NNWvWwGKxICMjAwCwdOlSxMTEICsrCzqdDpMmTer2+KCgIADodv/999+Pxx57DOPGjUNCQgIeeughREdHn7deLxGRuzM1t+MPHx3C/w5VAACmxgbh/qvHYcGE8B6Lq0IhYbwhAOMNAfhxahx2nKrFM1+exO6iOjz08RFsPVGNJ26eglB/DgIQkecQXniXLFmC6upqrFq1CkajESkpKdi0aZPzorPi4mIoFP27uOK3v/0tLBYL7rrrLjQ0NGD+/PnYtGkTdDrdcDwFIiIhSuqa8eN/7sLZ2maoFBL+38LxuPuKMc7R3IuRJAmXjg3D3MRQvLajCE98VoAvj1Xhe89tx9s/S8WYcP9hfgZERCNDkmVZFh3C1ZjNZuj1ephMJgQGBoqOQ0R0nsKqJvz4lV0wmlsxKtgHa/9vOqbGBg3qnMcqzLjn3XycrrYg1E+Dt+5MRXI0fwYSkWvqT1/jujRERG7maLkZS17MhdHcinER/vhwxbxBl10AmBgViH/9fC4uiQ5ErcWKW1/KRX5x/eADExEJxsJLRORGSuubsfTV3ai1WDEpJhDrfz4XhsChm64V6q/Fu8vnYMboYJhbO5Dx2h6crm4asvMTEYnAwktE5CYaW9tx5+t7UdPUhqTIALzzszkI8dMM+ffR+6jx1p2zkRIbBFNLO376+h7UW6xD/n2IiEYKCy8RkRvosNlx77v7cLyyEeEBWrx6xyzofdTD9v18NSq8vHQmYoJ8UFTbjJ+/nYe2DtvFH0hE5IJYeImI3MBfPz+OrSeqoVMr8M9lMxE9AptEhAdo8VrGLARoVdh9pg6PfHJ02L8nEdFwYOElInJxX5+sxovbTgMAnv5RCqaMChqx7z3eEIDn/m8aJAl4d1cxNh02jtj3JiIaKiy8REQurLapDb/+4AAA4Mdz4nDd5KiLPGLoLZgQgbsuTwQA/P4/B2E0tY54BiKiwWDhJSJyUbIs43cfHkRVYxvGRvjjj9clC8vy64UTMDlGj4bmdmR+sB92O5dwJyL3wcJLROSiPthbgi+PVUGtVODZW6fBR6MUlkWjUmDNrSnwUSux41QtXttRJCwLEVF/sfASEbmg2qY2/GVjAQDgrivGu8SOZ2PC/fHg9yYCAP72xXGUN7QITkRE1DcsvERELujPG4/B1NKOIP8ALEmNFx3H6bZZcZg5OhjNVhse+eSI6DhERH3CwktE5GJ2nKrBf/LLAAAzJk6CSuE6P6oVCgmP3TQJKoWEz49U4sujlaIjERFdlOv8FCUiIrR12PDghsMAgDGj4hCqDxIbqAdJkYG487IEAMDq/x6Bpa1DcCIiogtj4SUiciFv5Z7F6WoLdBoNJo8ZLzpOr+67ehxignxQ1tCClzrXCCYiclUsvERELsLU3I7nvioEAEwaMx4a9fBtHTxYvhoV/nCd4wK2l78+jSoz1+YlItfFwktE5CKe33ISppZ26P38ER89SnSci7puciRSYoPQbLXh71+eFB2HiKhXLLxERC6gpK4Zr+84CwCYMi4JCkkSnOjiJEnCH693jPKu31OMk5WNghMREfWMhZeIyAU89cVxtNvsiAgJRWRomOg4fTYrPgTXJBtgl4EnNhWIjkNE1CMWXiIiwY5VmPHx/nIAwNSxEyC5wejut/3u2iQoFRK+PFaFvLN1ouMQEZ2HhZeISLDnvnLMf401RCI4UC84Tf+NCffHLdMdc46fyS4UnIaI6HwsvEREAh03NmLjISMAIDlhrOA0A3fPlWOhVEjYdqIa+4rrRcchIuqGhZeISKCu0d1REQbo/QMEpxm4uFBf3DQtBgDwbDZXbCAi18LCS0QkyMnKRvzvUAUA9x7d7XJv5yjvluPVOFDSIDoOEZETCy8RkSDPbymELAMx4QYEBQSKjjNo8WF+uDElGgBHeYnItbDwEhEJUFLXjE8OOFZmSE4YIzjN0Ln3yrFQSEB2QRWOG7kuLxG5BhZeIiIB/rn9DOwyYAgJc8uVGXqTGO6P9EsiAQCvfH1acBoiIgcWXiKiEdbQbMUHe0sAABNGJwhOM/SWX54IANiwvwxV5lbBaYiIWHiJiEbcO7uK0Wy1Qe8fAENIqOg4Q256XDBmjg5Gu03G6zuKRMchImLhJSIaSW0dNrzRWQInjE5wu13V+qprlPedXcWwtHUITkNE3o6Fl4hoBP13fzmqGtvgo9Ui1hAlOs6wSZtoQEKYH0wt7fhX5/QNIiJRWHiJiEaILMv45/YzAIBxsfFQKjz3R7BSIeHO+Y75ya9+UwS7XRaciIi8mef+tCUicjF7iupRYGyEUqFAYkys6DjD7ubpoxCoU6G4rhlbT1SLjkNEXoyFl4hohLyZWwQAiIuMhkatFhtmBPholPjhTEex73ruREQisPASEY2AKnMrNh02AgDGxo4WnGbk/HiO47nmnKhGcW2z4DRE5K1YeImIRsB7u0vQYZcRqg9CsAdsI9xXCWF+uHx8OGQZeHvXWdFxiMhLsfASEQ2zdpsd7+52lD1vGt3tsrRzlPeDvSVobbcJTkNE3oiFl4homG0+WolKcxu0Gg1GRRhExxlxVyZFICbIBw3N7fjvgXLRcYjIC7HwEhENs3d3FQMAEqNjoVQoBacZeUqF5JzL2/VaEBGNJBZeIqJhVFLXjO2FNQCAxJhRgtOIc8uMUVApJOwvaUCB0Sw6DhF5GRZeIqJh9EHnLmOGkFD4+fgKTiNOeIAWaRMd0znW7+HOa0Q0slh4iYiGSYfNjn/tLQUAr9ho4mKWzHa8Bh/tK+PFa0Q0olh4iYiGybaT1TCaW6FRqxEdHiE6jnCXjwtHlF6HhuZ2fHG0UnQcIvIiLlF4165di/j4eOh0OqSmpmL37t29Hvuf//wHM2fORFBQEPz8/JCSkoK33nqr2zF33HEHJEnqdlu0aNFwPw0iom7e3+146z4+KsYrL1b7LqVCcu68tn4PL14jopEjvPCuX78emZmZWL16NfLz8zF16lSkp6ejqqqqx+NDQkLwxz/+Ebm5uTh48CAyMjKQkZGBzz//vNtxixYtQkVFhfP23nvvjcTTISICAFQ1tiK7wPFzLCHaey9W+64fzhgFSQK+KazlzmtENGKEF96nn34ay5cvR0ZGBpKTk7Fu3Tr4+vri1Vdf7fH4BQsW4KabbsLEiRMxZswY3HfffZgyZQq2b9/e7TitVovIyEjnLTg4eCSeDhERAOCj/DLYOndW0/sHiI7jMmJDfDF/bBgA4F95vHiNiEaG0MJrtVqRl5eHtLQ0530KhQJpaWnIzc296ONlWUZ2djaOHz+Oyy+/vNvXcnJyEBERgQkTJmDFihWora3t9TxtbW0wm83dbkREAyXLMj7Md1ysFs/R3fN0TWv4aF8Z7HZZcBoi8gZCC29NTQ1sNhsMhu47DxkMBhiNxl4fZzKZ4O/vD41Gg+uvvx7PPfccFi5c6Pz6okWL8OabbyI7OxtPPPEEtm7dimuvvRY2W89XBWdlZUGv1ztvsbG8mpqIBu5IuRknKpugUCgQGxEpOo7LuSbZgACtCqX1LdhdVCc6DhF5AZXoAAMREBCA/fv3o6mpCdnZ2cjMzERiYiIWLFgAALj11ludx06ePBlTpkzBmDFjkJOTg6uvvvq8861cuRKZmZnOz81mM0svEQ3Yf/LLAAAx4RHQqNWC07genVqJ6yZHYf3eEvwnvxRzEkNFRyIiDyd0hDcsLAxKpRKVld2Xp6msrERkZO+jIgqFAmPHjkVKSgp+/etf45ZbbkFWVlavxycmJiIsLAyFhYU9fl2r1SIwMLDbjYhoINptdnx8wFF4R0fFCE7jun4w3fHabDxkRIuVa/IS0fASWng1Gg1mzJiB7Oxs5312ux3Z2dmYO3dun89jt9vR1tbW69dLS0tRW1uLqKioQeUlIrqYbSeqUdtkhVajQWRImOg4LmtWfAhiQ3zQ1NaBL472PoWNiGgoCF+lITMzEy+//DLeeOMNHDt2DCtWrIDFYkFGRgYAYOnSpVi5cqXz+KysLGzevBmnT5/GsWPH8Le//Q1vvfUWfvzjHwMAmpqa8MADD2Dnzp0oKipCdnY2brzxRowdOxbp6elCniMReY+u6QxxhmgoFMJ/xLoshULCTdMcF/R92PmaERENF+FzeJcsWYLq6mqsWrUKRqMRKSkp2LRpk/NCtuLi4m6/NCwWC37xi1+gtLQUPj4+SEpKwttvv40lS5YAAJRKJQ4ePIg33ngDDQ0NiI6OxjXXXINHH30UWq1WyHMkIu9gamnH5mOOKVrxUdGC07i+H0yLwbPZJ7H9ZDUqza0wBOpERyIiDyXJssw1Yb7DbDZDr9fDZDJxPi8R9dn6PcX43YeHoPfzxzVz5kOSpCE57/2pEqIDhuZcrubmF3Yg72w9Hrx+In52WaLoOETkRvrT1/h+GxHREPl4fzkAIC4yesjKrqe7McUxEv7fA+WCkxCRJ2PhJSIaAlXmVuSedmxwExvJC2T76rrJUVAqJBwsNeFMjUV0HCLyUCy8RERD4JODFZBlIFQfBH8fX9Fx3EaYvxaXdm41/AlHeYlomLDwEhENga635OMiebFaf31/quM1+3h/GXhZCRENBxZeIqJBKqqx4EBJAySAWwkPQPolBmhUCpyqtuBohVl0HCLyQCy8RESD1PVWfERIGHRc/rDfAnRqXJ0UAYAXrxHR8GDhJSIaBFmW8bFzOgMvVhuormkNn+wvh93OaQ1ENLRYeImIBuFEZRMKq5qgkCTERBhEx3FbVyZFwF+rQrmpFftK6kXHISIPw8JLRDQIGw9VAAAiQ8OhUakFp3FfOrUSaRMd0xo+O2QUnIaIPA0LLxHRIHx22FF4R/FitUG7drJjSshnh41crYGIhhQLLxHRABVWNeFEpWM6Q3R4hOg4bu+K8eHw1ShR1tCCQ2Um0XGIyIOw8BIRDdCmztHdiJAwaNSczjBYOrUSV3au1rCR0xqIaAix8BIRDVBXKRvFi9WGzHWTuqY1VHBaAxENGRZeIqIBOFvr2CRBkiTEhLPwDpUFE8KhUytwtraZm1AQ0ZBh4SUiGoDPDjtGdyOCQ6DVaASn8Rx+WhWuGB8OANh0mNMaiGhosPASEQ3AZ4e4OsNwua5ztYb/HeK0BiIaGiy8RET9VFrfjAOljlUEOJ1h6F2VFAGNUoHT1RacrGoSHYeIPAALLxFRP3W91R4eFAKdVis4jecJ0Klx+fgwAOc29iAiGgwWXiKifuqavzvKwOkMw2VR52oNnMdLREOBhZeIqB+Mplbkna0HwOkMw2nhRANUCgkFxkacqua0BiIaHBZeIqJ+6NpsIlQfBF+dTnAaz6X3VePSsY5pDRzlJaLBYuElIuqHjV3TGbg6w7C7brLjNeY8XiIaLBZeIqI+qm5sw56iOgAsvCNhYXIklAoJR8rNKK5tFh2HiNwYCy8RUR99fsQIWQZCAvXw8/ERHcfjhfhpMCcxBIBjq2EiooFi4SUi6qNNnM4w4q7tXK3hM87jJaJBYOElIuoDc2s7dp6uBcDVGUbSNcmO13p/SQOqzK2C0xCRu2LhJSLqg5zj1eiwywjw9UOAn5/oOF4jIlCHqbFBAIDsgiqxYYjIbbHwEhH1wZdHKwFwdFeErlHerv8GRET9xcJLRHQR7TY7thx3jC5Gh0cITuN90iY6Cu/2who0WzsEpyEid8TCS0R0EXvO1KGxtQNatQYh+iDRcbzOeIM/YkN80NZhx9cna0THISI3xMJLRHQRm4853kqPCguHQpIEp/E+kiQ5R3k5rYGIBoKFl4joAmRZxmbO3xVuYWfh/aqgCja7LDgNEbkbFl4iogs4XtmI0voWKBUKGEJDRcfxWrMSQhCoU6HWYsX+knrRcYjIzbDwEhFdQNdb6BEhoVApVYLTeC+1UoErkxwXDH7BaQ1E1E8svEREF7D5WNfqDJzOIBrn8RLRQLHwEhH1osrcigMlDQCA6LBwsWEIV0wIh1op4VS1Baerm0THISI3wsJLRNSLLztHd0MC9fDR6gSnoUCdGnMSHfOos49x1zUi6jsWXiKiXnzZuRwZpzO4jq5pDZs5rYGI+oGFl4ioB83WDmwvdGxyEMPd1VzG1RMd/y32nq1DncUqOA0RuQsWXiKiHnx9sgbWDjv8fHwQ6OcvOg51GhXsi4lRgbDLwJYCTmsgor5h4SUi6kHXSgDRYRGQuLuaS1nYOcrbNeWEiOhiWHiJiL7DZpfxVefoIXdXcz0LkyMBAFtPVKO13SY4DRG5A5covGvXrkV8fDx0Oh1SU1Oxe/fuXo/9z3/+g5kzZyIoKAh+fn5ISUnBW2+91e0YWZaxatUqREVFwcfHB2lpaTh58uRwPw0i8hD7iutRa7FCrVIhLChYdBz6jkkxgTAEatFstSH3VK3oOETkBoQX3vXr1yMzMxOrV69Gfn4+pk6divT0dFRV9Tw3KyQkBH/84x+Rm5uLgwcPIiMjAxkZGfj888+dxzz55JN49tlnsW7dOuzatQt+fn5IT09Ha2vrSD0tInJj2Z2ju1Gh4VAohP+YpO+QJMm5WsNXnMdLRH0g/Cf5008/jeXLlyMjIwPJyclYt24dfH198eqrr/Z4/IIFC3DTTTdh4sSJGDNmDO677z5MmTIF27dvB+AY3V2zZg0efPBB3HjjjZgyZQrefPNNlJeXY8OGDSP4zIjIXXVdDBXF1Rlc1lWd2wx/VVAFWZYFpyEiVye08FqtVuTl5SEtLc15n0KhQFpaGnJzcy/6eFmWkZ2djePHj+Pyyy8HAJw5cwZGo7HbOfV6PVJTU3s9Z1tbG8xmc7cbEXmn8oYWFBgbIQGIDAkTHYd6MXdMKDQqBcoaWlBYxV3XiOjChBbempoa2Gw2GAzdLwoxGAwwGo29Ps5kMsHf3x8ajQbXX389nnvuOSxcuBAAnI/rzzmzsrKg1+udt9jY2ME8LSJyY1uOd+6upg+CVqMRnIZ646tRYW7nrmuc1kBEFyN8SsNABAQEYP/+/dizZw/+/Oc/IzMzEzk5OQM+38qVK2EymZy3kpKSoQtLRG5lS0E1ACAqLFxwErqYKyc4/ht1/SOFiKg3KpHfPCwsDEqlEpWV3ddSrKysRGRkZK+PUygUGDt2LAAgJSUFx44dQ1ZWFhYsWOB8XGVlJaKiorqdMyUlpcfzabVaaLXaQT4bInJ3re02fNO5u1pUGOfvurqrkgx4+JOj2FtUD3NrOwJ1atGRiMhFCR3h1Wg0mDFjBrKzs5332e12ZGdnY+7cuX0+j91uR1tbGwAgISEBkZGR3c5pNpuxa9eufp2TiLzP7jN1aGm3wUerRZB/gOg4dBFxob5IDPdDh13G9pM1ouMQkQsTOsILAJmZmVi2bBlmzpyJ2bNnY82aNbBYLMjIyAAALF26FDExMcjKygLgmG87c+ZMjBkzBm1tbdi4cSPeeustvPDCCwAcy9Xcf//9eOyxxzBu3DgkJCTgoYceQnR0NBYvXizqaRKRG+iaCxoZGs7d1dzEVRMicLr6DL4qqMJ1k6Mu/gAi8krCC++SJUtQXV2NVatWwWg0IiUlBZs2bXJedFZcXNxtHUyLxYJf/OIXKC0thY+PD5KSkvD2229jyZIlzmN++9vfwmKx4K677kJDQwPmz5+PTZs2QafTjfjzIyL3kdM5FzSa0xncxpVJEXhl+xnkHK+G3S5DoeA/VIjofJLMBQzPYzabodfrYTKZEBgYKDoOEY2A09VNuOpvW6GQJNx4RRrUKuHjAU73p0qIDmCR64m1w45pf/oCFqsN/733UkwZFSQ6EhGNkP70NbdcpYGIaKhtOe5YnSE8OMSlyi5dmEalwPxxjvWSu1bYICL6LhZeIiKc210tMpTLkbkb565rXJ6MiHrBwktEXs/S1oFdZ2oBcP6uO1owwfHf7GBpA2qa2gSnISJXxMJLRF5ve2EN2m0y/H184e/rKzoO9ZMhUIdLogMhy8DW45zWQETnY+ElIq/XtTpDVBiXI3NXV3aO8nLXNSLqCQsvEXk1WZa5nbAHuLJzHu+2E9XosNkFpyEiV8PCS0Re7VhFI4zmVigVSoQHhYiOQwOUEhuEYF81zK0dyC9uEB2HiFwMCy8RebWut8ANIaFQKpWC09BAKRUSrhjvGKHv2jGPiKgLCy8RebWu5cg4ncH9dU1ryOE8XiL6DhZeIvJaDc1W5BfXA2Dh9QSXjwuHQgIKjI0ob2gRHYeIXAgLLxF5re2FNbDLQKCfP3x1PqLj0CAF+2mQEhsEwHHxGhFRFxZeIvJaXaWIu6t5jivGO6Y1bGXhJaJvYeElIq8ky7KzFEWGhglOQ0PligmOf7xsP1mDdi5PRkSdWHiJyCudqGxCpbkNSoUC4UHBouPQEJkco0ewrxqNbR3YX9IgOg4RuQgWXiLySl3TGcKDuRyZJ1EqJFw2zjHKy22GiagLCy8ReSVOZ/BcXevxch4vEXVh4SUir9Ns7cCuM3UAWHg90WXjHf9ND5WZUNPUJjgNEbkCFl4i8jq7Tteh3WaHr84HAb5+ouPQEIsI0CE5KhCA4+I1IiIWXiLyOt+eziBJkuA0NBy6VmvgtAYiAlh4icgLbTvJ+buermse77YT1bDbZcFpiEg0Fl4i8ioldc04XW2BJEmICAkVHYeGyfS4YPhrVai1WHGk3Cw6DhEJxsJLRF6la3Q3VB8EjUotOA0NF41KgXljHP+g2XqiSnAaIhKNhZeIvMo2LkfmNTiPl4i6sPASkddot9nxTWEtACAyNFxwGhpul3duQJFf3ABza7vgNEQkEgsvEXmNfcUNaGrrgFatRnBAoOg4NMxiQ3yRGO4Hm13GjkIuT0bkzVh4ichrdM3lNHA5Mq/BXdeICGDhJSIvsu2EY5SP0xm8h7PwHq+GLHN5MiJvxcJLRF6hpqkNh8pMAIDIEF6w5i3mJIZCq1Kg3NSKwqom0XGISBAWXiLyCl1bzAb5B0Cn1QpOQyNFp1YiNbFreTJOayDyViy8ROQVnMuRhXE6g7fhPF4iYuElIo9nt8vnthPmdAav01V4d52pQ4vVJjgNEYnAwktEHu9ohRk1TVaolEqEBgWLjkMjbEy4H2KCfGDtsGPnmVrRcYhIABZeIvJ4XaO7EcGhUCr4Y8/bSJJ0bte145zWQOSN+JOfiDxeV8nhdsLeq2vXtW2cx0vklVh4icijNbV1IO9sPQAWXm82b2woVAoJp2ssKK5tFh2HiEYYCy8RebTcU7XosMvw9/GFv6+f6DgkSKBOjemjHfO3t57kKC+Rt2HhJSKP1rWdMEd36du7rhGRd2HhJSKPJcuyc+1VbidMXYU391QNrB12wWmIaCSx8BKRxyqqbUZJXQsUkoTw4BDRcUiw5KhAhPlrYbHanPO6icg7sPASkcfquiI/LCgYapVKcBoSTaGQcPl4x9SWnM6pLkTkHVh4ichjbeN0BvqOrmkN207UCE5CRCPJJQrv2rVrER8fD51Oh9TUVOzevbvXY19++WVcdtllCA4ORnBwMNLS0s47/o477oAkSd1uixYtGu6nQUQupK3Dhh2nHLtq8YI16jJ/bBgkCThWYUZVY6voOEQ0QoQX3vXr1yMzMxOrV69Gfn4+pk6divT0dFRV9fx2U05ODm677TZs2bIFubm5iI2NxTXXXIOysrJuxy1atAgVFRXO23vvvTcST4eIXEReUT1a2m3QabTQ+weIjkMuItRfi0nRegDA1xzlJfIawgvv008/jeXLlyMjIwPJyclYt24dfH198eqrr/Z4/DvvvINf/OIXSElJQVJSEl555RXY7XZkZ2d3O06r1SIyMtJ5Cw4OHomnQ0Quomut1cjQMEiSJDgNuZKuebzbuB4vkdcQWnitVivy8vKQlpbmvE+hUCAtLQ25ubl9OkdzczPa29sREtL9CuycnBxERERgwoQJWLFiBWpra4c0OxG5Nm4nTL25YnwEAODrkzWw22XBaYhoJAi9bLmmpgY2mw0Gg6Hb/QaDAQUFBX06x+9+9ztER0d3K82LFi3CD37wAyQkJODUqVP4wx/+gGuvvRa5ublQKpXnnaOtrQ1tbW3Oz81m8wCfERG5gkpzKwqMjQAAQwgLL3U3LS4I/loV6ixWHC43YcqoINGRiGiYufU6PY8//jjef/995OTkQKfTOe+/9dZbnX+ePHkypkyZgjFjxiAnJwdXX331eefJysrCI488MiKZiWj4da3OEBKoh1ajEZyGXI1aqcC8MaH44mgltp2oZuEl8gJCpzSEhYVBqVSisrKy2/2VlZWIjIy84GOfeuopPP744/jiiy8wZcqUCx6bmJiIsLAwFBYW9vj1lStXwmQyOW8lJSX9eyJE5FK2nXRcjGTgdAbqxeVcnozIqwgtvBqNBjNmzOh2wVnXBWhz587t9XFPPvkkHn30UWzatAkzZ8686PcpLS1FbW0toqKievy6VqtFYGBgtxsRuSebXcb2zouRorj+LvWiaz3e/OJ6NLa2C05DRMNN+CoNmZmZePnll/HGG2/g2LFjWLFiBSwWCzIyMgAAS5cuxcqVK53HP/HEE3jooYfw6quvIj4+HkajEUajEU1NTQCApqYmPPDAA9i5cyeKioqQnZ2NG2+8EWPHjkV6erqQ50hEI+dQmQn1ze1Qq1QICdSLjkMuKjbEFwlhfuiwy871monIcwmfw7tkyRJUV1dj1apVMBqNSElJwaZNm5wXshUXF0OhONfLX3jhBVitVtxyyy3dzrN69Wo8/PDDUCqVOHjwIN544w00NDQgOjoa11xzDR599FFotdoRfW5ENPK65u9GBId2+9lB9F1XjA/HmRoLtp6oRvolF55GR0TuTXjhBYB7770X9957b49fy8nJ6fZ5UVHRBc/l4+ODzz//fIiSEZG7cW4nHMbpDHRhl48Pw+s7irDtRDVkWeZ6zUQejMMfROQxTC3t2FfSAIDr79LFzUkMhUapQGl9C87UWETHIaJhxMJLRB5jR2ENbHYZgX5+8NP5iI5DLs5Xo8LMeMcunF3vDBCRZ2LhJSKPsbWztBhCOJ2B+sa5PNlJLk9G5MlYeInII8iyfG7+LqczUB9dPs5ReHNP1aKtwyY4DRENFxZeIvIIp6qbUG5qhVKhQHhwiOg45CYmRgUgPECLlnYb9hbVi45DRMOEhZeIPELOccfoblhQCFRKpeA05C4kSXKO8nIeL5HnYuElIo/QNQeT0xmovy4f7/h/ZisLL5HHYuElIrfX2m7DrtOO3bJYeKm/LhsXDkkCCoyNqDK3io5DRMOAhZeI3N6uM3Vo67DDR6tDoJ+/6DjkZkL8NJgc49iGmqs1EHkmFl4icnvfXp2Bu2XRQHTN4+W0BiLPxMJLRG5vK5cjo0HqWo93+8lq2Oyy4DRENNRYeInIrZU3tKCwqgkSAEMICy8NzLS4IPhrVahvbsfhMpPoOEQ0xFh4icitdU1nCNEHQaNWC05D7kqtVODSsaEAuDwZkSdi4SUit8bpDDRUzm0zzMJL5GlYeInIbXXY7Nhe2LX+brjgNOTuui5cyy9ugLm1XXAaIhpKLLxE5LYOlDagsbUDGrUawYF60XHIzcWG+CIxzA82u4wdhVyejMiTsPASkdva2rmdsCEkDAouR0ZDoGtaw9YTLLxEnoSFl4jc1lZuJ0xDrGub4W0nqiHLXJ6MyFOw8BKRW6q3WHGwtAEACy8NnTmJodAoFShraMHpGovoOEQ0RFh4icgtfV1YA1kG9P4B8NHqRMchD+GrUWFWQjAALk9G5ElYeInILXXN3+XoLg21rtUaWHiJPIeqPwc3NDTgo48+wtdff42zZ8+iubkZ4eHhmDZtGtLT0zFv3rzhyklE5GS3y871d6O4HBkNscvHhyPrswLknq5Fa7sNOrVSdCQiGqQ+jfCWl5fjZz/7GaKiovDYY4+hpaUFKSkpuPrqqzFq1Chs2bIFCxcuRHJyMtavXz/cmYnIyx0zmlHT1AaVUonQoGDRccjDJEUGICJAi9Z2O/YW1YuOQ0RDoE8jvNOmTcOyZcuQl5eH5OTkHo9paWnBhg0bsGbNGpSUlOA3v/nNkAYlIurSNbobERwKpYIzs2hoSZKEy8aF48P8Umw7WY354zhthsjd9anwHj16FKGhoRc8xsfHB7fddhtuu+021NbWDkk4IqKecP4uDbfLx4c5Cu+Javzhuomi4xDRIPVpaOTbZXfbtm2orr7wRP6LlWMiooFqbG1H3lnH28zcTpiGy2XjwiFJQIGxEZXmVtFxiGiQ+nXRGgBceeWVeP311xEYGIiDBw9CqVQiOTkZ3//+96HgW4tENMx2nKpFh12Gv68v/H19RcchDxXip8GUGD0OlJqw9UQ1fjQzVnQkIhqEfhdeWZZx9913AwCSkpJgs9lw4sQJxMfH49NPP0ViYuKQhyQi6tI1f5ejuzTcLh8fjgOlJmxj4SVyewMakl24cCFKS0uRl5eH/fv3o7i4GKNHj8avfvWroc5HROQky7Jz/m4U5+/SMLt8vOMfVdsLa2Czc5thInc2oML75z//GcHB55YCCgsLw+OPP46cnJyhykVEdJ5T1RaUNbRAoVAgPDhEdBzycCmxQQjQqtDQ3I5DZSbRcYhoEPpdeP39/dHU1HTe/U1NTdBoNEMSioioJ13TGcKDgqFS9ntGFlG/qJUKzBvruAibu64Rubd+F9758+fj5z//Ofbu3QvA8RZjbm4u7r77bixevHio8xEROXH+Lo20rmkNLLxE7q3fhXft2rXw9/fH7NmzodVqodVqMX/+fEycOBHPPPPMcGQkIkJruw27TjvW+Ob6uzRSLh/nKLz7ShpgamkXnIaIBqrf7wkmJCRg+/btOHz4MAoLC6FWq5GcnIyEhIThyEdEBADYeboWbR12+Gp1CPTzFx2HvERsiC8Sw/1wutqCHYU1uHZylOhIRDQAA54EN2nSJEyaNGkosxAR9co5nSEsHJIkCU5D3uTyceE4XW3BtpPVLLxEbmpId4r405/+hK+//nooT0lEBODcHEpOZ6CRdoVzHm8NZJnLkxG5oyEtvK+++irS09Nxww03DOVpicjLldQ141S1BZIkISKEW5fTyEpNDIFGqUBZQwtOVVtExyGiARjSwltUVITa2lqsWLFiKE9LRF5u20nH6G6oPggalVpwGvI2vhoVZiU41p7nag1E7mnICq/FYkFhYSF8fHxw3XXXDdVpiYicu6txOgOJ0rVaw1YWXiK31O+L1rZt29bj/YcPH8bq1atRXc0fBkQ0dKwdduw41bUcGdffJTGumBCOrM8KsPN0LVrbbdCplaIjEVE/9LvwLliwoMf7JUni3F0iGnL5xfVoauuAVq1BcECg6DjkpSYYAhAZqIPR3Irc07W4ckKE6EhE1A/9ntJQX1/f7VZTU4Ndu3Zh/vz5mD9//nBkJCIvtvVbqzNwOTISRZIkXJnUOa3hON/JJHI3/S68er2+2y0kJASzZs3CM888g7/85S8DCrF27VrEx8dDp9MhNTUVu3fv7vXYl19+GZdddhmCg4MRHByMtLS0846XZRmrVq1CVFQUfHx8kJaWhpMnTw4oGxGJxfm75CquGO8Y1c05XiU4CRH115BdtKZQKKDRaPr9uPXr1yMzMxOrV69Gfn4+pk6divT0dFRV9fwDJScnB7fddhu2bNmC3NxcxMbG4pprrkFZWZnzmCeffBLPPvss1q1bh127dsHPzw/p6elobW0d8PMjopFXZW7F0QozAMDAwkuCXTo2FCqFhKLaZhTVcHkyInciyf1cRfvgwYPn3VdZWYk//elPuOyyy3Drrbc6758yZcpFz5eamopZs2bh+eefBwDY7XbExsbil7/8JX7/+99f9PE2mw3BwcF4/vnnsXTpUsiyjOjoaPz617/Gb37zGwCAyWSCwWDA66+/3i1fb8xmM/R6PUwmEwIDOWeQSJR/55XiN/86gOBAPRbOnic6jjD3p0qIDuB0Dldw60u52Hm6Dg/fkIw7Lk0QHYfIq/Wnr/X7orWUlBRIktTjbjPffPMNnnjiCciyDEmSYLPZLnguq9WKvLw8rFy50nmfQqFAWloacnNz+5SnubkZ7e3tCAkJAQCcOXMGRqMRaWlpzmP0ej1SU1ORm5vbY+Fta2tDW1ub83Oz2dyn701Ew2srd1cjF7NgQgR2nq5DzolqFl4iN9LvwnvmzJkh++Y1NTWw2WwwGAzd7jcYDCgoKOjTOX73u98hOjraWXCNRqPzHN89Z9fXvisrKwuPPPJIf+MT0TCy2WV83bnhRBSXIyMXsWBCOB7/rAC5p7g8GZE76XfhHT169HDkGJDHH38c77//PnJycqDT6QZ8npUrVyIzM9P5udlsRmxs7FBEJKIBOljagIbmdqhVKoQE6kXHIQLgWJ4sSq9DhYnLkxG5kyHdWri/wsLCoFQqUVlZ2e3+yspKREZGXvCxTz31FB5//HF88cUX3eYKdz2uP+fUarUIDAzsdiMisbqmMxhCwqBQCP1RReQkSRIWTODyZETuRuhvEY1GgxkzZiA7O9t5n91uR3Z2NubOndvr45588kk8+uij2LRpE2bOnNntawkJCYiMjOx2TrPZjF27dl3wnETkWrZwOTJyUVyejMj99HtKw1DLzMzEsmXLMHPmTMyePRtr1qyBxWJBRkYGAGDp0qWIiYlBVlYWAOCJJ57AqlWr8O677yI+Pt45L9ff3x/+/v6QJAn3338/HnvsMYwbNw4JCQl46KGHEB0djcWLF4t6mkTUDzVNbThY2gAAiArj/F1yLd9dniw+zE90JCK6COGFd8mSJaiursaqVatgNBqRkpKCTZs2OS86Ky4u7vZ25gsvvACr1Ypbbrml23lWr16Nhx9+GADw29/+FhaLBXfddRcaGhowf/58bNq0aVDzfIlo5Gw9Xg1ZBoICAuGj5d9bci0BOjVmxgc7Vms4XoU7wrhaA5Gr6/c6vN6A6/ASiXXvu/n49GAFJsaPweSx40XHEY7r8LqeF7eeQtZnBVgwIRyvZ8wWHYfIK/Wnrw1oDu+VV16JO+6447z7r7rqKjz66KNobm4eyGmJiNBhs2Nb5wVrnM5ArmpB5+oMXcuTEZFrG1DhjY+PR3R09Hn3x8XFITs7G0lJSYMORkTeKb+4AebWDmjUaoTog0THIerReIM/ovQ6tHXYkXu6VnQcIrqIAc3hfe2113q8//XXXwfAncqIaOC2dF75HhkaBoXEt/HJNXUtT/be7hJsPV7N9XiJXNyQLkvWNZWB816JaKC2FDgKL3dXI1fH5cmI3Ee/C+/VV1+NsrKy8+7fvXs3UlJShiITEXmpClMLCoyNAIBIFl5ycd9dnoyIXFe/C69Op8OUKVOwfv16AI6NIh5++GHMnz8f11133ZAHJCLvsaXAcbFaqD4IWo1GcBqiCwvQqTErPgTAuak4ROSa+j2H93//+x/Wrl2Ln/70p/j4449RVFSEs2fP4tNPP8U111wzHBmJyEt0lQZOZyB3cWVSOHJP1+KrgipkXMr1eIlc1YAuWrvnnntQWlqKJ554AiqVCjk5OZg3b95QZyMiL9LWYcM3hTUAuBwZuY+rkgz4y8YC7DpdB0tbB/y0wvdzIqIe9HtKQ319PW6++Wa88MILePHFF/GjH/0I11xzDf7xj38MRz4i8hK7z9Sh2WqDTqNFUAAvfCX3MCbcD3EhvrDa7Nje+Q82InI9/S68kyZNQmVlJfbt24fly5fj7bffxj//+U889NBDuP7664cjIxF5ga75u1Fh4ZC4HBm5CUmScFWSY7WGrhVGiMj19Lvw3n333di2bRsSEs7NVVqyZAkOHDgAq9U6pOGIyHvkcP4uuamrJzoK71cFVbDbZcFpiKgn/S68Dz30EBSK8x82atQobN68eUhCEZF3Kaqx4HSNBZIkwRAaKjoOUb/MTgiBr0aJqsY2HCnnxktErqhPhbe4uLhfJ+1pnV4iot50rc4QHhQMtUotOA1R/2hVSlw2LgyAY5SXiFxPnwrvrFmz8POf/xx79uzp9RiTyYSXX34ZkyZNwocffjhkAYnI82057pi/G8nVGchNXZ1kAAB8VVApOAkR9aRP66ccPXoUf/7zn7Fw4ULodDrMmDED0dHR0Ol0qK+vx9GjR3HkyBFMnz4dTz75JDegIKI+a7Z2YOfpWgBAdFiE4DREA7MgyfGPtQOlJlQ3tiE8QCs4ERF9W59GeENDQ/H000+joqICzz//PMaNG4eamhqcPHkSAHD77bcjLy8Pubm5LLtE1C/fFNbC2mGHn84HAb5+ouMQDUhEgA5TRukBcNc1IlfUpxHegwcPYtKkSfDx8cEtt9yCW265ZbhzEZGXyD7meAs4KiyCy5GRW7tyQgQOlprw1bEq/GhmrOg4RPQtfRrhnTZtGmpqHAtqJyYmora2dlhDEZF3sNtlfHnMMRoWHc75u+TeupYn+/pkNawddsFpiOjb+lR4g4KCcObMGQBAUVER7Hb+RSaiwTtYZkJNUxtUSiXCg0NExyEalEnReoQHaGGx2rD7TJ3oOET0LX2a0nDzzTfjiiuuQFRUFCRJwsyZM6FUKns89vTp00MakIg8V9d0hsjQcCgVPf9MIXIXCoWEKyeE44O9pfiqoArzO5cqIyLx+lR4X3rpJfzgBz9AYWEhfvWrX2H58uUICAgY7mxE5OGc0xm4OgN5iKuSDPhgbymyCyrx0Pcmcl46kYvoU+EFgEWLFgEA8vLycN9997HwEtGglDW04FiFGRKAKK6/Sx5i/rgwaJQKnK1txukaC8aE+4uOREQYwNbCr732GssuEQ3aV53TGUL1wdBqNILTEA0Nf60KqYmO+ehbuOsakcvod+ElIhoKmzunM0RxdQbyMFclOaboZB9j4SVyFSy8RDTimto6sPOUY3nDmHCD4DREQ6ur8O4pqoOppV1wGiICWHiJSIDtJ6thtdnh7+PL3dXI44wO9cPYCH902GVsPVEtOg4RgYWXiAToWp2Bu6uRp1qY7HjnYvPRSsFJiAhg4SWiEWazy86LeaLDuRwZeaauwptTUMVd14hcAAsvEY2o/SUNqLVYoVapEB4ULDoO0bBIGRWEMH8tGts6sPN0reg4RF6PhZeIRtSX39pdTaHgjyDyTAqFhLSJjncwOK2BSDz+tiGiEdW1nTCnM5Cn65rW8OWxSsiyLDgNkXdj4SWiEVNS14wTlU2QJAlRoVx/lzzbpWPD4KNWosLUisNlZtFxiLwaCy8RjZiu6Qxh+mBo1GrBaYiGl06txOXjwwAAm48aBach8m4svEQ0Yrp2nuJ0BvIWC5MjAQBfcB4vkVAsvEQ0IkzN7c6r1aPDWHjJO1yVFAGFBBQYG1FS1yw6DpHXYuElohHx1fFKdNhlBPr5I8CPu6uRdwjx02BmfAgArtZAJBILLxGNiM8PO37Zx4QbBCchGlnXcNc1IuFYeIlo2LW227D1RDUAICaChZe8S9fyZLuL6tDQbBWchsg7sfAS0bDbdqIaLe02+Op0CA4IFB2HaESNDvXDeIO/Y1vt41Wi4xB5JRZeIhp2nx85N51BkiTBaYhG3kJOayASioWXiIZVh82O7ALO3yXv1rU82dbj1WjrsAlOQ+R9WHiJaFjtPlOHhuZ2aNVqhAUFi45DJMSUGD0iArSwWG3YcapWdBwiryO88K5duxbx8fHQ6XRITU3F7t27ez32yJEjuPnmmxEfHw9JkrBmzZrzjnn44YchSVK3W1JS0jA+AyK6kM+POHaYig43QKEQ/iOHSAiFQkIapzUQCSP0t8/69euRmZmJ1atXIz8/H1OnTkV6ejqqqnqe1N/c3IzExEQ8/vjjiIyM7PW8l1xyCSoqKpy37du3D9dTIKILkGXZucMUpzOQt/v28mR2uyw4DZF3EVp4n376aSxfvhwZGRlITk7GunXr4Ovri1dffbXH42fNmoW//vWvuPXWW6HVans9r0qlQmRkpPMWFhY2XE+BiC7gYKkJFaZWqJRKGEJCRcchEmremDAE6FSobmxDXnG96DhEXkVY4bVarcjLy0NaWtq5MAoF0tLSkJubO6hznzx5EtHR0UhMTMTtt9+O4uLiCx7f1tYGs9nc7UZEg9c1nSEyNBxKpVJwGiKxNCoF0iY6Rnk3HqoQnIbIuwgrvDU1NbDZbDAYur/NaTAYYDQaB3ze1NRUvP7669i0aRNeeOEFnDlzBpdddhkaGxt7fUxWVhb0er3zFhsbO+DvT0TndBXeUdxsgggAcO0kx3S8zw8bIcuc1kA0UjzuCpJrr70WP/zhDzFlyhSkp6dj48aNaGhowAcffNDrY1auXAmTyeS8lZSUjGBiIs9UWNWEU9UWKCQJkWHhouMQuYTLx4fDV6NEuakVB0pNouMQeQ1hhTcsLAxKpRKVld2vVq2srLzgBWn9FRQUhPHjx6OwsLDXY7RaLQIDA7vdiGhwukZ3I0JCoVGpBachcg06tRJXJkUAAD47zGkNRCNFWOHVaDSYMWMGsrOznffZ7XZkZ2dj7ty5Q/Z9mpqacOrUKURFRQ3ZOYno4r7oLLxcnYGou+smOX4ffXaI0xqIRorQKQ2ZmZl4+eWX8cYbb+DYsWNYsWIFLBYLMjIyAABLly7FypUrncdbrVbs378f+/fvh9VqRVlZGfbv399t9PY3v/kNtm7diqKiIuzYsQM33XQTlEolbrvtthF/fkTeqsLU4ny7loWXqLsFE8KhVSlQXNeMoxW8SJpoJKhEfvMlS5aguroaq1atgtFoREpKCjZt2uS8kK24uLjbQvXl5eWYNm2a8/OnnnoKTz31FK644grk5OQAAEpLS3HbbbehtrYW4eHhmD9/Pnbu3InwcM4hJBopXxxxTFUK0wdDd4ElBIm8kZ9WhSvGh+OLo5XYdNiIS6L1oiMReTxJ5vsp5zGbzdDr9TCZTJzPSzQAS17Mxa4zdZg6LgkTRieIjuP27k+VEB0giY5BQ2jDvjLcv34/xkb448vMK0THIXJL/elrHrdKAxGJVWVuxe6iOgDAKMPQXYBK5EmumhgBtVJCYVUTTlb2vmwmEQ0NFl4iGlKfHTZCloFQfRD8dD6i4xC5pECdGvPHOnYB/ezwwNeeJ6K+YeEloiH1v4OOpZZGRXB0l+hCrp3cuVoDCy/RsGPhJaIhYzS1Ys9Zx3SGWE5nILqghRMNUCokHKswo6jGIjoOkUdj4SWiIfPZ4QrndAZfTmcguqBgPw3mjQkFwFFeouHGwktEQ2bjIcd0hlgDN3oh6otFkxzvhGzirmtEw4qFl4iGhNHUij1F9QA4f5eor65JjoQkAQdKTSitbxYdh8hjsfAS0ZDoGt0NCwqGr04nOA2RewgP0GJ2fAgAYBOnNRANGxZeIhoS/zvE1RmIBuL6KY4pQJ8cKBechMhzsfAS0aCVN7Qg7yynMxANxHWTo6BUSDhQauJqDUTDhIWXiAaN0xmIBi7MX+tcrYGjvETDg4WXiAaNqzMQDc73p0YDAP57oByyLAtOQ+R5WHiJaFDKGlqQX9wAABgVYRAbhshNXXNJJDRKBU5WNeF4ZaPoOEQeh4WXiAbls87R3fCgEPhoOZ2BaCD0PmosmBAOAPjvfk5rIBpqLLxENCifHuxcnYFbCRMNyvdTHNMaPjnIaQ1EQ42Fl4gGrLS+GftLGgBwdQaiwbo6yQBfjRIldS3Y1/n3ioiGBgsvEQ3Yx51vvUYEh8BHqxWchsi9+WiUWJjsmAfP1RqIhhYLLxENiCzL+GhfGQAgLjJacBoiz9C1WsOnBytgs3NaA9FQYeElogE5Um5GYVUTFAoF5+8SDZHLxoVD76NGdWMbdp2uFR2HyGOw8BLRgHy83zG6Gx0WAY1KLTgNkWfQqBS4brLjH5D/5bQGoiHDwktE/Wazy875u6OjOJ2BaCjdMMXxd+qzw0ZYO+yC0xB5BhZeIuq33FO1qGpsg0atRmRouOg4RB4lNTEUEQFamFra8fXJatFxiDwCCy8R9VvXxWqxhigoFfwxQjSUlAoJ109xbNPNaQ1EQ4O/qYioX1qsNmw67NhsYjRXZyAaFl2rNWw+Wolma4fgNETuj4WXiPpl87FKWKw2+Pn4IFQfJDoOkUdKiQ1CXIgvmq02fH7EKDoOkdtj4SWiftnQOZ1hdGQ0JEkSnIbIM0mShJunjwIAfJhXJjgNkftj4SWiPqttasPWE46LaLjZBNHw+sH0GADAN6dqUN7QIjgNkXtj4SWiPuva/SkkUI9AP3/RcYg8WmyIL1ITQiDL5y4UJaKBYeEloj7jVsJEI+uWGV3TGkohy9xqmGigWHiJqE/O1Fiwv6QBkiQhzhAlOg6RV7h2chR81EqcrrEgv7hBdBwit8XCS0R90nWxmiEkDDqtVnAaIu/gr1Xh2s6thj/MLxWchsh9sfAS0UXJsowN+ztXZ+BWwkQj6pbO1Ro+OVCO1nab4DRE7omFl4guaufpOpytbYZKqURMeIToOEReZU5iKGKCfNDY2oHNRytFxyFySyy8RHRRH+wtAeC4WE2lVAlOQ+RdFArJuUQZpzUQDQwLLxFdkKmlHRsPObYSTogeJTgNkXf6Qee0hm0nqlFpbhWchsj9sPAS0QX990A52jrs0Pv5IyRQLzoOkVdKCPPDjNHBsMvnLiAlor5j4SWiC1q/pxgAkBATy62EiQRyrsmbzzV5ifqLhZeIenWk3ITDZWYoJAmjudkEkVDXT4mCVqXAicomHCoziY5D5FZYeImoVx/scVysFhNhgFajEZyGyLsF6tS45pLONXnzePEaUX+w8BJRj1rbbc6thN3tYrX8j/+BF3+ciKev88Xbv5yLioLdfXrcsS3v468Llfho9U3d7pdlGdtfX41/LInB36/3w/rfXoP60pPdjmkx1+HTrB/jmRuD8OziEGz6289gbWkasudEBJyb1vDRvjKuyUvUDyy8RNSjz48YYW7tgK/OB4aQMNFx+qwgZz1yXvw15v34ISx9YS/CE6fgXyuvhaW+6oKPMxmLkPPSbzFq8mXnfW33+r8if8NzWHjfP3D7c7nQ6Hzxr5XXosN67mr5/z3+Y9QUHcUPH/8cP3jsvyg5+DW++PvPh/z5kXe7bGwYRgX7wNzagU8PVoiOQ+Q2hBfetWvXIj4+HjqdDqmpqdi9u/eRmCNHjuDmm29GfHw8JEnCmjVrBn1OIurZ+s7pDAnRMW51sdreD9dgyrU/w+RFGQgbnYxr7nsBaq0vDn/+Wq+Psdts+DTrJ7h06WroIxO6fU2WZeR99Azm3P5HjJt3IyISp+C6372BptpynPxmAwCg9uwxnNnzORZlvoToiakYNWk+0u59Bsdy1qOppnw4ny55GYVCwm2z4wAA7+w6KzgNkfsQWnjXr1+PzMxMrF69Gvn5+Zg6dSrS09NRVdXzSExzczMSExPx+OOPIzIyckjOSUTnK65txo5TtQCAeDeazmBrt8J4Ig+jp1/tvE9SKDB6+tUoP5rb6+N2vP0ofIPDMeXaO8/7msl4BpY6I0ZPO3dOrZ8eUUmpKD+6EwBQfiwXWv8gRE6Y6Txm9PQ0SJIC5QW7huKpETn9aGYsVAoJ+4obcLTcLDoOkVsQWniffvppLF++HBkZGUhOTsa6devg6+uLV199tcfjZ82ahb/+9a+49dZbodVqh+ScRHS+rp3VDCFh8NP5CE7Tdy2mGsh2G3yDDd3u9w02wFLf85aspYe349CmV5H+/17q8euWOiMAwO875/QLjoCl3th5TCV8g7pvuaxQquATGOI8hmiohAdokd558dq7uznKS9QXwgqv1WpFXl4e0tLSzoVRKJCWlobc3N5HYkb6nETexmaX8e/OK8ATY9xndHcgrM2N2PjEMqT/vxfhq3efecpEt6c6pjVs2FcOS1uH4DRErk8l6hvX1NTAZrPBYOg+amIwGFBQUDCi52xra0NbW5vzc7OZbxGR99p2ohpGcys0ajWiwyMu/gAX4qMPg6RQovk7o7nN9ZXnjdACQH35KZiMRfjPQzc675NlOwDgqXQN7nztGPxCHCNplvpK+IdGOY+z1FchYsxUAIBfiAHNDd2nTdltHWgx18EvuOfpV0SDMXdMKBLC/HCmxoL/Hih3zuslop4Jv2jNFWRlZUGv1ztvsbGxoiMRCfPubsfOaqMjY6BUKAWn6R+lWoPI8TNwdt9Xzvtkux1n932F6OS55x0fGpeEO146gGXr8p23sXNvQNzUK7FsXT4Cw2Ohj0yAX0gkir91zjaLGRUFuxCdPAcAED1xLtqaGmA8kec85uy+ryDLdkQnpQ7jMyZvJUkS/q+z5L67q1hwGiLXJ6zwhoWFQalUorKy+0hMZWVlrxekDdc5V65cCZPJ5LyVlJQM6PsTubuyhhZkH3P8/Rkzyj3/4Tfz5vtxcOMrOPzFG6g9ewxfPPsLtLdaMCn9DgDA/55Yhm3//AMAQKXRITxhUreb1i8IGl9/hCdMglKtgSRJmHHTfch9988o3PFfVJ85hI1PLoN/aDTGXboYABA6eiISZqXj87//HBUFu1F6+BtkP/8rTFywBP5h3KGOhsfNM0ZBo1TgUJkJB0sbRMchcmnCCq9Go8GMGTOQnZ3tvM9utyM7Oxtz554/EjOc59RqtQgMDOx2I/JG7+0qhl0GIoJDEejnLzrOgCQtWIIFd/0V37zxMN5YMR3Vpw7glr9sdE5paKwqQVNt/9Yvnb3kAUy/8V58vuZuvHVPKqwtFtyStREqjc55zPW/fxuhsROw/rcL8eEfv4eYSZfimv/34pA+N6JvC/HT4LrJnRevcZSX6IIkWZZlUd98/fr1WLZsGV588UXMnj0ba9aswQcffICCggIYDAYsXboUMTExyMrKAuC4KO3o0aMAgOuuuw633347br/9dvj7+2Ps2LF9OmdfmM1m6PV6mEwmll/yGtYOO+Y9no2aJivmTZ6GUQbOPXUV96dKiA5wn7WQaeTsPlOHH72YCx+1Erv+eDUCdWrRkYhGTH/6mrCL1gBgyZIlqK6uxqpVq2A0GpGSkoJNmzY5i2lxcTEUinOD0OXl5Zg2bZrz86eeegpPPfUUrrjiCuTk5PTpnETUs01HjKhpskKn0brdxWpE3mpWfDDGRfjjZFUTPt5Xhp/MjRcdicglCR3hdVUc4SVv9KMXc7H7TB2SE8Zi0phxouPQt3CEly7ktW/O4JFPjiIpMgCf3XeZW+2MSDQY/elrXKWBiHDc2IjdZ+ogSRISY9zzYjUib/WDaaOgUytQYGxEfnG96DhELomFl4jwRm4RACA6LAK+Ot2FDyYil6L3VeOGKY7VQN7YwZ3XiHrCwkvk5RqarfhPvmNntXFxowWnIaKBWDYvHgCw8VAFKs2tYsMQuSAWXiIv9/6eErS22xHkH4DwoBDRcYhoACbF6DErPhgddhlv7+QoL9F3sfASebEOmx1v7igCAIyLi+fFLkRuLOPSBACONXlb222C0xC5FhZeIi+2+Wglyk2t0KrViDNEiY5DRINwTbIB0Xodai1WfHKgXHQcIpfCwkvkxV77pggAkBgTB6VSKTYMEQ2KSqlwrsP72jdF4KqjROew8BJ5qcNlJuwucixFNjY2TnQcIhoCt82OhU6twNEKM3adqRMdh8hlsPASeamXvz4NAIg1RMJHy6XIiDxBkK8GN08fBQB4pfPvOBGx8BJ5pbKGFnx6sAIAMCEuQXAaIhpKd85PgCQBXx6rQmFVk+g4RC6BhZfIC722/QxsdhkRwaEIDtSLjkNEQygx3B9pEw0AgH9u5ygvEcDCS+R1TC3teG93MQBgwmiO7hJ5orsuTwQAfJhfhurGNsFpiMRj4SXyMu/vLobFakOgnz8iQ8NExyGiYTBzdDBSYoNg7bDjrc6tw4m8GQsvkRexdtidS5FNGJ3AjSaIPJQkSc5R3jd3nkWztUNwIiKxWHiJvMhH+0phNLdCp9EiLpIbTRB5svRLIjE61BcNze14b3eJ6DhEQrHwEnkJm13Guq2OC1gmjE6AUsGNJog8mVIh4eeXjwEAvLztNNo6uN0weS8WXiIv8dnhCpypsUCjUiMxJlZ0HCIaATfPiIEhUAujuRUb9pWJjkMkDAsvkReQZRlrt5wCAIyLGw21SiU4ERGNBK1KieWXOebyvpBzCjY7txsm78TCS+QFco5X41iFGSqlEmNjR4uOQ0Qj6LbZcQj2VaOothkbD1WIjkMkBAsvkYeTZRnPbykEAIwZFQetWiM4ERGNJD+tChmXOtbcXrulEHaO8pIXYuEl8nDfFNYi72w9FAoFxsfFi45DRAIsmxsPf60KBcZGfHG0UnQcohHHwkvkwWRZxt+/PAEAGBMTCx+tTnAiIhJB76tGxqXxAIA1X57gKC95HRZeIg+2vbAGeWfroVQokBSfKDoOEQl05/wEBDhHeY2i4xCNKBZeIg8lyzLWfHkSAJDI0V0irxfkq/nWKO9JjvKSV2HhJfJQHN0lou/6KUd5yUux8BJ5IFmW8bcvHHN3E2PiOLpLRAC6j/I+vfkE1+Ulr8HCS+SBvjhaif0lDVAqlBzdJaJu7rwsEYE6FU5UNuHj/dx9jbwDCy+Rh7HZZTz1+XEAwPi4ePhotYITEZEr0fuocfeCMQAco7zWDrvgRETDj4WXyMNs2FeGk1VN0KjUmDA6QXQcInJBGfMSEBGgRWl9C97bXSw6DtGwY+El8iBtHTY8vdkxdzcpPhEatVpwIiJyRT4aJX559TgAwHNfFcLS1iE4EdHwYuEl8iDv7ipGWUMLdBotxsaOFh2HiFzYkpmxiAvxRU1TG17dfkZ0HKJhxcJL5CFMLe14Ntux7u4liWOhUioFJyIiV6ZRKfDra8YDANZtPYWqxlbBiYiGDwsvkYdYu6UQ9c3tCPTzR0L0KNFxiMgN3DAlGlNH6WGx2vD3zSdFxyEaNiy8RB6guLYZr31TBACYOi4JCgX/ahPRxSkUEh78XjIAYP2eYhw3NgpORDQ8+FuRyAM8sakA7TY7DCGhiAwNEx2HiNzIrPgQLLokEnYZ+PPGY6LjEA0LFl4iN7e3qA7/O1QBwDG6K0mS4ERE5G5+f20S1EoJ205UI+d4leg4REOOhZfIjdnsMlb/9wgAICF6FIICAgUnIiJ3FB/mh6Vz4wEAf/rkKDejII/Dwkvkxt7bXYwj5WaoVSpMHjtedBwicmP3pY1DmL8Gp2ssePUbLlNGnoWFl8hN1Vuszi2EJ40ZD52GWwgT0cAF6tT4/bUTAQDPZZ+E0cRlyshzsPASuam/fnEcDS3t0PsHYExMrOg4ROQBfjAtBtPjgmCx2pD1GS9gI8/Bwkvkhg6UNOC93cUAgOkTkrkMGRENCYVCwp9unARJAj7eX47cU7WiIxENCf6WJHIzHTY7Vv7nEGQZiIuMRnhwiOhIRORBJsXocXtqHADgjx8dQmu7TXAiosFzicK7du1axMfHQ6fTITU1Fbt3777g8f/617+QlJQEnU6HyZMnY+PGjd2+fscdd0CSpG63RYsWDedTIBoxr31ThKMVZmjUaqSMTxIdh4g80APpSQgP0OJ0jQUv5JwSHYdo0IQX3vXr1yMzMxOrV69Gfn4+pk6divT0dFRV9bwO4I4dO3DbbbfhzjvvxL59+7B48WIsXrwYhw8f7nbcokWLUFFR4by99957I/F0iIZVSV0znt58AgAwZewEXqhGRMNC76PGwzdcAgB4IecUCquaBCciGhzhhffpp5/G8uXLkZGRgeTkZKxbtw6+vr549dVXezz+mWeewaJFi/DAAw9g4sSJePTRRzF9+nQ8//zz3Y7TarWIjIx03oKDg0fi6RANG1mWserjw2hptyE8KAQJ0aNERyIiD3bd5EhclRQBq82OP3x0CHa7LDoS0YAJLbxWqxV5eXlIS0tz3qdQKJCWlobc3NweH5Obm9vteABIT08/7/icnBxERERgwoQJWLFiBWpre59439bWBrPZ3O1G5Gr+k1+GLceroZAkzJh4CXdUI6JhJUkS/nTjJfDVKLH7TB3e3nVWdCSiARNaeGtqamCz2WAwGLrdbzAYYDQae3yM0Wi86PGLFi3Cm2++iezsbDzxxBPYunUrrr32WthsPU+8z8rKgl6vd95iY7nEE7mWSnMrHvnEsaPaJYnjEOjnLzgREXmDUcG++N0ix7UCWRsLUFzbLDgR0cAIn9IwHG699VZ8//vfx+TJk7F48WJ8+umn2LNnD3Jycno8fuXKlTCZTM5bSUnJyAYmugBZlrHyP4dgbu1ASKAeE0YniI5ERF7kJ3NGY05iCFrabXjg3wc4tYHcktDCGxYWBqVSicrKym73V1ZWIjIyssfHREZG9ut4AEhMTERYWBgKCwt7/LpWq0VgYGC3G5Gr+HdeKb4qqIJCkjAreTLX3CWiEaVQSHjy5qnw1Six60wd3swtEh2JqN+E/ubUaDSYMWMGsrOznffZ7XZkZ2dj7ty5PT5m7ty53Y4HgM2bN/d6PACUlpaitrYWUVFRQxOcaISU1DXjkU+OAgAuGTMOev8AwYmIyBvFhfpi5bWOqQ2PbypAYVWj4ERE/SN8qCgzMxMvv/wy3njjDRw7dgwrVqyAxWJBRkYGAGDp0qVYuXKl8/j77rsPmzZtwt/+9jcUFBTg4Ycfxt69e3HvvfcCAJqamvDAAw9g586dKCoqQnZ2Nm688UaMHTsW6enpQp4j0UB02Oz4f+v3o6mtA6H6IEyI41QGIhLn9tTRuGxcGFrb7fjVe/vR1sENKch9CC+8S5YswVNPPYVVq1YhJSUF+/fvx6ZNm5wXphUXF6OiosJ5/Lx58/Duu+/ipZdewtSpU/Hvf/8bGzZswKRJkwAASqUSBw8exPe//32MHz8ed955J2bMmIGvv/4aWi3XLCX3sXbLKew9Ww+1UoXUSVM5lYGIhFIoJDz1w6kI9lXjaIUZf/vihOhIRH0mybLM2effYTabodfrYTKZOJ+XhMg7W48fvZgLm11G6iVTMDoqRnQkEuj+VAnRAVyGjlzD5qOVWP7mXgDA23emYv64MMGJyFv1p69xyIjIxTQ0W/Gr9/bBZpcRFxnNsktELmVhsgG3p8YBAO5fvx9Vja2CExFdHAsvkQux22VkfnAAZQ0t8PfxxfSkZNGRiIjO8+D1yZhgCEBNUxt+9d4+dNjsoiMRXRALL5ELWbftlGMJMoUCc6dMg0alFh2JiOg8Phol/vHj6fDTKLHzdB3+/iXn85JrY+ElchG5p2rx1OfHAQDTJyQjOIDzx4nIdY0J98fjN08B4LjI9quCyos8gkgcFl4iF1BS14x73s2HXQZGR8UgIXqU6EhERBd1w9RoLJ07GgBw33v7caq6SXAiop6x8BIJ1mztwPI396LOYkVwQCBmJF0CSeIV+UTkHh68Phmz4oPR2NaB5W/shamlXXQkovOw8BIJJMsyfvOvAygwNkKr0eDSqdOhUipFxyIi6jONSoF/3D4D0XodTtdYnKvMELkSFl4igZ7efAIbDxmhkCRcOmU6fHU+oiMREfVbeIAWLy2dCZ1aga0nqvHop0dFRyLqhoWXSJD1e4rx3FeFAIDpSZcgLChYcCIiooGbFKPHUz+cCgB4fUcR/rn9jOBEROew8BIJsPVENf7w0WEAQHLCGCTGxApOREQ0eN+bEo2V1yYBAB7731F8dqhCcCIiBxZeohF2sLQBv3g7Dza7jNGR0bgkcZzoSEREQ+auyxPx4zlxkGXHTmy7TteKjkTEwks0kk5WNmLZq7thsdoQERyKmcmTuSIDEXkUSZLw8A2XIG1iBNo67Ljzjb04VGoSHYu8HAsv0Qgprm3G7a/sQn1zO0IC9bh06nQoFfwrSESeR6VU4Pn/m47UhBA0tXVg2Wu7UVjVKDoWeTH+tiUaAWUNLbj9lZ2oamyD3s8fl02bCbVKJToWEdGw0amVeGXZTEwZpUedxYrbX9mFMzUW0bHIS7HwEg2zkrpmLHkxFyX1LfD38cXl02dBq9aIjkVENOwCdGq8njEb4w3+qDS34daXcrkbGwnBwks0jErqmnHrSztR2ll2F8yYDR+tTnQsIqIRE+KnwbvL5zhL720v7URhFUsvjSwWXqJhcrKyET96MRdlDS0I8PXDghmp3FiCiLxSmL8W7y2fg6TIAFQ1OkZ6D5fxQjYaOSy8RMMgv7geP1yXiwpTKwL9/LBgxmz46jiyS0TeK9Rfi3eXz8El0YGoabLi1pd2IvcUlyyjkcHCSzTEco5X4faXd6GhxbEaw5Uz5nAaAxERHNMb3rtrTrfVGzYd5uYUNPxYeImG0Fu5Rfjp63vQ0m6DISQMV0yfDa2GF6gREXUJ1Knxxk9n45pkA6wddqx4Jx8vbj0FWZZFRyMPxsJLNARsdhmPfHIED318BHYZiI+KwfyUGVx6jIioBzq1Ev+4fTp+Mmc0ZBnI+qwAv//wEKwddtHRyEOx8BINUp3Fijte243XvikCAEweMx6zkidzUwkiogtQKRV4dPEkPHxDMhQSsH5viWO9cnOr6GjkgfgbmWgQDpWacMNz2/H1yRooFUrMnZyCiQljuF0wEVEf3XFpAl5ZNhMBWhX2FNXje89tx96iOtGxyMOw8BINgCzLeDO3CDev24GyBscau1fPnotYQ5ToaEREbueqJAM+vvdSjIvw71y2bCde3HoKdjvn9dLQYOEl6qc6ixXL38zDqo+PwNphR3RYBNJmz0OQf4DoaEREbisx3B8b7rkU35sShQ67jKzPCrDstd2c4kBDgoWXqB+2FFTh2me24ctjlVBIElLGT8SlU6dDo1aLjkZE5Pb8tCo8d9s0/OWmydCpFfj6ZA2ufeZrfHaIS5fR4PAScqI+MDW340+fHsWH+aUAgABfP8yZnILggEDByYiIPIskSfi/1DjMig/GL9/bhwJjI1a8k4/rp0ThT9+/BKH+WtERyQ1xhJfoAmRZxn8PlCPt71udZXd8XAIWpl7KsktENIzGGQLw8b2X4pdXjYVSIeF/Byuw8O/b8K+9JVyzl/pNkvl/zXnMZjP0ej1MJhMCA1lqvNWp6ias/vgIthfWAHCM6s5KnoywoGDBycjb3J8qITqAK3+Q9zpUasID/z6AAmMjAGBWfDAeXTwJSZH8He3N+tPXWHh7wMLr3eotVjyTfRJv7zyLDrsMpUKBifFjMCE+AUqFUnQ88kIsvERAu82O1745gzVfnkSz1QaFBCyZFYfMheMRHsBpDt6IhXeQWHi9U7O1A2/sOIsXcgphbu0AAESFhWPa+GT4+/oKTkfejIWX6JzyhhY89r+j2HjICADw0yhx1+Vj8NP58QjQ8QJib8LCO0gsvN6ltd2Gd3YV4x85hahtsgIAgvwDMHV8EgwhYYLTEbHwEvVkT1EdHvv0KA6UmgAAQb5q/PzyMfjJ3NHw1/KafG/AwjtILLzewdTcjjdzi/D6jiLUWhxF18/HB5ckjENcVDQU3C2NXAQLL1HP7HYZ/ztUgb9/eQKnqy0AgACdCv+XGoc75sUjSu8jOCENJxbeQWLh9WxHy814e9dZbNhXhmarDQDgp/PBxIQxiI+KgULBxUvItbDwEl1Yh82Oj/eXY+2WQpyucRRflULC9VOisPyyREyK0QtOSMOBhXeQWHg9T2u7Df87WIG3d53FvuIG5/16/wAkxSciNiKSRZdcFgsvUd/Y7TK+KqjCK9tPY+fpOuf9sxNC8KOZsbh2UiT8ON3BY7DwDhILr2ew22XsK6nHJwcqsGFfGRpa2gE4FjUfFWHAmJg4hAeHQOLUBXJxLLxE/Xeo1IR/bj+NTw9WoMPuqDq+GiUWTYrELdNHYU5iKBQK/r1yZyy8g8TC675kWcb+kgZ8erACGw9VoMJ0bg92X50PEmNikRA9Cj5aLmFD7oOFl2jgKkwt+PfeUnyYX4qi2mbn/TFBPvje1CgsnGjAtLhgKFl+3Q4L7yCx8LqXprYO7DxVi69PVuPLY1Uoa2hxfk2lVCIm3IC4yCgYQsN5IRq5JRZeosGTZRn5xfX4d14ZPj1YjsbO5ScBINRPg6uSIpCWbMBl48Lgq+G0B3fAwjtILLyurcNmx9EKM74+WYNtJ6qRX1yPdtu5/41VSiWiwyMQGxGFyNAwKJXcLILcGwsv0dBqbbch+1gVvjhqxJaCKufa6wCgUSkwIy4YcxJDMScxBFNjg6BT8/eIK+pPX+M/Ycjl1Vms2Fdcj/zieuSdrceBEhNa2m3djvHz8UFkaDgiQ8JgCA2DiiWXiIh6oVMrcf2UKFw/JQrtNjv2FNXhy6NV2HzMiJK6FuSerkXu6VoAjgI8PS4IsxNCMSVGjymj9IgI1Al+BtRfHOHtAUd4xbDbZZTUN+NYRSMKjGYcqzCjwNiIs9+ac9VFrVIhPCgEkaFhiAwNg7+vn4DERCODI7xEI0OWZZyqtmDn6drOWx1qmtrOO84QqMXkGD0mxwRhYlQAxkb4Iy7EFyolV/sZSW43wrt27Vr89a9/hdFoxNSpU/Hcc89h9uzZvR7/r3/9Cw899BCKioowbtw4PPHEE7juuuucX5dlGatXr8bLL7+MhoYGXHrppXjhhRcwbty4kXg6dAGyLKO+uR1FtRYU1ThuZ2qbUVRjwenqJlisth4fF+Drh1B9EEKDghGmD0Kgnz9XVyAioiElSRLGRvhjbIQ/fjxnNGRZxukaC3JP1SK/uB6Hy0worGpCpbkNleYqfHmsyvlYjVKBxHA/jInwx9hwf4wO9UVsiC/iQnwR7q/lihCCCS+869evR2ZmJtatW4fU1FSsWbMG6enpOH78OCIiIs47fseOHbjtttuQlZWF733ve3j33XexePFi5OfnY9KkSQCAJ598Es8++yzeeOMNJCQk4KGHHkJ6ejqOHj0KnY5vQwyX1nYb6putqGm0osLUAqO5FRWmVhhNrY7PTY7P2zrsvZ5DoVBA7+cPvX8AggICoPcPRJB/ALQazQg+EyIiIkcBHhPujzHhjgIMAM3WDhwtN+NgqQmHy0w4XtmIU9VNaG23o8DYiAJj43nn0agUGBXsg1HBvogI0CI8QIuIAC0iAnSICDz3Zx8Np+MNF+FTGlJTUzFr1iw8//zzAAC73Y7Y2Fj88pe/xO9///vzjl+yZAksFgs+/fRT531z5sxBSkoK1q1bB1mWER0djV//+tf4zW9+AwAwmUwwGAx4/fXXceutt140kzdOabDZZVisHWhus6GprQOWrpvVBktbB5raOtBs7UBTmw0NzVbUN7ej3mJFfbO182P7efNqL8RHq0WArx/8ff3g7+uLAB8/BPj5wd/HlxtAEH0HpzQQuTa7XUZZQwsKq5pwsqoRhVVNKKlrQUl9MypMrbDZ+1a1ArQqBPtpoPdRO2+BPmoE+X7rc50avholfDRK+GlU8NEo4eu8qaBRec/vULeZ0mC1WpGXl4eVK1c671MoFEhLS0Nubm6Pj8nNzUVmZma3+9LT07FhwwYAwJkzZ2A0GpGWlub8ul6vR2pqKnJzc/tUeEdazvEqmFraYZdldNhkx0e7DLvd8dHWdZNl2GydX7vIMe12O9o67LB2dH20dfu8rcN27s/t9n6V1QuRJAlatQa+Oh18tDr46HTw1eq6fe6j1UKp4L9iiYjIMygUEmJDHFMYrkzq/u50u80Oo6kVxXXNKG9oQVVjG6ob21DV2IoqcxuqOv/c2m5HY1sHGts6evkufaNSSN8qwSpolAqoVZLjo1IBjcrxUa2UHJ93u+/csQpJglLxrZskQaGQoJQApaLrz+c+dt3np1Hi6omGQT2H4SC08NbU1MBms8Fg6P7CGAwGFBQU9PgYo9HY4/FGo9H59a77ejvmu9ra2tDWdm5Sutls7t8TGaTH/ncMhVVNI/o9eyNJEjQqJdQqFdRKx0eNSgW16tyftWo1dBo1fDQa6DQa6DRq50eNSsW5tURDzIsGbIg8jlqpcJbh3siyjKa2DlQ1tqGhuR2mFitMLe0wNbejoaXd8efOzxtbO9Dc3oFmqw3NbTY0WzvQ0m5zLs/ZYZfR2NrRuc7w+RfcDbfIQB0Lr6vKysrCI488Iuz7p8QGISJA6/xXlEohQSFJUCk7P3b+q0n1nX9pKRWKXo9RKSRoVQpo1UpolApo1ef+FadVKTs/dt2U8NMq4adVQatSsLASERGNIEmSEKBTI0CnHvA52m12NFttaLHaYLF2oMVqQ7PVhnabHVabHe0ddrTbZOfn1g472m1dN7nb59YOu/PdZMc7yDj3Z9nx7rLt21+X4bwvxM81r7kRWnjDwhybAlRWVna7v7KyEpGRkT0+JjIy8oLHd32srKxEVFRUt2NSUlJ6POfKlSu7TZMwm82IjY3t9/MZqKd+OHXEvhcRERF5HrVSAb2PAnqfgZdmTyb0jTKNRoMZM2YgOzvbeZ/dbkd2djbmzp3b42Pmzp3b7XgA2Lx5s/P4hIQEREZGdjvGbDZj165dvZ5Tq9UiMDCw242IiIiIPIPwKQ2ZmZlYtmwZZs6cidmzZ2PNmjWwWCzIyMgAACxduhQxMTHIysoCANx333244oor8Le//Q3XX3893n//fezduxcvvfQSAMfbAvfffz8ee+wxjBs3zrksWXR0NBYvXizqaRIRERGRIMIL75IlS1BdXY1Vq1bBaDQiJSUFmzZtcl50Vlxc3G2Zqnnz5uHdd9/Fgw8+iD/84Q8YN24cNmzY4FyDFwB++9vfwmKx4K677kJDQwPmz5+PTZs2cQ1eIiIiIi8kfB1eV+SN6/ASERERuZP+9DUudkNEREREHo2Fl4iIiIg8GgsvEREREXk0Fl4iIiIi8mgsvERERETk0Vh4iYiIiMijsfASERERkUdj4SUiIiIij8bCS0REREQejYWXiIiIiDwaCy8REREReTQWXiIiIiLyaCy8REREROTRWHiJiIiIyKOpRAdwRbIsAwDMZrPgJERERETUk66e1tXbLoSFtweNjY0AgNjYWMFJiIiIiOhCGhsbodfrL3iMJPelFnsZu92O8vJyBAQEQJKkYf9+ZrMZsbGxKCkpQWBg4LB/P3fC16ZnfF1654mvzaxZs7Bnz55BncMTX5ehwNeld3xtesbXpXcj/drIsozGxkZER0dDobjwLF2O8PZAoVBg1KhRI/59AwMD+ZenF3xtesbXpXee9Noolcohey6e9LoMJb4uveNr0zO+Lr0bydfmYiO7XXjRGhGRi7vnnntERyAicmssvERELo6Fl4hocFh4XYBWq8Xq1auh1WpFR3E5fG16xteld3xtesbXpWd8XXrH16ZnfF1658qvDS9aIyIiIiKPxhFeIiIiIvJoLLxERERE5NFYeImIiIjIo7HwEhEREZFHY+F1UW1tbUhJSYEkSdi/f7/oOC7h+9//PuLi4qDT6RAVFYWf/OQnKC8vFx1LqKKiItx5551ISEiAj48PxowZg9WrV8NqtYqO5hL+/Oc/Y968efD19UVQUJDoOEKtXbsW8fHx0Ol0SE1Nxe7du0VHEm7btm244YYbEB0dDUmSsGHDBtGRXEJWVhZmzZqFgIAAREREYPHixTh+/LjoWMK98MILmDJlinNThblz5+Kzzz4THcvlPP7445AkCffff7/oKN2w8Lqo3/72t4iOjhYdw6VceeWV+OCDD3D8+HF8+OGHOHXqFG655RbRsYQqKCiA3W7Hiy++iCNHjuDvf/871q1bhz/84Q+io7kEq9WKH/7wh1ixYoXoKEKtX78emZmZWL16NfLz8zF16lSkp6ejqqpKdDShLBYLpk6dirVr14qO4lK2bt2Ke+65Bzt37sTmzZvR3t6Oa665BhaLRXQ0oUaNGoXHH38ceXl52Lt3L6666irceOONOHLkiOhoLmPPnj148cUXMWXKFNFRzieTy9m4caOclJQkHzlyRAYg79u3T3Qkl/Txxx/LkiTJVqtVdBSX8uSTT8oJCQmiY7iU1157Tdbr9aJjCDN79mz5nnvucX5us9nk6OhoOSsrS2Aq1wJA/uijj0THcElVVVUyAHnr1q2io7ic4OBg+ZVXXhEdwyU0NjbK48aNkzdv3ixfccUV8n333Sc6Ujcc4XUxlZWVWL58Od566y34+vqKjuOy6urq8M4772DevHlQq9Wi47gUk8mEkJAQ0THIRVitVuTl5SEtLc15n0KhQFpaGnJzcwUmI3dhMpkAgD9XvsVms+H999+HxWLB3LlzRcdxCffccw+uv/76bj9rXAkLrwuRZRl33HEH7r77bsycOVN0HJf0u9/9Dn5+fggNDUVxcTE+/vhj0ZFcSmFhIZ577jn8/Oc/Fx2FXERNTQ1sNhsMBkO3+w0GA4xGo6BU5C7sdjvuv/9+XHrppZg0aZLoOMIdOnQI/v7+0Gq1uPvuu/HRRx8hOTlZdCzh3n//feTn5yMrK0t0lF6x8I6A3//+95Ak6YK3goICPPfcc2hsbMTKlStFRx4xfX1tujzwwAPYt28fvvjiCyiVSixduhSyB24W2N/XBQDKysqwaNEi/PCHP8Ty5csFJR9+A3ltiGhg7rnnHhw+fBjvv/++6CguYcKECdi/fz927dqFFStWYNmyZTh69KjoWEKVlJTgvvvuwzvvvAOdTic6Tq+4tfAIqK6uRm1t7QWPSUxMxI9+9CN88sknkCTJeb/NZoNSqcTtt9+ON954Y7ijjri+vjYajea8+0tLSxEbG4sdO3Z43FtK/X1dysvLsWDBAsyZMwevv/46FArP/bfsQP6fef3113H//fejoaFhmNO5HqvVCl9fX/z73//G4sWLnfcvW7YMDQ0NfJekkyRJ+Oijj7q9Rt7u3nvvxccff4xt27YhISFBdByXlJaWhjFjxuDFF18UHUWYDRs24KabboJSqXTeZ7PZIEkSFAoF2traun1NFJXoAN4gPDwc4eHhFz3u2WefxWOPPeb8vLy8HOnp6Vi/fj1SU1OHM6IwfX1temK32wE4lnDzNP15XcrKynDllVdixowZeO211zy67AKD+3/GG2k0GsyYMQPZ2dnOMme325GdnY17771XbDhySbIs45e//CU++ugj5OTksOxegN1u98jfQf1x9dVX49ChQ93uy8jIQFJSEn73u9+5RNkFWHhdSlxcXLfP/f39AQBjxozBqFGjRERyGbt27cKePXswf/58BAcH49SpU3jooYcwZswYjxvd7Y+ysjIsWLAAo0ePxlNPPYXq6mrn1yIjIwUmcw3FxcWoq6tDcXExbDabc03rsWPHOv9+eYPMzEwsW7YMM2fOxOzZs7FmzRpYLBZkZGSIjiZUU1MTCgsLnZ+fOXMG+/fvR0hIyHk/j73JPffcg3fffRcff/wxAgICnHO99Xo9fHx8BKcTZ+XKlbj22msRFxeHxsZGvPvuu8jJycHnn38uOppQAQEB583v7rrWxqXmfQtdI4Iu6MyZM1yWrNPBgwflK6+8Ug4JCZG1Wq0cHx8v33333XJpaanoaEK99tprMoAebyTLy5Yt6/G12bJli+hoI+65556T4+LiZI1GI8+ePVveuXOn6EjCbdmypcf/P5YtWyY6mlC9/Ux57bXXREcT6qc//ak8evRoWaPRyOHh4fLVV18tf/HFF6JjuSRXXJaMc3iJiIiIyKN59mQ/IiIiIvJ6LLxERERE5NFYeImIiIjIo7HwEhEREZFHY+ElIiIiIo/GwktEREREHo2Fl4iIiIg8GgsvEREREXk0Fl4iIiIi8mgsvERERETk0VSiAxAReRJZlvHFaRm7y4CWDiA+CLgpSUK4r9TrY746I+NwtYwqC6BWOB5z7VgJEX7nHrNurx2nG7o/LjUGuHmiY9zCYpXx3hEZFY1AczvgrwEuCQcWjZWgUznOc6ZBxsaTMqqbAasNCNYBqTESLh/dezYiIk/AwktENIRyzgLflABLkiWE+ACfn5Lxz30yfj0HUCt7LpanG2TMGyVhVCBgl4FNhTJe2SfjN3MBzbceMzsGSE8897laee4ckgRcEi4hfQzgrwZqWoANBTKaj8n4v8mOx2gUwLxYCVH+gEYJFDUAHx6ToVECc0ax9BKR5+KUBiKiISLLMrYXy7g6QcIlERKiAiQsmSTB3AYcqe79cT+bpsDMaAmR/hKiAyT86BIJDa1Aqbn7cRoFEKCVnLeukVsA8FVLmDtKQmyghGAfCeNCHJ+faTj3+JhACdMiHd8nxEfC9CgJE0KBogZ5aF8IIiIXwxFeIqIhUtcCNFqBcSHn7vNRSYgNlHHWJCMlsm+jqK0djo++6u737zMC+UY7AjRAcjhwdYLUbQT420xtMg5XyUgM7v37lJllFJmA9DEc3SUiz8bCS0Q0RBqtjo/+mu73B2jOfe1i7LKM/56QEa8HIv3PFdGUSAnBPkCgFqhoBD4rlFFtkbF0avey+s4hO45WA+12YGIYcMvE88vsn7+2o8nqmD6xMFFCagwLLxF5NhZeIqIByq+Q8Z+Cc9MBMlIGXxw3FMiobAJWzOx+rm/PsY3ydxTfl/Jl1DbLCP3WBXHfHy9hYSJQ3eyYC/zpSRk3JXU/14qZEtpsQLHJUZxDfYFpfRx9JiJyRyy8REQDlBwOxOnPFcUOu+Njk9VRSLs0WoHogIufb0OBHcdqHIU0SHfhAhqnd3ysaQFCfc/d75jfC0T4OaZEvLBXxtUJMgK1584X4uP4c5Q/0NQGbD4ts/ASkUdj4SUiGiCdSoLuWz9FZVlGgAY4WXeu4LZ2yCgxA3MvsAqCLMv4+LiMw9XAz2dIzkJ6IeWNjo+Bmt6PkTsHn7uKeE/sAGwX+DoRkSdg4SUiGiKSJGF+nGNd3TBfIMQH+OKUjECtY03cLi/l2XFJhIRLYx3FdsNxGfuMwLKpEnRKoLHN0VR1KsdSZrXNjq8nhTlGbSuagE9OyEgIAqICHOc4ViOjyQrEBjqWHKu0AP876ZgL3FWgd5TICNIB4X6OHGfqgW1nZVwaO2IvERGRECy8RERDaMFox6YOHx6T0dq58cSdKVK3NXhrWxwbRQCO+3JLHfe/mNd9ebAfJUuYGQ0oFcDJOhnbSxzn1muByRGOVRq6qBXA7jIZn5xwjOgG6YBJ4cCV8eeOkWXHnN26FkApASG+wHXjJKTGDNvLQUTkEiRZlrkAIxERERF5LG48QUREREQejYWXiIiIiDwaCy8REREReTQWXiIiIiLyaCy8REREROTRWHiJiIiIyKOx8BIRERGRR2PhJSIiIiKPxsJLRERERB6NhZeIiIiIPBoLLxGRh6qurkZkZCT+8pe/OO/bsWMHNBoNsrOzBSYjIhpZkizLsugQREQ0PDZu3IjFixdjx44dmDBhAlJSUnDjjTfi6aefFh2NiGjEsPASEXm4e+65B19++SVmzpyJQ4cOYc+ePdBqtaJjERGNGBZeIiIP19LSgkmTJqGkpAR5eXmYPHmy6EhERCOKc3iJiDzcqVOnUF5eDrvdjqKiItFxiIhGHEd4iYg8mNVqxezZs5GSkoIJEyZgzZo1OHToECIiIkRHIyIaMSy8REQe7IEHHsC///1vHDhwAP7+/rjiiiug1+vx6aefio5GRDRiOKWBiMhD5eTkYM2aNXjrrbcQGBgIhUKBt956C19//TVeeOEF0fGIiEYMR3iJiIiIyKNxhJeIiIiIPBoLLxERERF5NBZeIiIiIvJoLLxERERE5NFYeImIiIjIo7HwEhEREZFHY+ElIiIiIo/GwktEREREHo2Fl4iIiIg8GgsvEREREXk0Fl4iIiIi8mgsvERERETk0f4/espuYiOCZ+AAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex1 = shaded_normal_density(-0.2533)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $P(X\\leq x)$\n", + "\n", + "Shades in the region $P(X\\leq x)$ where $X∼N(μ,σ)$ is a normal distribution with mean $μ$ and standard deviation $σ$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex2 = shaded_normal_density(7.1, 7, 0.1, add_legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Upper tail probabilities \n", + "\n", + "#### $P(Z\\geq z)$\n", + "\n", + "Shading the region $P(Z\\geq z)$ where $Z∼N(0,1)$ is the standard normal $N(0,1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex3 = shaded_normal_density(-0.2533, lower_tail=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $P(X\\geq x)$\n", + "\n", + "Shades in the region $P(X\\geq x)$ where $X∼N(μ,σ)$ is a normal distribution with mean $μ$ and standard deviation $σ$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex4 = shaded_normal_density(7.1, 7, 0.1, lower_tail=False, add_legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inner range of values\n", + "#### $P(a < Z < b)$\n", + "\n", + "Shade in the region $P(a < Z < b)$ where $Z∼N(0,1)$ is the standard normal $N(0,1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex5 = shaded_normal_density((-1.1, 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### $P(a < X < b)$\n", + "\n", + "Shade in the region $P(a < X < b)$ where $X∼N(μ,σ)$ is a normal distribution with mean $μ$ and standard deviation $σ$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ex6 = shaded_normal_density((6.9, 7.1), 7, 0.1, add_legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These examples were based off of a lab by [Dr. Irene Vrbik](https://cmps.ok.ubc.ca/about/contact/irene-vrbik/) which can be found on their [website](https://irene.vrbik.ok.ubc.ca/labs/normal-distribution.html)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/problem_bank_helpers/__init__.py b/src/problem_bank_helpers/__init__.py index 1b141e8..b81f1b4 100644 --- a/src/problem_bank_helpers/__init__.py +++ b/src/problem_bank_helpers/__init__.py @@ -1,3 +1,4 @@ __version__ = "0.2.5" from .problem_bank_helpers import * +from . import stats # Keep stats as a separate namespace, but also make it accessible from the top level without an explicit import diff --git a/src/problem_bank_helpers/stats.py b/src/problem_bank_helpers/stats.py new file mode 100644 index 0000000..14c7fe2 --- /dev/null +++ b/src/problem_bank_helpers/stats.py @@ -0,0 +1,208 @@ +# Author: Firas Moosvi, Jake Bobowski, others +# Date: 2023-10-31 + +from __future__ import annotations + +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.figure import Figure +from scipy import stats + + +def shaded_normal_density( + q: float | tuple[float, float], + /, + mean: float = 0, + sd: float = 1, + rsd: float = 4, + lower_tail: bool = True, + add_prob: bool = True, + add_q: bool = True, + add_legend: bool = False, + figsize: tuple[float, float] | None = (8, 6), + color: str = "xkcd:sky blue", + x_label: str = "x", + y_label: str = "f(x; μ,σ)", + legend_text: str | None = None, + **kwargs, +) -> Figure: + """ + Generate a normal distribution plot with optional listed probability calculation. + + Parameters + ---------- + q : float or tuple of 2 floats + If a float, the upper or lower bound of the shaded area. If a tuple of floats, the lower and upper bounds of the shaded area. + mean : float, default: 0 + The mean of the normal distribution. + sd : float, default: 1 + The standard deviation of the normal distribution. + rsd : float, default: 4 + The number of standard deviations to plot on either side of the mean=. + lower_tail : bool, default: True + Whether the shaded area should represent the lower tail probability P(X <= x) (True) or the upper tail probability P(X > x) (False). + add_prob : bool, default: True + Whether to show the probability of the shaded area will be displayed on the plot. + add_q : bool, default: True + Whether the value(s) of `q` should be displayed on the x-axis of the plot. + add_legend : bool, default: False + Whether a legend with the mean and standard deviation values will be displayed on the plot. + figsize : tuple of 2 floats or None, default: (8, 6) + The size of the plot in inches. If None, the default matplotlib figure size will be used as this is passed to `matplotlib.pyplot.figure`. + color : color, default: 'xkcd:sky blue' + The color of the shaded area as a valid _. + x_label : str, default: 'x' + The label for the x-axis. + y_label : str, default: 'f(x; μ,σ)' + The label for the y-axis. + legend_text : str or None, optional + The text to display in the legend if add_legend is set to true. By default (None), the legend will display the mean and standard deviation values. + **kwargs + Additional keyword arguments to pass to `matplotlib.pyplot.figure`. + + Returns + ------- + matplotlib.figure.Figure + The generated matplotlib Figure object. + + Raises + ------ + TypeError + If the input parameters are not of the expected type. + ValueError + If the input values are out of the expected range. + + References + ---------- + Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `_. + + The R function by Dr. Irene Vrbick was adapted from `here `_. + """ + if not isinstance(mean, (float, int)): + raise TypeError(f"mean must be a number, not a {mean.__class__.__name__!r}") + if not isinstance(sd, (float, int)): + raise TypeError(f"sd must be a number, not a {sd.__class__.__name__!r}") + if not isinstance(rsd, (float, int)): + raise TypeError(f"rsd must be a number, not a {rsd.__class__.__name__!r}") + if ( + isinstance(q, tuple) + and len(q) == 2 + and isinstance(q[0], (float, int)) + and isinstance(q[1], (float, int)) + ): + q_lower, q_upper = sorted(q) + xx = np.linspace(mean - rsd * sd, mean + rsd * sd, 200) + yy = stats.norm.pdf(xx, mean, sd) + fig = plt.figure(figsize=figsize, **kwargs) + ax = fig.gca() + ax.plot(xx, yy) + ax.set_xlabel(x_label) + ax.set_ylabel(y_label) + x = np.linspace(q_lower, q_upper, 200) + y = stats.norm.pdf(x, mean, sd) + # fmt: off + filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one + np.concatenate([[q_lower], x, [q_upper]]), + np.concatenate([[0], y, [0]]), + color, + ) + # fmt: on + if add_prob: + height = max(y) / 4 + rv = stats.norm(mean, sd) + prob: float = rv.cdf(q_upper) - rv.cdf(q_lower) + ax.text((sum(q) / 2), height, f"{prob:.3f}", ha="center") + if add_q: + ax.set_xticks( + [q_lower, q_upper], + labels=[ + str(round(q_lower, 4)), + str(round(q_upper, 4)), + ], + minor=True, + color=color, + y=-0.05, + ) + if q_lower in ax.get_xticks(): + ax.get_xticklabels()[ + np.where(ax.get_xticks() == q_lower)[0][0] + ].set_color(color) + if q_upper in ax.get_xticks(): + ax.get_xticklabels()[ + np.where(ax.get_xticks() == q_upper)[0][0] + ].set_color(color) + + elif isinstance(q, (float, int)): + if not isinstance(lower_tail, bool): + raise TypeError( + f"lower_tail must be a bool, not a {lower_tail.__class__.__name__!r}" + ) + + xx = np.linspace(mean - rsd * sd, mean + rsd * sd, 200) + yy = stats.norm.pdf(xx, mean, sd) + fig = plt.figure(figsize=figsize, **kwargs) + ax = fig.gca() + ax.plot(xx, yy) + ax.set_xlabel(x_label) + ax.set_ylabel(y_label) + + if lower_tail is True: + x = np.linspace(xx[0], q, 100) + y = stats.norm.pdf(x, mean, sd) + # fmt: off + filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one + np.concatenate([[xx[0]], x, [q]]), + np.concatenate([[0], y, [0]]), + color, + ) + # fmt: on + if add_prob: + height: float = stats.norm.pdf(q, mean, sd) / 4 # type: ignore + prob: float = stats.norm.cdf(q, mean, sd) # type: ignore + ax.text((q - 0.5 * sd), height, f"{prob:.3f}", ha="center") + else: + x = np.linspace(q, xx[-1], 100) + y = stats.norm.pdf(x, mean, sd) + # fmt: off + filled, *_ = ax.fill( # Fill returns a list of polygons, but we're only making one + np.concatenate([[q], x, [xx[-1]]]), + np.concatenate([[0], y, [0]]), + color, + ) + # fmt: on + if add_prob: + height: float = stats.norm.pdf(q, mean, sd) / 4 # type: ignore + prob: float = stats.norm.sf(q, mean, sd) # type: ignore + ax.text((q + 0.5 * sd), height, f"{prob:.3f}", ha="center") + + if add_q: + if q in ax.get_xticks(): + ax.get_xticklabels()[np.where(ax.get_xticks() == q)[0][0]].set_color( + color + ) + else: + ax.set_xticks( + [q], + labels=[ + str(round(q, 4)), + ], + minor=True, + color=color, + y=-0.05, + ) + + else: + error_base = "q must be a tuple of two numbers, or a single number" + if isinstance(q, tuple): + if len(q) != 2: + raise ValueError(f"{error_base}, not a {len(q)}-tuple") + raise TypeError( + f"{error_base}, not a 2-tuple containing a {q[0].__class__.__name__!r} and a {q[1].__class__.__name__!r}" + ) + else: + raise TypeError(f"{error_base}, not a {q.__class__.__name__!r}") + + if add_legend: + ax.set_title(legend_text or f"μ = {mean}, σ = {sd}") + + return fig From 287fced51714ea65a8c9a2b06d1f9f154c477975 Mon Sep 17 00:00:00 2001 From: Bluesy1 <68259537+Bluesy1@users.noreply.github.com> Date: Tue, 31 Oct 2023 18:55:59 -0700 Subject: [PATCH 2/3] update dependencies --- poetry.lock | 762 ++++++++++++++++++++++++++++++++++++++++--------- pyproject.toml | 4 +- 2 files changed, 624 insertions(+), 142 deletions(-) diff --git a/poetry.lock b/poetry.lock index 7f6c085..edaf1d0 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,65 +1,507 @@ +# This file is automatically @generated by Poetry 1.5.1 and should not be changed by hand. + [[package]] name = "atomicwrites" version = "1.4.1" description = "Atomic file writes." -category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11"}, +] [[package]] name = "attrs" version = "23.1.0" description = "Classes Without Boilerplate" -category = "dev" optional = false python-versions = ">=3.7" +files = [ + {file = "attrs-23.1.0-py3-none-any.whl", hash = "sha256:1f28b4522cdc2fb4256ac1a020c78acf9cba2c6b461ccd2c126f3aa8e8335d04"}, + {file = "attrs-23.1.0.tar.gz", hash = "sha256:6279836d581513a26f1bf235f9acd333bc9115683f14f7e8fae46c98fc50e015"}, +] [package.extras] -cov = ["attrs", "coverage[toml] (>=5.3)"] -dev = ["attrs", "pre-commit"] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[docs,tests]", "pre-commit"] docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] -tests = ["attrs", "zope-interface"] -tests-no-zope = ["cloudpickle", "hypothesis", "mypy (>=1.1.1)", "pympler", "pytest-mypy-plugins", "pytest-xdist", "pytest (>=4.3.0)"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-no-zope = ["cloudpickle", "hypothesis", "mypy (>=1.1.1)", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-xdist[psutil]"] [[package]] name = "colorama" version = "0.4.6" description = "Cross-platform colored terminal text." -category = "dev" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "contourpy" +version = "1.1.0" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.8" +files = [ + {file = "contourpy-1.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:89f06eff3ce2f4b3eb24c1055a26981bffe4e7264acd86f15b97e40530b794bc"}, + {file = "contourpy-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dffcc2ddec1782dd2f2ce1ef16f070861af4fb78c69862ce0aab801495dda6a3"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25ae46595e22f93592d39a7eac3d638cda552c3e1160255258b695f7b58e5655"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:17cfaf5ec9862bc93af1ec1f302457371c34e688fbd381f4035a06cd47324f48"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18a64814ae7bce73925131381603fff0116e2df25230dfc80d6d690aa6e20b37"}, + {file = "contourpy-1.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90c81f22b4f572f8a2110b0b741bb64e5a6427e0a198b2cdc1fbaf85f352a3aa"}, + {file = "contourpy-1.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:53cc3a40635abedbec7f1bde60f8c189c49e84ac180c665f2cd7c162cc454baa"}, + {file = "contourpy-1.1.0-cp310-cp310-win32.whl", hash = "sha256:9b2dd2ca3ac561aceef4c7c13ba654aaa404cf885b187427760d7f7d4c57cff8"}, + {file = "contourpy-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:1f795597073b09d631782e7245016a4323cf1cf0b4e06eef7ea6627e06a37ff2"}, + {file = "contourpy-1.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0b7b04ed0961647691cfe5d82115dd072af7ce8846d31a5fac6c142dcce8b882"}, + {file = "contourpy-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27bc79200c742f9746d7dd51a734ee326a292d77e7d94c8af6e08d1e6c15d545"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:052cc634bf903c604ef1a00a5aa093c54f81a2612faedaa43295809ffdde885e"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9382a1c0bc46230fb881c36229bfa23d8c303b889b788b939365578d762b5c18"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5cec36c5090e75a9ac9dbd0ff4a8cf7cecd60f1b6dc23a374c7d980a1cd710e"}, + {file = "contourpy-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f0cbd657e9bde94cd0e33aa7df94fb73c1ab7799378d3b3f902eb8eb2e04a3a"}, + {file = "contourpy-1.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:181cbace49874f4358e2929aaf7ba84006acb76694102e88dd15af861996c16e"}, + {file = "contourpy-1.1.0-cp311-cp311-win32.whl", hash = "sha256:edb989d31065b1acef3828a3688f88b2abb799a7db891c9e282df5ec7e46221b"}, + {file = "contourpy-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fb3b7d9e6243bfa1efb93ccfe64ec610d85cfe5aec2c25f97fbbd2e58b531256"}, + {file = "contourpy-1.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bcb41692aa09aeb19c7c213411854402f29f6613845ad2453d30bf421fe68fed"}, + {file = "contourpy-1.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5d123a5bc63cd34c27ff9c7ac1cd978909e9c71da12e05be0231c608048bb2ae"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62013a2cf68abc80dadfd2307299bfa8f5aa0dcaec5b2954caeb5fa094171103"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b6616375d7de55797d7a66ee7d087efe27f03d336c27cf1f32c02b8c1a5ac70"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:317267d915490d1e84577924bd61ba71bf8681a30e0d6c545f577363157e5e94"}, + {file = "contourpy-1.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d551f3a442655f3dcc1285723f9acd646ca5858834efeab4598d706206b09c9f"}, + {file = "contourpy-1.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e7a117ce7df5a938fe035cad481b0189049e8d92433b4b33aa7fc609344aafa1"}, + {file = "contourpy-1.1.0-cp38-cp38-win32.whl", hash = "sha256:108dfb5b3e731046a96c60bdc46a1a0ebee0760418951abecbe0fc07b5b93b27"}, + {file = "contourpy-1.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:d4f26b25b4f86087e7d75e63212756c38546e70f2a92d2be44f80114826e1cd4"}, + {file = "contourpy-1.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc00bb4225d57bff7ebb634646c0ee2a1298402ec10a5fe7af79df9a51c1bfd9"}, + {file = "contourpy-1.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:189ceb1525eb0655ab8487a9a9c41f42a73ba52d6789754788d1883fb06b2d8a"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f2931ed4741f98f74b410b16e5213f71dcccee67518970c42f64153ea9313b9"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30f511c05fab7f12e0b1b7730ebdc2ec8deedcfb505bc27eb570ff47c51a8f15"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:143dde50520a9f90e4a2703f367cf8ec96a73042b72e68fcd184e1279962eb6f"}, + {file = "contourpy-1.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e94bef2580e25b5fdb183bf98a2faa2adc5b638736b2c0a4da98691da641316a"}, + {file = "contourpy-1.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ed614aea8462735e7d70141374bd7650afd1c3f3cb0c2dbbcbe44e14331bf002"}, + {file = "contourpy-1.1.0-cp39-cp39-win32.whl", hash = "sha256:71551f9520f008b2950bef5f16b0e3587506ef4f23c734b71ffb7b89f8721999"}, + {file = "contourpy-1.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:438ba416d02f82b692e371858143970ed2eb6337d9cdbbede0d8ad9f3d7dd17d"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a698c6a7a432789e587168573a864a7ea374c6be8d4f31f9d87c001d5a843493"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:397b0ac8a12880412da3551a8cb5a187d3298a72802b45a3bd1805e204ad8439"}, + {file = "contourpy-1.1.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:a67259c2b493b00e5a4d0f7bfae51fb4b3371395e47d079a4446e9b0f4d70e76"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2b836d22bd2c7bb2700348e4521b25e077255ebb6ab68e351ab5aa91ca27e027"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084eaa568400cfaf7179b847ac871582199b1b44d5699198e9602ecbbb5f6104"}, + {file = "contourpy-1.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:911ff4fd53e26b019f898f32db0d4956c9d227d51338fb3b03ec72ff0084ee5f"}, + {file = "contourpy-1.1.0.tar.gz", hash = "sha256:e53046c3863828d21d531cc3b53786e6580eb1ba02477e8681009b6aa0870b21"}, +] + +[package.dependencies] +numpy = ">=1.16" + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.2.0)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "wurlitzer"] + +[[package]] +name = "contourpy" +version = "1.1.1" +description = "Python library for calculating contours of 2D quadrilateral grids" +optional = false +python-versions = ">=3.8" +files = [ + {file = "contourpy-1.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:46e24f5412c948d81736509377e255f6040e94216bf1a9b5ea1eaa9d29f6ec1b"}, + {file = "contourpy-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e48694d6a9c5a26ee85b10130c77a011a4fedf50a7279fa0bdaf44bafb4299d"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a66045af6cf00e19d02191ab578a50cb93b2028c3eefed999793698e9ea768ae"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ebf42695f75ee1a952f98ce9775c873e4971732a87334b099dde90b6af6a916"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6aec19457617ef468ff091669cca01fa7ea557b12b59a7908b9474bb9674cf0"}, + {file = "contourpy-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:462c59914dc6d81e0b11f37e560b8a7c2dbab6aca4f38be31519d442d6cde1a1"}, + {file = "contourpy-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6d0a8efc258659edc5299f9ef32d8d81de8b53b45d67bf4bfa3067f31366764d"}, + {file = "contourpy-1.1.1-cp310-cp310-win32.whl", hash = "sha256:d6ab42f223e58b7dac1bb0af32194a7b9311065583cc75ff59dcf301afd8a431"}, + {file = "contourpy-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:549174b0713d49871c6dee90a4b499d3f12f5e5f69641cd23c50a4542e2ca1eb"}, + {file = "contourpy-1.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:407d864db716a067cc696d61fa1ef6637fedf03606e8417fe2aeed20a061e6b2"}, + {file = "contourpy-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe80c017973e6a4c367e037cb31601044dd55e6bfacd57370674867d15a899b"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30aaf2b8a2bac57eb7e1650df1b3a4130e8d0c66fc2f861039d507a11760e1b"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3de23ca4f381c3770dee6d10ead6fff524d540c0f662e763ad1530bde5112532"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:566f0e41df06dfef2431defcfaa155f0acfa1ca4acbf8fd80895b1e7e2ada40e"}, + {file = "contourpy-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b04c2f0adaf255bf756cf08ebef1be132d3c7a06fe6f9877d55640c5e60c72c5"}, + {file = "contourpy-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d0c188ae66b772d9d61d43c6030500344c13e3f73a00d1dc241da896f379bb62"}, + {file = "contourpy-1.1.1-cp311-cp311-win32.whl", hash = "sha256:0683e1ae20dc038075d92e0e0148f09ffcefab120e57f6b4c9c0f477ec171f33"}, + {file = "contourpy-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:8636cd2fc5da0fb102a2504fa2c4bea3cbc149533b345d72cdf0e7a924decc45"}, + {file = "contourpy-1.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:560f1d68a33e89c62da5da4077ba98137a5e4d3a271b29f2f195d0fba2adcb6a"}, + {file = "contourpy-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:24216552104ae8f3b34120ef84825400b16eb6133af2e27a190fdc13529f023e"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56de98a2fb23025882a18b60c7f0ea2d2d70bbbcfcf878f9067234b1c4818442"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:07d6f11dfaf80a84c97f1a5ba50d129d9303c5b4206f776e94037332e298dda8"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1eaac5257a8f8a047248d60e8f9315c6cff58f7803971170d952555ef6344a7"}, + {file = "contourpy-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19557fa407e70f20bfaba7d55b4d97b14f9480856c4fb65812e8a05fe1c6f9bf"}, + {file = "contourpy-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:081f3c0880712e40effc5f4c3b08feca6d064cb8cfbb372ca548105b86fd6c3d"}, + {file = "contourpy-1.1.1-cp312-cp312-win32.whl", hash = "sha256:059c3d2a94b930f4dafe8105bcdc1b21de99b30b51b5bce74c753686de858cb6"}, + {file = "contourpy-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f44d78b61740e4e8c71db1cf1fd56d9050a4747681c59ec1094750a658ceb970"}, + {file = "contourpy-1.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:70e5a10f8093d228bb2b552beeb318b8928b8a94763ef03b858ef3612b29395d"}, + {file = "contourpy-1.1.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8394e652925a18ef0091115e3cc191fef350ab6dc3cc417f06da66bf98071ae9"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bd5680f844c3ff0008523a71949a3ff5e4953eb7701b28760805bc9bcff217"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66544f853bfa85c0d07a68f6c648b2ec81dafd30f272565c37ab47a33b220684"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0c02b75acfea5cab07585d25069207e478d12309557f90a61b5a3b4f77f46ce"}, + {file = "contourpy-1.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41339b24471c58dc1499e56783fedc1afa4bb018bcd035cfb0ee2ad2a7501ef8"}, + {file = "contourpy-1.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f29fb0b3f1217dfe9362ec55440d0743fe868497359f2cf93293f4b2701b8251"}, + {file = "contourpy-1.1.1-cp38-cp38-win32.whl", hash = "sha256:f9dc7f933975367251c1b34da882c4f0e0b2e24bb35dc906d2f598a40b72bfc7"}, + {file = "contourpy-1.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:498e53573e8b94b1caeb9e62d7c2d053c263ebb6aa259c81050766beb50ff8d9"}, + {file = "contourpy-1.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ba42e3810999a0ddd0439e6e5dbf6d034055cdc72b7c5c839f37a7c274cb4eba"}, + {file = "contourpy-1.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6c06e4c6e234fcc65435223c7b2a90f286b7f1b2733058bdf1345d218cc59e34"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca6fab080484e419528e98624fb5c4282148b847e3602dc8dbe0cb0669469887"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:93df44ab351119d14cd1e6b52a5063d3336f0754b72736cc63db59307dabb718"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eafbef886566dc1047d7b3d4b14db0d5b7deb99638d8e1be4e23a7c7ac59ff0f"}, + {file = "contourpy-1.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efe0fab26d598e1ec07d72cf03eaeeba8e42b4ecf6b9ccb5a356fde60ff08b85"}, + {file = "contourpy-1.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f08e469821a5e4751c97fcd34bcb586bc243c39c2e39321822060ba902eac49e"}, + {file = "contourpy-1.1.1-cp39-cp39-win32.whl", hash = "sha256:bfc8a5e9238232a45ebc5cb3bfee71f1167064c8d382cadd6076f0d51cff1da0"}, + {file = "contourpy-1.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:c84fdf3da00c2827d634de4fcf17e3e067490c4aea82833625c4c8e6cdea0887"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:229a25f68046c5cf8067d6d6351c8b99e40da11b04d8416bf8d2b1d75922521e"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a10dab5ea1bd4401c9483450b5b0ba5416be799bbd50fc7a6cc5e2a15e03e8a3"}, + {file = "contourpy-1.1.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:4f9147051cb8fdb29a51dc2482d792b3b23e50f8f57e3720ca2e3d438b7adf23"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a75cc163a5f4531a256f2c523bd80db509a49fc23721b36dd1ef2f60ff41c3cb"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b53d5769aa1f2d4ea407c65f2d1d08002952fac1d9e9d307aa2e1023554a163"}, + {file = "contourpy-1.1.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11b836b7dbfb74e049c302bbf74b4b8f6cb9d0b6ca1bf86cfa8ba144aedadd9c"}, + {file = "contourpy-1.1.1.tar.gz", hash = "sha256:96ba37c2e24b7212a77da85004c38e7c4d155d3e72a45eeaf22c1f03f607e8ab"}, +] + +[package.dependencies] +numpy = {version = ">=1.16,<2.0", markers = "python_version <= \"3.11\""} + +[package.extras] +bokeh = ["bokeh", "selenium"] +docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"] +mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.4.1)", "types-Pillow"] +test = ["Pillow", "contourpy[test-no-images]", "matplotlib"] +test-no-images = ["pytest", "pytest-cov", "wurlitzer"] + +[[package]] +name = "cycler" +version = "0.12.1" +description = "Composable style cycles" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"}, + {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"}, +] + +[package.extras] +docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] +tests = ["pytest", "pytest-cov", "pytest-xdist"] + +[[package]] +name = "fonttools" +version = "4.43.1" +description = "Tools to manipulate font files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fonttools-4.43.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:bf11e2cca121df35e295bd34b309046c29476ee739753bc6bc9d5050de319273"}, + {file = "fonttools-4.43.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:10b3922875ffcba636674f406f9ab9a559564fdbaa253d66222019d569db869c"}, + {file = "fonttools-4.43.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f727c3e3d08fd25352ed76cc3cb61486f8ed3f46109edf39e5a60fc9fecf6ca"}, + {file = "fonttools-4.43.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad0b3f6342cfa14be996971ea2b28b125ad681c6277c4cd0fbdb50340220dfb6"}, + {file = "fonttools-4.43.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:3b7ad05b2beeebafb86aa01982e9768d61c2232f16470f9d0d8e385798e37184"}, + {file = "fonttools-4.43.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4c54466f642d2116686268c3e5f35ebb10e49b0d48d41a847f0e171c785f7ac7"}, + {file = "fonttools-4.43.1-cp310-cp310-win32.whl", hash = "sha256:1e09da7e8519e336239fbd375156488a4c4945f11c4c5792ee086dd84f784d02"}, + {file = "fonttools-4.43.1-cp310-cp310-win_amd64.whl", hash = "sha256:1cf9e974f63b1080b1d2686180fc1fbfd3bfcfa3e1128695b5de337eb9075cef"}, + {file = "fonttools-4.43.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5db46659cfe4e321158de74c6f71617e65dc92e54980086823a207f1c1c0e24b"}, + {file = "fonttools-4.43.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1952c89a45caceedf2ab2506d9a95756e12b235c7182a7a0fff4f5e52227204f"}, + {file = "fonttools-4.43.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c36da88422e0270fbc7fd959dc9749d31a958506c1d000e16703c2fce43e3d0"}, + {file = "fonttools-4.43.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bbbf8174501285049e64d174e29f9578495e1b3b16c07c31910d55ad57683d8"}, + {file = "fonttools-4.43.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d4071bd1c183b8d0b368cc9ed3c07a0f6eb1bdfc4941c4c024c49a35429ac7cd"}, + {file = "fonttools-4.43.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d21099b411e2006d3c3e1f9aaf339e12037dbf7bf9337faf0e93ec915991f43b"}, + {file = "fonttools-4.43.1-cp311-cp311-win32.whl", hash = "sha256:b84a1c00f832feb9d0585ca8432fba104c819e42ff685fcce83537e2e7e91204"}, + {file = "fonttools-4.43.1-cp311-cp311-win_amd64.whl", hash = "sha256:9a2f0aa6ca7c9bc1058a9d0b35483d4216e0c1bbe3962bc62ce112749954c7b8"}, + {file = "fonttools-4.43.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4d9740e3783c748521e77d3c397dc0662062c88fd93600a3c2087d3d627cd5e5"}, + {file = "fonttools-4.43.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:884ef38a5a2fd47b0c1291647b15f4e88b9de5338ffa24ee52c77d52b4dfd09c"}, + {file = "fonttools-4.43.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9648518ef687ba818db3fcc5d9aae27a369253ac09a81ed25c3867e8657a0680"}, + {file = "fonttools-4.43.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95e974d70238fc2be5f444fa91f6347191d0e914d5d8ae002c9aa189572cc215"}, + {file = "fonttools-4.43.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:34f713dad41aa21c637b4e04fe507c36b986a40f7179dcc86402237e2d39dcd3"}, + {file = "fonttools-4.43.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:360201d46165fc0753229afe785900bc9596ee6974833124f4e5e9f98d0f592b"}, + {file = "fonttools-4.43.1-cp312-cp312-win32.whl", hash = "sha256:bb6d2f8ef81ea076877d76acfb6f9534a9c5f31dc94ba70ad001267ac3a8e56f"}, + {file = "fonttools-4.43.1-cp312-cp312-win_amd64.whl", hash = "sha256:25d3da8a01442cbc1106490eddb6d31d7dffb38c1edbfabbcc8db371b3386d72"}, + {file = "fonttools-4.43.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:8da417431bfc9885a505e86ba706f03f598c85f5a9c54f67d63e84b9948ce590"}, + {file = "fonttools-4.43.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:51669b60ee2a4ad6c7fc17539a43ffffc8ef69fd5dbed186a38a79c0ac1f5db7"}, + {file = "fonttools-4.43.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:748015d6f28f704e7d95cd3c808b483c5fb87fd3eefe172a9da54746ad56bfb6"}, + {file = "fonttools-4.43.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7a58eb5e736d7cf198eee94844b81c9573102ae5989ebcaa1d1a37acd04b33d"}, + {file = "fonttools-4.43.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6bb5ea9076e0e39defa2c325fc086593ae582088e91c0746bee7a5a197be3da0"}, + {file = "fonttools-4.43.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5f37e31291bf99a63328668bb83b0669f2688f329c4c0d80643acee6e63cd933"}, + {file = "fonttools-4.43.1-cp38-cp38-win32.whl", hash = "sha256:9c60ecfa62839f7184f741d0509b5c039d391c3aff71dc5bc57b87cc305cff3b"}, + {file = "fonttools-4.43.1-cp38-cp38-win_amd64.whl", hash = "sha256:fe9b1ec799b6086460a7480e0f55c447b1aca0a4eecc53e444f639e967348896"}, + {file = "fonttools-4.43.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:13a9a185259ed144def3682f74fdcf6596f2294e56fe62dfd2be736674500dba"}, + {file = "fonttools-4.43.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2adca1b46d69dce4a37eecc096fe01a65d81a2f5c13b25ad54d5430ae430b13"}, + {file = "fonttools-4.43.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18eefac1b247049a3a44bcd6e8c8fd8b97f3cad6f728173b5d81dced12d6c477"}, + {file = "fonttools-4.43.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2062542a7565091cea4cc14dd99feff473268b5b8afdee564f7067dd9fff5860"}, + {file = "fonttools-4.43.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:18a2477c62a728f4d6e88c45ee9ee0229405e7267d7d79ce1f5ce0f3e9f8ab86"}, + {file = "fonttools-4.43.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a7a06f8d95b7496e53af80d974d63516ffb263a468e614978f3899a6df52d4b3"}, + {file = "fonttools-4.43.1-cp39-cp39-win32.whl", hash = "sha256:10003ebd81fec0192c889e63a9c8c63f88c7d72ae0460b7ba0cd2a1db246e5ad"}, + {file = "fonttools-4.43.1-cp39-cp39-win_amd64.whl", hash = "sha256:e117a92b07407a061cde48158c03587ab97e74e7d73cb65e6aadb17af191162a"}, + {file = "fonttools-4.43.1-py3-none-any.whl", hash = "sha256:4f88cae635bfe4bbbdc29d479a297bb525a94889184bb69fa9560c2d4834ddb9"}, + {file = "fonttools-4.43.1.tar.gz", hash = "sha256:17dbc2eeafb38d5d0e865dcce16e313c58265a6d2d20081c435f84dc5a9d8212"}, +] + +[package.extras] +all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.0.0)", "xattr", "zopfli (>=0.1.4)"] +graphite = ["lz4 (>=1.7.4.2)"] +interpolatable = ["munkres", "scipy"] +lxml = ["lxml (>=4.0,<5)"] +pathops = ["skia-pathops (>=0.5.0)"] +plot = ["matplotlib"] +repacker = ["uharfbuzz (>=0.23.0)"] +symfont = ["sympy"] +type1 = ["xattr"] +ufo = ["fs (>=2.2.0,<3)"] +unicode = ["unicodedata2 (>=15.0.0)"] +woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] [[package]] name = "iniconfig" version = "2.0.0" description = "brain-dead simple config-ini parsing" -category = "dev" optional = false python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "kiwisolver" +version = "1.4.5" +description = "A fast implementation of the Cassowary constraint solver" +optional = false +python-versions = ">=3.7" +files = [ + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:05703cf211d585109fcd72207a31bb170a0f22144d68298dc5e61b3c946518af"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:146d14bebb7f1dc4d5fbf74f8a6cb15ac42baadee8912eb84ac0b3b2a3dc6ac3"}, + {file = "kiwisolver-1.4.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6ef7afcd2d281494c0a9101d5c571970708ad911d028137cd558f02b851c08b4"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:9eaa8b117dc8337728e834b9c6e2611f10c79e38f65157c4c38e9400286f5cb1"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ec20916e7b4cbfb1f12380e46486ec4bcbaa91a9c448b97023fde0d5bbf9e4ff"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b42c68602539407884cf70d6a480a469b93b81b7701378ba5e2328660c847a"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aa12042de0171fad672b6c59df69106d20d5596e4f87b5e8f76df757a7c399aa"}, + {file = "kiwisolver-1.4.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a40773c71d7ccdd3798f6489aaac9eee213d566850a9533f8d26332d626b82c"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:19df6e621f6d8b4b9c4d45f40a66839294ff2bb235e64d2178f7522d9170ac5b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:83d78376d0d4fd884e2c114d0621624b73d2aba4e2788182d286309ebdeed770"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e391b1f0a8a5a10ab3b9bb6afcfd74f2175f24f8975fb87ecae700d1503cdee0"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:852542f9481f4a62dbb5dd99e8ab7aedfeb8fb6342349a181d4036877410f525"}, + {file = "kiwisolver-1.4.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59edc41b24031bc25108e210c0def6f6c2191210492a972d585a06ff246bb79b"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win32.whl", hash = "sha256:a6aa6315319a052b4ee378aa171959c898a6183f15c1e541821c5c59beaa0238"}, + {file = "kiwisolver-1.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:d0ef46024e6a3d79c01ff13801cb19d0cad7fd859b15037aec74315540acc276"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:11863aa14a51fd6ec28688d76f1735f8f69ab1fabf388851a595d0721af042f5"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ab3919a9997ab7ef2fbbed0cc99bb28d3c13e6d4b1ad36e97e482558a91be90"}, + {file = "kiwisolver-1.4.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fcc700eadbbccbf6bc1bcb9dbe0786b4b1cb91ca0dcda336eef5c2beed37b797"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dfdd7c0b105af050eb3d64997809dc21da247cf44e63dc73ff0fd20b96be55a9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76c6a5964640638cdeaa0c359382e5703e9293030fe730018ca06bc2010c4437"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbea0db94288e29afcc4c28afbf3a7ccaf2d7e027489c449cf7e8f83c6346eb9"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ceec1a6bc6cab1d6ff5d06592a91a692f90ec7505d6463a88a52cc0eb58545da"}, + {file = "kiwisolver-1.4.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:040c1aebeda72197ef477a906782b5ab0d387642e93bda547336b8957c61022e"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f91de7223d4c7b793867797bacd1ee53bfe7359bd70d27b7b58a04efbb9436c8"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:faae4860798c31530dd184046a900e652c95513796ef51a12bc086710c2eec4d"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:b0157420efcb803e71d1b28e2c287518b8808b7cf1ab8af36718fd0a2c453eb0"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:06f54715b7737c2fecdbf140d1afb11a33d59508a47bf11bb38ecf21dc9ab79f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fdb7adb641a0d13bdcd4ef48e062363d8a9ad4a182ac7647ec88f695e719ae9f"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win32.whl", hash = "sha256:bb86433b1cfe686da83ce32a9d3a8dd308e85c76b60896d58f082136f10bffac"}, + {file = "kiwisolver-1.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c08e1312a9cf1074d17b17728d3dfce2a5125b2d791527f33ffbe805200a355"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:32d5cf40c4f7c7b3ca500f8985eb3fb3a7dfc023215e876f207956b5ea26632a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f846c260f483d1fd217fe5ed7c173fb109efa6b1fc8381c8b7552c5781756192"}, + {file = "kiwisolver-1.4.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5ff5cf3571589b6d13bfbfd6bcd7a3f659e42f96b5fd1c4830c4cf21d4f5ef45"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7269d9e5f1084a653d575c7ec012ff57f0c042258bf5db0954bf551c158466e7"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da802a19d6e15dffe4b0c24b38b3af68e6c1a68e6e1d8f30148c83864f3881db"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3aba7311af82e335dd1e36ffff68aaca609ca6290c2cb6d821a39aa075d8e3ff"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763773d53f07244148ccac5b084da5adb90bfaee39c197554f01b286cf869228"}, + {file = "kiwisolver-1.4.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2270953c0d8cdab5d422bee7d2007f043473f9d2999631c86a223c9db56cbd16"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d099e745a512f7e3bbe7249ca835f4d357c586d78d79ae8f1dcd4d8adeb9bda9"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:74db36e14a7d1ce0986fa104f7d5637aea5c82ca6326ed0ec5694280942d1162"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:7e5bab140c309cb3a6ce373a9e71eb7e4873c70c2dda01df6820474f9889d6d4"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0f114aa76dc1b8f636d077979c0ac22e7cd8f3493abbab152f20eb8d3cda71f3"}, + {file = "kiwisolver-1.4.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:88a2df29d4724b9237fc0c6eaf2a1adae0cdc0b3e9f4d8e7dc54b16812d2d81a"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win32.whl", hash = "sha256:72d40b33e834371fd330fb1472ca19d9b8327acb79a5821d4008391db8e29f20"}, + {file = "kiwisolver-1.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:2c5674c4e74d939b9d91dda0fae10597ac7521768fec9e399c70a1f27e2ea2d9"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a2b053a0ab7a3960c98725cfb0bf5b48ba82f64ec95fe06f1d06c99b552e130"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd32d6c13807e5c66a7cbb79f90b553642f296ae4518a60d8d76243b0ad2898"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59ec7b7c7e1a61061850d53aaf8e93db63dce0c936db1fda2658b70e4a1be709"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da4cfb373035def307905d05041c1d06d8936452fe89d464743ae7fb8371078b"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2400873bccc260b6ae184b2b8a4fec0e4082d30648eadb7c3d9a13405d861e89"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1b04139c4236a0f3aff534479b58f6f849a8b351e1314826c2d230849ed48985"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4e66e81a5779b65ac21764c295087de82235597a2293d18d943f8e9e32746265"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:7931d8f1f67c4be9ba1dd9c451fb0eeca1a25b89e4d3f89e828fe12a519b782a"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:b3f7e75f3015df442238cca659f8baa5f42ce2a8582727981cbfa15fee0ee205"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:bbf1d63eef84b2e8c89011b7f2235b1e0bf7dacc11cac9431fc6468e99ac77fb"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:4c380469bd3f970ef677bf2bcba2b6b0b4d5c75e7a020fb863ef75084efad66f"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win32.whl", hash = "sha256:9408acf3270c4b6baad483865191e3e582b638b1654a007c62e3efe96f09a9a3"}, + {file = "kiwisolver-1.4.5-cp37-cp37m-win_amd64.whl", hash = "sha256:5b94529f9b2591b7af5f3e0e730a4e0a41ea174af35a4fd067775f9bdfeee01a"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:11c7de8f692fc99816e8ac50d1d1aef4f75126eefc33ac79aac02c099fd3db71"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:53abb58632235cd154176ced1ae8f0d29a6657aa1aa9decf50b899b755bc2b93"}, + {file = "kiwisolver-1.4.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:88b9f257ca61b838b6f8094a62418421f87ac2a1069f7e896c36a7d86b5d4c29"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3195782b26fc03aa9c6913d5bad5aeb864bdc372924c093b0f1cebad603dd712"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc579bf0f502e54926519451b920e875f433aceb4624a3646b3252b5caa9e0b6"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a580c91d686376f0f7c295357595c5a026e6cbc3d77b7c36e290201e7c11ecb"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:cfe6ab8da05c01ba6fbea630377b5da2cd9bcbc6338510116b01c1bc939a2c18"}, + {file = "kiwisolver-1.4.5-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d2e5a98f0ec99beb3c10e13b387f8db39106d53993f498b295f0c914328b1333"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a51a263952b1429e429ff236d2f5a21c5125437861baeed77f5e1cc2d2c7c6da"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3edd2fa14e68c9be82c5b16689e8d63d89fe927e56debd6e1dbce7a26a17f81b"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:74d1b44c6cfc897df648cc9fdaa09bc3e7679926e6f96df05775d4fb3946571c"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:76d9289ed3f7501012e05abb8358bbb129149dbd173f1f57a1bf1c22d19ab7cc"}, + {file = "kiwisolver-1.4.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:92dea1ffe3714fa8eb6a314d2b3c773208d865a0e0d35e713ec54eea08a66250"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win32.whl", hash = "sha256:5c90ae8c8d32e472be041e76f9d2f2dbff4d0b0be8bd4041770eddb18cf49a4e"}, + {file = "kiwisolver-1.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:c7940c1dc63eb37a67721b10d703247552416f719c4188c54e04334321351ced"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9407b6a5f0d675e8a827ad8742e1d6b49d9c1a1da5d952a67d50ef5f4170b18d"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:15568384086b6df3c65353820a4473575dbad192e35010f622c6ce3eebd57af9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0dc9db8e79f0036e8173c466d21ef18e1befc02de8bf8aa8dc0813a6dc8a7046"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cdc8a402aaee9a798b50d8b827d7ecf75edc5fb35ea0f91f213ff927c15f4ff0"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:6c3bd3cde54cafb87d74d8db50b909705c62b17c2099b8f2e25b461882e544ff"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:955e8513d07a283056b1396e9a57ceddbd272d9252c14f154d450d227606eb54"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:346f5343b9e3f00b8db8ba359350eb124b98c99efd0b408728ac6ebf38173958"}, + {file = "kiwisolver-1.4.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b9098e0049e88c6a24ff64545cdfc50807818ba6c1b739cae221bbbcbc58aad3"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:00bd361b903dc4bbf4eb165f24d1acbee754fce22ded24c3d56eec268658a5cf"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7b8b454bac16428b22560d0a1cf0a09875339cab69df61d7805bf48919415901"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:f1d072c2eb0ad60d4c183f3fb44ac6f73fb7a8f16a2694a91f988275cbf352f9"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:31a82d498054cac9f6d0b53d02bb85811185bcb477d4b60144f915f3b3126342"}, + {file = "kiwisolver-1.4.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6512cb89e334e4700febbffaaa52761b65b4f5a3cf33f960213d5656cea36a77"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win32.whl", hash = "sha256:9db8ea4c388fdb0f780fe91346fd438657ea602d58348753d9fb265ce1bca67f"}, + {file = "kiwisolver-1.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:59415f46a37f7f2efeec758353dd2eae1b07640d8ca0f0c42548ec4125492635"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5c7b3b3a728dc6faf3fc372ef24f21d1e3cee2ac3e9596691d746e5a536de920"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:620ced262a86244e2be10a676b646f29c34537d0d9cc8eb26c08f53d98013390"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:378a214a1e3bbf5ac4a8708304318b4f890da88c9e6a07699c4ae7174c09a68d"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf7be1207676ac608a50cd08f102f6742dbfc70e8d60c4db1c6897f62f71523"}, + {file = "kiwisolver-1.4.5-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ba55dce0a9b8ff59495ddd050a0225d58bd0983d09f87cfe2b6aec4f2c1234e4"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:fd32ea360bcbb92d28933fc05ed09bffcb1704ba3fc7942e81db0fd4f81a7892"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:5e7139af55d1688f8b960ee9ad5adafc4ac17c1c473fe07133ac092310d76544"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dced8146011d2bc2e883f9bd68618b8247387f4bbec46d7392b3c3b032640126"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9bf3325c47b11b2e51bca0824ea217c7cd84491d8ac4eefd1e409705ef092bd"}, + {file = "kiwisolver-1.4.5-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5794cf59533bc3f1b1c821f7206a3617999db9fbefc345360aafe2e067514929"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e368f200bbc2e4f905b8e71eb38b3c04333bddaa6a2464a6355487b02bb7fb09"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5d706eba36b4c4d5bc6c6377bb6568098765e990cfc21ee16d13963fab7b3e7"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85267bd1aa8880a9c88a8cb71e18d3d64d2751a790e6ca6c27b8ccc724bcd5ad"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210ef2c3a1f03272649aff1ef992df2e724748918c4bc2d5a90352849eb40bea"}, + {file = "kiwisolver-1.4.5-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:11d011a7574eb3b82bcc9c1a1d35c1d7075677fdd15de527d91b46bd35e935ee"}, + {file = "kiwisolver-1.4.5.tar.gz", hash = "sha256:e57e563a57fb22a142da34f38acc2fc1a5c864bc29ca1517a88abc963e60d6ec"}, +] + +[[package]] +name = "matplotlib" +version = "3.8.1" +description = "Python plotting package" +optional = false +python-versions = ">=3.9" +files = [ + {file = "matplotlib-3.8.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:e11ab864323fa73ac1b7849688d9671c47a2665242e899785b4db1a375b547e1"}, + {file = "matplotlib-3.8.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:43a9d40feb63c9e31a0b8b069dcbd74a912f59bdc0095d187126694cd26977e4"}, + {file = "matplotlib-3.8.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:608ea2951838d391e45dec2e644888db6899c752d3c29e157af9dcefb3d7d8d5"}, + {file = "matplotlib-3.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82ec95b02e894561c21e066bd0c716e4b410df141ce9441aa5af6cd937e4ade2"}, + {file = "matplotlib-3.8.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e3ad1759ad4a5245172c6d32b8ada603a6020d03211524c39d78d25c9a7dc0d2"}, + {file = "matplotlib-3.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:20a0fdfd3ee836179047f3782be060057b878ad37f5abe29edf006a1ff3ecd73"}, + {file = "matplotlib-3.8.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7658b7073c1d6a2922ecc0ed41602410fae88586cb8a54f7a2063d537b6beaf7"}, + {file = "matplotlib-3.8.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf6889643d4560fcc56f9f0941f078e4df0d72a6c3e4ca548841fc13c5642664"}, + {file = "matplotlib-3.8.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff842e27bc6a80de08c40e0bfdce460bd08080e8a94af131162b6a1b8948f2cc"}, + {file = "matplotlib-3.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f99d07c0e753717775be7be39ab383453b4d8b629c9fa174596b970c6555890"}, + {file = "matplotlib-3.8.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f34b46dbb1db1f09bfa937cd5853e5f2af232caeeff509c3ab6e43fd33780eae"}, + {file = "matplotlib-3.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1fcb49b6baf0375281979cbf26695ec10bd1cada1e311893e89533b3b70143e7"}, + {file = "matplotlib-3.8.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e17674ee127f78f26fea237e7f4d5cf910a8be82beb6260fedf358b88075b823"}, + {file = "matplotlib-3.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d921c0270647ab11c3ef283efaaa3d46fd005ba233bfb3aea75231cdf3656de8"}, + {file = "matplotlib-3.8.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2afe7d2f8c9e35e94fbcfcfd9b28f29cb32f0a9068cba469cf907428379c8db9"}, + {file = "matplotlib-3.8.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5a504ff40f81d6233603475a45497a6dca37a873393fa20ae6f7dd6596ef72b"}, + {file = "matplotlib-3.8.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:cd54bbf089953140905768ed4626d7223e1ad1d7e2a138410a9c4d3b865ccd80"}, + {file = "matplotlib-3.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:27502d2452208ae784c19504644f09f83742809143bbeae147617640930aa344"}, + {file = "matplotlib-3.8.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:f55fb5ff02d999a100be28bf6ffe826e1867a54c7b465409685332c9dd48ffa5"}, + {file = "matplotlib-3.8.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:afb72822ae410d62aa1a2920c6563cb5680de9078358f0e9474396c6c3e06be2"}, + {file = "matplotlib-3.8.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:43cf368a4a1d8cbc426944806e5e183cead746647a64d2cdb786441546235967"}, + {file = "matplotlib-3.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c54c55457c7f5ea4dfdba0020004fc7667f5c10c8d9b8010d735345acc06c9b8"}, + {file = "matplotlib-3.8.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e3bb809b743653b5aab5d72ee45c8c937c28e147b0846b0826a54bece898608c"}, + {file = "matplotlib-3.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:c1b0ecaa0d1f4fe1e30f625a2347f0034a89a7d17c39efbb502e554d92ee2f61"}, + {file = "matplotlib-3.8.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ca84deaa38cb64b7dd160ca2046b45f7b5dbff2b0179642e1339fadc337446c9"}, + {file = "matplotlib-3.8.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed3b29f54f6bbf3eaca4cbd23bc260155153ace63b7f597c474fa6fc6f386530"}, + {file = "matplotlib-3.8.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0d24c47a1bb47e392fbcd26fe322e4ff3431653ac1e8718e4e147d450ae97a44"}, + {file = "matplotlib-3.8.1.tar.gz", hash = "sha256:044df81c1f6f3a8e52d70c4cfcb44e77ea9632a10929932870dfaa90de94365d"}, +] + +[package.dependencies] +contourpy = ">=1.0.1" +cycler = ">=0.10" +fonttools = ">=4.22.0" +kiwisolver = ">=1.3.1" +numpy = ">=1.21,<2" +packaging = ">=20.0" +pillow = ">=8" +pyparsing = ">=2.3.1" +python-dateutil = ">=2.7" [[package]] name = "numpy" version = "1.25.1" description = "Fundamental package for array computing in Python" -category = "main" optional = false python-versions = ">=3.9" +files = [ + {file = "numpy-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:77d339465dff3eb33c701430bcb9c325b60354698340229e1dff97745e6b3efa"}, + {file = "numpy-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d736b75c3f2cb96843a5c7f8d8ccc414768d34b0a75f466c05f3a739b406f10b"}, + {file = "numpy-1.25.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a90725800caeaa160732d6b31f3f843ebd45d6b5f3eec9e8cc287e30f2805bf"}, + {file = "numpy-1.25.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c6c9261d21e617c6dc5eacba35cb68ec36bb72adcff0dee63f8fbc899362588"}, + {file = "numpy-1.25.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0def91f8af6ec4bb94c370e38c575855bf1d0be8a8fbfba42ef9c073faf2cf19"}, + {file = "numpy-1.25.1-cp310-cp310-win32.whl", hash = "sha256:fd67b306320dcadea700a8f79b9e671e607f8696e98ec255915c0c6d6b818503"}, + {file = "numpy-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:c1516db588987450b85595586605742879e50dcce923e8973f79529651545b57"}, + {file = "numpy-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6b82655dd8efeea69dbf85d00fca40013d7f503212bc5259056244961268b66e"}, + {file = "numpy-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e8f6049c4878cb16960fbbfb22105e49d13d752d4d8371b55110941fb3b17800"}, + {file = "numpy-1.25.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41a56b70e8139884eccb2f733c2f7378af06c82304959e174f8e7370af112e09"}, + {file = "numpy-1.25.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5154b1a25ec796b1aee12ac1b22f414f94752c5f94832f14d8d6c9ac40bcca6"}, + {file = "numpy-1.25.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:38eb6548bb91c421261b4805dc44def9ca1a6eef6444ce35ad1669c0f1a3fc5d"}, + {file = "numpy-1.25.1-cp311-cp311-win32.whl", hash = "sha256:791f409064d0a69dd20579345d852c59822c6aa087f23b07b1b4e28ff5880fcb"}, + {file = "numpy-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:c40571fe966393b212689aa17e32ed905924120737194b5d5c1b20b9ed0fb171"}, + {file = "numpy-1.25.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3d7abcdd85aea3e6cdddb59af2350c7ab1ed764397f8eec97a038ad244d2d105"}, + {file = "numpy-1.25.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1a180429394f81c7933634ae49b37b472d343cccb5bb0c4a575ac8bbc433722f"}, + {file = "numpy-1.25.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d412c1697c3853c6fc3cb9751b4915859c7afe6a277c2bf00acf287d56c4e625"}, + {file = "numpy-1.25.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20e1266411120a4f16fad8efa8e0454d21d00b8c7cee5b5ccad7565d95eb42dd"}, + {file = "numpy-1.25.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f76aebc3358ade9eacf9bc2bb8ae589863a4f911611694103af05346637df1b7"}, + {file = "numpy-1.25.1-cp39-cp39-win32.whl", hash = "sha256:247d3ffdd7775bdf191f848be8d49100495114c82c2bd134e8d5d075fb386a1c"}, + {file = "numpy-1.25.1-cp39-cp39-win_amd64.whl", hash = "sha256:1d5d3c68e443c90b38fdf8ef40e60e2538a27548b39b12b73132456847f4b631"}, + {file = "numpy-1.25.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:35a9527c977b924042170a0887de727cd84ff179e478481404c5dc66b4170009"}, + {file = "numpy-1.25.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d3fe3dd0506a28493d82dc3cf254be8cd0d26f4008a417385cbf1ae95b54004"}, + {file = "numpy-1.25.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:012097b5b0d00a11070e8f2e261128c44157a8689f7dedcf35576e525893f4fe"}, + {file = "numpy-1.25.1.tar.gz", hash = "sha256:9a3a9f3a61480cc086117b426a8bd86869c213fc4072e606f01c4e4b66eb92bf"}, +] [[package]] name = "packaging" version = "23.1" description = "Core utilities for Python packages" -category = "dev" optional = false python-versions = ">=3.7" +files = [ + {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"}, + {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"}, +] [[package]] name = "pandas" version = "2.0.3" description = "Powerful data structures for data analysis, time series, and statistics" -category = "main" optional = false python-versions = ">=3.8" +files = [ + {file = "pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8"}, + {file = "pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0"}, + {file = "pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210"}, + {file = "pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df"}, + {file = "pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd"}, + {file = "pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, + {file = "pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02"}, + {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641"}, + {file = "pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682"}, + {file = "pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] [package.dependencies] numpy = [ @@ -71,7 +513,7 @@ pytz = ">=2020.1" tzdata = ">=2022.1" [package.extras] -all = ["beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "PyQt5 (>=5.15.1)", "pyreadstat (>=1.1.2)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "pytest-asyncio (>=0.17.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "scipy (>=1.7.1)", "s3fs (>=2021.08.0)", "SQLAlchemy (>=1.4.16)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] +all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] aws = ["s3fs (>=2021.08.0)"] clipboard = ["PyQt5 (>=5.15.1)", "qtpy (>=2.2.0)"] compression = ["brotlipy (>=0.7.0)", "python-snappy (>=0.6.0)", "zstandard (>=0.15.2)"] @@ -83,23 +525,93 @@ gcp = ["gcsfs (>=2021.07.0)", "pandas-gbq (>=0.15.0)"] hdf5 = ["tables (>=3.6.1)"] html = ["beautifulsoup4 (>=4.9.3)", "html5lib (>=1.1)", "lxml (>=4.6.3)"] mysql = ["SQLAlchemy (>=1.4.16)", "pymysql (>=1.0.2)"] -output_formatting = ["jinja2 (>=3.0.0)", "tabulate (>=0.8.9)"] +output-formatting = ["jinja2 (>=3.0.0)", "tabulate (>=0.8.9)"] parquet = ["pyarrow (>=7.0.0)"] performance = ["bottleneck (>=1.3.2)", "numba (>=0.53.1)", "numexpr (>=2.7.1)"] plot = ["matplotlib (>=3.6.1)"] postgresql = ["SQLAlchemy (>=1.4.16)", "psycopg2 (>=2.8.6)"] spss = ["pyreadstat (>=1.1.2)"] sql-other = ["SQLAlchemy (>=1.4.16)"] -test = ["hypothesis (>=6.34.2)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "pytest-asyncio (>=0.17.0)"] +test = ["hypothesis (>=6.34.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] xml = ["lxml (>=4.6.3)"] +[[package]] +name = "pillow" +version = "10.1.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "Pillow-10.1.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1ab05f3db77e98f93964697c8efc49c7954b08dd61cff526b7f2531a22410106"}, + {file = "Pillow-10.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6932a7652464746fcb484f7fc3618e6503d2066d853f68a4bd97193a3996e273"}, + {file = "Pillow-10.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f63b5a68daedc54c7c3464508d8c12075e56dcfbd42f8c1bf40169061ae666"}, + {file = "Pillow-10.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0949b55eb607898e28eaccb525ab104b2d86542a85c74baf3a6dc24002edec2"}, + {file = "Pillow-10.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ae88931f93214777c7a3aa0a8f92a683f83ecde27f65a45f95f22d289a69e593"}, + {file = "Pillow-10.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b0eb01ca85b2361b09480784a7931fc648ed8b7836f01fb9241141b968feb1db"}, + {file = "Pillow-10.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d27b5997bdd2eb9fb199982bb7eb6164db0426904020dc38c10203187ae2ff2f"}, + {file = "Pillow-10.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7df5608bc38bd37ef585ae9c38c9cd46d7c81498f086915b0f97255ea60c2818"}, + {file = "Pillow-10.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:41f67248d92a5e0a2076d3517d8d4b1e41a97e2df10eb8f93106c89107f38b57"}, + {file = "Pillow-10.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1fb29c07478e6c06a46b867e43b0bcdb241b44cc52be9bc25ce5944eed4648e7"}, + {file = "Pillow-10.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2cdc65a46e74514ce742c2013cd4a2d12e8553e3a2563c64879f7c7e4d28bce7"}, + {file = "Pillow-10.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50d08cd0a2ecd2a8657bd3d82c71efd5a58edb04d9308185d66c3a5a5bed9610"}, + {file = "Pillow-10.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:062a1610e3bc258bff2328ec43f34244fcec972ee0717200cb1425214fe5b839"}, + {file = "Pillow-10.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:61f1a9d247317fa08a308daaa8ee7b3f760ab1809ca2da14ecc88ae4257d6172"}, + {file = "Pillow-10.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a646e48de237d860c36e0db37ecaecaa3619e6f3e9d5319e527ccbc8151df061"}, + {file = "Pillow-10.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:47e5bf85b80abc03be7455c95b6d6e4896a62f6541c1f2ce77a7d2bb832af262"}, + {file = "Pillow-10.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a92386125e9ee90381c3369f57a2a50fa9e6aa8b1cf1d9c4b200d41a7dd8e992"}, + {file = "Pillow-10.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f7c276c05a9767e877a0b4c5050c8bee6a6d960d7f0c11ebda6b99746068c2a"}, + {file = "Pillow-10.1.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:a89b8312d51715b510a4fe9fc13686283f376cfd5abca8cd1c65e4c76e21081b"}, + {file = "Pillow-10.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:00f438bb841382b15d7deb9a05cc946ee0f2c352653c7aa659e75e592f6fa17d"}, + {file = "Pillow-10.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d929a19f5469b3f4df33a3df2983db070ebb2088a1e145e18facbc28cae5b27"}, + {file = "Pillow-10.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a92109192b360634a4489c0c756364c0c3a2992906752165ecb50544c251312"}, + {file = "Pillow-10.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:0248f86b3ea061e67817c47ecbe82c23f9dd5d5226200eb9090b3873d3ca32de"}, + {file = "Pillow-10.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9882a7451c680c12f232a422730f986a1fcd808da0fd428f08b671237237d651"}, + {file = "Pillow-10.1.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1c3ac5423c8c1da5928aa12c6e258921956757d976405e9467c5f39d1d577a4b"}, + {file = "Pillow-10.1.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:806abdd8249ba3953c33742506fe414880bad78ac25cc9a9b1c6ae97bedd573f"}, + {file = "Pillow-10.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:eaed6977fa73408b7b8a24e8b14e59e1668cfc0f4c40193ea7ced8e210adf996"}, + {file = "Pillow-10.1.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:fe1e26e1ffc38be097f0ba1d0d07fcade2bcfd1d023cda5b29935ae8052bd793"}, + {file = "Pillow-10.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7a7e3daa202beb61821c06d2517428e8e7c1aab08943e92ec9e5755c2fc9ba5e"}, + {file = "Pillow-10.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:24fadc71218ad2b8ffe437b54876c9382b4a29e030a05a9879f615091f42ffc2"}, + {file = "Pillow-10.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa1d323703cfdac2036af05191b969b910d8f115cf53093125e4058f62012c9a"}, + {file = "Pillow-10.1.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:912e3812a1dbbc834da2b32299b124b5ddcb664ed354916fd1ed6f193f0e2d01"}, + {file = "Pillow-10.1.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:7dbaa3c7de82ef37e7708521be41db5565004258ca76945ad74a8e998c30af8d"}, + {file = "Pillow-10.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9d7bc666bd8c5a4225e7ac71f2f9d12466ec555e89092728ea0f5c0c2422ea80"}, + {file = "Pillow-10.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:baada14941c83079bf84c037e2d8b7506ce201e92e3d2fa0d1303507a8538212"}, + {file = "Pillow-10.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:2ef6721c97894a7aa77723740a09547197533146fba8355e86d6d9a4a1056b14"}, + {file = "Pillow-10.1.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0a026c188be3b443916179f5d04548092e253beb0c3e2ee0a4e2cdad72f66099"}, + {file = "Pillow-10.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:04f6f6149f266a100374ca3cc368b67fb27c4af9f1cc8cb6306d849dcdf12616"}, + {file = "Pillow-10.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb40c011447712d2e19cc261c82655f75f32cb724788df315ed992a4d65696bb"}, + {file = "Pillow-10.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a8413794b4ad9719346cd9306118450b7b00d9a15846451549314a58ac42219"}, + {file = "Pillow-10.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c9aeea7b63edb7884b031a35305629a7593272b54f429a9869a4f63a1bf04c34"}, + {file = "Pillow-10.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b4005fee46ed9be0b8fb42be0c20e79411533d1fd58edabebc0dd24626882cfd"}, + {file = "Pillow-10.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:4d0152565c6aa6ebbfb1e5d8624140a440f2b99bf7afaafbdbf6430426497f28"}, + {file = "Pillow-10.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d921bc90b1defa55c9917ca6b6b71430e4286fc9e44c55ead78ca1a9f9eba5f2"}, + {file = "Pillow-10.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:cfe96560c6ce2f4c07d6647af2d0f3c54cc33289894ebd88cfbb3bcd5391e256"}, + {file = "Pillow-10.1.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:937bdc5a7f5343d1c97dc98149a0be7eb9704e937fe3dc7140e229ae4fc572a7"}, + {file = "Pillow-10.1.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1c25762197144e211efb5f4e8ad656f36c8d214d390585d1d21281f46d556ba"}, + {file = "Pillow-10.1.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:afc8eef765d948543a4775f00b7b8c079b3321d6b675dde0d02afa2ee23000b4"}, + {file = "Pillow-10.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:883f216eac8712b83a63f41b76ddfb7b2afab1b74abbb413c5df6680f071a6b9"}, + {file = "Pillow-10.1.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b920e4d028f6442bea9a75b7491c063f0b9a3972520731ed26c83e254302eb1e"}, + {file = "Pillow-10.1.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c41d960babf951e01a49c9746f92c5a7e0d939d1652d7ba30f6b3090f27e412"}, + {file = "Pillow-10.1.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1fafabe50a6977ac70dfe829b2d5735fd54e190ab55259ec8aea4aaea412fa0b"}, + {file = "Pillow-10.1.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3b834f4b16173e5b92ab6566f0473bfb09f939ba14b23b8da1f54fa63e4b623f"}, + {file = "Pillow-10.1.0.tar.gz", hash = "sha256:e6bf8de6c36ed96c86ea3b6e1d5273c53f46ef518a062464cd7ef5dd2cf92e38"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] + [[package]] name = "pluggy" version = "1.2.0" description = "plugin and hook calling mechanisms for python" -category = "dev" optional = false python-versions = ">=3.7" +files = [ + {file = "pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849"}, + {file = "pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3"}, +] [package.extras] dev = ["pre-commit", "tox"] @@ -109,17 +621,37 @@ testing = ["pytest", "pytest-benchmark"] name = "py" version = "1.11.0" description = "library with cross-python path, ini-parsing, io, code, log facilities" -category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, + {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, +] + +[[package]] +name = "pyparsing" +version = "3.1.1" +description = "pyparsing module - Classes and methods to define and execute parsing grammars" +optional = false +python-versions = ">=3.6.8" +files = [ + {file = "pyparsing-3.1.1-py3-none-any.whl", hash = "sha256:32c7c0b711493c72ff18a981d24f28aaf9c1fb7ed5e9667c9e84e3db623bdbfb"}, + {file = "pyparsing-3.1.1.tar.gz", hash = "sha256:ede28a1a32462f5a9705e07aea48001a08f7cf81a021585011deba701581a0db"}, +] + +[package.extras] +diagrams = ["jinja2", "railroad-diagrams"] [[package]] name = "pytest" version = "6.2.5" description = "pytest: simple powerful testing with Python" -category = "dev" optional = false python-versions = ">=3.6" +files = [ + {file = "pytest-6.2.5-py3-none-any.whl", hash = "sha256:7310f8d27bc79ced999e760ca304d69f6ba6c6649c0b60fb0e04a4a77cacc134"}, + {file = "pytest-6.2.5.tar.gz", hash = "sha256:131b36680866a76e6781d13f101efb86cf674ebb9762eb70d3082b6f29889e89"}, +] [package.dependencies] atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""} @@ -138,9 +670,12 @@ testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "requests", "xm name = "python-dateutil" version = "2.8.2" description = "Extensions to the standard Python datetime module" -category = "main" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, + {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, +] [package.dependencies] six = ">=1.5" @@ -149,17 +684,65 @@ six = ">=1.5" name = "pytz" version = "2023.3" description = "World timezone definitions, modern and historical" -category = "main" optional = false python-versions = "*" +files = [ + {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, + {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, +] + +[[package]] +name = "scipy" +version = "1.11.3" +description = "Fundamental algorithms for scientific computing in Python" +optional = false +python-versions = "<3.13,>=3.9" +files = [ + {file = "scipy-1.11.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:370f569c57e1d888304052c18e58f4a927338eafdaef78613c685ca2ea0d1fa0"}, + {file = "scipy-1.11.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:9885e3e4f13b2bd44aaf2a1a6390a11add9f48d5295f7a592393ceb8991577a3"}, + {file = "scipy-1.11.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e04aa19acc324a1a076abb4035dabe9b64badb19f76ad9c798bde39d41025cdc"}, + {file = "scipy-1.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e1a8a4657673bfae1e05e1e1d6e94b0cabe5ed0c7c144c8aa7b7dbb774ce5c1"}, + {file = "scipy-1.11.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7abda0e62ef00cde826d441485e2e32fe737bdddee3324e35c0e01dee65e2a88"}, + {file = "scipy-1.11.3-cp310-cp310-win_amd64.whl", hash = "sha256:033c3fd95d55012dd1148b201b72ae854d5086d25e7c316ec9850de4fe776929"}, + {file = "scipy-1.11.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:925c6f09d0053b1c0f90b2d92d03b261e889b20d1c9b08a3a51f61afc5f58165"}, + {file = "scipy-1.11.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5664e364f90be8219283eeb844323ff8cd79d7acbd64e15eb9c46b9bc7f6a42a"}, + {file = "scipy-1.11.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00f325434b6424952fbb636506f0567898dca7b0f7654d48f1c382ea338ce9a3"}, + {file = "scipy-1.11.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f290cf561a4b4edfe8d1001ee4be6da60c1c4ea712985b58bf6bc62badee221"}, + {file = "scipy-1.11.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:91770cb3b1e81ae19463b3c235bf1e0e330767dca9eb4cd73ba3ded6c4151e4d"}, + {file = "scipy-1.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1f97cd89c0fe1a0685f8f89d85fa305deb3067d0668151571ba50913e445820"}, + {file = "scipy-1.11.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:dfcc1552add7cb7c13fb70efcb2389d0624d571aaf2c80b04117e2755a0c5d15"}, + {file = "scipy-1.11.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0d3a136ae1ff0883fffbb1b05b0b2fea251cb1046a5077d0b435a1839b3e52b7"}, + {file = "scipy-1.11.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bae66a2d7d5768eaa33008fa5a974389f167183c87bf39160d3fefe6664f8ddc"}, + {file = "scipy-1.11.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2f6dee6cbb0e263b8142ed587bc93e3ed5e777f1f75448d24fb923d9fd4dce6"}, + {file = "scipy-1.11.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:74e89dc5e00201e71dd94f5f382ab1c6a9f3ff806c7d24e4e90928bb1aafb280"}, + {file = "scipy-1.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:90271dbde4be191522b3903fc97334e3956d7cfb9cce3f0718d0ab4fd7d8bfd6"}, + {file = "scipy-1.11.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a63d1ec9cadecce838467ce0631c17c15c7197ae61e49429434ba01d618caa83"}, + {file = "scipy-1.11.3-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:5305792c7110e32ff155aed0df46aa60a60fc6e52cd4ee02cdeb67eaccd5356e"}, + {file = "scipy-1.11.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ea7f579182d83d00fed0e5c11a4aa5ffe01460444219dedc448a36adf0c3917"}, + {file = "scipy-1.11.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c77da50c9a91e23beb63c2a711ef9e9ca9a2060442757dffee34ea41847d8156"}, + {file = "scipy-1.11.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:15f237e890c24aef6891c7d008f9ff7e758c6ef39a2b5df264650eb7900403c0"}, + {file = "scipy-1.11.3-cp39-cp39-win_amd64.whl", hash = "sha256:4b4bb134c7aa457e26cc6ea482b016fef45db71417d55cc6d8f43d799cdf9ef2"}, + {file = "scipy-1.11.3.tar.gz", hash = "sha256:bba4d955f54edd61899776bad459bf7326e14b9fa1c552181f0479cc60a568cd"}, +] + +[package.dependencies] +numpy = ">=1.21.6,<1.28.0" + +[package.extras] +dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] +doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] +test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] [[package]] name = "sigfig" version = "1.3.2" description = "Python library for rounding numbers (with expected results)" -category = "main" optional = false python-versions = "*" +files = [ + {file = "sigfig-1.3.2-py3-none-any.whl", hash = "sha256:b54d4943ba553671bf18da2da109d7824cf44e7c80032a0fb56a6c209e558ee3"}, + {file = "sigfig-1.3.2.tar.gz", hash = "sha256:97a1225a38924e0586365500668fa3f2ba023bdb103207ea676507af378fce32"}, +] [package.dependencies] SortedContainers = "*" @@ -168,150 +751,47 @@ SortedContainers = "*" name = "six" version = "1.16.0" description = "Python 2 and 3 compatibility utilities" -category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] [[package]] name = "sortedcontainers" version = "2.4.0" description = "Sorted Containers -- Sorted List, Sorted Dict, Sorted Set" -category = "main" optional = false python-versions = "*" +files = [ + {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"}, + {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"}, +] [[package]] name = "toml" version = "0.10.2" description = "Python Library for Tom's Obvious, Minimal Language" -category = "dev" optional = false python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, + {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, +] [[package]] name = "tzdata" version = "2023.3" description = "Provider of IANA time zone data" -category = "main" optional = false python-versions = ">=2" - -[metadata] -lock-version = "1.1" -python-versions = "^3.10" -content-hash = "9aaa04eaad611d0b6b1b768b7e863dbe0ec12e6d0ec934cdd98a72d342192f7e" - -[metadata.files] -atomicwrites = [ - {file = "atomicwrites-1.4.1.tar.gz", hash = "sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11"}, -] -attrs = [ - {file = "attrs-23.1.0-py3-none-any.whl", hash = "sha256:1f28b4522cdc2fb4256ac1a020c78acf9cba2c6b461ccd2c126f3aa8e8335d04"}, - {file = "attrs-23.1.0.tar.gz", hash = "sha256:6279836d581513a26f1bf235f9acd333bc9115683f14f7e8fae46c98fc50e015"}, -] -colorama = [ - {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, - {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, -] -iniconfig = [ - {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, - {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, -] -numpy = [ - {file = "numpy-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:77d339465dff3eb33c701430bcb9c325b60354698340229e1dff97745e6b3efa"}, - {file = "numpy-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d736b75c3f2cb96843a5c7f8d8ccc414768d34b0a75f466c05f3a739b406f10b"}, - {file = "numpy-1.25.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a90725800caeaa160732d6b31f3f843ebd45d6b5f3eec9e8cc287e30f2805bf"}, - {file = "numpy-1.25.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c6c9261d21e617c6dc5eacba35cb68ec36bb72adcff0dee63f8fbc899362588"}, - {file = "numpy-1.25.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0def91f8af6ec4bb94c370e38c575855bf1d0be8a8fbfba42ef9c073faf2cf19"}, - {file = "numpy-1.25.1-cp310-cp310-win32.whl", hash = "sha256:fd67b306320dcadea700a8f79b9e671e607f8696e98ec255915c0c6d6b818503"}, - {file = "numpy-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:c1516db588987450b85595586605742879e50dcce923e8973f79529651545b57"}, - {file = "numpy-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6b82655dd8efeea69dbf85d00fca40013d7f503212bc5259056244961268b66e"}, - {file = "numpy-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e8f6049c4878cb16960fbbfb22105e49d13d752d4d8371b55110941fb3b17800"}, - {file = "numpy-1.25.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41a56b70e8139884eccb2f733c2f7378af06c82304959e174f8e7370af112e09"}, - {file = "numpy-1.25.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5154b1a25ec796b1aee12ac1b22f414f94752c5f94832f14d8d6c9ac40bcca6"}, - {file = "numpy-1.25.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:38eb6548bb91c421261b4805dc44def9ca1a6eef6444ce35ad1669c0f1a3fc5d"}, - {file = "numpy-1.25.1-cp311-cp311-win32.whl", hash = "sha256:791f409064d0a69dd20579345d852c59822c6aa087f23b07b1b4e28ff5880fcb"}, - {file = "numpy-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:c40571fe966393b212689aa17e32ed905924120737194b5d5c1b20b9ed0fb171"}, - {file = "numpy-1.25.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3d7abcdd85aea3e6cdddb59af2350c7ab1ed764397f8eec97a038ad244d2d105"}, - {file = "numpy-1.25.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1a180429394f81c7933634ae49b37b472d343cccb5bb0c4a575ac8bbc433722f"}, - {file = "numpy-1.25.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d412c1697c3853c6fc3cb9751b4915859c7afe6a277c2bf00acf287d56c4e625"}, - {file = "numpy-1.25.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20e1266411120a4f16fad8efa8e0454d21d00b8c7cee5b5ccad7565d95eb42dd"}, - {file = "numpy-1.25.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f76aebc3358ade9eacf9bc2bb8ae589863a4f911611694103af05346637df1b7"}, - {file = "numpy-1.25.1-cp39-cp39-win32.whl", hash = "sha256:247d3ffdd7775bdf191f848be8d49100495114c82c2bd134e8d5d075fb386a1c"}, - {file = "numpy-1.25.1-cp39-cp39-win_amd64.whl", hash = "sha256:1d5d3c68e443c90b38fdf8ef40e60e2538a27548b39b12b73132456847f4b631"}, - {file = "numpy-1.25.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:35a9527c977b924042170a0887de727cd84ff179e478481404c5dc66b4170009"}, - {file = "numpy-1.25.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d3fe3dd0506a28493d82dc3cf254be8cd0d26f4008a417385cbf1ae95b54004"}, - {file = "numpy-1.25.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:012097b5b0d00a11070e8f2e261128c44157a8689f7dedcf35576e525893f4fe"}, - {file = "numpy-1.25.1.tar.gz", hash = "sha256:9a3a9f3a61480cc086117b426a8bd86869c213fc4072e606f01c4e4b66eb92bf"}, -] -packaging = [ - {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"}, - {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"}, -] -pandas = [ - {file = "pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8"}, - {file = "pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f"}, - {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183"}, - {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0"}, - {file = "pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210"}, - {file = "pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e"}, - {file = "pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8"}, - {file = "pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26"}, - {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d"}, - {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df"}, - {file = "pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd"}, - {file = "pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b"}, - {file = "pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061"}, - {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, - {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089"}, - {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, - {file = "pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02"}, - {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, - {file = "pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b"}, - {file = "pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e"}, - {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b"}, - {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641"}, - {file = "pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682"}, - {file = "pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc"}, - {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, -] -pluggy = [ - {file = "pluggy-1.2.0-py3-none-any.whl", hash = "sha256:c2fd55a7d7a3863cba1a013e4e2414658b1d07b6bc57b3919e0c63c9abb99849"}, - {file = "pluggy-1.2.0.tar.gz", hash = "sha256:d12f0c4b579b15f5e054301bb226ee85eeeba08ffec228092f8defbaa3a4c4b3"}, -] -py = [ - {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, - {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, -] -pytest = [ - {file = "pytest-6.2.5-py3-none-any.whl", hash = "sha256:7310f8d27bc79ced999e760ca304d69f6ba6c6649c0b60fb0e04a4a77cacc134"}, - {file = "pytest-6.2.5.tar.gz", hash = "sha256:131b36680866a76e6781d13f101efb86cf674ebb9762eb70d3082b6f29889e89"}, -] -python-dateutil = [ - {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, - {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, -] -pytz = [ - {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, - {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, -] -sigfig = [ - {file = "sigfig-1.3.2-py3-none-any.whl", hash = "sha256:b54d4943ba553671bf18da2da109d7824cf44e7c80032a0fb56a6c209e558ee3"}, - {file = "sigfig-1.3.2.tar.gz", hash = "sha256:97a1225a38924e0586365500668fa3f2ba023bdb103207ea676507af378fce32"}, -] -six = [ - {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, - {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, -] -sortedcontainers = [ - {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"}, - {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"}, -] -toml = [ - {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, - {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, -] -tzdata = [ +files = [ {file = "tzdata-2023.3-py2.py3-none-any.whl", hash = "sha256:7e65763eef3120314099b6939b5546db7adce1e7d6f2e179e3df563c70511eda"}, {file = "tzdata-2023.3.tar.gz", hash = "sha256:11ef1e08e54acb0d4f95bdb1be05da659673de4acbd21bf9c69e94cc5e907a3a"}, ] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.10,<3.13" +content-hash = "e6cd7996f720177a4fc849e59c51a280ba65a9cc8b407a3e79a363753301bcc5" diff --git a/pyproject.toml b/pyproject.toml index 8a25ba1..4da2ba1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,10 +11,12 @@ repository = "https://github.com/open-resources/problem_bank_helpers" include = [{ path = "data/", format = ["sdist", "wheel"]}] [tool.poetry.dependencies] -python = "^3.10" +python = ">=3.10,<3.13" sigfig = "^1.1.9" numpy = "^1.20.3" pandas = "^2.0.0" +matplotlib = "^3.8.1" +scipy = "^1.11.3" [tool.poetry.dev-dependencies] pytest = "^6.2.4" From 15bcacbccbfdb0d7a1c065b4907f273d869649f6 Mon Sep 17 00:00:00 2001 From: Bluesy1 <68259537+Bluesy1@users.noreply.github.com> Date: Thu, 2 Nov 2023 21:19:36 -0700 Subject: [PATCH 3/3] Minor formatting nit --- notebook_features/shaded_normal_density_curve.ipynb | 6 +++--- src/problem_bank_helpers/stats.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/notebook_features/shaded_normal_density_curve.ipynb b/notebook_features/shaded_normal_density_curve.ipynb index 396b3cc..1029b2b 100644 --- a/notebook_features/shaded_normal_density_curve.ipynb +++ b/notebook_features/shaded_normal_density_curve.ipynb @@ -60,7 +60,7 @@ " figsize : tuple of 2 floats or None, default: (8, 6)\n", " The size of the plot in inches. If None, the default matplotlib figure size will be used as this is passed to `matplotlib.pyplot.figure`.\n", " color : color, default: 'xkcd:sky blue'\n", - " The color of the shaded area as a valid _.\n", + " The color of the shaded area as a valid `matplotlib color `__.\n", " x_label : str, default: 'x'\n", " The label for the x-axis.\n", " y_label : str, default: 'f(x; μ,σ)'\n", @@ -84,9 +84,9 @@ "\n", " References\n", " ----------\n", - " Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `_.\n", + " Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `__.\n", "\n", - " The R function by Dr. Irene Vrbick was adapted from `here `_.\n", + " The R function by Dr. Irene Vrbick was adapted from `here `__.\n", " \"\"\"\n", " if not isinstance(mean, (float, int)):\n", " raise TypeError(f\"mean must be a number, not a {mean.__class__.__name__!r}\")\n", diff --git a/src/problem_bank_helpers/stats.py b/src/problem_bank_helpers/stats.py index 14c7fe2..f02ac88 100644 --- a/src/problem_bank_helpers/stats.py +++ b/src/problem_bank_helpers/stats.py @@ -50,7 +50,7 @@ def shaded_normal_density( figsize : tuple of 2 floats or None, default: (8, 6) The size of the plot in inches. If None, the default matplotlib figure size will be used as this is passed to `matplotlib.pyplot.figure`. color : color, default: 'xkcd:sky blue' - The color of the shaded area as a valid _. + The color of the shaded area as a valid `matplotlib color `__. x_label : str, default: 'x' The label for the x-axis. y_label : str, default: 'f(x; μ,σ)' @@ -74,9 +74,9 @@ def shaded_normal_density( References ---------- - Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `_. + Based off of an R function written by Dr. Irene Vrbick for making `shaded normal density curves `__. - The R function by Dr. Irene Vrbick was adapted from `here `_. + The R function by Dr. Irene Vrbick was adapted from `here `__. """ if not isinstance(mean, (float, int)): raise TypeError(f"mean must be a number, not a {mean.__class__.__name__!r}")