From f36401cf17f443406a3a6a8757df8ea2922c0b34 Mon Sep 17 00:00:00 2001 From: bocchanskyy Date: Fri, 8 Nov 2024 21:48:40 +0400 Subject: [PATCH] lab3 done --- lab2/lab2.ipynb | 121 ++++- lab3/lab3.ipynb | 1121 +++++++++++++++++++++++++++++++++++++++++++++++ poetry.lock | 564 ++++++++++++++---------- pyproject.toml | 1 + 4 files changed, 1560 insertions(+), 247 deletions(-) create mode 100644 lab3/lab3.ipynb diff --git a/lab2/lab2.ipynb b/lab2/lab2.ipynb index 357c70e..d29f23c 100644 --- a/lab2/lab2.ipynb +++ b/lab2/lab2.ipynb @@ -36,16 +36,23 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index(['Unnamed: 0', 'carat', 'cut', 'color', 'clarity', 'depth', 'table',\n", - " 'price', 'x', 'y', 'z'],\n", - " dtype='object')\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 3\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpandas\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m df \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m../data/Diamonds-Prices.csv\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(df\u001b[38;5;241m.\u001b[39mcolumns)\n", + "File \u001b[1;32mc:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[1;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[0;32m 1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[0;32m 1014\u001b[0m dialect,\n\u001b[0;32m 1015\u001b[0m delimiter,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1022\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[0;32m 1023\u001b[0m )\n\u001b[0;32m 1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[1;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[1;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[0;32m 617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[0;32m 619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[1;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[0;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", + "File \u001b[1;32mc:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[1;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[0;32m 1617\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m 1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32mc:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1898\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[1;34m(self, f, engine)\u001b[0m\n\u001b[0;32m 1895\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(msg)\n\u001b[0;32m 1897\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m-> 1898\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mmapping\u001b[49m\u001b[43m[\u001b[49m\u001b[43mengine\u001b[49m\u001b[43m]\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 1899\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[0;32m 1900\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[1;32mc:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\pandas\\io\\parsers\\c_parser_wrapper.py:93\u001b[0m, in \u001b[0;36mCParserWrapper.__init__\u001b[1;34m(self, src, **kwds)\u001b[0m\n\u001b[0;32m 90\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdtype_backend\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpyarrow\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m 91\u001b[0m \u001b[38;5;66;03m# Fail here loudly instead of in cython after reading\u001b[39;00m\n\u001b[0;32m 92\u001b[0m import_optional_dependency(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpyarrow\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 93\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reader \u001b[38;5;241m=\u001b[39m \u001b[43mparsers\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTextReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43msrc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 95\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39munnamed_cols \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_reader\u001b[38;5;241m.\u001b[39munnamed_cols\n\u001b[0;32m 97\u001b[0m \u001b[38;5;66;03m# error: Cannot determine type of 'names'\u001b[39;00m\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -1432,7 +1439,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1473,7 +1480,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -1519,47 +1526,83 @@ ], "source": [ "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", "\n", "plt.figure(figsize=(10, 6))\n", "\n", + "\n", "# Связь между возрастом и состоянием\n", + "\n", "plt.subplot(2, 2, 1)\n", + "\n", "sns.scatterplot(data=df, x=\"Age\", y=\"Networth\")\n", + "\n", "plt.title(\"Связь между возрастом и состоянием\")\n", + "\n", "plt.xlabel(\"Возраст\")\n", + "\n", "plt.ylabel(\"Состояние (млрд)\")\n", + "\n", "plt.show()\n", "\n", "\n", + "\n", "# Связь между страной проживания и состоянием (топ-10 стран)\n", + "\n", "plt.subplot(2, 2, 2)\n", + "\n", "top_countries = df[\"Country\"].value_counts().index[:10]\n", + "\n", "sns.boxplot(data=df[df[\"Country\"].isin(top_countries)], x=\"Country\", y=\"Networth\")\n", + "\n", "plt.title(\"Связь между страной проживания и состоянием\")\n", + "\n", "plt.xticks(rotation=90)\n", + "\n", "plt.xlabel(\"Страна\")\n", + "\n", "plt.ylabel(\"Состояние (млрд)\")\n", + "\n", "plt.show()\n", "\n", "\n", + "\n", "# Связь между источником дохода и состоянием (топ-10 источников дохода)\n", + "\n", "plt.subplot(2, 2, 3)\n", + "\n", "top_sources = df[\"Source\"].value_counts().index[:10]\n", + "\n", "sns.boxplot(data=df[df[\"Source\"].isin(top_sources)], x=\"Source\", y=\"Networth\")\n", + "\n", "plt.title(\"Связь между источником дохода и состоянием\")\n", + "\n", "plt.xticks(rotation=90)\n", + "\n", "plt.xlabel(\"Источник дохода\")\n", + "\n", "plt.ylabel(\"Состояние (млрд)\")\n", + "\n", "plt.show()\n", "\n", + "\n", "# Связь между отраслью и состоянием (топ-10 отраслей)\n", + "\n", "plt.subplot(2, 2, 4)\n", + "\n", "top_industries = df[\"Industry\"].value_counts().index[:10]\n", + "\n", "sns.boxplot(data=df[df[\"Industry\"].isin(top_industries)], x=\"Industry\", y=\"Networth\")\n", + "\n", "plt.title(\"Связь между отраслью и состоянием\")\n", + "\n", "plt.xticks(rotation=90)\n", + "\n", "plt.xlabel(\"Отрасль\")\n", + "\n", "plt.ylabel(\"Состояние (млрд)\")\n", + "\n", "plt.show()" ] }, @@ -1572,7 +1615,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -1685,7 +1728,7 @@ "max 2578.000000 219.000000 100.000000" ] }, - "execution_count": 28, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -1711,7 +1754,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -1754,7 +1797,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -1788,7 +1831,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -1824,29 +1867,51 @@ ], "source": [ "# 1. Столбчатая диаграмма по странам\n", + "\n", "plt.figure(figsize=(12, 6))\n", + "\n", "sns.countplot(data=df, x=\"Country\", order=df[\"Country\"].value_counts().index)\n", + "\n", "plt.title(\"Количество людей по странам\")\n", + "\n", "plt.xlabel(\"Страна\")\n", + "\n", "plt.ylabel(\"Количество\")\n", + "\n", "plt.xticks(rotation=45)\n", + "\n", "plt.show()\n", "\n", + "\n", "# 2. Столбчатая диаграмма по отраслям\n", + "\n", "plt.figure(figsize=(12, 6))\n", + "\n", "sns.countplot(data=df, x=\"Industry\", order=df[\"Industry\"].value_counts().index)\n", + "\n", "plt.title(\"Количество людей по отраслям\")\n", + "\n", "plt.xlabel(\"Отрасль\")\n", + "\n", "plt.ylabel(\"Количество\")\n", + "\n", "plt.xticks(rotation=45)\n", + "\n", "plt.show()\n", "\n", + "\n", "# 3. Гистограмма для анализа возраста\n", + "\n", "plt.figure(figsize=(10, 5))\n", + "\n", "sns.histplot(df[\"Age\"], bins=30, kde=True)\n", + "\n", "plt.title(\"Распределение возраста\")\n", + "\n", "plt.xlabel(\"Возраст\")\n", + "\n", "plt.ylabel(\"Частота\")\n", + "\n", "plt.show()" ] }, @@ -1866,7 +1931,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -1875,7 +1940,7 @@ "((1560, 6), (520, 6), (520, 6))" ] }, - "execution_count": 49, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -1901,7 +1966,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -1936,7 +2001,7 @@ " Name: Networth, dtype: float64)" ] }, - "execution_count": 39, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1952,9 +2017,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ImportError", + "evalue": "cannot import name 'SMOTEREG' from 'imblearn.over_sampling' (c:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\imblearn\\over_sampling\\__init__.py)", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mImportError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mimblearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mover_sampling\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m SMOTEREG\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mimblearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01munder_sampling\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m RandomUnderSampler\n\u001b[0;32m 4\u001b[0m oversampler \u001b[38;5;241m=\u001b[39m SMOTEREG(random_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m12\u001b[39m)\n", + "\u001b[1;31mImportError\u001b[0m: cannot import name 'SMOTEREG' from 'imblearn.over_sampling' (c:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\imblearn\\over_sampling\\__init__.py)" + ] + } + ], "source": [ "from imblearn.over_sampling import RandomOverSampler\n", "from imblearn.under_sampling import RandomUnderSampler\n", @@ -1980,9 +2057,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (.venv)", + "display_name": ".venv", "language": "python", - "name": ".venv" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/lab3/lab3.ipynb b/lab3/lab3.ipynb new file mode 100644 index 0000000..9b892a8 --- /dev/null +++ b/lab3/lab3.ipynb @@ -0,0 +1,1121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Вариант 4. Данные по инсультам" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['id', 'gender', 'age', 'hypertension', 'heart_disease', 'ever_married',\n", + " 'work_type', 'Residence_type', 'avg_glucose_level', 'bmi',\n", + " 'smoking_status', 'stroke'],\n", + " dtype='object')\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idgenderagehypertensionheart_diseaseever_marriedwork_typeResidence_typeavg_glucose_levelbmismoking_statusstroke
09046Male67.001YesPrivateUrban228.6936.6formerly smoked1
151676Female61.000YesSelf-employedRural202.21NaNnever smoked1
231112Male80.001YesPrivateRural105.9232.5never smoked1
360182Female49.000YesPrivateUrban171.2334.4smokes1
41665Female79.010YesSelf-employedRural174.1224.0never smoked1
\n", + "
" + ], + "text/plain": [ + " id gender age hypertension heart_disease ever_married \\\n", + "0 9046 Male 67.0 0 1 Yes \n", + "1 51676 Female 61.0 0 0 Yes \n", + "2 31112 Male 80.0 0 1 Yes \n", + "3 60182 Female 49.0 0 0 Yes \n", + "4 1665 Female 79.0 1 0 Yes \n", + "\n", + " work_type Residence_type avg_glucose_level bmi smoking_status \\\n", + "0 Private Urban 228.69 36.6 formerly smoked \n", + "1 Self-employed Rural 202.21 NaN never smoked \n", + "2 Private Rural 105.92 32.5 never smoked \n", + "3 Private Urban 171.23 34.4 smokes \n", + "4 Self-employed Rural 174.12 24.0 never smoked \n", + "\n", + " stroke \n", + "0 1 \n", + "1 1 \n", + "2 1 \n", + "3 1 \n", + "4 1 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import train_test_split\n", + "from imblearn.over_sampling import RandomOverSampler\n", + "from sklearn.preprocessing import StandardScaler\n", + "import featuretools as ft\n", + "import time\n", + "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import cross_val_score\n", + "\n", + "df = pd.read_csv(\"../data/healthcare-dataset-stroke-data.csv\")\n", + "\n", + "print(df.columns)\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Бизнес цели и цели технического проекта.\n", + "## Бизнес цели:\n", + "### 1. Предсказание инсульта: Разработать систему, которая сможет предсказать вероятность инсульта у пациентов на основе их медицинских и социальных данных. Это может помочь медицинским учреждениям и специалистам в более раннем выявлении пациентов с высоким риском.\n", + "### 2. Снижение затрат на лечение: Предупреждение инсультов у пациентов позволит снизить затраты на лечение и реабилитацию. Это также поможет улучшить качество медицинских услуг и повысить удовлетворенность пациентов.\n", + "### 3. Повышение эффективности профилактики: Выявление факторов риска инсульта на ранней стадии может способствовать более эффективному проведению профилактических мероприятий.\n", + "## Цели технического проекта:\n", + "### 1. Создание и обучение модели машинного обучения: Разработка модели, способной предсказать вероятность инсульта на основе данных о пациентах (например, возраст, уровень глюкозы, наличие сердечно-сосудистых заболеваний, тип работы, индекс массы тела и т.д.).\n", + "### 2. Анализ и обработка данных: Провести предобработку данных (очистка, заполнение пропущенных значений, кодирование категориальных признаков), чтобы улучшить качество и надежность модели.\n", + "### 3. Оценка модели: Использовать метрики, такие как точность, полнота и F1-мера, чтобы оценить эффективность модели и минимизировать риск ложных положительных и ложных отрицательных предсказаний." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "id 0\n", + "gender 0\n", + "age 0\n", + "hypertension 0\n", + "heart_disease 0\n", + "ever_married 0\n", + "work_type 0\n", + "Residence_type 0\n", + "avg_glucose_level 0\n", + "bmi 201\n", + "smoking_status 0\n", + "stroke 0\n", + "dtype: int64\n", + "\n", + "id False\n", + "gender False\n", + "age False\n", + "hypertension False\n", + "heart_disease False\n", + "ever_married False\n", + "work_type False\n", + "Residence_type False\n", + "avg_glucose_level False\n", + "bmi True\n", + "smoking_status False\n", + "stroke False\n", + "dtype: bool\n", + "\n", + "bmi процент пустых значений: %3.93\n" + ] + } + ], + "source": [ + "print(df.isnull().sum())\n", + "print()\n", + "\n", + "print(df.isnull().any())\n", + "print()\n", + "\n", + "for i in df.columns:\n", + " null_rate = df[i].isnull().sum() / len(df) * 100\n", + " if null_rate > 0:\n", + " print(f\"{i} процент пустых значений: %{null_rate:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Видим пустые значения в bmi, заменяем их" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Количество пустых значений в каждом столбце после замены:\n", + "id 0\n", + "gender 0\n", + "age 0\n", + "hypertension 0\n", + "heart_disease 0\n", + "ever_married 0\n", + "work_type 0\n", + "Residence_type 0\n", + "avg_glucose_level 0\n", + "bmi 0\n", + "smoking_status 0\n", + "stroke 0\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "df[\"bmi\"] = df[\"bmi\"].fillna(df[\"bmi\"].median())\n", + "\n", + "missing_values = df.isnull().sum()\n", + "\n", + "print(\"Количество пустых значений в каждом столбце после замены:\")\n", + "print(missing_values)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['gender', 'age', 'hypertension', 'heart_disease', 'ever_married',\n", + " 'work_type', 'Residence_type', 'avg_glucose_level', 'bmi',\n", + " 'smoking_status', 'stroke'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "df = df.drop('id', axis = 1)\n", + "print(df.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Создаем выборки" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Размер обучающей выборки: (2503, 10)\n", + "Размер контрольной выборки: (1074, 10)\n", + "Размер тестовой выборки: (1533, 10)\n" + ] + } + ], + "source": [ + "# Разделим данные на признак (X) и переменую (Y)\n", + "# Начнем со stroke\n", + "X = df.drop(columns=['stroke'])\n", + "y = df['stroke']\n", + "\n", + "# Разбиваем на обучающую и тестовую выборки\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)\n", + "\n", + "# Разбиваем на обучающую и контрольную выборки\n", + "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.3)\n", + "\n", + "print(\"Размер обучающей выборки: \", X_train.shape)\n", + "print(\"Размер контрольной выборки: \", X_val.shape)\n", + "print(\"Размер тестовой выборки: \", X_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Оценим сбалансированность сборок" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Распределение классов в обучающей выборке:\n", + "stroke\n", + "0 0.951658\n", + "1 0.048342\n", + "Name: proportion, dtype: float64\n", + "\n", + "Распределение классов в контрольной выборке:\n", + "stroke\n", + "0 0.947858\n", + "1 0.052142\n", + "Name: proportion, dtype: float64\n", + "\n", + "Распределение классов в тестовой выборке:\n", + "stroke\n", + "0 0.953033\n", + "1 0.046967\n", + "Name: proportion, dtype: float64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from locale import normalize\n", + "\n", + "\n", + "def analyze_balance(y_train, y_val, y_test, y_name):\n", + " print(\"Распределение классов в обучающей выборке:\")\n", + " print(y_train.value_counts(normalize=True))\n", + "\n", + " print(\"\\nРаспределение классов в контрольной выборке:\")\n", + " print(y_val.value_counts(normalize=True))\n", + "\n", + " print(\"\\nРаспределение классов в тестовой выборке:\")\n", + " print(y_test.value_counts(normalize=True))\n", + "\n", + " fig, axes = plt.subplots(1, 3, figsize=(18,5), sharey=True)\n", + " fig.suptitle('Распределение в различных выборках')\n", + "\n", + " sns.barplot(x=y_train.value_counts().index, y=y_train.value_counts(normalize=True), ax=axes[0])\n", + " axes[0].set_title('Обучающая выборка')\n", + " axes[0].set_xlabel(y_name)\n", + " axes[0].set_ylabel('Доля')\n", + "\n", + " sns.barplot(x=y_val.value_counts().index, y=y_val.value_counts(normalize=True), ax=axes[1])\n", + " axes[1].set_title('Контрольная выборка')\n", + " axes[1].set_xlabel(y_name)\n", + "\n", + " sns.barplot(x=y_test.value_counts().index, y=y_test.value_counts(normalize=True), ax=axes[2])\n", + " axes[2].set_title('Тестовая выборка')\n", + " axes[2].set_xlabel(y_name)\n", + "\n", + " plt.show()\n", + "\n", + "analyze_balance(y_train, y_val, y_test, 'stroke')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Заметим, что выборки не сбалансированы. Для балансировки будем использовать RandomOverSampler" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Распределение классов в обучающей выборке:\n", + "stroke\n", + "0 0.5\n", + "1 0.5\n", + "Name: proportion, dtype: float64\n", + "\n", + "Распределение классов в контрольной выборке:\n", + "stroke\n", + "0 0.5\n", + "1 0.5\n", + "Name: proportion, dtype: float64\n", + "\n", + "Распределение классов в тестовой выборке:\n", + "stroke\n", + "0 0.953033\n", + "1 0.046967\n", + "Name: proportion, dtype: float64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "randoversamp = RandomOverSampler(random_state=42)\n", + "\n", + "# Применение RandomOverSampler для балансировки выборок\n", + "X_train_resampled, y_train_resampled = randoversamp.fit_resample(X_train, y_train)\n", + "X_val_resampled, y_val_resampled = randoversamp.fit_resample(X_val, y_val)\n", + "\n", + "# Проверка сбалансированности после RandomOverSampler\n", + "analyze_balance(y_train_resampled, y_val_resampled, y_test, \"stroke\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Выборки сбалансированы" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Применим унитарное кодирование категориальных признаков (one-hot encoding), переведя их в бинарные вектора." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " age hypertension heart_disease avg_glucose_level bmi gender_Male \\\n", + "0 31.0 0 0 80.88 29.3 False \n", + "1 63.0 1 0 81.54 24.2 False \n", + "2 33.0 0 0 86.97 42.2 False \n", + "3 7.0 0 0 61.42 20.8 False \n", + "4 62.0 0 0 163.17 25.6 False \n", + "\n", + " gender_Other ever_married_Yes work_type_Never_worked work_type_Private \\\n", + "0 False False False False \n", + "1 False True False True \n", + "2 False True False True \n", + "3 False False False False \n", + "4 False True False False \n", + "\n", + " work_type_Self-employed work_type_children Residence_type_Urban \\\n", + "0 False False True \n", + "1 False False True \n", + "2 False False False \n", + "3 False True True \n", + "4 False False True \n", + "\n", + " smoking_status_formerly smoked smoking_status_never smoked \\\n", + "0 True False \n", + "1 False True \n", + "2 False True \n", + "3 False False \n", + "4 False True \n", + "\n", + " smoking_status_smokes \n", + "0 False \n", + "1 False \n", + "2 False \n", + "3 False \n", + "4 False \n" + ] + } + ], + "source": [ + "# Определение категориальных признаков\n", + "categorical_features = [\n", + " \"gender\",\n", + " \"ever_married\",\n", + " \"work_type\",\n", + " \"Residence_type\",\n", + " \"smoking_status\",\n", + "]\n", + "\n", + "# Применение one-hot encoding к обучающей выборке\n", + "X_train_encoded = pd.get_dummies(\n", + " X_train_resampled, columns=categorical_features, drop_first=True\n", + ")\n", + "\n", + "# Применение one-hot encoding к контрольной выборке\n", + "X_val_encoded = pd.get_dummies(\n", + " X_val_resampled, columns=categorical_features, drop_first=True\n", + ")\n", + "\n", + "# Применение one-hot encoding к тестовой выборке\n", + "X_test_encoded = pd.get_dummies(X_test, columns=categorical_features, drop_first=True)\n", + "\n", + "print(X_train_encoded.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Перейдем к числовым признакам, а именно к колонке age, применим дискретизацию (позволяет преобразовать данные из числового представления в категориальное):" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " hypertension heart_disease avg_glucose_level bmi gender_Male \\\n", + "0 0 0 80.88 29.3 False \n", + "1 1 0 81.54 24.2 False \n", + "2 0 0 86.97 42.2 False \n", + "3 0 0 61.42 20.8 False \n", + "4 0 0 163.17 25.6 False \n", + "\n", + " gender_Other ever_married_Yes work_type_Never_worked work_type_Private \\\n", + "0 False False False False \n", + "1 False True False True \n", + "2 False True False True \n", + "3 False False False False \n", + "4 False True False False \n", + "\n", + " work_type_Self-employed work_type_children Residence_type_Urban \\\n", + "0 False False True \n", + "1 False False True \n", + "2 False False False \n", + "3 False True True \n", + "4 False False True \n", + "\n", + " smoking_status_formerly smoked smoking_status_never smoked \\\n", + "0 True False \n", + "1 False True \n", + "2 False True \n", + "3 False False \n", + "4 False True \n", + "\n", + " smoking_status_smokes age_bin \n", + "0 False middle-aged \n", + "1 False old \n", + "2 False middle-aged \n", + "3 False young \n", + "4 False old \n" + ] + } + ], + "source": [ + "# Определение числовых признаков для дискретизации\n", + "numerical_features = [\"age\"]\n", + "\n", + "\n", + "# Функция для дискретизации числовых признаков\n", + "def discretize_features(df, features, bins, labels):\n", + " for feature in features:\n", + " df[f\"{feature}_bin\"] = pd.cut(df[feature], bins=bins, labels=labels)\n", + " df.drop(columns=[feature], inplace=True)\n", + " return df\n", + "\n", + "\n", + "# Заданные интервалы и метки\n", + "age_bins = [0, 25, 55, 100]\n", + "age_labels = [\"young\", \"middle-aged\", \"old\"]\n", + "\n", + "# Применение дискретизации к обучающей, контрольной и тестовой выборкам\n", + "X_train_encoded = discretize_features(\n", + " X_train_encoded, numerical_features, bins=age_bins, labels=age_labels\n", + ")\n", + "X_val_encoded = discretize_features(\n", + " X_val_encoded, numerical_features, bins=age_bins, labels=age_labels\n", + ")\n", + "X_test_encoded = discretize_features(\n", + " X_test_encoded, numerical_features, bins=age_bins, labels=age_labels\n", + ")\n", + "\n", + "print(X_train_encoded.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Применим ручной синтез признаков. Например, в этом случае создадим признак, в котором вычисляется отклонение уровня глюкозы от среднего для определенной возрастной группы. Вышеуказанный признак может быть полезен для определения пациентов с аномальными данными." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " hypertension heart_disease avg_glucose_level bmi gender_Male \\\n", + "0 0 0 80.88 29.3 False \n", + "1 1 0 81.54 24.2 False \n", + "2 0 0 86.97 42.2 False \n", + "3 0 0 61.42 20.8 False \n", + "4 0 0 163.17 25.6 False \n", + "\n", + " gender_Other ever_married_Yes work_type_Never_worked work_type_Private \\\n", + "0 False False False False \n", + "1 False True False True \n", + "2 False True False True \n", + "3 False False False False \n", + "4 False True False False \n", + "\n", + " work_type_Self-employed work_type_children Residence_type_Urban \\\n", + "0 False False True \n", + "1 False False True \n", + "2 False False False \n", + "3 False True True \n", + "4 False False True \n", + "\n", + " smoking_status_formerly smoked smoking_status_never smoked \\\n", + "0 True False \n", + "1 False True \n", + "2 False True \n", + "3 False False \n", + "4 False True \n", + "\n", + " smoking_status_smokes age_bin glucose_age_deviation \n", + "0 False middle-aged -22.997954 \n", + "1 False old -54.147764 \n", + "2 False middle-aged -16.907954 \n", + "3 False young -32.619531 \n", + "4 False old 27.482236 \n" + ] + } + ], + "source": [ + "age_glucose_mean = X_train_encoded.groupby(\"age_bin\", observed=False)[\n", + " \"avg_glucose_level\"\n", + "].transform(\"mean\")\n", + "X_train_encoded[\"glucose_age_deviation\"] = (\n", + " X_train_encoded[\"avg_glucose_level\"] - age_glucose_mean\n", + ")\n", + "\n", + "age_glucose_mean = X_val_encoded.groupby(\"age_bin\", observed=False)[\n", + " \"avg_glucose_level\"\n", + "].transform(\"mean\")\n", + "X_val_encoded[\"glucose_age_deviation\"] = (\n", + " X_val_encoded[\"avg_glucose_level\"] - age_glucose_mean\n", + ")\n", + "\n", + "age_glucose_mean = X_test_encoded.groupby(\"age_bin\", observed=False)[\n", + " \"avg_glucose_level\"\n", + "].transform(\"mean\")\n", + "X_test_encoded[\"glucose_age_deviation\"] = (\n", + " X_test_encoded[\"avg_glucose_level\"] - age_glucose_mean\n", + ")\n", + "\n", + "print(X_train_encoded.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Используем масштабирование признаков, для приведения всех числовых признаков к одинаковым или очень похожим диапазонам значений/распределениям. \n", + "### Масштабирование признаков позволяет получить более качественную модель за счет снижения доминирования одних признаков над другими." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " hypertension heart_disease avg_glucose_level bmi gender_Male \\\n", + "0 0 0 -0.696288 -0.031658 False \n", + "1 1 0 -0.684615 -0.785297 False \n", + "2 0 0 -0.588575 1.874608 False \n", + "3 0 0 -1.040476 -1.287724 False \n", + "4 0 0 0.759172 -0.578416 False \n", + "\n", + " gender_Other ever_married_Yes work_type_Never_worked work_type_Private \\\n", + "0 False False False False \n", + "1 False True False True \n", + "2 False True False True \n", + "3 False False False False \n", + "4 False True False False \n", + "\n", + " work_type_Self-employed work_type_children Residence_type_Urban \\\n", + "0 False False True \n", + "1 False False True \n", + "2 False False False \n", + "3 False True True \n", + "4 False False True \n", + "\n", + " smoking_status_formerly smoked smoking_status_never smoked \\\n", + "0 True False \n", + "1 False True \n", + "2 False True \n", + "3 False False \n", + "4 False True \n", + "\n", + " smoking_status_smokes age_bin glucose_age_deviation \n", + "0 False middle-aged -0.428019 \n", + "1 False old -1.007754 \n", + "2 False middle-aged -0.314677 \n", + "3 False young -0.607088 \n", + "4 False old 0.511477 \n" + ] + } + ], + "source": [ + "numerical_features = [\"avg_glucose_level\", \"bmi\", \"glucose_age_deviation\"]\n", + "\n", + "scaler = StandardScaler()\n", + "X_train_encoded[numerical_features] = scaler.fit_transform(\n", + " X_train_encoded[numerical_features]\n", + ")\n", + "X_val_encoded[numerical_features] = scaler.transform(X_val_encoded[numerical_features])\n", + "X_test_encoded[numerical_features] = scaler.transform(\n", + " X_test_encoded[numerical_features]\n", + ")\n", + "\n", + "print(X_train_encoded.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Сконструируем признаки, используя фреймворк Featuretools:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " hypertension heart_disease avg_glucose_level bmi gender_Male \\\n", + "index \n", + "0 0 0 -0.696288 -0.031658 False \n", + "1 1 0 -0.684615 -0.785297 False \n", + "2 0 0 -0.588575 1.874608 False \n", + "3 0 0 -1.040476 -1.287724 False \n", + "4 0 0 0.759172 -0.578416 False \n", + "\n", + " gender_Other ever_married_Yes work_type_Never_worked \\\n", + "index \n", + "0 False False False \n", + "1 False True False \n", + "2 False True False \n", + "3 False False False \n", + "4 False True False \n", + "\n", + " work_type_Private work_type_Self-employed work_type_children \\\n", + "index \n", + "0 False False False \n", + "1 True False False \n", + "2 True False False \n", + "3 False False True \n", + "4 False False False \n", + "\n", + " Residence_type_Urban smoking_status_formerly smoked \\\n", + "index \n", + "0 True True \n", + "1 True False \n", + "2 False False \n", + "3 True False \n", + "4 True False \n", + "\n", + " smoking_status_never smoked smoking_status_smokes age_bin \\\n", + "index \n", + "0 False False middle-aged \n", + "1 True False old \n", + "2 True False middle-aged \n", + "3 False False young \n", + "4 True False old \n", + "\n", + " glucose_age_deviation \n", + "index \n", + "0 -0.428019 \n", + "1 -1.007754 \n", + "2 -0.314677 \n", + "3 -0.607088 \n", + "4 0.511477 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\bocchanskyy\\source\\repos\\MAI_PIbd-33_Volkov_NA\\.venv\\Lib\\site-packages\\woodwork\\type_sys\\utils.py:33: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " pd.to_datetime(\n" + ] + } + ], + "source": [ + "data = X_train_encoded.copy() # Используем предобработанные данные\n", + "\n", + "es = ft.EntitySet(id=\"patients\")\n", + "\n", + "es = es.add_dataframe(\n", + " dataframe_name=\"strokes_data\", dataframe=data, index=\"index\", make_index=True\n", + ")\n", + "\n", + "feature_matrix, feature_defs = ft.dfs(\n", + " entityset=es, target_dataframe_name=\"strokes_data\", max_depth=1\n", + ")\n", + "\n", + "print(feature_matrix.head())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Оценим качество набора признаков.\n", + "\n", + "1. Предсказательная способность (для задачи классификации)\n", + " - Метрики: Accuracy, Precision, Recall, F1-Score, ROC AUC\n", + " - Методы: Обучение модели на обучающей выборке и оценка на валидационной и тестовой выборках.\n", + "\n", + "2. Вычислительная эффективность\n", + " - Методы: Измерение времени, затраченного на генерацию признаков и обучение модели.\n", + "\n", + "3. Надежность\n", + " - Методы: Кросс-валидация и анализ чувствительности модели к изменениям в данных.\n", + "\n", + "4. Корреляция\n", + " - Методы: Анализ корреляционной матрицы признаков и исключение мультиколлинеарных признаков.\n", + "\n", + "5. Логическая согласованность\n", + " - Методы: Проверка логической связи признаков с целевой переменной и интерпретация результатов модели." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Время обучения модели: 0.33 секунд\n" + ] + } + ], + "source": [ + "X_train_encoded = pd.get_dummies(X_train_encoded, drop_first=True)\n", + "X_val_encoded = pd.get_dummies(X_val_encoded, drop_first=True)\n", + "X_test_encoded = pd.get_dummies(X_test_encoded, drop_first=True)\n", + "\n", + "all_columns = X_train_encoded.columns\n", + "X_train_encoded = X_train_encoded.reindex(columns=all_columns, fill_value=0)\n", + "X_val_encoded = X_val_encoded.reindex(columns=all_columns, fill_value=0)\n", + "X_test_encoded = X_test_encoded.reindex(columns=all_columns, fill_value=0)\n", + "\n", + "# Выбор модели\n", + "model = RandomForestClassifier(n_estimators=100, random_state=42)\n", + "\n", + "# Начинаем отсчет времени\n", + "start_time = time.time()\n", + "model.fit(X_train_encoded, y_train_resampled)\n", + "\n", + "# Время обучения модели\n", + "train_time = time.time() - start_time\n", + "\n", + "print(f\"Время обучения модели: {train_time:.2f} секунд\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Importance:\n", + " feature importance\n", + "3 bmi 1.937437e-01\n", + "2 avg_glucose_level 1.902965e-01\n", + "15 glucose_age_deviation 1.742016e-01\n", + "17 age_bin_old 1.676844e-01\n", + "0 hypertension 3.892436e-02\n", + "6 ever_married_Yes 3.224085e-02\n", + "4 gender_Male 2.826243e-02\n", + "16 age_bin_middle-aged 2.826115e-02\n", + "11 Residence_type_Urban 2.391783e-02\n", + "13 smoking_status_never smoked 2.307375e-02\n", + "8 work_type_Private 2.125517e-02\n", + "9 work_type_Self-employed 1.917397e-02\n", + "1 heart_disease 1.690222e-02\n", + "12 smoking_status_formerly smoked 1.681537e-02\n", + "14 smoking_status_smokes 1.665569e-02\n", + "10 work_type_children 8.476756e-03\n", + "7 work_type_Never_worked 1.141679e-04\n", + "5 gender_Other 5.572087e-08\n" + ] + } + ], + "source": [ + "# Получение важности признаков\n", + "importances = model.feature_importances_\n", + "feature_names = X_train_encoded.columns\n", + "\n", + "# Сортировка признаков по важности\n", + "feature_importance = pd.DataFrame({\"feature\": feature_names, \"importance\": importances})\n", + "feature_importance = feature_importance.sort_values(by=\"importance\", ascending=False)\n", + "\n", + "print(\"Feature Importance:\")\n", + "print(feature_importance)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9406392694063926\n", + "Precision: 0.047619047619047616\n", + "Recall: 0.013888888888888888\n", + "F1 Score: 0.021505376344086023\n", + "ROC AUC: 0.5000998174766141\n", + "Cross-validated Accuracy: 0.9930740606840847\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 1.0\n", + "Train Precision: 1.0\n", + "Train Recall: 1.0\n", + "Train F1 Score: 1.0\n", + "Train ROC AUC: 1.0\n" + ] + } + ], + "source": [ + "# Предсказание и оценка\n", + "y_pred = model.predict(X_test_encoded)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "precision = precision_score(y_test, y_pred)\n", + "recall = recall_score(y_test, y_pred)\n", + "f1 = f1_score(y_test, y_pred)\n", + "roc_auc = roc_auc_score(y_test, y_pred)\n", + "\n", + "print(f\"Accuracy: {accuracy}\")\n", + "print(f\"Precision: {precision}\")\n", + "print(f\"Recall: {recall}\")\n", + "print(f\"F1 Score: {f1}\")\n", + "print(f\"ROC AUC: {roc_auc}\")\n", + "\n", + "# Кросс-валидация\n", + "scores = cross_val_score(\n", + " model, X_train_encoded, y_train_resampled, cv=5, scoring=\"accuracy\"\n", + ")\n", + "accuracy_cv = scores.mean()\n", + "print(f\"Cross-validated Accuracy: {accuracy_cv}\")\n", + "\n", + "# Анализ важности признаков\n", + "feature_importances = model.feature_importances_\n", + "feature_names = X_train_encoded.columns\n", + "\n", + "importance_df = pd.DataFrame(\n", + " {\"Feature\": feature_names, \"Importance\": feature_importances}\n", + ")\n", + "importance_df = importance_df.sort_values(by=\"Importance\", ascending=False)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(x=\"Importance\", y=\"Feature\", data=importance_df)\n", + "plt.title(\"Feature Importance\")\n", + "plt.show()\n", + "\n", + "# Проверка на переобучение\n", + "y_train_pred = model.predict(X_train_encoded)\n", + "\n", + "accuracy_train = accuracy_score(y_train_resampled, y_train_pred)\n", + "precision_train = precision_score(y_train_resampled, y_train_pred)\n", + "recall_train = recall_score(y_train_resampled, y_train_pred)\n", + "f1_train = f1_score(y_train_resampled, y_train_pred)\n", + "roc_auc_train = roc_auc_score(y_train_resampled, y_train_pred)\n", + "\n", + "print(f\"Train Accuracy: {accuracy_train}\")\n", + "print(f\"Train Precision: {precision_train}\")\n", + "print(f\"Train Recall: {recall_train}\")\n", + "print(f\"Train F1 Score: {f1_train}\")\n", + "print(f\"Train ROC AUC: {roc_auc_train}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/poetry.lock b/poetry.lock index e527777..fda79e6 100644 --- a/poetry.lock +++ b/poetry.lock @@ -46,13 +46,13 @@ yaml = ["pyyaml"] [[package]] name = "apispec" -version = "6.7.0" +version = "6.7.1" description = "A pluggable API specification generator. Currently supports the OpenAPI Specification (f.k.a. the Swagger specification)." optional = false python-versions = ">=3.9" files = [ - {file = "apispec-6.7.0-py3-none-any.whl", hash = "sha256:7d2f2be3ceb7385eca550e4a2cc1e4d4a640093cc8fe04224301aa395a785b25"}, - {file = "apispec-6.7.0.tar.gz", hash = "sha256:fa2cf1063bb227ed6f7f66b019f320d7dc0a7cb02acdf166a160e2381f4b2c39"}, + {file = "apispec-6.7.1-py3-none-any.whl", hash = "sha256:d99e7a564f3871327c17b3e43726cc1e6ade2c97aa05706644a48818fc37999e"}, + {file = "apispec-6.7.1.tar.gz", hash = "sha256:c01b8b6ff40ffedf55b79a67f9dd920e9b2fc3909aae116facf6c8372a08b933"}, ] [package.dependencies] @@ -237,21 +237,20 @@ lxml = ["lxml"] [[package]] name = "bleach" -version = "6.1.0" +version = "6.2.0" description = "An easy safelist-based HTML-sanitizing tool." optional = false -python-versions = ">=3.8" +python-versions = ">=3.9" files = [ - {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, - {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, + {file = "bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e"}, + {file = "bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f"}, ] [package.dependencies] -six = ">=1.9.0" webencodings = "*" [package.extras] -css = ["tinycss2 (>=1.1.0,<1.3)"] +css = ["tinycss2 (>=1.1.0,<1.5)"] [[package]] name = "blinker" @@ -482,6 +481,17 @@ files = [ [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} +[[package]] +name = "cloudpickle" +version = "3.1.0" +description = "Pickler class to extend the standard pickle.Pickler functionality" +optional = false +python-versions = ">=3.8" +files = [ + {file = "cloudpickle-3.1.0-py3-none-any.whl", hash = "sha256:fe11acda67f61aaaec473e3afe030feb131d78a43461b718185363384f1ba12e"}, + {file = "cloudpickle-3.1.0.tar.gz", hash = "sha256:81a929b6e3c7335c863c771d673d105f02efdb89dfaba0c90495d1c64796601b"}, +] + [[package]] name = "colorama" version = "0.4.6" @@ -611,37 +621,37 @@ tests = ["pytest", "pytest-cov", "pytest-xdist"] [[package]] name = "debugpy" -version = "1.8.7" +version = "1.8.8" description = "An implementation of the Debug Adapter Protocol for Python" optional = false python-versions = ">=3.8" files = [ - {file = "debugpy-1.8.7-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:95fe04a573b8b22896c404365e03f4eda0ce0ba135b7667a1e57bd079793b96b"}, - {file = "debugpy-1.8.7-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:628a11f4b295ffb4141d8242a9bb52b77ad4a63a2ad19217a93be0f77f2c28c9"}, - {file = "debugpy-1.8.7-cp310-cp310-win32.whl", hash = "sha256:85ce9c1d0eebf622f86cc68618ad64bf66c4fc3197d88f74bb695a416837dd55"}, - {file = "debugpy-1.8.7-cp310-cp310-win_amd64.whl", hash = "sha256:29e1571c276d643757ea126d014abda081eb5ea4c851628b33de0c2b6245b037"}, - {file = "debugpy-1.8.7-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:caf528ff9e7308b74a1749c183d6808ffbedbb9fb6af78b033c28974d9b8831f"}, - {file = "debugpy-1.8.7-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cba1d078cf2e1e0b8402e6bda528bf8fda7ccd158c3dba6c012b7897747c41a0"}, - {file = "debugpy-1.8.7-cp311-cp311-win32.whl", hash = "sha256:171899588bcd412151e593bd40d9907133a7622cd6ecdbdb75f89d1551df13c2"}, - {file = "debugpy-1.8.7-cp311-cp311-win_amd64.whl", hash = "sha256:6e1c4ffb0c79f66e89dfd97944f335880f0d50ad29525dc792785384923e2211"}, - {file = "debugpy-1.8.7-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:4d27d842311353ede0ad572600c62e4bcd74f458ee01ab0dd3a1a4457e7e3706"}, - {file = "debugpy-1.8.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:703c1fd62ae0356e194f3e7b7a92acd931f71fe81c4b3be2c17a7b8a4b546ec2"}, - {file = "debugpy-1.8.7-cp312-cp312-win32.whl", hash = "sha256:2f729228430ef191c1e4df72a75ac94e9bf77413ce5f3f900018712c9da0aaca"}, - {file = "debugpy-1.8.7-cp312-cp312-win_amd64.whl", hash = "sha256:45c30aaefb3e1975e8a0258f5bbd26cd40cde9bfe71e9e5a7ac82e79bad64e39"}, - {file = "debugpy-1.8.7-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:d050a1ec7e925f514f0f6594a1e522580317da31fbda1af71d1530d6ea1f2b40"}, - {file = "debugpy-1.8.7-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2f4349a28e3228a42958f8ddaa6333d6f8282d5edaea456070e48609c5983b7"}, - {file = "debugpy-1.8.7-cp313-cp313-win32.whl", hash = "sha256:11ad72eb9ddb436afb8337891a986302e14944f0f755fd94e90d0d71e9100bba"}, - {file = "debugpy-1.8.7-cp313-cp313-win_amd64.whl", hash = "sha256:2efb84d6789352d7950b03d7f866e6d180284bc02c7e12cb37b489b7083d81aa"}, - {file = "debugpy-1.8.7-cp38-cp38-macosx_14_0_x86_64.whl", hash = "sha256:4b908291a1d051ef3331484de8e959ef3e66f12b5e610c203b5b75d2725613a7"}, - {file = "debugpy-1.8.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da8df5b89a41f1fd31503b179d0a84a5fdb752dddd5b5388dbd1ae23cda31ce9"}, - {file = "debugpy-1.8.7-cp38-cp38-win32.whl", hash = "sha256:b12515e04720e9e5c2216cc7086d0edadf25d7ab7e3564ec8b4521cf111b4f8c"}, - {file = "debugpy-1.8.7-cp38-cp38-win_amd64.whl", hash = "sha256:93176e7672551cb5281577cdb62c63aadc87ec036f0c6a486f0ded337c504596"}, - {file = "debugpy-1.8.7-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:90d93e4f2db442f8222dec5ec55ccfc8005821028982f1968ebf551d32b28907"}, - {file = "debugpy-1.8.7-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6db2a370e2700557a976eaadb16243ec9c91bd46f1b3bb15376d7aaa7632c81"}, - {file = "debugpy-1.8.7-cp39-cp39-win32.whl", hash = "sha256:a6cf2510740e0c0b4a40330640e4b454f928c7b99b0c9dbf48b11efba08a8cda"}, - {file = "debugpy-1.8.7-cp39-cp39-win_amd64.whl", hash = "sha256:6a9d9d6d31846d8e34f52987ee0f1a904c7baa4912bf4843ab39dadf9b8f3e0d"}, - {file = "debugpy-1.8.7-py2.py3-none-any.whl", hash = "sha256:57b00de1c8d2c84a61b90880f7e5b6deaf4c312ecbde3a0e8912f2a56c4ac9ae"}, - {file = "debugpy-1.8.7.zip", hash = "sha256:18b8f731ed3e2e1df8e9cdaa23fb1fc9c24e570cd0081625308ec51c82efe42e"}, + {file = "debugpy-1.8.8-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:e59b1607c51b71545cb3496876544f7186a7a27c00b436a62f285603cc68d1c6"}, + {file = "debugpy-1.8.8-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6531d952b565b7cb2fbd1ef5df3d333cf160b44f37547a4e7cf73666aca5d8d"}, + {file = "debugpy-1.8.8-cp310-cp310-win32.whl", hash = "sha256:b01f4a5e5c5fb1d34f4ccba99a20ed01eabc45a4684f4948b5db17a319dfb23f"}, + {file = "debugpy-1.8.8-cp310-cp310-win_amd64.whl", hash = "sha256:535f4fb1c024ddca5913bb0eb17880c8f24ba28aa2c225059db145ee557035e9"}, + {file = "debugpy-1.8.8-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:c399023146e40ae373753a58d1be0a98bf6397fadc737b97ad612886b53df318"}, + {file = "debugpy-1.8.8-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:09cc7b162586ea2171eea055985da2702b0723f6f907a423c9b2da5996ad67ba"}, + {file = "debugpy-1.8.8-cp311-cp311-win32.whl", hash = "sha256:eea8821d998ebeb02f0625dd0d76839ddde8cbf8152ebbe289dd7acf2cdc6b98"}, + {file = "debugpy-1.8.8-cp311-cp311-win_amd64.whl", hash = "sha256:d4483836da2a533f4b1454dffc9f668096ac0433de855f0c22cdce8c9f7e10c4"}, + {file = "debugpy-1.8.8-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:0cc94186340be87b9ac5a707184ec8f36547fb66636d1029ff4f1cc020e53996"}, + {file = "debugpy-1.8.8-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64674e95916e53c2e9540a056e5f489e0ad4872645399d778f7c598eacb7b7f9"}, + {file = "debugpy-1.8.8-cp312-cp312-win32.whl", hash = "sha256:5c6e885dbf12015aed73770f29dec7023cb310d0dc2ba8bfbeb5c8e43f80edc9"}, + {file = "debugpy-1.8.8-cp312-cp312-win_amd64.whl", hash = "sha256:19ffbd84e757a6ca0113574d1bf5a2298b3947320a3e9d7d8dc3377f02d9f864"}, + {file = "debugpy-1.8.8-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:705cd123a773d184860ed8dae99becd879dfec361098edbefb5fc0d3683eb804"}, + {file = "debugpy-1.8.8-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:890fd16803f50aa9cb1a9b9b25b5ec321656dd6b78157c74283de241993d086f"}, + {file = "debugpy-1.8.8-cp313-cp313-win32.whl", hash = "sha256:90244598214bbe704aa47556ec591d2f9869ff9e042e301a2859c57106649add"}, + {file = "debugpy-1.8.8-cp313-cp313-win_amd64.whl", hash = "sha256:4b93e4832fd4a759a0c465c967214ed0c8a6e8914bced63a28ddb0dd8c5f078b"}, + {file = "debugpy-1.8.8-cp38-cp38-macosx_14_0_x86_64.whl", hash = "sha256:143ef07940aeb8e7316de48f5ed9447644da5203726fca378f3a6952a50a9eae"}, + {file = "debugpy-1.8.8-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f95651bdcbfd3b27a408869a53fbefcc2bcae13b694daee5f1365b1b83a00113"}, + {file = "debugpy-1.8.8-cp38-cp38-win32.whl", hash = "sha256:26b461123a030e82602a750fb24d7801776aa81cd78404e54ab60e8b5fecdad5"}, + {file = "debugpy-1.8.8-cp38-cp38-win_amd64.whl", hash = "sha256:f3cbf1833e644a3100eadb6120f25be8a532035e8245584c4f7532937edc652a"}, + {file = "debugpy-1.8.8-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:53709d4ec586b525724819dc6af1a7703502f7e06f34ded7157f7b1f963bb854"}, + {file = "debugpy-1.8.8-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a9c013077a3a0000e83d97cf9cc9328d2b0bbb31f56b0e99ea3662d29d7a6a2"}, + {file = "debugpy-1.8.8-cp39-cp39-win32.whl", hash = "sha256:ffe94dd5e9a6739a75f0b85316dc185560db3e97afa6b215628d1b6a17561cb2"}, + {file = "debugpy-1.8.8-cp39-cp39-win_amd64.whl", hash = "sha256:5c0e5a38c7f9b481bf31277d2f74d2109292179081f11108e668195ef926c0f9"}, + {file = "debugpy-1.8.8-py2.py3-none-any.whl", hash = "sha256:ec684553aba5b4066d4de510859922419febc710df7bba04fe9e7ef3de15d34f"}, + {file = "debugpy-1.8.8.zip", hash = "sha256:e6355385db85cbd666be703a96ab7351bc9e6c61d694893206f8001e22aee091"}, ] [[package]] @@ -694,6 +704,41 @@ files = [ [package.extras] devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] +[[package]] +name = "featuretools" +version = "1.31.0" +description = "a framework for automated feature engineering" +optional = false +python-versions = "<4,>=3.9" +files = [ + {file = "featuretools-1.31.0-py3-none-any.whl", hash = "sha256:87c94e9ae959c89acd83da96bd2583f3ef0f6daaa9639cbb6e46dbde2c742a18"}, + {file = "featuretools-1.31.0.tar.gz", hash = "sha256:01bfb17fcc1715b4c3623c7bc94a8982122c4a0fa03350ed478601bb81f90155"}, +] + +[package.dependencies] +cloudpickle = ">=1.5.0" +holidays = ">=0.17" +numpy = ">=1.25.0" +packaging = ">=20.0" +pandas = ">=2.0.0" +psutil = ">=5.7.0" +scipy = ">=1.10.0" +tqdm = ">=4.66.3" +woodwork = ">=0.28.0" + +[package.extras] +autonormalize = ["autonormalize (>=2.0.1)"] +complete = ["featuretools[dask,nlp,premium]"] +dask = ["dask[dataframe] (>=2023.2.0)", "distributed (>=2023.2.0)"] +dev = ["black[jupyter] (>=23.1.0)", "featuretools[dask,docs,test]", "pre-commit (>=2.20.0)", "ruff (>=0.1.6)"] +docs = ["Sphinx (==5.1.1)", "autonormalize (>=2.0.1)", "click (>=7.0.0)", "featuretools[dask,test]", "ipython (==8.4.0)", "jupyter (==1.0.0)", "jupyter-client (>=8.0.2)", "matplotlib (==3.7.2)", "myst-parser (==0.18.0)", "nbconvert (==6.5.0)", "nbsphinx (==0.8.9)", "pydata-sphinx-theme (==0.9.0)", "sphinx-copybutton (==0.5.0)", "sphinx-inline-tabs (==2022.1.2b11)"] +nlp = ["nlp-primitives (>=2.12.0)"] +premium = ["premium-primitives (>=0.0.3)"] +sklearn = ["featuretools-sklearn-transformer (>=1.0.0)"] +sql = ["featuretools-sql (>=0.0.1)", "psycopg2-binary (>=2.9.3)"] +test = ["boto3 (>=1.34.32)", "composeml (>=0.8.0)", "graphviz (>=0.8.4)", "moto[all] (>=5.0.0)", "pip (>=23.3.0)", "pyarrow (>=14.0.1)", "pympler (>=0.8)", "pytest (>=7.1.2)", "pytest-cov (>=3.0.0)", "pytest-timeout (>=2.1.0)", "pytest-xdist (>=2.5.0)", "smart-open (>=5.0.0)", "urllib3 (>=1.26.18)"] +tsfresh = ["featuretools-tsfresh-primitives (>=1.0.0)"] + [[package]] name = "flask" version = "3.0.3" @@ -858,6 +903,20 @@ files = [ {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, ] +[[package]] +name = "holidays" +version = "0.60" +description = "World Holidays Framework" +optional = false +python-versions = ">=3.9" +files = [ + {file = "holidays-0.60-py3-none-any.whl", hash = "sha256:d857949c5ee35655215a10c5a26e6a856bdc3beccc4fbbc8debef98dfba17b82"}, + {file = "holidays-0.60.tar.gz", hash = "sha256:495fc5123f5d92b92673237375eb8c15a03d21c647b089db509b7d9612267556"}, +] + +[package.dependencies] +python-dateutil = "*" + [[package]] name = "httpcore" version = "1.0.6" @@ -942,6 +1001,25 @@ examples = ["keras (>=2.4.3)", "matplotlib (>=3.1.2)", "pandas (>=1.0.5)", "seab optional = ["keras (>=2.4.3)", "pandas (>=1.0.5)", "tensorflow (>=2.4.3)"] tests = ["black (>=23.3.0)", "flake8 (>=3.8.2)", "keras (>=2.4.3)", "mypy (>=1.3.0)", "pandas (>=1.0.5)", "pytest (>=5.0.1)", "pytest-cov (>=2.9.0)", "tensorflow (>=2.4.3)"] +[[package]] +name = "importlib-resources" +version = "6.4.5" +description = "Read resources from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"}, + {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"}, +] + +[package.extras] +check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"] +cover = ["pytest-cov"] +doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +enabler = ["pytest-enabler (>=2.2)"] +test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"] +type = ["pytest-mypy"] + [[package]] name = "ipykernel" version = "6.29.5" @@ -1350,13 +1428,13 @@ test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (> [[package]] name = "jupyterlab" -version = "4.2.5" +version = "4.3.0" description = "JupyterLab computational environment" optional = false python-versions = ">=3.8" files = [ - {file = "jupyterlab-4.2.5-py3-none-any.whl", hash = "sha256:73b6e0775d41a9fee7ee756c80f58a6bed4040869ccc21411dc559818874d321"}, - {file = "jupyterlab-4.2.5.tar.gz", hash = "sha256:ae7f3a1b8cb88b4f55009ce79fa7c06f99d70cd63601ee4aa91815d054f46f75"}, + {file = "jupyterlab-4.3.0-py3-none-any.whl", hash = "sha256:f67e1095ad61ae04349024f0b40345062ab108a0c6998d9810fec6a3c1a70cd5"}, + {file = "jupyterlab-4.3.0.tar.gz", hash = "sha256:7c6835cbf8df0af0ec8a39332e85ff11693fb9a468205343b4fc0bfbc74817e5"}, ] [package.dependencies] @@ -1375,9 +1453,9 @@ tornado = ">=6.2.0" traitlets = "*" [package.extras] -dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.3.5)"] -docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"] -docs-screenshots = ["altair (==5.3.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.2)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.1.post2)", "matplotlib (==3.8.3)", "nbconvert (>=7.0.0)", "pandas (==2.2.1)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"] +dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.6.9)"] +docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<8.1.0)", "sphinx-copybutton"] +docs-screenshots = ["altair (==5.4.1)", "ipython (==8.16.1)", "ipywidgets (==8.1.5)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.2.post3)", "matplotlib (==3.9.2)", "nbconvert (>=7.0.0)", "pandas (==2.2.3)", "scipy (==1.14.1)", "vega-datasets (==0.9.0)"] test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] upgrade-extension = ["copier (>=9,<10)", "jinja2-time (<0.3)", "pydantic (<3.0)", "pyyaml-include (<3.0)", "tomli-w (<2.0)"] @@ -1623,13 +1701,13 @@ files = [ [[package]] name = "marshmallow" -version = "3.23.0" +version = "3.23.1" description = "A lightweight library for converting complex datatypes to and from native Python datatypes." optional = false python-versions = ">=3.9" files = [ - {file = "marshmallow-3.23.0-py3-none-any.whl", hash = "sha256:82f20a2397834fe6d9611b241f2f7e7b680ed89c49f84728a1ad937be6b4bdf4"}, - {file = "marshmallow-3.23.0.tar.gz", hash = "sha256:98d8827a9f10c03d44ead298d2e99c6aea8197df18ccfad360dae7f89a50da2e"}, + {file = "marshmallow-3.23.1-py3-none-any.whl", hash = "sha256:fece2eb2c941180ea1b7fcbd4a83c51bfdd50093fdd3ad2585ee5e1df2508491"}, + {file = "marshmallow-3.23.1.tar.gz", hash = "sha256:3a8dfda6edd8dcdbf216c0ede1d1e78d230a6dc9c5a088f58c4083b974a0d468"}, ] [package.dependencies] @@ -1637,7 +1715,7 @@ packaging = ">=17.0" [package.extras] dev = ["marshmallow[tests]", "pre-commit (>=3.5,<5.0)", "tox"] -docs = ["alabaster (==1.0.0)", "autodocsumm (==0.2.13)", "sphinx (==8.1.3)", "sphinx-issues (==5.0.0)", "sphinx-version-warning (==1.1.2)"] +docs = ["alabaster (==1.0.0)", "autodocsumm (==0.2.14)", "sphinx (==8.1.3)", "sphinx-issues (==5.0.0)", "sphinx-version-warning (==1.1.2)"] tests = ["pytest", "simplejson"] [[package]] @@ -1821,26 +1899,26 @@ files = [ [[package]] name = "notebook" -version = "7.2.2" +version = "7.0.7" description = "Jupyter Notebook - A web-based notebook environment for interactive computing" optional = false python-versions = ">=3.8" files = [ - {file = "notebook-7.2.2-py3-none-any.whl", hash = "sha256:c89264081f671bc02eec0ed470a627ed791b9156cad9285226b31611d3e9fe1c"}, - {file = "notebook-7.2.2.tar.gz", hash = "sha256:2ef07d4220421623ad3fe88118d687bc0450055570cdd160814a59cf3a1c516e"}, + {file = "notebook-7.0.7-py3-none-any.whl", hash = "sha256:289b606d7e173f75a18beb1406ef411b43f97f7a9c55ba03efa3622905a62346"}, + {file = "notebook-7.0.7.tar.gz", hash = "sha256:3bcff00c17b3ac142ef5f436d50637d936b274cfa0b41f6ac0175363de9b4e09"}, ] [package.dependencies] jupyter-server = ">=2.4.0,<3" -jupyterlab = ">=4.2.0,<4.3" -jupyterlab-server = ">=2.27.1,<3" +jupyterlab = ">=4.0.2,<5" +jupyterlab-server = ">=2.22.1,<3" notebook-shim = ">=0.2,<0.3" tornado = ">=6.2.0" [package.extras] dev = ["hatch", "pre-commit"] docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.27.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] +test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] [[package]] name = "notebook-shim" @@ -1861,64 +1939,66 @@ test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync" [[package]] name = "numpy" -version = "2.1.2" +version = "2.1.3" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.10" files = [ - {file = "numpy-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:30d53720b726ec36a7f88dc873f0eec8447fbc93d93a8f079dfac2629598d6ee"}, - {file = "numpy-2.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8d3ca0a72dd8846eb6f7dfe8f19088060fcb76931ed592d29128e0219652884"}, - {file = "numpy-2.1.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:fc44e3c68ff00fd991b59092a54350e6e4911152682b4782f68070985aa9e648"}, - {file = "numpy-2.1.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:7c1c60328bd964b53f8b835df69ae8198659e2b9302ff9ebb7de4e5a5994db3d"}, - {file = "numpy-2.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6cdb606a7478f9ad91c6283e238544451e3a95f30fb5467fbf715964341a8a86"}, - {file = "numpy-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d666cb72687559689e9906197e3bec7b736764df6a2e58ee265e360663e9baf7"}, - {file = "numpy-2.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c6eef7a2dbd0abfb0d9eaf78b73017dbfd0b54051102ff4e6a7b2980d5ac1a03"}, - {file = "numpy-2.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:12edb90831ff481f7ef5f6bc6431a9d74dc0e5ff401559a71e5e4611d4f2d466"}, - {file = "numpy-2.1.2-cp310-cp310-win32.whl", hash = "sha256:a65acfdb9c6ebb8368490dbafe83c03c7e277b37e6857f0caeadbbc56e12f4fb"}, - {file = "numpy-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:860ec6e63e2c5c2ee5e9121808145c7bf86c96cca9ad396c0bd3e0f2798ccbe2"}, - {file = "numpy-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b42a1a511c81cc78cbc4539675713bbcf9d9c3913386243ceff0e9429ca892fe"}, - {file = "numpy-2.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:faa88bc527d0f097abdc2c663cddf37c05a1c2f113716601555249805cf573f1"}, - {file = "numpy-2.1.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:c82af4b2ddd2ee72d1fc0c6695048d457e00b3582ccde72d8a1c991b808bb20f"}, - {file = "numpy-2.1.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:13602b3174432a35b16c4cfb5de9a12d229727c3dd47a6ce35111f2ebdf66ff4"}, - {file = "numpy-2.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ebec5fd716c5a5b3d8dfcc439be82a8407b7b24b230d0ad28a81b61c2f4659a"}, - {file = "numpy-2.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2b49c3c0804e8ecb05d59af8386ec2f74877f7ca8fd9c1e00be2672e4d399b1"}, - {file = "numpy-2.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:2cbba4b30bf31ddbe97f1c7205ef976909a93a66bb1583e983adbd155ba72ac2"}, - {file = "numpy-2.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8e00ea6fc82e8a804433d3e9cedaa1051a1422cb6e443011590c14d2dea59146"}, - {file = "numpy-2.1.2-cp311-cp311-win32.whl", hash = "sha256:5006b13a06e0b38d561fab5ccc37581f23c9511879be7693bd33c7cd15ca227c"}, - {file = "numpy-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:f1eb068ead09f4994dec71c24b2844f1e4e4e013b9629f812f292f04bd1510d9"}, - {file = "numpy-2.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7bf0a4f9f15b32b5ba53147369e94296f5fffb783db5aacc1be15b4bf72f43b"}, - {file = "numpy-2.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b1d0fcae4f0949f215d4632be684a539859b295e2d0cb14f78ec231915d644db"}, - {file = "numpy-2.1.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f751ed0a2f250541e19dfca9f1eafa31a392c71c832b6bb9e113b10d050cb0f1"}, - {file = "numpy-2.1.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:bd33f82e95ba7ad632bc57837ee99dba3d7e006536200c4e9124089e1bf42426"}, - {file = "numpy-2.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b8cde4f11f0a975d1fd59373b32e2f5a562ade7cde4f85b7137f3de8fbb29a0"}, - {file = "numpy-2.1.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d95f286b8244b3649b477ac066c6906fbb2905f8ac19b170e2175d3d799f4df"}, - {file = "numpy-2.1.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ab4754d432e3ac42d33a269c8567413bdb541689b02d93788af4131018cbf366"}, - {file = "numpy-2.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e585c8ae871fd38ac50598f4763d73ec5497b0de9a0ab4ef5b69f01c6a046142"}, - {file = "numpy-2.1.2-cp312-cp312-win32.whl", hash = "sha256:9c6c754df29ce6a89ed23afb25550d1c2d5fdb9901d9c67a16e0b16eaf7e2550"}, - {file = "numpy-2.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:456e3b11cb79ac9946c822a56346ec80275eaf2950314b249b512896c0d2505e"}, - {file = "numpy-2.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a84498e0d0a1174f2b3ed769b67b656aa5460c92c9554039e11f20a05650f00d"}, - {file = "numpy-2.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4d6ec0d4222e8ffdab1744da2560f07856421b367928026fb540e1945f2eeeaf"}, - {file = "numpy-2.1.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:259ec80d54999cc34cd1eb8ded513cb053c3bf4829152a2e00de2371bd406f5e"}, - {file = "numpy-2.1.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:675c741d4739af2dc20cd6c6a5c4b7355c728167845e3c6b0e824e4e5d36a6c3"}, - {file = "numpy-2.1.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05b2d4e667895cc55e3ff2b56077e4c8a5604361fc21a042845ea3ad67465aa8"}, - {file = "numpy-2.1.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:43cca367bf94a14aca50b89e9bc2061683116cfe864e56740e083392f533ce7a"}, - {file = "numpy-2.1.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:76322dcdb16fccf2ac56f99048af32259dcc488d9b7e25b51e5eca5147a3fb98"}, - {file = "numpy-2.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:32e16a03138cabe0cb28e1007ee82264296ac0983714094380b408097a418cfe"}, - {file = "numpy-2.1.2-cp313-cp313-win32.whl", hash = "sha256:242b39d00e4944431a3cd2db2f5377e15b5785920421993770cddb89992c3f3a"}, - {file = "numpy-2.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:f2ded8d9b6f68cc26f8425eda5d3877b47343e68ca23d0d0846f4d312ecaa445"}, - {file = "numpy-2.1.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2ffef621c14ebb0188a8633348504a35c13680d6da93ab5cb86f4e54b7e922b5"}, - {file = "numpy-2.1.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ad369ed238b1959dfbade9018a740fb9392c5ac4f9b5173f420bd4f37ba1f7a0"}, - {file = "numpy-2.1.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d82075752f40c0ddf57e6e02673a17f6cb0f8eb3f587f63ca1eaab5594da5b17"}, - {file = "numpy-2.1.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:1600068c262af1ca9580a527d43dc9d959b0b1d8e56f8a05d830eea39b7c8af6"}, - {file = "numpy-2.1.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a26ae94658d3ba3781d5e103ac07a876b3e9b29db53f68ed7df432fd033358a8"}, - {file = "numpy-2.1.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13311c2db4c5f7609b462bc0f43d3c465424d25c626d95040f073e30f7570e35"}, - {file = "numpy-2.1.2-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:2abbf905a0b568706391ec6fa15161fad0fb5d8b68d73c461b3c1bab6064dd62"}, - {file = "numpy-2.1.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ef444c57d664d35cac4e18c298c47d7b504c66b17c2ea91312e979fcfbdfb08a"}, - {file = "numpy-2.1.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:bdd407c40483463898b84490770199d5714dcc9dd9b792f6c6caccc523c00952"}, - {file = "numpy-2.1.2-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:da65fb46d4cbb75cb417cddf6ba5e7582eb7bb0b47db4b99c9fe5787ce5d91f5"}, - {file = "numpy-2.1.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1c193d0b0238638e6fc5f10f1b074a6993cb13b0b431f64079a509d63d3aa8b7"}, - {file = "numpy-2.1.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a7d80b2e904faa63068ead63107189164ca443b42dd1930299e0d1cb041cec2e"}, - {file = "numpy-2.1.2.tar.gz", hash = "sha256:13532a088217fa624c99b843eeb54640de23b3414b14aa66d023805eb731066c"}, + {file = "numpy-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c894b4305373b9c5576d7a12b473702afdf48ce5369c074ba304cc5ad8730dff"}, + {file = "numpy-2.1.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b47fbb433d3260adcd51eb54f92a2ffbc90a4595f8970ee00e064c644ac788f5"}, + {file = "numpy-2.1.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:825656d0743699c529c5943554d223c021ff0494ff1442152ce887ef4f7561a1"}, + {file = "numpy-2.1.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:6a4825252fcc430a182ac4dee5a505053d262c807f8a924603d411f6718b88fd"}, + {file = "numpy-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e711e02f49e176a01d0349d82cb5f05ba4db7d5e7e0defd026328e5cfb3226d3"}, + {file = "numpy-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78574ac2d1a4a02421f25da9559850d59457bac82f2b8d7a44fe83a64f770098"}, + {file = "numpy-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c7662f0e3673fe4e832fe07b65c50342ea27d989f92c80355658c7f888fcc83c"}, + {file = "numpy-2.1.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fa2d1337dc61c8dc417fbccf20f6d1e139896a30721b7f1e832b2bb6ef4eb6c4"}, + {file = "numpy-2.1.3-cp310-cp310-win32.whl", hash = "sha256:72dcc4a35a8515d83e76b58fdf8113a5c969ccd505c8a946759b24e3182d1f23"}, + {file = "numpy-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:ecc76a9ba2911d8d37ac01de72834d8849e55473457558e12995f4cd53e778e0"}, + {file = "numpy-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4d1167c53b93f1f5d8a139a742b3c6f4d429b54e74e6b57d0eff40045187b15d"}, + {file = "numpy-2.1.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c80e4a09b3d95b4e1cac08643f1152fa71a0a821a2d4277334c88d54b2219a41"}, + {file = "numpy-2.1.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:576a1c1d25e9e02ed7fa5477f30a127fe56debd53b8d2c89d5578f9857d03ca9"}, + {file = "numpy-2.1.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:973faafebaae4c0aaa1a1ca1ce02434554d67e628b8d805e61f874b84e136b09"}, + {file = "numpy-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:762479be47a4863e261a840e8e01608d124ee1361e48b96916f38b119cfda04a"}, + {file = "numpy-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc6f24b3d1ecc1eebfbf5d6051faa49af40b03be1aaa781ebdadcbc090b4539b"}, + {file = "numpy-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:17ee83a1f4fef3c94d16dc1802b998668b5419362c8a4f4e8a491de1b41cc3ee"}, + {file = "numpy-2.1.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15cb89f39fa6d0bdfb600ea24b250e5f1a3df23f901f51c8debaa6a5d122b2f0"}, + {file = "numpy-2.1.3-cp311-cp311-win32.whl", hash = "sha256:d9beb777a78c331580705326d2367488d5bc473b49a9bc3036c154832520aca9"}, + {file = "numpy-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:d89dd2b6da69c4fff5e39c28a382199ddedc3a5be5390115608345dec660b9e2"}, + {file = "numpy-2.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f55ba01150f52b1027829b50d70ef1dafd9821ea82905b63936668403c3b471e"}, + {file = "numpy-2.1.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13138eadd4f4da03074851a698ffa7e405f41a0845a6b1ad135b81596e4e9958"}, + {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a6b46587b14b888e95e4a24d7b13ae91fa22386c199ee7b418f449032b2fa3b8"}, + {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:0fa14563cc46422e99daef53d725d0c326e99e468a9320a240affffe87852564"}, + {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8637dcd2caa676e475503d1f8fdb327bc495554e10838019651b76d17b98e512"}, + {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2312b2aa89e1f43ecea6da6ea9a810d06aae08321609d8dc0d0eda6d946a541b"}, + {file = "numpy-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a38c19106902bb19351b83802531fea19dee18e5b37b36454f27f11ff956f7fc"}, + {file = "numpy-2.1.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02135ade8b8a84011cbb67dc44e07c58f28575cf9ecf8ab304e51c05528c19f0"}, + {file = "numpy-2.1.3-cp312-cp312-win32.whl", hash = "sha256:e6988e90fcf617da2b5c78902fe8e668361b43b4fe26dbf2d7b0f8034d4cafb9"}, + {file = "numpy-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:0d30c543f02e84e92c4b1f415b7c6b5326cbe45ee7882b6b77db7195fb971e3a"}, + {file = "numpy-2.1.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96fe52fcdb9345b7cd82ecd34547fca4321f7656d500eca497eb7ea5a926692f"}, + {file = "numpy-2.1.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f653490b33e9c3a4c1c01d41bc2aef08f9475af51146e4a7710c450cf9761598"}, + {file = "numpy-2.1.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:dc258a761a16daa791081d026f0ed4399b582712e6fc887a95af09df10c5ca57"}, + {file = "numpy-2.1.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:016d0f6f5e77b0f0d45d77387ffa4bb89816b57c835580c3ce8e099ef830befe"}, + {file = "numpy-2.1.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c181ba05ce8299c7aa3125c27b9c2167bca4a4445b7ce73d5febc411ca692e43"}, + {file = "numpy-2.1.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5641516794ca9e5f8a4d17bb45446998c6554704d888f86df9b200e66bdcce56"}, + {file = "numpy-2.1.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ea4dedd6e394a9c180b33c2c872b92f7ce0f8e7ad93e9585312b0c5a04777a4a"}, + {file = "numpy-2.1.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0df3635b9c8ef48bd3be5f862cf71b0a4716fa0e702155c45067c6b711ddcef"}, + {file = "numpy-2.1.3-cp313-cp313-win32.whl", hash = "sha256:50ca6aba6e163363f132b5c101ba078b8cbd3fa92c7865fd7d4d62d9779ac29f"}, + {file = "numpy-2.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:747641635d3d44bcb380d950679462fae44f54b131be347d5ec2bce47d3df9ed"}, + {file = "numpy-2.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:996bb9399059c5b82f76b53ff8bb686069c05acc94656bb259b1d63d04a9506f"}, + {file = "numpy-2.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:45966d859916ad02b779706bb43b954281db43e185015df6eb3323120188f9e4"}, + {file = "numpy-2.1.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:baed7e8d7481bfe0874b566850cb0b85243e982388b7b23348c6db2ee2b2ae8e"}, + {file = "numpy-2.1.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a9f7f672a3388133335589cfca93ed468509cb7b93ba3105fce780d04a6576a0"}, + {file = "numpy-2.1.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7aac50327da5d208db2eec22eb11e491e3fe13d22653dce51b0f4109101b408"}, + {file = "numpy-2.1.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4394bc0dbd074b7f9b52024832d16e019decebf86caf909d94f6b3f77a8ee3b6"}, + {file = "numpy-2.1.3-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:50d18c4358a0a8a53f12a8ba9d772ab2d460321e6a93d6064fc22443d189853f"}, + {file = "numpy-2.1.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:14e253bd43fc6b37af4921b10f6add6925878a42a0c5fe83daee390bca80bc17"}, + {file = "numpy-2.1.3-cp313-cp313t-win32.whl", hash = "sha256:08788d27a5fd867a663f6fc753fd7c3ad7e92747efc73c53bca2f19f8bc06f48"}, + {file = "numpy-2.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2564fbdf2b99b3f815f2107c1bbc93e2de8ee655a69c261363a1172a79a257d4"}, + {file = "numpy-2.1.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4f2015dfe437dfebbfce7c85c7b53d81ba49e71ba7eadbf1df40c915af75979f"}, + {file = "numpy-2.1.3-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3522b0dfe983a575e6a9ab3a4a4dfe156c3e428468ff08ce582b9bb6bd1d71d4"}, + {file = "numpy-2.1.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c006b607a865b07cd981ccb218a04fc86b600411d83d6fc261357f1c0966755d"}, + {file = "numpy-2.1.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e14e26956e6f1696070788252dcdff11b4aca4c3e8bd166e0df1bb8f315a67cb"}, + {file = "numpy-2.1.3.tar.gz", hash = "sha256:aa08e04e08aaf974d4458def539dece0d28146d866a39da5639596f4921fd761"}, ] [[package]] @@ -1934,13 +2014,13 @@ files = [ [[package]] name = "packaging" -version = "24.1" +version = "24.2" description = "Core utilities for Python packages" optional = false python-versions = ">=3.8" files = [ - {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, - {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, ] [[package]] @@ -2619,114 +2699,101 @@ files = [ [[package]] name = "rpds-py" -version = "0.20.0" +version = "0.21.0" description = "Python bindings to Rust's persistent data structures (rpds)" optional = false -python-versions = ">=3.8" +python-versions = ">=3.9" files = [ - {file = "rpds_py-0.20.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3ad0fda1635f8439cde85c700f964b23ed5fc2d28016b32b9ee5fe30da5c84e2"}, - {file = "rpds_py-0.20.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9bb4a0d90fdb03437c109a17eade42dfbf6190408f29b2744114d11586611d6f"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6377e647bbfd0a0b159fe557f2c6c602c159fc752fa316572f012fc0bf67150"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb851b7df9dda52dc1415ebee12362047ce771fc36914586b2e9fcbd7d293b3e"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e0f80b739e5a8f54837be5d5c924483996b603d5502bfff79bf33da06164ee2"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a8c94dad2e45324fc74dce25e1645d4d14df9a4e54a30fa0ae8bad9a63928e3"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8e604fe73ba048c06085beaf51147eaec7df856824bfe7b98657cf436623daf"}, - {file = "rpds_py-0.20.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:df3de6b7726b52966edf29663e57306b23ef775faf0ac01a3e9f4012a24a4140"}, - {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf258ede5bc22a45c8e726b29835b9303c285ab46fc7c3a4cc770736b5304c9f"}, - {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:55fea87029cded5df854ca7e192ec7bdb7ecd1d9a3f63d5c4eb09148acf4a7ce"}, - {file = "rpds_py-0.20.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ae94bd0b2f02c28e199e9bc51485d0c5601f58780636185660f86bf80c89af94"}, - {file = "rpds_py-0.20.0-cp310-none-win32.whl", hash = "sha256:28527c685f237c05445efec62426d285e47a58fb05ba0090a4340b73ecda6dee"}, - {file = "rpds_py-0.20.0-cp310-none-win_amd64.whl", hash = "sha256:238a2d5b1cad28cdc6ed15faf93a998336eb041c4e440dd7f902528b8891b399"}, - {file = "rpds_py-0.20.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:ac2f4f7a98934c2ed6505aead07b979e6f999389f16b714448fb39bbaa86a489"}, - {file = "rpds_py-0.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:220002c1b846db9afd83371d08d239fdc865e8f8c5795bbaec20916a76db3318"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8d7919548df3f25374a1f5d01fbcd38dacab338ef5f33e044744b5c36729c8db"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:758406267907b3781beee0f0edfe4a179fbd97c0be2e9b1154d7f0a1279cf8e5"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3d61339e9f84a3f0767b1995adfb171a0d00a1185192718a17af6e124728e0f5"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1259c7b3705ac0a0bd38197565a5d603218591d3f6cee6e614e380b6ba61c6f6"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c1dc0f53856b9cc9a0ccca0a7cc61d3d20a7088201c0937f3f4048c1718a209"}, - {file = "rpds_py-0.20.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7e60cb630f674a31f0368ed32b2a6b4331b8350d67de53c0359992444b116dd3"}, - {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dbe982f38565bb50cb7fb061ebf762c2f254ca3d8c20d4006878766e84266272"}, - {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:514b3293b64187172bc77c8fb0cdae26981618021053b30d8371c3a902d4d5ad"}, - {file = "rpds_py-0.20.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d0a26ffe9d4dd35e4dfdd1e71f46401cff0181c75ac174711ccff0459135fa58"}, - {file = "rpds_py-0.20.0-cp311-none-win32.whl", hash = "sha256:89c19a494bf3ad08c1da49445cc5d13d8fefc265f48ee7e7556839acdacf69d0"}, - {file = "rpds_py-0.20.0-cp311-none-win_amd64.whl", hash = "sha256:c638144ce971df84650d3ed0096e2ae7af8e62ecbbb7b201c8935c370df00a2c"}, - {file = "rpds_py-0.20.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a84ab91cbe7aab97f7446652d0ed37d35b68a465aeef8fc41932a9d7eee2c1a6"}, - {file = "rpds_py-0.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:56e27147a5a4c2c21633ff8475d185734c0e4befd1c989b5b95a5d0db699b21b"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2580b0c34583b85efec8c5c5ec9edf2dfe817330cc882ee972ae650e7b5ef739"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b80d4a7900cf6b66bb9cee5c352b2d708e29e5a37fe9bf784fa97fc11504bf6c"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50eccbf054e62a7b2209b28dc7a22d6254860209d6753e6b78cfaeb0075d7bee"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49a8063ea4296b3a7e81a5dfb8f7b2d73f0b1c20c2af401fb0cdf22e14711a96"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea438162a9fcbee3ecf36c23e6c68237479f89f962f82dae83dc15feeceb37e4"}, - {file = "rpds_py-0.20.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:18d7585c463087bddcfa74c2ba267339f14f2515158ac4db30b1f9cbdb62c8ef"}, - {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d4c7d1a051eeb39f5c9547e82ea27cbcc28338482242e3e0b7768033cb083821"}, - {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4df1e3b3bec320790f699890d41c59d250f6beda159ea3c44c3f5bac1976940"}, - {file = "rpds_py-0.20.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2cf126d33a91ee6eedc7f3197b53e87a2acdac63602c0f03a02dd69e4b138174"}, - {file = "rpds_py-0.20.0-cp312-none-win32.whl", hash = "sha256:8bc7690f7caee50b04a79bf017a8d020c1f48c2a1077ffe172abec59870f1139"}, - {file = "rpds_py-0.20.0-cp312-none-win_amd64.whl", hash = "sha256:0e13e6952ef264c40587d510ad676a988df19adea20444c2b295e536457bc585"}, - {file = "rpds_py-0.20.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:aa9a0521aeca7d4941499a73ad7d4f8ffa3d1affc50b9ea11d992cd7eff18a29"}, - {file = "rpds_py-0.20.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a1f1d51eccb7e6c32ae89243cb352389228ea62f89cd80823ea7dd1b98e0b91"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a86a9b96070674fc88b6f9f71a97d2c1d3e5165574615d1f9168ecba4cecb24"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c8ef2ebf76df43f5750b46851ed1cdf8f109d7787ca40035fe19fbdc1acc5a7"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b74b25f024b421d5859d156750ea9a65651793d51b76a2e9238c05c9d5f203a9"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57eb94a8c16ab08fef6404301c38318e2c5a32216bf5de453e2714c964c125c8"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1940dae14e715e2e02dfd5b0f64a52e8374a517a1e531ad9412319dc3ac7879"}, - {file = "rpds_py-0.20.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d20277fd62e1b992a50c43f13fbe13277a31f8c9f70d59759c88f644d66c619f"}, - {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:06db23d43f26478303e954c34c75182356ca9aa7797d22c5345b16871ab9c45c"}, - {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b2a5db5397d82fa847e4c624b0c98fe59d2d9b7cf0ce6de09e4d2e80f8f5b3f2"}, - {file = "rpds_py-0.20.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a35df9f5548fd79cb2f52d27182108c3e6641a4feb0f39067911bf2adaa3e57"}, - {file = "rpds_py-0.20.0-cp313-none-win32.whl", hash = "sha256:fd2d84f40633bc475ef2d5490b9c19543fbf18596dcb1b291e3a12ea5d722f7a"}, - {file = "rpds_py-0.20.0-cp313-none-win_amd64.whl", hash = "sha256:9bc2d153989e3216b0559251b0c260cfd168ec78b1fac33dd485750a228db5a2"}, - {file = "rpds_py-0.20.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:f2fbf7db2012d4876fb0d66b5b9ba6591197b0f165db8d99371d976546472a24"}, - {file = "rpds_py-0.20.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1e5f3cd7397c8f86c8cc72d5a791071431c108edd79872cdd96e00abd8497d29"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce9845054c13696f7af7f2b353e6b4f676dab1b4b215d7fe5e05c6f8bb06f965"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c3e130fd0ec56cb76eb49ef52faead8ff09d13f4527e9b0c400307ff72b408e1"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4b16aa0107ecb512b568244ef461f27697164d9a68d8b35090e9b0c1c8b27752"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aa7f429242aae2947246587d2964fad750b79e8c233a2367f71b554e9447949c"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af0fc424a5842a11e28956e69395fbbeab2c97c42253169d87e90aac2886d751"}, - {file = "rpds_py-0.20.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b8c00a3b1e70c1d3891f0db1b05292747f0dbcfb49c43f9244d04c70fbc40eb8"}, - {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:40ce74fc86ee4645d0a225498d091d8bc61f39b709ebef8204cb8b5a464d3c0e"}, - {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4fe84294c7019456e56d93e8ababdad5a329cd25975be749c3f5f558abb48253"}, - {file = "rpds_py-0.20.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:338ca4539aad4ce70a656e5187a3a31c5204f261aef9f6ab50e50bcdffaf050a"}, - {file = "rpds_py-0.20.0-cp38-none-win32.whl", hash = "sha256:54b43a2b07db18314669092bb2de584524d1ef414588780261e31e85846c26a5"}, - {file = "rpds_py-0.20.0-cp38-none-win_amd64.whl", hash = "sha256:a1862d2d7ce1674cffa6d186d53ca95c6e17ed2b06b3f4c476173565c862d232"}, - {file = "rpds_py-0.20.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3fde368e9140312b6e8b6c09fb9f8c8c2f00999d1823403ae90cc00480221b22"}, - {file = "rpds_py-0.20.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9824fb430c9cf9af743cf7aaf6707bf14323fb51ee74425c380f4c846ea70789"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:11ef6ce74616342888b69878d45e9f779b95d4bd48b382a229fe624a409b72c5"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c52d3f2f82b763a24ef52f5d24358553e8403ce05f893b5347098014f2d9eff2"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d35cef91e59ebbeaa45214861874bc6f19eb35de96db73e467a8358d701a96c"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d72278a30111e5b5525c1dd96120d9e958464316f55adb030433ea905866f4de"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4c29cbbba378759ac5786730d1c3cb4ec6f8ababf5c42a9ce303dc4b3d08cda"}, - {file = "rpds_py-0.20.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6632f2d04f15d1bd6fe0eedd3b86d9061b836ddca4c03d5cf5c7e9e6b7c14580"}, - {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d0b67d87bb45ed1cd020e8fbf2307d449b68abc45402fe1a4ac9e46c3c8b192b"}, - {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ec31a99ca63bf3cd7f1a5ac9fe95c5e2d060d3c768a09bc1d16e235840861420"}, - {file = "rpds_py-0.20.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:22e6c9976e38f4d8c4a63bd8a8edac5307dffd3ee7e6026d97f3cc3a2dc02a0b"}, - {file = "rpds_py-0.20.0-cp39-none-win32.whl", hash = "sha256:569b3ea770c2717b730b61998b6c54996adee3cef69fc28d444f3e7920313cf7"}, - {file = "rpds_py-0.20.0-cp39-none-win_amd64.whl", hash = "sha256:e6900ecdd50ce0facf703f7a00df12374b74bbc8ad9fe0f6559947fb20f82364"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:617c7357272c67696fd052811e352ac54ed1d9b49ab370261a80d3b6ce385045"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9426133526f69fcaba6e42146b4e12d6bc6c839b8b555097020e2b78ce908dcc"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:deb62214c42a261cb3eb04d474f7155279c1a8a8c30ac89b7dcb1721d92c3c02"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fcaeb7b57f1a1e071ebd748984359fef83ecb026325b9d4ca847c95bc7311c92"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d454b8749b4bd70dd0a79f428731ee263fa6995f83ccb8bada706e8d1d3ff89d"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d807dc2051abe041b6649681dce568f8e10668e3c1c6543ebae58f2d7e617855"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3c20f0ddeb6e29126d45f89206b8291352b8c5b44384e78a6499d68b52ae511"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b7f19250ceef892adf27f0399b9e5afad019288e9be756d6919cb58892129f51"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4f1ed4749a08379555cebf4650453f14452eaa9c43d0a95c49db50c18b7da075"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:dcedf0b42bcb4cfff4101d7771a10532415a6106062f005ab97d1d0ab5681c60"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:39ed0d010457a78f54090fafb5d108501b5aa5604cc22408fc1c0c77eac14344"}, - {file = "rpds_py-0.20.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:bb273176be34a746bdac0b0d7e4e2c467323d13640b736c4c477881a3220a989"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f918a1a130a6dfe1d7fe0f105064141342e7dd1611f2e6a21cd2f5c8cb1cfb3e"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:f60012a73aa396be721558caa3a6fd49b3dd0033d1675c6d59c4502e870fcf0c"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d2b1ad682a3dfda2a4e8ad8572f3100f95fad98cb99faf37ff0ddfe9cbf9d03"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:614fdafe9f5f19c63ea02817fa4861c606a59a604a77c8cdef5aa01d28b97921"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fa518bcd7600c584bf42e6617ee8132869e877db2f76bcdc281ec6a4113a53ab"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0475242f447cc6cb8a9dd486d68b2ef7fbee84427124c232bff5f63b1fe11e5"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f90a4cd061914a60bd51c68bcb4357086991bd0bb93d8aa66a6da7701370708f"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:def7400461c3a3f26e49078302e1c1b38f6752342c77e3cf72ce91ca69fb1bc1"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:65794e4048ee837494aea3c21a28ad5fc080994dfba5b036cf84de37f7ad5074"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:faefcc78f53a88f3076b7f8be0a8f8d35133a3ecf7f3770895c25f8813460f08"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:5b4f105deeffa28bbcdff6c49b34e74903139afa690e35d2d9e3c2c2fba18cec"}, - {file = "rpds_py-0.20.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fdfc3a892927458d98f3d55428ae46b921d1f7543b89382fdb483f5640daaec8"}, - {file = "rpds_py-0.20.0.tar.gz", hash = "sha256:d72a210824facfdaf8768cf2d7ca25a042c30320b3020de2fa04640920d4e121"}, + {file = "rpds_py-0.21.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a017f813f24b9df929674d0332a374d40d7f0162b326562daae8066b502d0590"}, + {file = "rpds_py-0.21.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:20cc1ed0bcc86d8e1a7e968cce15be45178fd16e2ff656a243145e0b439bd250"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad116dda078d0bc4886cb7840e19811562acdc7a8e296ea6ec37e70326c1b41c"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:808f1ac7cf3b44f81c9475475ceb221f982ef548e44e024ad5f9e7060649540e"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de552f4a1916e520f2703ec474d2b4d3f86d41f353e7680b597512ffe7eac5d0"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:efec946f331349dfc4ae9d0e034c263ddde19414fe5128580f512619abed05f1"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b80b4690bbff51a034bfde9c9f6bf9357f0a8c61f548942b80f7b66356508bf5"}, + {file = "rpds_py-0.21.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:085ed25baac88953d4283e5b5bd094b155075bb40d07c29c4f073e10623f9f2e"}, + {file = "rpds_py-0.21.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:daa8efac2a1273eed2354397a51216ae1e198ecbce9036fba4e7610b308b6153"}, + {file = "rpds_py-0.21.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:95a5bad1ac8a5c77b4e658671642e4af3707f095d2b78a1fdd08af0dfb647624"}, + {file = "rpds_py-0.21.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3e53861b29a13d5b70116ea4230b5f0f3547b2c222c5daa090eb7c9c82d7f664"}, + {file = "rpds_py-0.21.0-cp310-none-win32.whl", hash = "sha256:ea3a6ac4d74820c98fcc9da4a57847ad2cc36475a8bd9683f32ab6d47a2bd682"}, + {file = "rpds_py-0.21.0-cp310-none-win_amd64.whl", hash = "sha256:b8f107395f2f1d151181880b69a2869c69e87ec079c49c0016ab96860b6acbe5"}, + {file = "rpds_py-0.21.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:5555db3e618a77034954b9dc547eae94166391a98eb867905ec8fcbce1308d95"}, + {file = "rpds_py-0.21.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:97ef67d9bbc3e15584c2f3c74bcf064af36336c10d2e21a2131e123ce0f924c9"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ab2c2a26d2f69cdf833174f4d9d86118edc781ad9a8fa13970b527bf8236027"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4e8921a259f54bfbc755c5bbd60c82bb2339ae0324163f32868f63f0ebb873d9"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a7ff941004d74d55a47f916afc38494bd1cfd4b53c482b77c03147c91ac0ac3"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5145282a7cd2ac16ea0dc46b82167754d5e103a05614b724457cffe614f25bd8"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de609a6f1b682f70bb7163da745ee815d8f230d97276db049ab447767466a09d"}, + {file = "rpds_py-0.21.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:40c91c6e34cf016fa8e6b59d75e3dbe354830777fcfd74c58b279dceb7975b75"}, + {file = "rpds_py-0.21.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d2132377f9deef0c4db89e65e8bb28644ff75a18df5293e132a8d67748397b9f"}, + {file = "rpds_py-0.21.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0a9e0759e7be10109645a9fddaaad0619d58c9bf30a3f248a2ea57a7c417173a"}, + {file = "rpds_py-0.21.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9e20da3957bdf7824afdd4b6eeb29510e83e026473e04952dca565170cd1ecc8"}, + {file = "rpds_py-0.21.0-cp311-none-win32.whl", hash = "sha256:f71009b0d5e94c0e86533c0b27ed7cacc1239cb51c178fd239c3cfefefb0400a"}, + {file = "rpds_py-0.21.0-cp311-none-win_amd64.whl", hash = "sha256:e168afe6bf6ab7ab46c8c375606298784ecbe3ba31c0980b7dcbb9631dcba97e"}, + {file = "rpds_py-0.21.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:30b912c965b2aa76ba5168fd610087bad7fcde47f0a8367ee8f1876086ee6d1d"}, + {file = "rpds_py-0.21.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ca9989d5d9b1b300bc18e1801c67b9f6d2c66b8fd9621b36072ed1df2c977f72"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f54e7106f0001244a5f4cf810ba8d3f9c542e2730821b16e969d6887b664266"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fed5dfefdf384d6fe975cc026886aece4f292feaf69d0eeb716cfd3c5a4dd8be"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:590ef88db231c9c1eece44dcfefd7515d8bf0d986d64d0caf06a81998a9e8cab"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f983e4c2f603c95dde63df633eec42955508eefd8d0f0e6d236d31a044c882d7"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b229ce052ddf1a01c67d68166c19cb004fb3612424921b81c46e7ea7ccf7c3bf"}, + {file = "rpds_py-0.21.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ebf64e281a06c904a7636781d2e973d1f0926a5b8b480ac658dc0f556e7779f4"}, + {file = "rpds_py-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:998a8080c4495e4f72132f3d66ff91f5997d799e86cec6ee05342f8f3cda7dca"}, + {file = "rpds_py-0.21.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:98486337f7b4f3c324ab402e83453e25bb844f44418c066623db88e4c56b7c7b"}, + {file = "rpds_py-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a78d8b634c9df7f8d175451cfeac3810a702ccb85f98ec95797fa98b942cea11"}, + {file = "rpds_py-0.21.0-cp312-none-win32.whl", hash = "sha256:a58ce66847711c4aa2ecfcfaff04cb0327f907fead8945ffc47d9407f41ff952"}, + {file = "rpds_py-0.21.0-cp312-none-win_amd64.whl", hash = "sha256:e860f065cc4ea6f256d6f411aba4b1251255366e48e972f8a347cf88077b24fd"}, + {file = "rpds_py-0.21.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:ee4eafd77cc98d355a0d02f263efc0d3ae3ce4a7c24740010a8b4012bbb24937"}, + {file = "rpds_py-0.21.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:688c93b77e468d72579351a84b95f976bd7b3e84aa6686be6497045ba84be560"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c38dbf31c57032667dd5a2f0568ccde66e868e8f78d5a0d27dcc56d70f3fcd3b"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2d6129137f43f7fa02d41542ffff4871d4aefa724a5fe38e2c31a4e0fd343fb0"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:520ed8b99b0bf86a176271f6fe23024323862ac674b1ce5b02a72bfeff3fff44"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aaeb25ccfb9b9014a10eaf70904ebf3f79faaa8e60e99e19eef9f478651b9b74"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af04ac89c738e0f0f1b913918024c3eab6e3ace989518ea838807177d38a2e94"}, + {file = "rpds_py-0.21.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b9b76e2afd585803c53c5b29e992ecd183f68285b62fe2668383a18e74abe7a3"}, + {file = "rpds_py-0.21.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5afb5efde74c54724e1a01118c6e5c15e54e642c42a1ba588ab1f03544ac8c7a"}, + {file = "rpds_py-0.21.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:52c041802a6efa625ea18027a0723676a778869481d16803481ef6cc02ea8cb3"}, + {file = "rpds_py-0.21.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee1e4fc267b437bb89990b2f2abf6c25765b89b72dd4a11e21934df449e0c976"}, + {file = "rpds_py-0.21.0-cp313-none-win32.whl", hash = "sha256:0c025820b78817db6a76413fff6866790786c38f95ea3f3d3c93dbb73b632202"}, + {file = "rpds_py-0.21.0-cp313-none-win_amd64.whl", hash = "sha256:320c808df533695326610a1b6a0a6e98f033e49de55d7dc36a13c8a30cfa756e"}, + {file = "rpds_py-0.21.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:2c51d99c30091f72a3c5d126fad26236c3f75716b8b5e5cf8effb18889ced928"}, + {file = "rpds_py-0.21.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cbd7504a10b0955ea287114f003b7ad62330c9e65ba012c6223dba646f6ffd05"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6dcc4949be728ede49e6244eabd04064336012b37f5c2200e8ec8eb2988b209c"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f414da5c51bf350e4b7960644617c130140423882305f7574b6cf65a3081cecb"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9afe42102b40007f588666bc7de82451e10c6788f6f70984629db193849dced1"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b929c2bb6e29ab31f12a1117c39f7e6d6450419ab7464a4ea9b0b417174f044"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8404b3717da03cbf773a1d275d01fec84ea007754ed380f63dfc24fb76ce4592"}, + {file = "rpds_py-0.21.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e12bb09678f38b7597b8346983d2323a6482dcd59e423d9448108c1be37cac9d"}, + {file = "rpds_py-0.21.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:58a0e345be4b18e6b8501d3b0aa540dad90caeed814c515e5206bb2ec26736fd"}, + {file = "rpds_py-0.21.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:c3761f62fcfccf0864cc4665b6e7c3f0c626f0380b41b8bd1ce322103fa3ef87"}, + {file = "rpds_py-0.21.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c2b2f71c6ad6c2e4fc9ed9401080badd1469fa9889657ec3abea42a3d6b2e1ed"}, + {file = "rpds_py-0.21.0-cp39-none-win32.whl", hash = "sha256:b21747f79f360e790525e6f6438c7569ddbfb1b3197b9e65043f25c3c9b489d8"}, + {file = "rpds_py-0.21.0-cp39-none-win_amd64.whl", hash = "sha256:0626238a43152918f9e72ede9a3b6ccc9e299adc8ade0d67c5e142d564c9a83d"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6b4ef7725386dc0762857097f6b7266a6cdd62bfd209664da6712cb26acef035"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:6bc0e697d4d79ab1aacbf20ee5f0df80359ecf55db33ff41481cf3e24f206919"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da52d62a96e61c1c444f3998c434e8b263c384f6d68aca8274d2e08d1906325c"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:98e4fe5db40db87ce1c65031463a760ec7906ab230ad2249b4572c2fc3ef1f9f"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30bdc973f10d28e0337f71d202ff29345320f8bc49a31c90e6c257e1ccef4333"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:faa5e8496c530f9c71f2b4e1c49758b06e5f4055e17144906245c99fa6d45356"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:32eb88c30b6a4f0605508023b7141d043a79b14acb3b969aa0b4f99b25bc7d4a"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a89a8ce9e4e75aeb7fa5d8ad0f3fecdee813802592f4f46a15754dcb2fd6b061"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:241e6c125568493f553c3d0fdbb38c74babf54b45cef86439d4cd97ff8feb34d"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:3b766a9f57663396e4f34f5140b3595b233a7b146e94777b97a8413a1da1be18"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:af4a644bf890f56e41e74be7d34e9511e4954894d544ec6b8efe1e21a1a8da6c"}, + {file = "rpds_py-0.21.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3e30a69a706e8ea20444b98a49f386c17b26f860aa9245329bab0851ed100677"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:031819f906bb146561af051c7cef4ba2003d28cff07efacef59da973ff7969ba"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b876f2bc27ab5954e2fd88890c071bd0ed18b9c50f6ec3de3c50a5ece612f7a6"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc5695c321e518d9f03b7ea6abb5ea3af4567766f9852ad1560f501b17588c7b"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4de1da871b5c0fd5537b26a6fc6814c3cc05cabe0c941db6e9044ffbb12f04a"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:878f6fea96621fda5303a2867887686d7a198d9e0f8a40be100a63f5d60c88c9"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8eeec67590e94189f434c6d11c426892e396ae59e4801d17a93ac96b8c02a6c"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ff2eba7f6c0cb523d7e9cff0903f2fe1feff8f0b2ceb6bd71c0e20a4dcee271"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a429b99337062877d7875e4ff1a51fe788424d522bd64a8c0a20ef3021fdb6ed"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:d167e4dbbdac48bd58893c7e446684ad5d425b407f9336e04ab52e8b9194e2ed"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:4eb2de8a147ffe0626bfdc275fc6563aa7bf4b6db59cf0d44f0ccd6ca625a24e"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:e78868e98f34f34a88e23ee9ccaeeec460e4eaf6db16d51d7a9b883e5e785a5e"}, + {file = "rpds_py-0.21.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:4991ca61656e3160cdaca4851151fd3f4a92e9eba5c7a530ab030d6aee96ec89"}, + {file = "rpds_py-0.21.0.tar.gz", hash = "sha256:ed6378c9d66d0de903763e7706383d60c33829581f0adff47b6535f1802fa6db"}, ] [[package]] @@ -2868,23 +2935,23 @@ win32 = ["pywin32"] [[package]] name = "setuptools" -version = "75.2.0" +version = "75.3.0" description = "Easily download, build, install, upgrade, and uninstall Python packages" optional = false python-versions = ">=3.8" files = [ - {file = "setuptools-75.2.0-py3-none-any.whl", hash = "sha256:a7fcb66f68b4d9e8e66b42f9876150a3371558f98fa32222ffaa5bced76406f8"}, - {file = "setuptools-75.2.0.tar.gz", hash = "sha256:753bb6ebf1f465a1912e19ed1d41f403a79173a9acf66a42e7e6aec45c3c16ec"}, + {file = "setuptools-75.3.0-py3-none-any.whl", hash = "sha256:f2504966861356aa38616760c0f66568e535562374995367b4e69c7143cf6bcd"}, + {file = "setuptools-75.3.0.tar.gz", hash = "sha256:fba5dd4d766e97be1b1681d98712680ae8f2f26d7881245f2ce9e40714f1a686"}, ] [package.extras] check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)", "ruff (>=0.5.2)"] -core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=2.6.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] +core = ["importlib-metadata (>=6)", "importlib-resources (>=5.10.2)", "jaraco.collections", "jaraco.functools", "jaraco.text (>=3.7)", "more-itertools", "more-itertools (>=8.8)", "packaging", "packaging (>=24)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1)", "wheel (>=0.43.0)"] cover = ["pytest-cov"] doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] enabler = ["pytest-enabler (>=2.2)"] -test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] -type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.11.*)", "pytest-mypy"] +test = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "ini2toml[lite] (>=0.14)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "jaraco.test (>=5.5)", "packaging (>=23.2)", "pip (>=19.1)", "pyproject-hooks (!=1.1)", "pytest (>=6,!=8.1.*)", "pytest-home (>=0.5)", "pytest-perf", "pytest-subprocess", "pytest-timeout", "pytest-xdist (>=3)", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel (>=0.44.0)"] +type = ["importlib-metadata (>=7.0.2)", "jaraco.develop (>=7.21)", "mypy (==1.12.*)", "pytest-mypy"] [[package]] name = "six" @@ -3008,6 +3075,27 @@ files = [ {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"}, ] +[[package]] +name = "tqdm" +version = "4.67.0" +description = "Fast, Extensible Progress Meter" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tqdm-4.67.0-py3-none-any.whl", hash = "sha256:0cd8af9d56911acab92182e88d763100d4788bdf421d251616040cc4d44863be"}, + {file = "tqdm-4.67.0.tar.gz", hash = "sha256:fe5a6f95e6fe0b9755e9469b77b9c3cf850048224ecaa8293d7d2d31f97d869a"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[package.extras] +dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"] +discord = ["requests"] +notebook = ["ipywidgets (>=6)"] +slack = ["slack-sdk"] +telegram = ["requests"] + [[package]] name = "traitlets" version = "5.14.3" @@ -3152,13 +3240,13 @@ test = ["websockets"] [[package]] name = "werkzeug" -version = "3.0.5" +version = "3.1.3" description = "The comprehensive WSGI web application library." optional = false -python-versions = ">=3.8" +python-versions = ">=3.9" files = [ - {file = "werkzeug-3.0.5-py3-none-any.whl", hash = "sha256:6e589e0b303561b8b1a61d363ee05b1d7de6ca12f27a3a25269ae6ee93e363fd"}, - {file = "werkzeug-3.0.5.tar.gz", hash = "sha256:033bc3783777078517f32ae3ba9e86e9bc38bdbf139b1a5a3af9679a64ed1293"}, + {file = "werkzeug-3.1.3-py3-none-any.whl", hash = "sha256:54b78bf3716d19a65be4fceccc0d1d7b89e608834989dfae50ea87564639213e"}, + {file = "werkzeug-3.1.3.tar.gz", hash = "sha256:60723ce945c19328679790e3282cc758aa4a6040e4bb330f53d30fa546d44746"}, ] [package.dependencies] @@ -3178,7 +3266,33 @@ files = [ {file = "widgetsnbextension-4.0.13.tar.gz", hash = "sha256:ffcb67bc9febd10234a362795f643927f4e0c05d9342c727b65d2384f8feacb6"}, ] +[[package]] +name = "woodwork" +version = "0.31.0" +description = "a data typing library for machine learning" +optional = false +python-versions = "<4,>=3.9" +files = [ + {file = "woodwork-0.31.0-py3-none-any.whl", hash = "sha256:5cb3370553b5f466f8c8599b1bf559584dc0b798cc1f2da26bbd7029d256c6f9"}, + {file = "woodwork-0.31.0.tar.gz", hash = "sha256:6ef82af1d5b6525b02efe6417c574c810cfdcc606cb266bd0d7fb17a1d066b67"}, +] + +[package.dependencies] +importlib-resources = ">=5.10.0" +numpy = ">=1.25.0" +pandas = ">=2.0.0" +python-dateutil = ">=2.8.2" +scikit-learn = ">=1.1.0" +scipy = ">=1.10.0" + +[package.extras] +complete = ["woodwork[updater]"] +dev = ["click (>=8.1.7)", "pre-commit (>=2.20.0)", "ruff (>=0.1.6)", "woodwork[docs,test]"] +docs = ["Sphinx (==5.1.1)", "ipython (==8.4.0)", "jupyter (==1.0.0)", "myst-parser (==0.18.0)", "nbconvert (==6.5.0)", "nbsphinx (==0.8.9)", "pyarrow (>=14.0.1)", "pydata-sphinx-theme (==0.9.0)", "sphinx-copybutton (==0.5.0)", "sphinx-inline-tabs (==2022.1.2b11)"] +test = ["boto3 (>=1.34.32)", "moto[all] (>=5.0.0)", "pyarrow (>=14.0.1)", "pytest (>=7.0.1)", "pytest-cov (>=2.10.1)", "pytest-xdist (>=2.1.0)", "smart-open (>=5.0.0)"] +updater = ["alteryx-open-src-update-checker (>=3.1.0)"] + [metadata] lock-version = "2.0" python-versions = "^3.12" -content-hash = "8f6f51a2fb7bb7aace7499e9b968bf191e5756a935a92dec2319fed34e82d7aa" +content-hash = "556410853ef9373c37e89e83904ed4a45f8d9cd01980211241a736f9697b291b" diff --git a/pyproject.toml b/pyproject.toml index b265ba9..f497d3d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,6 +18,7 @@ flask-cors = "^5.0.0" ipykernel = "^6.29.5" imbalanced-learn = "^0.12.4" seaborn = "^0.13.2" +featuretools = "^1.31.0" [tool.poetry.group.dev.dependencies]